cacheplane · blove · May 13, 2026 · May 13, 2026
diff --git a/cowork/README.md b/cowork/README.md
@@ -0,0 +1,68 @@
+# Cacheplane GTM — Cowork skill
+
+A single Claude Cowork skill that operates Cacheplane's GTM motion: weekly PostHog snapshots, lead triage, workstream scaffolding, and "where are we?" status questions.
+
+The skill is **project-local**. It isn't published to a marketplace. Install steps are manual and one-time per machine.
+
+## What's in this directory
+
+```
+cowork/
+├── README.md           # This file.
+└── gtm/
+    └── SKILL.md        # The single Cowork skill. Edit here; install copies/symlinks elsewhere.
+```
+
+## Install (one-time per machine)
+
+The skill ships as `cowork/gtm/SKILL.md`. To make it loadable by Cowork / Claude Code on your machine, register it as a user-level skill:
+
+```bash
+mkdir -p ~/.claude/skills/gtm
+cp cowork/gtm/SKILL.md ~/.claude/skills/gtm/SKILL.md
+```
+
+Or symlink it so edits in this repo flow through immediately:
+
+```bash
+mkdir -p ~/.claude/skills/gtm
+ln -sf "$(pwd)/cowork/gtm/SKILL.md" ~/.claude/skills/gtm/SKILL.md
+```
+
+Verify: open a Claude Code session in this repo and type `/gtm`. The skill should load and announce its responsibilities.
+
+## Invoke
+
+- `/gtm` — drops into the GTM operator. Examples of what to ask:
+  - *"Run the weekly snapshot procedure."*
+  - *"Triage these inbound leads against the qualified-lead definition."*
+  - *"Scaffold a new workstream spec for `posthog-experiments`."*
+  - *"Where are we on comparison pages?"*
+
+## Schedule (optional, one-time per machine)
+
+Cowork has no in-repo scheduling primitive. To run the weekly snapshot automatically every Monday at 9am, create a routine once per machine:
+
+```bash
+/schedule create weekly-snapshot 'every Monday 9am' /gtm "run the weekly snapshot procedure"
+```
+
+The routine itself lives at the user/runtime layer; it is not committed to the repo. The instruction to create it lives here.
+
+## Update
+
+Edit `cowork/gtm/SKILL.md` in this repo. If you symlinked, the change is live immediately. If you copied, re-run the `cp` command after committing.
+
+## Why one skill, not a plugin
+
+- **One file to grok** — anyone reading the repo can see what GTM operations look like.
+- **No plugin packaging ceremony** until the motion proves out and we want to ship it as `@ngaf/gtm-plugin` for other Angular agent startups to adopt.
+- **No per-workstream subagents** until context bleed proves to be a problem. Splitting later is a one-day refactor.
+
+## See also
+
+- [gtm.md](../gtm.md) — durable strategy
+- [docs/gtm/](../docs/gtm/) — operational docs (ICP, messaging, taxonomy)
+- [docs/superpowers/specs/gtm/](../docs/superpowers/specs/gtm/) — per-workstream design specs
+- [tools/posthog/README.md](../tools/posthog/README.md) — dashboards-as-code conventions
+- [libs/telemetry/README.md](../libs/telemetry/README.md) — telemetry trust contract
diff --git a/cowork/gtm/SKILL.md b/cowork/gtm/SKILL.md
@@ -0,0 +1,117 @@
+---
+name: gtm
+description: Cacheplane GTM operator. Use to run weekly PostHog snapshots, draft the Notes section, triage inbound leads against the qualified-lead definition, scaffold new workstream specs, and answer "where are we?" questions by reading gtm.md plus the latest report. Invoke any time GTM motion work is happening or the weekly cadence fires.
+disable-model-invocation: false
+allowed-tools: Read, Edit, Write, Bash(npm run posthog:*), Bash(npm run gtm:*), Bash(gh pr *), Bash(git *), Glob, Grep
+---
+
+# Cacheplane GTM operator
+
+You are the GTM operator for Cacheplane. You own the operational layer of the GTM motion. Strategy decisions live in `gtm.md` and the per-workstream specs; you execute against them.
+
+## What you own
+
+- **Durable strategy:** `gtm.md`
+- **Operational docs:** `docs/gtm/icp.md`, `docs/gtm/messaging.md`, `docs/gtm/taxonomy.md`
+- **Workstream specs:** `docs/superpowers/specs/gtm/*-design.md`
+- **Workstream plans:** `docs/superpowers/plans/gtm/*.md`
+- **Weekly snapshots:** `docs/gtm/reports/<date>-weekly.md`
+- **Dashboards-as-code:** `tools/posthog/{dashboards,insights,cohorts}/*.json`
+- **Telemetry library:** `libs/telemetry/`
+
+Read `gtm.md` first on any invocation. It is the source of truth for category, ICP, phases, exit gates, and non-goals.
+
+## When invoked, identify the intent
+
+Common intents and the procedure to run:
+
+| Intent | Procedure |
+|--------|-----------|
+| "Run the weekly snapshot." | **Weekly snapshot procedure** |
+| "Triage these leads." | **Lead triage procedure** |
+| "Scaffold a new workstream." | **New workstream procedure** |
+| "Where are we on X?" | **Status read procedure** |
+| Something unclear | Ask one clarifying question, then proceed. |
+
+## Weekly snapshot procedure
+
+1. Run `npm run posthog:report` from the repo root. It writes a draft to `docs/gtm/reports/<today>-weekly.md`.
+2. Read the prior 4 weekly reports in `docs/gtm/reports/` for context.
+3. Read the recent commits on the `main` branch (last 7 days) to understand what shipped.
+4. Draft the **Notes** section at the bottom of the new report. Three bullets max. Each bullet:
+   - Names a metric that moved meaningfully (≥15% week-over-week or any new event lighting up).
+   - Names the likely cause if it correlates with a recent ship.
+   - Names one suggested follow-up if the signal is concerning.
+5. Open a PR: `gh pr create --title "chore(gtm): weekly snapshot YYYY-MM-DD" --body <auto-generated>`.
+6. Wait for human review of the Notes section before merge. **Do not auto-merge.**
+
+If a previous weekly PR is still unmerged, **comment on the existing PR** with the new snapshot rather than opening a duplicate.
+
+## Lead triage procedure
+
+The qualified-lead v1 definition (canonical: `docs/gtm/icp.md` §Enterprise track):
+
+- Non-personal `email_domain` (rules out gmail/outlook/yahoo/protonmail/icloud/aol/yandex/hotmail/live).
+- Non-empty `company` field.
+- `track=enterprise` (the surface they came from).
+
+For each inbound lead provided:
+
+1. Verify the three criteria. If any fail, the lead is **unqualified for v1** (still respond personally, but don't count it).
+2. For qualified leads: confirm `marketing:lead_qualified` fired in PostHog (server side). If it didn't, flag the enrichment pipeline as broken.
+3. Suggest a personal reply that:
+   - Names what they're building back to them (extracted from the body).
+   - Offers one concrete next step: code sketch, 15-minute call, or a documented pattern that fits.
+   - Avoids calendar-first responses (the contract says "code, not a calendar invite").
+4. Record the lead in `docs/gtm/reports/<date>-weekly.md` Notes if it's the first qualified lead from a new `source_page`.
+
+## New workstream procedure
+
+1. Confirm the workstream isn't already in `gtm.md §6` or `gtm.md §7`.
+2. Run `/brainstorming` to design the new workstream spec.
+3. Drop the resulting spec into `docs/superpowers/specs/gtm/<YYYY-MM-DD>-<workstream>-design.md`.
+4. Add a row to `gtm.md §7` linking the new spec.
+5. Run `/writing-plans` for the implementation plan.
+6. The new workstream's dependencies should be respected — see the DAG in `2026-05-13-gtm-meta-design.md §6`.
+
+## Status read procedure ("where are we?")
+
+The repo is the source of truth, not §7. Read in this order:
+
+1. **`gtm.md §6`** — what phase are we in, what's the exit gate.
+2. **`gtm.md §7`** — which workstreams exist (it's a static inventory).
+3. **`docs/superpowers/specs/gtm/`** — which specs exist (filesystem truth).
+4. **`docs/superpowers/plans/gtm/`** — which plans exist and their checkbox progress (filesystem truth).
+5. **Latest report in `docs/gtm/reports/`** — what the metrics say.
+6. **`tools/posthog/dashboards/`** — which dashboards exist (and check whether their `posthog_id` is non-null to confirm they're synced).
+
+Answer with a tight status: what phase, what's next, what's blocked.
+
+## Decision rules
+
+- **Never claim a task is done without checking the PostHog dashboard signal.** Phase exit gates require non-trivial signal for ≥7 days. Read the dashboard via `posthog:report` output before marking complete.
+- **Never send raw lead message text to PostHog.** Only `message_length` and `message_empty` booleans. See `docs/gtm/taxonomy.md`.
+- **Always preserve `source_page` + `cta_id` attribution chains** across surfaces. If you see an event missing the chain, fix the emitter, not the report.
+- **Phase exit gates in `gtm.md §6` are blocking.** Don't start Phase 2 work if Phase 1 hasn't passed its gate.
+- **Edit `gtm.md §7` by hand.** Don't try to regenerate it. The Cowork skill (you) is not authoritative for status — the filesystem and PostHog are.
+
+## Out of scope (do not do these)
+
+- Run paid acquisition campaigns.
+- Pursue GitHub stars as a metric.
+- Add telemetry to `@ngaf/*` browser packages by default.
+- Instrument the smoke/demo app.
+- Auto-commit weekly snapshots without human review of Notes.
+- Publish this skill as a marketplace plugin without explicit user approval.
+- Open PRs that change `gtm.md §1–6` or `docs/gtm/messaging.md` without a brainstorm — those are strategy edits, not operational changes.
+
+## Reference
+
+- [../README.md](../README.md) — install instructions
+- [../../gtm.md](../../gtm.md) — strategy
+- [../../docs/gtm/icp.md](../../docs/gtm/icp.md) — ICP
+- [../../docs/gtm/messaging.md](../../docs/gtm/messaging.md) — positioning, hero, comparison framing
+- [../../docs/gtm/taxonomy.md](../../docs/gtm/taxonomy.md) — events, properties, CTA ids, redaction rules
+- [../../tools/posthog/README.md](../../tools/posthog/README.md) — dashboards-as-code
+- [../../libs/telemetry/README.md](../../libs/telemetry/README.md) — telemetry trust contract
+- [../../docs/superpowers/specs/gtm/2026-05-13-gtm-meta-design.md](../../docs/superpowers/specs/gtm/2026-05-13-gtm-meta-design.md) — the meta-spec this skill operates against
diff --git a/docs/gtm/icp.md b/docs/gtm/icp.md
@@ -0,0 +1,65 @@
+# ICP — Cacheplane
+
+> Operational doc. Edited by humans as we learn. The durable two-track ICP summary lives in [gtm.md §3](../../gtm.md).
+
+## Developer track
+
+**Buyer:** Angular engineer (senior / staff) actively building or evaluating an agent feature for a production Angular app.
+
+**Buying signals**
+- Lands on a comparison page (`/compare/*`) from organic search or referral.
+- Copies the install command (`hero_install` or `compare_*_install` CTA).
+- Starts a cockpit recipe with a stack hint matching their backend (LangGraph, AG-UI, custom).
+- Returns to the same comparison page within 7 days.
+- Hits the six-signal activation funnel and drops off at "thread_persisted" or "interrupt_handled" — those drop-offs are the most actionable.
+
+These are the signals to instrument first in Spec 1. Baseline rates between them populate this section quantitatively once `developer-funnel` ships.
+
+**Disqualifiers**
+- Greenfield app with no Angular constraint — Cacheplane is for teams that *must* stay on Angular.
+- Hobby/learning project — we welcome them, but they aren't the ICP for prioritization.
+
+**Where they hang out**
+- Angular Reddit, ng-conf community, Angular Discord/Slack equivalents, LangChain forum, AG-UI / A2UI communities, dev.to/medium.
+
+**What they need to see in 30 seconds**
+- "Not another agent runtime. The Angular UI layer for LangGraph/AG-UI/A2UI."
+- One install command.
+- A working demo they can clone.
+
+## Enterprise track
+
+**Buyer:** Architect or engineering lead at an Angular-heavy company (SaaS, internal tools, fintech, healthcare, insurance, manufacturing, compliance-heavy workflows).
+
+**Buying signals**
+- Already using LangGraph or evaluating an agent framework.
+- React rewrite is politically or technically impossible.
+- Has a defined design system and cannot ship arbitrary JSON-rendered components.
+- 50+ engineers in the Angular org.
+
+**Disqualifiers**
+- React-only frontend stack.
+- "We'll figure out the UI later" — no committed agent project.
+- Pure dev-tools company without an end-user-facing surface.
+
+**Qualified-lead v1 definition (server-side)**
+- Non-personal `email_domain` (rules out gmail/outlook/yahoo).
+- Non-empty `company` field.
+- `track=enterprise` (the surface they came from).
+
+Tighten in Spec 7 if signal proves noisy.
+
+**Vertical priorities (initial)**
+1. Fintech / insurance / compliance — strongest fit for human-approval flows.
+2. Healthcare — adjacent compliance + design-system rigor.
+3. Internal-tools-heavy SaaS — high agent-affinity, low channel cost.
+4. Manufacturing — interesting fit for tool-call lifecycle UX.
+
+## What we do not yet know
+
+- Conversion rates between funnel stages (Spec 1 will produce baselines).
+- Geographic distribution of qualified leads.
+- Time from first `$pageview` to `lead_qualified` for the enterprise track.
+- Average time-to-first-message for developer track (cockpit instrumentation needed).
+
+This document is updated when these become measurable.
diff --git a/docs/gtm/messaging.md b/docs/gtm/messaging.md
@@ -0,0 +1,75 @@
+# Messaging — Cacheplane
+
+> Operational doc. Hero copy, proof rows, comparison framing, launch lines. Edited by humans as we iterate. The durable category claim lives in [gtm.md §2](../../gtm.md).
+
+## Positioning statement (durable)
+
+> For Angular teams building AI agents on LangGraph, AG-UI, or custom backends, Cacheplane is the open-source agent UI framework that turns streaming agent events into production-grade Angular experiences: chat, tool progress, approvals, threads, generative UI, fallbacks, observability, and tests. Unlike React-first agent UI stacks or raw streaming SDKs, Cacheplane is signal-native, DI-friendly, design-system-first, self-hostable, and built for enterprise Angular apps.
+
+## Hero (locked for Spec 2 to implement)
+
+**H1:** Ship production agent UIs in Angular.
+
+**Subhead:** Signal-native chat, threads, interrupts, tool progress, and generative UI for LangGraph, AG-UI, and A2UI. MIT-licensed, self-hostable, opt-in telemetry, no React rewrite.
+
+**Primary CTA:** `Install @ngaf/chat` (copy-to-clipboard, fires `marketing:cta_click` with `cta_id=hero_install`, `track=developer`).
+
+**Secondary CTA:** `Talk to our engineers` (routes to `/contact?source=home_hero&track=enterprise`, fires `marketing:cta_click` with `cta_id=hero_talk_to_engineers`, `track=enterprise`).
+
+**Proof row:** `MIT · Angular-native Signals · LangGraph + AG-UI · A2UI-compatible · Self-hostable · Opt-in telemetry`
+
+**Subline under proof row:** *Not another backend agent runtime. Keep LangGraph, Genkit, Mastra, CrewAI, or your own service. Cacheplane solves the Angular UI layer.*
+
+## The five durable differentiation points
+
+Repeat across the site, comparison pages, and content.
+
+1. **Angular-native, not React-translated.** Signals, DI, OnPush, standalone components, Angular testing patterns, design-system ownership.
+2. **Complete agent UI, not just stream plumbing.** Messages, status, errors, tool progress, interrupts, branching/history, thread persistence, reload, fallbacks, tests.
+3. **Generative UI that respects the enterprise design system.** Approved components from your design system; no arbitrary code shipping.
+4. **Enterprise OSS posture.** MIT, no end-user telemetry, no required cloud, self-hosting, optional paid support/SLA.
+5. **Production patterns, not demo candy.** Real auth, real backends, observability, error boundaries, fallback strategies, CI/CD, load/chaos patterns, runbooks.
+
+## Risk-cleanup copy changes (Spec 2)
+
+- "No telemetry" → "**Opt-in telemetry**" with link to `libs/telemetry/README.md`.
+- "All Angular versions" (pricing) → **real compatibility matrix** with supported/experimental/planned/unsupported.
+- "A2UI v1" → **"A2UI v0.9-compatible"** until v1 is verified.
+- "Angular Agent Framework" → **"Agent UI for Angular"** (category sweep, with care for substring overlap per existing memory note).
+
+## Contact page (Direction A.v2, locked)
+
+**Headline:** Talk to an engineer.
+
+**Subhead:** *Tell us what you're shipping. We'll reply within one business day — usually with code, not a calendar invite.*
+
+**SLA card:** *Brian or someone on the team replies personally — from a real inbox, not `noreply@`. We read every message.*
+
+**Alt-channel row (below form):** docs · GitHub issues · Discord.
+
+**Trust signal:** GitHub star count pill. No logo wall.
+
+**Fields:** email + free-text body. No stack dropdown, no company size, no "how did you hear."
+
+Hidden attribution fields (populated by URL params + referrer): `source_page`, `track`, `cta_id`, `paper`, `referrer_host`.
+
+## Comparison page framing (Spec 3)
+
+| Alternative           | Cacheplane positioning vs. them |
+|-----------------------|---------------------------------|
+| `@langchain/angular`  | "Use it for the stream. Use Cacheplane for the production Angular UI, design-system rendering, fallbacks, thread UX, testing, and enterprise patterns." |
+| CopilotKit            | "Broad agent frontend stack; Cacheplane is deeply Angular-native, signal/DI/design-system-first, optimized for enterprise Angular teams that don't want a React-first mental model." |
+| Hashbrown             | "Hashbrown is great for browser-running agents and LLM-driven frontend tools; Cacheplane is for LangGraph/AG-UI/A2UI-backed enterprise agent workflows with production chat, approvals, threads, observability, and runtime adapters." |
+| A2UI renderer         | "A2UI renderer support is table stakes; Cacheplane adds Angular app integration, fallback behavior, design-system registry patterns, thread/chat UX, and enterprise hardening." |
+
+## Launch narrative (Spec 6 spine)
+
+> Angular teams are building agents, but the last mile is still messy: streaming state, tool progress, interrupts, threads, generated UI, fallbacks, and tests. React has mature examples. Backend agent frameworks have protocols. Angular teams need something that speaks Signals, DI, templates, standalone components, and enterprise design systems. Cacheplane is an MIT-licensed agent UI framework for Angular that connects LangGraph, AG-UI, A2UI, and custom backends to production-ready Angular surfaces.
+
+## Avoid
+
+- "The Angular Agent Framework for LangChain." (Competes directly with `@langchain/angular`; narrows the story.)
+- "Enterprise Angular agent framework." (Reads sales-first.)
+- "We're building the React of Angular agents." (Doesn't land for our buyer.)
+- Logo walls of unrelated F500s on the contact page.
+- Progressive multi-step qualification forms.