@ionivetech/mugiwara 0.6.6 → 0.8.0

package/src/cli.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // src/cli.ts
-import { existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -11,9 +11,15 @@ import { targets, TARGET_IDS } from './targets/index.ts';
 import { installTo, removeInstalled, VERSION, ensureProjectGitignore, removeProjectGitignore } from './installer.ts';
 import { manifestPath, readManifest, writeManifest, type Scope } from './manifest.ts';
 import { resetMission, archiveMission } from './mission.ts';
-import { runOnboard } from './onboard.ts';
 import { runScript, RUNNABLE } from './run.ts';
 import { readContinue, readState, resolveContinue, formatTable, formatResume, gitActor } from './continue.ts';
+import { blamePath } from './provenance.ts';
+import { signReport, verifyReport, ensurePureKey, hasMinisign } from './sign.ts';
+import { ensureConfig } from './config.ts';
+import { costEnvelope } from './cost.ts';
+import { computeLiveSlop } from './slop.ts';
+import { loadRegistry } from './evidence.ts';
+import { buildCostLedger, toCostJSON } from './reporting.ts';
 
 const str = (v: FlagValue): string | undefined => (typeof v === 'string' ? v : undefined);
 const flag = (v: FlagValue): boolean => v === true;
@@ -22,6 +28,23 @@ export async function run(argv: string[]): Promise<void> {
   const { command, flags, _ } = parseArgs(argv);
   if (flag(flags.help) || command === 'help') return help();
   if (flag(flags.version)) { console.log(`mugiwara ${VERSION}`); return; }
+  // `continue` and `status` are read-only position commands: dispatch before
+  // config bootstrap so a fresh project never gets a .mugiwara/config created
+  // and no setup chatter is printed before missions/members are listed.
+  if (command === 'continue' || command === 'status') {
+    return command === 'continue' ? continueCmd(flags, _) : statusCmd(flags);
+  }
+  // A command on a fresh project must be immediately usable — bootstrap the
+  // default .mugiwara/config when it is missing (not only at install time).
+  // Skipped for install/update --dry-run: a dry run must not mutate the
+  // project (the installer writes the config itself on a real install).
+  const isDryRunInstall = (command === 'install' || command === 'update') && flag(flags.dryRun);
+  if (!isDryRunInstall) {
+    const projectDir = resolve(str(flags.project) ?? process.cwd());
+    if (ensureConfig(projectDir)) {
+      console.log(`default .mugiwara/config written at ${join(projectDir, '.mugiwara', 'config')} (edit it to customise)`);
+    }
+  }
   switch (command) {
     case 'install': return install(flags);
     case 'update': return install({ ...flags, force: true });
@@ -29,13 +52,15 @@ export async function run(argv: string[]): Promise<void> {
     case 'list': return list(flags);
     case 'reset': return resetCmd(flags);
     case 'archive': return archive(flags, _);
-    case 'onboard': return onboardCmd(flags);
+    case 'clean': return cleanCmd(flags);
     case 'continue': return continueCmd(flags, _);
     case 'status': return statusCmd(flags);
+    case 'cost': return costCmd(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, _);
+    case 'blame': return blameCmd(flags, _);
+    case 'handoff': return handoffCmd(flags, _);
+    case 'sign': return signCmd(flags, _);
     default: throw new Error(`Unknown command: ${command}`);
   }
 }
@@ -59,17 +84,74 @@ function archive(flags: Args['flags'], positionals: string[]): void {
   if (!mission) { console.error('usage: mugiwara archive <mission> [--project <dir>] [--dry-run]'); process.exit(1); }
   const result = archiveMission(projectDir, mission, { dryRun: flag(flags.dryRun) });
   if (result.report) console.log(`archive target: ${result.report}`);
+  else console.error(`no mission dir for "${mission}" under .mugiwara/missions/`);
   if (result.removed.length) console.log(`${flag(flags.dryRun) ? 'would remove' : 'removed'}: ${result.removed.join(', ')}`);
   if (result.kept.length) console.log(`kept: ${result.kept.join(', ')}`);
   if (result.index) console.log(`index updated: ${result.index}`);
 }
 
-async function onboardCmd(flags: Args['flags']): Promise<void> {
+/**
+ * `mugiwara clean` — batch-archive every closed mission. A mission is closed
+ * when its dir holds a report.md and no live state.json/<member>.json. With
+ * --all, missions with live state are included too (--force overrides the
+ * safety stop). --before <date> restricts to missions whose state was last
+ * touched before that date.
+ */
+function cleanCmd(flags: Args['flags']): void {
   const projectDir = resolve(str(flags.project) ?? process.cwd());
-  if (!existsSync(projectDir)) throw new Error(`Project dir not found: ${projectDir}`);
-  await runOnboard(projectDir);
+  const dryRun = flag(flags.dryRun);
+  const root = join(projectDir, '.mugiwara', 'missions');
+  if (!existsSync(root)) { console.log('nothing to clean (.mugiwara/missions/ does not exist).'); return; }
+  const before = str(flags.before);
+  const beforeMs = before ? Date.parse(before) : NaN;
+  if (before && !Number.isFinite(beforeMs)) { console.error(`invalid --before date: ${before}`); process.exit(1); }
+
+  let candidates = readdirSync(root, { withFileTypes: true })
+    .filter((e) => e.isDirectory() && /^[A-Za-z0-9._-]+$/.test(e.name) && !/^\.+$/.test(e.name))
+    .map((e) => e.name);
+  // default: CLOSED missions only — a report.md present and no live session
+  // state. --all widens to every mission dir, including in-flight ones.
+  // --before additionally treats an in-flight mission as closable when its
+  // newest state was last touched before the date: untouched work is safe to
+  // fold even without a report.md yet.
+  const stateFiles = (m: string): string[] =>
+    readdirSync(join(root, m)).filter((f) => {
+      const stem = f.replace(/\.json$/, '');
+      return f.endsWith('.json') && stem !== 'continue' && !stem.startsWith('continue-');
+    });
+  const hasLiveState = (m: string): boolean => stateFiles(m).length > 0;
+  const staleBefore = (m: string): boolean => {
+    if (!Number.isFinite(beforeMs)) return false;
+    for (const f of stateFiles(m)) {
+      try {
+        const ts = Date.parse(JSON.parse(readFileSync(join(root, m, f), 'utf8')).updated_at ?? '') || 0;
+        if (ts === 0 || ts >= beforeMs) return false; // unknown freshness → never assume stale
+      } catch { return false; }
+    }
+    return true;
+  };
+  if (!flag(flags.all)) {
+    candidates = candidates.filter((m) =>
+      (existsSync(join(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) {
+      console.error(`✗ in-flight mission(s): ${live.join(', ')}. Use --force to archive them anyway.`);
+      process.exit(1);
+    }
+  }
+  if (!candidates.length) { console.log('nothing to clean.'); return; }
+  for (const m of candidates) {
+    const r = archiveMission(projectDir, m, { dryRun });
+    console.log(`${dryRun ? 'would clean' : 'cleaned'} ${m}${r.report ? ` → ${r.report}` : ''}`);
+    if (r.index) console.log(`index updated: ${r.index}`);
+  }
 }
 
+
+
 async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; projectDir: string; targetIds: string[] }> {
   const interactive = !flag(flags.yes);
   if (interactive && !process.stdin.isTTY) {
@@ -140,22 +222,8 @@ async function install(flags: Args['flags']): Promise<void> {
   });
   console.log(`\nOK mugiwara ${VERSION} installed (manifest: ${file})`);
   if (allNotes.length) console.log(`${allNotes.length} note(s) above may need attention.`);
-  // TASK 8: name exactly one next step, and state the active mode + enforce
-  // value since both change behaviour.
-  if (scope === 'project') {
-    const cfg = join(projectDir, '.mugiwara', 'config');
-    let mode = 'guided', enforce = 'block';
-    if (existsSync(cfg)) {
-      for (const line of readFileSync(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(`\nNext: 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.');
-  }
+  // A fresh install writes a default .mugiwara/config — point at it directly.
+  console.log('\nNext: edit .mugiwara/config to customise (mode, branch, coverage, depths).');
 }
 
 async function uninstall(flags: Args['flags']): Promise<void> {
@@ -261,7 +329,13 @@ function continueCmd(flags: Args['flags'], positionals: string[]): void {
   }
 
   const r = resolveContinue(entries, mission, member);
-  if (r.kind === 'resume') { console.log(formatResume(r.entry)); return; }
+  if (r.kind === 'resume') {
+    console.log(formatResume(r.entry));
+    const st = readState(projectDir).find((s) => s.mission === r.entry.mission && s.member === r.entry.member);
+    const stale = st ? stalenessLine(projectDir, st.base_sha) : null;
+    if (stale) console.log(stale);
+    return;
+  }
 
   if (r.kind === 'none') {
     console.log('No mission in flight. Start one with Flow 0 triage (mugiwara-orchestration).');
@@ -299,6 +373,61 @@ function statusCmd(flags: Args['flags']): void {
   }
 }
 
+/** `mugiwara cost [--mission <id>] [--json] [--ledger]` — show cost ledger, avoided work, efficiency, trail. */
+function costCmd(flags: Args['flags'], positionals: string[]): void {
+  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const mission = str(flags.mission) ?? positionals[1] ?? (() => {
+    const states = readState(projectDir);
+    if (states.length === 1) return states[0].mission;
+    if (states.length > 1) {
+      console.error('multiple missions in flight — specify --mission <id>');
+      process.exit(1);
+    }
+    return null;
+  })();
+  if (!mission) {
+    console.error('usage: mugiwara cost [--mission <id>] [--json] [--ledger] [--project <dir>]');
+    process.exit(1);
+  }
+  const missionDir = join(projectDir, '.mugiwara', 'missions', mission);
+  if (!existsSync(missionDir)) {
+    console.error(`No cost ledger found for mission "${mission}"`);
+    process.exit(1);
+  }
+  const states = readState(projectDir).filter((s) => s.mission === mission);
+  const envelope = states.length
+    ? costEnvelope({ lane: (states[0] as unknown as { lane?: string }).lane, budget: (states[0] as unknown as { budget?: number }).budget, tokens_est: (states[0] as unknown as { tokens_est?: number }).tokens_est })
+    : costEnvelope({ lane: 'full', tokens_est: 0 });
+  // live slop (§3.3): run existing detectors over state already available
+  // (heal cycle, context registry repeated reads) so slop_interventions is real.
+  const state0 = states[0] as unknown as { heal_cycle?: number };
+  let repeatedReads = 0;
+  try {
+    const reg = loadRegistry(missionDir);
+    repeatedReads = reg.reduce((s, e) => s + Math.max(e.reads - 1, 0), 0);
+  } catch {
+    repeatedReads = 0;
+  }
+  const liveSlop = computeLiveSlop({ heal_cycle: state0?.heal_cycle ?? 0, repeated_reads: repeatedReads });
+  const ledger = buildCostLedger({ missionDir, envelope, slopSummary: { interventions: liveSlop.interventions } });
+  if (flag(flags.json)) {
+    console.log(toCostJSON(ledger));
+    return;
+  }
+  console.log(`Cost envelope: ${ledger.envelope.status} ${ledger.envelope.pct}% (${ledger.envelope.used}/${ledger.envelope.planned})`);
+  console.log(`Avoided: ${ledger.avoided.stages_avoided} stages, ${ledger.avoided.contexts_avoided} contexts, ~${ledger.avoided.tokens_avoided_est} tokens`);
+  console.log(`Efficiency: reuse ${ledger.efficiency.reuse_rate}, dup ${ledger.efficiency.duplicate_avoidance_chars} chars, budget ${ledger.efficiency.budget_efficiency_pct}%`);
+  if (ledger.avoided.slop_interventions > 0) {
+    const roles = Object.entries(liveSlop.perRole).map(([r, n]) => `${r}:${n}`).join(', ');
+    console.log(`Slop: ${ledger.avoided.slop_interventions} intervention(s) — ${roles}`);
+  }
+  console.log(`Trail: ${ledger.trail.length} decisions`);
+  if (flag(flags.ledger) && ledger.trail.length) {
+    for (const t of ledger.trail.slice(0, 20)) console.log(`- ${t.ts} — ${t.actor}: ${t.decision} — reason: ${t.reason}${t.evidence ? ` — evidence: ${t.evidence}` : ''}`);
+    if (ledger.trail.length > 20) console.log(`… ${ledger.trail.length - 20} more`);
+  }
+}
+
 /** `mugiwara run <script.sh> [args]` — run a bundled harness script here. */
 function runCmd(flags: Args['flags'], positionals: string[]): void {
   const projectDir = resolve(str(flags.project) ?? process.cwd());
@@ -311,88 +440,100 @@ function runCmd(flags: Args['flags'], positionals: string[]): void {
   if (code !== 0) process.exit(code);
 }
 
-/** `mugiwara initiative <status|conflict-check|set-status> <plan> [args]` — team sub-mission coordination. */
-function initiativeCmd(flags: Args['flags'], positionals: string[]): void {
+/** `mugiwara blame <path>` — provenance note on the last commit touching path. */
+function blameCmd(flags: Args['flags'], positionals: string[]): void {
   const projectDir = resolve(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 path = positionals[1];
+  if (!path) { console.error('usage: mugiwara blame <file-path>'); process.exit(1); }
+  console.log(blamePath(projectDir, path));
+}
+
+/**
+ * Staleness: has main moved since the mission's recorded base?
+ * N commits behind = the ground this mission started from has shifted.
+ */
+export function stalenessLine(projectDir: string, baseSha: string): string | null {
+  if (!baseSha || baseSha === 'unknown') return null;
+  const git = (args: string[]): string => {
+    try {
+      return execFileSync('git', args, { cwd: projectDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    } catch { return ''; }
+  };
+  let main = '';
+  for (const ref of ['main', 'master']) {
+    main = git(['rev-parse', '--verify', ref]);
+    if (main) break;
   }
-  const script = join(import.meta.dirname, '..', 'scripts', 'initiative.ts');
-  // initiative.ts is TypeScript — spawn `bun` (which strips types), not node,
-  // which only strips types on >=22.18. engines floor is >=20.11.
-  const bun = process.platform === 'win32' ? 'bun.exe' : 'bun';
-  const r = spawnSync(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);
+  if (!main) return null;
+  try {
+    const behind = Number(git(['rev-list', '--count', `${baseSha}..${main}`])) || 0;
+    return behind > 0
+      ? `⚠ stale base: main is ${behind} commit(s) ahead of this mission's base ${baseSha.slice(0, 7)} — rebase check before continuing`
+      : null;
+  } catch { return null; }
 }
 
-/** `mugiwara start <mission> [member]` — begin a mission from its plan. */
-function startCmd(flags: Args['flags'], positionals: string[]): void {
+/** `mugiwara handoff <mission>` — a report the next engineer can act on. */
+function handoffCmd(flags: Args['flags'], positionals: string[]): void {
   const projectDir = resolve(str(flags.project) ?? process.cwd());
   const mission = positionals[1];
-  if (!mission) {
-    console.error('usage: mugiwara start <mission> [member]');
-    process.exit(1);
-  }
-  // find the plan doc: plans/<mission>.md or plans/YYYY-MM-DD-<mission>.md
-  const plansDir = join(projectDir, '.mugiwara', 'plans');
-  let planFile = '';
-  if (existsSync(plansDir)) {
-    const bare = join(plansDir, `${mission}.md`);
-    if (existsSync(bare)) planFile = bare;
-    else {
-      const dated = readdirSync(plansDir).filter((f) => f.endsWith(`-${mission}.md`)).sort().pop();
-      if (dated) planFile = join(plansDir, dated);
-    }
-  }
-  if (!planFile) {
-    console.error(`mugiwara start: no plan found for "${mission}" in ${plansDir}`);
-    process.exit(1);
+  if (!mission) { console.error('usage: mugiwara handoff <mission> [--project <dir>]'); process.exit(1); }
+  const states = readState(projectDir).filter((s) => s.mission === mission);
+  if (!states.length) { console.error(`no in-flight mission "${mission}"`); process.exit(1); }
+  const lines = [
+    `# Handoff: ${mission}`,
+    '',
+    `Generated ${new Date().toISOString()} by \`mugiwara handoff\`.`,
+    '',
+    '| | |',
+    '|---|---|',
+  ];
+  for (const s of states) {
+    const scope = s.member ? ` [${s.member}]` : '';
+    lines.push(`| Mission${scope} | flow ${s.flow}, tasks ${s.tasks_done}/${s.tasks_total}, lane ${s.lane}${s.lane_rose ? ' (rose)' : ''}, mode ${s.mode} |`);
+    lines.push(`| Branch | \`${s.branch}\` |`);
+    lines.push(`| Actor | ${s.actor || '(unknown)'} |`);
+    if (s.next_action) lines.push(`| Next action | ${s.next_action} |`);
+    if (s.blockers_open) lines.push(`| Open blockers | ${s.blockers_open} |`);
+    if (s.heal_cycle) lines.push(`| Heal cycles | ${s.heal_cycle}/${s.heal_max_cycles}${s.heal_halt ? ' — HALTED' : ''} |`);
+    if (s.evidence.length) lines.push(`| Evidence | ${s.evidence.join(', ')} |`);
+    const stale = stalenessLine(projectDir, s.base_sha);
+    if (stale) lines.push(`| Staleness | ${stale.replace('⚠ stale base: ', '')} |`);
   }
-  const plan = readFileSync(planFile, 'utf8');
+  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 = join('.mugiwara', 'missions', mission, 'handoff.md');
+  writeFileSync(resolve(projectDir, out), lines.join('\n') + '\n');
+  console.log(lines.join('\n'));
+  console.log(`\nwritten: ${out}`);
+}
 
-  // team plan = has a ## Sub-missions table; solo = none.
-  const subMatch = plan.match(/##\s*Sub-missions/i);
-  let member = positionals[2] ?? '';
-  if (subMatch && !member) {
-    // team: find the row whose Assignee matches this git actor
-    const actor = gitActor(projectDir);
-    const name = actor.split('<')[0].trim();
-    const rowRe = /^\|\s*([\w.-]+)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|/gm;
-    let m: RegExpExecArray | null;
-    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);
+/** `mugiwara sign <mission>` / `--verify` / `--gen-key` — optional attestation. */
+function signCmd(flags: Args['flags'], _: string[]): void {
+  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  if (flag(flags.genKey)) {
+    const backend = str(flags.backend) ?? 'auto';
+    const home = homedir();
+    if (backend === 'minisign') {
+      if (!hasMinisign()) { console.error('✗ minisign not installed — cannot generate keys with this backend'); process.exit(1); }
+      try {
+        execFileSync('minisign', ['-G'], { stdio: 'inherit' });
+        console.log('✓ minisign key pair generated in ~/.mugiwara/');
+        return;
+      } catch { console.error('✗ key generation failed'); process.exit(1); }
     }
-    member = found;
-  }
-
-  // write the savepoint: mission [member] flow=0 mode=auto lane=full (start)
-  const code = runScript('savepoint.sh', [mission, member, '0', 'auto', 'full'], projectDir);
-  if (code !== 0) process.exit(code);
-
-  // team plan: mark the sub-mission in-progress in the plan (source of truth)
-  if (subMatch && member) {
-    const init = join(import.meta.dirname, '..', 'scripts', 'initiative.ts');
-    const bun = process.platform === 'win32' ? 'bun.exe' : 'bun';
-    const r = spawnSync(bun, [init, 'set-status', planFile, '--id', member, '--status', 'in-progress'], {
-      cwd: projectDir, stdio: 'inherit', env: process.env,
-    });
-    if (r.status) process.exit(r.status);
+    // pure (default)
+    const dir = ensurePureKey(home);
+    console.log(`✓ pure ed25519 key pair ready: ${join(dir, 'mugiwara.key')} / ${join(dir, 'mugiwara.pub')}`);
+    return;
   }
-
-  console.log(`mugiwara start: ${mission}${member ? ` [${member}]` : ''} begun at Flow 0. Resume anytime with: mugiwara continue ${mission}${member ? ` ${member}` : ''}`);
+  const mission = _[1];
+  if (!mission) { console.error('usage: mugiwara sign <mission> [--verify] [--gen-key [--backend pure|minisign]] [--project <dir>]'); process.exit(1); }
+  const missionDir = join(projectDir, '.mugiwara', 'missions', mission);
+  if (!existsSync(missionDir)) { console.error(`no mission dir: ${missionDir}`); process.exit(1); }
+  const r = flag(flags.verify) ? verifyReport(projectDir, missionDir) : signReport(projectDir, missionDir);
+  console.log(`${r.ok ? '✓' : '✗'} ${r.message}`);
+  if (!r.ok) process.exit(1);
 }
 
 function help(): void {
@@ -404,21 +545,27 @@ Usage:
   mugiwara uninstall     remove installed files via manifest
   mugiwara list          show installations
   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 reset         wipe mission state (missions/ + legacy dirs)
+  mugiwara archive <m>   fold a closed mission's waves into its report, then remove loose files
+  mugiwara clean [--all] [--before <date>]
+                         batch-archive every closed mission (report.md present, no live state)
   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 cost [--mission <id>] [--json] [--ledger]
+                         show cost ledger, avoided work, efficiency, trail (human + JSON)
+  mugiwara blame <path>  provenance note on the last commit touching <path>
+                         (fetch notes first: git fetch origin 'refs/notes/mugiwara:refs/notes/mugiwara')
+  mugiwara handoff <m>   write .mugiwara/missions/<m>/handoff.md — a report the next
+                         engineer can act on (computed state + staleness check)
+  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 run <script> [args...]
                          run a bundled harness script here (${RUNNABLE.join(', ')})
-  mugiwara savepoint <mission> [member] [wave] [mode]
+  mugiwara savepoint <mission> [member] [flow] [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
 
@@ -430,8 +577,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)`);
+   --all                  with continue/status: every actor; with clean: include in-flight missions
+   --force                with clean --all: archive in-flight missions anyway
+   --before <date>        with clean: also archive missions untouched since this date
+   --keep-logs            with reset: keep lessons.md (lessons ledger survives)`);
 }
 
 const isMain = process.argv[1] !== undefined && fileURLToPath(import.meta.url) === resolve(process.argv[1]);