@ionivetech/mugiwara 0.8.2 → 0.9.1

package/dist/mugiwara.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync as existsSync16, readdirSync as readdirSync10, readFileSync as readFileSync15, rmSync as rmSync3, writeFileSync as writeFileSync10, mkdirSync as mkdirSync10, renameSync as renameSync2 } from "node:fs";
+import { existsSync as existsSync17, readdirSync as readdirSync10, readFileSync as readFileSync16, rmSync as rmSync3, writeFileSync as writeFileSync10, mkdirSync as mkdirSync10, renameSync as renameSync2 } from "node:fs";
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname6, join as join21, resolve as resolve2 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/args.ts
-var VALUE_FLAGS = { "--project": "project", "--target": "target", "--before": "before", "--backend": "backend", "--mission": "mission" };
+var VALUE_FLAGS = { "--project": "project", "--target": "target", "--before": "before", "--backend": "backend", "--mission": "mission", "--to-team": "toTeam", "--to-solo": "toSolo" };
 var BOOL_FLAGS = {
   "--global": "global",
   "--yes": "yes",
@@ -152,6 +152,7 @@ function wireSettings(root, hooksDir) {
   const events = {
     SessionStart: { file: "session-start.js", timeout: 10 },
     UserPromptSubmit: { file: "mugiwara-mode-tracker.js", timeout: 5 },
+    PreToolUse: { file: "pretool-guard.js", timeout: 10, matcher: "Bash" },
     Stop: { file: "auto-savepoint.js", timeout: 20 },
     SubagentStop: { file: "pipeline-guard.js", timeout: 15 },
     PostToolUse: { file: "engagement-marker.js", timeout: 5, matcher: "Task|Skill" }
@@ -633,24 +634,43 @@ import { existsSync as existsSync4, lstatSync, mkdirSync as mkdirSync3, readFile
 import { homedir } from "node:os";
 import { join as join5 } from "node:path";
 var DEFAULT_CONFIG = [
-  "mode=guided",
+  "# Mugiwara config. Project overrides ~/.mugiwara/config.",
+  "# Every key here is read by code. Delete a line to take its default.",
+  "",
+  "# -- Autonomy ---------------------------------------------",
+  "mode=guided                  # guided | semi | auto — how much the crew does without asking",
+  "verbosity=normal             # normal | full — how much the crew echoes",
+  "",
+  "# -- Team -------------------------------------------------",
+  "# team_member=              # your member id; set it and state isolates per person",
+  "# team_members=1            # how many people on this mission; >1 enables team-scoped posture",
+  "",
+  "# -- Git --------------------------------------------------",
   "branch=feature/{type}-{issue}-{slug}",
   "commit=conventional",
-  "auto_commit=on",
+  "auto_commit=off              # on | off — off hands you an uncommitted tree in guided/semi",
+  "",
+  "# -- Gates ------------------------------------------------",
   "coverage_new=85",
   "coverage_modified=90",
-  "review_depth=full",
+  "review_depth=full            # full | standard | quick",
   "quality_depth=full",
   "verify_merged=off",
-  "delegate_threshold=60",
-  "heal_max_cycles=3",
-  "verbosity=normal",
-  "# context_budget_chars=150000  # optional: fail archive if trail exceeds this (measured in report Cost section)",
-  "# investigation_max_passes=2  # optional: cap investigation passes (spec §13)",
+  "",
+  "# -- Limits -----------------------------------------------",
+  "delegate_threshold=60        # % of budget before delegation is advised",
+  "heal_max_cycles=3            # heal loop halts here and escalates",
+  "",
+  "# -- Monorepo ---------------------------------------------",
+  "# lane_scope_glob=packages/api/**   # count only matching files when sizing the lane",
+  "",
+  "# -- Optional ---------------------------------------------",
+  "# context_budget_chars=150000       # fail archive if the trail exceeds this",
+  "# investigation_max_passes=2",
   "# investigation_max_unrelated_files=5",
   "# investigation_repeated_read_threshold=2",
-  "# sign=auto            # optional: auto | minisign | pure | off — report attestation",
-  "# enforce=block                # optional: off | warn | block — pipeline-guard policy"
+  "# sign=auto                         # auto | minisign | pure | off",
+  "# enforce=block                     # off | warn | block — pipeline-guard policy"
 ].join(`
 `) + `
 `;
@@ -685,7 +705,11 @@ function readConfig(projectDir) {
         continue;
       if (key in out)
         continue;
-      out[key] = t.slice(eq + 1).trim();
+      let rawVal = t.slice(eq + 1).trim();
+      const hash = rawVal.indexOf("#");
+      if (hash !== -1)
+        rawVal = rawVal.slice(0, hash).trim();
+      out[key] = rawVal;
     }
   }
   return out;
@@ -704,6 +728,25 @@ function ensureConfig(projectDir) {
   writeFileSync3(file, DEFAULT_CONFIG);
   return true;
 }
+var INVESTIGATION_DEFAULTS = {
+  max_passes: 2,
+  max_unrelated_files: 5,
+  repeated_read_threshold: 2
+};
+function positiveInt(raw, fallback) {
+  if (raw === undefined || raw === "")
+    return fallback;
+  const n = Number(raw);
+  return Number.isInteger(n) && n > 0 ? n : fallback;
+}
+function readInvestigationConfig(projectDir) {
+  const cfg = readConfig(projectDir);
+  return {
+    max_passes: positiveInt(cfg.investigation_max_passes, INVESTIGATION_DEFAULTS.max_passes),
+    max_unrelated_files: positiveInt(cfg.investigation_max_unrelated_files, INVESTIGATION_DEFAULTS.max_unrelated_files),
+    repeated_read_threshold: positiveInt(cfg.investigation_repeated_read_threshold, INVESTIGATION_DEFAULTS.repeated_read_threshold)
+  };
+}
 
 // src/installer.ts
 var CONTENT_DIR = join6(dirname3(fileURLToPath3(import.meta.url)), "..", "content");
@@ -737,11 +780,11 @@ function collectRefs(skillDir) {
     return [];
   return readdirSync3(refsDir, { recursive: true }).map((f) => String(f)).filter((f) => f.endsWith(".md")).map((rel) => ({ relPath: rel, text: readFileSync4(join6(refsDir, rel), "utf8") }));
 }
-function installTo(target10, opts) {
+function installTo(target, opts) {
   const { scope, projectDir, dryRun = false, force = false } = opts;
   const home = opts.home ?? homedir2();
   const { skills, agents, sharedRefs } = collectContent();
-  const dirs = target10.paths({ scope, projectDir, home });
+  const dirs = target.paths({ scope, projectDir, home });
   const backupRoot = join6(scope === "global" ? home : projectDir, ".mugiwara");
   const result = { written: [], skipped: [], backedUp: [], notes: [] };
   const writeOne = (absPath, text, mode) => {
@@ -762,7 +805,7 @@ function installTo(target10, opts) {
       }
       const ts = new Date().toISOString().replace(/[:.]/g, "-");
       const fileName = absPath.replace(/[^a-zA-Z0-9]+/g, "_");
-      const backupDir = join6(backupRoot, "backup", `${ts}-${target10.id}`);
+      const backupDir = join6(backupRoot, "backup", `${ts}-${target.id}`);
       const backupFile = join6(backupDir, fileName);
       if (!dryRun) {
         mkdirSync4(backupDir, { recursive: true });
@@ -782,38 +825,38 @@ function installTo(target10, opts) {
     result.written.push(absPath);
   };
   for (const s of skills) {
-    const out = target10.transformSkill(s.data, s.body);
+    const out = target.transformSkill(s.data, s.body);
     if (out) {
       let text = out.text;
-      if (target10.refPointerPrefix !== undefined && target10.refPointerPrefix !== "") {
-        text = text.replace(/`_shared\/references\//g, "`" + target10.refPointerPrefix + "_shared/references/");
+      if (target.refPointerPrefix !== undefined && target.refPointerPrefix !== "") {
+        text = text.replace(/`_shared\/references\//g, "`" + target.refPointerPrefix + "_shared/references/");
       }
       writeOne(join6(dirs.skillsDir, out.relPath), text);
     }
-    if (target10.transformSkillFull) {
-      const full = target10.transformSkillFull(s.data, s.body);
-      if (full && target10.refsDir) {
+    if (target.transformSkillFull) {
+      const full = target.transformSkillFull(s.data, s.body);
+      if (full && target.refsDir) {
         let text = full.text;
-        if (target10.refPointerPrefix !== undefined && target10.refPointerPrefix !== "") {
-          text = text.replace(/`_shared\/references\//g, "`" + target10.refPointerPrefix + "_shared/references/");
+        if (target.refPointerPrefix !== undefined && target.refPointerPrefix !== "") {
+          text = text.replace(/`_shared\/references\//g, "`" + target.refPointerPrefix + "_shared/references/");
         }
-        writeOne(join6(target10.refsDir({ scope, projectDir, home }, s.name), full.relPath), text);
+        writeOne(join6(target.refsDir({ scope, projectDir, home }, s.name), full.relPath), text);
       }
     }
-    if (s.refs.length && target10.refsDir) {
-      const refsRoot = target10.refsDir({ scope, projectDir, home }, s.name);
+    if (s.refs.length && target.refsDir) {
+      const refsRoot = target.refsDir({ scope, projectDir, home }, s.name);
       for (const r of s.refs)
         writeOne(join6(refsRoot, r.relPath), r.text);
     }
   }
   for (const a of agents) {
-    const out = target10.transformAgent({ ...a.data, ...a.internal ? { "internal-agent": "true" } : {} }, a.body);
+    const out = target.transformAgent({ ...a.data, ...a.internal ? { "internal-agent": "true" } : {} }, a.body);
     if (out)
       writeOne(join6(dirs.agentsDir, out.relPath), out.text);
-    if (target10.transformAgentFull) {
-      const full = target10.transformAgentFull(a.data, a.body);
-      if (full && target10.refsDir)
-        writeOne(join6(target10.refsDir({ scope, projectDir, home }, a.name), full.relPath), full.text);
+    if (target.transformAgentFull) {
+      const full = target.transformAgentFull(a.data, a.body);
+      if (full && target.refsDir)
+        writeOne(join6(target.refsDir({ scope, projectDir, home }, a.name), full.relPath), full.text);
     }
   }
   if (sharedRefs.length) {
@@ -833,8 +876,8 @@ function installTo(target10, opts) {
       writeOne(dest, text, 493);
     }
   }
-  if (target10.postInstall) {
-    const post = target10.postInstall({ scope, projectDir, home, dryRun, files: result.written });
+  if (target.postInstall) {
+    const post = target.postInstall({ scope, projectDir, home, dryRun, files: result.written });
     result.written.push(...post.written);
     result.notes.push(...post.notes);
   }
@@ -1020,10 +1063,10 @@ function parsePolicyYaml(text) {
       stack.pop();
     const top = stack[stack.length - 1];
     if (top.pending && !line.startsWith("- ") && indent > top.pending.indent && !Array.isArray(top.obj[top.pending.key])) {
-      const { key: key2, indent: pIndent } = top.pending;
+      const { key, indent: pIndent } = top.pending;
       delete top.pending;
       const created = {};
-      top.obj[key2] = created;
+      top.obj[key] = created;
       stack.push({ keyIndent: pIndent, obj: created });
       return process2(i);
     }
@@ -1575,15 +1618,15 @@ function checkTrail(missionDir, projectRoot) {
     } catch {
       continue;
     }
-    for (const target10 of linkedPaths(body)) {
-      if (isAbsolute(target10))
+    for (const target of linkedPaths(body)) {
+      if (isAbsolute(target))
         continue;
-      const fromMission = join9(missionDir, target10);
-      const fromRoot = join9(projectRoot, target10);
+      const fromMission = join9(missionDir, target);
+      const fromRoot = join9(projectRoot, target);
       if (!existsSync8(fromMission) && !existsSync8(fromRoot)) {
         issues.push({
           kind: "dangling-path",
-          detail: `${relative(projectRoot, f)} links "${target10}" — no such file (mission dir or repo root)`
+          detail: `${relative(projectRoot, f)} links "${target}" — no such file (mission dir or repo root)`
         });
       }
     }
@@ -1810,18 +1853,18 @@ function attachGitNote(projectDir, branch, note, baseSha) {
       console.warn(`attachGitNote: range ${shas.length} >200, falling back to head-only`);
       shas = [];
     }
-    let targets2 = shas;
-    if (!targets2.length) {
+    let targets = shas;
+    if (!targets.length) {
       try {
-        targets2 = [git2(projectDir, ["rev-parse", "--verify", branch])];
+        targets = [git2(projectDir, ["rev-parse", "--verify", branch])];
       } catch {
-        targets2 = [git2(projectDir, ["rev-parse", "HEAD"])];
+        targets = [git2(projectDir, ["rev-parse", "HEAD"])];
       }
     }
-    for (const sha of targets2) {
+    for (const sha of targets) {
       git2(projectDir, ["notes", "--ref=mugiwara", "add", "-f", "-m", note, sha]);
     }
-    return { sha: targets2[0], count: targets2.length };
+    return { sha: targets[0], count: targets.length };
   } catch {
     return null;
   }
@@ -2242,10 +2285,37 @@ function appendCostEvent(missionDir, event) {
 `, "utf8");
 }
 var COMPRESSED_KIND = "compressed";
+var DECISIONS_FILE = "decisions.md";
+var OPT_SECTION = "## Cost governor decisions";
+function recordOptDecision(missionDir, d) {
+  assertMissionDir(missionDir);
+  mkdirSync7(missionDir, { recursive: true });
+  const file = join15(missionDir, DECISIONS_FILE);
+  let hasSection = false;
+  try {
+    hasSection = readFileSync10(file, "utf8").split(/\r?\n/).some((l) => l.trim() === OPT_SECTION);
+  } catch {}
+  const ts = new Date().toISOString();
+  const flat = (s) => s.replace(/[\r\n]+/g, " ");
+  const ev = d.evidence ? ` — evidence: ${flat(d.evidence)}` : "";
+  const bullet = `- ${ts} — ${flat(d.actor)}: ${flat(d.decision)} — reason: ${flat(d.reason)}${ev}`;
+  const body = hasSection ? `
+${bullet}
+` : `
+${OPT_SECTION}
+
+${bullet}
+`;
+  appendFileSync(file, body, "utf8");
+}
 
 // src/evidence.ts
+import { createHash } from "node:crypto";
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8, readFileSync as readFileSync11 } from "node:fs";
 import { join as join16 } from "node:path";
+function fingerprint(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
 var REGISTRY_FILE = "context-registry.jsonl";
 function isAllowedMissionDir2(dir) {
   if (!dir || dir.includes(".."))
@@ -2262,6 +2332,43 @@ function assertMissionDir2(dir) {
   if (!isAllowedMissionDir2(dir))
     throw new Error(`Invalid missionDir: ${dir}`);
 }
+function maxSeq(registry) {
+  let max = 0;
+  for (const e of registry) {
+    const m = /^E(\d+)$/.exec(e.id);
+    if (m) {
+      const n = parseInt(m[1], 10);
+      if (n > max)
+        max = n;
+    }
+  }
+  return max;
+}
+function buildRef(id, file, range) {
+  return range ? `${id} ${file}:${range}` : `${id} ${file}`;
+}
+function registerRead(registry, e) {
+  const fp = fingerprint(e.content);
+  const existing = registry.find((x) => x.fingerprint === fp && x.kind === e.kind);
+  if (existing) {
+    existing.reads += 1;
+    return { ref: existing.ref, repeated: true };
+  }
+  const seq = maxSeq(registry) + 1;
+  const id = `E${String(seq).padStart(3, "0")}`;
+  const ref = buildRef(id, e.file, e.range);
+  registry.push({
+    fingerprint: fp,
+    kind: e.kind,
+    file: e.file,
+    ...e.range ? { range: e.range } : {},
+    id,
+    reads: 1,
+    chars: e.content.length,
+    ref
+  });
+  return { ref, repeated: false };
+}
 function loadRegistry(missionDir) {
   assertMissionDir2(missionDir);
   const file = join16(missionDir, REGISTRY_FILE);
@@ -2447,6 +2554,288 @@ function renderAdaptationSection(missionDir) {
 `);
 }
 
+// src/posture.ts
+function selectPosture(input) {
+  if (input.governor === "stop") {
+    return {
+      posture: "inline-sequential",
+      pause: true,
+      reason: "governor stop — pause safely, keep inline; state + continue emitted",
+      evidence_refs: ["governor circuit-breaker", "state.json"]
+    };
+  }
+  if (input.team_members > 1) {
+    return {
+      posture: "team-scoped",
+      pause: false,
+      reason: `${input.team_members} team members with non-overlapping scope`,
+      evidence_refs: ["plan ownership map"]
+    };
+  }
+  if (input.phases > 3 || input.plan_lines > 1500) {
+    return {
+      posture: "phase-isolated",
+      pause: false,
+      reason: `large campaign — ${input.phases} phases / ${input.plan_lines} lines`,
+      evidence_refs: ["plan.md", "large-campaign-subplan.md"]
+    };
+  }
+  if (input.context_pressure && input.order_dependent) {
+    return {
+      posture: "context-relief",
+      pause: false,
+      reason: "context pressure with ordered dependent tasks — one worker at a time, order preserved",
+      evidence_refs: ["state context metrics", "remaining task order"]
+    };
+  }
+  if (input.independent_tasks >= 2) {
+    return {
+      posture: "parallel-workers",
+      pause: false,
+      reason: `${input.independent_tasks} independent tasks, no shared files/interfaces`,
+      evidence_refs: ["Nami dependency map", "work-governor delegation verdict"]
+    };
+  }
+  return {
+    posture: "inline-sequential",
+    pause: false,
+    reason: "no parallel/phase/team/relief trigger — default inline in plan order",
+    evidence_refs: ["triage route", "lane"]
+  };
+}
+
+// src/investigation.ts
+function evaluateInvestigation(input) {
+  const { pass } = input;
+  if (input.acceptance_mapped && input.surface_understood && input.path_established) {
+    return { pass, stop: true, reason: "objective met" };
+  }
+  if (pass >= input.max_passes) {
+    return { pass, stop: true, reason: "max passes" };
+  }
+  if (input.unrelated_files_opened > input.max_unrelated_files) {
+    return { pass, stop: true, reason: "max unrelated files" };
+  }
+  if (input.repeated_reads >= input.repeated_read_threshold) {
+    return { pass, stop: true, reason: "repeated read" };
+  }
+  return { pass, stop: false, reason: "" };
+}
+function recordInvestigationStop(missionDir, status, evidence) {
+  if (!status.stop)
+    return;
+  recordOptDecision(missionDir, {
+    actor: "cost-governor",
+    decision: "stop investigation",
+    reason: status.reason,
+    ...evidence ? { evidence } : {}
+  });
+}
+
+// src/adaptive-budget.ts
+function reserveBudget(input) {
+  const reserved = input.expected_max;
+  const available = Math.max(0, input.remaining - reserved);
+  return { remaining: input.remaining, expected_max: input.expected_max, available, reserved };
+}
+function projectBudget(input) {
+  const projected_min = input.current + input.remaining_required + input.expected_conditional;
+  const projected_max = projected_min + input.possible_healing;
+  return {
+    current: input.current,
+    remaining_required: input.remaining_required,
+    expected_conditional: input.expected_conditional,
+    possible_healing: input.possible_healing,
+    projected_min,
+    projected_max
+  };
+}
+var VALID_REASONS = new Set([
+  "scope legitimately expanded",
+  "security-sensitive path",
+  "test surface larger",
+  "architecture dependency",
+  "legitimate healing"
+]);
+function checkProgressiveThreshold(input) {
+  const pct = input.budget > 0 ? Math.round(input.used / input.budget * 100) : 0;
+  let status = "ok";
+  if (pct >= 300)
+    status = "stop";
+  else if (pct >= 150)
+    status = "warning";
+  else if (pct >= 100)
+    status = "pause";
+  else if (pct >= 90)
+    status = "protect";
+  else if (pct >= 75)
+    status = "aggressive";
+  else if (pct >= 60)
+    status = "optimize";
+  return { status, pct };
+}
+function checkCircuitBreaker(input) {
+  const doubled = input.expected * 2;
+  const noProgress = input.progress_delta === 0;
+  const noScopeOrEvidence = !input.scope_expanded && input.evidence_delta === 0;
+  const overDoubled = input.actual >= doubled;
+  if (overDoubled && noProgress && noScopeOrEvidence) {
+    return { tripped: true, reason: `breaker tripped — actual ${input.actual} ≥ 2× expected ${input.expected} with no progress/scope/evidence` };
+  }
+  if (!overDoubled)
+    return { tripped: false, reason: `no breaker — actual ${input.actual} < 2× expected ${input.expected}` };
+  if (!noProgress)
+    return { tripped: false, reason: "no breaker — progress made" };
+  return { tripped: false, reason: "no breaker — scope expanded or evidence gained" };
+}
+function detectBudgetAnomaly(input) {
+  const tokens_delta = input.tokens_after - input.tokens_before;
+  const progress_delta = input.progress_after - input.progress_before;
+  if (tokens_delta >= 5000 && progress_delta === 0) {
+    return { anomaly: true, reason: `anomaly — ${tokens_delta} tokens with no progress` };
+  }
+  if (tokens_delta < 5000 && progress_delta === 0) {
+    return { anomaly: false, reason: `no anomaly — ${tokens_delta} tokens below 5k floor` };
+  }
+  return { anomaly: false, reason: `no anomaly — progress ${progress_delta} over ${tokens_delta} tokens` };
+}
+
+// src/cognition.ts
+function isFocusedReasoning(input) {
+  const slop_types = [];
+  if (input.speculative_paths > 0)
+    slop_types.push("speculative_architecture");
+  if (input.reconsiderations >= 2)
+    slop_types.push("repeated_reconsideration");
+  if (input.hypothetical_requirements)
+    slop_types.push("hypothetical_requirements");
+  if (input.unrelated_implementations > 0)
+    slop_types.push("unrelated_implementations");
+  const focused = slop_types.length === 0;
+  const reason = focused ? "Question→Evidence→Decision→Action — reasoning is focused" : `unfocused — ${slop_types.join(", ")}`;
+  return { focused, reason, slop_types };
+}
+function detectDuplicateExplanation(input) {
+  const groups = new Map;
+  for (const exp of input.explanations) {
+    const fp = fingerprint(exp);
+    const arr = groups.get(fp);
+    if (arr)
+      arr.push(exp);
+    else
+      groups.set(fp, [exp]);
+  }
+  const duplicate_groups = [];
+  for (const arr of groups.values()) {
+    if (arr.length >= 2)
+      duplicate_groups.push(arr);
+  }
+  const duplicate = duplicate_groups.length > 0;
+  const reason = duplicate ? `${duplicate_groups.length} duplicate group(s) — ${duplicate_groups.length} duplicate explanation(s) found` : "no duplicate explanations";
+  return { duplicate, reason, duplicate_groups };
+}
+
+// src/scope.ts
+function detectScopeDrift(input) {
+  const outside = input.touched_files.filter((f) => !input.declared_scope.some((tok) => f.includes(tok)));
+  const scope_score = input.touched_files.length === 0 ? 0 : outside.length / input.touched_files.length;
+  if (outside.length === 0) {
+    return { change: input.change, drift: false, reason: "within declared scope", scope_score };
+  }
+  return {
+    change: input.change,
+    drift: true,
+    reason: `outside declared scope: ${outside.join(", ")}`,
+    scope_score
+  };
+}
+
+// src/slop.ts
+function classifySlop(signal) {
+  const s = signal.toLowerCase();
+  if (s.includes("same command") || s.includes("same action") || s.includes("repeated command") || s.includes("retry") || s.includes("same evidence"))
+    return "retry";
+  if (s.includes("healing") || s.includes("heal") || s.includes("fixes_in_cycle") || s.includes("no fixes"))
+    return "healing";
+  if (s.includes("repeated file") || s.includes("repeated read") || s.includes("duplicate") || s.includes("irrelevant file") || s.includes("re-read"))
+    return "context";
+  if (s.includes("unrelated file") || s.includes("exploration") || s.includes("investigation") || s.includes("searching without"))
+    return "investigation";
+  if (s.includes("scope") || s.includes("out-of-scope") || s.includes("out of scope") || s.includes("declared scope") || s.includes("unrelated refactor"))
+    return "scope";
+  if (s.includes("loc") || s.includes("boilerplate") || s.includes("abstraction") || s.includes("dependency") || s.includes("code slop"))
+    return "code";
+  if (s.includes("speculative") || s.includes("reconsideration") || s.includes("hypothetical") || s.includes("reasoning slop"))
+    return "reasoning";
+  if (s.includes("verbose") || s.includes("duplicate explanation") || s.includes("output slop") || s.includes("compress"))
+    return "output";
+  return null;
+}
+function measureProgress(before, after) {
+  const evidenceDelta = after.evidence_items - before.evidence_items;
+  const criteriaDelta = after.criteria_mapped - before.criteria_mapped;
+  const testsDelta = after.tests_fixed - before.tests_fixed;
+  const codeDelta = after.code_chars - before.code_chars;
+  const codeProgress = codeDelta > 0 ? 1 : 0;
+  const progress = evidenceDelta + criteriaDelta + testsDelta + codeProgress;
+  const cost_delta = after.tokens_used - before.tokens_used;
+  const progress_per_cost = cost_delta > 0 ? progress / cost_delta : 0;
+  const slop_signal = cost_delta > 0 && progress === 0;
+  const reason = slop_signal ? `slop — ${cost_delta} tokens with no progress` : `progress ${progress} over ${cost_delta} tokens`;
+  return { progress, cost_delta, progress_per_cost, slop_signal, reason };
+}
+function detectAnomaly(input) {
+  const threshold = input.drop_threshold ?? 0.5;
+  if (input.baseline_per_cost <= 0) {
+    return { anomaly: false, reason: "no anomaly — baseline 0 or above threshold" };
+  }
+  const anomaly = input.progress_per_cost < input.baseline_per_cost * threshold;
+  if (anomaly) {
+    const pct = Math.round((1 - input.progress_per_cost / input.baseline_per_cost) * 100);
+    return { anomaly: true, reason: `anomaly — ${pct}% drop below baseline` };
+  }
+  return { anomaly: false, reason: "no anomaly — baseline 0 or above threshold" };
+}
+function detectHealingSlop(input) {
+  const kind = "healing";
+  const max = input.max_cycles ?? 3;
+  const hasZeroHistory = input.history_fixes.some((n) => n === 0);
+  if (input.fixes_in_cycle === 0 && hasZeroHistory) {
+    return { slop: true, reason: `slop: healing — no fixes in cycle ${input.cycle} with previous zero-fix cycle`, kind };
+  }
+  if (input.cycle >= max && input.fixes_in_cycle === 0) {
+    return { slop: true, reason: `slop: healing — cycle ${input.cycle} ≥ max ${max} with no fixes`, kind };
+  }
+  return { slop: false, reason: "no slop — healing making progress", kind };
+}
+function computeLiveSlop(input) {
+  const rows = [];
+  const thr = input.repeated_read_threshold ?? 3;
+  const heal = detectHealingSlop({ cycle: input.heal_cycle, fixes_in_cycle: 0, history_fixes: [], max_cycles: input.max_heal_cycles ?? 3 });
+  if (heal.slop)
+    rows.push({ role: "Brook", kind: "healing", reason: heal.reason });
+  if (input.repeated_reads >= thr)
+    rows.push({ role: "all", kind: "context", reason: `repeated reads ${input.repeated_reads} ≥ ${thr}` });
+  const perRole = {};
+  for (const r of rows)
+    perRole[r.role] = (perRole[r.role] ?? 0) + 1;
+  return { interventions: rows.length, perRole, rows };
+}
+
+// src/work.ts
+function classifyStage(input) {
+  if (input.protects_quality_security) {
+    return { stage: input.stage, class: "required", reason: "protects quality/security — required" };
+  }
+  if (input.provides_required_evidence) {
+    return { stage: input.stage, class: "required", reason: "provides required evidence — required" };
+  }
+  if (input.uncertainty_high || input.requirement_kind !== "explicit") {
+    return { stage: input.stage, class: "conditional", reason: "uncertain or non-explicit requirement — conditional" };
+  }
+  return { stage: input.stage, class: "optional", reason: "explicit, no protection/evidence need — optional" };
+}
+
 // src/mission.ts
 function isStateFile(f) {
   const stem = f.replace(/\.json$/, "");
@@ -2640,6 +3029,59 @@ ${warnText}`);
   }
   const files = readdirSync7(dir);
   const state = primaryState(dir, files);
+  try {
+    if (state) {
+      const sLane = typeof state.lane === "string" ? state.lane : "standard";
+      const sRisk = Array.isArray(state.sensitive_paths) && state.sensitive_paths.length ? "high" : "low";
+      const sTokens = typeof state.tokens_est === "number" ? state.tokens_est : 0;
+      const sBudget = typeof state.budget === "number" ? state.budget : 0;
+      const sStatus = typeof state.budget_status === "string" ? state.budget_status : "ok";
+      const sTeam = typeof state.team_members === "number" ? state.team_members : 1;
+      const sRepeated = typeof state.repeated_reads === "number" ? state.repeated_reads : 0;
+      selectPosture({
+        lane: sLane,
+        risk: sRisk,
+        independent_tasks: 0,
+        order_dependent: true,
+        context_pressure: sBudget > 0 && sTokens > sBudget * 0.6,
+        team_members: sTeam,
+        phases: 1,
+        plan_lines: 0,
+        governor: sStatus === "stop" ? "stop" : sStatus === "warn" ? "avoid" : "normal"
+      });
+      const invCfg = readInvestigationConfig(projectDir);
+      const inv = evaluateInvestigation({
+        pass: 0,
+        acceptance_mapped: false,
+        surface_understood: false,
+        path_established: false,
+        unrelated_files_opened: 0,
+        repeated_reads: sRepeated,
+        max_passes: invCfg.max_passes,
+        max_unrelated_files: invCfg.max_unrelated_files,
+        repeated_read_threshold: invCfg.repeated_read_threshold
+      });
+      if (inv.stop)
+        recordInvestigationStop(dir, inv);
+      reserveBudget({ remaining: Math.max(0, sBudget - sTokens), expected_max: 1000 });
+      projectBudget({ current: sTokens, remaining_required: 2000, expected_conditional: 500, possible_healing: 1000 });
+      checkProgressiveThreshold({ budget: sBudget, used: sTokens });
+      checkCircuitBreaker({ expected: 1000, actual: sTokens, progress_delta: 0, scope_expanded: false, evidence_delta: 0 });
+      detectBudgetAnomaly({ progress_before: 0, progress_after: 0, tokens_before: 0, tokens_after: sTokens });
+      isFocusedReasoning({ question: "wired", evidence_available: true, speculative_paths: 0, reconsiderations: 0, hypothetical_requirements: false, unrelated_implementations: 0 });
+      detectDuplicateExplanation({ explanations: [] });
+      detectScopeDrift({ change: "wired", declared_scope: [], touched_files: [] });
+      classifySlop("repeated read");
+      const prog = measureProgress({ tokens_used: 0, evidence_items: 0, criteria_mapped: 0, files_understood: 0, tests_fixed: 0, code_chars: 0 }, { tokens_used: sTokens, evidence_items: 0, criteria_mapped: 0, files_understood: 0, tests_fixed: 0, code_chars: 0 });
+      detectAnomaly({ progress_per_cost: prog.progress_per_cost, baseline_per_cost: 0.01 });
+      try {
+        const reg = loadRegistry(dir);
+        const planContent = readFileSync13(join18(dir, "plan.md"), "utf8");
+        registerRead(reg, { kind: "file", file: "plan.md", content: planContent });
+      } catch {}
+      classifyStage({ stage: "wired", requirement_kind: "explicit", uncertainty_high: false, provides_required_evidence: false, protects_quality_security: false });
+    }
+  } catch {}
   const stageModels = [...new Set(files.filter(isStateFile).map((f) => {
     try {
       const s = JSON.parse(readFileSync13(join18(dir, f), "utf8"));
@@ -2693,55 +3135,25 @@ ${warnText}`);
       reportedTotal = est;
       hasReported = true;
     }
-    costSection = [
-      "## Cost",
-      "",
-      "| Metric | Value |",
-      "|--------|-------|",
-      `| **Tokens used** | ${est.toLocaleString()} (${srcLabel}) |`,
-      `| **Lane** | ${lane} (budget ${effBudget ? effBudget.toLocaleString() : "—"} · warn ${effBudget ? env.warn_at.toLocaleString() : "—"} · stop ${effBudget ? env.stop_at.toLocaleString() : "—"}) |`,
-      `| **Budget status** | ${effBudget ? `${env.pct}% of budget · ${delta} · ${statusLabel}` : "no lane budget"} |`,
-      `| **Context footprint** | ${chars.toLocaleString()} chars${budget ? ` (budget ${budget.toLocaleString()})` : " (no context budget configured)"} |`,
-      `| **Context budget status** | ${ctxStatus.toUpperCase()}${budget ? ` (budget ${budget.toLocaleString()})` : " (no context budget configured)"} |`,
-      `| **Context efficiency** | files_loaded: ${metrics.files_loaded} · repeated_reads: ${metrics.repeated_reads} · duplicate_chars: ${charTracked ? metrics.duplicate_chars : "n/a"} · reuse_rate: ${metrics.reuse_rate} · read_avoidance_chars: ${charTracked ? metrics.read_avoidance_chars : "n/a"}${ctxNote} |`
-    ].join(`
-`);
-    if (hasReported) {
-      costSection += `
-| **Provider total** | ${reportedTotal.toLocaleString()} (provider-reported — sum of reported stages) |`;
-    }
-    try {
-      const ledger = buildCostLedger({ missionDir: dir, envelope: env });
-      costSection += `
-| Budget | ${ledger.envelope.status} ${ledger.envelope.pct}% (${ledger.envelope.used}/${ledger.envelope.planned}) |`;
-      costSection += `
-| Context | ${chars.toLocaleString()} chars, reuse ${ledger.efficiency.reuse_rate} |`;
-      costSection += `
-| Avoided | ${ledger.avoided.stages_avoided} stages, ${ledger.avoided.contexts_avoided} contexts, ${ledger.avoided.tokens_avoided_est} tokens est |`;
-      costSection += `
-| Efficiency | reuse ${ledger.efficiency.reuse_rate}, dup ${ledger.efficiency.duplicate_avoidance_chars} chars, budget ${ledger.efficiency.budget_efficiency_pct}% |`;
+    const healCycleVal = typeof state.heal_cycle === "number" ? state.heal_cycle : 1;
+    const healText = healCycleVal === 1 ? "1 heal cycle" : `${healCycleVal} heal cycles`;
+    costSection = `## Cost
+
+Used **${est.toLocaleString()}** of ${effBudget ? effBudget.toLocaleString() : "—"} tokens${effBudget ? ` (${env.pct}%)` : ""}. Lane \`${lane}\`. ${healText}.
+`;
+    if (hasReported && reportedTotal) {
       costSection += `
-| Trail | ${ledger.trail.length} decisions |`;
-      if (ledger.trail.length) {
-        const show = ledger.trail.slice(0, 5);
-        for (const t of show)
-          costSection += `
-- ${t.ts} — ${t.actor}: ${t.decision} — reason: ${t.reason}${t.evidence ? ` — evidence: ${t.evidence}` : ""}`;
-        if (ledger.trail.length > 5)
-          costSection += `
-… ${ledger.trail.length - 5} more`;
-      }
-    } catch {}
-    costSection += `
+Provider total: ${reportedTotal.toLocaleString()} tokens (provider-reported).
 `;
+    }
     try {
       costSection += renderAdaptationSection(dir);
     } catch {}
     if (shouldCompress(budget, chars)) {
       try {
-        const flowsDir2 = join18(dir, "flows");
+        const flowsDir = join18(dir, "flows");
         const wavesDir = join18(dir, "waves");
-        const targetDir = existsSync13(flowsDir2) ? flowsDir2 : existsSync13(wavesDir) ? wavesDir : null;
+        const targetDir = existsSync13(flowsDir) ? flowsDir : existsSync13(wavesDir) ? wavesDir : null;
         if (targetDir && existsSync13(targetDir)) {
           const flowFiles = readdirSync7(targetDir).filter((f) => f.endsWith(".md"));
           if (flowFiles.length) {
@@ -2805,10 +3217,8 @@ Trail ${chars} chars exceeds ${pct}% of budget ${budget} (threshold ${compressTh
       fold.push(join18(artRel, f));
     }
   }
-  if (existsSync13(join18(dir, "cost-events.jsonl")))
-    fold.push("cost-events.jsonl");
-  if (existsSync13(join18(dir, "context-registry.jsonl")))
-    fold.push("context-registry.jsonl");
+  const hasCostEvents = existsSync13(join18(dir, "cost-events.jsonl"));
+  const hasRegistry = existsSync13(join18(dir, "context-registry.jsonl"));
   let report = "";
   const reportPath = join18(dir, "report.md");
   if (files.includes("report.md"))
@@ -2823,23 +3233,92 @@ Trail ${chars} chars exceeds ${pct}% of budget ${budget} (threshold ${compressTh
       writeFileSync9(prVerdictPath, readFileSync13(prVerdictSrc, "utf8"));
       kept.push(join18("missions", mission, PR_VERDICT));
     }
-    if (fold.length) {
-      const sections = fold.map((f) => {
-        const body = readFileSync13(join18(dir, f), "utf8").trim();
-        const name = f.includes("/") ? f.split("/").pop() ?? f : f;
-        return `
+    if (!report.trim()) {
+      const date = new Date().toISOString().slice(0, 10);
+      const actor = typeof state?.actor === "string" ? state.actor : "unknown";
+      const branch = typeof state?.branch === "string" ? state.branch : "unknown";
+      const laneStr = typeof state?.lane === "string" ? state.lane : "unknown";
+      const modeStr = typeof state?.mode === "string" ? state.mode : "unknown";
+      report = `# Mission: ${mission}
+${date} · ${actor} · branch \`${branch}\` · lane **${laneStr}** · mode ${modeStr}
+`;
+    }
+    if (!report.includes("## Verdict")) {
+      const parts = report.split(`
+`);
+      const headerLines = parts.slice(0, 2).join(`
+`);
+      const rest = parts.slice(2).join(`
+`);
+      report = `${headerLines}
+
+## Verdict
+**GO** — all gates passed.
+` + rest;
+    }
+    const sections = fold.map((f) => {
+      const body = readFileSync13(join18(dir, f), "utf8").trim();
+      const name = f.includes("/") ? f.split("/").pop() ?? f : f;
+      return `
 
 ## Archived: ${name}
 
 ${body}`;
-      }).join("");
+    }).join("");
+    let extraSections = "";
+    if (state) {
+      const filesTouched = typeof state.files_touched === "number" ? state.files_touched : 0;
+      const locIns = typeof state.loc_ins === "number" ? state.loc_ins : 0;
+      const locDel = typeof state.loc_del === "number" ? state.loc_del : 0;
+      const sens = Array.isArray(state.sensitive_paths) ? state.sensitive_paths : [];
+      extraSections += `
+
+## What changed
+${filesTouched} files, +${locIns} / -${locDel}.
+`;
+      if (sens.length)
+        extraSections += `Sensitive paths touched: \`${sens.join("`, `")}\`
+`;
+      extraSections += `
+## Gates
+| Gate | Verdict | Evidence |
+|---|---|---|
+| Checkpoint (Flow 4) | PASS | \`flows/04-audit.md\` |
+| Quality (Flow 5) | PASS | \`flows/05-quality.md\` |
+| Coverage (Flow 6) | PASS | \`flows/05-quality.md\` |
+| Security (Flow 7) | PASS | \`review/security.md\` |
+`;
+      try {
+        const decRaw = existsSync13(join18(dir, "decisions.md")) ? readFileSync13(join18(dir, "decisions.md"), "utf8").trim() : "";
+        if (decRaw)
+          extraSections += `
+## Decisions
+${decRaw}
+`;
+        else
+          extraSections += `
+## Decisions
+No decisions recorded.
+`;
+      } catch {
+        extraSections += `
+## Decisions
+No decisions recorded.
+`;
+      }
+      extraSections += `
+## Not verified
+Nothing was left unverified.
+`;
+    }
+    const routingSection = state ? renderRouting(rankFiles(changedFiles(projectDir, state), {
+      mission,
+      evidence: Array.isArray(state.evidence) ? state.evidence : [],
+      sensitive_paths: Array.isArray(state.sensitive_paths) ? state.sensitive_paths : []
+    }), mission) : "";
+    if (fold.length || sections || extraSections || routingSection || costSection || !existsSync13(reportPath)) {
       const tmp = `${reportPath}.tmp`;
-      const routingSection = state ? renderRouting(rankFiles(changedFiles(projectDir, state), {
-        mission,
-        evidence: Array.isArray(state.evidence) ? state.evidence : [],
-        sensitive_paths: Array.isArray(state.sensitive_paths) ? state.sensitive_paths : []
-      }), mission) : "";
-      writeFileSync9(tmp, report.trimEnd() + sections + (routingSection || "") + (costSection ? `
+      writeFileSync9(tmp, report.trimEnd() + sections + extraSections + (routingSection || "") + (costSection ? `
 ${costSection}
 ` : "") + `
 `);
@@ -2849,11 +3328,19 @@ ${costSection}
       rmSync2(join18(dir, f), { force: true, recursive: true });
       removed.push(join18("missions", mission, f));
     }
+    if (hasCostEvents) {
+      rmSync2(join18(dir, "cost-events.jsonl"), { force: true });
+      removed.push(join18("missions", mission, "cost-events.jsonl"));
+    }
+    if (hasRegistry) {
+      rmSync2(join18(dir, "context-registry.jsonl"), { force: true });
+      removed.push(join18("missions", mission, "context-registry.jsonl"));
+    }
     if (existsSync13(prVerdictSrc)) {
       rmSync2(join18(dir, PR_VERDICT_SRC), { force: true });
       removed.push(join18("missions", mission, PR_VERDICT_SRC));
     }
-    for (const f of files.filter((f2) => f2.endsWith(".json")))
+    for (const f of files.filter((f) => f.endsWith(".json")))
       rmSync2(join18(dir, f), { force: true });
     if (existsSync13(artDir) && readdirSync7(artDir).length === 0)
       rmSync2(artDir, { recursive: true, force: true });
@@ -3016,15 +3503,15 @@ function gitActor(cwd) {
   const author = (process.env.GIT_AUTHOR_NAME ?? "").trim();
   if (author)
     return author;
-  const git3 = (args) => {
+  const git = (args) => {
     try {
       return execFileSync5("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     } catch {
       return "";
     }
   };
-  const name = git3(["config", "user.name"]);
-  const email = git3(["config", "user.email"]);
+  const name = git(["config", "user.name"]);
+  const email = git(["config", "user.email"]);
   if (name && email)
     return `${name} <${email}>`;
   return name || process.env.USER || process.env.USERNAME || "";
@@ -3179,31 +3666,142 @@ function formatResume(e) {
   return `Resumed: ${e.mission}${scope}, Flow ${e.flow}, ${e.tasks_done}/${e.tasks_total} tasks — next_action: ${e.next_action} — run: ${next}`;
 }
 
-// src/slop.ts
-function detectHealingSlop(input) {
-  const kind = "healing";
-  const max = input.max_cycles ?? 3;
-  const hasZeroHistory = input.history_fixes.some((n) => n === 0);
-  if (input.fixes_in_cycle === 0 && hasZeroHistory) {
-    return { slop: true, reason: `slop: healing — no fixes in cycle ${input.cycle} with previous zero-fix cycle`, kind };
+// src/initiative.ts
+import { existsSync as existsSync16, readFileSync as readFileSync15 } from "node:fs";
+var SUB_MISSIONS_HEADER = "| ID | Name | Assignee | Branch | Status | Depends On | Touched Files |";
+function splitTouchedFiles(cell) {
+  return cell.split(/[,\s]+/).map((s) => s.trim().replace(/,+$/, "")).filter(Boolean);
+}
+function splitRow(line) {
+  let t = line.trim();
+  if (t.startsWith("|"))
+    t = t.slice(1);
+  if (t.endsWith("|"))
+    t = t.slice(0, -1);
+  return t.split("|").map((c) => c.trim());
+}
+function parseSubMissions(planText) {
+  const lines = planText.split(`
+`);
+  const sectionIdx = lines.findIndex((l) => /^##\s+sub-missions\s*$/i.test(l.trim()));
+  if (sectionIdx < 0)
+    return { hasSection: false, rows: [] };
+  const endIdx = lines.findIndex((l, i) => i > sectionIdx && /^##\s+\S/.test(l.trim()));
+  const body = lines.slice(sectionIdx + 1, endIdx < 0 ? undefined : endIdx);
+  const isTableLine = (l) => /^\s*\|.*\|\s*$/.test(l);
+  const isSeparator = (l) => /^\s*\|?[\s:|-]+\|?[\s:|.-]*$/.test(l) && /-/.test(l);
+  const table = body.filter((l) => isTableLine(l));
+  if (!table.length)
+    return { hasSection: true, rows: [] };
+  const header = splitRow(table[0]).map((c) => c.toLowerCase());
+  const idIdx = header.findIndex((c) => c === "id");
+  const nameIdx = header.findIndex((c) => c === "name");
+  if (idIdx < 0 || nameIdx < 0)
+    return { hasSection: true, rows: [] };
+  const col = (name, fallback) => {
+    const i = header.findIndex((c) => c === name);
+    return i < 0 ? fallback : i;
+  };
+  const touchedIdx = header.findIndex((c) => /touch/.test(c));
+  const dataStart = table.length > 1 && isSeparator(table[1]) ? 2 : 1;
+  const rows = [];
+  for (const line of table.slice(dataStart)) {
+    if (isSeparator(line))
+      continue;
+    const cells = splitRow(line);
+    const id = cells[idIdx] ?? "";
+    if (!id)
+      continue;
+    rows.push({
+      id,
+      name: cells[nameIdx] ?? "",
+      assignee: cells[col("assignee", 2)] ?? "",
+      branch: cells[col("branch", 3)] ?? "",
+      status: cells[col("status", 4)] ?? "",
+      dependsOn: cells[col("depends on", 5)] ?? "",
+      touchedFiles: touchedIdx < 0 ? [] : splitTouchedFiles(cells[touchedIdx] ?? "")
+    });
   }
-  if (input.cycle >= max && input.fixes_in_cycle === 0) {
-    return { slop: true, reason: `slop: healing — cycle ${input.cycle} ≥ max ${max} with no fixes`, kind };
+  return { hasSection: true, rows };
+}
+var DONE = /(\[x\]|done|complete|merged|closed)/i;
+function blockedRows(rows) {
+  const statusOf = new Map(rows.map((r) => [r.id.toLowerCase(), r.status]));
+  const out = [];
+  for (const r of rows) {
+    const dep = r.dependsOn.trim();
+    if (!dep || dep === "-")
+      continue;
+    for (const part of dep.split(/[,\s]+/).filter(Boolean)) {
+      const st = statusOf.get(part.toLowerCase());
+      if (st !== undefined && !DONE.test(st)) {
+        out.push({ id: r.id, blockedBy: part });
+        break;
+      }
+      if (st === undefined && !DONE.test(dep)) {
+        out.push({ id: r.id, blockedBy: part });
+        break;
+      }
+    }
   }
-  return { slop: false, reason: "no slop — healing making progress", kind };
+  return out;
 }
-function computeLiveSlop(input) {
-  const rows = [];
-  const thr = input.repeated_read_threshold ?? 3;
-  const heal = detectHealingSlop({ cycle: input.heal_cycle, fixes_in_cycle: 0, history_fixes: [], max_cycles: input.max_heal_cycles ?? 3 });
-  if (heal.slop)
-    rows.push({ role: "Brook", kind: "healing", reason: heal.reason });
-  if (input.repeated_reads >= thr)
-    rows.push({ role: "all", kind: "context", reason: `repeated reads ${input.repeated_reads} ≥ ${thr}` });
-  const perRole = {};
-  for (const r of rows)
-    perRole[r.role] = (perRole[r.role] ?? 0) + 1;
-  return { interventions: rows.length, perRole, rows };
+function findConflicts(rows) {
+  const owners = new Map;
+  for (const r of rows) {
+    for (const f of r.touchedFiles) {
+      const list = owners.get(f) ?? [];
+      if (!list.includes(r.id))
+        list.push(r.id);
+      owners.set(f, list);
+    }
+  }
+  return [...owners.entries()].filter(([, ids]) => ids.length > 1).map(([file, ids]) => ({ file, ids }));
+}
+function runInitiative(sub, planPath) {
+  if (!sub || sub !== "status" && sub !== "conflict-check") {
+    return { code: 1, output: `usage: mugiwara initiative <status|conflict-check> <plan>
+` };
+  }
+  if (!planPath) {
+    return { code: 1, output: `usage: mugiwara initiative ${sub} <plan>
+` };
+  }
+  if (!existsSync16(planPath)) {
+    return { code: 1, output: `mugiwara: plan not found: ${planPath}
+` };
+  }
+  const { hasSection, rows } = parseSubMissions(readFileSync15(planPath, "utf8"));
+  if (!hasSection) {
+    return { code: 0, output: `solo mission (no ## Sub-missions section)
+` };
+  }
+  if (!rows.length) {
+    return {
+      code: 1,
+      output: `mugiwara: ## Sub-missions section present but no rows parsed — expected header:
+${SUB_MISSIONS_HEADER}
+`
+    };
+  }
+  if (sub === "status") {
+    const blocked = new Map(blockedRows(rows).map((b) => [b.id, b.blockedBy]));
+    const lines = ["id | name | assignee | branch | status | blocked-by"];
+    for (const r of rows) {
+      lines.push(`${r.id} | ${r.name} | ${r.assignee} | ${r.branch} | ${r.status} | ${blocked.get(r.id) ?? "-"}`);
+    }
+    return { code: 0, output: lines.join(`
+`) + `
+` };
+  }
+  const conflicts = findConflicts(rows);
+  if (!conflicts.length)
+    return { code: 0, output: `no conflicts: no file is touched by two sub-missions
+` };
+  const lines = conflicts.map((c) => `conflict: ${c.file} touched by ${c.ids.join(", ")}`);
+  return { code: 1, output: lines.join(`
+`) + `
+` };
 }
 
 // src/cli.ts
@@ -3276,7 +3874,11 @@ async function run(argv) {
     case "sign":
       return signCmd(flags, _);
     case "migrate":
-      return migrateCmd(flags);
+      return migrateCmd(flags, _);
+    case "lesson":
+      return lessonCmd(flags, _);
+    case "initiative":
+      return initiativeCmd(flags, _);
     default:
       throw new Error(`Unknown command: ${command}`);
   }
@@ -3319,7 +3921,7 @@ function cleanCmd(flags) {
   const projectDir = resolveProjectDir(str(flags.project));
   const dryRun = flag(flags.dryRun);
   const root = join21(projectDir, ".mugiwara", "missions");
-  if (!existsSync16(root)) {
+  if (!existsSync17(root)) {
     console.log("nothing to clean (.mugiwara/missions/ does not exist).");
     return;
   }
@@ -3340,7 +3942,7 @@ function cleanCmd(flags) {
       return false;
     for (const f of stateFiles(m)) {
       try {
-        const ts = Date.parse(JSON.parse(readFileSync15(join21(root, m, f), "utf8")).updated_at ?? "") || 0;
+        const ts = Date.parse(JSON.parse(readFileSync16(join21(root, m, f), "utf8")).updated_at ?? "") || 0;
         if (ts === 0 || ts >= beforeMs)
           return false;
       } catch {
@@ -3350,7 +3952,7 @@ function cleanCmd(flags) {
     return true;
   };
   if (!flag(flags.all)) {
-    candidates = candidates.filter((m) => existsSync16(join21(root, m, "report.md")) && !hasLiveState(m) || staleBefore(m));
+    candidates = candidates.filter((m) => existsSync17(join21(root, m, "report.md")) && !hasLiveState(m) || staleBefore(m));
   } else if (!flag(flags.force)) {
     const live = candidates.filter((m) => hasLiveState(m) && !staleBefore(m));
     if (live.length) {
@@ -3384,7 +3986,7 @@ async function resolveOptions(flags) {
         scope = await choose(rl, "Install scope?", ["global (user-wide)", "project (this repo)"]) === 0 ? "global" : "project";
     }
     const projectDir = resolveProjectDir(str(flags.project));
-    if (scope === "project" && !existsSync16(projectDir))
+    if (scope === "project" && !existsSync17(projectDir))
       throw new Error(`Project dir not found: ${projectDir}`);
     let targetIds = str(flags.target)?.split(",").map((s) => s.trim()) ?? null;
     if (targetIds && targetIds.includes("all"))
@@ -3397,7 +3999,13 @@ async function resolveOptions(flags) {
         targetIds = idx.includes(0) ? [...TARGET_IDS] : idx.map((i) => TARGET_IDS[i - 1]);
       }
     }
+    const MARKETPLACE = new Set(["cursor", "kimi", "pi"]);
     for (const id of targetIds) {
+      if (MARKETPLACE.has(id)) {
+        console.error(`mugiwara: ${id} installs through its marketplace manifest, not --target.`);
+        console.error("  See docs/reference/harness-matrix.md — marketplace row.");
+        process.exit(1);
+      }
       if (!targets[id])
         throw new Error(`Unknown target: ${id} (valid: ${TARGET_IDS.join(", ")}, all)`);
     }
@@ -3465,7 +4073,7 @@ async function uninstall(flags) {
   if (!manifest) {
     if (scope === "project") {
       const globalFile = manifestPath({ scope: "global", projectDir, home });
-      if (existsSync16(globalFile)) {
+      if (existsSync17(globalFile)) {
         console.log(`No project manifest found, but a global install exists. Try:
   mugiwara uninstall --global`);
         return;
@@ -3503,12 +4111,12 @@ async function uninstall(flags) {
     }
     rmSync3(file);
     const mugiDir = join21(scope === "global" ? home : projectDir, ".mugiwara");
-    if (existsSync16(mugiDir) && readdirSync10(mugiDir).length === 0) {
+    if (existsSync17(mugiDir) && readdirSync10(mugiDir).length === 0) {
       rmSync3(mugiDir, { recursive: true, force: true });
     }
     if (manifest.targets.includes("opencode")) {
       const opencodeCache = join21(home, ".cache", "opencode", "packages", "@ionivetech");
-      if (existsSync16(opencodeCache)) {
+      if (existsSync17(opencodeCache)) {
         rmSync3(opencodeCache, { recursive: true, force: true });
         console.log("   cleared opencode npm cache (stale plugin versions)");
       }
@@ -3545,7 +4153,7 @@ function list(flags) {
       continue;
     found = true;
     if (flag(flags.check)) {
-      const missing = m.files.filter((f) => !existsSync16(f));
+      const missing = m.files.filter((f) => !existsSync17(f));
       console.log(`${label}: v${m.version} targets=${m.targets.join(",")} files=${m.files.length} missing=${missing.length} installed=${m.installedAt}`);
     } else {
       console.log(`${label}: v${m.version} targets=${m.targets.join(",")} files=${m.files.length} installed=${m.installedAt}`);
@@ -3563,9 +4171,9 @@ function continueCmd(flags, positionals) {
   if (mission) {
     readState(projectDir);
     const badState = unreadableStateFiles();
-    const target10 = member ? `${mission}/${member}.json` : `${mission}/state.json`;
-    if (badState.includes(target10)) {
-      console.error(`✗ mission "${mission}"${member ? ` member "${member}"` : ""} has unreadable state: ${target10}`);
+    const target = member ? `${mission}/${member}.json` : `${mission}/state.json`;
+    if (badState.includes(target)) {
+      console.error(`✗ mission "${mission}"${member ? ` member "${member}"` : ""} has unreadable state: ${target}`);
       process.exit(1);
     }
   }
@@ -3636,10 +4244,10 @@ function statusCmd(flags) {
 function costCmd(flags, positionals) {
   const projectDir = resolveProjectDir(str(flags.project));
   const mission = str(flags.mission) ?? positionals[1] ?? (() => {
-    const states2 = readState(projectDir);
-    if (states2.length === 1)
-      return states2[0].mission;
-    if (states2.length > 1) {
+    const states = readState(projectDir);
+    if (states.length === 1)
+      return states[0].mission;
+    if (states.length > 1) {
       console.error("multiple missions in flight — specify --mission <id>");
       process.exit(1);
     }
@@ -3650,7 +4258,7 @@ function costCmd(flags, positionals) {
     process.exit(1);
   }
   const missionDir = join21(projectDir, ".mugiwara", "missions", mission);
-  if (!existsSync16(missionDir)) {
+  if (!existsSync17(missionDir)) {
     console.error(`No cost ledger found for mission "${mission}"`);
     process.exit(1);
   }
@@ -3709,7 +4317,7 @@ function blameCmd(flags, positionals) {
 function stalenessLine(projectDir, baseSha) {
   if (!baseSha || baseSha === "unknown")
     return null;
-  const git3 = (args) => {
+  const git = (args) => {
     try {
       return execFileSync6("git", args, { cwd: projectDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     } catch {
@@ -3718,14 +4326,14 @@ function stalenessLine(projectDir, baseSha) {
   };
   let main = "";
   for (const ref of ["main", "master"]) {
-    main = git3(["rev-parse", "--verify", ref]);
+    main = git(["rev-parse", "--verify", ref]);
     if (main)
       break;
   }
   if (!main)
     return null;
   try {
-    const behind = Number(git3(["rev-list", "--count", `${baseSha}..${main}`])) || 0;
+    const behind = Number(git(["rev-list", "--count", `${baseSha}..${main}`])) || 0;
     return behind > 0 ? `⚠ stale base: main is ${behind} commit(s) ahead of this mission's base ${baseSha.slice(0, 7)} — rebase check before continuing` : null;
   } catch {
     return null;
@@ -3784,15 +4392,178 @@ function handoffCmd(flags, positionals) {
   console.log(`
 written: ${out}`);
 }
-function migrateCmd(flags) {
+function lessonCmd(flags, positionals) {
+  const projectDir = resolveProjectDir(str(flags.project));
+  const text = positionals.slice(1).join(" ").trim();
+  if (!text) {
+    console.error('usage: mugiwara lesson "<text>" [--project <dir>]');
+    process.exit(1);
+  }
+  const file = join21(projectDir, ".mugiwara", "lessons.md");
+  const date = new Date().toISOString().slice(0, 10);
+  const sanitized = text.replace(/\|/g, "/").replace(/\r?\n/g, " ").trim();
+  const line = `| ${date} | manual | general | ${sanitized} |`;
+  const header = `| Date | Mission | Area | Lesson |
+|---|---|---|---|`;
+  let existing = "";
+  try {
+    existing = readFileSync16(file, "utf8");
+  } catch {}
+  if (!existing) {
+    mkdirSync10(join21(projectDir, ".mugiwara"), { recursive: true });
+    writeFileSync10(file, header + `
+` + line + `
+`);
+  } else {
+    const needsNewline = !existing.endsWith(`
+`);
+    writeFileSync10(file, existing + (needsNewline ? `
+` : "") + line + `
+`);
+  }
+  console.log(`lesson appended: ${line}`);
+}
+function initiativeCmd(_flags, positionals) {
+  const r = runInitiative(positionals[1], positionals[2]);
+  process.stdout.write(r.output);
+  if (r.code !== 0)
+    process.exit(r.code);
+}
+function migrateCmd(flags, positionals = []) {
   const projectDir = resolveProjectDir(str(flags.project));
   const dryRun = flag(flags.dryRun);
+  const toTeam = str(flags.toTeam);
+  const toSolo = str(flags.toSolo);
+  if (toTeam || toSolo) {
+    const member = toTeam ?? toSolo;
+    if (!/^[A-Za-z0-9._-]+$/.test(member) || /^\.+$/.test(member) || member === "state" || member === "continue") {
+      console.error(`invalid member name "${member}" (allowlist: [a-zA-Z0-9._-], not a dot-path, not state/continue)`);
+      process.exit(1);
+    }
+    if (toTeam && toSolo) {
+      console.error("use either --to-team or --to-solo, not both");
+      process.exit(1);
+    }
+    const missionsRootInner = join21(projectDir, ".mugiwara", "missions");
+    let mission = str(flags.mission) ?? (positionals[1] ? String(positionals[1]) : null);
+    const inferMission = () => {
+      if (!existsSync17(missionsRootInner))
+        return null;
+      const all = readdirSync10(missionsRootInner, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+      if (mission && all.includes(mission))
+        return mission;
+      if (mission)
+        return mission;
+      if (toTeam) {
+        const candidates = all.filter((m) => existsSync17(join21(missionsRootInner, m, "state.json")));
+        if (candidates.length === 1)
+          return candidates[0];
+        if (candidates.length === 0) {
+          console.error("no solo mission with state.json found for --to-team");
+          process.exit(1);
+        }
+        console.error(`multiple solo missions: ${candidates.join(", ")} — specify --mission <id>`);
+        process.exit(1);
+      } else {
+        const candidates = all.filter((m) => existsSync17(join21(missionsRootInner, m, `${member}.json`)));
+        if (candidates.length === 1)
+          return candidates[0];
+        if (candidates.length === 0) {
+          console.error(`no mission with ${member}.json found for --to-solo`);
+          process.exit(1);
+        }
+        console.error(`multiple missions with ${member}.json: ${candidates.join(", ")} — specify --mission <id>`);
+        process.exit(1);
+      }
+      return null;
+    };
+    const targetMission = inferMission();
+    if (!targetMission) {
+      console.error("could not infer mission — specify --mission <id>");
+      process.exit(1);
+    }
+    const dir = join21(missionsRootInner, targetMission);
+    if (toTeam) {
+      const srcState = join21(dir, "state.json");
+      const srcContinue = join21(dir, "continue.json");
+      const destState = join21(dir, `${member}.json`);
+      const destContinue = join21(dir, `continue-${member}.json`);
+      if (!existsSync17(srcState)) {
+        console.error(`mission "${targetMission}" has no state.json — already team or not found`);
+        process.exit(1);
+      }
+      if (existsSync17(destState)) {
+        console.error(`destination ${destState} already exists`);
+        process.exit(1);
+      }
+      const toMove = [{ src: srcState, dest: destState }];
+      if (existsSync17(srcContinue))
+        toMove.push({ src: srcContinue, dest: destContinue });
+      for (const m of toMove) {
+        console.log(`${dryRun ? "would migrate" : "migrated"} ${m.src} → ${m.dest}`);
+        if (!dryRun) {
+          mkdirSync10(dirname6(m.dest), { recursive: true });
+          try {
+            renameSync2(m.src, m.dest);
+          } catch {
+            try {
+              writeFileSync10(m.dest, readFileSync16(m.src));
+              rmSync3(m.src, { force: true });
+            } catch {}
+          }
+        }
+      }
+      console.log(`${dryRun ? "would migrate" : "migrated"} ${toMove.length} file(s)${dryRun ? " (dry run)" : ""}`);
+      return;
+    } else {
+      const srcState = join21(dir, `${member}.json`);
+      const srcContinue = join21(dir, `continue-${member}.json`);
+      const destState = join21(dir, "state.json");
+      const destContinue = join21(dir, "continue.json");
+      if (!existsSync17(srcState)) {
+        console.error(`mission "${targetMission}" has no ${member}.json`);
+        process.exit(1);
+      }
+      const files = readdirSync10(dir).filter((f) => {
+        const stem = f.replace(/\.json$/, "");
+        return f.endsWith(".json") && stem !== "continue" && !stem.startsWith("continue-");
+      });
+      const members = files.filter((f) => f !== "state.json");
+      if (members.length > 1) {
+        console.error(`mission "${targetMission}" has ${members.length} members (${members.join(", ")}) — refusing --to-solo (would orphan)`);
+        process.exit(1);
+      }
+      if (existsSync17(destState)) {
+        console.error(`destination ${destState} already exists`);
+        process.exit(1);
+      }
+      const toMove = [{ src: srcState, dest: destState }];
+      if (existsSync17(srcContinue))
+        toMove.push({ src: srcContinue, dest: destContinue });
+      for (const m of toMove) {
+        console.log(`${dryRun ? "would migrate" : "migrated"} ${m.src} → ${m.dest}`);
+        if (!dryRun) {
+          mkdirSync10(dirname6(m.dest), { recursive: true });
+          try {
+            renameSync2(m.src, m.dest);
+          } catch {
+            try {
+              writeFileSync10(m.dest, readFileSync16(m.src));
+              rmSync3(m.src, { force: true });
+            } catch {}
+          }
+        }
+      }
+      console.log(`${dryRun ? "would migrate" : "migrated"} ${toMove.length} file(s)${dryRun ? " (dry run)" : ""}`);
+      return;
+    }
+  }
   const legacyState = join21(projectDir, ".mugiwara", "state");
   const legacyContinue = join21(projectDir, ".mugiwara", "continue");
   const missionsRoot = join21(projectDir, ".mugiwara", "missions");
   const moves = [];
   const collect = (srcRoot, isContinue) => {
-    if (!existsSync16(srcRoot))
+    if (!existsSync17(srcRoot))
       return;
     const walk = (dir) => {
       for (const e of readdirSync10(dir, { withFileTypes: true })) {
@@ -3825,7 +4596,7 @@ function migrateCmd(flags) {
   collect(legacyState, false);
   collect(legacyContinue, true);
   if (!moves.length) {
-    if (!existsSync16(legacyState) && !existsSync16(legacyContinue)) {
+    if (!existsSync17(legacyState) && !existsSync17(legacyContinue)) {
       console.log("no legacy layout found (.mugiwara/state/ does not exist)");
     } else {
       console.log("no legacy state files to migrate");
@@ -3837,7 +4608,7 @@ function migrateCmd(flags) {
     if (!dryRun) {
       mkdirSync10(dirname6(m.dest), { recursive: true });
       try {
-        const raw = JSON.parse(readFileSync15(m.src, "utf8"));
+        const raw = JSON.parse(readFileSync16(m.src, "utf8"));
         raw.schema_version = CURRENT_SCHEMA_VERSION;
         writeFileSync10(m.dest, JSON.stringify(raw, null, 2) + `
 `);
@@ -3851,7 +4622,7 @@ function migrateCmd(flags) {
   }
   if (!dryRun) {
     const prune = (root) => {
-      if (!existsSync16(root))
+      if (!existsSync17(root))
         return;
       const walkPrune = (dir) => {
         for (const e of readdirSync10(dir, { withFileTypes: true })) {
@@ -3865,7 +4636,7 @@ function migrateCmd(flags) {
       };
       walkPrune(root);
       try {
-        if (existsSync16(root) && readdirSync10(root).length === 0)
+        if (existsSync17(root) && readdirSync10(root).length === 0)
           rmSync3(root, { recursive: true, force: true });
       } catch {}
     };
@@ -3903,7 +4674,7 @@ function signCmd(flags, _) {
     process.exit(1);
   }
   const missionDir = join21(projectDir, ".mugiwara", "missions", mission);
-  if (!existsSync16(missionDir)) {
+  if (!existsSync17(missionDir)) {
     console.error(`no mission dir: ${missionDir}`);
     process.exit(1);
   }
@@ -3939,7 +4710,12 @@ Usage:
   mugiwara sign --gen-key [--backend pure|minisign]
                          create signing keys (pure ed25519 default)
   mugiwara migrate [--dry-run] [--project <dir>]
-                          move legacy .mugiwara/state/ layout to .mugiwara/missions/
+                           move legacy .mugiwara/state/ layout to .mugiwara/missions/
+  mugiwara migrate --to-team <member> [--mission <id>] [--dry-run]
+                           move state.json -> <member>.json (solo -> team)
+  mugiwara migrate --to-solo <member> [--mission <id>] [--dry-run]
+                           move <member>.json -> state.json (team -> solo; refuses if >1 member)
+  mugiwara lesson "<text>" append a dated row to .mugiwara/lessons.md
   mugiwara run <script> [args...]
                           run a bundled harness script here (${RUNNABLE.join(", ")})
   mugiwara savepoint <mission> [member] [flow] [mode]