@ionivetech/mugiwara 0.5.5 → 0.6.1

package/scripts/evidence.sh

@@ -1,17 +1,39 @@
 #!/usr/bin/env bash
 # scripts/evidence.sh — run a check and capture its evidence.
-# Usage: evidence.sh <label> [-- command args...]
-# output: .mugiwara/results/<label>-<hash>.log
+# Usage: evidence.sh <mission> <label> [-- command args...]
+# output: .mugiwara/results/<mission>/<label>-<hash>.log
 set -u
 
 die() { echo "evidence: $*" >&2; exit 1; }
 
-LABEL="${1:-}"
-shift 2>/dev/null || true
-[ -z "$LABEL" ] && die "usage: evidence.sh <label> [-- command args...]"
+MISSION="${1:-}"
+LABEL="${2:-}"
+shift 2 2>/dev/null || true
+
+# strip an optional "--" separator between <label> and the command
+[ "${1:-}" = "--" ] && shift
+
+[ -z "$MISSION" ] && die "usage: evidence.sh <mission> <label> [-- command args...]"
+[ -z "$LABEL" ] && die "usage: evidence.sh <mission> <label> [-- command args...]"
+
+# mission allowlist — path-traversal guard (same rule as mission-report.sh)
+case "$MISSION" in
+  *[!a-zA-Z0-9._-]*) die "invalid mission name \"$MISSION\" (allowlist: [a-zA-Z0-9._-])" ;;
+esac
+
+# label allowlist — LABEL feeds the output filename; traversal or shell
+# metacharacters must not reach the filesystem (same rule as MISSION)
+case "$LABEL" in
+  *[!a-zA-Z0-9._-]*) die "invalid label \"$LABEL\" (allowlist: [a-zA-Z0-9._-])" ;;
+esac
+# dot-only labels (".", "..", "...") pass the char allowlist but escape the
+# results dir — reject them before any filename is built from LABEL.
+if [[ "$LABEL" =~ ^\.+$ ]]; then
+  die "invalid label \"$LABEL\" (allowlist: [a-zA-Z0-9._-], not a dot-path)"
+fi
 
 MUGIWARA_DIR="${MUGIWARA_DIR:-.mugiwara}"
-RESULTS_DIR="$MUGIWARA_DIR/results"
+RESULTS_DIR="$MUGIWARA_DIR/results/$MISSION"
 mkdir -p "$RESULTS_DIR"
 
 TIMESTAMP=$(date +%Y%m%d-%H%M%S)

package/scripts/gate-selftest.ts

