@ionivetech/mugiwara 0.6.1 → 0.6.3

package/scripts/setup-fixtures.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env bun
+// scripts/setup-fixtures.ts — materialize test/fixtures/*.json into real git
+// repos in a temp dir. Each fixture = a JSON manifest with base/branch file
+// trees. The script writes the base tree on the trunk branch, creates the
+// feature branch, applies the branch tree, and commits. Used by tests to get
+// a deterministic repo per scenario. Never touches the main repo's .git.
+//
+// Usage:
+//   bun scripts/setup-fixtures.ts <fixture> <targetDir>
+//   bun scripts/setup-fixtures.ts --list
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+
+const fixturesDir = join(import.meta.dirname, '..', 'test', 'fixtures');
+
+function fixtureNames(): string[] {
+  return readdirSync(fixturesDir).filter(f => f.endsWith('.json')).map(f => f.replace(/\.json$/, ''));
+}
+
+if (process.argv[2] === '--list') {
+  console.log(fixtureNames().join('\n'));
+  process.exit(0);
+}
+
+const name = process.argv[2];
+const target = process.argv[3];
+if (!name || !target) {
+  console.error('usage: bun scripts/setup-fixtures.ts <fixture> <targetDir>');
+  process.exit(1);
+}
+
+type Fixture = {
+  name: string;
+  baseBranch: string;
+  base: Record<string, string>;
+  branch: Record<string, string>;
+  binary?: string[];
+  gitInit?: boolean;
+  note?: string;
+};
+
+const file = join(fixturesDir, name + '.json');
+if (!existsSync(file)) {
+  console.error(`fixture not found: ${name} (have: ${fixtureNames().join(', ')})`);
+  process.exit(1);
+}
+const fx = JSON.parse(readFileSync(file, 'utf8')) as Fixture;
+
+// target must be a fresh empty dir
+if (existsSync(target)) rmSync(target, { recursive: true, force: true });
+mkdirSync(target, { recursive: true });
+
+if (fx.gitInit === false) {
+  // no-git fixture: just an empty dir with one file, no .git ever created
+  mkdirSync(join(target, 'src'), { recursive: true });
+  writeFileSync(join(target, 'src', 'main.ts'), 'export const main = () => 1;\n');
+  console.log(`fixture ${name}: materialized (no .git)`);
+  process.exit(0);
+}
+
+const writeTree = (tree: Record<string, string>) => {
+  for (const [path, content] of Object.entries(tree)) {
+    const full = join(target, path);
+    mkdirSync(join(full, '..'), { recursive: true });
+    writeFileSync(full, content);
+  }
+};
+
+// names feed unquoted git branch args — validate before interpolation (F3).
+// Fixture files are repo-owned, but `name` is a CLI arg and `trunk` comes from
+// fixture JSON; both must be safe git ref names.
+const SAFE_REF = /^[A-Za-z0-9._/-]+$/;
+if (!SAFE_REF.test(name) || !SAFE_REF.test(fx.baseBranch || '')) {
+  console.error(`fixture ${name}: unsafe branch name rejected`);
+  process.exit(1);
+}
+
+execSync('git init -q', { cwd: target });
+execSync('git config user.email test@test.com && git config user.name Test', { cwd: target });
+
+const trunk = fx.baseBranch || 'main';
+// branch named after trunk if trunk isn't main (so savepoint base-resolve paths differ)
+execSync(`git checkout -q -b ${trunk}`, { cwd: target });
+
+// base commit on trunk
+writeTree(fx.base);
+for (const rel of fx.binary ?? []) {
+  if (fx.base[rel]) writeFileSync(join(target, rel), fx.base[rel]);
+}
+execSync('git add -A && git commit -q -m base', { cwd: target });
+
+// feature branch applies the branch tree (files removed from base not in
+// branch get deleted; contents updated; new files added)
+execSync(`git checkout -q -b feat-${fx.name}`, { cwd: target });
+for (const rel of Object.keys(fx.base)) {
+  if (!(rel in fx.branch)) {
+    execSync(`git rm -q --ignore-unmatch "${rel}"`, { cwd: target });
+  }
+}
+writeTree(fx.branch);
+for (const rel of fx.binary ?? []) {
+  if (fx.branch[rel]) writeFileSync(join(target, rel), fx.branch[rel]);
+}
+execSync('git add -A && git commit -q -m wip', { cwd: target });
+
+console.log(`fixture ${name}: materialized at ${target} (trunk=${trunk}, branch=feat-${fx.name})`);

