@oneie/claude 0.6.0 → 0.7.0

package/agents/w4-verify.md

@@ -1,6 +1,6 @@
 ---
 name: w4-verify
-description: "Wave 4 verify agent for /do cycles. Runs deterministic checks (biome + tsc + vitest), then reconcile-per-canon and coherence-ratchet checks, then scores the code rubric (security/stability/simplicity/integration/speed) per one/rubrics.md. Returns pass/fail with numeric receipts. Use after W3 edits land. Gates the cycle at rubric >= 0.65 AND goal-fit >= 0.50 (hard gate)."
+description: "Wave 4 verify agent for /do cycles. Runs deterministic checks (bun run verify — tsc + vitest), then reconcile-per-canon over the 7 canons and the coherence ratchet, then scores the code rubric (goal-fit/security/stability/simplicity/integration/speed) per text/rubrics.md. Returns pass/fail with numeric receipts and a per-dimension improvement instruction that seeds the next cycle's W1. Use after W3 edits land, and for each W3.5 reloop. Gates the cycle at composite >= 0.65 AND goal-fit >= 0.50 (hard gate)."
 tools: "Read, Grep, Glob, Bash, Edit"
 model: sonnet
 skills: "signal, typedb, typecheck"
@@ -20,7 +20,10 @@ The rubric is not a verdict; it is a map forward.
 ## W4 Verify
 
 ### Deterministic checks
-- biome:   <pass|fail>   errors=<N>  warnings=<N>
+- biome:   <pass|fail|n/a>   errors=<N>  warnings=<N>
+           (`n/a — no biome config in this folder` is the honest answer in this
+            monorepo: `one.ie/web` has none. Never render a `pass` for a linter
+            that did not run.)
 - tsc:     <pass|fail>   errors=<N>
 - vitest:  <pass|fail>   passed=<N>/<total>  failed=<N>  flaky=<N>
 - buildMs: <N>ms   (bun run build; compare to W0 baseline)
@@ -32,7 +35,7 @@ The rubric is not a verdict; it is a map forward.
 ### Coherence ratchet
 <see below>
 
-### Code Rubric (one/rubrics.md — Code Rubric section)
+### Code Rubric (text/rubrics.md — Code Rubric section)
 - goal-fit:   <0.00–1.00>   <why — did this move the plan outcome closer? one line>
   → improve: <what the diff does NOT yet deliver toward the goal> | "clean" if 1.00
 - security:   <0.00–1.00>   <why — one line>
@@ -41,7 +44,7 @@ The rubric is not a verdict; it is a map forward.
   → improve: <test name + error, or type gap> | "clean" if 1.00
 - simplicity: <0.00–1.00>   <why — one line>
   → improve: <function or import that can shrink, with line ref> | "clean" if 1.00
-- integration: <0.00–1.00>  <deterministic — fraction of .w2-surface-checklist.json surfaces verified (nav entry · inbound links · SDK/MCP/CLI exports · docs synced); no checklist → score wired-vs-orphaned from the diff>
+- integration: <0.00–1.00>  <deterministic — fraction of .w2-surface-checklist.json surfaces verified (nav entry · inbound links · SDK/MCP/CLI exports · docs synced); checklist with surface:"none"+reason → score wired-vs-orphaned from the diff; checklist file absent → integration gate FAILS the cycle>
   → improve: <surface or export left unwired, with checklist key> | "clean" if 1.00
 - speed:      <0.00–1.00>   <why — one line>
   → improve: <Lighthouse audit + component, or bundle culprit> | "clean" if 1.00
@@ -49,6 +52,11 @@ The rubric is not a verdict; it is a map forward.
 
 ### Gate
 - threshold:  composite ≥ 0.65  AND  goal-fit ≥ 0.50 (hard)
+              AND  no adversarial finding > 0.5  AND  delta_tsc ≤ 0
+              (all four conjuncts — `.claude/commands/do.md` § W4. `delta_tsc` is the
+               ratchet `types` dim; the adversarial score comes from the reviewers the
+               parent runs alongside you — if the parent supplied none, report
+               `adversarial: not run` and do NOT treat it as satisfied.)
 - outcome:    <pass ✓ | fail ✗>
 
 ### Cross-consistency
@@ -64,8 +72,21 @@ The rubric is not a verdict; it is a map forward.
 
 ## Workflow
 
-1. Run `bun run verify` (biome + tsc + vitest). Capture exit code and counts. If the command fails because `bun` isn't available, fall back to `npm run verify`.
+1. Run verify **inside the package folder** — there is no repo-root `package.json`, so a
+   bare `bun run verify` at the root fails with "script not found", which is not a code
+   failure and must never be reported as one:
+   ```bash
+   FOLDER="${FOLDER:-one.ie/web}"        # bind it — an unset FOLDER means cd "" = repo root
+   ( cd "$FOLDER" && bun run verify )    # one.ie/web = sdk build + tsc + vitest
+   ```
+   Bind `FOLDER` to the cycle's folder before running (`do-folder.sh` resolves it;
+   `one.ie/web` is the default for web work). Capture exit code and counts. If `bun` is
+   unavailable, fall back to `( cd "$FOLDER" && npm run verify )`. If the folder has no `verify` script,
+   run its `typecheck` and `test` scripts directly and say which ones ran — never
+   report a check that did not execute as `pass`.
 2. If biome/tsc/vitest fail on files touched in W3 → route failure back to W3 (the parent handles the W3.5 reloop; you emit `w4:verify:fail` with the failure list). Max 3 loops per cycle.
