@ionivetech/mugiwara 0.8.0 → 0.8.2

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "mugiwara",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "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.2",
   "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.2",
   "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,207 @@ 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 → 9000 (direct fixture 9k)', true, () => budgetForLane('spike') === 9000);
+    // 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:");
+  });
+}
+
+// --- B1: CLI availability — remove section → content validation fails ---
+console.log('\nB1 — CLI availability');
+{
+  const wf = join(root, 'content', 'skills', 'mugiwara-workflow', 'SKILL.md');
+  const original = readFileSync(wf, 'utf8');
+  try {
+    const b1Pattern = /## CLI availability[\s\S]*?## Artifact trust/;
+    const b1Broken = original.replace(b1Pattern, '## Artifact trust');
+    if (!b1Pattern.test(original) || b1Broken === original) {
+      console.error('✗ B1: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(wf, b1Broken);
+      assert('missing CLI availability → grep fails', false, () => run('B1-grep', 'grep -q "CLI availability" content/skills/mugiwara-workflow/SKILL.md'));
+    }
+  } finally {
+    writeFileSync(wf, original);
+    assert('restored → content validation passes', true, () => run('B1-restore', 'grep -q "CLI availability" content/skills/mugiwara-workflow/SKILL.md'));
+  }
+}
+
+// --- B2: team evidence gate — revert to single state.json → integrity gate fails on team ---
+console.log('\nB2 — team evidence gate');
+{
+  const integ = join(root, 'src', 'integrity.ts');
+  const original = readFileSync(integ, 'utf8');
+  try {
+    const fixedPattern = /const stateFiles = existsSync\(missionDir\)/;
+    const broken = original.replace(fixedPattern, "const evidenceFile = join(missionDir, 'state.json'); // B2 revert");
+    const fullPattern = /  \/\/ Solo layout writes state\.json; team layout writes <member>\.json per member\./;
+    let b2Broken = original;
+    if (fullPattern.test(original)) {
+      // remove the team-aware block header to make grep for stateFiles fail for the specific definition
+      b2Broken = original.replace(fixedPattern, "const evidenceFile = join(missionDir, 'state.json'); // B2 revert");
+      // also need to remove remaining stateFiles references to make grep fail - replace all stateFiles with evidenceFile
+      b2Broken = b2Broken.replace(/stateFiles/g, 'evidenceFile');
+    }
+    if (!fixedPattern.test(original) || broken === original) {
+      console.error('✗ B2: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(integ, b2Broken);
+      assert('single state.json → team evidence gate dead', false, () => run('B2', 'grep -q "const stateFiles = existsSync" src/integrity.ts'));
+    }
+  } finally {
+    writeFileSync(integ, original);
+    assert('restored → team gate present', true, () => run('B2-restore', 'grep -q "const stateFiles = existsSync" src/integrity.ts'));
+  }
+}
+
+// --- B3: task counter — restore unanchored grep → savepoint task test fails ---
+console.log('\nB3 — task counter');
+{
+  const sp = join(root, 'scripts', 'savepoint.sh');
+  const original = readFileSync(sp, 'utf8');
+  try {
+    const broken = original.replace('TASKS_TOTAL=$(count_boxes "$PLAN_FILE" \'[ xX]\')', 'TASKS_TOTAL=$(grep -cE \'^\\s*-\\s*\\[[ xX]\\]\' "$PLAN_FILE" 2>/dev/null || true)')
+      .replace('TASKS_DONE=$(count_boxes "$PLAN_FILE" \'[xX]\')', 'TASKS_DONE=$(grep -c \'\\[x\\]\' "$PLAN_FILE" 2>/dev/null || true)');
+    if (broken === original) {
+      console.error('✗ B3: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(sp, broken);
+      assert('unanchored grep → savepoint task test fails', false, () => run('B3', 'bun run test -- savepoint -t "B3: task counting"'));
+    }
+  } finally {
+    writeFileSync(sp, original);
+    assert('restored → savepoint task test passes', true, () => run('B3-restore', 'bun run test -- savepoint -t "B3: task counting"'));
+  }
+}
+
+// --- B4: repo root — restore [ -d .git ] → lane subdirectory test fails ---
+console.log('\nB4 — repo root');
+{
+  const lane = join(root, 'scripts', 'lane.sh');
+  const original = readFileSync(lane, 'utf8');
+  try {
+    const broken = original.replace(
+      /# Resolve the repo root: handles subdirectories and git worktrees[\s\S]*?cd "\$REPO_ROOT" \|\| \{ echo "lane: cannot enter repo root" >&2; exit 1; \}/,
+      '[ -d .git ] || { echo "lane: not a git repository" >&2; exit 1; }'
+    );
+    if (broken === original) {
+      console.error('✗ B4: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(lane, broken);
+      assert('[ -d .git ] → lane subdirectory gate dead', false, () => run('B4', 'grep -q "git rev-parse --show-toplevel" scripts/lane.sh'));
+    }
+  } finally {
+    writeFileSync(lane, original);
+    assert('restored → lane uses git rev-parse', true, () => run('B4-restore', 'grep -q "git rev-parse --show-toplevel" scripts/lane.sh'));
+  }
+}
+
+// --- B5: spike budget — set below base → lane-base fails ---
+console.log('\nB5 — spike budget');
+{
+  const baseFile = join(root, 'scripts', 'lib', 'lane-base.sh');
+  const original = readFileSync(baseFile, 'utf8');
+  try {
+    const broken = original.replace('BUDGET_spike=9000', 'BUDGET_spike=3000');
+    if (broken === original) {
+      console.error('✗ B5: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(baseFile, broken);
+      assert('BUDGET_spike 3000 < LANE_BASE 5411 → lane-base fails', false, () => run('B5', 'bun scripts/lane-base.ts'));
+    }
+  } finally {
+    writeFileSync(baseFile, original);
+    assert('restored → lane-base passes', true, () => run('B5-restore', 'bun scripts/lane-base.ts'));
+  }
+}
+
+// --- B6: corrupt state — swallow parse errors again → status test fails ---
+console.log('\nB6 — corrupt state');
+{
+  const cont = join(root, 'src', 'continue.ts');
+  const original = readFileSync(cont, 'utf8');
+  try {
+    const broken = original.replace('unreadable.push(join(mission, f));', '// corrupt savepoint — skip, never crash the listing');
+    if (broken === original) {
+      console.error('✗ B6: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(cont, broken);
+      assert('swallow parse errors → unreadable gate dead', false, () => run('B6', 'grep -q "unreadableStateFiles" src/continue.ts && grep -q "unreadable.push" src/continue.ts'));
+    }
+  } finally {
+    writeFileSync(cont, original);
+    assert('restored → corrupt state surfaced', true, () => run('B6-restore', 'grep -q "unreadable.push" src/continue.ts'));
+  }
+}
+
+// --- B7: zero evidence — remove check → integrity team test fails ---
+console.log('\nB7 — zero evidence');
+{
+  const integ = join(root, 'src', 'integrity.ts');
+  const original = readFileSync(integ, 'utf8');
+  try {
+    const b7Pattern = /mission declares no evidence/;
+    const broken = original.replace(b7Pattern, 'ZERO_EVIDENCE_REMOVED');
+    if (!b7Pattern.test(original) || broken === original) {
+      console.error('✗ B7: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(integ, broken);
+      assert('no zero-evidence check → integrity gate dead', false, () => run('B7', 'grep -q "mission declares no evidence" src/integrity.ts'));
+    }
+  } finally {
+    writeFileSync(integ, original);
+    assert('restored → zero-evidence warned', true, () => run('B7-restore', 'grep -q "mission declares no evidence" src/integrity.ts'));
+  }
+}
+
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed > 0 ? 1 : 0);