@@ -0,0 +1,317 @@
+#!/usr/bin/env bun
+// scripts/gate-selftest.ts — G2: prove each gate can fail.
+// Mutate → assert RED → restore → assert GREEN. Exit 0 when all pass.
+
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, copyFileSync, renameSync, unlinkSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const root = join(import.meta.dirname, '..');
+let passed = 0;
+let failed = 0;
+
+function run(name: string, cmd: string): boolean {
+  try { execSync(cmd, { cwd: root, stdio: 'pipe', timeout: 60000 }); return true; }
+  catch { return false; }
+}
+
+function assert(name: string, shouldSucceed: boolean, fn: () => boolean) {
+  const ok = fn() === shouldSucceed;
+  if (ok) { passed++; console.log(`  ✓ ${name}`); }
+  else { failed++; console.log(`  ✗ ${name}`); }
+}
+
+// --- G1: verify-install — delete one shared ref, prove gate fails ---
+console.log('\nG1 — verify-install');
+if (!existsSync(join(root, 'scripts', 'verify-install.ts'))) {
+  console.log('  ⚠  verify-install.ts not found, skipping');
+} else {
+  const refFile = join(root, 'references', 'source-grounding.md');
+  const backup = join(root, 'references', 'source-grounding.md.bak');
+  const text = readFileSync(refFile, 'utf8');
+  try {
+    renameSync(refFile, backup);
+    assert('broken pointer → exit 1', false, () => run('G1', 'bun scripts/verify-install.ts'));
+  } finally {
+    writeFileSync(refFile, text);
+    if (existsSync(backup)) unlinkSync(backup);
+    assert('restored → exit 0', true, () => run('G1', 'bun scripts/verify-install.ts'));
+  }
+}
+
+// --- G4: section-length — create SKILL.md with 25-line section ---
+console.log('\nG4 — section-length');
+if (!existsSync(join(root, 'scripts', 'validate-content.ts'))) {
+  console.log('  ⚠  validate-content.ts not found, skipping');
+} else {
+  const tmpDir = mkdtempSync(join(tmpdir(), 'mugi-g4-'));
+  try {
+    const skillDir = join(tmpDir, 'skills', 'test-skill');
+    mkdirSync(skillDir, { recursive: true });
+    const skillFile = join(skillDir, 'SKILL.md');
+
+    const makeBody = (sectionLines: number) => {
+      let body = '---\nname: test-skill\ndescription: Test skill for section-length gate, twenty chars\n---\n\n# Test\n\n## Skip when\n\n- Test\n\n## Long Section\n\n';
+      for (let i = 0; i < sectionLines; i++) body += `Line ${i + 1} of content for section length test.\n`;
+      body += '\n## Red flags\n\n- Test flag\n';
+      return body;
+    };
+
+    writeFileSync(skillFile, makeBody(25));
+    assert('section ≥20 lines → exit 1', false, () => run('G4', `bun scripts/validate-content.ts --check ${skillFile}`));
+
+    writeFileSync(skillFile, makeBody(5));
+    assert('short section → exit 0', true, () => run('G4', `bun scripts/validate-content.ts --check ${skillFile}`));
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+// --- G3: savepoint fixtures — prove test fails when a field is broken ---
+console.log('\nG3 — savepoint fixtures');
+if (!existsSync(join(root, 'test', 'savepoint.test.ts'))) {
+  console.log('  ⚠  savepoint.test.ts not found, skipping');
+} else {
+  const testFile = join(root, 'test', 'savepoint.test.ts');
+  const original = readFileSync(testFile, 'utf8');
+  try {
+    // Break one assertion: change lane validation to expect a wrong value
+    const broken = original.replace(
+      "expect(['direct', 'lean', 'standard', 'full', 'spike']).toContain(state.lane)",
+      "expect(state.lane).toBe('NONEXISTENT')"
+    );
+    writeFileSync(testFile, broken);
+    assert('broken assertion → gate fails', false, () => run('G3', 'bun run test -- savepoint'));
+  } finally {
+    writeFileSync(testFile, original);
+    assert('restored → gate passes', true, () => run('G3', 'bun run test -- savepoint'));
+  }
+}
+
+// --- Retrieval eval ratchet ---
+console.log('\nRetrieval eval ratchet');
+if (!existsSync(join(root, 'scripts', 'retrieval-eval.ts'))) {
+  console.log('  ⚠  retrieval-eval.ts not found, skipping');
+} else {
+  // Strip trigger words from one skill description to break retrieval
+  const orchestrationFile = join(root, 'content', 'skills', 'mugiwara-orchestration', 'SKILL.md');
+  if (existsSync(orchestrationFile)) {
+    const original = readFileSync(orchestrationFile, 'utf8');
+    try {
+      const broken = original.replace(/description:.*/, 'description: Does stuff.');
+      writeFileSync(orchestrationFile, broken);
+      assert('stripped description → ratchet fails', false, () => run('retrieval', 'bun scripts/retrieval-eval.ts'));
+    } finally {
+      writeFileSync(orchestrationFile, original);
+      assert('restored → ratchet passes', true, () => run('retrieval', 'bun scripts/retrieval-eval.ts'));
+    }
+  }
+}
+
+// --- Manifest sync ---
+console.log('\nManifest sync');
+const manifestFile = join(root, '.claude-plugin', 'plugin.json');
+if (!existsSync(manifestFile)) {
+  console.log('  ⚠  manifest not found, skipping');
+} else {
+  const original = readFileSync(manifestFile, 'utf8');
+  try {
+    const mdata = JSON.parse(original);
+    const skills: string[] = mdata.metadata.skills;
+    const removed = skills.shift()!;
+    writeFileSync(manifestFile, JSON.stringify(mdata, null, 2));
+    assert('missing skill → exit 1', false, () => run('manifest', 'bun scripts/validate-content.ts --check-manifest'));
+  } finally {
+    writeFileSync(manifestFile, original);
+    assert('restored → exit 0', true, () => run('manifest', 'bun scripts/validate-content.ts --check-manifest'));
+  }
+}
+
+// --- Docs drift ---
+console.log('\nDocs drift');
+const skillsDoc = join(root, 'docs', 'concepts', 'skills.md');
+if (!existsSync(skillsDoc)) {
+  console.log('  ⚠  docs/skills.md not found, skipping');
+} else {
+  const original = readFileSync(skillsDoc, 'utf8');
+  try {
+    // remove every occurrence of mugiwara-frontend entirely
+    const broken = original.replace(/mugiwara-frontend/g, '');
+    writeFileSync(skillsDoc, broken);
+    assert('removed skill mention → exit 1', false, () => run('docs', 'bun scripts/validate-content.ts --check-docs'));
+  } finally {
+    writeFileSync(skillsDoc, original);
+    assert('restored → exit 0', true, () => run('docs', 'bun scripts/validate-content.ts --check-docs'));
+  }
+}
+
+// --- Index budget ---
+console.log('\nIndex budget');
+const usingSkillFile = join(root, 'content', 'skills', 'using-mugiwara', 'SKILL.md');
+if (!existsSync(usingSkillFile)) {
+  console.log('  ⚠  using-mugiwara not found, skipping');
+} else {
+  const original = readFileSync(usingSkillFile, 'utf8');
+  try {
+    // Push budget way past 5500
+    const longDesc = 'A'.repeat(6000);
+    const broken = original.replace(/description:.*/, `description: ${longDesc}`);
+    writeFileSync(usingSkillFile, broken);
+    assert('description past budget → exit 1', false, () => run('budget', 'bun scripts/validate-content.ts'));
+  } finally {
+    writeFileSync(usingSkillFile, original);
+    assert('restored → exit 0', true, () => run('budget', 'bun scripts/validate-content.ts --check-manifest --check-docs'));
+  }
+}
+
+// --- Eval coverage ---
+console.log('\nEval coverage');
+const evalDir = join(root, 'evals', 'cases');
+if (!existsSync(evalDir)) {
+  console.log('  ⚠  evals/cases not found, skipping');
+} else {
+  assert('eval cases present → run-evals exits 0', true, () => run('evals', 'bun scripts/run-evals.ts'));
+}
+
+// --- F2: write-scope gate — remove write-scope from one agent, prove red ---
+console.log('\nF2 — write-scope gate');
+const scopeAgent = join(root, 'content', 'agents', 'nami-planner.md');
+if (!existsSync(scopeAgent)) {
+  console.log('  ⚠  nami-planner.md not found, skipping');
+} else {
+  const original = readFileSync(scopeAgent, 'utf8');
+  try {
+    const broken = original.replace(/\nwrite-scope: artifacts/, '');
+    writeFileSync(scopeAgent, broken);
+    assert('missing write-scope → exit 1', false, () => run('F2-scope', 'bun scripts/validate-content.ts'));
+  } finally {
+    writeFileSync(scopeAgent, original);
+    assert('restored → exit 0', true, () => run('F2-scope', 'bun scripts/validate-content.ts --check-manifest --check-docs'));
+  }
+}
+
+// --- F2: source-scope on non-executor agent — prove red ---
+console.log('\nF2 — source-scope restriction');
+const plannerAgent = join(root, 'content', 'agents', 'nami-planner.md');
+if (!existsSync(plannerAgent)) {
+  console.log('  ⚠  nami-planner.md not found, skipping');
+} else {
+  const original = readFileSync(plannerAgent, 'utf8');
+  try {
+    const broken = original.replace('write-scope: artifacts', 'write-scope: source');
+    writeFileSync(plannerAgent, broken);
+    assert('source on non-executor → exit 1', false, () => run('F2-source', 'bun scripts/validate-content.ts'));
+  } finally {
+    writeFileSync(plannerAgent, original);
+    assert('restored → exit 0', true, () => run('F2-source', 'bun scripts/validate-content.ts --check-manifest --check-docs'));
+  }
+}
+
+// --- F3: remove Return-to-Luffy from one agent — prove red ---
+console.log('\nF3 — hub rule gate');
+const hubAgent = join(root, 'content', 'agents', 'robin-reviewer.md');
+if (!existsSync(hubAgent)) {
+  console.log('  ⚠  robin-reviewer.md not found, skipping');
+} else {
+  const original = readFileSync(hubAgent, 'utf8');
+  try {
+    const broken = original.replace(/## Return to Luffy\n\n[\s\S]*?(?=\n## )/, '\n');
+    writeFileSync(hubAgent, broken);
+    assert('missing Return-to-Luffy → exit 1', false, () => run('F3-hub', 'bun scripts/validate-content.ts'));
+  } finally {
+    writeFileSync(hubAgent, original);
+    assert('restored → exit 0', true, () => run('F3-hub', 'bun scripts/validate-content.ts --check-manifest --check-docs'));
+  }
+}
+
+// --- F3: hub-skill gate — every agent must list mugiwara-orchestration; strip it, prove red ---
+console.log('\nF3 — hub-skill gate');
+const hubSkillAgent = join(root, 'content', 'agents', 'sanji-quality.md');
+if (!existsSync(hubSkillAgent)) {
+  console.log('  ⚠  sanji-quality.md not found, skipping');
+} else {
+  const original = readFileSync(hubSkillAgent, 'utf8');
+  try {
+    const broken = original.replace('mugiwara-orchestration, ', '').replace(', mugiwara-orchestration', '');
+    writeFileSync(hubSkillAgent, broken);
+    assert('orchestration skill stripped → exit 1', false, () => run('F3-skill', 'bun scripts/validate-content.ts'));
+  } finally {
+    writeFileSync(hubSkillAgent, original);
+    assert('restored → exit 0', true, () => run('F3-skill', 'bun scripts/validate-content.ts --check-manifest --check-docs'));
+  }
+}
+
+// --- F4: reintroduce handoff leak — prove red ---
+console.log('\nF4 — handoff-target gate');
+const brainstormSkill = join(root, 'content', 'skills', 'mugiwara-brainstorm', 'SKILL.md');
+if (!existsSync(brainstormSkill)) {
+  console.log('  ⚠  mugiwara-brainstorm/SKILL.md not found, skipping');
+} else {
+  const original = readFileSync(brainstormSkill, 'utf8');
+  try {
+    const broken = original.replace(
+      'and return to Luffy, who routes to Nami or Zoro.',
+      'and hand to Nami (mugiwara-planning) via the main thread.'
+    );
+    writeFileSync(brainstormSkill, broken);
+    assert('handoff leak → exit 1', false, () => run('F4-handoff', 'bun scripts/validate-content.ts'));
+  } finally {
+    writeFileSync(brainstormSkill, original);
+    assert('restored → exit 0', true, () => run('F4-handoff', 'bun scripts/validate-content.ts --check-manifest --check-docs'));
+  }
+}
+
+// --- F2: red-flags gate — strip the heading from one skill, prove red ---
+console.log('\nF2 — red-flags gate');
+const redSkill = join(root, 'content', 'skills', 'mugiwara-workflow', 'SKILL.md');
+if (!existsSync(redSkill)) {
+  console.log('  ⚠  mugiwara-workflow/SKILL.md not found, skipping');
+} else {
+  const original = readFileSync(redSkill, 'utf8');
+  try {
+    const broken = original.replace('## Red flags', '## Disabled');
+    writeFileSync(redSkill, broken);
+    assert('missing Red flags → exit 1', false, () => run('F2-redflags', 'bun scripts/validate-content.ts'));
+  } finally {
+    writeFileSync(redSkill, original);
+    assert('restored → exit 0', true, () => run('F2-redflags', 'bun scripts/validate-content.ts --check-manifest --check-docs'));
+  }
+}
+
+// --- W1: write-boundary gate — strip the section, prove red ---
+console.log('\nW1 — write-boundary gate');
+const wbSkill = join(root, 'content', 'skills', 'mugiwara-orchestration', 'SKILL.md');
+if (!existsSync(wbSkill)) {
+  console.log('  ⚠  mugiwara-orchestration/SKILL.md not found, skipping');
+} else {
+  const original = readFileSync(wbSkill, 'utf8');
+  try {
+    const broken = original.replace('## Write boundary', '## Boundary');
+    writeFileSync(wbSkill, broken);
+    assert('missing write boundary → exit 1', false, () => run('W1-wb', 'bun scripts/validate-content.ts'));
+  } finally {
+    writeFileSync(wbSkill, original);
+    assert('restored → exit 0', true, () => run('W1-wb', 'bun scripts/validate-content.ts --check-manifest --check-docs'));
+  }
+}
+
+// --- F14: agent-count gate — flip an internal agent to user-facing, prove red ---
+console.log('\nF14 — agent-count gate');
+const countAgent = join(root, 'content', 'agents', 'eval-runner.md');
+if (!existsSync(countAgent)) {
+  console.log('  ⚠  eval-runner.md not found, skipping');
+} else {
+  const original = readFileSync(countAgent, 'utf8');
+  try {
+    const broken = original.replace('internal: true', 'internal: false');
+    writeFileSync(countAgent, broken);
+    assert('count drift → exit 1', false, () => run('F14-count', 'bun scripts/validate-content.ts'));
+  } finally {
+    writeFileSync(countAgent, original);
+    assert('restored → exit 0', true, () => run('F14-count', 'bun scripts/validate-content.ts --check-manifest --check-docs'));
+  }
+}
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/scripts/initiative.ts

@@ -0,0 +1,262 @@
+#!/usr/bin/env bun
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+const USAGE = `initiative — team sub-mission coordination for mugiwara plans
+
+Usage:
+  bun run scripts/initiative.ts status <plan-file>
+  bun run scripts/initiative.ts conflict-check <plan-file>
+  bun run scripts/initiative.ts set-status <plan-file> --id <id> --status <pending|in-progress|done|blocked>
+
+Commands:
+  status          Parse Sub-missions table, render ASCII dashboard
+  conflict-check  Detect overlapping Touched Files across in-progress sub-missions
+  set-status      Update status marker for a sub-mission row
+`;
+
+interface SubMission {
+  id: string;
+  name: string;
+  assignee: string;
+  branch: string;
+  status: string;
+  dependsOn: string;
+  touchedFiles: string[];
+}
+
+const STATUS_MARKERS: Record<string, string> = {
+  pending: '[ ]',
+  'in-progress': '[~]',
+  done: '[x]',
+  blocked: '[!]',
+};
+
+function resolvePlan(planFile: string): string {
+  const resolved = resolve(process.cwd(), planFile);
+  if (existsSync(resolved)) return resolved;
+
+  const plansDir = join(process.cwd(), '.mugiwara', 'plans');
+  const plansPath = join(plansDir, planFile.endsWith('.md') ? planFile : `${planFile}.md`);
+  if (existsSync(plansPath)) return plansPath;
+  if (!planFile.endsWith('.md') && existsSync(join(plansDir, planFile))) return join(plansDir, planFile);
+
+  const alt = join(plansDir, `${planFile}.md`);
+  const err = `Plan not found: "${planFile}" (tried: ${resolved}, ${plansPath}, ${alt})`;
+  throw new Error(err);
+}
+
+// A plan is a markdown document. Garbage (no markdown structure) is not a
+// "solo mission" — it is a malformed plan. Heading check keeps the
+// no-sub-missions-but-valid-markdown case working as solo mission.
+function assertPlanContent(content: string, planFile: string): void {
+  if (!/^#{1,6}\s/m.test(content)) {
+    throw new Error(`Not a valid plan file: "${planFile}" — expected markdown (no heading found)`);
+  }
+}
+
+function parseSubMissions(content: string): SubMission[] {
+  const lines = content.split('\n');
+  let inTable = false;
+  let inSubSection = false;
+  const subs: SubMission[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith('## Sub-missions')) {
+      inSubSection = true;
+      continue;
+    }
+    if (inSubSection && line.startsWith('## ') && !line.startsWith('## Sub-missions')) {
+      break;
+    }
+    if (!inSubSection) continue;
+
+    const trimmed = line.trim();
+    if (trimmed.startsWith('| ID ') && trimmed.includes('| Name ')) {
+      inTable = true;
+      continue;
+    }
+    if (inTable && trimmed.startsWith('|---')) continue;
+    if (inTable && trimmed.startsWith('|')) {
+      const cols = trimmed.split('|').map(c => c.trim()).filter(Boolean);
+      if (cols.length >= 6) {
+        subs.push({
+          id: cols[0],
+          name: cols[1],
+          assignee: cols[2],
+          branch: cols[3],
+          status: cols[4],
+          dependsOn: cols[5],
+          touchedFiles: cols.slice(6).join(' ').split(/\s+/).filter(Boolean),
+        });
+      }
+    }
+    if (inTable && !trimmed.startsWith('|')) {
+      inTable = false;
+    }
+  }
+
+  return subs;
+}
+
+function cmdStatus(planFile: string): void {
+  const content = readFileSync(planFile, 'utf8');
+  assertPlanContent(content, planFile);
+  const subs = parseSubMissions(content);
+
+  if (subs.length === 0) {
+    console.log('No sub-missions found — solo mission.');
+    return;
+  }
+
+  const doneCount = subs.filter(s => s.status === '[x]').length;
+  const total = subs.length;
+  const pct = Math.round((doneCount / total) * 100);
+  const barLen = 20;
+  const filled = Math.round((doneCount / total) * barLen);
+  const bar = '█'.repeat(filled) + '░'.repeat(barLen - filled);
+
+  console.log(`\n${doneCount}/${total} done [${bar}] ${pct}%\n`);
+  console.log(`${'ID'.padEnd(8)} ${'Name'.padEnd(20)} ${'Assignee'.padEnd(12)} ${'Branch'.padEnd(28)} ${'Status'.padEnd(8)} ${'Depends'.padEnd(10)} ${'Files'}`);
+  console.log('─'.repeat(120));
+
+  for (const s of subs) {
+    const icon = { '[ ]': '◻', '[~]': '◉', '[x]': '✓', '[!]': '✗' }[s.status] || '?';
+    console.log(
+      `${s.id.padEnd(8)} ${s.name.padEnd(20)} ${s.assignee.padEnd(12)} ${s.branch.padEnd(28)} ${icon} ${s.status.padEnd(3)} ${s.dependsOn.padEnd(10)} ${s.touchedFiles.join(', ')}`
+    );
+  }
+  console.log();
+}
+
+function cmdConflictCheck(planFile: string): void {
+  const content = readFileSync(planFile, 'utf8');
+  assertPlanContent(content, planFile);
+  const subs = parseSubMissions(content);
+
+  if (subs.length === 0) {
+    console.log('No sub-missions — no conflicts possible.');
+    return;
+  }
+
+  const active = subs.filter(s => s.status === '[~]');
+  if (active.length < 2) {
+    console.log('Fewer than 2 in-progress sub-missions — no conflicts to check.');
+    return;
+  }
+
+  const fileToSubs = new Map<string, string[]>();
+  for (const s of active) {
+    for (const f of s.touchedFiles) {
+      const entries = fileToSubs.get(f) || [];
+      entries.push(s.id);
+      fileToSubs.set(f, entries);
+    }
+  }
+
+  const conflicts: string[] = [];
+  for (const [file, ids] of fileToSubs) {
+    if (ids.length > 1) {
+      conflicts.push(`  ⚠ ${file} — touched by: ${ids.join(', ')}`);
+    }
+  }
+
+  if (conflicts.length === 0) {
+    console.log('No file conflicts among in-progress sub-missions.');
+  } else {
+    console.log(`\n${conflicts.length} file conflict(s) detected:\n`);
+    console.log(conflicts.join('\n'));
+    console.log();
+  }
+}
+
+function cmdSetStatus(planFile: string, id: string, status: string): void {
+  if (!STATUS_MARKERS[status]) {
+    console.error(`Invalid status: "${status}". Use: pending, in-progress, done, blocked`);
+    process.exit(1);
+  }
+
+  const content = readFileSync(planFile, 'utf8');
+  assertPlanContent(content, planFile);
+  const lines = content.split('\n');
+  const newMarker = STATUS_MARKERS[status];
+  let inTable = false;
+  let inSubSection = false;
+  let found = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith('## Sub-missions')) {
+      inSubSection = true;
+      continue;
+    }
+    if (inSubSection && line.startsWith('## ') && !line.startsWith('## Sub-missions')) {
+      break;
+    }
+    if (!inSubSection) continue;
+
+    const trimmed = line.trim();
+    if (trimmed.startsWith('| ID ')) { inTable = true; continue; }
+    if (!inTable || !trimmed.startsWith('|')) continue;
+    if (trimmed.startsWith('|---')) continue;
+
+    const cols = trimmed.split('|').map(c => c.trim()).filter(Boolean);
+    if (cols[0] === id) {
+      const oldMarker = cols[4];
+      if (!Object.values(STATUS_MARKERS).includes(oldMarker)) {
+        console.error(`Row ${id}: status column "${oldMarker}" is not a recognized marker`);
+        process.exit(1);
+      }
+      lines[i] = lines[i].replace(oldMarker, newMarker);
+      found = true;
+      break;
+    }
+  }
+
+  if (!found) {
+    console.error(`Sub-mission "${id}" not found in Sub-missions table.`);
+    process.exit(1);
+  }
+
+  writeFileSync(planFile, lines.join('\n'));
+  console.log(`✓ ${id}: ${status}`);
+}
+
+// --- main ---
+
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+  console.log(USAGE);
+  process.exit(0);
+}
+
+const cmd = args[0];
+
+try {
+  if (cmd === 'status') {
+    if (args.length < 2) { console.error('Missing plan-file argument.'); process.exit(1); }
+    cmdStatus(resolvePlan(args[1]));
+  } else if (cmd === 'conflict-check') {
+    if (args.length < 2) { console.error('Missing plan-file argument.'); process.exit(1); }
+    cmdConflictCheck(resolvePlan(args[1]));
+  } else if (cmd === 'set-status') {
+    const idIdx = args.indexOf('--id');
+    const statusIdx = args.indexOf('--status');
+    if (idIdx === -1 || statusIdx === -1 || args.length < 6) {
+      console.error('set-status requires --id <id> --status <status>');
+      process.exit(1);
+    }
+    const id = args[idIdx + 1];
+    const statusVal = args[statusIdx + 1];
+    cmdSetStatus(resolvePlan(args[1]), id, statusVal);
+  } else {
+    console.error(`Unknown command: "${cmd}"`);
+    console.log(USAGE);
+    process.exit(1);
+  }
+} catch (err) {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+}

