@ionivetech/mugiwara 0.6.6 → 0.7.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,10 @@ 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 } from './sign.ts';
 
 const str = (v: FlagValue): string | undefined => (typeof v === 'string' ? v : undefined);
 const flag = (v: FlagValue): boolean => v === true;
@@ -29,13 +30,14 @@ 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 '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 +61,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 +199,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 +306,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).');
@@ -311,88 +362,84 @@ 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);
-  }
-  const plan = readFileSync(planFile, 'utf8');
-
-  // 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);
-    }
-    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);
+  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: ', '')} |`);
   }
+  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}`);
+}
 
-  console.log(`mugiwara start: ${mission}${member ? ` [${member}]` : ''} begun at Flow 0. Resume anytime with: mugiwara continue ${mission}${member ? ` ${member}` : ''}`);
+/** `mugiwara sign <mission>` / `--verify` — optional minisign attestation. */
+function signCmd(flags: Args['flags'], _: string[]): void {
+  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const mission = _[1];
+  if (!mission) { console.error('usage: mugiwara sign <mission> [--verify] [--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 +451,23 @@ 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 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>      optional attestation: minisign-sign report.md (--verify to check)
   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 +479,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]);

package/src/continue.ts

@@ -6,9 +6,10 @@
 // in one process spawn.
 //
 // Reads what scripts/savepoint.sh writes:
-//   .mugiwara/continue/<mission>/state.json    (solo)
-//   .mugiwara/continue/<mission>/<member>.json (team)
-//   .mugiwara/state/<mission>/...              (same shape, more fields)
+//   .mugiwara/missions/<mission>/state.json              (solo state)
+//   .mugiwara/missions/<mission>/<member>.json           (team state)
+//   .mugiwara/missions/<mission>/continue.json           (solo resume point)
+//   .mugiwara/missions/<mission>/continue-<member>.json  (team resume point)
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join } from 'node:path';
@@ -37,6 +38,8 @@ export type StateEntry = ContinueEntry & {
   lane_rose: boolean;
   lane_prev: string;
   lane_peak: string;
+  base_sha: string;
+  sensitive_paths: string[];
   blockers_open: number;
   heal_cycle: number;
   heal_max_cycles: number;
@@ -81,9 +84,14 @@ export function gitActor(cwd: string): string {
   return name || process.env.USER || process.env.USERNAME || '';
 }
 
-/** Read every JSON under `.mugiwara/<root>/<mission>/*.json`. Corrupt files are skipped. */
-function scan<T>(projectDir: string, root: string, map: (raw: Record<string, unknown>, member: string | null) => T): T[] {
-  const base = join(projectDir, '.mugiwara', root);
+/**
+ * Read every mission dir under `.mugiwara/missions/<mission>/`, picking the
+ * files this reader owns: state readers take `state.json` / `<member>.json`,
+ * continue readers take `continue.json` / `continue-<member>.json`. Corrupt
+ * files are skipped.
+ */
+function scan<T>(projectDir: string, kind: 'state' | 'continue', map: (raw: Record<string, unknown>, member: string | null) => T): T[] {
+  const base = join(projectDir, '.mugiwara', 'missions');
   if (!existsSync(base)) return [];
   const out: T[] = [];
   const missions = readdirSync(base, { withFileTypes: true })
@@ -93,9 +101,18 @@ function scan<T>(projectDir: string, root: string, map: (raw: Record<string, unk
   for (const mission of missions) {
     const dir = join(base, mission);
     for (const f of readdirSync(dir).filter((n) => n.endsWith('.json')).sort()) {
-      // state.json is the solo (member-less) file; <member>.json is a team member
       const stem = f.slice(0, -'.json'.length);
-      const member = stem === 'state' ? null : stem;
+      // state files: `state` (solo) or `<member>`; continue files: `continue`
+      // (solo) or `continue-<member>`. Each scan ignores the other kind.
+      let member: string | null;
+      if (kind === 'state') {
+        if (stem === 'continue' || stem.startsWith('continue-')) continue;
+        member = stem === 'state' ? null : stem;
+      } else {
+        if (stem === 'continue') member = null;
+        else if (stem.startsWith('continue-')) member = stem.slice('continue-'.length);
+        else continue;
+      }
       if (member !== null && !isSafeKey(member)) continue;
       try {
         const raw = JSON.parse(readFileSync(join(dir, f), 'utf8')) as Record<string, unknown>;
@@ -145,8 +162,10 @@ export function readState(projectDir: string): StateEntry[] {
       lane_rose: r.lane_rose === true,
       lane_prev: text(r.lane_prev),
       lane_peak: text(r.lane_peak),
-      next_action: '',
-      next_session_prompt: '',
+      base_sha: text(r.base_sha),
+      sensitive_paths: Array.isArray(r.sensitive_paths) ? r.sensitive_paths.map(text).filter(Boolean) : [],
+      next_action: text(r.next_action),
+      next_session_prompt: text(r.next_session_prompt),
       updated_at: text(r.updated_at),
       blockers_open: num(r.blockers_open),
       heal_cycle: num(r.heal_cycle),

package/src/installer.ts

@@ -161,10 +161,10 @@ export function installTo(target: Target, opts: InstallOptions): InstallResult {
     result.notes.push(...post.notes);
   }
 
-  // TASK 8: a fresh install must be immediately usable — write a default
-  // .mugiwara/config (the same defaults `mugiwara onboard` would write) so no
-  // key silently falls back. Only for project scope; global installs don't own
-  // a project config. Never overwrite an existing config.
+  // A fresh install must be immediately usable — write a default
+  // .mugiwara/config so no key silently falls back. Only for project scope;
+  // global installs don't own a project config. Never overwrite an existing
+  // config.
   if (scope === 'project') {
     const configPath = join(projectDir, '.mugiwara', 'config');
     // lstat, not existsSync: a pre-created symlinked config must not be
@@ -181,13 +181,15 @@ export function installTo(target: Target, opts: InstallOptions): InstallResult {
         'coverage_modified=80',
         'review_depth=full',
         'quality_depth=full',
+        'verify_merged=off',
         'delegate_threshold=60',
         'heal_max_cycles=3',
         'verbosity=normal',
+        '# context_budget_chars=150000  # optional: fail archive if trail exceeds this (measured in report Cost section)',
       ].join('\n') + '\n';
       if (!dryRun) { mkdirSync(dirname(configPath), { recursive: true }); writeFileSync(configPath, body); }
       result.written.push(configPath);
-      result.notes.push(`default config written: ${configPath} (run \`mugiwara onboard\` to customise)`);
+      result.notes.push(`default config written: ${configPath} (edit it to customise)`);
     }
   }
   return result;
@@ -223,13 +225,14 @@ function assertNotSymlink(file: string): void {
 
 const GITIGNORE_BLOCK_START = '# >>> mugiwara >>>';
 const GITIGNORE_BLOCK_END = '# <<< mugiwara <<<';
-// legacy marker from v0.6.2 — block was undelimited, single '# mugiwara'
-// header. Kept for detection so an old install is not double-appended.
-const GITIGNORE_MARKER = '# mugiwara';
-const GITIGNORE_BLOCK = `# >>> mugiwara >>> — audit trail is the product: commit reports/, results/, logs/, spec/, plans/.
-# Ignore session state and regenerated files.
-.mugiwara/state/
-.mugiwara/continue/
+// legacy markers — pre-0.7 blocks ignored per-type dirs (.mugiwara/state/,
+// .mugiwara/continue/) instead of the mission-first layout. Kept for
+// detection so an old install is upgraded, not double-appended.
+const GITIGNORE_LEGACY = ['.mugiwara/state/', '# mugiwara'];
+const GITIGNORE_BLOCK = `# >>> mugiwara >>> — audit trail is the product: commit plan.md, flows/, review.md,
+# decisions.md, blockers.md, report.md under .mugiwara/missions/. Ignore session state.
+.mugiwara/missions/**/*.json
+.mugiwara/index.md
 .mugiwara/config
 .mugiwara/refs/
 # <<< mugiwara <<<
@@ -242,14 +245,14 @@ export function ensureProjectGitignore(projectDir: string, opts: { dryRun?: bool
   let existing = existsSync(path) ? readFileSync(path, 'utf8') : '';
   if (existing) {
     // Delimited block present with the current entries → nothing to do.
-    if (existing.includes(GITIGNORE_BLOCK_START) && existing.includes('.mugiwara/state/')) {
+    if (existing.includes(GITIGNORE_BLOCK_START) && existing.includes('.mugiwara/missions/**/*.json')) {
       return { appended: false, notes: [] };
     }
-    // Legacy (v0.6.2) or outdated delimited block → upgrade in place:
-    // strip the old mugiwara entries (both forms), then append the new block.
+    // Legacy (pre-0.7) or outdated delimited block → upgrade in place:
+    // strip the old mugiwara entries, then append the new block.
     // Without this, upgraded projects keep committing per-wave state/continue
     // JSON to git — session state must stay ignored (Robin MAJOR, Jinbe Low).
-    const hadOld = existing.includes(GITIGNORE_MARKER) || existing.includes(GITIGNORE_BLOCK_START);
+    const hadOld = GITIGNORE_LEGACY.some((m) => existing.includes(m)) || existing.includes(GITIGNORE_BLOCK_START);
     if (hadOld) {
       const clean = removeProjectGitignore(projectDir, { dryRun });
       existing = clean.removed ? (existsSync(path) ? readFileSync(path, 'utf8') : '') : existing;
@@ -281,20 +284,22 @@ export function removeProjectGitignore(projectDir: string, { dryRun = false }: {
     const end = current.indexOf(GITIGNORE_BLOCK_END);
     if (end < start) return { removed: false, notes: ['delimiter mismatch — .gitignore left untouched'] };
     cleaned = current.slice(0, start) + current.slice(end + GITIGNORE_BLOCK_END.length);
-  } else if (current.includes(GITIGNORE_MARKER)) {
-    // legacy (v0.6.2): strip the exact undelimited block — the header, the
-    // explanatory comment, and the five known lines. Prefix-matching would
+  } else if (current.includes('# mugiwara')) {
+    // legacy (pre-0.7): strip the exact undelimited block — the header, the
+    // explanatory comment, and the known lines. Prefix-matching would
     // delete user-owned lines that merely start with a mugiwara path.
     const LEGACY_LINES = new Set([
       '.mugiwara/state.json',
       '.mugiwara/state-*.json',
       '.mugiwara/config',
+      '.mugiwara/state/',
+      '.mugiwara/continue/',
       '.mugiwara/continue.md',
       '.mugiwara/refs/',
     ]);
     const lines = current.split('\n').filter(l => {
       const t = l.trim();
-      if (t.startsWith(GITIGNORE_MARKER)) return false; // header + comment
+      if (t.startsWith('# mugiwara')) return false; // header + comment
       return !LEGACY_LINES.has(t);
     });
     cleaned = lines.join('\n');