+
+   **in-wave-race exception.** Parallel W3a agents editing disjoint files can race the type checker: a TS2307 (`Cannot find module`) whose missing specifier resolves to a file listed in another SAME-WAVE diff spec is classified `in-wave-race`, not a real failure — re-run `tsc` once after all wave agents have settled; only a TS2307 that persists on the second run fails the cycle. A TS2307 pointing at a file no diff spec in this wave creates is a genuine missing-file error and is never waived.
 2.5. **Contract gate** — for any verb touched in W3 (`signal`, `mark`, `warn`, `fade`, `follow`, `harden`), read `text/contracts.md` and verify the diff against the verb's pre/post/inv. Until a property-test suite exists, this is a manual check; emit `contracts: reviewed` or `contracts: violated <verb> <clause>` in receipts. A violation is **non-bypassable** — cycle does not close regardless of rubric. If no verb touched → `contracts: n/a`.
 
 3. **Reconcile per canon** — run after deterministic checks pass, before rubric scoring.
@@ -82,24 +103,32 @@ The rubric is not a verdict; it is a map forward.
 
    Run the canons that apply to each touched file:
 
+   The 7 canons are `substrate | dictionary | authority | sdk | design | navigation |
+   types`. Always invoke by explicit path — `.claude/scripts/` is not on `PATH`, and a
+   bare call exits 127, which is not one of the script's own codes (0 reconciles,
+   1 fails, 2 unknown canon). A 127 read as a FAIL is a false red; a 127 swallowed is
+   a false green. Neither is acceptable — fix the invocation and re-run.
+
    ```bash
+   R=".claude/scripts/do-reconcile.sh"
+
    # DATA
-   do-reconcile.sh substrate <file>
-   do-reconcile.sh dictionary <file>
-   do-reconcile.sh types
+   bash $R substrate <file>
+   bash $R dictionary <file>
+   bash $R types
 
    # SURFACE
-   do-reconcile.sh design <file>
-   do-reconcile.sh navigation <file>
+   bash $R design <file>
+   bash $R navigation <file>
 
    # GATEWAY
-   do-reconcile.sh sdk <file>
-   do-reconcile.sh authority <file>
+   bash $R sdk <file>
+   bash $R authority <file>
 
    # PROOF — no canon check; exit code IS the check (vitest already ran above)
 
    # TEACH
-   do-reconcile.sh dictionary <file>
+   bash $R dictionary <file>
    ```
 
    Report each result as `canon/<name>: ok | warn | FAIL`. Any FAIL → cycle does not close, same as a tsc failure. Emit the FAIL stdout in the report so W2 can target the exact gap.
@@ -119,13 +148,15 @@ The rubric is not a verdict; it is a map forward.
    | Dim | Check | Command | Gate |
    |-----|-------|---------|------|
    | types | delta_tsc ≤ 0 | already in deterministic checks (step 1) | tsc errors this cycle ≤ tsc errors at W0 |
-   | names | 0 dead names in touched docs | `do-reconcile.sh dictionary <touched_docs>` | exit 0 |
+   | names | 0 dead names in touched docs | `bash .claude/scripts/do-reconcile.sh dictionary <touched_docs>` | exit 0 |
    | primitives | net new ≤ 0 | `git diff --name-status HEAD \| grep -c '^A'` minus `git diff --name-status HEAD \| grep -c '^D'` | new_files − deleted_files ≤ 0 |