package/scripts/validate-content.ts

@@ -319,5 +319,66 @@ const agentsDoc = join(docsDir, 'concepts', 'agents.md');
   if (docErrors === 0) console.log('✓ docs in sync with content/');
 }
 
+// --- doc-integrity check: documented thresholds must match source constants ---
+// Docs are claims; a claim that drifts from the source is a lie. LANE_BASE +
+// BUDGET live in scripts/lib/lane-base.sh (validated by lane-base.ts); the
+// cost docs must cite the same numbers. Evidence logs carry an exit code /
+// verdict claim — a test must back it (lane-integrity cases 22-24).
+const integrityArg = process.argv.indexOf('--check-doc-integrity');
+if (integrityArg !== -1) {
+  const src = join(import.meta.dirname, '..', 'scripts', 'lib', 'lane-base.sh');
+  if (!existsSync(src)) {
+    errors.push('doc-integrity: scripts/lib/lane-base.sh not found — cannot verify thresholds');
+  } else {
+    const constants = readFileSync(src, 'utf8');
+    const docs = ['docs/concepts/cost.md', 'docs/concepts/lanes.md', 'README.md'];
+    const expected: [string, string][] = [
+      ['lean', '7,000'], ['standard', '13,000'], ['full', '23,000'],
+      ['lean', '12,000'], ['standard', '25,000'], ['full', '50,000'],
+    ];
+    for (const doc of docs) {
+      const p = join(import.meta.dirname, '..', doc);
+      if (!existsSync(p)) { errors.push(`doc-integrity: ${doc} not found`); continue; }
+      const text = readFileSync(p, 'utf8');
+      for (const [lane, num] of expected) {
+        // each doc must cite the budget/LANE_BASE number for that lane; accept
+        // both the comma form (7,000) and the k-shorthand (7k / ~7k)
+        const compact = num.replace(',', '').replace(/0+$/, '');
+        const kForm = /^(\d+)000$/.exec(num);
+        const variants = [num, compact, ...(kForm ? [`${kForm[1]}k`, `~${kForm[1]}k`] : [])];
+        if (!variants.some(v => text.includes(v))) {
+          errors.push(`doc-integrity: ${doc} missing ${lane} threshold ${num} (source: ${src})`);
+        }
+      }
+      // warn/stop are 1.5x / 3x of BUDGET (code: WARN_AT=BUDGET*3/2,
+      // STOP_AT=BUDGET*3) — presence is not enough, the arithmetic must be
+      // right. A doc claiming 1.5x/3x of LANE_BASE is the exact lie this gate
+      // exists to catch. Checked on the authoritative cost doc only.
+      if (doc === 'docs/concepts/cost.md') {
+        const budgets: [string, number][] = [['lean', 12000], ['standard', 25000], ['full', 50000]];
+        for (const [lane, budget] of budgets) {
+          const warn = budget * 3 / 2;
+          const stop = budget * 3;
+          const warnForms = [`${warn}`, `${Math.round(warn / 1000)}k`, `${warn.toLocaleString()}`, `${warn / 1000}k`];
+          const stopForms = [`${stop}`, `${stop / 1000}k`, `${stop.toLocaleString()}`];
+          const hasWarn = warnForms.some(f => text.includes(f));
+          const hasStop = stopForms.some(f => text.includes(f));
+          if (!hasWarn || !hasStop) {
+            errors.push(`doc-integrity: ${doc} ${lane} warn/stop must be 1.5x/3x of budget ${budget} (warn ${warn}, stop ${stop})`);
+          }
+        }
+      }
+    }
+    if (!constants.includes('LANE_BASE_lean=7000')) errors.push('doc-integrity: source lane-base.sh lean base drifted (expected 7000)');
+    if (!constants.includes('BUDGET_full=50000')) errors.push('doc-integrity: source lane-base.sh full budget drifted (expected 50000)');
+  }
+  // evidence exit-code claim must be test-backed
+  const evTest = join(import.meta.dirname, '..', 'test', 'lane-integrity.test.ts');
+  const testText = existsSync(evTest) ? readFileSync(evTest, 'utf8') : '';
+  if (!testText.includes('# Exit:') || !testText.includes('# Verdict:')) {
+    errors.push('doc-integrity: audit-trail claims evidence logs carry exit code + verdict, but no test asserts them');
+  }
+}
+
 if (errors.length) { console.error(errors.map(e => `✗ ${e}`).join('\n')); process.exit(1); }
 console.log(`✓ content valid: ${skillDirs.length} skills, ${agentFiles.length} agents`);

