@ionivetech/mugiwara 0.8.1 → 0.9.0

package/src/cli.ts

@@ -12,7 +12,7 @@ import { installTo, removeInstalled, VERSION, ensureProjectGitignore, removeProj
 import { manifestPath, readManifest, writeManifest, type Scope } from './manifest.ts';
 import { resetMission, archiveMission } from './mission.ts';
 import { runScript, RUNNABLE } from './run.ts';
-import { readContinue, readState, resolveContinue, formatTable, formatResume, gitActor, hasLegacyLayout, CURRENT_SCHEMA_VERSION } from './continue.ts';
+import { readContinue, readState, resolveContinue, formatTable, formatResume, gitActor, hasLegacyLayout, CURRENT_SCHEMA_VERSION, unreadableStateFiles } from './continue.ts';
 import { blamePath } from './provenance.ts';
 import { signReport, verifyReport, ensurePureKey, hasMinisign } from './sign.ts';
 import { ensureConfig } from './config.ts';
@@ -25,6 +25,17 @@ import { enforceHarnessPolicy } from './policy.ts';
 const str = (v: FlagValue): string | undefined => (typeof v === 'string' ? v : undefined);
 const flag = (v: FlagValue): boolean => v === true;
 
+// Anchor to the repo root so running from a package subdirectory does not
+// create a shadow .mugiwara/ there. (B4)
+function resolveProjectDir(explicit?: string): string {
+  if (explicit) return resolve(explicit);
+  try {
+    const root = execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' }).trim();
+    if (root) return root;
+  } catch { /* not a git repo — fall through */ }
+  return process.cwd();
+}
+
 export async function run(argv: string[]): Promise<void> {
   const { command, flags, _ } = parseArgs(argv);
   if (flag(flags.help) || command === 'help') return help();
@@ -35,7 +46,7 @@ export async function run(argv: string[]): Promise<void> {
   {
     const bypass = new Set(['install', 'update', 'uninstall', 'list']);
     if (!bypass.has(command)) {
-      const projectDirForHarness = resolve(str(flags.project) ?? process.cwd());
+      const projectDirForHarness = resolveProjectDir(str(flags.project));
       enforceHarnessPolicy(projectDirForHarness);
     }
   }
@@ -45,7 +56,7 @@ export async function run(argv: string[]): Promise<void> {
   // Skipped for install/update --dry-run: a dry run must not mutate the project.
   const isDryRunInstall = (command === 'install' || command === 'update') && flag(flags.dryRun);
   if (!isDryRunInstall) {
-    const projectDir = resolve(str(flags.project) ?? process.cwd());
+    const projectDir = resolveProjectDir(str(flags.project));
     if (ensureConfig(projectDir)) {
       console.log(`default .mugiwara/config written at ${join(projectDir, '.mugiwara', 'config')} (edit it to customise)`);
     }
@@ -69,13 +80,14 @@ export async function run(argv: string[]): Promise<void> {
     case 'blame': return blameCmd(flags, _);
     case 'handoff': return handoffCmd(flags, _);
     case 'sign': return signCmd(flags, _);
-    case 'migrate': return migrateCmd(flags);
+    case 'migrate': return migrateCmd(flags, _);
+    case 'lesson': return lessonCmd(flags, _);
     default: throw new Error(`Unknown command: ${command}`);
   }
 }
 
 function resetCmd(flags: Args['flags']): void {
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   const force = flag(flags.force);
   const result = resetMission(projectDir, flag(flags.keepLogs), force);
   if (result.blocked) {
@@ -88,7 +100,7 @@ function resetCmd(flags: Args['flags']): void {
 }
 
 function archive(flags: Args['flags'], positionals: string[]): void {
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   const mission = positionals[1];
   if (!mission) { console.error('usage: mugiwara archive <mission> [--project <dir>] [--dry-run]'); process.exit(1); }
   const result = archiveMission(projectDir, mission, { dryRun: flag(flags.dryRun) });
@@ -107,7 +119,7 @@ function archive(flags: Args['flags'], positionals: string[]): void {
  * touched before that date.
  */
 function cleanCmd(flags: Args['flags']): void {
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   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; }
@@ -173,7 +185,7 @@ async function resolveOptions(flags: Args['flags']): Promise<{ scope: Scope; pro
       if (!interactive) { scope = 'project'; }
       else scope = (await choose(rl!, 'Install scope?', ['global (user-wide)', 'project (this repo)'])) === 0 ? 'global' : 'project';
     }
-    const projectDir = resolve(str(flags.project) ?? process.cwd());
+    const projectDir = resolveProjectDir(str(flags.project));
     if (scope === 'project' && !existsSync(projectDir)) throw new Error(`Project dir not found: ${projectDir}`);
 
     let targetIds = str(flags.target)?.split(',').map(s => s.trim()) ?? null;
@@ -231,13 +243,15 @@ 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.`);
+  console.log('CLI: run `npm i -g @ionivetech/mugiwara` so the crew can call `mugiwara savepoint/archive/continue`.');
+  console.log('     Without it the crew degrades to inline-only — no state, no resume, no closure gate.');
   // 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> {
   const scope: Scope = flag(flags.global) ? 'global' : 'project';
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   const home = homedir();
   const file = manifestPath({ scope, projectDir, home });
   const manifest = readManifest(file);
@@ -310,7 +324,7 @@ function schemaWarnings(projectDir: string): void {
 
 function list(flags: Args['flags']): void {
   const home = homedir();
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   legacyWarning(projectDir);
   let found = false;
   for (const [label, file] of [
@@ -342,12 +356,28 @@ function list(flags: Args['flags']): void {
  * the caller must stop and let the user pick.
  */
 function continueCmd(flags: Args['flags'], positionals: string[]): void {
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   legacyWarning(projectDir);
   schemaWarnings(projectDir);
   const [mission, member] = positionals.slice(1);
   let entries = readContinue(projectDir);
 
+  // If the requested member's state file is unreadable, refuse rather than
+  // resuming from continue-<member>.json alone. A resume point without its
+  // state is a guess. (B6)
+  if (mission) {
+    // readState populates unreadableStateFiles for state files; entries already captured
+    readState(projectDir);
+    const badState = unreadableStateFiles();
+    const target = member ? `${mission}/${member}.json` : `${mission}/state.json`;
+    if (badState.includes(target)) {
+      console.error(`✗ mission "${mission}"${member ? ` member "${member}"` : ''} has unreadable state: ${target}`);
+      process.exit(1);
+    }
+    // re-read continue entries after the state scan cleared unreadable (preserve original entries)
+    // entries already holds the correct continue data, no need to re-read
+  }
+
   // default to this actor's work; --all crosses actors on a shared checkout
   if (!flag(flags.all)) {
     const actor = gitActor(projectDir);
@@ -386,11 +416,19 @@ function continueCmd(flags: Args['flags'], positionals: string[]): void {
 
 /** `mugiwara status` — one screen of computed mission state, no model needed. */
 function statusCmd(flags: Args['flags']): void {
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   legacyWarning(projectDir);
   schemaWarnings(projectDir);
   const states = readState(projectDir);
-  if (!states.length) { console.log('No mission state on disk.'); return; }
+  const bad = unreadableStateFiles();
+  if (bad.length) {
+    console.error(`⚠ ${bad.length} unreadable state file(s): ${bad.join(', ')}`);
+    console.error('  These are not "no mission" — they are corrupt. Inspect or delete them.');
+  }
+  if (!states.length) {
+    console.log(bad.length ? 'No readable mission state on disk.' : '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) {
@@ -406,7 +444,7 @@ 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 projectDir = resolveProjectDir(str(flags.project));
   const mission = str(flags.mission) ?? positionals[1] ?? (() => {
     const states = readState(projectDir);
     if (states.length === 1) return states[0].mission;
@@ -461,7 +499,7 @@ function costCmd(flags: Args['flags'], positionals: string[]): void {
 
 /** `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());
+  const projectDir = resolveProjectDir(str(flags.project));
   const name = positionals[1];
   if (!name) {
     console.error(`usage: mugiwara run <script> [args...]\n  scripts: ${RUNNABLE.join(', ')}`);
@@ -473,7 +511,7 @@ function runCmd(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 projectDir = resolveProjectDir(str(flags.project));
   const path = positionals[1];
   if (!path) { console.error('usage: mugiwara blame <file-path>'); process.exit(1); }
   console.log(blamePath(projectDir, path));
@@ -506,10 +544,15 @@ export function stalenessLine(projectDir: string, baseSha: string): string | nul
 
 /** `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 projectDir = resolveProjectDir(str(flags.project));
   const mission = positionals[1];
   if (!mission) { console.error('usage: mugiwara handoff <mission> [--project <dir>]'); process.exit(1); }
   const states = readState(projectDir).filter((s) => s.mission === mission);
+  const bad = unreadableStateFiles().filter((p) => p.startsWith(`${mission}/`));
+  if (bad.length) {
+    console.error(`✗ mission "${mission}" has unreadable state: ${bad.join(', ')}`);
+    process.exit(1);
+  }
   if (!states.length) { console.error(`no in-flight mission "${mission}"`); process.exit(1); }
   const lines = [
     `# Handoff: ${mission}`,
@@ -539,9 +582,143 @@ function handoffCmd(flags: Args['flags'], positionals: string[]): void {
   console.log(`\nwritten: ${out}`);
 }
 
-export function migrateCmd(flags: Args['flags']): void {
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+function lessonCmd(flags: Args['flags'], positionals: string[]): void {
+  const projectDir = resolveProjectDir(str(flags.project));
+  const text = positionals.slice(1).join(' ').trim();
+  if (!text) { console.error('usage: mugiwara lesson "<text>" [--project <dir>]'); process.exit(1); }
+  const file = join(projectDir, '.mugiwara', 'lessons.md');
+  const date = new Date().toISOString().slice(0, 10);
+  const sanitized = text.replace(/\|/g, '/').replace(/\r?\n/g, ' ').trim();
+  const line = `| ${date} | manual | general | ${sanitized} |`;
+  const header = '| Date | Mission | Area | Lesson |\n|---|---|---|---|';
+  let existing = '';
+  try { existing = readFileSync(file, 'utf8'); } catch {}
+  if (!existing) {
+    mkdirSync(join(projectDir, '.mugiwara'), { recursive: true });
+    writeFileSync(file, header + '\n' + line + '\n');
+  } else {
+    // ensure file ends with newline
+    const needsNewline = !existing.endsWith('\n');
+    writeFileSync(file, existing + (needsNewline ? '\n' : '') + line + '\n');
+  }
+  console.log(`lesson appended: ${line}`);
+}
+
+export function migrateCmd(flags: Args['flags'], positionals: string[] = []): void {
+  const projectDir = resolveProjectDir(str(flags.project));
   const dryRun = flag(flags.dryRun);
+  // --to-team / --to-solo: solo<->team layout switch (W4). Moves, not copies.
+  const toTeam = str(flags.toTeam);
+  const toSolo = str(flags.toSolo);
+  if (toTeam || toSolo) {
+    const member = (toTeam ?? toSolo) as string;
+    if (!/^[A-Za-z0-9._-]+$/.test(member) || /^\.+$/.test(member) || member === 'state' || member === 'continue') {
+      console.error(`invalid member name "${member}" (allowlist: [a-zA-Z0-9._-], not a dot-path, not state/continue)`);
+      process.exit(1);
+    }
+    if (toTeam && toSolo) {
+      console.error('use either --to-team or --to-solo, not both');
+      process.exit(1);
+    }
+    const missionsRootInner = join(projectDir, '.mugiwara', 'missions');
+    let mission = str(flags.mission) ?? (positionals[1] ? String(positionals[1]) : null);
+    const inferMission = (): string | null => {
+      if (!existsSync(missionsRootInner)) return null;
+      const all = readdirSync(missionsRootInner, { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name);
+      if (mission && all.includes(mission)) return mission;
+      if (mission) return mission;
+      // try to find candidate missions for the requested operation
+      if (toTeam) {
+        const candidates = all.filter(m => existsSync(join(missionsRootInner, m, 'state.json')));
+        if (candidates.length === 1) return candidates[0];
+        if (candidates.length === 0) {
+          console.error('no solo mission with state.json found for --to-team');
+          process.exit(1);
+        }
+        console.error(`multiple solo missions: ${candidates.join(', ')} — specify --mission <id>`);
+        process.exit(1);
+      } else {
+        const candidates = all.filter(m => existsSync(join(missionsRootInner, m, `${member}.json`)));
+        if (candidates.length === 1) return candidates[0];
+        if (candidates.length === 0) {
+          console.error(`no mission with ${member}.json found for --to-solo`);
+          process.exit(1);
+        }
+        console.error(`multiple missions with ${member}.json: ${candidates.join(', ')} — specify --mission <id>`);
+        process.exit(1);
+      }
+      return null;
+    };
+    const targetMission = inferMission();
+    if (!targetMission) {
+      console.error('could not infer mission — specify --mission <id>');
+      process.exit(1);
+    }
+    const dir = join(missionsRootInner, targetMission);
+    if (toTeam) {
+      const srcState = join(dir, 'state.json');
+      const srcContinue = join(dir, 'continue.json');
+      const destState = join(dir, `${member}.json`);
+      const destContinue = join(dir, `continue-${member}.json`);
+      if (!existsSync(srcState)) {
+        console.error(`mission "${targetMission}" has no state.json — already team or not found`);
+        process.exit(1);
+      }
+      if (existsSync(destState)) {
+        console.error(`destination ${destState} already exists`);
+        process.exit(1);
+      }
+      const toMove: Array<{ src: string; dest: string }> = [{ src: srcState, dest: destState }];
+      if (existsSync(srcContinue)) toMove.push({ src: srcContinue, dest: destContinue });
+      for (const m of toMove) {
+        console.log(`${dryRun ? 'would migrate' : 'migrated'} ${m.src} → ${m.dest}`);
+        if (!dryRun) {
+          mkdirSync(dirname(m.dest), { recursive: true });
+          try { renameSync(m.src, m.dest); } catch { /* fallback copy */ 
+            try { writeFileSync(m.dest, readFileSync(m.src)); rmSync(m.src, { force: true }); } catch {}
+          }
+        }
+      }
+      console.log(`${dryRun ? 'would migrate' : 'migrated'} ${toMove.length} file(s)${dryRun ? ' (dry run)' : ''}`);
+      return;
+    } else {
+      // --to-solo
+      const srcState = join(dir, `${member}.json`);
+      const srcContinue = join(dir, `continue-${member}.json`);
+      const destState = join(dir, 'state.json');
+      const destContinue = join(dir, 'continue.json');
+      if (!existsSync(srcState)) {
+        console.error(`mission "${targetMission}" has no ${member}.json`);
+        process.exit(1);
+      }
+      const files = readdirSync(dir).filter(f => {
+        const stem = f.replace(/\.json$/, '');
+        return f.endsWith('.json') && stem !== 'continue' && !stem.startsWith('continue-');
+      });
+      const members = files.filter(f => f !== 'state.json');
+      if (members.length > 1) {
+        console.error(`mission "${targetMission}" has ${members.length} members (${members.join(', ')}) — refusing --to-solo (would orphan)`);
+        process.exit(1);
+      }
+      if (existsSync(destState)) {
+        console.error(`destination ${destState} already exists`);
+        process.exit(1);
+      }
+      const toMove: Array<{ src: string; dest: string }> = [{ src: srcState, dest: destState }];
+      if (existsSync(srcContinue)) toMove.push({ src: srcContinue, dest: destContinue });
+      for (const m of toMove) {
+        console.log(`${dryRun ? 'would migrate' : 'migrated'} ${m.src} → ${m.dest}`);
+        if (!dryRun) {
+          mkdirSync(dirname(m.dest), { recursive: true });
+          try { renameSync(m.src, m.dest); } catch {
+            try { writeFileSync(m.dest, readFileSync(m.src)); rmSync(m.src, { force: true }); } catch {}
+          }
+        }
+      }
+      console.log(`${dryRun ? 'would migrate' : 'migrated'} ${toMove.length} file(s)${dryRun ? ' (dry run)' : ''}`);
+      return;
+    }
+  }
   const legacyState = join(projectDir, '.mugiwara', 'state');
   const legacyContinue = join(projectDir, '.mugiwara', 'continue');
   const missionsRoot = join(projectDir, '.mugiwara', 'missions');
@@ -623,7 +800,7 @@ export function migrateCmd(flags: Args['flags']): void {
 
 /** `mugiwara sign <mission>` / `--verify` / `--gen-key` — optional attestation. */
 function signCmd(flags: Args['flags'], _: string[]): void {
-  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const projectDir = resolveProjectDir(str(flags.project));
   if (flag(flags.genKey)) {
     const backend = str(flags.backend) ?? 'auto';
     const home = homedir();
@@ -676,7 +853,12 @@ Usage:
   mugiwara sign --gen-key [--backend pure|minisign]
                          create signing keys (pure ed25519 default)
   mugiwara migrate [--dry-run] [--project <dir>]
-                          move legacy .mugiwara/state/ layout to .mugiwara/missions/
+                           move legacy .mugiwara/state/ layout to .mugiwara/missions/
+  mugiwara migrate --to-team <member> [--mission <id>] [--dry-run]
+                           move state.json -> <member>.json (solo -> team)
+  mugiwara migrate --to-solo <member> [--mission <id>] [--dry-run]
+                           move <member>.json -> state.json (team -> solo; refuses if >1 member)
+  mugiwara lesson "<text>" append a dated row to .mugiwara/lessons.md
   mugiwara run <script> [args...]
                           run a bundled harness script here (${RUNNABLE.join(', ')})
   mugiwara savepoint <mission> [member] [flow] [mode]

package/src/config.ts

@@ -9,24 +9,43 @@ import { join } from 'node:path';
 
 /** The default config body, identical to what the installer has always written. */
 export const DEFAULT_CONFIG = [
-  'mode=guided',
+  '# Mugiwara config. Project overrides ~/.mugiwara/config.',
+  '# Every key here is read by code. Delete a line to take its default.',
+  '',
+  '# -- Autonomy ---------------------------------------------',
+  'mode=guided                  # guided | semi | auto — how much the crew does without asking',
+  'verbosity=normal             # normal | full — how much the crew echoes',
+  '',
+  '# -- Team -------------------------------------------------',
+  '# team_member=              # your member id; set it and state isolates per person',
+  '# team_members=1            # how many people on this mission; >1 enables team-scoped posture',
+  '',
+  '# -- Git --------------------------------------------------',
   'branch=feature/{type}-{issue}-{slug}',
   'commit=conventional',
-  'auto_commit=on',
+  'auto_commit=on               # on | off — off hands you an uncommitted tree in guided/semi',
+  '',
+  '# -- Gates ------------------------------------------------',
   'coverage_new=85',
   'coverage_modified=90',
-  'review_depth=full',
+  'review_depth=full            # full | standard | quick',
   'quality_depth=full',
   'verify_merged=off',
-  'delegate_threshold=60',
-  'heal_max_cycles=3',
-  'verbosity=normal',
-  '# context_budget_chars=150000  # optional: fail archive if trail exceeds this (measured in report Cost section)',
-  '# investigation_max_passes=2  # optional: cap investigation passes (spec §13)',
+  '',
+  '# -- Limits -----------------------------------------------',
+  'delegate_threshold=60        # % of budget before delegation is advised',
+  'heal_max_cycles=3            # heal loop halts here and escalates',
+  '',
+  '# -- Monorepo ---------------------------------------------',
+  '# lane_scope_glob=packages/api/**   # count only matching files when sizing the lane',
+  '',
+  '# -- Optional ---------------------------------------------',
+  '# context_budget_chars=150000       # fail archive if the trail exceeds this',
+  '# investigation_max_passes=2',
   '# investigation_max_unrelated_files=5',
   '# investigation_repeated_read_threshold=2',
-  '# sign=auto            # optional: auto | minisign | pure | off — report attestation',
-  '# enforce=block                # optional: off | warn | block — pipeline-guard policy',
+  '# sign=auto                         # auto | minisign | pure | off',
+  '# enforce=block                     # off | warn | block — pipeline-guard policy',
 ].join('\n') + '\n';
 
 /** Config file path candidates: project first, then user home. */
@@ -57,7 +76,10 @@ export function readConfig(projectDir: string): Record<string, string> {
       const key = t.slice(0, eq).trim();
       if (!key) continue;
       if (key in out) continue; // project value already set — keep it
-      out[key] = t.slice(eq + 1).trim();
+      let rawVal = t.slice(eq + 1).trim();
+      const hash = rawVal.indexOf('#');
+      if (hash !== -1) rawVal = rawVal.slice(0, hash).trim();
+      out[key] = rawVal;
     }
   }
   return out;

package/src/continue.ts

@@ -111,6 +111,11 @@ export function gitActor(cwd: string): string {
   return name || process.env.USER || process.env.USERNAME || '';
 }
 
+const unreadable: string[] = [];
+
+/** State files that exist but could not be parsed. Cleared by each scan. (B6) */
+export function unreadableStateFiles(): string[] { return [...unreadable]; }
+
 /**
  * Read every mission dir under `.mugiwara/missions/<mission>/`, picking the
  * files this reader owns: state readers take `state.json` / `<member>.json`,
@@ -118,6 +123,7 @@ export function gitActor(cwd: string): string {
  * files are skipped.
  */
 function scan<T>(projectDir: string, kind: 'state' | 'continue', map: (raw: Record<string, unknown>, member: string | null) => T): T[] {
+  unreadable.length = 0;
   const base = join(projectDir, '.mugiwara', 'missions');
   if (!existsSync(base)) return [];
   const out: T[] = [];
@@ -148,7 +154,7 @@ function scan<T>(projectDir: string, kind: 'state' | 'continue', map: (raw: Reco
         if (text(raw.mission) !== mission) continue;
         out.push(map(raw, member));
       } catch {
-        // corrupt savepoint — skip, never crash the listing
+        unreadable.push(join(mission, f));
       }
     }
   }

package/src/cost.ts

@@ -33,7 +33,7 @@ export const LANE_BUDGET: Record<string, number> = {
   lean: 12000,
   standard: 25000,
   full: 50000,
-  spike: 3000,
+  spike: 9000,
 };
 
 /** Token estimate for skills/agents loaded in this lane (0 for unknown/direct). */

package/src/installer.ts

@@ -1,5 +1,5 @@
 // src/installer.ts
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, copyFileSync, rmSync, lstatSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, copyFileSync, rmSync, lstatSync, chmodSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
@@ -57,6 +57,7 @@ export interface Target {
 }
 
 export const CONTENT_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'content');
+const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf8')) as { version: string };
 export const VERSION = pkg.version;
 
@@ -99,9 +100,13 @@ export function installTo(target: Target, opts: InstallOptions): InstallResult {
   const backupRoot = join(scope === 'global' ? home : projectDir, '.mugiwara');
   const result: InstallResult = { written: [], skipped: [], backedUp: [], notes: [] };
 
-  const writeOne = (absPath: string, text: string) => {
+  const writeOne = (absPath: string, text: string, mode?: number) => {
     if (existsSync(absPath)) {
-      if (readFileSync(absPath, 'utf8') === text) { result.skipped.push(absPath); return; }
+      if (readFileSync(absPath, 'utf8') === text) {
+        // ensure mode even when content unchanged
+        if (!dryRun && mode !== undefined) { try { chmodSync(absPath, mode); } catch { /* ignore */ } }
+        result.skipped.push(absPath); return;
+      }
       if (!force) {
         result.skipped.push(absPath);
         result.notes.push(`conflict (not overwritten; run update to replace with backup): ${absPath}`);
@@ -114,7 +119,11 @@ export function installTo(target: Target, opts: InstallOptions): InstallResult {
       if (!dryRun) { mkdirSync(backupDir, { recursive: true }); copyFileSync(absPath, backupFile); }
       result.backedUp.push(absPath);
     }
-    if (!dryRun) { mkdirSync(dirname(absPath), { recursive: true }); writeFileSync(absPath, text); }
+    if (!dryRun) {
+      mkdirSync(dirname(absPath), { recursive: true });
+      writeFileSync(absPath, text);
+      if (mode !== undefined) { try { chmodSync(absPath, mode); } catch { /* ignore */ } }
+    }
     result.written.push(absPath);
   };
 
@@ -156,6 +165,20 @@ export function installTo(target: Target, opts: InstallOptions): InstallResult {
     for (const r of sharedRefs) writeOne(join(sharedRoot, r.relPath), r.text);
   }
 
+  // Shell fallbacks: pure sh, no Node. The critical path (lane sizing + state)
+  // must survive on a harness where the CLI cannot run. See plan.md B1.
+  {
+    const SHELL_FALLBACKS = ['lane.sh', 'savepoint.sh', 'lib/patterns.sh', 'lib/lane-base.sh'];
+    const mugiwaraDir = join(scope === 'global' ? home : projectDir, '.mugiwara');
+    for (const rel of SHELL_FALLBACKS) {
+      const src = join(REPO_ROOT, 'scripts', rel);
+      if (!existsSync(src)) continue;
+      const text = readFileSync(src, 'utf8');
+      const dest = join(mugiwaraDir, 'bin', rel);
+      writeOne(dest, text, 0o755);
+    }
+  }
+
   if (target.postInstall) {
     const post = target.postInstall({ scope, projectDir, home, dryRun, files: result.written });
     result.written.push(...post.written);

package/src/integrity.ts

@@ -162,23 +162,54 @@ export function checkTrail(missionDir: string, projectRoot: string): IntegrityIs
 
   // 3: evidence entries recorded as repo paths must exist
   const evidencePaths: string[] = [];
-  const evidenceFile = join(missionDir, 'state.json');
-  if (existsSync(evidenceFile)) {
+  // Solo layout writes state.json; team layout writes <member>.json per member.
+  // Reading only state.json left the evidence gate dead on the team path (B2).
+  const stateFiles = existsSync(missionDir)
+    ? readdirSync(missionDir)
+        .filter((n) => n.endsWith('.json') && n !== 'continue.json' && !n.startsWith('continue-'))
+        .sort()
+    : [];
+  for (const name of stateFiles) {
+    const evidenceFile = join(missionDir, name);
     try {
       const s = JSON.parse(readFileSync(evidenceFile, 'utf8')) as { evidence?: unknown };
-      if (Array.isArray(s.evidence)) {
-        for (const e of s.evidence) {
-          if (typeof e !== 'string' || !e.trim()) continue;
-          evidencePaths.push(e);
-          const cand = join(projectRoot, e);
-          if (!isAbsolute(e) && !existsSync(cand) && !existsSync(join(missionDir, e))) {
-            issues.push({ kind: 'evidence', detail: `state.json evidence "${e}" does not exist` });
-          }
+      if (!Array.isArray(s.evidence)) continue;
+      for (const e of s.evidence) {
+        if (typeof e !== 'string' || !e.trim()) continue;
+        evidencePaths.push(e);
+        const cand = join(projectRoot, e);
+        if (!isAbsolute(e) && !existsSync(cand) && !existsSync(join(missionDir, e))) {
+          issues.push({ kind: 'evidence', detail: `${name} evidence "${e}" does not exist` });
         }
       }
     } catch { /* corrupt state — the state reader owns that error */ }
   }
 
+  // Iron Law: no evidence = not complete. Absent evidence is a different failure
+  // from thin evidence, and previously went unreported entirely. (B7)
+  if (evidencePaths.length === 0) {
+    let severity: 'warn' | 'block' = 'warn';
+    try {
+      const policy = loadPolicy(projectRoot);
+      const lanes = (policy as unknown as { evidence?: { require_nonempty_for_lanes?: string[] } })?.evidence?.require_nonempty_for_lanes;
+      if (Array.isArray(lanes) && lanes.length) {
+        const stateLanes = new Set<string>();
+        for (const name of stateFiles) {
+          try {
+            const s = JSON.parse(readFileSync(join(missionDir, name), 'utf8')) as { lane?: unknown };
+            if (typeof s.lane === 'string') stateLanes.add(s.lane);
+          } catch { /* ignore */ }
+        }
+        if ([...stateLanes].some((l) => lanes.includes(l))) severity = 'block';
+      }
+    } catch { /* policy read failure -> keep warn */ }
+    issues.push({
+      kind: 'evidence',
+      severity,
+      detail: 'mission declares no evidence — closing with zero recorded checks',
+    });
+  }
+
   // 4: evidence-content spot check (T7): a PASS verdict that cites an evidence
   // path must point at a file that exists AND contains command-output shape
   // (backticked command or exit-status token). Fake-but-consistent trails