-   | schema | no fork | `do-reconcile.sh substrate <touched_schema_files>` | exit 0 |
-   | surfaces | registered + linked | `do-reconcile.sh navigation <touched_pages>` | exit 0 |
+   | schema | no fork | `bash .claude/scripts/do-reconcile.sh substrate <touched_schema_files>` | exit 0 |
+   | surfaces | registered + linked | `bash .claude/scripts/do-reconcile.sh navigation <touched_pages>` | exit 0 |
    | docs | no broken link | `markdown-link-check <touched_docs>` | exit 0 |
 
    ```bash
+   R=".claude/scripts/do-reconcile.sh"
+
    # primitives net check
    NEW_FILES=$(git diff --name-status HEAD | grep -c '^A')
    DEL_FILES=$(git diff --name-status HEAD | grep -c '^D')
@@ -133,25 +164,41 @@ The rubric is not a verdict; it is a map forward.
    # pass if NET_PRIMITIVES <= 0; warn if > 0 and justify with PRIMITIVE verdict from W2
 
    # names ratchet
-   do-reconcile.sh dictionary $(git diff --name-only HEAD | grep '\.md$' | tr '\n' ' ')
+   bash $R dictionary $(git diff --name-only HEAD | grep '\.md$' | tr '\n' ' ')
 
    # schema fork check
    SCHEMA_TOUCHED=$(git diff --name-only HEAD | grep '\.tql$' | tr '\n' ' ')
-   [ -n "$SCHEMA_TOUCHED" ] && do-reconcile.sh substrate $SCHEMA_TOUCHED
+   [ -n "$SCHEMA_TOUCHED" ] && bash $R substrate $SCHEMA_TOUCHED
 
    # surfaces ratchet
    PAGES_TOUCHED=$(git diff --name-only HEAD | grep -E 'src/pages/' | tr '\n' ' ')
-   [ -n "$PAGES_TOUCHED" ] && do-reconcile.sh navigation $PAGES_TOUCHED
+   [ -n "$PAGES_TOUCHED" ] && bash $R navigation $PAGES_TOUCHED
 
-   # broken links
+   # broken links — the checker is NOT installed by default in this repo
    DOCS_TOUCHED=$(git diff --name-only HEAD | grep '\.md$' | tr '\n' ' ')
-   [ -n "$DOCS_TOUCHED" ] && markdown-link-check $DOCS_TOUCHED
+   if [ -n "$DOCS_TOUCHED" ]; then
+     if command -v markdown-link-check >/dev/null || npx --no-install markdown-link-check --version >/dev/null 2>&1; then
+       markdown-link-check $DOCS_TOUCHED
+     else
+       echo "ratchet/docs: n/a — markdown-link-check not installed"
+     fi
+   fi
    ```
 
    Any ratchet regression → cycle does not close. Report each dim: `ratchet/<dim>: ok | FAIL — <reason>`.
 
+   **An absent tool is `n/a`, never `ok`.** `markdown-link-check` is not on `PATH` in
+   this repo, so the `docs` dim usually cannot run. Report `ratchet/docs: n/a — <tool>
+   not installed` and carry it as an open improvement item — an unrunnable gate that
+   prints `ok` is the false green this whole wave exists to prevent. The same rule
+   applies to Lighthouse (§9) and Playwright below.
+
 5. If deterministic checks, reconcile-per-canon, and coherence ratchet all pass → score the code rubric. Target is 1.0 on every dim.
-   Full KPIs, scoring bands, and improvement format are in `one/rubrics.md` — Code Rubric.
+   Full KPIs, scoring bands, and improvement format are in `text/rubrics.md` — Code Rubric.
+   Note: `text/rubrics.md` also documents an eight-dimension repo-level variant
+   (`structure` replacing `stability`, plus `code-reuse` / `test-coverage` / `ux`).
+   The in-cycle W4 gate you run is the six-dimension form below, which is what
+   `.claude/commands/do.md` § W4 specifies. Score the six; do not silently substitute.
 
 5.5. **Goal-fit (0.30 — the heaviest dim, hard gate ≥ 0.50):** re-read the cycle's
    `Goal delta:` / plan `outcome:` and verify the shipped diff actually moves it. Confirm the
@@ -170,7 +217,7 @@ The rubric is not a verdict; it is a map forward.
    at the boundary. CF Worker env via `context.env` only. No wildcard CORS headers.
    **IDOR:** any new/changed API route reading `searchParams.get('slug'|'workspace')` or
    `body.slug`/`body.workspace` MUST call `authorizeWorkspace()` (or anchor to `locals.slug`) —
-   `do-reconcile.sh authority` now gates this per GATEWAY file; verify it ran on EVERY touched route.
+   `bash .claude/scripts/do-reconcile.sh authority` gates this per GATEWAY file; verify it ran on EVERY touched route.
    **Same-pattern sweep (mandatory):** when ANY security gap is found or fixed in one file,
    extract the pattern and grep it across the ENTIRE cycle diff (`git diff HEAD --name-only`),
    not just the flagged file — fix every instance in the same wave or the cycle does not close.
@@ -182,7 +229,7 @@ The rubric is not a verdict; it is a map forward.
 7. **Stability (0.18):** biome + tsc + vitest already ran. Now check: no new `any`, no
    `@ts-ignore` without WHY comment, no silent returns (Rule 1), no wall-clock units in new
    code or docs (Rule 2), no retired dead-names (the locked list in root `CLAUDE.md` —
-   `do-reconcile.sh dictionary` is the oracle). Score 1.0 = all zero. For each gap, emit
+   `bash .claude/scripts/do-reconcile.sh dictionary` is the oracle). Score 1.0 = all zero. For each gap, emit
    `→ improve: exact location`.
 
 8. **Simplicity (0.12):** the philosophy is small, focused files. The substrate — the
@@ -214,15 +261,23 @@ The rubric is not a verdict; it is a map forward.
    Score 1.0 = all files feel focused and single-purpose; functions tight; zero ceremony.
    For each gap, name what to split or delete.
 
