@ionivetech/mugiwara 0.8.0 → 0.8.2

package/dist/mugiwara.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync as existsSync15, readdirSync as readdirSync10, readFileSync as readFileSync14, rmSync as rmSync3, writeFileSync as writeFileSync10 } from "node:fs";
+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 { execFileSync as execFileSync6 } from "node:child_process";
 import { homedir as homedir4 } from "node:os";
-import { join as join20, resolve as resolve2 } from "node:path";
+import { dirname as dirname6, join as join21, resolve as resolve2 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/args.ts
@@ -623,7 +623,7 @@ var targets = { claude: target, opencode: target2, copilot: target3, gemini: tar
 var TARGET_IDS = Object.keys(targets);
 
 // src/installer.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, readdirSync as readdirSync3, writeFileSync as writeFileSync4, copyFileSync as copyFileSync3, rmSync, lstatSync as lstatSync2 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, readdirSync as readdirSync3, writeFileSync as writeFileSync4, copyFileSync as copyFileSync3, rmSync, lstatSync as lstatSync2, chmodSync as chmodSync2 } from "node:fs";
 import { dirname as dirname3, join as join6 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
@@ -658,6 +658,17 @@ function configPaths(projectDir) {
   return [join5(projectDir, ".mugiwara", "config"), join5(homedir(), ".mugiwara", "config")];
 }
 function readConfig(projectDir) {
+  try {
+    const file = join5(projectDir, ".mugiwara", "config");
+    let exists = false;
+    try {
+      exists = lstatSync(file).isFile() || lstatSync(file).isSymbolicLink();
+    } catch {
+      exists = false;
+    }
+    if (!exists)
+      ensureConfig(projectDir);
+  } catch {}
   const out = {};
   for (const file of configPaths(projectDir)) {
     if (!existsSync4(file))
@@ -696,6 +707,7 @@ function ensureConfig(projectDir) {
 
 // src/installer.ts
 var CONTENT_DIR = join6(dirname3(fileURLToPath3(import.meta.url)), "..", "content");
+var REPO_ROOT = join6(dirname3(fileURLToPath3(import.meta.url)), "..");
 var pkg = JSON.parse(readFileSync4(join6(dirname3(fileURLToPath3(import.meta.url)), "..", "package.json"), "utf8"));
 var VERSION = pkg.version;
 function collectContent() {
@@ -732,9 +744,14 @@ function installTo(target10, opts) {
   const dirs = target10.paths({ scope, projectDir, home });
   const backupRoot = join6(scope === "global" ? home : projectDir, ".mugiwara");
   const result = { written: [], skipped: [], backedUp: [], notes: [] };
-  const writeOne = (absPath, text) => {
+  const writeOne = (absPath, text, mode) => {
     if (existsSync5(absPath)) {
       if (readFileSync4(absPath, "utf8") === text) {
+        if (!dryRun && mode !== undefined) {
+          try {
+            chmodSync2(absPath, mode);
+          } catch {}
+        }
         result.skipped.push(absPath);
         return;
       }
@@ -756,6 +773,11 @@ function installTo(target10, opts) {
     if (!dryRun) {
       mkdirSync4(dirname3(absPath), { recursive: true });
       writeFileSync4(absPath, text);
+      if (mode !== undefined) {
+        try {
+          chmodSync2(absPath, mode);
+        } catch {}
+      }
     }
     result.written.push(absPath);
   };
@@ -799,6 +821,18 @@ function installTo(target10, opts) {
     for (const r of sharedRefs)
       writeOne(join6(sharedRoot, r.relPath), r.text);
   }
+  {
+    const SHELL_FALLBACKS = ["lane.sh", "savepoint.sh", "lib/patterns.sh", "lib/lane-base.sh"];
+    const mugiwaraDir = join6(scope === "global" ? home : projectDir, ".mugiwara");
+    for (const rel of SHELL_FALLBACKS) {
+      const src = join6(REPO_ROOT, "scripts", rel);
+      if (!existsSync5(src))
+        continue;
+      const text = readFileSync4(src, "utf8");
+      const dest = join6(mugiwaraDir, "bin", rel);
+      writeOne(dest, text, 493);
+    }
+  }
   if (target10.postInstall) {
     const post = target10.postInstall({ scope, projectDir, home, dryRun, files: result.written });
     result.written.push(...post.written);
@@ -957,32 +991,524 @@ function writeManifest(file, data) {
 }
 
 // src/mission.ts
-import { existsSync as existsSync11, rmSync as rmSync2, readFileSync as readFileSync11, readdirSync as readdirSync7, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8, renameSync, openSync, writeSync, closeSync } from "node:fs";
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync13, rmSync as rmSync2, readFileSync as readFileSync13, readdirSync as readdirSync7, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, renameSync, openSync, writeSync, closeSync } from "node:fs";
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { join as join18 } from "node:path";
+
+// src/integrity.ts
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync7 } from "node:fs";
+import { isAbsolute, join as join9, relative } from "node:path";
+
+// src/policy.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { join as join8 } from "node:path";
+var POLICY_FILES = ["mugiwara.policy.yml", "mugiwara.policy.yaml"];
+var KNOWN_ROOTS = ["lanes", "gates", "evidence", "integrity", "attestation", "harness"];
+function parsePolicyYaml(text) {
+  const root = {};
+  const stack = [{ keyIndent: -1, obj: root }];
+  const lines = text.split(/\r?\n/);
+  const process2 = (i) => {
+    if (i >= lines.length)
+      return;
+    const noComment = lines[i].replace(/(^|\s)#.*$/, "");
+    if (!noComment.trim())
+      return process2(i + 1);
+    const indent = noComment.length - noComment.trimStart().length;
+    const line = noComment.trim();
+    while (stack.length > 1 && indent <= stack[stack.length - 1].keyIndent)
+      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;
+      delete top.pending;
+      const created = {};
+      top.obj[key2] = created;
+      stack.push({ keyIndent: pIndent, obj: created });
+      return process2(i);
+    }
+    if (line.startsWith("- ")) {
+      if (top.pending) {
+        const existing = top.obj[top.pending.key];
+        const arr = Array.isArray(existing) ? existing : [];
+        arr.push(scalar(line.slice(2)));
+        top.obj[top.pending.key] = arr;
+      }
+      return process2(i + 1);
+    }
+    const colon = line.indexOf(":");
+    if (colon === -1)
+      return process2(i + 1);
+    const key = line.slice(0, colon).trim();
+    const rest = line.slice(colon + 1).trim();
+    if (rest === "") {
+      top.pending = { key, indent };
+    } else {
+      top.obj[key] = scalar(rest);
+      delete top.pending;
+    }
+    process2(i + 1);
+  };
+  process2(0);
+  return root;
+}
+function scalar(v) {
+  const t = v.trim().replace(/^["']|["']$/g, "");
+  if (/^-?\d+(\.\d+)?$/.test(t))
+    return Number(t);
+  if (t === "true")
+    return true;
+  if (t === "false")
+    return false;
+  return t;
+}
+function extractExtraSecretPatterns(text) {
+  const lines = text.split(/\r?\n/);
+  let inBlock = false;
+  let baseIndent = -1;
+  const out = [];
+  let current = null;
+  let currentIndent = -1;
+  for (const rawLine of lines) {
+    const noComment = rawLine.replace(/(^|\s)#.*$/, "");
+    if (!noComment.trim())
+      continue;
+    const indent = noComment.length - noComment.trimStart().length;
+    const trimmed = noComment.trim();
+    if (!inBlock) {
+      if (trimmed.startsWith("extra_secret_patterns:")) {
+        inBlock = true;
+        baseIndent = indent;
+        continue;
+      }
+    } else {
+      if (indent <= baseIndent && !trimmed.startsWith("-") && trimmed.includes(":")) {
+        break;
+      }
+      if (trimmed.startsWith("-")) {
+        if (current)
+          out.push(current);
+        current = {};
+        currentIndent = indent;
+        const afterDash = trimmed.slice(1).trim();
+        if (!afterDash)
+          continue;
+        if (afterDash.startsWith("{") && afterDash.endsWith("}")) {
+          const inner = afterDash.slice(1, -1);
+          for (const part of inner.split(",")) {
+            const colon = part.indexOf(":");
+            if (colon === -1)
+              continue;
+            const k = part.slice(0, colon).trim();
+            const v = part.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
+            if (k && v)
+              current[k] = v;
+          }
+        } else if (afterDash.includes(":")) {
+          const colon = afterDash.indexOf(":");
+          const k = afterDash.slice(0, colon).trim();
+          const v = afterDash.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
+          if (k && v)
+            current[k] = v;
+        } else {
+          const v = afterDash.replace(/^["']|["']$/g, "");
+          if (v)
+            current["pattern"] = v;
+        }
+      } else if (current && trimmed.includes(":")) {
+        if (indent > currentIndent) {
+          const colon = trimmed.indexOf(":");
+          const k = trimmed.slice(0, colon).trim();
+          const v = trimmed.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
+          if (k && v)
+            current[k] = v;
+        } else if (indent <= baseIndent) {
+          break;
+        }
+      }
+    }
+  }
+  if (current)
+    out.push(current);
+  return out.filter((o) => typeof o.pattern === "string" && typeof o.label === "string" && o.pattern.length > 0);
+}
+function extractAttestation(text) {
+  const lines = text.split(/\r?\n/);
+  let attBase = -1;
+  let inAtt = false;
+  let required;
+  const trusted = [];
+  const revoked = [];
+  let collecting = null;
+  let collectBase = -1;
+  let current = null;
+  let curIndent = -1;
+  const flush = () => {
+    if (!current)
+      return;
+    if (collecting === "trusted")
+      trusted.push(current);
+    else if (collecting === "revoked")
+      revoked.push(current);
+    current = null;
+  };
+  for (let idx = 0;idx < lines.length; idx++) {
+    const rawLine = lines[idx];
+    const noComment = rawLine.replace(/(^|\s)#.*$/, "");
+    if (!noComment.trim())
+      continue;
+    const indent = noComment.length - noComment.trimStart().length;
+    const trimmed = noComment.trim();
+    if (!inAtt) {
+      if (trimmed === "attestation:" || trimmed.startsWith("attestation:")) {
+        const after = trimmed.slice("attestation:".length).trim();
+        if (after.startsWith("{")) {
+          return null;
+        }
+        inAtt = true;
+        attBase = indent;
+        continue;
+      }
+      continue;
+    }
+    if (indent <= attBase && !trimmed.startsWith("-") && trimmed.includes(":")) {
+      flush();
+      break;
+    }
+    if (collecting) {
+      if (indent <= collectBase && !trimmed.startsWith("-") && trimmed.includes(":")) {
+        flush();
+        collecting = null;
+      } else if (trimmed.startsWith("-")) {
+        flush();
+        current = {};
+        curIndent = indent;
+        const afterDash = trimmed.slice(1).trim();
+        if (!afterDash)
+          continue;
+        if (afterDash.startsWith("{") && afterDash.endsWith("}")) {
+          const inner = afterDash.slice(1, -1);
+          for (const part of inner.split(",")) {
+            const colon = part.indexOf(":");
+            if (colon === -1)
+              continue;
+            const k = part.slice(0, colon).trim();
+            const v = part.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
+            if (k && v)
+              current[k] = v;
+          }
+        } else if (afterDash.includes(":")) {
+          const colon = afterDash.indexOf(":");
+          const k = afterDash.slice(0, colon).trim();
+          const v = afterDash.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
+          if (k && v)
+            current[k] = v;
+        } else {
+          const v = afterDash.replace(/^["']|["']$/g, "");
+          if (v)
+            current["id"] = v;
+        }
+        continue;
+      } else if (current && trimmed.includes(":")) {
+        if (indent > curIndent) {
+          const colon = trimmed.indexOf(":");
+          const k = trimmed.slice(0, colon).trim();
+          const v = trimmed.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
+          if (k && v)
+            current[k] = v;
+          continue;
+        }
+      }
+      if (collecting)
+        continue;
+    }
+    if (trimmed.startsWith("required:")) {
+      const v = trimmed.slice("required:".length).trim().replace(/^["']|["']$/g, "");
+      if (v === "true")
+        required = true;
+      else if (v === "false")
+        required = false;
+      continue;
+    }
+    if (trimmed.startsWith("trusted_keys:")) {
+      const after = trimmed.slice("trusted_keys:".length).trim();
+      if (after === "[]")
+        continue;
+      collecting = "trusted";
+      collectBase = indent;
+      current = null;
+      continue;
+    }
+    if (trimmed.startsWith("revoked:")) {
+      const after = trimmed.slice("revoked:".length).trim();
+      if (after === "[]")
+        continue;
+      collecting = "revoked";
+      collectBase = indent;
+      current = null;
+      continue;
+    }
+  }
+  flush();
+  if (required === undefined && trusted.length === 0 && revoked.length === 0)
+    return null;
+  const out = {};
+  if (required !== undefined)
+    out.required = required;
+  if (trusted.length)
+    out.trusted_keys = trusted;
+  if (revoked.length)
+    out.revoked = revoked;
+  return out;
+}
+function loadPolicy(projectDir) {
+  for (const name of POLICY_FILES) {
+    const file = join8(projectDir, name);
+    if (!existsSync7(file))
+      continue;
+    const text = readFileSync6(file, "utf8");
+    const raw = parsePolicyYaml(text);
+    const extra = extractExtraSecretPatterns(text);
+    if (extra.length) {
+      if (!raw.integrity || typeof raw.integrity !== "object" || Array.isArray(raw.integrity))
+        raw.integrity = {};
+      raw.integrity.extra_secret_patterns = extra;
+    }
+    const att = extractAttestation(text);
+    if (att) {
+      if (!raw.attestation || typeof raw.attestation !== "object" || Array.isArray(raw.attestation))
+        raw.attestation = {};
+      const a = raw.attestation;
+      if (att.required !== undefined)
+        a.required = att.required;
+      if (att.trusted_keys)
+        a.trusted_keys = att.trusted_keys;
+      if (att.revoked)
+        a.revoked = att.revoked;
+    }
+    return normalize(raw);
+  }
+  return null;
+}
+function normalize(raw) {
+  for (const k of Object.keys(raw)) {
+    if (!KNOWN_ROOTS.includes(k))
+      throw new Error(`unknown policy key "${k}" (known: ${KNOWN_ROOTS.join(", ")})`);
+  }
+  const out = {};
+  const lanes = raw.lanes;
+  if (lanes && Array.isArray(lanes.force_full))
+    out.lanes = { force_full: strings(lanes.force_full) };
+  const gates = raw.gates;
+  if (gates) {
+    out.gates = {};
+    const cov = gates.coverage;
+    if (cov) {
+      out.gates.coverage = {};
+      if (typeof cov.new === "number")
+        out.gates.coverage.new = cov.new;
+      if (typeof cov.modified === "number")
+        out.gates.coverage.modified = cov.modified;
+    }
+    if (Array.isArray(gates.require_human_approval))
+      out.gates.require_human_approval = strings(gates.require_human_approval);
+  }
+  const evidence = raw.evidence;
+  if (evidence) {
+    const ev = {};
+    if (Array.isArray(evidence.required))
+      ev.required = strings(evidence.required);
+    else if (typeof evidence.required === "string" && evidence.required.trim().startsWith("[")) {
+      try {
+        const p = JSON.parse(evidence.required);
+        if (Array.isArray(p))
+          ev.required = strings(p);
+      } catch {}
+    }
+    if (Array.isArray(evidence.require_nonempty_for_lanes))
+      ev.require_nonempty_for_lanes = strings(evidence.require_nonempty_for_lanes);
+    else if (typeof evidence.require_nonempty_for_lanes === "string" && evidence.require_nonempty_for_lanes.trim().startsWith("[")) {
+      try {
+        const p = JSON.parse(evidence.require_nonempty_for_lanes);
+        if (Array.isArray(p))
+          ev.require_nonempty_for_lanes = strings(p);
+      } catch {}
+    }
+    if (ev.required || ev.require_nonempty_for_lanes)
+      out.evidence = ev;
+  }
+  const integrity = raw.integrity;
+  if (integrity && Array.isArray(integrity.extra_secret_patterns)) {
+    const arr = integrity.extra_secret_patterns;
+    const cleaned = [];
+    for (const e of arr) {
+      if (!e || typeof e !== "object")
+        continue;
+      const rec = e;
+      if (typeof rec.pattern !== "string" || typeof rec.label !== "string")
+        continue;
+      const sev = rec.severity === "warn" ? "warn" : rec.severity === "block" ? "block" : undefined;
+      const entry = { pattern: rec.pattern, label: rec.label };
+      if (sev)
+        entry.severity = sev;
+      cleaned.push(entry);
+    }
+    if (cleaned.length)
+      out.integrity = { extra_secret_patterns: cleaned };
+  }
+  const att = raw.attestation;
+  if (att) {
+    const a = {};
+    if (typeof att.required === "boolean")
+      a.required = att.required;
+    if (Array.isArray(att.trusted_keys)) {
+      const cleanedTk = [];
+      for (const e of att.trusted_keys) {
+        if (!e || typeof e !== "object")
+          continue;
+        const rec = e;
+        if (typeof rec.id !== "string" || typeof rec.pubkey !== "string")
+          continue;
+        if (!rec.id.trim() || !rec.pubkey.trim())
+          continue;
+        const entry = { id: rec.id.trim(), pubkey: rec.pubkey.trim() };
+        if (typeof rec.added === "string" && rec.added.trim())
+          entry.added = rec.added.trim();
+        cleanedTk.push(entry);
+      }
+      if (cleanedTk.length)
+        a.trusted_keys = cleanedTk;
+    }
+    if (Array.isArray(att.revoked)) {
+      const cleanedRv = [];
+      for (const e of att.revoked) {
+        if (!e || typeof e !== "object")
+          continue;
+        const rec = e;
+        if (typeof rec.id !== "string" || !rec.id.trim())
+          continue;
+        const entry = { id: rec.id.trim() };
+        if (typeof rec.revoked === "string" && rec.revoked.trim())
+          entry.revoked = rec.revoked.trim();
+        if (typeof rec.reason === "string" && rec.reason.trim())
+          entry.reason = rec.reason.trim();
+        if (typeof rec.pubkey === "string" && rec.pubkey.trim())
+          entry.pubkey = rec.pubkey.trim();
+        cleanedRv.push(entry);
+      }
+      if (cleanedRv.length)
+        a.revoked = cleanedRv;
+    }
+    if (a.required !== undefined || a.trusted_keys || a.revoked)
+      out.attestation = a;
+  }
+  const harness = raw.harness;
+  if (harness && typeof harness.require_enforcement === "boolean") {
+    out.harness = { require_enforcement: harness.require_enforcement };
+  }
+  return out;
+}
+function strings(a) {
+  return a.filter((x) => typeof x === "string" && x.length > 0);
+}
+function detectHarness(projectDir) {
+  const e = process.env;
+  const has = (v) => v !== undefined && v !== "";
+  if (has(e.CLAUDECODE) || has(e.CLAUDE_CODE_ENTRYPOINT) || typeof e.ANTHROPIC_MODEL === "string" && /claude/i.test(e.ANTHROPIC_MODEL))
+    return "claude";
+  if (has(e.OPENCODE) || has(e.OPENCODE_TOKENS_FILE))
+    return "opencode";
+  const candidates = [
+    projectDir ? join8(projectDir, ".opencode", "config.json") : null,
+    join8(process.cwd(), ".opencode", "config.json")
+  ].filter(Boolean);
+  for (const p of candidates) {
+    try {
+      if (existsSync7(p))
+        return "opencode";
+    } catch {}
+  }
+  if (has(e.CURSOR) || has(e.VSCODE_GIT_ASKPASS_NODE))
+    return "cursor";
+  return "unknown";
+}
+function isEnforcedHarness(projectDir) {
+  return detectHarness(projectDir) === "opencode";
+}
+function getHarnessEnforcementError(projectDir) {
+  let policy;
+  try {
+    policy = loadPolicy(projectDir);
+  } catch (e) {
+    throw e;
+  }
+  if (!policy?.harness?.require_enforcement)
+    return null;
+  if (isEnforcedHarness(projectDir))
+    return null;
+  const h = detectHarness(projectDir);
+  return `harness enforcement required but current harness is rules-based only — use opencode or set harness.require_enforcement:false (detected: ${h})`;
+}
+function enforceHarnessPolicy(projectDir) {
+  const err = getHarnessEnforcementError(projectDir);
+  if (!err)
+    return;
+  console.error(`✗ ${err}`);
+  process.exit(1);
+}
 
 // src/integrity.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "node:fs";
-import { isAbsolute, join as join8, relative } from "node:path";
 var SECRET_PATTERNS = [
-  [/AKIA[0-9A-Z]{16}/, "AWS access key id"],
-  [/-----BEGIN [A-Z ]*PRIVATE KEY-----/, "private key block"],
-  [/gh[pousr]_[A-Za-z0-9]{20,}/, "GitHub token"],
-  [/xox[baprs]-[A-Za-z0-9-]{10,}/, "Slack token"],
-  [/sk-[A-Za-z0-9]{32,}/, "API key (sk-…)"],
-  [/eyJhbGciOi[A-Za-z0-9_.-]{20,}/, "JWT pasted verbatim"],
-  [/(api[_-]?key|secret|passwd|password)\s*[=:]\s*["'][^"'\s]{8,}["']/i, "credential assignment"]
+  [/AKIA[0-9A-Z]{16}/, "AWS access key id", "block"],
+  [/-----BEGIN [A-Z ]*PRIVATE KEY-----/, "private key block", "block"],
+  [/gh[pousr]_[A-Za-z0-9]{20,}/, "GitHub token", "block"],
+  [/xox[baprs]-[A-Za-z0-9-]{10,}/, "Slack token", "block"],
+  [/sk-[A-Za-z0-9]{32,}/, "API key (sk-…)", "block"],
+  [/eyJhbGciOi[A-Za-z0-9_.-]{20,}/, "JWT pasted verbatim", "block"],
+  [/(api[_-]?key|secret|passwd|password)\s*[=:]\s*["'][^"'\s]{8,}["']/i, "credential assignment", "block"],
+  [/AIza[0-9A-Za-z_-]{35}/, "Google API key", "block"],
+  [/ya29\.[0-9A-Za-z_-]{20,}/, "Google OAuth token", "block"],
+  [/\b[a-z][a-z0-9+.-]*:\/\/[^\s:@/]+:[^\s@/]{4,}@[^\s/]+/i, "connection string with inline credential", "block"],
+  [/\bAC[a-f0-9]{32}\b/, "Twilio account SID", "block"],
+  [/\bSK[a-f0-9]{32}\b/, "Twilio API key", "block"],
+  [/\bglpat-[A-Za-z0-9_-]{20,}/, "GitLab token", "block"],
+  [/\bnpm_[A-Za-z0-9]{36}\b/, "npm token", "block"],
+  [/\bdop_v1_[a-f0-9]{64}\b/, "DigitalOcean token", "block"],
+  [/\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})\b/, "card-number shape (verify before committing)", "warn"]
 ];
 var ALLOW_SECRET = "mugiwara:allow-secret";
-function findSecrets(body) {
+function loadExtraPatterns(projectRoot) {
+  try {
+    const policy = loadPolicy(projectRoot);
+    const extras = policy?.integrity?.extra_secret_patterns;
+    if (!extras || !Array.isArray(extras))
+      return [];
+    const out = [];
+    for (const e of extras) {
+      if (!e || typeof e.pattern !== "string" || typeof e.label !== "string")
+        continue;
+      const rec = e;
+      const sev = rec.severity === "warn" ? "warn" : "block";
+      try {
+        const re = new RegExp(rec.pattern);
+        out.push([re, rec.label, sev]);
+      } catch {}
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function findSecrets(body, extra) {
   const out = [];
+  const patterns = extra ? [...SECRET_PATTERNS, ...extra] : SECRET_PATTERNS;
   for (const line of body.split(/\r?\n/)) {
     if (line.includes(ALLOW_SECRET))
       continue;
-    for (const [re, label] of SECRET_PATTERNS) {
+    for (const [re, label, severity] of patterns) {
       const hit = line.match(re);
       if (hit)
-        out.push({ label, hit: hit[0] });
+        out.push({ label, hit: hit[0], severity: severity ?? "block" });
     }
   }
   return out;
@@ -992,7 +1518,7 @@ function trailFiles(dir) {
   const out = [];
   const walk = (d) => {
     for (const e of readdirSync4(d, { withFileTypes: true })) {
-      const p = join8(d, e.name);
+      const p = join9(d, e.name);
       if (e.isDirectory())
         walk(p);
       else if (TRAIL_EXTS.has(e.name.slice(e.name.lastIndexOf(".")) || ""))
@@ -1020,7 +1546,7 @@ function collectPassCitedPaths(missionDir) {
   for (const f of trailFiles(missionDir)) {
     let body;
     try {
-      body = readFileSync6(f, "utf8");
+      body = readFileSync7(f, "utf8");
     } catch {
       continue;
     }
@@ -1041,62 +1567,92 @@ function collectPassCitedPaths(missionDir) {
 function checkTrail(missionDir, projectRoot) {
   const issues = [];
   const files = trailFiles(missionDir);
+  const extraPatterns = loadExtraPatterns(projectRoot);
   for (const f of files) {
     let body;
     try {
-      body = readFileSync6(f, "utf8");
+      body = readFileSync7(f, "utf8");
     } catch {
       continue;
     }
     for (const target10 of linkedPaths(body)) {
       if (isAbsolute(target10))
         continue;
-      const fromMission = join8(missionDir, target10);
-      const fromRoot = join8(projectRoot, target10);
-      if (!existsSync7(fromMission) && !existsSync7(fromRoot)) {
+      const fromMission = join9(missionDir, target10);
+      const fromRoot = join9(projectRoot, target10);
+      if (!existsSync8(fromMission) && !existsSync8(fromRoot)) {
         issues.push({
           kind: "dangling-path",
           detail: `${relative(projectRoot, f)} links "${target10}" — no such file (mission dir or repo root)`
         });
       }
     }
-    for (const { label, hit } of findSecrets(body)) {
+    for (const { label, hit, severity } of findSecrets(body, extraPatterns.length ? extraPatterns : undefined)) {
+      const isWarn = severity === "warn";
       issues.push({
-        kind: "secret",
-        detail: `${relative(projectRoot, f)} matches ${label}: ${hit.slice(0, 12)}…`
+        kind: isWarn ? "secret-warn" : "secret",
+        detail: `${relative(projectRoot, f)} matches ${label}: ${hit.slice(0, 12)}…`,
+        severity: isWarn ? "warn" : "block"
       });
     }
   }
   const evidencePaths = [];
-  const evidenceFile = join8(missionDir, "state.json");
-  if (existsSync7(evidenceFile)) {
+  const stateFiles = existsSync8(missionDir) ? readdirSync4(missionDir).filter((n) => n.endsWith(".json") && n !== "continue.json" && !n.startsWith("continue-")).sort() : [];
+  for (const name of stateFiles) {
+    const evidenceFile = join9(missionDir, name);
     try {
-      const s = JSON.parse(readFileSync6(evidenceFile, "utf8"));
-      if (Array.isArray(s.evidence)) {
-        for (const e of s.evidence) {
-          if (typeof e !== "string" || !e.trim())
-            continue;
-          evidencePaths.push(e);
-          const cand = join8(projectRoot, e);
-          if (!isAbsolute(e) && !existsSync7(cand) && !existsSync7(join8(missionDir, e))) {
-            issues.push({ kind: "evidence", detail: `state.json evidence "${e}" does not exist` });
-          }
+      const s = JSON.parse(readFileSync7(evidenceFile, "utf8"));
+      if (!Array.isArray(s.evidence))
+        continue;
+      for (const e of s.evidence) {
+        if (typeof e !== "string" || !e.trim())
+          continue;
+        evidencePaths.push(e);
+        const cand = join9(projectRoot, e);
+        if (!isAbsolute(e) && !existsSync8(cand) && !existsSync8(join9(missionDir, e))) {
+          issues.push({ kind: "evidence", detail: `${name} evidence "${e}" does not exist` });
+        }
+      }
+    } catch {}
+  }
+  if (evidencePaths.length === 0) {
+    let severity = "warn";
+    try {
+      const policy = loadPolicy(projectRoot);
+      const lanes = policy?.evidence?.require_nonempty_for_lanes;
+      if (Array.isArray(lanes) && lanes.length) {
+        const stateLanes = new Set;
+        for (const name of stateFiles) {
+          try {
+            const s = JSON.parse(readFileSync7(join9(missionDir, name), "utf8"));
+            if (typeof s.lane === "string")
+              stateLanes.add(s.lane);
+          } catch {}
         }
+        if ([...stateLanes].some((l) => lanes.includes(l)))
+          severity = "block";
       }
     } catch {}
+    issues.push({
+      kind: "evidence",
+      severity,
+      detail: "mission declares no evidence — closing with zero recorded checks"
+    });
   }
   const passCited = collectPassCitedPaths(missionDir);
   for (const e of passCited) {
     if (!e.trim() || isAbsolute(e))
       continue;
-    const candMission = join8(missionDir, e);
-    const candRoot = join8(projectRoot, e);
-    const resolved = existsSync7(candMission) ? candMission : existsSync7(candRoot) ? candRoot : null;
+    if (/(?:^|\/)(state|continue)(-[^\/]*)?\.json$/.test(e))
+      continue;
+    const candMission = join9(missionDir, e);
+    const candRoot = join9(projectRoot, e);
+    const resolved = existsSync8(candMission) ? candMission : existsSync8(candRoot) ? candRoot : null;
     if (!resolved)
       continue;
     let body;
     try {
-      body = readFileSync6(resolved, "utf8");
+      body = readFileSync7(resolved, "utf8");
     } catch {
       continue;
     }
@@ -1112,12 +1668,12 @@ function formatIssues(issues) {
 }
 
 // src/check-artifacts.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, readdirSync as readdirSync5 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, readdirSync as readdirSync5 } from "node:fs";
+import { join as join10 } from "node:path";
 var LANE_MIN = new Set(["standard", "full", "spike"]);
 function checkMissionArtifacts(missionDir) {
-  const statePath = join9(missionDir, "state.json");
-  if (!existsSync8(statePath)) {
+  const statePath = join10(missionDir, "state.json");
+  if (!existsSync9(statePath)) {
     return { ok: true, missing: [], lane: null };
   }
   let lane = "unknown";
@@ -1130,17 +1686,17 @@ function checkMissionArtifacts(missionDir) {
     return { ok: true, missing: [], lane };
   }
   const missing = [];
-  if (!existsSync8(join9(missionDir, "plan.md")))
+  if (!existsSync9(join10(missionDir, "plan.md")))
     missing.push("plan.md");
-  const flowsDir = join9(missionDir, "flows");
-  const hasFlows = existsSync8(flowsDir) && readdirSync5(flowsDir).length > 0;
+  const flowsDir = join10(missionDir, "flows");
+  const hasFlows = existsSync9(flowsDir) && readdirSync5(flowsDir).length > 0;
   if (!hasFlows)
     missing.push("flows/ (no execution evidence)");
   return { ok: missing.length === 0, missing, lane };
 }
 function readFileSyncSafe(p) {
   try {
-    return readFileSync7(p, "utf8");
+    return readFileSync8(p, "utf8");
   } catch {
     return "";
   }
@@ -1149,7 +1705,7 @@ function readFileSyncSafe(p) {
 // src/rollback.ts
 import { execFileSync } from "node:child_process";
 import { writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function git(cwd, args) {
   return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
 }
@@ -1188,7 +1744,7 @@ function generateRollback(projectDir, missionDir, input) {
     const commitsNewestFirst = [...revList].reverse();
     const filesTouched = input.baseSha === "unknown" ? [] : git(projectDir, ["diff", "--name-only", input.baseSha, input.branch]).split(/\r?\n/).filter(Boolean);
     const body = buildRollback(input, commitsNewestFirst, filesTouched);
-    const file = join10(missionDir, "rollback.sh");
+    const file = join11(missionDir, "rollback.sh");
     writeFileSync6(file, body, { mode: 493 });
     return { file: "rollback.sh", commits: commitsNewestFirst.length };
   } catch {
@@ -1199,7 +1755,7 @@ function generateRollback(projectDir, missionDir, input) {
 // src/provenance.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function git2(cwd, args) {
   return execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
 }
@@ -1239,16 +1795,33 @@ function renderProvenanceMd(note, sha) {
 `) + `
 `;
 }
-function attachGitNote(projectDir, branch, note) {
+function attachGitNote(projectDir, branch, note, baseSha) {
   try {
-    let sha;
+    const range = baseSha ? `${baseSha}..${branch}` : branch;
+    let shas = [];
     try {
-      sha = git2(projectDir, ["rev-parse", "--verify", branch]);
+      const raw = git2(projectDir, ["rev-list", range]);
+      shas = raw.split(`
+`).filter(Boolean);
     } catch {
-      sha = git2(projectDir, ["rev-parse", "HEAD"]);
+      shas = [];
+    }
+    if (shas.length > 200) {
+      console.warn(`attachGitNote: range ${shas.length} >200, falling back to head-only`);
+      shas = [];
     }
-    git2(projectDir, ["notes", "--ref=mugiwara", "add", "-f", "-m", note, sha]);
-    return { sha };
+    let targets2 = shas;
+    if (!targets2.length) {
+      try {
+        targets2 = [git2(projectDir, ["rev-parse", "--verify", branch])];
+      } catch {
+        targets2 = [git2(projectDir, ["rev-parse", "HEAD"])];
+      }
+    }
+    for (const sha of targets2) {
+      git2(projectDir, ["notes", "--ref=mugiwara", "add", "-f", "-m", note, sha]);
+    }
+    return { sha: targets2[0], count: targets2.length };
   } catch {
     return null;
   }
@@ -1268,13 +1841,243 @@ function blamePath(projectDir, path) {
 ${note}`;
   } catch {
     return `${path} @ ${sha.slice(0, 7)}
-(no mugiwara provenance note on this commit)`;
+no per-commit note — see .mugiwara/missions/<m>/provenance.md`;
   }
 }
-function writeProvenance(projectDir, missionDir, state) {
+function writeProvenance(projectDir, missionDir, state, baseSha) {
   const note = buildNote(state);
-  const attached = attachGitNote(projectDir, state.branch, note);
-  writeFileSync7(join11(missionDir, "provenance.md"), renderProvenanceMd(note, attached ? attached.sha : null));
+  const resolvedBase = baseSha ?? (typeof state.base_sha === "string" ? state.base_sha : undefined);
+  const cleanBase = resolvedBase && resolvedBase !== "unknown" ? resolvedBase : undefined;
+  const attached = attachGitNote(projectDir, state.branch, note, cleanBase);
+  writeFileSync7(join12(missionDir, "provenance.md"), renderProvenanceMd(note, attached ? attached.sha : null));
+}
+
+// src/sign.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { chmodSync as chmodSync3, existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "node:fs";
+import { createPrivateKey, createPublicKey, generateKeyPairSync, sign, verify } from "node:crypto";
+import { homedir as homedir3 } from "node:os";
+import { join as join13 } from "node:path";
+function signArgs(reportPath, secretKey) {
+  return ["-Sm", reportPath, "-s", secretKey];
+}
+function verifyArgs(reportPath, pubKey) {
+  return pubKey ? ["-Vm", reportPath, "-p", pubKey] : ["-Vm", reportPath];
+}
+function hasMinisign() {
+  try {
+    execFileSync3("minisign", ["-v"], { stdio: ["ignore", "pipe", "ignore"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function defaultKey(flag) {
+  return join13(homedir3(), ".mugiwara", flag === "secret" ? "minisign.key" : "minisign.pub");
+}
+function generatePureKey() {
+  const { privateKey, publicKey } = generateKeyPairSync("ed25519");
+  const privJwk = privateKey.export({ format: "jwk" });
+  const pubJwk = publicKey.export({ format: "jwk" });
+  return {
+    key: Buffer.from(privJwk.d, "base64url").toString("base64"),
+    pub: Buffer.from(pubJwk.x, "base64url").toString("base64")
+  };
+}
+function ensurePureKey(homeDir) {
+  const dir = join13(homeDir, ".mugiwara");
+  const keyPath = join13(dir, "mugiwara.key");
+  const pubPath = join13(dir, "mugiwara.pub");
+  if (!existsSync10(keyPath) || !existsSync10(pubPath)) {
+    mkdirSync6(dir, { recursive: true });
+    const { key, pub } = generatePureKey();
+    if (!existsSync10(keyPath)) {
+      writeFileSync8(keyPath, key + `
+`, { mode: 384 });
+    }
+    if (!existsSync10(pubPath))
+      writeFileSync8(pubPath, pub + `
+`);
+  }
+  try {
+    chmodSync3(keyPath, 384);
+  } catch {}
+  return dir;
+}
+function pureSign(content, seedBase64, opts) {
+  const seed = Buffer.from(seedBase64.trim(), "base64");
+  if (seed.length !== 32)
+    return { ok: false, message: "invalid seed (want 32B base64)" };
+  const pubBuf = Buffer.from(opts.pub.trim(), "base64");
+  if (pubBuf.length !== 32)
+    return { ok: false, message: "invalid pub (want 32B base64)" };
+  const privateKey = createPrivateKey({
+    key: {
+      kty: "OKP",
+      crv: "Ed25519",
+      d: seed.toString("base64url"),
+      x: pubBuf.toString("base64url")
+    },
+    format: "jwk"
+  });
+  const sig = sign(null, Buffer.from(content, "utf8"), privateKey).toString("base64");
+  const out = { algo: "ed25519-pure", sig, pub: opts.pub, mission: opts.mission, commit: opts.commit, ts: opts.ts };
+  if (opts.outputPath)
+    writeFileSync8(opts.outputPath, JSON.stringify(out, null, 2) + `
+`);
+  return { ...out, ok: true };
+}
+function pureVerify(content, sig) {
+  try {
+    const pub = Buffer.from(sig.pub, "base64");
+    if (pub.length !== 32)
+      return false;
+    const publicKey = createPublicKey({
+      key: { kty: "OKP", crv: "Ed25519", x: pub.toString("base64url") },
+      format: "jwk"
+    });
+    return verify(null, Buffer.from(content, "utf8"), publicKey, Buffer.from(sig.sig, "base64"));
+  } catch {
+    return false;
+  }
+}
+function resolveBackend(configured, env) {
+  switch (configured) {
+    case "off":
+      return "off";
+    case "minisign":
+      return env.hasMinisign ? "minisign" : "minisign-fail";
+    case "pure":
+      return "pure";
+    case "auto":
+    default:
+      return env.hasMinisign && env.hasKey ? "minisign" : "pure";
+  }
+}
+function configuredBackend(projectDir) {
+  return readConfig(projectDir).sign;
+}
+function missionMeta(projectDir, mission) {
+  let commit = "unknown";
+  try {
+    commit = execFileSync3("git", ["rev-parse", "HEAD"], { cwd: projectDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {}
+  return { commit, ts: new Date().toISOString() };
+}
+function signReport(projectDir, missionDir) {
+  const report = join13(missionDir, "report.md");
+  if (!existsSync10(report))
+    return { ok: false, message: "no report.md to sign — archive first" };
+  const mission = missionDir.split(join13(".mugiwara", "missions", "")).pop() ?? "unknown";
+  const backend = resolveBackend(configuredBackend(projectDir), { hasMinisign: hasMinisign(), hasKey: existsSync10(defaultKey("secret")) });
+  if (backend === "off")
+    return { ok: false, message: "signing disabled (sign=off)" };
+  if (backend === "minisign-fail")
+    return { ok: false, message: "sign=minisign but minisign not installed — install it or set sign=pure" };
+  if (backend === "minisign") {
+    const secretKey = process.env.MUGIWARA_SIGN_KEY?.trim() || defaultKey("secret");
+    try {
+      execFileSync3("minisign", signArgs(report, secretKey), { cwd: projectDir, stdio: "pipe", input: process.env.MUGIWARA_SIGN_PASSWORD ?? "" });
+      return { ok: true, message: `signed ${report}.minisig (minisign, key: ${secretKey})` };
+    } catch (e) {
+      return { ok: false, message: `signing failed: ${e.message}` };
+    }
+  }
+  const dir = ensurePureKey(homedir3());
+  const seed = process.env.MUGIWARA_SIGN_KEY?.trim() || readFileSyncSafe2(join13(dir, "mugiwara.key"));
+  const pub = process.env.MUGIWARA_SIGN_PUB?.trim() || readFileSyncSafe2(join13(dir, "mugiwara.pub"));
+  if (!seed || !pub)
+    return { ok: false, message: "pure keys missing — run `mugiwara sign --gen-key --backend pure`" };
+  const content = readFileSafe(report);
+  if (content === null)
+    return { ok: false, message: `cannot read ${report}` };
+  const { commit, ts } = missionMeta(projectDir, mission);
+  const sig = pureSign(content, seed, { mission, commit, ts, pub, outputPath: `${report}.mugisig` });
+  if (!sig.ok)
+    return { ok: false, message: `signing failed: ${sig.message}` };
+  return { ok: true, message: `signed ${report}.mugisig (pure ed25519, key: ${join13(dir, "mugiwara.key")})` };
+}
+function normalizePubkey(pk) {
+  const t = pk.trim();
+  return t.startsWith("ed25519:") ? t.slice("ed25519:".length).trim() : t;
+}
+function checkTrust(projectDir, signerPubB64) {
+  try {
+    const policy = loadPolicy(projectDir);
+    const att = policy?.attestation;
+    if (!att)
+      return { ok: true };
+    const trusted = att.trusted_keys ?? [];
+    const revoked = att.revoked ?? [];
+    const signer = signerPubB64.trim();
+    const directlyRevoked = revoked.some((r) => {
+      const rpk = r.pubkey;
+      if (!rpk)
+        return false;
+      return normalizePubkey(rpk) === signer;
+    });
+    if (directlyRevoked)
+      return { ok: false, message: "signature valid but signer revoked (pubkey in revoked list)" };
+    if (trusted.length === 0) {
+      return { ok: true };
+    }
+    const match = trusted.find((e) => normalizePubkey(e.pubkey) === signer);
+    if (!match)
+      return { ok: false, message: "signature valid but signer untrusted (pub not in trusted_keys)" };
+    const revokedById = revoked.some((r) => r.id === match.id);
+    if (revokedById)
+      return { ok: false, message: `signature valid but signer revoked (id: ${match.id})` };
+    return { ok: true };
+  } catch {
+    return { ok: true };
+  }
+}
+function verifyReport(projectDir, missionDir) {
+  const report = join13(missionDir, "report.md");
+  const minisig = `${report}.minisig`;
+  const mugisig = `${report}.mugisig`;
+  if (!existsSync10(minisig) && !existsSync10(mugisig)) {
+    return { ok: false, message: "not signed (no .minisig or .mugisig beside report.md)" };
+  }
+  if (existsSync10(minisig)) {
+    if (!hasMinisign())
+      return { ok: false, message: "minisig present but minisign not installed — cannot verify that signature" };
+    const pubKey = existsSync10(defaultKey("public")) ? defaultKey("public") : null;
+    try {
+      execFileSync3("minisign", verifyArgs(report, pubKey), { cwd: projectDir, stdio: "pipe" });
+      return { ok: true, message: "signature verifies against report.md (minisig)" };
+    } catch {
+      return { ok: false, message: "SIGNATURE INVALID — report.md changed after signing (minisig)" };
+    }
+  }
+  try {
+    const parsed = JSON.parse(readFileSafe(mugisig) ?? "{}");
+    const content = readFileSafe(report);
+    if (content === null || parsed.algo !== "ed25519-pure")
+      return { ok: false, message: "invalid .mugisig file" };
+    if (!pureVerify(content, parsed))
+      return { ok: false, message: "SIGNATURE INVALID — report.md changed after signing (mugisig)" };
+    const trust = checkTrust(projectDir, parsed.pub);
+    if (!trust.ok)
+      return { ok: false, message: trust.message };
+    return { ok: true, message: "signature verifies against report.md (mugisig, ed25519-pure)" };
+  } catch {
+    return { ok: false, message: "invalid .mugisig file" };
+  }
+}
+function readFileSafe(p) {
+  try {
+    return readFileSync9(p, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readFileSyncSafe2(p) {
+  try {
+    return readFileSync9(p, "utf8").trim();
+  } catch {
+    return "";
+  }
 }
 
 // src/routing.ts
@@ -1331,8 +2134,8 @@ function renderRouting(ranked, mission) {
 }
 
 // src/budget.ts
-import { existsSync as existsSync9, readdirSync as readdirSync6, statSync } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync6, statSync } from "node:fs";
+import { join as join14 } from "node:path";
 function readBudgetConfig(projectDir) {
   const cfg = readConfig(projectDir);
   const raw = cfg.context_budget_chars;
@@ -1350,13 +2153,13 @@ function measureContextChars(missionDir) {
   };
   for (const f of readdirSync6(missionDir)) {
     if (/\.md$/.test(f))
-      add(join12(missionDir, f));
+      add(join14(missionDir, f));
   }
   for (const sub of ["flows", "waves"]) {
-    const dir = join12(missionDir, sub);
-    if (existsSync9(dir)) {
+    const dir = join14(missionDir, sub);
+    if (existsSync11(dir)) {
       for (const f of readdirSync6(dir))
-        add(join12(dir, f));
+        add(join14(dir, f));
     }
   }
   return total;
@@ -1367,15 +2170,22 @@ function formatFootprint(chars, budget) {
     return `${base} (no budget configured)`;
   return chars > budget ? `${base} — OVER budget ${budget}` : `${base} (budget ${budget})`;
 }
+var COMPRESS_THRESHOLD_PCT = 0.8;
+function shouldCompress(budget, chars) {
+  return budget > 0 && chars > Math.floor(budget * COMPRESS_THRESHOLD_PCT);
+}
+function compressThreshold(budget) {
+  return Math.floor(budget * COMPRESS_THRESHOLD_PCT);
+}
 
 // src/cost.ts
-import { appendFileSync, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "node:fs";
-import { join as join13 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync7, readFileSync as readFileSync10 } from "node:fs";
+import { join as join15 } from "node:path";
 var LANE_BUDGET = {
   lean: 12000,
   standard: 25000,
   full: 50000,
-  spike: 3000
+  spike: 9000
 };
 function budgetForLane(lane) {
   return LANE_BUDGET[lane] ?? 0;
@@ -1426,15 +2236,16 @@ function assertMissionDir(dir) {
 }
 function appendCostEvent(missionDir, event) {
   assertMissionDir(missionDir);
-  mkdirSync6(missionDir, { recursive: true });
+  mkdirSync7(missionDir, { recursive: true });
   const line = Object.assign({ ts: new Date().toISOString() }, event);
-  appendFileSync(join13(missionDir, COST_EVENTS_FILE), JSON.stringify(line) + `
+  appendFileSync(join15(missionDir, COST_EVENTS_FILE), JSON.stringify(line) + `
 `, "utf8");
 }
+var COMPRESSED_KIND = "compressed";
 
 // src/evidence.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync9 } from "node:fs";
-import { join as join14 } from "node:path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8, readFileSync as readFileSync11 } from "node:fs";
+import { join as join16 } from "node:path";
 var REGISTRY_FILE = "context-registry.jsonl";
 function isAllowedMissionDir2(dir) {
   if (!dir || dir.includes(".."))
@@ -1453,10 +2264,10 @@ function assertMissionDir2(dir) {
 }
 function loadRegistry(missionDir) {
   assertMissionDir2(missionDir);
-  const file = join14(missionDir, REGISTRY_FILE);
+  const file = join16(missionDir, REGISTRY_FILE);
   try {
     const out = [];
-    for (const line of readFileSync9(file, "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync11(file, "utf8").split(/\r?\n/)) {
       if (!line.trim())
         continue;
       let e;
@@ -1497,8 +2308,8 @@ function computeContextMetrics(stats) {
 }
 
 // src/reporting.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync12 } from "node:fs";
+import { join as join17 } from "node:path";
 function isAllowedMissionDir3(dir) {
   if (!dir || dir.includes(".."))
     return false;
@@ -1516,10 +2327,10 @@ function assertMissionDir3(dir) {
 }
 function parseDecisionTrail(missionDir) {
   assertMissionDir3(missionDir);
-  const file = join15(missionDir, "decisions.md");
-  if (!existsSync10(file))
+  const file = join17(missionDir, "decisions.md");
+  if (!existsSync12(file))
     return [];
-  const raw = readFileSync10(file, "utf8");
+  const raw = readFileSync12(file, "utf8");
   const lines = raw.split(/\r?\n/);
   const headerIdx = lines.findIndex((l) => l.trim() === "## Cost governor decisions" || l.trim() === "## Budget");
   const scan = headerIdx >= 0 ? lines.slice(headerIdx) : lines;
@@ -1535,11 +2346,11 @@ function parseDecisionTrail(missionDir) {
 }
 function loadCostEvents(missionDir) {
   assertMissionDir3(missionDir);
-  const file = join15(missionDir, "cost-events.jsonl");
-  if (!existsSync10(file))
+  const file = join17(missionDir, "cost-events.jsonl");
+  if (!existsSync12(file))
     return [];
   const out = [];
-  for (const line of readFileSync10(file, "utf8").split(/\r?\n/)) {
+  for (const line of readFileSync12(file, "utf8").split(/\r?\n/)) {
     if (!line.trim())
       continue;
     try {
@@ -1646,18 +2457,65 @@ function primaryState(dir, files) {
   if (!name)
     return null;
   try {
-    return JSON.parse(readFileSync11(join16(dir, name), "utf8"));
+    return JSON.parse(readFileSync13(join18(dir, name), "utf8"));
   } catch {
     return null;
   }
 }
+function tasksFromState(state) {
+  if (!state)
+    return { done: 0, total: 0 };
+  const t = state.tasks;
+  if (t && typeof t.done === "number" && typeof t.total === "number")
+    return { done: t.done, total: t.total };
+  const done = Number(state.tasks_done);
+  const total = Number(state.tasks_total);
+  return { done: Number.isFinite(done) ? done : 0, total: Number.isFinite(total) ? total : 0 };
+}
+function countPlanTasks(missionDir) {
+  let total = 0;
+  let done = 0;
+  const planFile = join18(missionDir, "plan.md");
+  if (existsSync13(planFile)) {
+    try {
+      const text = readFileSync13(planFile, "utf8");
+      for (const line of text.split(/\r?\n/)) {
+        if (/^\s*-\s*\[[ xX]\]/.test(line)) {
+          total++;
+          if (/^\s*-\s*\[[xX]\]/.test(line))
+            done++;
+        }
+      }
+    } catch {}
+  }
+  if (total === 0) {
+    const subPlanDir = join18(missionDir, "sub-plan");
+    if (existsSync13(subPlanDir)) {
+      try {
+        for (const f of readdirSync7(subPlanDir)) {
+          if (!f.endsWith(".md"))
+            continue;
+          const text = readFileSync13(join18(subPlanDir, f), "utf8");
+          for (const line of text.split(/\r?\n/)) {
+            if (/^\s*-\s*\[[ xX]\]/.test(line)) {
+              total++;
+              if (/^\s*-\s*\[[xX]\]/.test(line))
+                done++;
+            }
+          }
+        }
+      } catch {}
+    }
+  }
+  return { done, total };
+}
 function changedFiles(projectDir, state) {
   const base = typeof state?.base_sha === "string" ? state.base_sha : "";
   const branch = typeof state?.branch === "string" ? state.branch : "";
   if (!base || base === "unknown" || !branch)
     return [];
   try {
-    return execFileSync3("git", ["diff", "--name-only", base, branch], {
+    return execFileSync4("git", ["diff", "--name-only", base, branch], {
       cwd: projectDir,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -1667,16 +2525,16 @@ function changedFiles(projectDir, state) {
   }
 }
 function activeActor(projectDir) {
-  const missionsDir = join16(projectDir, ".mugiwara", "missions");
-  if (!existsSync11(missionsDir))
+  const missionsDir = join18(projectDir, ".mugiwara", "missions");
+  if (!existsSync13(missionsDir))
     return null;
   const missions = readdirSync7(missionsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   let latest = null;
   for (const mission of missions) {
-    const d = join16(missionsDir, mission);
+    const d = join18(missionsDir, mission);
     for (const f of readdirSync7(d).filter(isStateFile)) {
       try {
-        const s = JSON.parse(readFileSync11(join16(d, f), "utf8"));
+        const s = JSON.parse(readFileSync13(join18(d, f), "utf8"));
         const t = Date.parse(s.updated_at || "") || 0;
         if (!latest || t > latest.updated)
           latest = { actor: s.actor || null, updated: t };
@@ -1686,8 +2544,8 @@ function activeActor(projectDir) {
   return latest ? latest.actor : null;
 }
 function resetMission(projectDir, keepLogs, force) {
-  const root = join16(projectDir, ".mugiwara");
-  if (!existsSync11(root))
+  const root = join18(projectDir, ".mugiwara");
+  if (!existsSync13(root))
     return { removed: [], kept: [] };
   if (!force) {
     const actor = activeActor(projectDir);
@@ -1698,66 +2556,93 @@ function resetMission(projectDir, keepLogs, force) {
   const removed = [];
   const kept = [];
   for (const dir of ["missions", "spec", "plans", "results", "review", "issues", "reports", "state", "continue"]) {
-    const p = join16(root, dir);
-    if (existsSync11(p)) {
+    const p = join18(root, dir);
+    if (existsSync13(p)) {
       rmSync2(p, { recursive: true, force: true });
       removed.push(dir);
     }
   }
   for (const f of readdirSync7(root)) {
     if (/^state(-.+)?\.json$/.test(f)) {
-      const p = join16(root, f);
-      if (existsSync11(p)) {
+      const p = join18(root, f);
+      if (existsSync13(p)) {
         rmSync2(p);
         removed.push(f);
       }
     }
   }
   if (!keepLogs) {
-    for (const p of [join16(root, "lessons.md"), join16(root, "logs")]) {
-      if (existsSync11(p)) {
+    for (const p of [join18(root, "lessons.md"), join18(root, "logs")]) {
+      if (existsSync13(p)) {
         rmSync2(p, { recursive: true, force: true });
-        removed.push(p.startsWith(join16(root, "logs")) ? "logs" : "lessons.md");
+        removed.push(p.startsWith(join18(root, "logs")) ? "logs" : "lessons.md");
       }
     }
   } else {
-    if (existsSync11(join16(root, "lessons.md")))
+    if (existsSync13(join18(root, "lessons.md")))
       kept.push("lessons.md");
-    else if (existsSync11(join16(root, join16("logs", "lessons.md"))))
-      kept.push(join16("logs", "lessons.md"));
+    else if (existsSync13(join18(root, join18("logs", "lessons.md"))))
+      kept.push(join18("logs", "lessons.md"));
+  }
+  if (removed.includes("missions") && existsSync13(join18(root, "index.md"))) {
+    rmSync2(join18(root, "index.md"));
+    removed.push("index.md");
   }
   for (const f of ["config", "manifest.json", "backup"]) {
-    if (existsSync11(join16(root, f)))
+    if (existsSync13(join18(root, f)))
       kept.push(f);
   }
   return { removed, kept };
 }
 function archiveMission(projectDir, mission, opts = {}) {
   const { dryRun = false } = opts;
-  const root = join16(projectDir, ".mugiwara");
+  const root = join18(projectDir, ".mugiwara");
   if (!mission || /[^a-zA-Z0-9._-]/.test(mission) || /^\.+$/.test(mission))
     throw new Error(`invalid mission name "${mission}" (allowlist: [a-zA-Z0-9._-], not a dot-path)`);
   const removed = [];
   const kept = [];
-  const dir = join16(root, "missions", mission);
-  if (!existsSync11(dir))
+  const dir = join18(root, "missions", mission);
+  if (!existsSync13(dir))
     return { report: null, removed, kept };
   if (!dryRun) {
     const issues = checkTrail(dir, projectDir);
-    if (issues.length) {
+    const blocking = issues.filter((i) => i.kind !== "secret-warn" && i.severity !== "warn");
+    if (blocking.length) {
       throw new Error(`closure integrity gate failed — fix these before archiving:
-${formatIssues(issues)}`);
+${formatIssues(blocking)}`);
+    }
+    if (issues.length && blocking.length === 0) {
+      try {
+        const warnText = formatIssues(issues);
+        if (warnText)
+          console.warn(`closure integrity warnings (non-blocking):
+${warnText}`);
+      } catch {}
     }
     const artifacts = checkMissionArtifacts(dir);
     if (!artifacts.ok) {
       throw new Error(`archive artifact gate failed — missing: ${artifacts.missing.join(", ")} (lane ${artifacts.lane}). Write the evidence trail before archiving.`);
     }
+    try {
+      const policy = loadPolicy(projectDir);
+      if (policy?.attestation?.required) {
+        const v = verifyReport(projectDir, dir);
+        if (!v.ok) {
+          throw new Error(`closure integrity gate failed — attestation required but report not signed/trusted: ${v.message}`);
+        }
+      }
+    } catch (e) {
+      if (e.message.startsWith("closure integrity gate failed — attestation required"))
+        throw e;
+      if (e.message.startsWith("unknown policy key"))
+        throw e;
+    }
   }
   const files = readdirSync7(dir);
   const state = primaryState(dir, files);
   const stageModels = [...new Set(files.filter(isStateFile).map((f) => {
     try {
-      const s = JSON.parse(readFileSync11(join16(dir, f), "utf8"));
+      const s = JSON.parse(readFileSync13(join18(dir, f), "utf8"));
       return typeof s.model === "string" ? s.model : "";
     } catch {
       return "";
@@ -1797,7 +2682,7 @@ ${formatIssues(issues)}`);
     let hasReported = false;
     for (const f of files.filter(isStateFile)) {
       try {
-        const s = JSON.parse(readFileSync11(join16(dir, f), "utf8"));
+        const s = JSON.parse(readFileSync13(join18(dir, f), "utf8"));
         if (s.tokens_source === "reported" && typeof s.tokens_est === "number") {
           reportedTotal += s.tokens_est;
           hasReported = true;
@@ -1852,6 +2737,41 @@ ${formatIssues(issues)}`);
     try {
       costSection += renderAdaptationSection(dir);
     } catch {}
+    if (shouldCompress(budget, chars)) {
+      try {
+        const flowsDir2 = join18(dir, "flows");
+        const wavesDir = join18(dir, "waves");
+        const targetDir = existsSync13(flowsDir2) ? flowsDir2 : existsSync13(wavesDir) ? wavesDir : null;
+        if (targetDir && existsSync13(targetDir)) {
+          const flowFiles = readdirSync7(targetDir).filter((f) => f.endsWith(".md"));
+          if (flowFiles.length) {
+            const pct = Math.round(chars / budget * 100);
+            const stub = `# Compressed trail
+
+Trail ${chars} chars exceeds ${pct}% of budget ${budget} (threshold ${compressThreshold(budget)}) — flows archived as stub to preserve budget. Original flows: ${flowFiles.join(", ")}
+`;
+            for (const f of flowFiles) {
+              try {
+                rmSync2(join18(targetDir, f), { force: true });
+              } catch {}
+            }
+            writeFileSync9(join18(targetDir, "00-compressed.md"), stub);
+          }
+        }
+        appendCostEvent(dir, {
+          kind: COMPRESSED_KIND,
+          mission,
+          tokens_est: est,
+          budget: laneBudget,
+          status: "compressed",
+          context_chars: chars,
+          context_status: ctxStatus,
+          context_metrics: metrics
+        });
+        costSection += `
+| **Compressed** | yes — ${chars} chars >80% of ${budget} — flows stubbed as 00-compressed.md |`;
+      } catch {}
+    }
     appendCostEvent(dir, {
       kind: "closure",
       mission,
@@ -1873,39 +2793,39 @@ ${formatIssues(issues)}`);
       fold.push(f);
   }
   const PR_VERDICT = "pr-verdict.md";
-  const PR_VERDICT_SRC = join16("flows", "07-pr-verdict.md");
-  const flowsDir = join16(dir, "flows");
-  const legacyWavesDir = join16(dir, "waves");
-  const artDir = existsSync11(flowsDir) ? flowsDir : existsSync11(legacyWavesDir) ? legacyWavesDir : flowsDir;
+  const PR_VERDICT_SRC = join18("flows", "07-pr-verdict.md");
+  const flowsDir = join18(dir, "flows");
+  const legacyWavesDir = join18(dir, "waves");
+  const artDir = existsSync13(flowsDir) ? flowsDir : existsSync13(legacyWavesDir) ? legacyWavesDir : flowsDir;
   const artRel = artDir === legacyWavesDir ? "waves" : "flows";
-  if (existsSync11(artDir)) {
+  if (existsSync13(artDir)) {
     for (const f of readdirSync7(artDir).sort()) {
       if (artRel === "flows" && f === "07-pr-verdict.md")
         continue;
-      fold.push(join16(artRel, f));
+      fold.push(join18(artRel, f));
     }
   }
-  if (existsSync11(join16(dir, "cost-events.jsonl")))
+  if (existsSync13(join18(dir, "cost-events.jsonl")))
     fold.push("cost-events.jsonl");
-  if (existsSync11(join16(dir, "context-registry.jsonl")))
+  if (existsSync13(join18(dir, "context-registry.jsonl")))
     fold.push("context-registry.jsonl");
   let report = "";
-  const reportPath = join16(dir, "report.md");
+  const reportPath = join18(dir, "report.md");
   if (files.includes("report.md"))
-    report = readFileSync11(reportPath, "utf8");
-  else if (existsSync11(join16(artDir, "06-closure.md")))
-    report = readFileSync11(join16(artDir, "06-closure.md"), "utf8");
+    report = readFileSync13(reportPath, "utf8");
+  else if (existsSync13(join18(artDir, "06-closure.md")))
+    report = readFileSync13(join18(artDir, "06-closure.md"), "utf8");
   if (!dryRun) {
-    mkdirSync8(dir, { recursive: true });
-    const prVerdictSrc = join16(dir, PR_VERDICT_SRC);
-    if (existsSync11(prVerdictSrc)) {
-      const prVerdictPath = join16(dir, PR_VERDICT);
-      writeFileSync8(prVerdictPath, readFileSync11(prVerdictSrc, "utf8"));
-      kept.push(join16("missions", mission, PR_VERDICT));
+    mkdirSync9(dir, { recursive: true });
+    const prVerdictSrc = join18(dir, PR_VERDICT_SRC);
+    if (existsSync13(prVerdictSrc)) {
+      const prVerdictPath = join18(dir, PR_VERDICT);
+      writeFileSync9(prVerdictPath, readFileSync13(prVerdictSrc, "utf8"));
+      kept.push(join18("missions", mission, PR_VERDICT));
     }
     if (fold.length) {
       const sections = fold.map((f) => {
-        const body = readFileSync11(join16(dir, f), "utf8").trim();
+        const body = readFileSync13(join18(dir, f), "utf8").trim();
         const name = f.includes("/") ? f.split("/").pop() ?? f : f;
         return `
 
@@ -1919,26 +2839,26 @@ ${body}`;
         evidence: Array.isArray(state.evidence) ? state.evidence : [],
         sensitive_paths: Array.isArray(state.sensitive_paths) ? state.sensitive_paths : []
       }), mission) : "";
-      writeFileSync8(tmp, report.trimEnd() + sections + (routingSection || "") + (costSection ? `
+      writeFileSync9(tmp, report.trimEnd() + sections + (routingSection || "") + (costSection ? `
 ${costSection}
 ` : "") + `
 `);
       renameSync(tmp, reportPath);
     }
     for (const f of fold) {
-      rmSync2(join16(dir, f), { force: true, recursive: true });
-      removed.push(join16("missions", mission, f));
+      rmSync2(join18(dir, f), { force: true, recursive: true });
+      removed.push(join18("missions", mission, f));
     }
-    if (existsSync11(prVerdictSrc)) {
-      rmSync2(join16(dir, PR_VERDICT_SRC), { force: true });
-      removed.push(join16("missions", mission, PR_VERDICT_SRC));
+    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")))
-      rmSync2(join16(dir, f), { force: true });
-    if (existsSync11(artDir) && readdirSync7(artDir).length === 0)
+      rmSync2(join18(dir, f), { force: true });
+    if (existsSync13(artDir) && readdirSync7(artDir).length === 0)
       rmSync2(artDir, { recursive: true, force: true });
-    if (!existsSync11(reportPath)) {
-      writeFileSync8(reportPath, `# Mission: ${mission}
+    if (!existsSync13(reportPath)) {
+      writeFileSync9(reportPath, `# Mission: ${mission}
 
 Archived before closure — no wave artifacts were present.
 `);
@@ -1950,38 +2870,44 @@ Archived before closure — no wave artifacts were present.
         baseSha: typeof state.base_sha === "string" ? state.base_sha : "unknown"
       });
       if (rb)
-        kept.push(join16("missions", mission, rb.file));
+        kept.push(join18("missions", mission, rb.file));
       try {
+        const st = tasksFromState(state);
+        const pt = countPlanTasks(dir);
+        const tasks_done = pt.total > 0 ? pt.done : st.done;
+        const tasks_total = pt.total > 0 ? pt.total : st.total;
+        const baseShaForNote = typeof state.base_sha === "string" ? state.base_sha : undefined;
         writeProvenance(projectDir, dir, {
           mission,
           actor: typeof state.actor === "string" ? state.actor : "",
           lane: typeof state.lane === "string" ? state.lane : "",
           mode: typeof state.mode === "string" ? state.mode : "",
           branch: state.branch,
-          tasks_done: Number(state.tasks_done) || 0,
-          tasks_total: Number(state.tasks_total) || 0,
+          tasks_done,
+          tasks_total,
           evidence: Array.isArray(state.evidence) ? state.evidence : [],
-          models: stageModels
-        });
-        kept.push(join16("missions", mission, "provenance.md"));
+          models: stageModels,
+          base_sha: baseShaForNote
+        }, baseShaForNote);
+        kept.push(join18("missions", mission, "provenance.md"));
       } catch {}
     }
   } else {
     for (const f of fold)
-      removed.push(join16("missions", mission, f));
+      removed.push(join18("missions", mission, f));
   }
-  removed.push(join16("missions", mission, "<session state>"));
+  removed.push(join18("missions", mission, "<session state>"));
   if (files.includes("plan.md"))
-    kept.push(join16("missions", mission, "plan.md"));
+    kept.push(join18("missions", mission, "plan.md"));
   if (files.includes("handoff.md"))
-    kept.push(join16("missions", mission, "handoff.md"));
-  kept.push(join16("missions", mission, "report.md"));
+    kept.push(join18("missions", mission, "handoff.md"));
+  kept.push(join18("missions", mission, "report.md"));
   let index;
-  const indexFile = join16(root, "index.md");
+  const indexFile = join18(root, "index.md");
   const line = `- ${mission} — ${new Date().toISOString().slice(0, 10)}
 `;
   if (!dryRun) {
-    const existing = existsSync11(indexFile) ? readFileSync11(indexFile, "utf8") : "";
+    const existing = existsSync13(indexFile) ? readFileSync13(indexFile, "utf8") : "";
     if (!existing.split(/\r?\n/).some((l) => l.startsWith(`- ${mission} —`))) {
       const header = existing ? "" : `# Mission index
 
@@ -1995,28 +2921,28 @@ Archived before closure — no wave artifacts were present.
     }
     index = "index.md";
   }
-  return { report: join16("missions", mission, "report.md"), removed, kept, index };
+  return { report: join18("missions", mission, "report.md"), removed, kept, index };
 }
 
 // src/run.ts
-import { existsSync as existsSync12, readdirSync as readdirSync8 } from "node:fs";
+import { existsSync as existsSync14, readdirSync as readdirSync8 } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { dirname as dirname5, join as join17, resolve } from "node:path";
+import { dirname as dirname5, join as join19, resolve } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var here3 = dirname5(fileURLToPath4(import.meta.url));
-var SCRIPTS_DIR = join17(here3, "..", "scripts");
+var SCRIPTS_DIR = join19(here3, "..", "scripts");
 var RUNNABLE = ["savepoint.sh", "lane.sh"];
 function findBash() {
   const explicit = process.env.MUGIWARA_BASH?.trim();
   if (explicit)
-    return existsSync12(explicit) ? explicit : null;
+    return existsSync14(explicit) ? explicit : null;
   const candidates = process.platform === "win32" ? [
     "C:\\Program Files\\Git\\bin\\bash.exe",
     "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
-    join17(process.env.LOCALAPPDATA ?? "", "Programs", "Git", "bin", "bash.exe")
+    join19(process.env.LOCALAPPDATA ?? "", "Programs", "Git", "bin", "bash.exe")
   ] : ["/bin/bash", "/usr/bin/bash", "/usr/local/bin/bash", "/opt/homebrew/bin/bash"];
   for (const p of candidates) {
-    if (p && existsSync12(p))
+    if (p && existsSync14(p))
       return p;
   }
   const probe = spawnSync(process.platform === "win32" ? "where" : "which", ["bash"], {
@@ -2033,9 +2959,9 @@ function runScript(name, args, projectDir) {
   if (!/^[a-z0-9-]+\.sh$/.test(name)) {
     throw new Error(`invalid script name "${name}" (expected one of: ${RUNNABLE.join(", ")})`);
   }
-  const script = join17(SCRIPTS_DIR, name);
-  if (!existsSync12(script)) {
-    const have = existsSync12(SCRIPTS_DIR) ? readdirSync8(SCRIPTS_DIR).filter((f) => f.endsWith(".sh")) : [];
+  const script = join19(SCRIPTS_DIR, name);
+  if (!existsSync14(script)) {
+    const have = existsSync14(SCRIPTS_DIR) ? readdirSync8(SCRIPTS_DIR).filter((f) => f.endsWith(".sh")) : [];
     throw new Error(`script not found: ${name}${have.length ? ` (available: ${have.join(", ")})` : ""}`);
   }
   const bash = findBash();
@@ -2052,9 +2978,30 @@ function runScript(name, args, projectDir) {
 }
 
 // src/continue.ts
-import { existsSync as existsSync13, readFileSync as readFileSync12, readdirSync as readdirSync9 } from "node:fs";
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync14, readdirSync as readdirSync9 } from "node:fs";
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { join as join20 } from "node:path";
+var CURRENT_SCHEMA_VERSION = 2;
+function hasLegacyLayout(projectDir) {
+  for (const legacy of [join20(projectDir, ".mugiwara", "state"), join20(projectDir, ".mugiwara", "continue")]) {
+    if (!existsSync15(legacy))
+      continue;
+    try {
+      const walk = (dir) => {
+        for (const e of readdirSync9(dir, { withFileTypes: true })) {
+          if (e.isFile() && e.name.endsWith(".json"))
+            return true;
+          if (e.isDirectory() && walk(join20(dir, e.name)))
+            return true;
+        }
+        return false;
+      };
+      if (walk(legacy))
+        return true;
+    } catch {}
+  }
+  return false;
+}
 var SAFE = /^[A-Za-z0-9._-]+$/;
 var isSafeKey = (s) => SAFE.test(s) && !/^\.+$/.test(s);
 var num = (v) => {
@@ -2071,7 +3018,7 @@ function gitActor(cwd) {
     return author;
   const git3 = (args) => {
     try {
-      return execFileSync4("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      return execFileSync5("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     } catch {
       return "";
     }
@@ -2082,14 +3029,19 @@ function gitActor(cwd) {
     return `${name} <${email}>`;
   return name || process.env.USER || process.env.USERNAME || "";
 }
+var unreadable = [];
+function unreadableStateFiles() {
+  return [...unreadable];
+}
 function scan(projectDir, kind, map) {
-  const base = join18(projectDir, ".mugiwara", "missions");
-  if (!existsSync13(base))
+  unreadable.length = 0;
+  const base = join20(projectDir, ".mugiwara", "missions");
+  if (!existsSync15(base))
     return [];
   const out = [];
   const missions = readdirSync9(base, { withFileTypes: true }).filter((e) => e.isDirectory() && isSafeKey(e.name)).map((e) => e.name).sort();
   for (const mission of missions) {
-    const dir = join18(base, mission);
+    const dir = join20(base, mission);
     for (const f of readdirSync9(dir).filter((n) => n.endsWith(".json")).sort()) {
       const stem = f.slice(0, -".json".length);
       let member;
@@ -2108,11 +3060,13 @@ function scan(projectDir, kind, map) {
       if (member !== null && !isSafeKey(member))
         continue;
       try {
-        const raw = JSON.parse(readFileSync12(join18(dir, f), "utf8"));
+        const raw = JSON.parse(readFileSync14(join20(dir, f), "utf8"));
         if (text(raw.mission) !== mission)
           continue;
         out.push(map(raw, member));
-      } catch {}
+      } catch {
+        unreadable.push(join20(mission, f));
+      }
     }
   }
   return out;
@@ -2136,6 +3090,7 @@ function readContinue(projectDir) {
 function readState(projectDir) {
   return scan(projectDir, "state", (r, member) => {
     const tasks = r.tasks ?? {};
+    const sv = r.schema_version;
     return {
       mission: text(r.mission),
       member,
@@ -2165,7 +3120,8 @@ function readState(projectDir) {
       budget: num(r.budget),
       budget_status: text(r.budget_status) || "ok",
       files_touched: num(r.files_touched),
-      evidence: Array.isArray(r.evidence) ? r.evidence.map(text).filter(Boolean) : []
+      evidence: Array.isArray(r.evidence) ? r.evidence.map(text).filter(Boolean) : [],
+      schema_version: typeof sv === "number" || typeof sv === "string" ? sv : null
     };
   });
 }
@@ -2223,194 +3179,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/sign.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
-import { chmodSync as chmodSync2, existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
-import { createPrivateKey, createPublicKey, generateKeyPairSync, sign, verify } from "node:crypto";
-import { homedir as homedir3 } from "node:os";
-import { join as join19 } from "node:path";
-function signArgs(reportPath, secretKey) {
-  return ["-Sm", reportPath, "-s", secretKey];
-}
-function verifyArgs(reportPath, pubKey) {
-  return pubKey ? ["-Vm", reportPath, "-p", pubKey] : ["-Vm", reportPath];
-}
-function hasMinisign() {
-  try {
-    execFileSync5("minisign", ["-v"], { stdio: ["ignore", "pipe", "ignore"] });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function defaultKey(flag) {
-  return join19(homedir3(), ".mugiwara", flag === "secret" ? "minisign.key" : "minisign.pub");
-}
-function generatePureKey() {
-  const { privateKey, publicKey } = generateKeyPairSync("ed25519");
-  const privJwk = privateKey.export({ format: "jwk" });
-  const pubJwk = publicKey.export({ format: "jwk" });
-  return {
-    key: Buffer.from(privJwk.d, "base64url").toString("base64"),
-    pub: Buffer.from(pubJwk.x, "base64url").toString("base64")
-  };
-}
-function ensurePureKey(homeDir) {
-  const dir = join19(homeDir, ".mugiwara");
-  const keyPath = join19(dir, "mugiwara.key");
-  const pubPath = join19(dir, "mugiwara.pub");
-  if (!existsSync14(keyPath) || !existsSync14(pubPath)) {
-    mkdirSync9(dir, { recursive: true });
-    const { key, pub } = generatePureKey();
-    if (!existsSync14(keyPath)) {
-      writeFileSync9(keyPath, key + `
-`, { mode: 384 });
-    }
-    if (!existsSync14(pubPath))
-      writeFileSync9(pubPath, pub + `
-`);
-  }
-  try {
-    chmodSync2(keyPath, 384);
-  } catch {}
-  return dir;
-}
-function pureSign(content, seedBase64, opts) {
-  const seed = Buffer.from(seedBase64.trim(), "base64");
-  if (seed.length !== 32)
-    return { ok: false, message: "invalid seed (want 32B base64)" };
-  const pubBuf = Buffer.from(opts.pub.trim(), "base64");
-  if (pubBuf.length !== 32)
-    return { ok: false, message: "invalid pub (want 32B base64)" };
-  const privateKey = createPrivateKey({
-    key: {
-      kty: "OKP",
-      crv: "Ed25519",
-      d: seed.toString("base64url"),
-      x: pubBuf.toString("base64url")
-    },
-    format: "jwk"
-  });
-  const sig = sign(null, Buffer.from(content, "utf8"), privateKey).toString("base64");
-  const out = { algo: "ed25519-pure", sig, pub: opts.pub, mission: opts.mission, commit: opts.commit, ts: opts.ts };
-  if (opts.outputPath)
-    writeFileSync9(opts.outputPath, JSON.stringify(out, null, 2) + `
-`);
-  return { ...out, ok: true };
-}
-function pureVerify(content, sig) {
-  try {
-    const pub = Buffer.from(sig.pub, "base64");
-    if (pub.length !== 32)
-      return false;
-    const publicKey = createPublicKey({
-      key: { kty: "OKP", crv: "Ed25519", x: pub.toString("base64url") },
-      format: "jwk"
-    });
-    return verify(null, Buffer.from(content, "utf8"), publicKey, Buffer.from(sig.sig, "base64"));
-  } catch {
-    return false;
-  }
-}
-function resolveBackend(configured, env) {
-  switch (configured) {
-    case "off":
-      return "off";
-    case "minisign":
-      return env.hasMinisign ? "minisign" : "minisign-fail";
-    case "pure":
-      return "pure";
-    case "auto":
-    default:
-      return env.hasMinisign && env.hasKey ? "minisign" : "pure";
-  }
-}
-function configuredBackend(projectDir) {
-  return readConfig(projectDir).sign;
-}
-function missionMeta(projectDir, mission) {
-  let commit = "unknown";
-  try {
-    commit = execFileSync5("git", ["rev-parse", "HEAD"], { cwd: projectDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-  } catch {}
-  return { commit, ts: new Date().toISOString() };
-}
-function signReport(projectDir, missionDir) {
-  const report = join19(missionDir, "report.md");
-  if (!existsSync14(report))
-    return { ok: false, message: "no report.md to sign — archive first" };
-  const mission = missionDir.split(join19(".mugiwara", "missions", "")).pop() ?? "unknown";
-  const backend = resolveBackend(configuredBackend(projectDir), { hasMinisign: hasMinisign(), hasKey: existsSync14(defaultKey("secret")) });
-  if (backend === "off")
-    return { ok: false, message: "signing disabled (sign=off)" };
-  if (backend === "minisign-fail")
-    return { ok: false, message: "sign=minisign but minisign not installed — install it or set sign=pure" };
-  if (backend === "minisign") {
-    const secretKey = process.env.MUGIWARA_SIGN_KEY?.trim() || defaultKey("secret");
-    try {
-      execFileSync5("minisign", signArgs(report, secretKey), { cwd: projectDir, stdio: "pipe", input: process.env.MUGIWARA_SIGN_PASSWORD ?? "" });
-      return { ok: true, message: `signed ${report}.minisig (minisign, key: ${secretKey})` };
-    } catch (e) {
-      return { ok: false, message: `signing failed: ${e.message}` };
-    }
-  }
-  const dir = ensurePureKey(homedir3());
-  const seed = process.env.MUGIWARA_SIGN_KEY?.trim() || readFileSyncSafe2(join19(dir, "mugiwara.key"));
-  const pub = process.env.MUGIWARA_SIGN_PUB?.trim() || readFileSyncSafe2(join19(dir, "mugiwara.pub"));
-  if (!seed || !pub)
-    return { ok: false, message: "pure keys missing — run `mugiwara sign --gen-key --backend pure`" };
-  const content = readFileSafe(report);
-  if (content === null)
-    return { ok: false, message: `cannot read ${report}` };
-  const { commit, ts } = missionMeta(projectDir, mission);
-  const sig = pureSign(content, seed, { mission, commit, ts, pub, outputPath: `${report}.mugisig` });
-  if (!sig.ok)
-    return { ok: false, message: `signing failed: ${sig.message}` };
-  return { ok: true, message: `signed ${report}.mugisig (pure ed25519, key: ${join19(dir, "mugiwara.key")})` };
-}
-function verifyReport(projectDir, missionDir) {
-  const report = join19(missionDir, "report.md");
-  const minisig = `${report}.minisig`;
-  const mugisig = `${report}.mugisig`;
-  if (!existsSync14(minisig) && !existsSync14(mugisig)) {
-    return { ok: false, message: "not signed (no .minisig or .mugisig beside report.md)" };
-  }
-  if (existsSync14(minisig)) {
-    if (!hasMinisign())
-      return { ok: false, message: "minisig present but minisign not installed — cannot verify that signature" };
-    const pubKey = existsSync14(defaultKey("public")) ? defaultKey("public") : null;
-    try {
-      execFileSync5("minisign", verifyArgs(report, pubKey), { cwd: projectDir, stdio: "pipe" });
-      return { ok: true, message: "signature verifies against report.md (minisig)" };
-    } catch {
-      return { ok: false, message: "SIGNATURE INVALID — report.md changed after signing (minisig)" };
-    }
-  }
-  try {
-    const parsed = JSON.parse(readFileSafe(mugisig) ?? "{}");
-    const content = readFileSafe(report);
-    if (content === null || parsed.algo !== "ed25519-pure")
-      return { ok: false, message: "invalid .mugisig file" };
-    return pureVerify(content, parsed) ? { ok: true, message: "signature verifies against report.md (mugisig, ed25519-pure)" } : { ok: false, message: "SIGNATURE INVALID — report.md changed after signing (mugisig)" };
-  } catch {
-    return { ok: false, message: "invalid .mugisig file" };
-  }
-}
-function readFileSafe(p) {
-  try {
-    return readFileSync13(p, "utf8");
-  } catch {
-    return null;
-  }
-}
-function readFileSyncSafe2(p) {
-  try {
-    return readFileSync13(p, "utf8").trim();
-  } catch {
-    return "";
-  }
-}
-
 // src/slop.ts
 function detectHealingSlop(input) {
   const kind = "healing";
@@ -2441,6 +3209,16 @@ function computeLiveSlop(input) {
 // src/cli.ts
 var str = (v) => typeof v === "string" ? v : undefined;
 var flag = (v) => v === true;
+function resolveProjectDir(explicit) {
+  if (explicit)
+    return resolve2(explicit);
+  try {
+    const root = execFileSync6("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+    if (root)
+      return root;
+  } catch {}
+  return process.cwd();
+}
 async function run(argv) {
   const { command, flags, _ } = parseArgs(argv);
   if (flag(flags.help) || command === "help")
@@ -2449,16 +3227,23 @@ async function run(argv) {
     console.log(`mugiwara ${VERSION}`);
     return;
   }
-  if (command === "continue" || command === "status") {
-    return command === "continue" ? continueCmd(flags, _) : statusCmd(flags);
+  {
+    const bypass = new Set(["install", "update", "uninstall", "list"]);
+    if (!bypass.has(command)) {
+      const projectDirForHarness = resolveProjectDir(str(flags.project));
+      enforceHarnessPolicy(projectDirForHarness);
+    }
   }
   const isDryRunInstall = (command === "install" || command === "update") && flag(flags.dryRun);
   if (!isDryRunInstall) {
-    const projectDir = resolve2(str(flags.project) ?? process.cwd());
+    const projectDir = resolveProjectDir(str(flags.project));
     if (ensureConfig(projectDir)) {
-      console.log(`default .mugiwara/config written at ${join20(projectDir, ".mugiwara", "config")} (edit it to customise)`);
+      console.log(`default .mugiwara/config written at ${join21(projectDir, ".mugiwara", "config")} (edit it to customise)`);
     }
   }
+  if (command === "continue" || command === "status") {
+    return command === "continue" ? continueCmd(flags, _) : statusCmd(flags);
+  }
   switch (command) {
     case "install":
       return install(flags);
@@ -2490,12 +3275,14 @@ async function run(argv) {
       return handoffCmd(flags, _);
     case "sign":
       return signCmd(flags, _);
+    case "migrate":
+      return migrateCmd(flags);
     default:
       throw new Error(`Unknown command: ${command}`);
   }
 }
 function resetCmd(flags) {
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   const force = flag(flags.force);
   const result = resetMission(projectDir, flag(flags.keepLogs), force);
   if (result.blocked) {
@@ -2510,7 +3297,7 @@ function resetCmd(flags) {
     console.log(`kept: ${result.kept.join(", ")}`);
 }
 function archive(flags, positionals) {
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   const mission = positionals[1];
   if (!mission) {
     console.error("usage: mugiwara archive <mission> [--project <dir>] [--dry-run]");
@@ -2529,10 +3316,10 @@ function archive(flags, positionals) {
     console.log(`index updated: ${result.index}`);
 }
 function cleanCmd(flags) {
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   const dryRun = flag(flags.dryRun);
-  const root = join20(projectDir, ".mugiwara", "missions");
-  if (!existsSync15(root)) {
+  const root = join21(projectDir, ".mugiwara", "missions");
+  if (!existsSync16(root)) {
     console.log("nothing to clean (.mugiwara/missions/ does not exist).");
     return;
   }
@@ -2543,7 +3330,7 @@ function cleanCmd(flags) {
     process.exit(1);
   }
   let candidates = readdirSync10(root, { withFileTypes: true }).filter((e) => e.isDirectory() && /^[A-Za-z0-9._-]+$/.test(e.name) && !/^\.+$/.test(e.name)).map((e) => e.name);
-  const stateFiles = (m) => readdirSync10(join20(root, m)).filter((f) => {
+  const stateFiles = (m) => readdirSync10(join21(root, m)).filter((f) => {
     const stem = f.replace(/\.json$/, "");
     return f.endsWith(".json") && stem !== "continue" && !stem.startsWith("continue-");
   });
@@ -2553,7 +3340,7 @@ function cleanCmd(flags) {
       return false;
     for (const f of stateFiles(m)) {
       try {
-        const ts = Date.parse(JSON.parse(readFileSync14(join20(root, m, f), "utf8")).updated_at ?? "") || 0;
+        const ts = Date.parse(JSON.parse(readFileSync15(join21(root, m, f), "utf8")).updated_at ?? "") || 0;
         if (ts === 0 || ts >= beforeMs)
           return false;
       } catch {
@@ -2563,7 +3350,7 @@ function cleanCmd(flags) {
     return true;
   };
   if (!flag(flags.all)) {
-    candidates = candidates.filter((m) => existsSync15(join20(root, m, "report.md")) && !hasLiveState(m) || staleBefore(m));
+    candidates = candidates.filter((m) => existsSync16(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) {
@@ -2596,8 +3383,8 @@ async function resolveOptions(flags) {
       } else
         scope = await choose(rl, "Install scope?", ["global (user-wide)", "project (this repo)"]) === 0 ? "global" : "project";
     }
-    const projectDir = resolve2(str(flags.project) ?? process.cwd());
-    if (scope === "project" && !existsSync15(projectDir))
+    const projectDir = resolveProjectDir(str(flags.project));
+    if (scope === "project" && !existsSync16(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"))
@@ -2664,19 +3451,21 @@ Dry run — nothing written.`);
 OK mugiwara ${VERSION} installed (manifest: ${file})`);
   if (allNotes.length)
     console.log(`${allNotes.length} note(s) above may need attention.`);
+  console.log("CLI: run `npm i -g @ionivetech/mugiwara` so the crew can call `mugiwara savepoint/archive/continue`.");
+  console.log("     Without it the crew degrades to inline-only — no state, no resume, no closure gate.");
   console.log(`
 Next: edit .mugiwara/config to customise (mode, branch, coverage, depths).`);
 }
 async function uninstall(flags) {
   const scope = flag(flags.global) ? "global" : "project";
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   const home = homedir4();
   const file = manifestPath({ scope, projectDir, home });
   const manifest = readManifest(file);
   if (!manifest) {
     if (scope === "project") {
       const globalFile = manifestPath({ scope: "global", projectDir, home });
-      if (existsSync15(globalFile)) {
+      if (existsSync16(globalFile)) {
         console.log(`No project manifest found, but a global install exists. Try:
   mugiwara uninstall --global`);
         return;
@@ -2713,13 +3502,13 @@ async function uninstall(flags) {
         console.log(`   note: ${n}`);
     }
     rmSync3(file);
-    const mugiDir = join20(scope === "global" ? home : projectDir, ".mugiwara");
-    if (existsSync15(mugiDir) && readdirSync10(mugiDir).length === 0) {
+    const mugiDir = join21(scope === "global" ? home : projectDir, ".mugiwara");
+    if (existsSync16(mugiDir) && readdirSync10(mugiDir).length === 0) {
       rmSync3(mugiDir, { recursive: true, force: true });
     }
     if (manifest.targets.includes("opencode")) {
-      const opencodeCache = join20(home, ".cache", "opencode", "packages", "@ionivetech");
-      if (existsSync15(opencodeCache)) {
+      const opencodeCache = join21(home, ".cache", "opencode", "packages", "@ionivetech");
+      if (existsSync16(opencodeCache)) {
         rmSync3(opencodeCache, { recursive: true, force: true });
         console.log("   cleared opencode npm cache (stale plugin versions)");
       }
@@ -2727,9 +3516,25 @@ async function uninstall(flags) {
   }
   console.log(`OK removed ${removed.length} files`);
 }
+function legacyWarning(projectDir) {
+  if (hasLegacyLayout(projectDir)) {
+    console.error("⚠ legacy layout detected (v0.6 .mugiwara/state/ — run `mugiwara migrate` to move to missions/)");
+  }
+}
+function schemaWarnings(projectDir) {
+  const states = readState(projectDir);
+  for (const s of states) {
+    const v = s.schema_version;
+    if (v !== CURRENT_SCHEMA_VERSION) {
+      const wrote = v === null || v === undefined || v === "" ? "unknown" : String(v);
+      console.error(`⚠ state written by v${wrote} (mission ${s.mission}${s.member ? `/${s.member}` : ""}) — current expects v${CURRENT_SCHEMA_VERSION} — run \`mugiwara migrate\``);
+    }
+  }
+}
 function list(flags) {
   const home = homedir4();
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
+  legacyWarning(projectDir);
   let found = false;
   for (const [label, file] of [
     ["project", manifestPath({ scope: "project", projectDir, home })],
@@ -2740,7 +3545,7 @@ function list(flags) {
       continue;
     found = true;
     if (flag(flags.check)) {
-      const missing = m.files.filter((f) => !existsSync15(f));
+      const missing = m.files.filter((f) => !existsSync16(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}`);
@@ -2750,9 +3555,20 @@ function list(flags) {
     console.log("No mugiwara installation found.");
 }
 function continueCmd(flags, positionals) {
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
+  legacyWarning(projectDir);
+  schemaWarnings(projectDir);
   const [mission, member] = positionals.slice(1);
   let entries = readContinue(projectDir);
+  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}`);
+      process.exit(1);
+    }
+  }
   if (!flag(flags.all)) {
     const actor = gitActor(projectDir);
     const mine = entries.filter((e) => e.actor === actor);
@@ -2790,10 +3606,17 @@ Pick one: mugiwara continue ${r.mission} <member>`);
   process.exit(2);
 }
 function statusCmd(flags) {
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
+  legacyWarning(projectDir);
+  schemaWarnings(projectDir);
   const states = readState(projectDir);
+  const bad = unreadableStateFiles();
+  if (bad.length) {
+    console.error(`⚠ ${bad.length} unreadable state file(s): ${bad.join(", ")}`);
+    console.error('  These are not "no mission" — they are corrupt. Inspect or delete them.');
+  }
   if (!states.length) {
-    console.log("No mission state on disk.");
+    console.log(bad.length ? "No readable mission state on disk." : "No mission state on disk.");
     return;
   }
   const actor = flag(flags.all) ? null : gitActor(projectDir);
@@ -2811,7 +3634,7 @@ function statusCmd(flags) {
   }
 }
 function costCmd(flags, positionals) {
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   const mission = str(flags.mission) ?? positionals[1] ?? (() => {
     const states2 = readState(projectDir);
     if (states2.length === 1)
@@ -2826,8 +3649,8 @@ function costCmd(flags, positionals) {
     console.error("usage: mugiwara cost [--mission <id>] [--json] [--ledger] [--project <dir>]");
     process.exit(1);
   }
-  const missionDir = join20(projectDir, ".mugiwara", "missions", mission);
-  if (!existsSync15(missionDir)) {
+  const missionDir = join21(projectDir, ".mugiwara", "missions", mission);
+  if (!existsSync16(missionDir)) {
     console.error(`No cost ledger found for mission "${mission}"`);
     process.exit(1);
   }
@@ -2863,7 +3686,7 @@ function costCmd(flags, positionals) {
   }
 }
 function runCmd(flags, positionals) {
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   const name = positionals[1];
   if (!name) {
     console.error(`usage: mugiwara run <script> [args...]
@@ -2875,7 +3698,7 @@ function runCmd(flags, positionals) {
     process.exit(code);
 }
 function blameCmd(flags, positionals) {
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   const path = positionals[1];
   if (!path) {
     console.error("usage: mugiwara blame <file-path>");
@@ -2909,13 +3732,18 @@ function stalenessLine(projectDir, baseSha) {
   }
 }
 function handoffCmd(flags, positionals) {
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   const mission = positionals[1];
   if (!mission) {
     console.error("usage: mugiwara handoff <mission> [--project <dir>]");
     process.exit(1);
   }
   const states = readState(projectDir).filter((s) => s.mission === mission);
+  const bad = unreadableStateFiles().filter((p) => p.startsWith(`${mission}/`));
+  if (bad.length) {
+    console.error(`✗ mission "${mission}" has unreadable state: ${bad.join(", ")}`);
+    process.exit(1);
+  }
   if (!states.length) {
     console.error(`no in-flight mission "${mission}"`);
     process.exit(1);
@@ -2947,7 +3775,7 @@ function handoffCmd(flags, positionals) {
   }
   lines.push("", "## Resuming", "", `\`mugiwara continue ${mission}\` prints the exact resume point.`);
   lines.push("Verify `next_action` against plan.md before executing — the table above is computed state, not judgement.");
-  const out = join20(".mugiwara", "missions", mission, "handoff.md");
+  const out = join21(".mugiwara", "missions", mission, "handoff.md");
   writeFileSync10(resolve2(projectDir, out), lines.join(`
 `) + `
 `);
@@ -2956,8 +3784,98 @@ function handoffCmd(flags, positionals) {
   console.log(`
 written: ${out}`);
 }
+function migrateCmd(flags) {
+  const projectDir = resolveProjectDir(str(flags.project));
+  const dryRun = flag(flags.dryRun);
+  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))
+      return;
+    const walk = (dir) => {
+      for (const e of readdirSync10(dir, { withFileTypes: true })) {
+        const full = join21(dir, e.name);
+        if (e.isDirectory())
+          walk(full);
+        else if (e.isFile() && e.name.endsWith(".json")) {
+          const rel = full.slice(srcRoot.length + 1);
+          let destRel;
+          if (isContinue) {
+            const parts = rel.split("/");
+            const file = parts.pop();
+            const mission = parts.join("/");
+            const stem = file.slice(0, -".json".length);
+            let destFile;
+            if (stem === "state")
+              destFile = "continue.json";
+            else
+              destFile = `continue-${stem}.json`;
+            destRel = mission ? join21(mission, destFile) : destFile;
+          } else {
+            destRel = rel;
+          }
+          moves.push({ src: full, dest: join21(missionsRoot, destRel) });
+        }
+      }
+    };
+    walk(srcRoot);
+  };
+  collect(legacyState, false);
+  collect(legacyContinue, true);
+  if (!moves.length) {
+    if (!existsSync16(legacyState) && !existsSync16(legacyContinue)) {
+      console.log("no legacy layout found (.mugiwara/state/ does not exist)");
+    } else {
+      console.log("no legacy state files to migrate");
+    }
+    return;
+  }
+  for (const m of moves) {
+    console.log(`${dryRun ? "would migrate" : "migrated"} ${m.src} → ${m.dest}`);
+    if (!dryRun) {
+      mkdirSync10(dirname6(m.dest), { recursive: true });
+      try {
+        const raw = JSON.parse(readFileSync15(m.src, "utf8"));
+        raw.schema_version = CURRENT_SCHEMA_VERSION;
+        writeFileSync10(m.dest, JSON.stringify(raw, null, 2) + `
+`);
+        rmSync3(m.src, { force: true });
+      } catch {
+        try {
+          renameSync2(m.src, m.dest);
+        } catch {}
+      }
+    }
+  }
+  if (!dryRun) {
+    const prune = (root) => {
+      if (!existsSync16(root))
+        return;
+      const walkPrune = (dir) => {
+        for (const e of readdirSync10(dir, { withFileTypes: true })) {
+          if (e.isDirectory())
+            walkPrune(join21(dir, e.name));
+        }
+        try {
+          if (readdirSync10(dir).length === 0)
+            rmSync3(dir, { recursive: true, force: true });
+        } catch {}
+      };
+      walkPrune(root);
+      try {
+        if (existsSync16(root) && readdirSync10(root).length === 0)
+          rmSync3(root, { recursive: true, force: true });
+      } catch {}
+    };
+    prune(legacyState);
+    prune(legacyContinue);
+  }
+  console.log(`${dryRun ? "would migrate" : "migrated"} ${moves.length} file(s)${dryRun ? " (dry run)" : ""}`);
+}
 function signCmd(flags, _) {
-  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   if (flag(flags.genKey)) {
     const backend = str(flags.backend) ?? "auto";
     const home = homedir4();
@@ -2976,7 +3894,7 @@ function signCmd(flags, _) {
       }
     }
     const dir = ensurePureKey(home);
-    console.log(`✓ pure ed25519 key pair ready: ${join20(dir, "mugiwara.key")} / ${join20(dir, "mugiwara.pub")}`);
+    console.log(`✓ pure ed25519 key pair ready: ${join21(dir, "mugiwara.key")} / ${join21(dir, "mugiwara.pub")}`);
     return;
   }
   const mission = _[1];
@@ -2984,8 +3902,8 @@ function signCmd(flags, _) {
     console.error("usage: mugiwara sign <mission> [--verify] [--gen-key [--backend pure|minisign]] [--project <dir>]");
     process.exit(1);
   }
-  const missionDir = join20(projectDir, ".mugiwara", "missions", mission);
-  if (!existsSync15(missionDir)) {
+  const missionDir = join21(projectDir, ".mugiwara", "missions", mission);
+  if (!existsSync16(missionDir)) {
     console.error(`no mission dir: ${missionDir}`);
     process.exit(1);
   }
@@ -3020,10 +3938,12 @@ Usage:
   mugiwara sign <m>      attestation: sign report.md (auto/minisign/pure/off; --verify to check)
   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/
   mugiwara run <script> [args...]
-                         run a bundled harness script here (${RUNNABLE.join(", ")})
+                          run a bundled harness script here (${RUNNABLE.join(", ")})
   mugiwara savepoint <mission> [member] [flow] [mode]
-                         shorthand for: mugiwara run savepoint.sh ...
+                          shorthand for: mugiwara run savepoint.sh ...
   mugiwara --help        this help
   mugiwara --version     print version
 
@@ -3048,6 +3968,7 @@ if (isMain) {
   });
 }
 export {
+  migrateCmd,
   run,
   stalenessLine
 };