package/src/cli.ts

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 import { parseArgs, type FlagValue, type Args } from './args.ts';
 import { createRl, choose, multiChoose, confirm } from './prompt.ts';
 import { targets, TARGET_IDS } from './targets/index.ts';
-import { installTo, removeInstalled, VERSION, ensureProjectGitignore } from './installer.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';
 
@@ -151,6 +151,10 @@ async function uninstall(flags: Args['flags']): Promise<void> {
   }
   const removed = removeInstalled(manifest, { dryRun: flag(flags.dryRun) });
   if (!flag(flags.dryRun)) {
+    if (scope === 'project') {
+      const gi = removeProjectGitignore(projectDir);
+      for (const n of gi.notes) console.log(`   note: ${n}`);
+    }
     rmSync(file);
     const mugiDir = join(scope === 'global' ? home : projectDir, '.mugiwara');
     if (existsSync(mugiDir) && readdirSync(mugiDir).length === 0) {

package/src/installer.ts

@@ -182,28 +182,90 @@ 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/.
+const GITIGNORE_BLOCK = `# >>> mugiwara >>> — audit trail is the product: commit reports/, results/, logs/, spec/, plans/.
 # Ignore session state and regenerated files.
-.mugiwara/state.json
-.mugiwara/state-*.json
+.mugiwara/state/
+.mugiwara/continue/
 .mugiwara/config
-.mugiwara/continue.md
 .mugiwara/refs/
+# <<< mugiwara <<<
 `;
 
 export function ensureProjectGitignore(projectDir: string, opts: { dryRun?: boolean } = {}): { appended: boolean; notes: string[] } {
   const { dryRun = false } = opts;
   const path = join(projectDir, '.gitignore');
   assertNotSymlink(path);
-  if (existsSync(path) && readFileSync(path, 'utf8').includes(GITIGNORE_MARKER)) {
-    return { appended: false, notes: [] };
+  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/')) {
+      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.
+    // 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);
+    if (hadOld) {
+      const clean = removeProjectGitignore(projectDir, { dryRun });
+      existing = clean.removed ? (existsSync(path) ? readFileSync(path, 'utf8') : '') : existing;
+    }
   }
-  const existing = existsSync(path) ? readFileSync(path, 'utf8') : '';
   const separator = existing.length && !existing.endsWith('\n') ? '\n' : '';
   if (!dryRun) {
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, existing + separator + GITIGNORE_BLOCK);
   }
-  return { appended: true, notes: [`.gitignore ${dryRun ? 'would append' : 'appended'} mugiwara audit-trail block`] };
+  return { appended: true, notes: [`.gitignore ${dryRun ? 'would upgrade+append' : 'upgraded'} mugiwara audit-trail block`] };
+}
+
+// remove the delimited mugiwara block, preserving user lines. Handles both
+// the current delimited block and the legacy undelimited block (v0.6.2).
+export function removeProjectGitignore(projectDir: string, { dryRun = false }: { dryRun?: boolean } = {}): { removed: boolean; notes: string[] } {
+  const path = join(projectDir, '.gitignore');
+  assertNotSymlink(path);
+  if (!existsSync(path)) return { removed: false, notes: [] };
+  const current = readFileSync(path, 'utf8');
+
+  const delimited = current.includes(GITIGNORE_BLOCK_START);
+  let cleaned: string;
+  if (delimited) {
+    // strip everything between (and including) the delimiters. Both
+    // delimiters must be present — a missing END (hand-edit) with end=-1
+    // would slice() from char 18 and truncate the user's file.
+    const start = current.indexOf(GITIGNORE_BLOCK_START);
+    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
+    // 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/continue.md',
+      '.mugiwara/refs/',
+    ]);
+    const lines = current.split('\n').filter(l => {
+      const t = l.trim();
+      if (t.startsWith(GITIGNORE_MARKER)) return false; // header + comment
+      return !LEGACY_LINES.has(t);
+    });
+    cleaned = lines.join('\n');
+  } else {
+    return { removed: false, notes: [] };
+  }
+
+  cleaned = cleaned.replace(/\n{3,}/g, '\n\n').replace(/^\n+/, '').replace(/\n+$/, '\n');
+  if (cleaned.trim() === '') cleaned = '';
+  if (cleaned === current) return { removed: false, notes: [] };
+  if (!dryRun) writeFileSync(path, cleaned);
+  return { removed: true, notes: [`.gitignore ${dryRun ? 'would strip' : 'stripped'} mugiwara block`] };
 }