-8.5. **Integration (0.12 — deterministic first):** wired, never orphaned. If
-   `.w2-surface-checklist.json` exists, the score IS the fraction of declared surfaces
-   verified — nav entry registered in `navigation.ts`, every inbound link present, every
-   declared SDK/MCP/CLI export wired, docs from `.w2-doc-plan.json` synced (the same greps
-   the W4 surface-layer gate runs; score = verified/declared, no judgment involved). No
-   checklist → score wired-vs-orphaned from the diff: new exports have a caller or a barrel
-   re-export, new files have an importer, no dangling route/component. The surface hard
-   gates still block independently — this score is what makes the axis compound
-   (`mark` amount + `s:integration` signal). For each gap, emit
+8.5. **Integration (0.12 — deterministic first):** wired, never orphaned. The checklist
+   is mandatory — W2 always writes `.w2-surface-checklist.json`, either the surface layers
+   or `{"surface":"none","reason":"..."}`. Three cases:
+   - **File absent → the integration gate FAILS the cycle.** Do not fall back to diff
+     heuristics — a missing checklist is exactly the cycle where W2 forgot the UI, and
+     the gate must not vanish there. Report `integration: FAIL — .w2-surface-checklist.json
+     missing` and fail the gate.
+   - **Checklist with `surface:"none"` + a `reason` string** (explicit, auditable "no
+     user-visible surface, because X") → score wired-vs-orphaned from the diff: new exports
+     have a caller or a barrel re-export, new files have an importer, no dangling
+     route/component. `surface:"none"` without a reason is also a FAIL.
+   - **Checklist with layers** → the score IS the fraction of declared surfaces
+     verified — nav entry registered in `navigation.ts`, every inbound link present, every
+     declared SDK/MCP/CLI export wired, docs from `.w2-doc-plan.json` synced (the same greps
+     the W4 surface-layer gate runs; score = verified/declared, no judgment involved).
+   The surface hard gates still block independently — this score is what makes the axis
+   compound (`mark` amount + `s:integration` signal). For each gap, emit
    `→ improve: <checklist key or file> — left unwired`.
 
 9. **Speed (0.10):** Three sub-checks, all must pass for 1.0.
@@ -235,13 +290,19 @@ The rubric is not a verdict; it is a map forward.
 
    **Token efficiency:**
    ```bash
-   # Agent/skill body line delta vs baseline
-   AGENT_LINES_NOW=$(find agents -name '*.md' 2>/dev/null | xargs wc -l 2>/dev/null | tail -1 | awk '{print $1}')
-   AGENT_LINES_W0=$(jq '.agentLines' .w0-baseline.json)
-   AGENT_DELTA=$((AGENT_LINES_NOW - AGENT_LINES_W0))
+   # Agent/skill body line delta vs baseline. The agents live at .claude/agents/ —
+   # there is no `agents/` at repo root, and a bare `find agents` errors, leaving
+   # AGENT_LINES_NOW empty and the arithmetic below broken.
+   AGENT_LINES_NOW=$(find .claude/agents .claude/skills -name '*.md' 2>/dev/null | xargs wc -l 2>/dev/null | tail -1 | awk '{print $1}')
+   AGENT_LINES_W0=$(jq -r '.agentLines // empty' .w0-baseline.json 2>/dev/null)
+   if [ -n "$AGENT_LINES_NOW" ] && [ -n "$AGENT_LINES_W0" ]; then
+     AGENT_DELTA=$((AGENT_LINES_NOW - AGENT_LINES_W0))
+   else
+     echo "agent-lines: n/a — no .w0-baseline.json agentLines to compare"
+   fi
 
    # Flag any single .md file over 300 lines (token bloat per activation)
-   find agents one.ie/web/src -name '*.md' 2>/dev/null | xargs wc -l | sort -rn | head -10
+   find .claude/agents .claude/skills one.ie/web/src -name '*.md' 2>/dev/null | xargs wc -l | sort -rn | head -10
 
    # Check for context stuffing in chat.ts — full file trees injected per request?
    git diff HEAD | grep -E '^\+.*listFiles|readdir|readdirSync' | grep -i 'prompt\|system\|context'
@@ -256,7 +317,9 @@ The rubric is not a verdict; it is a map forward.
 10. **W0 rubric delta** — read the pre-cycle baseline if present. Report the delta for each axis so the cycle shows measurable improvement, not just an absolute score.
 
 ```bash
-# Load W0 rubric baseline (written by do-rubric.py before the first cycle)
+# Load W0 rubric baseline. do-rubric.py writes text/<slug>-w0-rubric.json before the
+# first cycle; do-auto.sh copies it into the worktree as .w0-rubric.json. Read the
+# worktree copy — and if it is absent, that is `velocity: null`, not a zero delta.
 if [ -f .w0-rubric.json ]; then
   W0_SEC=$(jq -r '.scores.security'   .w0-rubric.json 2>/dev/null)
   W0_STA=$(jq -r '.scores.stability'  .w0-rubric.json 2>/dev/null)
@@ -274,7 +337,7 @@ If `.w0-rubric.json` is absent, set `velocity: null` and omit deltas.
 
 11. Composite = `0.30·goal-fit + 0.18·security + 0.18·stability + 0.12·simplicity + 0.12·integration + 0.10·speed`. Gate: composite ≥ 0.65 AND goal-fit ≥ 0.50 (hard).
 
-11. Must-not checks (bypass composite — immediate warn):
+11.5. Must-not checks (bypass composite — immediate warn):
    - Hardcoded secret or API key → `warn(1)` on security, cycle fails.
    - `eval()` or unsanitized `dangerouslySetInnerHTML` → `warn(1)`, cycle fails.
    - Test failure on W3-touched files → `warn(1)` on stability, route to W3.5.
@@ -377,16 +440,24 @@ Do NOT score 1.0 for speed without a real Lighthouse number.
 
 ### Playwright (functional + a11y verification)
 
-```bash
-# If playwright tests exist
-npx playwright test --reporter=line 2>&1 | tail -20
+Playwright runs only when the cycle declares `requires_playwright: true` (testing policy,
+`.claude/commands/do.md`). Vitest is the default; do not add a Playwright gate to a cycle
+that did not ask for one.
 
-# Quick a11y scan (axe-playwright) on touched pages — if configured
-npx playwright test tests/a11y --reporter=line
+```bash
+# Only if the cycle declares requires_playwright AND a config exists
+if [ -f playwright.config.ts ] || [ -f playwright.config.js ]; then
+  npx playwright test --reporter=line 2>&1 | tail -20
+  # a11y scan (axe-playwright) on touched pages — if that suite exists
+  [ -d tests/a11y ] && npx playwright test tests/a11y --reporter=line
+else
+  echo "playwright: n/a — no config in this folder"
+fi
 ```
 
 Playwright failures are stability failures — they join the vitest gate.
 A11y failures from playwright count against the Accessibility Lighthouse category.
+Absent config → `playwright: n/a`, never a silent pass.
 
 ### Bundle size (Speed dim)
 
@@ -394,8 +465,9 @@ A11y failures from playwright count against the Accessibility Lighthouse categor
 # Check CF Worker bundle size
 npx wrangler deploy --dry-run --outdir=.wrangler/output 2>&1 | grep -E 'Total|gzip'
 
-# Or check Astro build output
-bun run build 2>&1 | grep -E 'dist/|\.js|\.css|kB'
+# Or check Astro build output (in the package folder — no root package.json)
+FOLDER="${FOLDER:-one.ie/web}"
+( cd "$FOLDER" && bun run build ) 2>&1 | grep -E 'dist/|\.js|\.css|kB'
 
 # Delta vs W0: compare to the buildMs + sizes recorded in W0
 ```
@@ -444,24 +516,34 @@ cat > .w4-improvements.json <<EOF
   "w0_composite": W0_CMP_OR_NULL,
   "velocity": COMPOSITE_MINUS_W0_COMPOSITE_OR_NULL,
   "open": [
-    { "dim": "security",   "score": SEC,  "file": "...", "line": N, "action": "..." },
-    { "dim": "stability",  "score": STA,  "file": "...", "line": N, "action": "..." },
-    { "dim": "simplicity", "score": SIM,  "file": "...", "line": N, "action": "..." },
-    { "dim": "speed",      "score": SPD,  "audit": "...", "component": "...", "action": "..." }
+    { "dim": "goal-fit",    "score": GOA,  "action": "<what the goal still needs>" },
+    { "dim": "security",    "score": SEC,  "file": "...", "line": N, "action": "..." },
+    { "dim": "stability",   "score": STA,  "file": "...", "line": N, "action": "..." },
+    { "dim": "simplicity",  "score": SIM,  "file": "...", "line": N, "action": "..." },
+    { "dim": "integration", "score": INT,  "checklist_key": "...", "action": "..." },
+    { "dim": "speed",       "score": SPD,  "audit": "...", "component": "...", "action": "..." }
   ]
 }
 EOF
