@pieerry/harness-kit 3.3.1 → 4.0.0

package/.claude/runtime/scripts/product-manager/confluence-publish.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""
+Publish a PRD or PRP to Confluence.
+
+Reads credentials from environment:
+  - JIRA_USERNAME (email)
+  - JIRA_API_TOKEN (API token)
+
+Targets the Confluence at https://YOUR-DOMAIN.atlassian.net.
+
+Usage:
+  confluence-publish.py --artifact PATH.md --kind {prd|prp}
+
+Exit 0 on success, 1 on failure. Stays silent on routine output, prints
+errors to stderr.
+"""
+
+import argparse
+import base64
+import html
+import json
+import os
+import re
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+CONFLUENCE_BASE = "https://YOUR-DOMAIN.atlassian.net/wiki/rest/api/content"
+SPACE_KEY = "TET1"
+
+# Parent page IDs per kind. Override via env if needed.
+PARENT_IDS = {
+    "prd": os.environ.get("CONFLUENCE_PARENT_PRD", "11351457795"),
+    "prp": os.environ.get("CONFLUENCE_PARENT_PRP", "11351457795"),
+}
+
+
+def md_to_storage(md: str) -> str:
+    """Minimal Markdown to Confluence storage XHTML.
+    Good enough for headings, paragraphs, fenced code, lists, tables.
+    For richer rendering, swap for a real converter later.
+    """
+    lines = md.splitlines()
+    out: list[str] = []
+    in_code = False
+    in_list: str | None = None  # 'ul' or 'ol'
+    in_table = False
+
+    def close_list():
+        nonlocal in_list
+        if in_list:
+            out.append(f"</{in_list}>")
+            in_list = None
+
+    def close_table():
+        nonlocal in_table
+        if in_table:
+            out.append("</tbody></table>")
+            in_table = False
+
+    for line in lines:
+        if line.startswith("```"):
+            close_list()
+            close_table()
+            if not in_code:
+                lang = line[3:].strip() or "none"
+                out.append(
+                    f'<ac:structured-macro ac:name="code">'
+                    f'<ac:parameter ac:name="language">{html.escape(lang)}</ac:parameter>'
+                    f'<ac:plain-text-body><![CDATA['
+                )
+                in_code = True
+            else:
+                out.append("]]></ac:plain-text-body></ac:structured-macro>")
+                in_code = False
+            continue
+
+        if in_code:
+            out.append(line)
+            continue
+
+        h = re.match(r"^(#{1,6})\s+(.+)$", line)
+        if h:
+            close_list()
+            close_table()
+            level = len(h.group(1))
+            out.append(f"<h{level}>{html.escape(h.group(2))}</h{level}>")
+            continue
+
+        if re.match(r"^[-*]\s+", line):
+            close_table()
+            if in_list != "ul":
+                close_list()
+                out.append("<ul>")
+                in_list = "ul"
+            item = re.sub(r"^[-*]\s+", "", line)
+            out.append(f"<li>{html.escape(item)}</li>")
+            continue
+
+        if re.match(r"^\d+\.\s+", line):
+            close_table()
+            if in_list != "ol":
+                close_list()
+                out.append("<ol>")
+                in_list = "ol"
+            item = re.sub(r"^\d+\.\s+", "", line)
+            out.append(f"<li>{html.escape(item)}</li>")
+            continue
+
+        if line.startswith("|") and "|" in line[1:]:
+            close_list()
+            cells = [c.strip() for c in line.strip("|").split("|")]
+            if not in_table:
+                out.append("<table><tbody>")
+                in_table = True
+                out.append(
+                    "<tr>"
+                    + "".join(f"<th>{html.escape(c)}</th>" for c in cells)
+                    + "</tr>"
+                )
+            elif all(re.fullmatch(r":?-+:?", c) for c in cells):
+                # separator row, skip
+                pass
+            else:
+                out.append(
+                    "<tr>"
+                    + "".join(f"<td>{html.escape(c)}</td>" for c in cells)
+                    + "</tr>"
+                )
+            continue
+
+        # paragraph or blank
+        close_list()
+        close_table()
+        if line.strip():
+            out.append(f"<p>{html.escape(line)}</p>")
+
+    close_list()
+    close_table()
+    return "\n".join(out)
+
+
+def extract_title(md: str) -> str:
+    for line in md.splitlines():
+        m = re.match(r"^#\s+(.+)$", line)
+        if m:
+            return m.group(1).strip()
+    return "Untitled"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--artifact", required=True, type=Path)
+    parser.add_argument("--kind", required=True, choices=["prd", "prp"])
+    args = parser.parse_args()
+
+    username = os.environ.get("JIRA_USERNAME")
+    token = os.environ.get("JIRA_API_TOKEN")
+    if not username or not token:
+        print("[confluence-publish] JIRA_USERNAME/JIRA_API_TOKEN not set", file=sys.stderr)
+        return 1
+
+    md = args.artifact.read_text(encoding="utf-8")
+    title = extract_title(md)
+    storage = md_to_storage(md)
+
+    payload = {
+        "type": "page",
+        "title": title,
+        "ancestors": [{"id": PARENT_IDS[args.kind]}],
+        "space": {"key": SPACE_KEY},
+        "body": {"storage": {"value": storage, "representation": "storage"}},
+    }
+
+    auth = base64.b64encode(f"{username}:{token}".encode()).decode()
+    req = urllib.request.Request(
+        CONFLUENCE_BASE,
+        data=json.dumps(payload).encode("utf-8"),
+        method="POST",
+        headers={
+            "Authorization": f"Basic {auth}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        },
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=20) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+            page_url = data.get("_links", {}).get("base", "") + data.get(
+                "_links", {}
+            ).get("webui", "")
+            print(f"[confluence-publish] published: {page_url}", file=sys.stderr)
+            return 0
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", errors="replace")
+        print(f"[confluence-publish] HTTP {e.code}: {body[:500]}", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"[confluence-publish] error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.claude/{plugins/product-manager/scripts → runtime/scripts/product-manager}/link-validator.py

@@ -42,7 +42,7 @@ def main() -> int:
         candidates = [
             args.repo_root / prd_rel,
             args.artifact.parent / prd_rel,
-            args.repo_root / ".claude/plugins/product-manager" / prd_rel,
+            args.repo_root / ".claude/agents/product-manager" / prd_rel,
         ]
         if not any(c.exists() for c in candidates):
             failures.append(f"Source PRD path does not resolve: {prd_rel}")

package/.claude/{plugins/product-manager/scripts → runtime/scripts/product-manager}/token-phase.py

@@ -137,7 +137,7 @@ def main() -> int:
     parser.add_argument("--details", default="{}")
     args = parser.parse_args()
 
-    markers_dir = args.plugin_dir / "outputs" / ".markers"
+    markers_dir = args.plugin_dir / ".markers"
     start_marker = markers_dir / f"{args.feature_id}.{args.phase}.start"
     end_marker = markers_dir / f"{args.feature_id}.{args.phase}.end"
 
@@ -187,7 +187,7 @@ def main() -> int:
         files["prp"] = args.prp_path
 
     tokens_path = (
-        args.plugin_dir / "outputs" / "tokens" / f"{args.feature_id}.json"
+        args.plugin_dir / "tokens" / f"{args.feature_id}.json"
     )
     update_tokens_json(tokens_path, args.feature_id, files, phase_entry)
 

package/.claude/scripts/pipeline.py

@@ -55,12 +55,12 @@ STAGE_TO_COMMAND = {
 }
 
 STAGE_TO_OUTPUT_DIR = {
-    "prd": ".claude/plugins/product-manager/outputs/prd",
-    "prp": ".claude/plugins/product-manager/outputs/prp",
-    "plan": ".claude/plugins/staff-software-engineer/outputs/plan",
-    "dev": ".claude/plugins/staff-software-engineer/outputs/dev",
-    "test": ".claude/plugins/staff-software-engineer/outputs/test",
-    "pr": ".claude/plugins/staff-software-engineer/outputs/pr",
+    "prd": ".claude/runtime/outputs/pm/prd",
+    "prp": ".claude/runtime/outputs/pm/prp",
+    "plan": ".claude/runtime/outputs/sse/plan",
+    "dev": ".claude/runtime/outputs/sse/dev",
+    "test": ".claude/runtime/outputs/sse/test",
+    "pr": ".claude/runtime/outputs/sse/pr",
 }
 
 

package/.claude/settings.json

@@ -36,7 +36,7 @@
       {
         "matcher": "Write",
         "hooks": [
-          { "type": "command", "command": "[ -x .claude/plugins/product-manager/hooks/pre-prp-check.sh ] && bash .claude/plugins/product-manager/hooks/pre-prp-check.sh; exit 0" }
+          { "type": "command", "command": "[ -x .claude/runtime/hooks/product-manager/pre-prp-check.sh ] && bash .claude/runtime/hooks/product-manager/pre-prp-check.sh; exit 0" }
         ]
       },
       {
@@ -50,18 +50,18 @@
       {
         "matcher": "Write",
         "hooks": [
-          { "type": "command", "command": "[ -x .claude/plugins/product-manager/hooks/post-write-prd.sh ] && bash .claude/plugins/product-manager/hooks/post-write-prd.sh; exit 0" },
-          { "type": "command", "command": "[ -x .claude/plugins/product-manager/hooks/post-write-prp.sh ] && bash .claude/plugins/product-manager/hooks/post-write-prp.sh; exit 0" },
-          { "type": "command", "command": "[ -x .claude/plugins/staff-software-engineer/hooks/post-write-sse.sh ] && bash .claude/plugins/staff-software-engineer/hooks/post-write-sse.sh; exit 0" },
+          { "type": "command", "command": "[ -x .claude/runtime/hooks/product-manager/post-write-prd.sh ] && bash .claude/runtime/hooks/product-manager/post-write-prd.sh; exit 0" },
+          { "type": "command", "command": "[ -x .claude/runtime/hooks/product-manager/post-write-prp.sh ] && bash .claude/runtime/hooks/product-manager/post-write-prp.sh; exit 0" },
+          { "type": "command", "command": "[ -x .claude/runtime/hooks/staff-software-engineer/post-write-sse.sh ] && bash .claude/runtime/hooks/staff-software-engineer/post-write-sse.sh; exit 0" },
           { "type": "command", "command": "[ -x .claude/hooks/pipeline-postwrite.sh ] && bash .claude/hooks/pipeline-postwrite.sh; exit 0" }
         ]
       },
       {
         "matcher": "Edit",
         "hooks": [
-          { "type": "command", "command": "[ -x .claude/plugins/product-manager/hooks/post-eval-prd.sh ] && bash .claude/plugins/product-manager/hooks/post-eval-prd.sh; exit 0" },
-          { "type": "command", "command": "[ -x .claude/plugins/product-manager/hooks/post-eval-prp.sh ] && bash .claude/plugins/product-manager/hooks/post-eval-prp.sh; exit 0" },
-          { "type": "command", "command": "[ -x .claude/plugins/staff-software-engineer/hooks/post-eval-sse.sh ] && bash .claude/plugins/staff-software-engineer/hooks/post-eval-sse.sh; exit 0" },
+          { "type": "command", "command": "[ -x .claude/runtime/hooks/product-manager/post-eval-prd.sh ] && bash .claude/runtime/hooks/product-manager/post-eval-prd.sh; exit 0" },
+          { "type": "command", "command": "[ -x .claude/runtime/hooks/product-manager/post-eval-prp.sh ] && bash .claude/runtime/hooks/product-manager/post-eval-prp.sh; exit 0" },
+          { "type": "command", "command": "[ -x .claude/runtime/hooks/staff-software-engineer/post-eval-sse.sh ] && bash .claude/runtime/hooks/staff-software-engineer/post-eval-sse.sh; exit 0" },
           { "type": "command", "command": "[ -x .claude/hooks/pipeline-postedit.sh ] && bash .claude/hooks/pipeline-postedit.sh; exit 0" }
         ]
       }

package/.claude/settings.local.json

@@ -74,8 +74,8 @@
       "Bash(npm publish *)",
       "Bash(git tag *)",
       "Bash(sh -n /Users/pierryborges/Development/harness-kit/.claude/hooks/pipeline-session-start.sh)",
-      "Bash(sh -n .claude/plugins/staff-software-engineer/hooks/post-write-sse.sh)",
-      "Bash(sh -n .claude/plugins/staff-software-engineer/hooks/post-eval-sse.sh)",
+      "Bash(sh -n .claude/runtime/hooks/staff-software-engineer/post-write-sse.sh)",
+      "Bash(sh -n .claude/runtime/hooks/staff-software-engineer/post-eval-sse.sh)",
       "Bash(sh -n .claude/hooks/activity-pre-read.sh)",
       "Bash(sh -n .claude/hooks/status-line.sh)",
       "Read(//private/tmp/act-test/**)",
@@ -84,7 +84,15 @@
       "Bash(cp /Users/pierryborges/Development/harness-kit/.claude/hooks/status-line.sh .claude/hooks/)",
       "Bash(cp /Users/pierryborges/Development/harness-kit/.claude/scripts/pipeline.py .claude/scripts/)",
       "Bash(npx --yes tsc --noEmit -p tsconfig.json)",
-      "Bash(ffmpeg -y -i out/demo.mp4 -vf 'fps=10,scale=720:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=96[p];[s1][p]paletteuse=dither=bayer:bayer_scale=5' -loop 0 preview.gif)"
+      "Bash(ffmpeg -y -i out/demo.mp4 -vf 'fps=10,scale=720:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=96[p];[s1][p]paletteuse=dither=bayer:bayer_scale=5' -loop 0 preview.gif)",
+      "WebFetch(domain:arxiv.org)",
+      "WebFetch(domain:openai.com)",
+      "Bash(grep -v \"^$\")",
+      "Bash(grep \"Error\\\\|^[^:]*:[^:]*:$\")",
+      "Bash(echo \"exit=$?\")",
+      "Bash(echo \"next exit=$? \\(expect 1, nothing to do\\)\")",
+      "Bash(:)",
+      "Bash(ffmpeg -y -i out/demo.mp4 -vf \"fps=8,scale=640:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=64[p];[s1][p]paletteuse=dither=bayer:bayer_scale=5\" -loop 0 preview.gif)"
     ]
   }
 }

package/AGENTS.md

@@ -0,0 +1,141 @@
+# AGENTS.md — Agent Registry & Routing
+
+Source of truth for every agent, skill, and runtime path in this workspace.
+
+This file is the **declarative spec**. Execution lives in `.claude/agents/` (definitions), `.claude/runtime/` (state, outputs), and `.claude/shared/` (cross-agent docs). Pipelines like `/sse:run` and `/product-manager:run` consult this registry when dispatching.
+
+Portable across tools (Claude Code, Cursor, Codex) — all read `AGENTS.md` at the repo root.
+
+---
+
+## Quick map
+
+```
+AGENTS.md                          ← this file: registry + routing
+CLAUDE.md                          ← project context (style, role, conventions)
+.claude/
+├── agents/                        ← per-agent definitions + bundled assets
+│   ├── product-manager/
+│   │   ├── README.md
+│   │   ├── sensors/               deterministic checks
+│   │   ├── evals/                 LLM-judge rubrics
+│   │   ├── guides/                pipeline, writing style, templates, examples
+│   │   └── skills/                prd, prp
+│   ├── staff-software-engineer/
+│   │   ├── README.md
+│   │   ├── sensors/
+│   │   ├── evals/
+│   │   ├── guides/                pipeline, coding-style, commit-style, conventions-override
+│   │   └── skills/                backend, web, mobile, devops
+│   ├── product-manager.md         orchestrator agent
+│   └── staff-software-engineer.md orchestrator agent
+├── commands/                      ← slash-command entry points
+│   ├── product-manager/           /product-manager:{prd,prp,run}
+│   ├── sse/                       /sse:{plan,dev,test,pr,run}
+│   └── pipeline/                  /pipeline:{continue,reset}
+├── conventions/                   ← generic conventions (overridable per repo)
+├── hooks/                         ← root lifecycle hooks (session-start, prompt, postedit, postwrite, status-line, activity-pre-read)
+├── scripts/                       ← root utilities (pipeline.py, activity.py, pr-monitor.py)
+└── runtime/                       ← generated artifacts + per-agent hooks/scripts
+    ├── outputs/
+    │   ├── pm/{prd,prp,tokens,.markers}/
+    │   └── sse/{plan,dev,test,pr,tokens,.markers}/
+    ├── hooks/
+    │   ├── product-manager/       phase markers, sensor gates, eval, publish
+    │   └── staff-software-engineer/
+    └── scripts/
+        ├── product-manager/       sensor-runner, token-phase, link-validator, confluence-publish
+        └── staff-software-engineer/  token-phase
+```
+
+---
+
+## Agent registry
+
+### Orchestrators
+
+| Agent | When to use | Entry | Definition |
+|---|---|---|---|
+| `product-manager` | Generate PRD then PRP for a squad/feature | `/product-manager:run` | `.claude/agents/product-manager.md` |
+| `staff-software-engineer` | Full engineering pipeline: plan → dev → test → pr | `/sse:run` | `.claude/agents/staff-software-engineer.md` |
+
+---
+
+## Routing
+
+When the user types a slash command, the entry point is unambiguous. When the user describes work in natural language, the main session consults this routing table:
+
+| User intent | Route |
+|---|---|
+| "ship a new feature end-to-end" | `staff-software-engineer` (`/sse:run` full pipeline) |
+| "draft a PRD" | `product-manager` → `/product-manager:prd` |
+| "draft a PRP" | `product-manager` → `/product-manager:prp` |
+| "full PM pipeline" | `product-manager` → `/product-manager:run` |
+| "make the plan" | `/sse:plan` |
+| "implement the plan" | `/sse:dev` |
+| "run tests" | `/sse:test` |
+| "open the PR" | `/sse:pr` |
+| "continue the active pipeline" | `/pipeline:continue` |
+| "abandon active feature" | `/pipeline:reset` |
+
+**Rule of thumb:** if you know the agent, invoke directly. If you only know the intent, this table dispatches.
+
+---
+
+## Pipeline stages
+
+Six gated stages, one feature: `prd → prp → plan → dev → test → pr`.
+
+Each stage:
+1. Writes a markdown artifact to `.claude/runtime/outputs/{pm,sse}/{stage}/{feature_id}.md`.
+2. Triggers deterministic sensors (markdown rules + Python runner) on save.
+3. Applies an LLM-judge eval rubric, retries on low score (up to 3).
+4. On approval, records token spend per phase under `.claude/runtime/outputs/{pm,sse}/tokens/{feature_id}.json`.
+
+Phase markers under `.claude/runtime/outputs/{pm,sse}/.markers/` track stage boundaries (`{feature}.{phase}.{start,end}`) for token accounting and pipeline status.
+
+---
+
+## Runtime (state, outputs, hooks)
+
+Generated artifacts and lifecycle hooks live under `.claude/runtime/`.
+
+| Path | Contents |
+|---|---|
+| `runtime/outputs/pm/{prd,prp,tokens,.markers}/` | PRD/PRP artifacts, token JSONs, phase markers |
+| `runtime/outputs/sse/{plan,dev,test,pr,tokens,.markers}/` | Plan/dev/test/pr artifacts, token JSONs, phase markers |
+| `runtime/hooks/<agent>/` | Per-agent lifecycle hooks (post-write, post-eval, pre-prp-check) |
+| `runtime/scripts/<agent>/` | Per-agent utilities (sensor-runner, token-phase, link-validator, confluence-publish) |
+
+`settings.json` `hooks` blocks reference these paths. `.claude/scripts/pipeline.py` reads/writes markers and outputs.
+
+---
+
+## Distribution
+
+This repo is **harness-kit**, the source-of-truth template. Consumer repos install the harness via `setup/install.sh`, which copies:
+
+- `AGENTS.md` and `CLAUDE.md` to the target root
+- `.claude/agents/`, `.claude/commands/`, `.claude/hooks/`, `.claude/scripts/`, `.claude/conventions/` to the target `.claude/`
+- `.claude/runtime/hooks/`, `.claude/runtime/scripts/` to the target (definition-side only; `outputs/`, `state/`, `.markers/` are runtime, not distributed)
+- `.claude/settings.json` `hooks` block, merged with the consumer's existing settings
+
+`setup/update.sh` migrates v3.x consumers (which have `.claude/plugins/`) to v4.x layout in place. v3.x consumers were the **plugin-shaped** distribution.
+
+---
+
+## Adding a new agent
+
+1. Create `.claude/agents/<name>.md` (or `.claude/agents/<name>/agent.md` if bundled assets).
+2. Register here under the right section.
+3. If invocable via slash command, add `.claude/commands/<name>.md`.
+4. If it needs lifecycle hooks, add under `.claude/runtime/hooks/<name>/` and wire in `.claude/settings.json`.
+
+---
+
+## See also
+
+- [`CLAUDE.md`](./CLAUDE.md) — workspace context, style, role
+- [`.claude/commands/`](./.claude/commands/) — slash command definitions
+- [`setup/install.sh`](./setup/install.sh) — consumer installer
+- [`setup/update.sh`](./setup/update.sh) — v3→v4 migration tool

package/CLAUDE.md

@@ -2,6 +2,8 @@
 
 Read by Claude Code on every session. Defines how to work in this harness-kit workspace.
 
+**See [`AGENTS.md`](./AGENTS.md) for the full agent registry, routing table, and runtime paths.** Consult it whenever you need to decide which agent handles a request, where assets live, or how stages flow.
+
 ## Response Style
 
 - **Language:** match the user. Default English. Domain terms stay native.
@@ -29,9 +31,9 @@ AI copilot for product + engineering delivery. Thinking partner and execution as
 
 Configurable per consumer. Fill `context-library/business-info.md` and `context-library/squads/{slug}/` with your own structure. Ask which squad the work belongs to when not clear.
 
-## Plugins
+## Agents
 
-This workspace ships two Claude Code plugins under `.claude/plugins/`. Both have their own README with full detail.
+Two orchestrator agents, registered in [`AGENTS.md`](./AGENTS.md). Each lives under `.claude/agents/<name>/` with its own README, sensors, evals, guides, and skills.
 
 ### product-manager
 
@@ -40,7 +42,7 @@ PRD and PRP generation. Slash commands:
 - `/product-manager:prp` draft a PRP (engineering-ready spec)
 - `/product-manager:run` full PM pipeline
 
-Sub-agent `product-manager` is also Task-tool-invokable for delegation.
+Sub-agent `product-manager` is also Task-tool-invokable for delegation. Assets: `.claude/agents/product-manager/`.
 
 ### staff-software-engineer
 
@@ -51,13 +53,13 @@ Engineering pipeline. Slash commands:
 - `/sse:pr` open the draft PR
 - `/sse:run` full SSE pipeline
 
-Sub-agent `staff-software-engineer` is also Task-tool-invokable.
+Sub-agent `staff-software-engineer` is also Task-tool-invokable. Assets: `.claude/agents/staff-software-engineer/`.
 
 Full pipeline order: `prd → prp → plan → dev → test → pr`. Each stage gets an approval marker. The status bar tracks the current one.
 
 ## Project conventions override
 
-Each target repo can override SSE plugin defaults with files in `.claude/conventions/`:
+Each target repo can override SSE defaults with files in `.claude/conventions/`:
 
 ```
 {repo}/.claude/conventions/
@@ -67,11 +69,11 @@ Each target repo can override SSE plugin defaults with files in `.claude/convent
 └── devops.md
 ```
 
-When a file exists, plugin reads it on top of defaults. Project wins. Reference: `.claude/plugins/staff-software-engineer/guides/conventions-override.md`.
+When a file exists, the agent reads it on top of defaults. Project wins. Reference: `.claude/agents/staff-software-engineer/guides/conventions-override.md`.
 
 ## Token accounting and status bar
 
-After approval, hooks compute tokens used per phase from the Claude transcript and append to `outputs/tokens/{feature_id}.json` (per plugin). One JSON collects phases across the full lifecycle.
+After approval, hooks compute tokens used per phase from the Claude transcript and append to `.claude/runtime/outputs/{pm,sse}/tokens/{feature_id}.json` (per agent). One JSON per agent collects phases across the full lifecycle.
 
 The status bar follows the active feature through the 6-stage pipeline. See `.claude/hooks/status-line.sh`.