@ionivetech/mugiwara 0.8.0 → 0.8.1

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "mugiwara",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, healing.",
   "contextFileName": "GEMINI.md"
 }

package/hooks/mugiwara-mode-tracker.js

@@ -54,12 +54,22 @@ function applyModeChange(mode) {
   writeFileSync(tmp, body);
   renameSync(tmp, file);
 }
+function isCodexInput(parsed) {
+  if (process.env.CODEX_HOME || process.env.CODEX_THREAD_ID)
+    return true;
+  if (typeof parsed.turn_id === "string")
+    return true;
+  if (typeof parsed.cwd === "string" && typeof parsed.model === "string")
+    return true;
+  return false;
+}
 async function main() {
   let input = "";
   for await (const chunk of process.stdin)
     input += chunk;
   if (!input.trim()) {
-    process.stdout.write(JSON.stringify({ prompt: "" }));
+    const codexEmpty = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID);
+    process.stdout.write(JSON.stringify(codexEmpty ? {} : { prompt: "" }));
     return;
   }
   let parsed;
@@ -68,12 +78,22 @@ async function main() {
   } catch {
     parsed = { prompt: input };
   }
-  const prompt = parsed.prompt ?? "";
+  const prompt = typeof parsed.prompt === "string" ? parsed.prompt : "";
   const change = parseModeChange(prompt);
   if (change)
     applyModeChange(change);
-  process.stdout.write(JSON.stringify({ prompt }));
+  const codex = isCodexInput(parsed);
+  if (codex) {
+    if (change) {
+      process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: `Mugiwara mode changed to ${change}` } }));
+    } else {
+      process.stdout.write(JSON.stringify({}));
+    }
+  } else {
+    process.stdout.write(JSON.stringify({ prompt }));
+  }
 }
 main().catch(() => {
-  process.stdout.write(JSON.stringify({ prompt: "" }));
+  const codexFallback = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID);
+  process.stdout.write(JSON.stringify(codexFallback ? {} : { prompt: "" }));
 });

package/hooks/mugiwara-mode-tracker.ts

@@ -57,24 +57,53 @@ function applyModeChange(mode: string) {
   renameSync(tmp, file);
 }
 
+// Codex vs Claude: Codex UserPromptSubmit expects {} or {hookSpecificOutput:{hookEventName,additionalContext}}
+// Claude expects {prompt:""} — Codex rejects "prompt" (additionalProperties:false).
+// Detect Codex via env or input shape (turn_id/cwd/model are Codex-only).
+function isCodexInput(parsed: Record<string, unknown>): boolean {
+  if (process.env.CODEX_HOME || process.env.CODEX_THREAD_ID) return true;
+  if (typeof parsed.turn_id === 'string') return true;
+  if (typeof parsed.cwd === 'string' && typeof parsed.model === 'string') return true;
+  return false;
+}
+
 // main
 async function main() {
   let input = '';
   for await (const chunk of process.stdin) input += chunk;
-  if (!input.trim()) { process.stdout.write(JSON.stringify({ prompt: '' })); return; }
+  if (!input.trim()) {
+    // empty stdin — Codex expects {}, Claude expects {prompt:""}
+    // Emit Codex-safe empty ( {} ) — Claude also accepts {} as no-op (prompt passthrough)
+    // but to keep Claude behavior, sniff env: if Codex-like env, emit {}, else prompt
+    const codexEmpty = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID);
+    process.stdout.write(JSON.stringify(codexEmpty ? {} : { prompt: '' }));
+    return;
+  }
 
-  let parsed: { prompt?: string };
-  try { parsed = JSON.parse(input); } catch { parsed = { prompt: input }; }
-  const prompt = parsed.prompt ?? '';
+  let parsed: Record<string, unknown>;
+  try { parsed = JSON.parse(input) as Record<string, unknown>; } catch { parsed = { prompt: input }; }
+  const prompt = typeof parsed.prompt === 'string' ? parsed.prompt : '';
 
   const change = parseModeChange(prompt);
   if (change) applyModeChange(change);
 
-  // pass-through — always return the prompt unchanged
-  process.stdout.write(JSON.stringify({ prompt }));
+  const codex = isCodexInput(parsed);
+  if (codex) {
+    // Codex schema: additionalProperties:false — "prompt" is invalid. Use hookSpecificOutput or {}.
+    if (change) {
+      process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: `Mugiwara mode changed to ${change}` } }));
+    } else {
+      process.stdout.write(JSON.stringify({}));
+    }
+  } else {
+    // Claude: pass-through prompt
+    process.stdout.write(JSON.stringify({ prompt }));
+  }
 }
 
 main().catch(() => {
   // silent — hook must never block the conversation
-  process.stdout.write(JSON.stringify({ prompt: '' }));
+  // Codex-safe fallback: {} (valid for both, but Claude prefers prompt — however {} is also accepted as no-op)
+  const codexFallback = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID);
+  process.stdout.write(JSON.stringify(codexFallback ? {} : { prompt: '' }));
 });