-# Omit any dim with score 1.00 from "open" — those are clean.
+# All six scored dims appear here. Omit any dim with score 1.00 from "open" — those are
+# clean. Never omit a dim because you did not score it; an unscored dim is a fail on
+# that dim (Rule 3).
 
 # b) Human-readable history: feeds pattern detection and learning
 cat >> docs/improvements.md <<EOF
 
 ## $(date -u +%Y-%m-%d) · cycle N · composite=COMPOSITE (Δ VELOCITY)
-- security/SEC:   IMPROVE_LINE_OR_clean
-- stability/STA:  IMPROVE_LINE_OR_clean
-- simplicity/SIM: IMPROVE_LINE_OR_clean
-- speed/SPD:      IMPROVE_LINE_OR_clean
+- goal-fit/GOA:    IMPROVE_LINE_OR_clean
+- security/SEC:    IMPROVE_LINE_OR_clean
+- stability/STA:   IMPROVE_LINE_OR_clean
+- simplicity/SIM:  IMPROVE_LINE_OR_clean
+- integration/INT: IMPROVE_LINE_OR_clean
+- speed/SPD:       IMPROVE_LINE_OR_clean
 EOF
+
+# c) Shrink the improvements queue: delete every line this cycle actually resolved.
+#    The queue shrinks or the loop is hoarding (.claude/commands/do.md § W1).
+#    Delete only what you verified fixed — never a line you merely read.
 ```
 
 **Systemic gap detection** — after writing, check for patterns:
@@ -490,11 +572,19 @@ the substrate — this file is structurally weak and should be prioritized in fu
 
 ## Known-flaky allowlist
 
-Tests matching patterns in `scripts/deploy.ts` `KNOWN_FLAKY` are stochastic (timing, network). They do NOT fail the gate — report them as `flaky=N` in the receipt and continue. See memory `feedback_timing_tests.md`.
+A test that is stochastic by construction — hardware-timing benchmarks, network reachability,
+sampling/distribution tests — does NOT fail the gate. Report it as `flaky=N` in the receipt,
+name each one, and continue. Judge stochasticity from the test itself; there is no
+`KNOWN_FLAKY` allowlist in this repo (the one the older prompt cited, in `scripts/deploy.ts`,
+no longer exists — do not cite a file you have not read). A test that fails deterministically
+on re-run is not flaky: it is a stability failure and routes to W3.5.
 
 ## TypeScript crash handling
 
-`tsc` 5.9 has a known stack-overflow bug — see memory `feedback_typecheck_crash.md`. If `tsc` crashes WITHOUT a real `TS####` error line, treat as pass. Fall through to `scripts/typecheck.sh` if it exists.
+If `tsc` crashes (stack overflow, internal error) WITHOUT emitting a real `TS####` error
+line, treat it as pass and report `tsc: crashed — no TS#### emitted, treated as pass`.
+A crash that DOES emit `TS####` lines is a normal failure. Re-run once before either
+verdict.
 
 ## Completion signal
 