package/scripts/lane.sh

@@ -51,12 +51,29 @@ else
   REASON="$FILE_COUNT files"
 fi
 
-if [ "$HAS_SENSITIVE" -eq 1 ] && [ "$LANE" != "full" ]; then
+# Sensitive-path escalation is unconditional — it wins over any count-based
+# lane AND over the docs-only downgrade below (bug C9).
+if [ "$HAS_SENSITIVE" -eq 1 ]; then
   PREV="$LANE"
   LANE="full"
   REASON="sensitive paths ($SENSITIVE) — escalated from $PREV"
 fi
 
+# path-weighted sizing: docs-only changes (markdown/config/docs outside the
+# product surface) never escalate to full from file count alone — size by the
+# code surface actually touched. Sensitive-path escalation above still wins.
+# Product surface for mugiwara: content/, src/, scripts/, test/, hooks/,
+# .opencode/, .claude/, evals/ — everything else is docs/config/asset.
+PRODUCT_PAT="^content/|^src/|^scripts/|^test/|^hooks/|^\.opencode/|^\.claude/|^evals/"
+if [ "$LANE" = "full" ] && [ "$HAS_SENSITIVE" -eq 0 ] && [ -n "$CHANGED" ]; then
+  CODE_COUNT=$(echo "$CHANGED" | grep -E "$PRODUCT_PAT" 2>/dev/null | grep -c . || true)
+  if [ -z "$CODE_COUNT" ] || [ "$CODE_COUNT" -eq 0 ] 2>/dev/null; then
+    PREV="$LANE"
+    LANE="standard"
+    REASON="$FILE_COUNT files, docs-only — path-weighted down from $PREV"
+  fi
+fi
+
 if [ "$JSON_OUT" -eq 1 ]; then
   SENS_ARR=""
   [ -n "$SENSITIVE" ] && SENS_ARR=$(echo "$SENSITIVE" | tr ',' '\n' | sed 's/^/"/;s/$/"/' | tr '\n' ',' | sed 's/,$//')