@ionivetech/mugiwara 0.8.2 → 0.9.0

package/dist/mugiwara.js

@@ -8,7 +8,7 @@ import { dirname as dirname6, join as join21, resolve as resolve2 } from "node:p
 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",
@@ -633,24 +633,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=on               # 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 +704,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 +727,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");
@@ -2242,10 +2284,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 +2331,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 +2553,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 +3028,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,47 +3134,17 @@ ${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 {}
@@ -2805,10 +3216,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 +3232,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,6 +3327,14 @@ ${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));
@@ -3179,33 +3665,6 @@ 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 };
-  }
-  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/cli.ts
 var str = (v) => typeof v === "string" ? v : undefined;
 var flag = (v) => v === true;
@@ -3276,7 +3735,9 @@ async function run(argv) {
     case "sign":
       return signCmd(flags, _);
     case "migrate":
-      return migrateCmd(flags);
+      return migrateCmd(flags, _);
+    case "lesson":
+      return lessonCmd(flags, _);
     default:
       throw new Error(`Unknown command: ${command}`);
   }
@@ -3784,9 +4245,166 @@ function handoffCmd(flags, positionals) {
   console.log(`
 written: ${out}`);
 }
-function migrateCmd(flags) {
+function lessonCmd(flags, positionals) {
+  const projectDir = resolveProjectDir(str(flags.project));
+  const text2 = positionals.slice(1).join(" ").trim();
+  if (!text2) {
+    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 = text2.replace(/\|/g, "/").replace(/\r?\n/g, " ").trim();
+  const line = `| ${date} | manual | general | ${sanitized} |`;
+  const header = `| Date | Mission | Area | Lesson |
+|---|---|---|---|`;
+  let existing = "";
+  try {
+    existing = readFileSync15(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 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 (!existsSync16(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) => existsSync16(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) => existsSync16(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 (!existsSync16(srcState)) {
+        console.error(`mission "${targetMission}" has no state.json — already team or not found`);
+        process.exit(1);
+      }
+      if (existsSync16(destState)) {
+        console.error(`destination ${destState} already exists`);
+        process.exit(1);
+      }
+      const toMove = [{ src: srcState, dest: destState }];
+      if (existsSync16(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, readFileSync15(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 (!existsSync16(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 (existsSync16(destState)) {
+        console.error(`destination ${destState} already exists`);
+        process.exit(1);
+      }
+      const toMove = [{ src: srcState, dest: destState }];
+      if (existsSync16(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, readFileSync15(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");
@@ -3939,7 +4557,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]