@@ -508,11 +598,12 @@ Success:
     "content": {
       "passed": N, "failed": 0,
       "rubric": {
-        "goal-fit":   { "score": 0.90, "improve": "clean" },
-        "security":   { "score": 0.95, "improve": "src/pages/api/provision.ts:31 — missing Zod parse on slug" },
-        "stability":  { "score": 1.00, "improve": "clean" },
-        "simplicity": { "score": 0.85, "improve": "inline formatDate() at src/lib/slug.ts:12, saves 9 lines" },
-        "speed":      { "score": 0.80, "improve": "EvalCard client:load → client:visible; Lighthouse Perf 97" }
+        "goal-fit":    { "score": 0.90, "improve": "clean" },
+        "security":    { "score": 0.95, "improve": "src/pages/api/provision.ts:31 — missing Zod parse on slug" },
+        "stability":   { "score": 1.00, "improve": "clean" },
+        "simplicity":  { "score": 0.85, "improve": "inline formatDate() at src/lib/slug.ts:12, saves 9 lines" },
+        "integration": { "score": 1.00, "improve": "clean" },
+        "speed":       { "score": 0.80, "improve": "EvalCard client:load → client:visible; Lighthouse Perf 97" }
       },
       "composite": 0.91,
       "velocity": +0.06,
@@ -537,11 +628,12 @@ Failure:
       "passed": N, "failed": M,
       "failures": ["<test name or tsc error>"],
       "rubric": {
-        "goal-fit":   { "score": 0.40, "improve": "diff does not advance plan outcome — goal still needs <X>" },
-        "security":   { "score": 0.50, "improve": "src/pages/api/chat.ts:23 — missing Zod parse on body.slug" },
-        "stability":  { "score": 0.00, "improve": "vitest: chat renders message FAILED — type mismatch line 14" },
-        "simplicity": { "score": 0.60, "improve": "parseMarkdown() 18 lines, one caller — inline and delete" },
-        "speed":      { "score": 0.50, "improve": "Lighthouse Perf 94 — unused JS from lodash import in slug.ts" }
+        "goal-fit":    { "score": 0.40, "improve": "diff does not advance plan outcome — goal still needs <X>" },
+        "security":    { "score": 0.50, "improve": "src/pages/api/chat.ts:23 — missing Zod parse on body.slug" },
+        "stability":   { "score": 0.00, "improve": "vitest: chat renders message FAILED — type mismatch line 14" },
+        "simplicity":  { "score": 0.60, "improve": "parseMarkdown() 18 lines, one caller — inline and delete" },
+        "integration": { "score": 0.50, "improve": "surfaces[0].nav_entry — /u/[slug]/new left unwired" },
+        "speed":       { "score": 0.50, "improve": "Lighthouse Perf 94 — unused JS from lodash import in slug.ts" }
       },
       "composite": 0.34,
       "velocity": -0.12,
@@ -553,7 +645,10 @@ Failure:
 }
 ```
 
-`velocity` = this cycle's composite minus the previous cycle's composite (read from `docs/improvements.md`).
+`velocity` = this cycle's composite minus the **W0 baseline** composite from
+`.w0-rubric.json` (step 10) — one definition, used everywhere. If `.w0-rubric.json` is
+absent, `velocity` is `null` — report the prior cycle's composite from
+`docs/improvements.md` as prose context if it helps, never as the `velocity` field.
 Positive velocity = the system is improving. Negative = something regressed.
 Pheromone compounds the velocity signal: `mark(edge, composite)` every cycle → paths that
 consistently score high get strong; paths that keep failing accumulate resistance.

package/commands/browser.md

@@ -1,55 +1,118 @@
-# /browser — Playwright browser diagnostic
+# /browser — headless-shell browser driver
 
-Runs a headless Chrome check against a URL and reports page health, JS errors, and chat behaviour.
+Drives **chrome-headless-shell** against a URL and reports page health, JS errors, network, and anything you tell it to click, fill, or evaluate.
+
+This replaced the `claude-in-chrome` MCP tools. No extension, no Chrome profile, no desktop browser, no human in the loop — one process per invocation, one JSON report on stdout.
 
 ## Usage
 
+```bash
+node .claude/scripts/chrome.mjs <url> [flags]
 ```
-/browser [url] [--send "message"] [--screenshot] [--network]
+
+Default url: `http://localhost:4321`.
+
+## Flags
+
+| Flag | Does |
+|---|---|
+| `--text` | page `innerText` (truncate at `--max`, default 4000) |
+| `--html` | page HTML |
+| `--sel <css>` | scope `--text`/`--html` to a selector |
+| `--screenshot [path]` | PNG, default `/tmp/chrome-shot.png`; add `--full-page` for the whole document |
+| `--console` | every console line (errors are always reported) |
+| `--network` | responses to `/api/*`; `--network-all` widens it to everything |
+| `--eval <js>` | evaluate an expression in the page, return its value |
+| `--do <json>` | run a step list — see below |
+| `--send <msg>` | chat drill: fill the first textarea, press Enter, capture the SSE stream |
+| `--send-wait <ms>` | how long to hold open after `--send` (default 12000) |
+| `--wait <ms>` | settle time after load (default 2500) |
+| `--timeout <ms>` | navigation timeout (default 20000) |
+| `--state <path>` | persist cookies + localStorage to `<path>` and reuse them next run |
+| `--cookie <n=v>` | cookie for the target host (repeatable) |
+| `--header <k: v>` | extra HTTP header (repeatable) |
+| `--ua <string>` · `--viewport <WxH>` | user agent · viewport (default 1280x800) |
+| `--headed` | full Chromium with a visible window instead of the shell |
+| `--max <n>` | truncation ceiling for text/html/eval |
+
+`PROVE_SESSION_COOKIE="name=value"` is honoured the same way as before, so an auth-gated `/u/[slug]/*` route can be proven signed-in.
+
+## Steps (`--do`)
+
+A JSON array executed in order. Each entry is one object; every step reports `{step, kind, ok, error?, result?}` and a failed step does **not** abort the run.
+
+```json
+[
+  {"goto": "http://localhost:4321/login"},
+  {"fill": "input[type=email]", "value": "tony@one.ie"},
+  {"click": "button[type=submit]"},
+  {"waitFor": ".dashboard"},
+  {"eval": "document.querySelectorAll('[data-row]').length"},
+  {"screenshot": "/tmp/after-login.png"}
+]
 ```
 
