@ionivetech/mugiwara 0.6.4 → 0.6.6

package/dist/mugiwara.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync as existsSync7, readdirSync as readdirSync5, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync8, readdirSync as readdirSync7, rmSync as rmSync3 } from "node:fs";
+import { spawnSync as spawnSync2 } from "node:child_process";
 import { homedir as homedir2 } from "node:os";
-import { join as join8, resolve } from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { join as join11, resolve as resolve2 } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/args.ts
 var VALUE_FLAGS = { "--project": "project", "--target": "target" };
@@ -16,6 +17,7 @@ var BOOL_FLAGS = {
   "--dry-run": "dryRun",
   "--keep-logs": "keepLogs",
   "--check": "check",
+  "--all": "all",
   "--help": "help",
   "-h": "help",
   "--version": "version",
@@ -81,7 +83,7 @@ async function confirm(rl, question) {
 }
 
 // src/targets/claude.ts
-import { existsSync, mkdirSync, copyFileSync, chmodSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, chmodSync, readdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -119,6 +121,107 @@ function toolsFromScope(scope) {
     return "Read, Grep, Glob, Write, Bash, WebFetch, WebSearch";
   return;
 }
+var SCRIPTS_SRC = join(here, "..", "..", "scripts");
+function copyScripts(dstDir) {
+  if (!existsSync(SCRIPTS_SRC))
+    return [];
+  const written = [];
+  const copyDir = (src, dst) => {
+    if (!existsSync(src))
+      return;
+    for (const f of readdirSync(src)) {
+      if (!f.endsWith(".sh") && f !== "initiative.ts" || f === "install.sh")
+        continue;
+      const to = join(dst, f);
+      mkdirSync(dst, { recursive: true });
+      copyFileSync(join(src, f), to);
+      chmodSync(to, 493);
+      written.push(to);
+    }
+  };
+  copyDir(SCRIPTS_SRC, dstDir);
+  copyDir(join(SCRIPTS_SRC, "lib"), join(dstDir, "lib"));
+  return written;
+}
+function wireSettings(root, hooksDir) {
+  const file = join(root, "settings.json");
+  const events = {
+    SessionStart: { file: "session-start.js", timeout: 10 },
+    UserPromptSubmit: { file: "mugiwara-mode-tracker.js", timeout: 5 },
+    Stop: { file: "auto-savepoint.js", timeout: 20 },
+    SubagentStop: { file: "pipeline-guard.js", timeout: 15 },
+    PostToolUse: { file: "engagement-marker.js", timeout: 5, matcher: "Task|Skill" }
+  };
+  let settings = {};
+  if (existsSync(file)) {
+    try {
+      settings = JSON.parse(readFileSync(file, "utf8"));
+    } catch {
+      return { written: [], notes: [`${file} is not valid JSON — add the mugiwara hooks manually`] };
+    }
+  }
+  const hooks = settings.hooks ?? {};
+  let changed = false;
+  for (const [event, spec] of Object.entries(events)) {
+    const command = join(hooksDir, spec.file);
+    if (!existsSync(command))
+      continue;
+    const groups = Array.isArray(hooks[event]) ? hooks[event] : [];
+    const already = groups.some((g) => g.hooks?.some((h) => h.command?.includes(spec.file)));
+    if (already)
+      continue;
+    const group = { hooks: [{ type: "command", command: JSON.stringify(command), timeout: spec.timeout }] };
+    if (spec.matcher)
+      group.matcher = spec.matcher;
+    groups.push(group);
+    hooks[event] = groups;
+    changed = true;
+  }
+  if (!changed)
+    return { written: [], notes: [] };
+  settings.hooks = hooks;
+  writeFileSync(file, JSON.stringify(settings, null, 2) + `
+`);
+  return { written: [], notes: [`hooks registered in ${file}`] };
+}
+function unwireSettings(root) {
+  const file = join(root, "settings.json");
+  if (!existsSync(file))
+    return { changed: [], notes: [] };
+  let settings;
+  try {
+    settings = JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return { changed: [], notes: [`${file} is not valid JSON — left untouched`] };
+  }
+  const hooks = settings.hooks;
+  if (!hooks)
+    return { changed: [], notes: [] };
+  const ours = new Set(["session-start.js", "mugiwara-mode-tracker.js", "auto-savepoint.js", "pipeline-guard.js", "engagement-marker.js"]);
+  const isOurs = (h) => [...ours].some((f) => h.command?.includes(join("hooks", f)) || h.command?.includes(`hooks/${f}`));
+  let changed = false;
+  for (const [event, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups))
+      continue;
+    const kept = groups.map((g) => ({ ...g, hooks: (g.hooks ?? []).filter((h) => !isOurs(h)) })).filter((g) => g.hooks.length > 0);
+    if (kept.length !== groups.length || kept.some((g, i) => g.hooks.length !== groups[i]?.hooks?.length)) {
+      changed = true;
+    }
+    if (kept.length)
+      hooks[event] = kept;
+    else {
+      delete hooks[event];
+      changed = true;
+    }
+  }
+  if (!changed)
+    return { changed: [], notes: [] };
+  if (!Object.keys(hooks).length)
+    delete settings.hooks;
+  writeFileSync(file, JSON.stringify(settings, null, 2) + `
+`);
+  return { changed: [file], notes: [] };
+}
 var target = {
   id: "claude",
   label: "Claude Code",
@@ -157,7 +260,7 @@ var target = {
       return { written: [], notes: [] };
     if (existsSync(HOOKS_SRC)) {
       for (const f of readdirSync(HOOKS_SRC)) {
-        if (!f.endsWith(".ts"))
+        if (!/\.(ts|js|json)$/.test(f))
           continue;
         const dst = join(root, "hooks", f);
         if (!existsSync(dst)) {
@@ -167,6 +270,10 @@ var target = {
           written.push(dst);
         }
       }
+      written.push(...copyScripts(join(root, "scripts")));
+      const wired = wireSettings(root, join(root, "hooks"));
+      written.push(...wired.written);
+      notes.push(...wired.notes);
     }
     if (existsSync(COMMANDS_SRC)) {
       const dstDir = join(root, "commands");
@@ -184,6 +291,12 @@ var target = {
       }
     }
     return { written, notes };
+  },
+  postUninstall({ scope, projectDir, home, dryRun }) {
+    if (dryRun)
+      return { changed: [], notes: [] };
+    const root = scope === "global" ? join(home, ".claude") : join(projectDir, ".claude");
+    return unwireSettings(root);
   }
 };
 
@@ -318,7 +431,17 @@ var target3 = {
   transformSkill(data, body) {
     return {
       relPath: `${data.name}.instructions.md`,
-      text: stringifyFrontmatter({ description: data.description, applyTo: "**/*" }, body)
+      text: stringifyFrontmatter({ description: data.description, applyTo: "**/*" }, `# ${data.name}
+
+> ${data.description}
+
+Full skill: read \`.mugiwara/refs/${data.name}/${data.name}.md\` when the crew invokes this role.`)
+    };
+  },
+  transformSkillFull(data, body) {
+    return {
+      relPath: `${data.name}.md`,
+      text: stringifyFrontmatter({ description: data.description }, body)
     };
   },
   transformAgent(data, body) {
@@ -333,7 +456,7 @@ var target3 = {
 };
 
 // src/targets/generic.ts
-import { existsSync as existsSync3, writeFileSync } from "node:fs";
+import { existsSync as existsSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join4 } from "node:path";
 function makeGeneric(opts) {
   const { id, label, rulesDir, bootstrapFile, bootstrapPointer, tier = bootstrapPointer ? 2 : 3 } = opts;
@@ -359,7 +482,7 @@ function makeGeneric(opts) {
 
 ## Skip when
 
-Full skill: \`${data.name}\` — read \`.mugiwara/refs/${data.name}.md\` when the crew invokes this role.`
+Full skill: \`${data.name}\` — read \`.mugiwara/refs/${data.name}/${data.name}.md\` when the crew invokes this role.`
         };
       }
       return { relPath: `${data.name}.md`, text: `# ${data.name}
@@ -385,7 +508,7 @@ ${body}` };
 
 > ${data.description}
 
-Skills: ${data.skills ?? ""}. Read \`.mugiwara/refs/${data.name}.md\` when embodying this role.
+Skills: ${data.skills ?? ""}. Read \`.mugiwara/refs/${data.name}/${data.name}.md\` when embodying this role.
 
 Only zoro-execution and brook-healing may modify source code.
 Return your output to luffy-orchestrator; do not choose the next step.`
@@ -410,8 +533,8 @@ Skills used: ${data.skills ?? ""}
 
 ${body}` };
     },
-    refsDir({ projectDir }) {
-      return join4(projectDir, ".mugiwara", "refs");
+    refsDir({ projectDir }, skillName) {
+      return join4(projectDir, ".mugiwara", "refs", skillName);
     },
     postInstall({ projectDir, dryRun }) {
       if (!bootstrapFile)
@@ -421,7 +544,7 @@ ${body}` };
       const file = join4(projectDir, bootstrapFile);
       if (!existsSync3(file)) {
         if (!dryRun)
-          writeFileSync(file, `${bootstrapPointer}
+          writeFileSync2(file, `${bootstrapPointer}
 `);
         written.push(file);
       } else {
@@ -496,7 +619,7 @@ var targets = { claude: target, opencode: target2, copilot: target3, gemini: tar
 var TARGET_IDS = Object.keys(targets);
 
 // src/installer.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync2, copyFileSync as copyFileSync3, rmSync, lstatSync } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync3, copyFileSync as copyFileSync3, rmSync, lstatSync } from "node:fs";
 import { dirname as dirname3, join as join5 } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
@@ -560,7 +683,7 @@ function installTo(target10, opts) {
     }
     if (!dryRun) {
       mkdirSync3(dirname3(absPath), { recursive: true });
-      writeFileSync2(absPath, text);
+      writeFileSync3(absPath, text);
     }
     result.written.push(absPath);
   };
@@ -609,6 +732,38 @@ function installTo(target10, opts) {
     result.written.push(...post.written);
     result.notes.push(...post.notes);
   }
+  if (scope === "project") {
+    const configPath = join5(projectDir, ".mugiwara", "config");
+    let configExists = false;
+    try {
+      configExists = lstatSync(configPath).isFile() || lstatSync(configPath).isSymbolicLink();
+    } catch {
+      configExists = false;
+    }
+    if (!configExists) {
+      const body = [
+        "mode=guided",
+        "branch=feature/{type}-{issue}-{slug}",
+        "commit=conventional",
+        "auto_commit=on",
+        "coverage_new=90",
+        "coverage_modified=80",
+        "review_depth=full",
+        "quality_depth=full",
+        "delegate_threshold=60",
+        "heal_max_cycles=3",
+        "verbosity=normal"
+      ].join(`
+`) + `
+`;
+      if (!dryRun) {
+        mkdirSync3(dirname3(configPath), { recursive: true });
+        writeFileSync3(configPath, body);
+      }
+      result.written.push(configPath);
+      result.notes.push(`default config written: ${configPath} (run \`mugiwara onboard\` to customise)`);
+    }
+  }
   return result;
 }
 function removeInstalled(manifest, { dryRun = false } = {}) {
@@ -676,7 +831,7 @@ function ensureProjectGitignore(projectDir, opts = {}) {
 ` : "";
   if (!dryRun) {
     mkdirSync3(dirname3(path), { recursive: true });
-    writeFileSync2(path, existing + separator + GITIGNORE_BLOCK);
+    writeFileSync3(path, existing + separator + GITIGNORE_BLOCK);
   }
   return { appended: true, notes: [`.gitignore ${dryRun ? "would upgrade+append" : "upgraded"} mugiwara audit-trail block`] };
 }
@@ -723,12 +878,12 @@ function removeProjectGitignore(projectDir, { dryRun = false } = {}) {
   if (cleaned === current)
     return { removed: false, notes: [] };
   if (!dryRun)
-    writeFileSync2(path, cleaned);
+    writeFileSync3(path, cleaned);
   return { removed: true, notes: [`.gitignore ${dryRun ? "would strip" : "stripped"} mugiwara block`] };
 }
 
 // src/manifest.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname4, join as join6 } from "node:path";
 function manifestPath({ scope, projectDir, home }) {
   return scope === "global" ? join6(home, ".mugiwara", "manifest.json") : join6(projectDir, ".mugiwara", "manifest.json");
@@ -738,7 +893,7 @@ function readManifest(file) {
 }
 function writeManifest(file, data) {
   mkdirSync4(dirname4(file), { recursive: true });
-  writeFileSync3(file, JSON.stringify(data, null, 2) + `
+  writeFileSync4(file, JSON.stringify(data, null, 2) + `
 `);
 }
 
@@ -912,6 +1067,417 @@ function archiveMission(projectDir, mission, opts = {}) {
   return { report, removed, kept, index };
 }
 
+// src/onboard.ts
+import { existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join8 } from "node:path";
+var DEFAULT_ORDER = [
+  "mode",
+  "branch",
+  "commit",
+  "auto_commit",
+  "coverage_new",
+  "coverage_modified",
+  "review_depth",
+  "quality_depth",
+  "delegate_threshold",
+  "heal_max_cycles",
+  "verbosity"
+];
+var DEFAULTS = {
+  auto_commit: "on",
+  delegate_threshold: "60",
+  heal_max_cycles: "3",
+  verbosity: "normal"
+};
+var BRANCH_PRESETS = {
+  1: "feature/{type}-{issue}-{slug}",
+  2: "feature/{slug}",
+  3: "feat/{slug}"
+};
+var COMMIT_PRESETS = {
+  1: "conventional",
+  2: "gitmoji",
+  3: "plain"
+};
+function parseConfig(lines) {
+  const map = new Map;
+  for (const line of lines) {
+    const t = line.trim();
+    if (!t || t.startsWith("#"))
+      continue;
+    const eq = t.indexOf("=");
+    if (eq === -1)
+      continue;
+    const k = t.slice(0, eq).trim();
+    const v = t.slice(eq + 1).trim();
+    if (!map.has(k))
+      map.set(k, v);
+  }
+  return map;
+}
+function buildConfig(existing, updates) {
+  const merged = new Map(existing);
+  for (const [k, v] of Object.entries(updates))
+    merged.set(k, v);
+  const lines = [];
+  for (const k of DEFAULT_ORDER) {
+    const v = merged.get(k) ?? DEFAULTS[k];
+    if (v === undefined)
+      continue;
+    lines.push(`${k}=${v}`);
+    merged.delete(k);
+  }
+  for (const [k, v] of merged)
+    lines.push(`${k}=${v}`);
+  return lines.join(`
+`) + `
+`;
+}
+async function askFreeText(rl, prompt) {
+  for (;; ) {
+    const v = (await rl.question(prompt)).trim();
+    if (v)
+      return v;
+    console.log("  Cannot be empty.");
+  }
+}
+function assertNotSymlink2(file) {
+  if (!existsSync7(file))
+    return;
+  try {
+    if (lstatSync2(file).isSymbolicLink())
+      throw new Error(`refusing to follow symlink: ${file}`);
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return;
+    throw e;
+  }
+}
+async function runOnboard(projectDir) {
+  if (!process.stdin.isTTY) {
+    throw new Error("Not a terminal. Run `mugiwara onboard` in a terminal, or edit .mugiwara/config directly.");
+  }
+  const mugiwaraDir = join8(projectDir, ".mugiwara");
+  const configPath = join8(mugiwaraDir, "config");
+  assertNotSymlink2(configPath);
+  const existing = parseConfig(existsSync7(configPath) ? readFileSync6(configPath, "utf8").split(/\r?\n/) : []);
+  const rl = createRl();
+  try {
+    console.log("");
+    console.log("╔══════════════════════════════════════╗");
+    console.log("║   Mugiwara Onboarding Wizard         ║");
+    console.log("╚══════════════════════════════════════╝");
+    console.log("");
+    if (existing.size > 0) {
+      const redo = await confirm(rl, "Existing .mugiwara/config found. Re-onboard?");
+      if (!redo) {
+        console.log("Onboarding cancelled. Config preserved.");
+        return;
+      }
+      console.log("");
+    }
+    const branchChoice = await choose(rl, "Q1 — Branch naming pattern:", [
+      "Trunk-based — feature/{type}-{issue}-{slug}",
+      "GitFlow — feature/{slug}",
+      "GitHub Flow — feat/{slug}",
+      "Custom — enter your own pattern"
+    ]);
+    let branch;
+    if (branchChoice === 3) {
+      branch = await askFreeText(rl, "  Branch pattern (placeholders: {type} {issue} {slug}, e.g. {issue}-{slug}): ");
+    } else {
+      branch = BRANCH_PRESETS[branchChoice + 1];
+    }
+    const modeIdx = await choose(rl, "Q2 — Autonomy mode:", [
+      "guided — ask before every wave transition",
+      "semi — auto-advance through waves, pause on failures",
+      "auto — full auto-pilot"
+    ]);
+    const mode = ["guided", "semi", "auto"][modeIdx];
+    const reviewIdx = await choose(rl, "Q3 — Code review depth:", [
+      "full — breaking-change map, five-axis review, <=3 cycles",
+      "standard — five-axis review, 1 cycle",
+      "quick — diff-only, no caller-map"
+    ]);
+    const reviewDepth = ["full", "standard", "quick"][reviewIdx];
+    const qualityIdx = await choose(rl, "Q4 — Quality check depth:", [
+      "full — format, lint, typecheck, test, build",
+      "standard — lint, typecheck, test",
+      "quick — test only"
+    ]);
+    const qualityDepth = ["full", "standard", "quick"][qualityIdx];
+    const covIdx = await choose(rl, "Q5 — Test coverage threshold:", [
+      "90/80 — new code 90%, modified 80%",
+      "80/70 — new code 80%, modified 70%",
+      "custom — enter your own values",
+      "none — 0/0, no coverage enforcement"
+    ]);
+    let coverageNew = 90;
+    let coverageModified = 80;
+    if (covIdx === 1) {
+      coverageNew = 80;
+      coverageModified = 70;
+    } else if (covIdx === 2) {
+      coverageNew = Number.parseInt(await askFreeText(rl, "  Coverage for new code (%): "), 10) || 0;
+      coverageModified = Number.parseInt(await askFreeText(rl, "  Coverage for modified code (%): "), 10) || 0;
+    } else if (covIdx === 3) {
+      coverageNew = 0;
+      coverageModified = 0;
+    }
+    const commitChoice = await choose(rl, "Q6 — Commit style:", [
+      "Conventional Commits — feat:, fix:, chore:, docs:",
+      "Gitmoji — emoji-prefixed conventional",
+      "Plain — no prefix, imperative sentence",
+      "Custom template — enter your own (placeholders: {type} {issue} {title})"
+    ]);
+    let commit;
+    if (commitChoice === 3) {
+      commit = await askFreeText(rl, "  Commit template (e.g. {issue}: {title}): ");
+    } else {
+      commit = COMMIT_PRESETS[commitChoice + 1];
+    }
+    if (!existsSync7(mugiwaraDir))
+      mkdirSync6(mugiwaraDir, { recursive: true });
+    const body = buildConfig(existing, {
+      mode,
+      branch,
+      commit,
+      coverage_new: String(coverageNew),
+      coverage_modified: String(coverageModified),
+      review_depth: reviewDepth,
+      quality_depth: qualityDepth
+    });
+    writeFileSync5(configPath, `# .mugiwara/config — written by mugiwara onboard on ${new Date().toISOString().slice(0, 10)}
+${body}`);
+    console.log("╔══════════════════════════════════════╗");
+    console.log("║   Onboarding Complete                ║");
+    console.log("╚══════════════════════════════════════╝");
+    console.log("");
+    console.log(`  Branch pattern:   ${branch}`);
+    console.log(`  Autonomy mode:    ${mode}`);
+    console.log(`  Review depth:     ${reviewDepth}`);
+    console.log(`  Quality depth:    ${qualityDepth}`);
+    console.log(`  Coverage:         ${coverageNew}/${coverageModified}`);
+    console.log(`  Commit style:     ${commit}`);
+    console.log("");
+    console.log(`  Config written:   ${configPath}`);
+    console.log("");
+  } finally {
+    rl.close();
+  }
+}
+
+// src/run.ts
+import { existsSync as existsSync8, readdirSync as readdirSync5 } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname as dirname5, join as join9, resolve } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+var here3 = dirname5(fileURLToPath4(import.meta.url));
+var SCRIPTS_DIR = join9(here3, "..", "scripts");
+var RUNNABLE = ["savepoint.sh", "lane.sh", "evidence.sh", "mission-report.sh"];
+function findBash() {
+  const explicit = process.env.MUGIWARA_BASH?.trim();
+  if (explicit)
+    return existsSync8(explicit) ? explicit : null;
+  const candidates = process.platform === "win32" ? [
+    "C:\\Program Files\\Git\\bin\\bash.exe",
+    "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+    join9(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 && existsSync8(p))
+      return p;
+  }
+  const probe = spawnSync(process.platform === "win32" ? "where" : "which", ["bash"], {
+    encoding: "utf8"
+  });
+  const first = probe.stdout?.split(/\r?\n/).find((l) => l.trim());
+  return first?.trim() || null;
+}
+function noBashMessage() {
+  const remedy = process.platform === "win32" ? "Install Git for Windows (which ships bash)" : "Install bash with your package manager (e.g. `apk add bash`, `apt install bash`)";
+  return `no bash found. ${remedy}, or set MUGIWARA_BASH to a bash executable.`;
+}
+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 = join9(SCRIPTS_DIR, name);
+  if (!existsSync8(script)) {
+    const have = existsSync8(SCRIPTS_DIR) ? readdirSync5(SCRIPTS_DIR).filter((f) => f.endsWith(".sh")) : [];
+    throw new Error(`script not found: ${name}${have.length ? ` (available: ${have.join(", ")})` : ""}`);
+  }
+  const bash = findBash();
+  if (!bash)
+    throw new Error(noBashMessage());
+  const r = spawnSync(bash, [script, ...args], {
+    cwd: resolve(projectDir),
+    stdio: "inherit",
+    env: process.env
+  });
+  if (r.error)
+    throw r.error;
+  return r.status ?? 1;
+}
+
+// src/continue.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync as readdirSync6 } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join as join10 } from "node:path";
+var SAFE = /^[A-Za-z0-9._-]+$/;
+var isSafeKey = (s) => SAFE.test(s) && !/^\.+$/.test(s);
+var num = (v) => {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : 0;
+};
+var text = (v) => typeof v === "string" ? v : "";
+function gitActor(cwd) {
+  const env = (process.env.STATE_ACTOR ?? "").trim();
+  if (env)
+    return env;
+  const author = (process.env.GIT_AUTHOR_NAME ?? "").trim();
+  if (author)
+    return author;
+  const git = (args) => {
+    try {
+      return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    } catch {
+      return "";
+    }
+  };
+  const name = git(["config", "user.name"]);
+  const email = git(["config", "user.email"]);
+  if (name && email)
+    return `${name} <${email}>`;
+  return name || process.env.USER || process.env.USERNAME || "";
+}
+function scan(projectDir, root, map) {
+  const base = join10(projectDir, ".mugiwara", root);
+  if (!existsSync9(base))
+    return [];
+  const out = [];
+  const missions = readdirSync6(base, { withFileTypes: true }).filter((e) => e.isDirectory() && isSafeKey(e.name)).map((e) => e.name).sort();
+  for (const mission of missions) {
+    const dir = join10(base, mission);
+    for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
+      const stem = f.slice(0, -".json".length);
+      const member = stem === "state" ? null : stem;
+      if (member !== null && !isSafeKey(member))
+        continue;
+      try {
+        const raw = JSON.parse(readFileSync7(join10(dir, f), "utf8"));
+        if (text(raw.mission) !== mission)
+          continue;
+        out.push(map(raw, member));
+      } catch {}
+    }
+  }
+  return out;
+}
+function readContinue(projectDir) {
+  return scan(projectDir, "continue", (r, member) => ({
+    mission: text(r.mission),
+    member,
+    actor: text(r.actor),
+    branch: text(r.branch),
+    flow: num(r.flow ?? r.wave),
+    mode: text(r.mode) || "guided",
+    tasks_done: num(r.tasks_done),
+    tasks_total: num(r.tasks_total),
+    lane: text(r.lane) || "direct",
+    next_action: text(r.next_action),
+    next_session_prompt: text(r.next_session_prompt),
+    updated_at: text(r.updated_at)
+  }));
+}
+function readState(projectDir) {
+  return scan(projectDir, "state", (r, member) => {
+    const tasks = r.tasks ?? {};
+    return {
+      mission: text(r.mission),
+      member,
+      actor: text(r.actor),
+      branch: text(r.branch),
+      flow: num(r.flow ?? r.wave),
+      mode: text(r.mode) || "guided",
+      tasks_done: num(tasks.done),
+      tasks_total: num(tasks.total),
+      lane: text(r.lane) || "direct",
+      lane_reason: text(r.lane_reason),
+      lane_rose: r.lane_rose === true,
+      lane_prev: text(r.lane_prev),
+      lane_peak: text(r.lane_peak),
+      next_action: "",
+      next_session_prompt: "",
+      updated_at: text(r.updated_at),
+      blockers_open: num(r.blockers_open),
+      heal_cycle: num(r.heal_cycle),
+      heal_max_cycles: num(r.heal_max_cycles) || 3,
+      heal_halt: r.heal_halt === true,
+      delegate_threshold: num(r.delegate_threshold) || 60,
+      delegate_due: r.delegate_due === true,
+      tokens_est: num(r.tokens_est),
+      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) : []
+    };
+  });
+}
+function resolveContinue(entries, mission, member) {
+  if (!entries.length)
+    return { kind: "none" };
+  if (!mission) {
+    const missions = [...new Set(entries.map((e) => e.mission))];
+    if (missions.length === 1)
+      return resolveContinue(entries, missions[0], member);
+    return { kind: "missions", entries };
+  }
+  const inMission = entries.filter((e) => e.mission === mission);
+  if (!inMission.length) {
+    return { kind: "unknown-mission", mission, known: [...new Set(entries.map((e) => e.mission))] };
+  }
+  if (member) {
+    const hit = inMission.find((e) => e.member === member);
+    if (!hit) {
+      return {
+        kind: "unknown-member",
+        mission,
+        member,
+        known: inMission.map((e) => e.member ?? "(solo)")
+      };
+    }
+    return { kind: "resume", entry: hit };
+  }
+  const solo = inMission.find((e) => e.member === null);
+  if (solo && inMission.length === 1)
+    return { kind: "resume", entry: solo };
+  return { kind: "members", mission, entries: inMission };
+}
+function pad(s, n) {
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+function formatTable(entries) {
+  const rows = entries.map((e) => [
+    e.mission,
+    e.member ?? "—",
+    String(e.flow),
+    `${e.tasks_done}/${e.tasks_total}`,
+    e.lane,
+    e.mode
+  ]);
+  const head = ["MISSION", "MEMBER", "FLOW", "TASKS", "LANE", "MODE"];
+  const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+  const line = (cells) => "  " + cells.map((c, i) => pad(c, widths[i])).join("  ").trimEnd();
+  return [line(head), ...rows.map(line)].join(`
+`);
+}
+function formatResume(e) {
+  const scope = e.member ? ` [${e.member}]` : "";
+  const next = e.next_session_prompt || "(no next_session_prompt recorded)";
+  return `Resumed: ${e.mission}${scope}, Flow ${e.flow}, ${e.tasks_done}/${e.tasks_total} tasks — next_action: ${e.next_action} — run: ${next}`;
+}
+
 // src/cli.ts
 var str = (v) => typeof v === "string" ? v : undefined;
 var flag = (v) => v === true;
@@ -936,12 +1502,26 @@ async function run(argv) {
       return resetCmd(flags);
     case "archive":
       return archive(flags, _);
+    case "onboard":
+      return onboardCmd(flags);
+    case "continue":
+      return continueCmd(flags, _);
+    case "status":
+      return statusCmd(flags);
+    case "run":
+      return runCmd(flags, _);
+    case "savepoint":
+      return runCmd(flags, ["run", "savepoint.sh", ..._.slice(1)]);
+    case "initiative":
+      return initiativeCmd(flags, _);
+    case "start":
+      return startCmd(flags, _);
     default:
       throw new Error(`Unknown command: ${command}`);
   }
 }
 function resetCmd(flags) {
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolve2(str(flags.project) ?? process.cwd());
   const force = flag(flags.force);
   const result = resetMission(projectDir, flag(flags.keepLogs), force);
   if (result.blocked) {
@@ -956,7 +1536,7 @@ function resetCmd(flags) {
     console.log(`kept: ${result.kept.join(", ")}`);
 }
 function archive(flags, positionals) {
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolve2(str(flags.project) ?? process.cwd());
   const mission = positionals[1];
   if (!mission) {
     console.error("usage: mugiwara archive <mission> [--project <dir>] [--dry-run]");
@@ -972,6 +1552,12 @@ function archive(flags, positionals) {
   if (result.index)
     console.log(`index updated: ${result.index}`);
 }
+async function onboardCmd(flags) {
+  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  if (!existsSync10(projectDir))
+    throw new Error(`Project dir not found: ${projectDir}`);
+  await runOnboard(projectDir);
+}
 async function resolveOptions(flags) {
   const interactive = !flag(flags.yes);
   if (interactive && !process.stdin.isTTY) {
@@ -986,8 +1572,8 @@ async function resolveOptions(flags) {
       } else
         scope = await choose(rl, "Install scope?", ["global (user-wide)", "project (this repo)"]) === 0 ? "global" : "project";
     }
-    const projectDir = resolve(str(flags.project) ?? process.cwd());
-    if (scope === "project" && !existsSync7(projectDir))
+    const projectDir = resolve2(str(flags.project) ?? process.cwd());
+    if (scope === "project" && !existsSync10(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"))
@@ -1054,17 +1640,34 @@ Dry run — nothing written.`);
 OK mugiwara ${VERSION} installed (manifest: ${file})`);
   if (allNotes.length)
     console.log(`${allNotes.length} note(s) above may need attention.`);
+  if (scope === "project") {
+    const cfg = join11(projectDir, ".mugiwara", "config");
+    let mode = "guided", enforce = "block";
+    if (existsSync10(cfg)) {
+      for (const line of readFileSync8(cfg, "utf8").split(/\r?\n/)) {
+        const [k, v] = line.split("=").map((s) => s.trim());
+        if (k === "mode")
+          mode = v;
+        if (k === "enforce")
+          enforce = v;
+      }
+    }
+    console.log(`
+Next: run \`mugiwara onboard\` to customise (mode=${mode}, enforce=${enforce} now).`);
+  } else {
+    console.log("\nNext: run `mugiwara onboard` in a project to write its .mugiwara/config.");
+  }
 }
 async function uninstall(flags) {
   const scope = flag(flags.global) ? "global" : "project";
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolve2(str(flags.project) ?? process.cwd());
   const home = homedir2();
   const file = manifestPath({ scope, projectDir, home });
   const manifest = readManifest(file);
   if (!manifest) {
     if (scope === "project") {
       const globalFile = manifestPath({ scope: "global", projectDir, home });
-      if (existsSync7(globalFile)) {
+      if (existsSync10(globalFile)) {
         console.log(`No project manifest found, but a global install exists. Try:
   mugiwara uninstall --global`);
         return;
@@ -1084,6 +1687,16 @@ async function uninstall(flags) {
     }
   }
   const removed = removeInstalled(manifest, { dryRun: flag(flags.dryRun) });
+  for (const id of manifest.targets) {
+    const t = targets[id];
+    if (!t?.postUninstall)
+      continue;
+    const post = t.postUninstall({ scope, projectDir, home, dryRun: flag(flags.dryRun) });
+    for (const f of post.changed)
+      console.log(`   unwired mugiwara hooks from ${f}`);
+    for (const n of post.notes)
+      console.log(`   note: ${n}`);
+  }
   if (!flag(flags.dryRun)) {
     if (scope === "project") {
       const gi = removeProjectGitignore(projectDir);
@@ -1091,13 +1704,13 @@ async function uninstall(flags) {
         console.log(`   note: ${n}`);
     }
     rmSync3(file);
-    const mugiDir = join8(scope === "global" ? home : projectDir, ".mugiwara");
-    if (existsSync7(mugiDir) && readdirSync5(mugiDir).length === 0) {
+    const mugiDir = join11(scope === "global" ? home : projectDir, ".mugiwara");
+    if (existsSync10(mugiDir) && readdirSync7(mugiDir).length === 0) {
       rmSync3(mugiDir, { recursive: true, force: true });
     }
     if (manifest.targets.includes("opencode")) {
-      const opencodeCache = join8(home, ".cache", "opencode", "packages", "@ionivetech");
-      if (existsSync7(opencodeCache)) {
+      const opencodeCache = join11(home, ".cache", "opencode", "packages", "@ionivetech");
+      if (existsSync10(opencodeCache)) {
         rmSync3(opencodeCache, { recursive: true, force: true });
         console.log("   cleared opencode npm cache (stale plugin versions)");
       }
@@ -1107,7 +1720,7 @@ async function uninstall(flags) {
 }
 function list(flags) {
   const home = homedir2();
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolve2(str(flags.project) ?? process.cwd());
   let found = false;
   for (const [label, file] of [
     ["project", manifestPath({ scope: "project", projectDir, home })],
@@ -1118,7 +1731,7 @@ function list(flags) {
       continue;
     found = true;
     if (flag(flags.check)) {
-      const missing = m.files.filter((f) => !existsSync7(f));
+      const missing = m.files.filter((f) => !existsSync10(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}`);
@@ -1127,6 +1740,155 @@ function list(flags) {
   if (!found)
     console.log("No mugiwara installation found.");
 }
+function continueCmd(flags, positionals) {
+  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const [mission, member] = positionals.slice(1);
+  let entries = readContinue(projectDir);
+  if (!flag(flags.all)) {
+    const actor = gitActor(projectDir);
+    const mine = entries.filter((e) => e.actor === actor);
+    if (mine.length)
+      entries = mine;
+  }
+  const r = resolveContinue(entries, mission, member);
+  if (r.kind === "resume") {
+    console.log(formatResume(r.entry));
+    return;
+  }
+  if (r.kind === "none") {
+    console.log("No mission in flight. Start one with Flow 0 triage (mugiwara-orchestration).");
+  } else if (r.kind === "missions") {
+    console.log(`${new Set(r.entries.map((e) => e.mission)).size} missions in flight:
+`);
+    console.log(formatTable(r.entries));
+    console.log(`
+Pick one: mugiwara continue <mission> [member]`);
+  } else if (r.kind === "members") {
+    console.log(`Mission "${r.mission}" has ${r.entries.length} members in flight:
+`);
+    console.log(formatTable(r.entries));
+    console.log(`
+Pick one: mugiwara continue ${r.mission} <member>`);
+  } else if (r.kind === "unknown-mission") {
+    console.error(`No in-flight mission "${r.mission}". Known: ${r.known.join(", ") || "(none)"}`);
+  } else {
+    console.error(`Mission "${r.mission}" has no member "${r.member}". Known: ${r.known.join(", ")}`);
+  }
+  process.exit(2);
+}
+function statusCmd(flags) {
+  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const states = readState(projectDir);
+  if (!states.length) {
+    console.log("No mission state on disk.");
+    return;
+  }
+  const actor = flag(flags.all) ? null : gitActor(projectDir);
+  const rows = actor ? states.filter((s) => s.actor === actor).length ? states.filter((s) => s.actor === actor) : states : states;
+  for (const s of rows) {
+    const scope = s.member ? ` [${s.member}]` : "";
+    console.log(`${s.mission}${scope}`);
+    console.log(`  flow ${s.flow} · ${s.tasks_done}/${s.tasks_total} tasks · lane ${s.lane}${s.lane_rose ? " ⬆ ROSE" : ""}${s.lane_reason ? ` (${s.lane_reason})` : ""} · mode ${s.mode}`);
+    console.log(`  blockers ${s.blockers_open} · heal cycle ${s.heal_cycle}/${s.heal_max_cycles}${s.heal_halt ? " — HALT" : ""} · files touched ${s.files_touched}`);
+    if (s.budget)
+      console.log(`  tokens ${s.tokens_est}/${s.budget} (${s.budget_status})${s.delegate_due ? " · delegate due" : ""}`);
+    console.log(`  branch ${s.branch} · updated ${s.updated_at}`);
+    if (s.evidence.length)
+      console.log(`  evidence: ${s.evidence.join(", ")}`);
+  }
+}
+function runCmd(flags, positionals) {
+  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const name = positionals[1];
+  if (!name) {
+    console.error(`usage: mugiwara run <script> [args...]
+  scripts: ${RUNNABLE.join(", ")}`);
+    process.exit(1);
+  }
+  const code = runScript(name, positionals.slice(2), projectDir);
+  if (code !== 0)
+    process.exit(code);
+}
+function initiativeCmd(flags, positionals) {
+  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const sub = positionals[1];
+  if (!sub) {
+    console.error("usage: mugiwara initiative <status|conflict-check|set-status> <plan-file> [--id <id> --status <s>]");
+    process.exit(1);
+  }
+  const script = join11(import.meta.dirname, "..", "scripts", "initiative.ts");
+  const bun = process.platform === "win32" ? "bun.exe" : "bun";
+  const r = spawnSync2(bun, [script, ...positionals.slice(1)], {
+    cwd: projectDir,
+    stdio: "inherit",
+    env: process.env
+  });
+  if (r.error)
+    throw r.error;
+  if (r.status)
+    process.exit(r.status);
+}
+function startCmd(flags, positionals) {
+  const projectDir = resolve2(str(flags.project) ?? process.cwd());
+  const mission = positionals[1];
+  if (!mission) {
+    console.error("usage: mugiwara start <mission> [member]");
+    process.exit(1);
+  }
+  const plansDir = join11(projectDir, ".mugiwara", "plans");
+  let planFile = "";
+  if (existsSync10(plansDir)) {
+    const bare = join11(plansDir, `${mission}.md`);
+    if (existsSync10(bare))
+      planFile = bare;
+    else {
+      const dated = readdirSync7(plansDir).filter((f) => f.endsWith(`-${mission}.md`)).sort().pop();
+      if (dated)
+        planFile = join11(plansDir, dated);
+    }
+  }
+  if (!planFile) {
+    console.error(`mugiwara start: no plan found for "${mission}" in ${plansDir}`);
+    process.exit(1);
+  }
+  const plan = readFileSync8(planFile, "utf8");
+  const subMatch = plan.match(/##\s*Sub-missions/i);
+  let member = positionals[2] ?? "";
+  if (subMatch && !member) {
+    const actor = gitActor(projectDir);
+    const name = actor.split("<")[0].trim();
+    const rowRe = /^\|\s*([\w.-]+)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|/gm;
+    let m;
+    let found = "";
+    while (m = rowRe.exec(plan)) {
+      const assignee = m[3].trim();
+      if (assignee === name || assignee === actor) {
+        found = m[1].trim();
+        break;
+      }
+    }
+    if (!found) {
+      console.error(`mugiwara start: no sub-mission assigned to "${name}" in ${planFile}. Pass a member explicitly: mugiwara start ${mission} <member>`);
+      process.exit(1);
+    }
+    member = found;
+  }
+  const code = runScript("savepoint.sh", [mission, member, "0", "auto", "full"], projectDir);
+  if (code !== 0)
+    process.exit(code);
+  if (subMatch && member) {
+    const init = join11(import.meta.dirname, "..", "scripts", "initiative.ts");
+    const bun = process.platform === "win32" ? "bun.exe" : "bun";
+    const r = spawnSync2(bun, [init, "set-status", planFile, "--id", member, "--status", "in-progress"], {
+      cwd: projectDir,
+      stdio: "inherit",
+      env: process.env
+    });
+    if (r.status)
+      process.exit(r.status);
+  }
+  console.log(`mugiwara start: ${mission}${member ? ` [${member}]` : ""} begun at Flow 0. Resume anytime with: mugiwara continue ${mission}${member ? ` ${member}` : ""}`);
+}
 function help() {
   console.log(`mugiwara ${VERSION} — the Straw Hat crew for AI agents
 
@@ -1138,6 +1900,19 @@ Usage:
   mugiwara list --check  health check: show installations + missing files
   mugiwara reset         wipe mission state (spec/plans/results/review/issues[/logs])
   mugiwara archive <m>    fold a closed mission's evidence into its report, then remove loose files
+  mugiwara onboard       run the zero-LLM onboarding wizard (writes .mugiwara/config)
+  mugiwara continue      list in-flight missions (exit 2 = pick one, nothing resumed)
+  mugiwara continue <m> [member]
+                         print the exact resume point for that mission/member
+  mugiwara status        computed mission state: wave, tasks, lane, blockers, budget
+  mugiwara run <script> [args...]
+                         run a bundled harness script here (${RUNNABLE.join(", ")})
+  mugiwara savepoint <mission> [member] [wave] [mode]
+                         shorthand for: mugiwara run savepoint.sh ...
+  mugiwara initiative <status|conflict-check|set-status> <plan> [args]
+                         team sub-mission coordination (status / conflict-check / set-status)
+  mugiwara start <mission> [member]
+                         begin a mission from its plan (solo, or team sub-mission by git actor)
   mugiwara --help        this help
   mugiwara --version     print version
 
@@ -1149,9 +1924,10 @@ Flags:
   --force                overwrite differing files (with backup)
   --dry-run              print actions without writing
   --check                with list: report missing files (health check)
+  --all                  with continue/status: every actor, not just yours
   --keep-logs            with reset: keep .mugiwara/logs (lessons ledger survives)`);
 }
-var isMain = process.argv[1] !== undefined && fileURLToPath4(import.meta.url) === resolve(process.argv[1]);
+var isMain = process.argv[1] !== undefined && fileURLToPath5(import.meta.url) === resolve2(process.argv[1]);
 if (isMain) {
   run(process.argv.slice(2)).catch((err) => {
     console.error(`mugiwara: ${err.message}`);