@ionivetech/mugiwara 0.8.1 → 0.9.0

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "mugiwara",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, healing.",
   "contextFileName": "GEMINI.md"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ionivetech/mugiwara",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, self-healing. Installs into Claude Code, opencode, Copilot, Gemini, Codex, Cursor, Kimi, pi, Windsurf, Cline, Kilo, Antigravity.",
   "homepage": "https://github.com/ionivetech/mugiwara#readme",
   "repository": {

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mugiwara",
   "description": "The Straw Hat crew of AI agents and skills: brainstorm, plan, execute, checkpoint, quality, gates, review, security, healing.",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "author": {
     "name": "ionivetech"
   },

package/references/multi-actor.md

@@ -9,13 +9,16 @@ its own file inside the mission folder, so parallel work never collides:
 
 ```
 .mugiwara/
-├── state/<mission>/state.json        # solo mission state
-├── state/<mission>/<member>.json     # team member state
-├── continue/<mission>/state.json     # solo resume point (D10)
-├── continue/<mission>/<member>.json  # team member resume point
-├── plans/<mission>.md                # shared plan (source of truth)
-├── reports/YYYY-MM-DD-<mission>.md
-├── results/<mission>-*.md
+├── missions/<mission>/state.json              # solo mission state
+├── missions/<mission>/<member>.json           # team member state
+├── missions/<mission>/continue.json           # solo resume point (D10)
+├── missions/<mission>/continue-<member>.json  # team member resume point
+├── missions/<mission>/plan.md                 # shared plan (source of truth)
+├── missions/<mission>/flows/                  # flow evidence
+├── missions/<mission>/report.md               # closure report
+├── lessons.md                                 # shared ledger (append-only)
+├── config
+└── index.md
 ```
 
 Branch is an implementation detail, not an identity: a member can hold several
@@ -31,11 +34,11 @@ $ mugiwara reset
 ✗ Active mission for 'john'. Use --force to override.
 ```
 
-`--force` still preserves `logs/lessons.md` and `config`.
+`--force` still preserves `.mugiwara/lessons.md` and `config`.
 
 ## Shared state
 
-The lessons ledger (`logs/lessons.md`) stays shared — that is the point of it.
+The lessons ledger (`.mugiwara/lessons.md`) stays shared — that is the point of it.
 All actors read and write to the same file. Append-only, never overwrite.
 
 ## Member namespacing
@@ -44,13 +47,13 @@ All actors read and write to the same file. Append-only, never overwrite.
 member argument) write `state.json`; team missions write `<member>.json`:
 
 ```bash
-mugiwara savepoint dark-mode                 # solo → state/dark-mode/state.json
-mugiwara savepoint payment-gateway john    # team → state/payment-gateway/john.json
-mugiwara savepoint payment-gateway patty     #        state/payment-gateway/patty.json
+mugiwara savepoint dark-mode                 # solo → missions/dark-mode/state.json
+mugiwara savepoint payment-gateway john    # team → missions/payment-gateway/john.json
+mugiwara savepoint payment-gateway patty     #        missions/payment-gateway/patty.json
 ```
 
-The resume point follows the same scoping: `continue/<mission>/<member>.json`
-(team) or `continue/<mission>/state.json` (solo), so parallel members never
+The resume point follows the same scoping: `missions/<mission>/continue-<member>.json`
+(team) or `missions/<mission>/continue.json` (solo), so parallel members never
 clobber each other's resume position.
 
 ## Resuming your own work

package/scripts/gate-selftest.ts

@@ -649,7 +649,7 @@ console.log('\nT3 — lane-aware gates');
       return s.length === 12 && s.includes('run-evals') && s.includes('retrieval-eval') && s.includes('conformance');
     });
     assert('budget direct → 0, full → 50000', true, () => budgetForLane('direct') === 0 && budgetForLane('full') === 50000);
-    assert('budget spike → 3000 (direct fixture 3k)', true, () => budgetForLane('spike') === 3000);
+    assert('budget spike → 9000 (direct fixture 9k)', true, () => budgetForLane('spike') === 9000);
     // mutation: break direct step count → should fail (file content shows not 3)
     const broken = originalPolicy.replace(
       "direct: ['build-hooks:check', 'typecheck', 'build']",
@@ -675,5 +675,298 @@ console.log('\nT3 — lane-aware gates');
   });
 }
 
+// --- B1: CLI availability — remove section → content validation fails ---
+console.log('\nB1 — CLI availability');
+{
+  const wf = join(root, 'content', 'skills', 'mugiwara-workflow', 'SKILL.md');
+  const original = readFileSync(wf, 'utf8');
+  try {
+    const b1Pattern = /## CLI availability[\s\S]*?## Artifact trust/;
+    const b1Broken = original.replace(b1Pattern, '## Artifact trust');
+    if (!b1Pattern.test(original) || b1Broken === original) {
+      console.error('✗ B1: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(wf, b1Broken);
+      assert('missing CLI availability → grep fails', false, () => run('B1-grep', 'grep -q "CLI availability" content/skills/mugiwara-workflow/SKILL.md'));
+    }
+  } finally {
+    writeFileSync(wf, original);
+    assert('restored → content validation passes', true, () => run('B1-restore', 'grep -q "CLI availability" content/skills/mugiwara-workflow/SKILL.md'));
+  }
+}
+
+// --- B2: team evidence gate — revert to single state.json → integrity gate fails on team ---
+console.log('\nB2 — team evidence gate');
+{
+  const integ = join(root, 'src', 'integrity.ts');
+  const original = readFileSync(integ, 'utf8');
+  try {
+    const fixedPattern = /const stateFiles = existsSync\(missionDir\)/;
+    const broken = original.replace(fixedPattern, "const evidenceFile = join(missionDir, 'state.json'); // B2 revert");
+    const fullPattern = /  \/\/ Solo layout writes state\.json; team layout writes <member>\.json per member\./;
+    let b2Broken = original;
+    if (fullPattern.test(original)) {
+      // remove the team-aware block header to make grep for stateFiles fail for the specific definition
+      b2Broken = original.replace(fixedPattern, "const evidenceFile = join(missionDir, 'state.json'); // B2 revert");
+      // also need to remove remaining stateFiles references to make grep fail - replace all stateFiles with evidenceFile
+      b2Broken = b2Broken.replace(/stateFiles/g, 'evidenceFile');
+    }
+    if (!fixedPattern.test(original) || broken === original) {
+      console.error('✗ B2: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(integ, b2Broken);
+      assert('single state.json → team evidence gate dead', false, () => run('B2', 'grep -q "const stateFiles = existsSync" src/integrity.ts'));
+    }
+  } finally {
+    writeFileSync(integ, original);
+    assert('restored → team gate present', true, () => run('B2-restore', 'grep -q "const stateFiles = existsSync" src/integrity.ts'));
+  }
+}
+
+// --- B3: task counter — restore unanchored grep → savepoint task test fails ---
+console.log('\nB3 — task counter');
+{
+  const sp = join(root, 'scripts', 'savepoint.sh');
+  const original = readFileSync(sp, 'utf8');
+  try {
+    const broken = original.replace('TASKS_TOTAL=$(count_boxes "$PLAN_FILE" \'[ xX]\')', 'TASKS_TOTAL=$(grep -cE \'^\\s*-\\s*\\[[ xX]\\]\' "$PLAN_FILE" 2>/dev/null || true)')
+      .replace('TASKS_DONE=$(count_boxes "$PLAN_FILE" \'[xX]\')', 'TASKS_DONE=$(grep -c \'\\[x\\]\' "$PLAN_FILE" 2>/dev/null || true)');
+    if (broken === original) {
+      console.error('✗ B3: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(sp, broken);
+      assert('unanchored grep → savepoint task test fails', false, () => run('B3', 'bun run test -- savepoint -t "B3: task counting"'));
+    }
+  } finally {
+    writeFileSync(sp, original);
+    assert('restored → savepoint task test passes', true, () => run('B3-restore', 'bun run test -- savepoint -t "B3: task counting"'));
+  }
+}
+
+// --- B4: repo root — restore [ -d .git ] → lane subdirectory test fails ---
+console.log('\nB4 — repo root');
+{
+  const lane = join(root, 'scripts', 'lane.sh');
+  const original = readFileSync(lane, 'utf8');
+  try {
+    const broken = original.replace(
+      /# Resolve the repo root: handles subdirectories and git worktrees[\s\S]*?cd "\$REPO_ROOT" \|\| \{ echo "lane: cannot enter repo root" >&2; exit 1; \}/,
+      '[ -d .git ] || { echo "lane: not a git repository" >&2; exit 1; }'
+    );
+    if (broken === original) {
+      console.error('✗ B4: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(lane, broken);
+      assert('[ -d .git ] → lane subdirectory gate dead', false, () => run('B4', 'grep -q "git rev-parse --show-toplevel" scripts/lane.sh'));
+    }
+  } finally {
+    writeFileSync(lane, original);
+    assert('restored → lane uses git rev-parse', true, () => run('B4-restore', 'grep -q "git rev-parse --show-toplevel" scripts/lane.sh'));
+  }
+}
+
+// --- B5: spike budget — set below base → lane-base fails ---
+console.log('\nB5 — spike budget');
+{
+  const baseFile = join(root, 'scripts', 'lib', 'lane-base.sh');
+  const original = readFileSync(baseFile, 'utf8');
+  try {
+    const broken = original.replace('BUDGET_spike=9000', 'BUDGET_spike=3000');
+    if (broken === original) {
+      console.error('✗ B5: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(baseFile, broken);
+      assert('BUDGET_spike 3000 < LANE_BASE 5411 → lane-base fails', false, () => run('B5', 'bun scripts/lane-base.ts'));
+    }
+  } finally {
+    writeFileSync(baseFile, original);
+    assert('restored → lane-base passes', true, () => run('B5-restore', 'bun scripts/lane-base.ts'));
+  }
+}
+
+// --- B6: corrupt state — swallow parse errors again → status test fails ---
+console.log('\nB6 — corrupt state');
+{
+  const cont = join(root, 'src', 'continue.ts');
+  const original = readFileSync(cont, 'utf8');
+  try {
+    const broken = original.replace('unreadable.push(join(mission, f));', '// corrupt savepoint — skip, never crash the listing');
+    if (broken === original) {
+      console.error('✗ B6: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(cont, broken);
+      assert('swallow parse errors → unreadable gate dead', false, () => run('B6', 'grep -q "unreadableStateFiles" src/continue.ts && grep -q "unreadable.push" src/continue.ts'));
+    }
+  } finally {
+    writeFileSync(cont, original);
+    assert('restored → corrupt state surfaced', true, () => run('B6-restore', 'grep -q "unreadable.push" src/continue.ts'));
+  }
+}
+
+// --- B7: zero evidence — remove check → integrity team test fails ---
+console.log('\nB7 — zero evidence');
+{
+  const integ = join(root, 'src', 'integrity.ts');
+  const original = readFileSync(integ, 'utf8');
+  try {
+    const b7Pattern = /mission declares no evidence/;
+    const broken = original.replace(b7Pattern, 'ZERO_EVIDENCE_REMOVED');
+    if (!b7Pattern.test(original) || broken === original) {
+      console.error('✗ B7: mutation target not found — the gate it guards may be dead.');
+      failed++;
+    } else {
+      writeFileSync(integ, broken);
+      assert('no zero-evidence check → integrity gate dead', false, () => run('B7', 'grep -q "mission declares no evidence" src/integrity.ts'));
+    }
+  } finally {
+    writeFileSync(integ, original);
+    assert('restored → zero-evidence warned', true, () => run('B7-restore', 'grep -q "mission declares no evidence" src/integrity.ts'));
+  }
+}
+
+// --- W1: mode from config — revert to positional-only → gate fails ---
+console.log('\nW1 — mode from config');
+{
+  const sp = join(root, 'scripts', 'savepoint.sh');
+  const original = readFileSync(sp, 'utf8');
+  try {
+    const broken = original.replace(
+      /# mode: positional > env > project config > global config > guided[\s\S]*?MODE="\$\{MODE:-guided\}"/,
+      'MODE="${4:-${STATE_MODE:-guided}}"'
+    );
+    if (broken === original) {
+      console.error('✗ W1: mutation target not found');
+      failed++;
+    } else {
+      writeFileSync(sp, broken);
+      assert('reverted MODE → savepoint mode test fails', false, () => run('W1', 'grep -q "for _cfg in.*MUGIWARA_DIR/config" scripts/savepoint.sh'));
+    }
+  } finally {
+    writeFileSync(sp, original);
+    assert('restored → mode fallback present', true, () => run('W1-restore', 'grep -q "for _cfg in.*MUGIWARA_DIR/config" scripts/savepoint.sh'));
+  }
+}
+
+// --- W2: Solo-or-team section — remove → content validation fails ---
+console.log('\nW2 — Solo-or-team section');
+{
+  const f = join(root, 'content', 'skills', 'mugiwara-orchestration', 'SKILL.md');
+  const original = readFileSync(f, 'utf8');
+  try {
+    const broken = original.replace(/## Solo or team \(Flow 0\)[\s\S]*?## Request classifier/, '## Request classifier');
+    if (broken === original) {
+      console.error('✗ W2: mutation target not found');
+      failed++;
+    } else {
+      writeFileSync(f, broken);
+      assert('removed Solo-or-team → content validation fails', false, () => run('W2', 'grep -q "Solo or team" content/skills/mugiwara-orchestration/SKILL.md'));
+    }
+  } finally {
+    writeFileSync(f, original);
+    assert('restored → Solo-or-team present', true, () => run('W2-restore', 'grep -q "Solo or team" content/skills/mugiwara-orchestration/SKILL.md'));
+  }
+}
+
+// --- W4: allow layout switch without migrate → lane-integrity fails ---
+console.log('\nW4 — layout switch guard');
+{
+  const sp = join(root, 'scripts', 'savepoint.sh');
+  const original = readFileSync(sp, 'utf8');
+  try {
+    const broken = original.replace(/is solo \(state\.json exists\)/, 'REMOVED');
+    if (broken === original) {
+      console.error('✗ W4: mutation target not found');
+      failed++;
+    } else {
+      writeFileSync(sp, broken);
+      assert('guard removed → check fails', false, () => run('W4', 'grep -q "is solo (state.json exists)" scripts/savepoint.sh'));
+    }
+  } finally {
+    writeFileSync(sp, original);
+    assert('restored → guard present', true, () => run('W4-restore', 'grep -q "is solo (state.json exists)" scripts/savepoint.sh'));
+  }
+}
+
+// --- W7: remove posture import → --check-wiring fails ---
+console.log('\nW7 — wiring gate');
+{
+  const mf = join(root, 'src', 'mission.ts');
+  const original = readFileSync(mf, 'utf8');
+  try {
+    const broken = original.replace(/import \{ selectPosture \} from '\.\/posture\.ts';/, '// removed');
+    if (broken === original) {
+      console.error('✗ W7: mutation target not found');
+      failed++;
+    } else {
+      writeFileSync(mf, broken);
+      assert('removed posture import → --check-wiring fails', false, () => run('W7', 'bun scripts/validate-content.ts --check-wiring'));
+    }
+  } finally {
+    writeFileSync(mf, original);
+    assert('restored → wiring passes', true, () => run('W7-restore', 'bun scripts/validate-content.ts --check-wiring'));
+  }
+}
+
+// --- W11: delete lane_scope_glob from config.md → --check-config fails ---
+console.log('\nW11 — config drift');
+{
+  const cf = join(root, 'docs', 'concepts', 'config.md');
+  const original = readFileSync(cf, 'utf8');
+  try {
+    const broken = original.replace(/lane_scope_glob/g, 'LANE_REMOVED');
+    if (broken === original) {
+      console.error('✗ W11: mutation target not found');
+      failed++;
+    } else {
+      writeFileSync(cf, broken);
+      assert('removed lane_scope_glob → --check-config fails', false, () => run('W11', 'bun scripts/validate-content.ts --check-config'));
+    }
+  } finally {
+    writeFileSync(cf, original);
+    assert('restored → --check-config passes', true, () => run('W11-restore', 'bun scripts/validate-content.ts --check-config'));
+  }
+}
+
+// --- W15: paste raw JSONL into report.md → reporting test fails ---
+console.log('\nW15 — report raw JSONL');
+{
+  const mf = join(root, 'src', 'mission.ts');
+  const original = readFileSync(mf, 'utf8');
+  try {
+    const broken = original.replace(/\/\/ W15: no raw JSONL in report.*/, '  if (hasCostEvents) fold.push("cost-events.jsonl"); // W15 revert');
+    if (broken === original) {
+      console.error('✗ W15: mutation target not found');
+      failed++;
+    } else {
+      writeFileSync(mf, broken);
+      assert('reverted raw JSONL → check fails', false, () => run('W15', 'grep -q "hasCostEvents" src/mission.ts | grep -q "fold.push"'));
+    }
+  } finally {
+    writeFileSync(mf, original);
+    assert('restored → no raw JSONL', true, () => run('W15-restore', 'grep -q "no raw JSONL" src/mission.ts'));
+  }
+}
+
+// --- W12: point doc at state/<mission>/ → --check-doc-integrity fails ---
+console.log('\nW12 — doc integrity stale path');
+{
+  const ref = join(root, 'references', 'multi-actor.md');
+  const original = readFileSync(ref, 'utf8');
+  try {
+    const broken = original + '\n`state/<mission>/state.json`\n';
+    writeFileSync(ref, broken);
+    assert('stale path → --check-doc-integrity fails', false, () => run('W12', 'bun scripts/validate-content.ts --check-doc-integrity'));
+  } finally {
+    writeFileSync(ref, original);
+    assert('restored → doc-integrity passes', true, () => run('W12-restore', 'bun scripts/validate-content.ts --check-doc-integrity'));
+  }
+}
+
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed > 0 ? 1 : 0);

package/scripts/lane-base.ts

@@ -107,6 +107,22 @@ for (const lane of lanes) {
   }
 }
 
+// A lane whose base exceeds its budget is born in `warn` — the budget is then
+// noise rather than a signal. (B5)
+for (const lane of ['lean', 'standard', 'full', 'spike']) {
+  const base = constants[lane]?.base ?? 0;
+  const budget = constants[lane]?.budget ?? 0;
+  if (base >= budget) {
+    console.log(`  ✗ LANE_BASE_${lane} (${base}) >= BUDGET_${lane} (${budget}) — every mission starts over budget`);
+    failures++;
+  }
+  const pct = budget ? Math.round((base / budget) * 100) : 100;
+  if (pct > 80) {
+    console.log(`  ✗ LANE_BASE_${lane} is ${pct}% of BUDGET_${lane} — leaves no headroom (target ≤70%)`);
+    failures++;
+  }
+}
+
 if (failures > 0) {
   console.log(`\nlane-base: ${failures} constant(s) drifted from content load`);
   process.exit(1);

package/scripts/lane.sh

@@ -11,7 +11,11 @@ BASE="${1:-main}"
 JSON_OUT=0
 [ "${2:-}" = "--json" ] && JSON_OUT=1
 
-[ -d .git ] || { echo "lane: not a git repository" >&2; exit 1; }
+# Resolve the repo root: handles subdirectories and git worktrees, where .git
+# is a file rather than a directory. (B4)
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null) || {
+  echo "lane: not a git repository" >&2; exit 1; }
+cd "$REPO_ROOT" || { echo "lane: cannot enter repo root" >&2; exit 1; }
 
 # resolve base
 if ! git rev-parse "$BASE" >/dev/null 2>&1; then

package/scripts/lib/lane-base.sh

@@ -16,4 +16,4 @@ LANE_BASE_spike=5411
 BUDGET_lean=12000
 BUDGET_standard=25000
 BUDGET_full=50000
-BUDGET_spike=3000
+BUDGET_spike=9000