-**Arguments (all optional):**
-- `url` — page to check (default: `http://localhost:4321`)
-- `--send "text"` — type and submit a chat message, then compare rail before/after
-- `--screenshot` — save `/tmp/browser-check.png`
-- `--network` — capture API request list
+Kinds: `goto` · `click` · `dblclick` · `hover` · `fill`+`value` · `press`(+`sel`) · `select`+`value` · `check`(+`value:false` to uncheck) · `upload`+`files` · `scroll` (px, or a selector to bring into view) · `wait` (ms) · `waitFor` (selector) · `eval` · `screenshot`.
+
+## Sessions
 
-## How to invoke
+Each invocation is a fresh browser — that is the trade for having no extension. `--state` is how a session survives it:
 
 ```bash
-node .claude/scripts/browser-check.mjs http://localhost:4321/studio/boq-empire?agent=boq-empire --send "hello" --screenshot
-```
+# sign in once, keep the session
+node .claude/scripts/chrome.mjs http://localhost:4321/login --state /tmp/one.json \
+  --do '[{"fill":"#email","value":"tony@one.ie"},{"click":"button[type=submit]"},{"waitFor":".dashboard"}]'
 
-Or directly in conversation — Claude runs the script via Bash.
+# every later run reuses it
+node .claude/scripts/chrome.mjs http://localhost:4321/u/one/in --state /tmp/one.json --text
+```
 
-## What it checks
+The report carries `stateLoaded` (was the file read) and `stateSaved` (where it was written). Without `--state`, cookies and localStorage die with the process — put the whole flow in one `--do` list instead.
 
-| Check | How |
-|---|---|
-| HTTP status | `page.goto` response code |
-| Title | `page.title()` |
-| JS errors | `pageerror` events |
-| Console errors | `console.error` events |
-| Chat rail (before send) | `.chat-rail` innerText |
-| Chat POST body | fetch monkey-patch captures `agentId`, `slug`, messages |
-| Stream content | Reads cloned SSE stream; shows first 800 chars |
-| Chat rail (after send) | After 12s wait post-submit |
+`file://` URLs work, so a local fixture is a valid target.
 
-## Prerequisites
+## Examples
 