package/src/mission.ts

@@ -4,12 +4,23 @@ import { existsSync, rmSync, readFileSync, readdirSync, mkdirSync, appendFileSyn
 import { join } from 'node:path';
 
 function activeActor(projectDir: string): string | null {
-  const stateFile = join(projectDir, '.mugiwara', 'state.json');
-  if (!existsSync(stateFile)) return null;
-  try {
-    const state = JSON.parse(readFileSync(stateFile, 'utf8'));
-    return state.actor || null;
-  } catch { return null; }
+  // state now lives at .mugiwara/state/<mission>/[member].json — scan the
+  // latest state file for its actor
+  const stateDir = join(projectDir, '.mugiwara', 'state');
+  if (!existsSync(stateDir)) return null;
+  const missions = readdirSync(stateDir, { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name);
+  let latest: { actor: string; updated: number } | null = null;
+  for (const mission of missions) {
+    const d = join(stateDir, mission);
+    for (const f of readdirSync(d).filter(f => f.endsWith('.json'))) {
+      try {
+        const s = JSON.parse(readFileSync(join(d, f), 'utf8'));
+        const t = Date.parse(s.updated_at || '') || 0;
+        if (!latest || t > latest.updated) latest = { actor: s.actor || null, updated: t };
+      } catch { /* corrupt — skip */ }
+    }
+  }
+  return latest ? latest.actor : null;
 }
 
 export function resetMission(projectDir: string, keepLogs: boolean, force?: boolean): { removed: string[]; kept: string[]; blocked?: string } {
@@ -30,7 +41,12 @@ export function resetMission(projectDir: string, keepLogs: boolean, force?: bool
     const p = join(root, dir);
     if (existsSync(p)) { rmSync(p, { recursive: true, force: true }); removed.push(dir); }
   }
-  // mission state files — state.json + branch-specific state-*.json
+  // mission state + continue folders — state/<mission>/, continue/<mission>/
+  for (const dir of ['state', 'continue']) {
+    const p = join(root, dir);
+    if (existsSync(p)) { rmSync(p, { recursive: true, force: true }); removed.push(dir); }
+  }
+  // legacy flat state files — state.json + branch-specific state-*.json
   for (const f of readdirSync(root)) {
     if (/^state(-.+)?\.json$/.test(f)) {
       const p = join(root, f);
@@ -80,15 +96,13 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
     if (f) report = join('reports', f);
   }
 
-  // remove per-mission wave intermediates from results/<mission>/, EXCEPT
-  // 06-closure.md and 07-pr-verdict.md (PR material + closure stay)
+  // step results 01..05 + todos.md are evidence — kept; archive removes
+  // step results 01..05 + todos.md are evidence — kept; archive removes
+  // only spec/review/issues/logs + continue/<mission>/ + state/<mission>/
   const resultsDir = join(root, 'results', mission);
   if (existsSync(resultsDir)) {
     for (const f of readdirSync(resultsDir)) {
-      if (f === '06-closure.md' || f === '07-pr-verdict.md') { kept.push(join('results', mission, f)); continue; }
-      const p = join(resultsDir, f);
-      if (!dryRun) rmSync(p, { recursive: true, force: true });
-      removed.push(join('results', mission, f));
+      kept.push(join('results', mission, f));
     }
   }
 
@@ -124,21 +138,22 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
     }
   }
 
-  // continue.md is a session handoff — only remove it if it belongs to THIS
-  // mission (its content references the mission name); otherwise leave it.
-  const cont = join(root, 'continue.md');
-  if (existsSync(cont)) {
-    try {
-      if (readFileSync(cont, 'utf8').includes(mission)) {
-        if (!dryRun) rmSync(cont);
-        removed.push('continue.md');
-      }
-    } catch { /* unreadable — leave it */ }
+  // continue/<mission>/ is a session handoff — remove this mission's folder
+  const contDir = join(root, 'continue', mission);
+  if (existsSync(contDir)) {
+    if (!dryRun) rmSync(contDir, { recursive: true, force: true });
+    removed.push(join('continue', mission));
+  }
+  // state/<mission>/ — remove this mission's computed state (archived)
+  const stateDir = join(root, 'state', mission);
+  if (existsSync(stateDir)) {
+    if (!dryRun) rmSync(stateDir, { recursive: true, force: true });
+    removed.push(join('state', mission));
   }
 
   // kept: report + the audit-trail survivors
   if (report) kept.push(report);
-  for (const k of ['plans', 'config', 'state.json', join('logs', 'lessons.md')]) {
+  for (const k of ['plans', 'config', join('logs', 'lessons.md')]) {
     if (existsSync(join(root, k))) kept.push(k);
   }
 

package/src/targets/claude.ts

@@ -10,8 +10,10 @@ const HOOKS_SRC = join(here, '..', '..', 'hooks');
 const COMMANDS_SRC = join(here, '..', '..', '.claude', 'commands');
 
 // Claude Code has no path-scoped permission. write-scope maps to a partial
-// `tools:` list: artifacts agents lose Edit (cannot modify existing source)
-// but keep Write (must create .mugiwara/**); source agents get the default set.
+// `tools:` list — applied to internal subagent-only agents only: artifacts
+// agents lose Edit (cannot modify existing source) but keep Write (must create
+// .mugiwara/**). User-facing crew run inline in the main thread and keep the
+// default toolset (incl. Edit); discipline is enforced by rules, not tools.
 function toolsFromScope(scope?: string): string | undefined {
   if (scope === 'artifacts') return 'Read, Grep, Glob, Write, Bash, WebFetch, WebSearch';
   return undefined;
@@ -35,7 +37,7 @@ export const target: Target = {
   transformAgent(data: FrontmatterData, body: string) {
     const fm: FrontmatterData = { name: data.name, description: data.description };
     if (data.tools) fm.tools = data.tools;
-    else {
+    else if (data['internal-agent'] === 'true') {
       const generated = toolsFromScope(data['write-scope']);
       if (generated) fm.tools = generated;
     }

package/src/targets/opencode.ts

@@ -32,23 +32,27 @@ const CREW: Record<string, CrewConfig> = {
   'memory-keeper': { color: '#d946ef', temperature: 0.2, steps: 8 },
 };
 
-// write-scope is the single source of truth (content/agents/*.md frontmatter).
-// The path boundary (artifacts vs source) IS expressible in opencode:
-// permission.edit accepts glob/pattern -> action, last match wins. Artifacts
-// agents get deny-all-edit except .mugiwara/**; source agents (zoro, brook)
-// get full edit allow. Derived at install time from the frontmatter field.
+// write-scope is the single source of truth (content/agents/*.md frontmatter),
+// but it is a RULE for user-facing crew agents: they run inline in the main
+// thread, so a runtime permission bound to the active-agent identity would
+// force tab-switching per wave and break auto mode + resume. Runtime
+// enforcement stays for internal subagent-only agents (internal: true) — the
+// path boundary IS expressible in opencode: permission.edit accepts
+// glob/pattern -> action, last match wins. Artifacts internal agents get
+// deny-all-edit except .mugiwara/**; source internal agents get full edit
+// allow. Derived at install time from the frontmatter field.
 function permissionFromScope(scope: string | undefined): Record<string, string | Record<string, string>> | undefined {
   if (scope === 'source') return { edit: 'allow' };
   if (scope === 'artifacts') return { edit: { '*': 'deny', '.mugiwara/**': 'allow' } };
   return undefined;
 }
 
-function agentFrontmatter(name: string, description: string, writeScope?: string) {
+function agentFrontmatter(name: string, description: string, internal: boolean, writeScope?: string) {
   const crew = CREW[name];
   const lines = [`description: ${description}`, `mode: all`];
   if (crew) {
     lines.push(`color: '${crew.color}'`, `temperature: ${crew.temperature}`, `steps: ${crew.steps}`);
-    const perm = permissionFromScope(writeScope);
+    const perm = internal ? permissionFromScope(writeScope) : undefined;
     if (perm) {
       lines.push('permission:');
       for (const [k, v] of Object.entries(perm)) {
@@ -81,7 +85,7 @@ export const target: Target = {
   },
   transformAgent(data: FrontmatterData, body: string) {
     const desc = data['internal-agent'] === 'true' ? `[INTERNAL] ${data.description}` : data.description;
-    const fm = agentFrontmatter(data.name, desc, data['write-scope']);
+    const fm = agentFrontmatter(data.name, desc, data['internal-agent'] === 'true', data['write-scope']);
     return { relPath: `${data.name}.md`, text: `---\n${fm}\n---\n${body}` };
   },
   refsDir({ scope, projectDir, home }, skillName: string) {