package/hooks/session-start.js

@@ -104,6 +104,11 @@ if (active.length === 1 && mode === "auto") {
 ${lines}
 ` + `Run /mugiwara continue <mission> [member] to resume one explicitly.`;
 }
+var isCodexSession = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID || process.env.CODEX_HOME_DIR);
 if (resumeContext) {
-  console.log(JSON.stringify({ additionalContext: resumeContext }));
+  if (isCodexSession) {
+    console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: resumeContext } }));
+  } else {
+    console.log(JSON.stringify({ additionalContext: resumeContext }));
+  }
 }

package/hooks/session-start.ts

@@ -131,6 +131,13 @@ if (active.length === 1 && mode === 'auto') {
 
 // Silent unless there is in-flight work: a session that never used mugiwara
 // gets zero injected context.
+// Codex vs Claude: Codex SessionStart expects {hookSpecificOutput:{hookEventName,additionalContext}}
+// Claude expects {additionalContext} — Codex rejects top-level additionalContext (additionalProperties:false).
+const isCodexSession = !!(process.env.CODEX_HOME || process.env.CODEX_THREAD_ID || process.env.CODEX_HOME_DIR);
 if (resumeContext) {
-  console.log(JSON.stringify({ additionalContext: resumeContext }));
+  if (isCodexSession) {
+    console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: resumeContext } }));
+  } else {
+    console.log(JSON.stringify({ additionalContext: resumeContext }));
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ionivetech/mugiwara",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, self-healing. Installs into Claude Code, opencode, Copilot, Gemini, Codex, Cursor, Kimi, pi, Windsurf, Cline, Kilo, Antigravity.",
   "homepage": "https://github.com/ionivetech/mugiwara#readme",
   "repository": {
@@ -63,7 +63,7 @@
     "sync-version": "bun scripts/sync-version.ts",
     "build-hooks": "bun scripts/build-hooks.ts",
     "build-hooks:check": "bun scripts/build-hooks.ts --check",
-    "gate": "bun run build-hooks:check && bun run typecheck && bun run test:coverage && bun run build && bun scripts/validate-content.ts --check-manifest --check-docs --check-doc-integrity && bun scripts/lane-base.ts && bun scripts/check-doc-links.ts && bun run verify-pack && bun scripts/run-evals.ts && bun scripts/retrieval-eval.ts && bun scripts/benchmark-governor.ts && bun scripts/verify-install.ts && bun scripts/conformance.ts && bun run coverage-gate",
+    "gate": "bun run build-hooks:check && bun run typecheck && bun run test:coverage && bun run build && bun scripts/write-metrics.ts && bun scripts/validate-content.ts --check-manifest --check-docs --check-doc-integrity --check-readme-metrics && bun scripts/lane-base.ts && bun scripts/check-doc-links.ts && bun run verify-pack && bun scripts/run-evals.ts && bun scripts/retrieval-eval.ts && bun scripts/benchmark-governor.ts && bun scripts/verify-install.ts && bun scripts/conformance.ts && bun run coverage-gate",
     "verify-pack": "npm pack --dry-run 2>&1 | node -e \"let s='';process.stdin.on('data',d=>s+=d);process.stdin.on('end',()=>{if(!s.includes('ionivetech-mugiwara')){console.error('npm pack failed');process.exit(1)};console.log('npm package clean')})\"",
     "prepack": "bun run build && bun run sync-version"
   },

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mugiwara",
   "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, healing.",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "author": {
     "name": "ionivetech"
   },

package/references/cost-governor.md

@@ -0,0 +1,104 @@
+# Cost Governor — Terse & Low-Cost Execution
+
+Single source for Work, Scope/Code, Cognitive/Output, Stop-Slop, Adaptive Budget, Benchmark. Verdicts recommended, not enforced; crew acts. Trail rows → `.mugiwara/missions/<mission>/decisions.md` → `## Cost governor decisions`. `savepoint`/`lane-base`/`config` untouched.
+
+## Ladder — before adding code, run top to bottom, stop at first that holds
+
+1. Does this need to exist at all? Speculative need → skip, one line why (YAGNI).
+2. Already in codebase? Reuse helper/util/pattern nearby → reuse it.
+3. Stdlib does it? Use it.
+4. Native platform covers it? `<input type="date">` over picker lib, CSS over JS, DB constraint over app code → native.
+5. Already-installed dependency solves it? Use it. Never add new dep for a few lines.
+6. Can it be one line? One line.
+7. Only then: minimum code that works. No unrequested abstraction (one impl → no interface/factory/config), no boilerplate for later, deletion over addition, fewest files, shortest diff.
+
+Each step: grep callers first; fix root cause in shared function, not symptom in caller. One guard in shared path beats guards in every caller.
+
+## Output — terse, deduped
+
+Reasoning: Question → Evidence → Decision → Action. No speculative architecture, hypothetical requirements, repeated reconsideration, unrelated implementations. Investigation ends when `acceptance_mapped + surface_understood + path_established` or limits hit with concrete reason (§13). Alternatives ≤3, evidence-backed only.
+
+Output: Decision / Action / Result / Evidence / Blocker only, mission-focused. Duplicate explanations fingerprinted and dropped. Every verdict → `cognitive-governor` trail row.
+
+## Scope & code
+
+Prefer smallest correct scope — reuse + local modification over new architecture (§14). Abstraction justified only when used in ≥2 places or required by contract, never speculative (§15). Dependency added only with explicit justification (§16). Minimum sufficient implementation, never minimum LOC at expense of verification/quality (§15/§38). Measure change surface. Code waste (unnecessary helper/abstraction/wrapper/interface/config/dependency/generated code/refactor) named. Trail row `scope-governor`.
+
+## Slop — taxonomy, signals, measurement, intervention
+
+Taxonomy 8 kinds (§21): investigation, context, reasoning, output, code, retry, healing, scope.
+
+Signals (§22): repeated reads/commands, token-without-evidence, LOC-without-acceptance, abstraction-without-justification.
+
+Measure (§23): evidence/criteria/tests/code vs cost delta — cost grows without progress → slop. Flag anomaly (§24): 5k tokens zero progress, work-to-cost drop.
+
+Intervene (§20): tolerate / stop / compress / escalate by severity.
+
+Detectors — six categories:
+- retry §21.6/§31 same-action same-evidence same-failure → STOP
+- healing §21.7/§32 no progress → stop; `heal_cycle ≥ 3` → halt
+- scope §21.8 out-of-scope without acceptance → reject
+- context §21.2 duplicate/irrelevant → discard/compress
+- investigation §21.1 unbounded exploration → stop
+- code §21.5 unnecessary abstraction/dependency/boilerplate → remove/simplify
+
+Trail row `slop-governor`.
+
+## Budget — reserve, projection, thresholds, breaker
+
+Reserve expected max before expensive stages (Review/Security/Healing). Continuously project `current + remaining required + expected conditional + possible healing` (§26).
+
+Expand only with evidence (§27 valid: scope legitimately expanded, security-sensitive path, test surface larger, architecture dependency, legitimate healing; invalid: verbosity/reread/repeat/unnecessary code).
+
+Thresholds (§28): 60% → optimize, 75% → aggressive, 90% → protect, 100% → pause, 150% → warning, 300% → stop.
+
+Breaker (§29): actual ≥ 2× expected without progress/scope/evidence → trip.
+
+Anomaly (§24): flag 5k-zero-progress, re-consumes slop signal.
+
+Record every non-ok verdict via `recordBudgetDecision` (§41). Trail row `budget-governor`. Ledger aggregates envelope+events+registry+trail; `mugiwara cost` surfaces ledger (--json); report Cost section renders ledger+avoided+efficiency+trail (§43).
+
+## Benchmark & hardening
+
+Tracks `scripts/benchmark-governor.ts` harness (deterministic, no network).
+
+Cost suite (§48) — 4 workloads:
+- lean-trivial: projected 8000 + overhead 1000, context ≤20000, evidence ≥1, surface 2 files 50 LOC
+- standard-feature: projected 15000 + overhead 1500, context ≤40000, evidence ≥3
+- large-repo: projected 22000 + overhead 2200, context ≤80000, evidence ≥5, surface 50 files
+- long-mission: projected 23000 + overhead 2300, context ≤90000, 9 stages projection ≤ budget
+Check: `measured.tokens ≤ projected + overhead` else fail; `measured.context ≤ max` else fail
+
+Stop-Slop suite (§45) — 12 scenarios detect→classify→intervene:
+- endless-exploration → investigation slop → stop
+- repeated-reads (3× no evidence) → context slop → stop; with concrete reason → tolerate
+- repeated-commands (same cmd+evidence fail) → retry slop → stop
+- repeated-failed-test → retry slop → stop
+- repeated-reasoning → reasoning slop → stop
+- unnecessary-abstraction → code slop → stop
+- unnecessary-dependency → code slop → stop
+- unrelated-refactor → scope slop → stop
+- verbose-output → output slop → stop
+- no-progress-healing (cycle ≥3, 0 fixes) → healing slop → stop
+- premature-completion → scope slop → escalate
+- excessive-context (repeated reads + duplicate chars) → context slop → stop
+
+Stress (bench-only, no runtime): large repository 50 files within scope → pass; long mission 9 stages projection ≤ full budget → pass; runaway 2× expected no progress → breaker tripped.
+
+Thresholds live in `scripts/benchmark-thresholds.json` (or THRESHOLDS const) — `tokens > projected+overhead` fail, `context > max` fail, only move on explicit fixture update, ratchet like retrieval-eval. Regression (§49): cost down but correctness/evidence/security/quality/scope down → fail. Determinism: harness pure over explicit fixture inputs, no Date.now/Math.random/network. CI: `package.json:gate` includes harness; `gate-selftest` tampers thresholds → harness must exit 1. Harness measures, not enforces.
+
+## Reporting & trail
+
+Ledger aggregates envelope+events+registry+trail; `mugiwara cost` surfaces ledger; report Cost section renders ledger+avoided+efficiency+trail (§43). Every verdict lands as trail row in decisions.md.
+
+## Checklist
+
+- [ ] ladder run before each code addition, no skipped rung
+- [ ] output Decision/Action/Result/Evidence/Blocker, deduped
+- [ ] scope/code: reuse checked, abstraction & dep justified
+- [ ] slop: taxonomy classified, signals measured, intervention applied
+- [ ] budget: reserved, projected, thresholds respected, breaker armed
+- [ ] benchmark: 4 cost + 12 slop + 3 stress green, thresholds ratcheted
+- [ ] trail rows written for every non-trivial verdict
+
+Unchecked boxes are not done.

package/references/wave-banners.md

@@ -53,8 +53,7 @@ their banners appear only when a wave or worker names them.
 
 ## Rules
 
-1. Banner before EVERY flow stage; handoff after it. No flow stage starts without its
-   banner (orchestration red flag).
+1. Banner before EVERY flow stage; handoff after it. Main thread emits `===== FLOW N — CREW =====` FIRST line and `→ Flow N+1 — Crew` LAST line even when subagent does work — covers Flow 0 Luffy, 1 Usopp, 2 Nami, 3 Zoro, 4 Chopper, 5 Sanji, 6 Franky, 7 Robin/Jinbe, 8 Brook, 9 Luffy. No flow stage starts without its banner (orchestration red flag).
 2. The color comes from this table only — never invent a hex mid-mission.
 3. One form everywhere: equals line `===== <emoji> FLOW N — <CREW> (ROLE) =====` — five `=` per side, the crew emoji from the table leading the line, ANSI-wrapped in terminals, plain in markdown-rendering UIs. When unsure, the plain form is safe everywhere.
 4. Only the crew table's colors and the two SGR forms above (truecolor,

package/scripts/gate-selftest.ts

@@ -6,6 +6,8 @@ import { execSync } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync, copyFileSync, renameSync, unlinkSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { tmpdir } from 'node:os';
+import { gatesForLane } from '../src/policy.ts';
+import { budgetForLane } from '../src/cost.ts';
 
 const root = join(import.meta.dirname, '..');
 let passed = 0;
@@ -91,9 +93,11 @@ console.log('\nCost gate — measured vs stated index chars');
   const costFile = join(root, 'docs', 'concepts', 'cost.md');
   const original = readFileSync(costFile, 'utf8');
   try {
-    const drifted = original.replace(/\*\*Current:\*\* \d[\d,]* chars/, '**Current:** 1 chars');
-    if (drifted === original) {
-      console.log('  ⚠  "**Current:** N chars" pattern not found in cost.md — skipping');
+    const costPattern = /\*\*Current:\*\* \d[\d,]* chars/;
+    const drifted = original.replace(costPattern, '**Current:** 1 chars');
+    if (!costPattern.test(original) || drifted === original) {
+      console.error('✗ COST: mutation target not found — the gate it guards may be dead.');
+      failed++;
     } else {
       writeFileSync(costFile, drifted);
       assert('drifted stated index chars → exit 1', false, () => run('COST', 'bun scripts/validate-content.ts'));
@@ -134,12 +138,14 @@ if (!existsSync(savepointFile)) {
   const original = readFileSync(savepointFile, 'utf8');
   try {
     // reintroduce the D1 defect: read lane_prev with require() of a relative path
+    const d1Pattern = /PREV_JSON=\$\(node -e "try\{const fs=require\('fs'\);const s=JSON\.parse\(fs\.readFileSync\(process\.argv\[1\],'utf8'\)\);process\.stdout\.write\(JSON\.stringify\(\{mission:s\.mission\|\|'',lane:s\.lane\|\|'',peak:s\.lane_peak\|\|''\}\)\)\}catch\(e\)\{process\.stdout\.write\('\{\}'\)\}" "\$STATE_FILE" 2>\/dev\/null \|\| true\)/;
     const broken = original.replace(
-      /PREV_JSON=\$\(node -e "try\{const fs=require\('fs'\);const s=JSON\.parse\(fs\.readFileSync\(process\.argv\[1\],'utf8'\)\);process\.stdout\.write\(JSON\.stringify\(\{mission:s\.mission\|\|'',lane:s\.lane\|\|'',peak:s\.lane_peak\|\|''\}\)\)\}catch\(e\)\{process\.stdout\.write\('\{\}'\)\}" "\$STATE_FILE" 2>\/dev\/null \|\| true\)/,
+      d1Pattern,
       "PREV_JSON=$(node -e \"try{const s=require(process.argv[1]);process.stdout.write(JSON.stringify({mission:s.mission||'',lane:s.lane||'',peak:s.lane_peak||''}))}catch(e){process.stdout.write('{}')}\" \"$STATE_FILE\" 2>/dev/null || true)"
     );
-    if (broken === original) {
-      console.log('  ⚠  D1 mutation pattern not found — skipping');
+    if (!d1Pattern.test(original) || broken === original) {
+      console.error('✗ D1: mutation target not found — the gate it guards may be dead.');
+      failed++;
     } else {
       writeFileSync(savepointFile, broken);
       assert('broken LANE_PREV resolve → lane-integrity fails', false, () => run('D1', 'bun run test -- lane-integrity -t "lane_prev"'));
@@ -158,12 +164,14 @@ if (!existsSync(savepointFile)) {
   const original = readFileSync(savepointFile, 'utf8');
   try {
     // neuter the clamp: make lane_rank always return 0 so a drop never holds
+    const d2Pattern = /lane_rank\(\) \{\n  case "\$1" in\n    direct\) echo 0 ;;[\s\S]*?\n  esac\n\}/;
     const broken = original.replace(
-      /lane_rank\(\) \{\n  case "\$1" in\n    direct\) echo 0 ;;[\s\S]*?\n  esac\n\}/,
+      d2Pattern,
       'lane_rank() {\n  echo 0\n}'
     );
-    if (broken === original) {
-      console.log('  ⚠  D2 mutation pattern not found — skipping');
+    if (!d2Pattern.test(original) || broken === original) {
+      console.error('✗ D2: mutation target not found — the gate it guards may be dead.');
+      failed++;
     } else {
       writeFileSync(savepointFile, broken);
       assert('broken clamp → lane-integrity fails', false, () => run('D2', 'bun run test -- lane-integrity -t "clamp"'));
@@ -183,12 +191,14 @@ if (!existsSync(patternsFile)) {
   const original = readFileSync(patternsFile, 'utf8');
   try {
     // reintroduce the D3 defect: singular-only list (no payments/, migrations/)
+    const d3Pattern = /SENSITIVE_PATS=.*/;
     const broken = original.replace(
-      /SENSITIVE_PATS=.*/,
+      d3Pattern,
       'SENSITIVE_PATS="auth/|payment/|billing/|crypto/|secrets/|\\.env$|config/.*key|migration/|\\.sql$|schema\\.|\\.prisma$|\\.terraform|\\.tf$"'
     );
-    if (broken === original) {
-      console.log('  ⚠  D3 mutation pattern not found — skipping');
+    if (!d3Pattern.test(original) || broken === original) {
+      console.error('✗ D3: mutation target not found — the gate it guards may be dead.');
+      failed++;
     } else {
       writeFileSync(patternsFile, broken);
       assert('singular sensitive patterns → lane-integrity fails', false, () => run('D3', 'bun run test -- lane-integrity -t "payments"'));
@@ -218,10 +228,12 @@ if (!existsSync(patternsFile)) {
     const live = original.match(/SENSITIVE_PATS="([^"]+)"/)?.[1] ?? '';
     const broken = live.split('|').filter(t => !D3B_FAMILY_TOKENS.has(t)).join('|');
     const brokenLine = `SENSITIVE_PATS="${broken}"`;
-    if (broken === live || !live) {
-      console.log('  ⚠  D3b: no D3 family tokens found in live SENSITIVE_PATS — skipping');
+    const d3bPattern = /SENSITIVE_PATS="[^"]*"/;
+    if (!d3bPattern.test(original) || broken === live || !live) {
+      console.error('✗ D3b: mutation target not found — the gate it guards may be dead.');
+      failed++;
     } else {
-      writeFileSync(patternsFile, original.replace(/SENSITIVE_PATS="[^"]*"/, brokenLine));
+      writeFileSync(patternsFile, original.replace(d3bPattern, brokenLine));
       assert('missing new categories → lane-integrity fails', false, () => run('D3b', 'bun run test -- lane-integrity -t "sensitive-paths"'));
     }
   } finally {
@@ -238,12 +250,14 @@ if (!existsSync(savepointFile)) {
   const original = readFileSync(savepointFile, 'utf8');
   try {
     // revert to delta-based (0 on deletions/refactors)
+    const d4Pattern = /LOC_TOKENS=\$\(\( LOC_CHURN \* 12 \)\)/;
     const broken = original.replace(
-      /LOC_TOKENS=\$\(\( LOC_CHURN \* 12 \)\)/,
+      d4Pattern,
       'LOC_TOKENS=$(( LOC_DELTA > 0 ? LOC_DELTA * 12 : 0 ))'
     );
-    if (broken === original) {
-      console.log('  ⚠  D4 mutation pattern not found — skipping');
+    if (!d4Pattern.test(original) || broken === original) {
+      console.error('✗ D4: mutation target not found — the gate it guards may be dead.');
+      failed++;
     } else {
       writeFileSync(savepointFile, broken);
       assert('zero churn tokens → lane-integrity fails', false, () => run('D4', 'bun run test -- lane-integrity -t "churn"'));
@@ -263,12 +277,14 @@ if (!existsSync(savepointFile)) {
   try {
     // silently drop the continue writer block (make it a no-op). Anchor on the
     // D10 header comment so the regex hits the writer, not the STATE_FILE if.
+    const d10Pattern = /# --- continue.*\(D10\): machine-written resume point ---[\s\S]*?\nfi\n\n/;
     const broken = original.replace(
-      /# --- continue\/<mission>\/<member>\.json \(D10\): machine-written resume point ---[\s\S]*?\nfi\n\n/,
+      d10Pattern,
       '# --- continue writer disabled (D10) ---\n\n'
     );
-    if (broken === original) {
-      console.log('  ⚠  D10 mutation pattern not found — skipping');
+    if (!d10Pattern.test(original) || broken === original) {
+      console.error('✗ D10: mutation target not found — the gate it guards may be dead.');
+      failed++;
     } else {
       writeFileSync(savepointFile, broken);
       assert('broken continue writer → savepoint fails', false, () => run('D10', 'bun run test -- savepoint -t "D10"'));
@@ -612,5 +628,52 @@ console.log('\nDOCLINKS — doc link resolution');
   }
 }
 
+// --- T3: lane-aware gates — direct 3 steps, full 12 steps ---
+console.log('\nT3 — lane-aware gates');
+{
+  const policyFile = join(root, 'src', 'policy.ts');
+  const originalPolicy = readFileSync(policyFile, 'utf8');
+  try {
+    assert('direct lane → 3 steps', true, () => gatesForLane('direct').length === 3);
+    assert('direct lane includes typecheck+build', true, () => {
+      const s = gatesForLane('direct');
+      return s.includes('typecheck') && s.includes('build');
+    });
+    assert('lean lane → 6 steps with validate-content', true, () => {
+      const s = gatesForLane('lean');
+      return s.length === 6 && s.includes('validate-content');
+    });
+    assert('standard lane → 9 steps', true, () => gatesForLane('standard').length === 9);
+    assert('full lane → 12 steps with evals/retrieval/conformance', true, () => {
+      const s = gatesForLane('full');
+      return s.length === 12 && s.includes('run-evals') && s.includes('retrieval-eval') && s.includes('conformance');
+    });
+    assert('budget direct → 0, full → 50000', true, () => budgetForLane('direct') === 0 && budgetForLane('full') === 50000);
+    assert('budget spike → 3000 (direct fixture 3k)', true, () => budgetForLane('spike') === 3000);
+    // mutation: break direct step count → should fail (file content shows not 3)
+    const broken = originalPolicy.replace(
+      "direct: ['build-hooks:check', 'typecheck', 'build']",
+      "direct: ['typecheck']"
+    );
+    if (broken !== originalPolicy) {
+      writeFileSync(policyFile, broken);
+      assert('broken direct gate → not 3 steps', false, () => readFileSync(policyFile, 'utf8').includes("direct: ['build-hooks:check', 'typecheck', 'build']"));
+    } else {
+      console.error('✗ T3: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    }
+  } finally {
+    writeFileSync(policyFile, originalPolicy);
+    assert('restored → direct 3 steps', true, () => {
+      const txt = readFileSync(policyFile, 'utf8');
+      return txt.includes("direct: ['build-hooks:check', 'typecheck', 'build']");
+    });
+  }
+  assert('full still includes conformance (conformance 71→74)', true, () => {
+    const txt = readFileSync(policyFile, 'utf8');
+    return txt.includes("'conformance'") && txt.includes("full:");
+  });
+}
+
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed > 0 ? 1 : 0);

package/scripts/savepoint.sh

@@ -331,6 +331,13 @@ if [ -n "$PLAN_FILE" ] && [ -f "$PLAN_FILE" ]; then
   TASKS_TOTAL=$(grep -cE '^\s*-\s*\[[ xX]\]' "$PLAN_FILE" 2>/dev/null || true)
   TASKS_DONE=$(grep -c '\[x\]' "$PLAN_FILE" 2>/dev/null || true)
 fi
+# Fallback for large campaigns (>3 phases, >1500 lines) where master plan.md is an index
+# and tasks live in sub-plan/*.md — only when plan.md has zero checkbox tasks to
+# keep simple missions unchanged.
+if [ "${TASKS_TOTAL:-0}" -eq 0 ] 2>/dev/null && [ -d "$MISSION_DIR/sub-plan" ]; then
+  TASKS_TOTAL=$(grep -rcE '^\s*-\s*\[[ xX]\]' "$MISSION_DIR/sub-plan" 2>/dev/null | awk -F: '{s+=$2} END {print s+0}' || true)
+  TASKS_DONE=$(grep -rc '\[x\]' "$MISSION_DIR/sub-plan" 2>/dev/null | awk -F: '{s+=$2} END {print s+0}' || true)
+fi
 
 # blocker count
 BLOCKERS_FILE="$MISSION_DIR/blockers.md"
@@ -365,6 +372,16 @@ if [ "$HEAL_CYCLE" -ge "$HEAL_MAX_CYCLES" ] 2>/dev/null; then
   HEAL_HALT=true
 fi
 
+# slop — context (repeated reads) per cost-governor §§21-24,31-32 — T5 wire all crews Luffy/Nami/Zoro/Brook
+REPEATED_READS=0
+REPEATED_THRESHOLD=3
+REGISTRY_FILE="$MISSION_DIR/context-registry.jsonl"
+if [ -f "$REGISTRY_FILE" ]; then
+  REPEATED_READS=$(node -e "try{const fs=require('fs');const t=fs.readFileSync(process.argv[1],'utf8');let s=0;for(const l of t.split(/\r?\n/)){if(!l.trim())continue;try{const e=JSON.parse(l);if(typeof e.reads==='number'&&e.reads>=2)s+=Math.floor(e.reads)-1}catch{}}console.log(s)}catch(e){console.log(0)}" "$REGISTRY_FILE" 2>/dev/null || echo 0)
+  REPEATED_READS=$(( ${REPEATED_READS:-0} + 0 ))
+fi
+# repeated_reads > threshold → context slop — crew must skip re-read/compress before dispatch (§22,31); heal_cycle≥max → halt/escalate (§21.7/32) — cost-governor §§20,21-24
+
 # depth flags — advisory → measured (roadmap v0.8 item 4). Read from config
 # like the other keys; computed into state.json so enforcement is a fact the
 # gates flow stage can read, not prose.
@@ -523,7 +540,9 @@ const data = {
   budget_status: process.argv[19],
   skill_version: process.argv[20],
   evidence: process.argv[21] ? process.argv[21].split(',').filter(Boolean) : [],
-  updated_at: process.argv[22]
+  updated_at: process.argv[22],
+  schema_version: 2,
+  repeated_reads: parseInt(process.argv[41], 10) || 0
 };
 require('fs').writeFileSync(process.argv[23], JSON.stringify(data, null, 2) + '\n');
 " \
@@ -536,7 +555,8 @@ require('fs').writeFileSync(process.argv[23], JSON.stringify(data, null, 2) + '\
   "$STATE_FILE" "$LANE_PREV" "$LANE_ROSE" "$TOKENS_SOURCE" "$LANE_PEAK" \
   "$LOC_INS" "$LOC_DEL" "$LOC_CHURN" "$MEMBER" "$VERBOSITY" \
   "$HEAL_MAX_CYCLES" "$HEAL_HALT" "$DELEGATE_THRESHOLD" "$DELEGATE_DUE" \
-  "$MODEL" "$DEPTH_REVIEW" "$DEPTH_QUALITY" "$DEPTH_VERIFY"
+  "$MODEL" "$DEPTH_REVIEW" "$DEPTH_QUALITY" "$DEPTH_VERIFY" \
+  "$REPEATED_READS"
 
 if [ "$LANE_ROSE" = true ]; then
   echo "⚠ LANE ROSE: $LANE_PREV → $LANE ($LANE_REASON) — escalate per check-in protocol"

package/scripts/validate-content.ts

@@ -417,6 +417,66 @@ if (integrityArg !== -1) {
 }
 }
 
+// --- README metrics gate (D3): README table must match .metrics/latest.json ---
+if (process.argv.includes('--check-readme-metrics')) {
+  const metricsPath = join(import.meta.dirname, '..', '.metrics', 'latest.json');
+  if (!existsSync(metricsPath)) {
+    errors.push(`README metrics: ${metricsPath} not found — run bun scripts/write-metrics.ts`);
+  } else {
+    let metrics: any;
+    try { metrics = JSON.parse(readFileSync(metricsPath, 'utf8')); }
+    catch (e) { errors.push(`README metrics: invalid JSON in ${metricsPath}: ${e}`); }
+    if (metrics) {
+      const readmePath = join(import.meta.dirname, '..', 'README.md');
+      if (!existsSync(readmePath)) {
+        errors.push('README metrics: README.md not found');
+      } else {
+        const readme = readFileSync(readmePath, 'utf8');
+        // rank-1: **95.9%**, 216 probes
+        const rankMatch = readme.match(/Retrieval routing rank-1[^\n]*?(\d+\.\d+)%[^\n]*?(\d+)\s+probes/i);
+        if (!rankMatch) {
+          errors.push('README metrics: could not parse Retrieval routing rank-1 row (expected "**X.Y%**, N probes")');
+        } else {
+          const readmeRank = parseFloat(rankMatch[1]);
+          const readmeProbes = parseInt(rankMatch[2], 10);
+          const wantRank = Number(metrics.retrieval_rank1);
+          const wantProbes = Number(metrics.retrieval_probes);
+          if (Math.abs(readmeRank - wantRank) > 0.05) {
+            errors.push(`README metrics: rank-1 ${readmeRank}% != metrics ${wantRank}% (probes ${readmeProbes} vs ${wantProbes}) — run bun scripts/write-metrics.ts and update README`);
+          }
+          if (readmeProbes !== wantProbes) {
+            errors.push(`README metrics: probes ${readmeProbes} != metrics ${wantProbes} (rank ${readmeRank}% vs ${wantRank}%) — run bun scripts/write-metrics.ts and update README`);
+          }
+        }
+        // pointers: **286/286**, 9 targets (or tiers)
+        const ptrMatch = readme.match(/Reference pointers resolve[^\n]*?\*\*(\d+)\/(\d+)\*\*[^\n]*?(\d+)\s+(tiers|targets)/i);
+        if (!ptrMatch) {
+          errors.push('README metrics: could not parse Reference pointers row (expected "**N/N**, M targets")');
+        } else {
+          const a = parseInt(ptrMatch[1], 10);
+          const b = parseInt(ptrMatch[2], 10);
+          const count = parseInt(ptrMatch[3], 10);
+          const wantTotal = Number(metrics.pointers_total);
+          const wantTargets = Number(metrics.pointers_targets);
+          if (a !== wantTotal || b !== wantTotal) {
+            errors.push(`README metrics: pointers ${a}/${b} != metrics ${wantTotal}/${wantTotal} — run bun scripts/write-metrics.ts and update README`);
+          }
+          if (count !== wantTargets) {
+            errors.push(`README metrics: targets/tiers ${count} != metrics ${wantTargets} — run bun scripts/write-metrics.ts and update README (expected ${wantTargets} targets)`);
+          }
+        }
+        // sanity: table still claims "Nothing in this table is an estimate"
+        if (!readme.includes('Nothing in this table is an estimate')) {
+          errors.push('README metrics: missing "Nothing in this table is an estimate" line');
+        }
+        if (errors.filter(e => e.startsWith('README metrics:')).length === 0) {
+          console.log(`✓ README metrics match .metrics/latest.json (rank-1 ${metrics.retrieval_rank1}% ${metrics.retrieval_probes} probes, ${metrics.pointers_total}/${metrics.pointers_total} pointers, ${metrics.pointers_targets} targets)`);
+        }
+      }
+    }
+  }
+}
+
 // Conditional-assertion guard: an expect() reachable only inside a truthiness
 // check silently passes when the value is absent. This class produced 9 defects.
 // Allowed: checks keyed on a declared invariant (tier, fixture keys).

package/scripts/verify-install.ts

@@ -18,6 +18,7 @@ import { targets, TARGET_IDS } from '../src/targets/index.ts';
 
 const repoRoot = join(import.meta.dirname, '..');
 const fail: string[] = [];
+const isJson = process.argv.includes('--json');
 
 function findMd(root: string, out: string[] = []): string[] {
   if (!existsSync(root)) return out;
@@ -169,6 +170,25 @@ if (orphans.length > ORPHAN_BASELINE) {
 }
 
 // ---------------------------------------------------------------------------
+if (isJson) {
+  const payload = {
+    pointers_total: pointers,
+    pointers_targets: TARGET_IDS.length,
+    pointers_broken: brokenPointers,
+    prose_paths: prosePaths,
+    prose_files: proseFiles.length,
+    orphans,
+    orphans_count: orphans.length,
+    ref_files: refFiles.length,
+    targets: TARGET_IDS.length,
+    pointers: pointers,
+    broken_pointers: brokenPointers,
+  };
+  console.log(JSON.stringify(payload, null, 2));
+  if (fail.length) process.exit(1);
+  process.exit(0);
+}
+
 console.log(`  ${pointers} pointers checked across ${TARGET_IDS.length} targets`);
 console.log(`  ${prosePaths} prose paths checked in ${proseFiles.length} files`);
 console.log(`  ${orphans.length}/${refFiles.length} reference files unreachable (baseline ${ORPHAN_BASELINE})`);