-Playwright installed once:
 ```bash
-cd /tmp && npm install playwright && npx playwright install chromium
+# health check one route
+node .claude/scripts/chrome.mjs http://localhost:4321/pricing --console --network
+
+# read a page
+node .claude/scripts/chrome.mjs https://one.ie --text --sel main --max 8000
+
+# drill a form and shoot the result
+node .claude/scripts/chrome.mjs http://localhost:4321/contact \
+  --do '[{"fill":"#email","value":"a@b.c"},{"click":"button[type=submit]"},{"wait":2000}]' \
+  --screenshot /tmp/contact.png
+
+# chat diagnostic (the old browser-check job)
+node .claude/scripts/chrome.mjs "http://localhost:4321/studio/boq-empire?agent=boq-empire" --send "hello"
 ```
 
-Check with: `node -e "require('/tmp/node_modules/playwright'); console.log('ok')"`
+## Report fields
+
+`url` · `finalUrl` · `engine` · `playwrightFrom` · `httpStatus` · `navError` · `title` · `jsErrors` · `consoleErrors` · `console?` · `network?` · `steps?` · `chatCapture?` · `chatRailBefore?` · `chatRailAfter?` · `text?` · `html?` · `eval?` · `screenshot?`
+
+Exit **0** = the run completed (read `httpStatus` and `jsErrors` for the verdict). Exit **1** = the browser could not run at all, and stderr carries `{"error": …, "fix": …}`.
+
+## Prerequisites
+
+None to install by hand. chrome-headless-shell ships with the repo's Playwright and the script finds it:
+
+1. `ONE_PLAYWRIGHT_DIR` if set
+2. `one.ie/web/node_modules` then `node_modules`, in this tree **and** in the main worktree (via `git rev-parse --git-common-dir`) — a linked worktree has no `node_modules` of its own
+3. `/tmp/node_modules` (legacy)
+
+If none resolve it exits 1 with the fix: `cd one.ie/web && bun install && bunx playwright install chromium-headless-shell`. If the shell channel is missing it falls back to plain headless Chromium.
+
+## Who calls it
+
+| Caller | How |
+|---|---|
+| `do-prove.sh` | every `--route` check — reads `httpStatus`, `jsErrors`, `consoleErrors`; curl is the fallback when the browser can't run. A route fails on 404, ≥500, an uncaught JS error, or a console error; subresource **401/403 are tolerated** (PROVE runs signed-out, so gated is not broken) — the same policy the curl leg already applied |
+| `browser-check.mjs` | deprecated shim, maps old flags onto `chrome.mjs` and renames fields back |
+| you | directly, via Bash |
 
-## Output
+## What it is not
 
-JSON report to stdout. Key fields:
-- `httpStatus` — 200/404/500
-- `jsErrors` — uncaught JS exceptions
-- `consoleErrors` — console.error calls
-- `chatRailBefore` / `chatRailAfter` — visible text
-- `chatCapture[].body` — POST body (check `agentId` present)
-- `chatCapture[].stream` — SSE response (check for error vs real tokens)
+Not a hand on the operator's own logged-in Chrome. It has no profile, no session, and no visible surface for a human to approve an action on. Jobs that need those — `.claude/skills/directory-autofill` is the one in this repo — are **not** served by this script.

package/commands/cc-connect.md

@@ -20,11 +20,17 @@ Three spaces wired by default:
 /cc-connect broadcast "text"         # fan out — all space:* groups at once
 /cc-connect listen                   # start SSE listeners for all subscribed spaces
 /cc-connect stop                     # kill all listeners
+/cc-connect stop space:vespio        # kill just one listener
 /cc-connect status                   # listener PIDs + unread counts per space
+/cc-connect listeners                # list every running listener PID
+/cc-connect groups                   # ask channels which groups exist (discovery)
 /cc-connect join space:X             # subscribe + start listener for a new space
 /cc-connect leave space:X            # unsubscribe + stop listener
 ```
 
+`read` with no group reads your default space; `read <group>` reads one named
+space. Requires `bash`, `curl`, and `jq` on PATH.
+
 **→ Use `/chat` for the simple two-key interface: read = fan in, send = fan out.**
 
 ## How to invoke

package/commands/chat.md

@@ -32,4 +32,16 @@ Want a desktop popup when something lands? `brew install terminal-notifier` (one
 
 ## Advanced (raw commands, rarely needed)
 
-`/chat` is a shortcut for `.claude/scripts/cc-connect.sh`. Reach for the raw form only when you need something `/chat` doesn't expose — joining a new space, checking listener status, reading offline history. See `/cc-connect` for the full surface.
+`/chat` is a shortcut for `.claude/scripts/cc-connect.sh`. The three moves map exactly:
+
+| `/chat` form | runs |
+|---|---|
+| `/chat` | `.claude/scripts/cc-connect.sh read --all` |
+| `/chat "text"` | `.claude/scripts/cc-connect.sh broadcast "text"` |
+| `/chat @vespio "text"` | `.claude/scripts/cc-connect.sh send --to space:vespio "text"` |
+
+`@name` is `/chat` sugar — cc-connect itself wants the full `space:name`.
+Send fans out via `broadcast`, not `send`: `send` with no `--to` hits only your
+default space, which is not what `/chat "text"` promises.
+
+Reach for the raw form only when you need something `/chat` doesn't expose — joining a new space, checking listener status, reading offline history. See `/cc-connect` for the full surface.