@ionivetech/mugiwara 0.6.5 → 0.7.0

package/scripts/coverage-gate.ts

@@ -0,0 +1,193 @@
+#!/usr/bin/env bun
+// scripts/coverage-gate.ts — enforce the `coverage_new` / `coverage_modified`
+// thresholds declared in `.mugiwara/config` against the files THIS diff adds
+// and changes, not against a global project number. Two keys exist precisely
+// because the two populations are judged differently (mugiwara-gates SKILL.md
+// §Coverage gate); a global percentage would collapse them into one and let an
+// untested new file hide behind an old well-tested one.
+//
+// Run: bun scripts/coverage-gate.ts            enforce (gate step)
+//      bun scripts/coverage-gate.ts --base X   compare against ref X
+//      bun scripts/coverage-gate.ts --show     print per-file numbers, never fail
+//
+// Exit 0 = pass or recorded SKIP. Exit 1 = a threshold was missed.
+// A repo with no coverage tooling or no test suite records a SKIP with its
+// reason — never a fake pass (decision log row 50).
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join, relative, sep } from 'node:path';
+
+const root = join(import.meta.dirname, '..');
+const SHOW = process.argv.includes('--show');
+
+/** `.mugiwara/config` → project, then `~`. Returns undefined if the key is set nowhere. */
+function config(key: string): string | undefined {
+  for (const base of [root, homedir()]) {
+    const file = join(base, '.mugiwara', 'config');
+    if (!existsSync(file)) continue;
+    // \r?\n: a config written on Windows is still a config
+    for (const line of readFileSync(file, 'utf8').split(/\r?\n/)) {
+      const t = line.trim();
+      if (!t || t.startsWith('#')) continue;
+      const eq = t.indexOf('=');
+      if (eq === -1) continue;
+      if (t.slice(0, eq).trim() !== key) continue;
+      return t.slice(eq + 1).trim();
+    }
+  }
+  return undefined;
+}
+
+/** Documented defaults: new >= 90, modified >= 80. A key set to 0 = no threshold. */
+function threshold(key: string, fallback: number): number {
+  const raw = config(key);
+  if (raw === undefined || raw === '') return fallback;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0 || n > 100) {
+    console.log(`coverage-gate: ignoring unparseable ${key}="${raw}", using ${fallback}`);
+    return fallback;
+  }
+  return n;
+}
+
+function skip(reason: string): never {
+  console.log(`coverage-gate: SKIP — ${reason}`);
+  process.exit(0);
+}
+
+function git(args: string[]): string {
+  return execFileSync('git', args, { cwd: root, encoding: 'utf8' }).trim();
+}
+
+// ---- 1. is there anything to measure at all? -------------------------------
+
+const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+if (!deps['@vitest/coverage-v8'] && !deps['@vitest/coverage-istanbul'])
+  skip('no coverage tooling installed (no @vitest/coverage-* in package.json)');
+if (!existsSync(join(root, 'test')))
+  skip('no test suite found (no test/ directory)');
+
+// ---- 2. which files does this diff add and change? ------------------------
+
+const baseArg = process.argv.indexOf('--base');
+let base = baseArg !== -1 ? process.argv[baseArg + 1] : process.env.MUGIWARA_COVERAGE_BASE;
+if (!base) {
+  // the mission's own recorded base_sha is the truthful diff origin
+  const missionsDir = join(root, '.mugiwara', 'missions');
+  if (existsSync(missionsDir)) {
+    for (const m of readdirSync(missionsDir)) {
+      const f = join(missionsDir, m, 'state.json');
+      if (!existsSync(f)) continue;
+      const sha = JSON.parse(readFileSync(f, 'utf8')).base_sha;
+      if (sha) { base = sha; break; }
+    }
+  }
+}
+if (!base) {
+  for (const ref of ['origin/main', 'main', 'origin/master', 'master']) {
+    try { base = git(['merge-base', 'HEAD', ref]); break; } catch { /* next */ }
+  }
+}
+if (!base) skip('no diff base could be resolved (no state base_sha, no main/master ref)');
+
+let changed: Array<{ status: string; path: string }>;
+try {
+  changed = git(['diff', '--name-status', '--diff-filter=AMR', '-M', `${base}`, 'HEAD'])
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((l) => {
+      const parts = l.split('\t');
+      // rename rows are `R096\told\tnew` — the new path is the one to judge
+      return { status: parts[0][0], path: parts[parts.length - 1] };
+    });
+} catch (e) {
+  skip(`git diff against ${base} failed (${(e as Error).message})`);
+}
+
+if (!changed.length) skip(`no added or modified files between ${base.slice(0, 7)} and HEAD`);
+
+// ---- 3. measure ------------------------------------------------------------
+
+const summaryPath = join(root, 'coverage', 'coverage-summary.json');
+const needsRun =
+  !existsSync(summaryPath) ||
+  statSync(summaryPath).mtimeMs < Math.max(...changed
+    .map((c) => join(root, c.path))
+    .filter(existsSync)
+    .map((p) => statSync(p).mtimeMs), 0);
+
+if (needsRun) {
+  console.log('coverage-gate: measuring (vitest run --coverage)...');
+  const r = spawnSync('npx', ['vitest', 'run', '--coverage', '--silent'], {
+    cwd: root, stdio: 'inherit', shell: process.platform === 'win32',
+  });
+  if (r.status !== 0) {
+    console.log('coverage-gate: FAIL — test run did not pass, coverage is not measurable');
+    process.exit(1);
+  }
+}
+if (!existsSync(summaryPath))
+  skip('coverage run produced no coverage-summary.json (json-summary reporter not configured)');
+
+const summary = JSON.parse(readFileSync(summaryPath, 'utf8'));
+// keys are absolute OS paths; normalise to repo-relative posix to match git
+const measured = new Map<string, number>();
+for (const [k, v] of Object.entries<any>(summary)) {
+  if (k === 'total') continue;
+  measured.set(relative(root, k).split(sep).join('/'), v.lines?.pct ?? 0);
+}
+
+// ---- 4. apply the two thresholds ------------------------------------------
+// Policy as code: mugiwara.policy.yml gates.coverage can RAISE a
+// threshold — the max of config and policy wins, never lower.
+
+const { loadPolicy, effectiveThreshold } = await import('../src/policy.ts');
+let policyCoverage: { new?: number; modified?: number } | undefined;
+try {
+  const policy = loadPolicy(root);
+  policyCoverage = policy?.gates?.coverage;
+  if (policy?.gates?.require_human_approval?.length)
+    console.log(`coverage-gate: policy requires human approval on: ${policy.gates.require_human_approval.join(', ')}`);
+} catch (e) {
+  console.log(`coverage-gate: ${(e as Error).message}`);
+  process.exit(1);
+}
+
+const NEW = effectiveThreshold(threshold('coverage_new', 90), policyCoverage?.new);
+const MOD = effectiveThreshold(threshold('coverage_modified', 80), policyCoverage?.modified);
+
+const rows = changed.map((c) => {
+  const isNew = c.status === 'A';
+  return {
+    path: c.path,
+    kind: isNew ? 'new' : 'modified',
+    limit: isNew ? NEW : MOD,
+    pct: measured.get(c.path),
+  };
+});
+
+const scoped = rows.filter((r) => r.pct !== undefined);
+const unscoped = rows.filter((r) => r.pct === undefined);
+
+console.log(`coverage-gate: base ${base.slice(0, 7)} · thresholds new>=${NEW || 'off'} modified>=${MOD || 'off'}`);
+console.log(`  ${changed.length} changed file(s), ${scoped.length} within coverage scope, ${unscoped.length} outside it`);
+
+const failures = scoped.filter((r) => r.limit > 0 && (r.pct as number) < r.limit);
+
+for (const r of scoped.sort((a, b) => (a.pct as number) - (b.pct as number))) {
+  const bad = r.limit > 0 && (r.pct as number) < r.limit;
+  if (SHOW || bad || (r.pct as number) < 100)
+    console.log(`  ${bad ? '✗' : '✓'} ${r.path} — ${(r.pct as number).toFixed(2)}% ${r.kind} (limit ${r.limit || 'off'})`);
+}
+if (SHOW && unscoped.length)
+  console.log(unscoped.map((r) => `  · ${r.path} — outside coverage scope (not a measured source file)`).join('\n'));
+
+if (SHOW) process.exit(0);
+if (failures.length) {
+  console.log(`\ncoverage-gate: FAIL — ${failures.length} file(s) below their threshold`);
+  console.log('Do not lower the thresholds or exclude files to pass: add the missing tests.');
+  process.exit(1);
+}
+console.log('\ncoverage-gate: PASS');

package/scripts/gate-selftest.ts

@@ -12,7 +12,7 @@ let passed = 0;
 let failed = 0;
 
 function run(name: string, cmd: string): boolean {
-  try { execSync(cmd, { cwd: root, stdio: 'pipe', timeout: 60000 }); return true; }
+  try { execSync(cmd, { cwd: root, stdio: 'pipe', timeout: 180000 }); return true; }
   catch { return false; }
 }
 
@@ -82,6 +82,28 @@ console.log('\nG5 — conditional-assertion guard');
   }
 }
 
+// --- Cost gate: prove a drifted stated index size goes red -------------------
+// validate-content fails when docs/concepts/cost.md's "**Current:** N chars"
+// disagrees with the measured skill+agent description total. Without this
+// mutation the gate is unproven — a gate that cannot fail is not a gate.
+console.log('\nCost gate — measured vs stated index chars');
+{
+  const costFile = join(root, 'docs', 'concepts', 'cost.md');
+  const original = readFileSync(costFile, 'utf8');
+  try {
+    const drifted = original.replace(/\*\*Current:\*\* \d[\d,]* chars/, '**Current:** 1 chars');
+    if (drifted === original) {
+      console.log('  ⚠  "**Current:** N chars" pattern not found in cost.md — skipping');
+    } else {
+      writeFileSync(costFile, drifted);
+      assert('drifted stated index chars → exit 1', false, () => run('COST', 'bun scripts/validate-content.ts'));
+    }
+  } finally {
+    writeFileSync(costFile, original);
+    assert('restored → exit 0', true, () => run('COST', 'bun scripts/validate-content.ts'));
+  }
+}
+
 // --- G3: savepoint fixtures — prove test fails when a field is broken ---
 console.log('\nG3 — savepoint fixtures');
 if (!existsSync(join(root, 'test', 'savepoint.test.ts'))) {
@@ -316,19 +338,19 @@ if (!existsSync(skillsDoc)) {
 
 // --- 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');
+const budgetSkillFile = join(root, 'content', 'skills', 'mugiwara-workflow', 'SKILL.md');
+if (!existsSync(budgetSkillFile)) {
+  console.log('  ⚠  mugiwara-workflow not found, skipping');
 } else {
-  const original = readFileSync(usingSkillFile, 'utf8');
+  const original = readFileSync(budgetSkillFile, 'utf8');
   try {
     // Push budget way past 5500
     const longDesc = 'A'.repeat(6000);
     const broken = original.replace(/description:.*/, `description: ${longDesc}`);
-    writeFileSync(usingSkillFile, broken);
+    writeFileSync(budgetSkillFile, broken);
     assert('description past budget → exit 1', false, () => run('budget', 'bun scripts/validate-content.ts'));
   } finally {
-    writeFileSync(usingSkillFile, original);
+    writeFileSync(budgetSkillFile, original);
     assert('restored → exit 0', true, () => run('budget', 'bun scripts/validate-content.ts --check-manifest --check-docs'));
   }
 }
@@ -481,5 +503,94 @@ if (!existsSync(countAgent)) {
   }
 }
 
+// --- CI: closure integrity gate — a secret in the trail must fail the archive ---
+console.log('\nCI — closure integrity gate');
+{
+  const tmp = mkdtempSync(join(tmpdir(), 'mugi-ci-'));
+  try {
+    const mdir = join(tmp, '.mugiwara', 'missions', 'selftest-mission');
+    mkdirSync(mdir, { recursive: true });
+    const cli = `bun src/cli.ts archive selftest-mission --project ${tmp}`;
+    // A mission with no trail at all archives fine (stub report path).
+    assert('clean stub → exit 0', true, () => run('CI-clean', cli));
+    // A planted secret must turn the gate red.
+    writeFileSync(join(mdir, 'report.md'), 'token = ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZ123456\n');
+    writeFileSync(join(mdir, 'state.json'), JSON.stringify({ mission: 'selftest-mission' }));
+    assert('planted secret → exit 1', false, () => run('CI-secret', cli));
+    unlinkSync(join(mdir, 'report.md'));
+    unlinkSync(join(mdir, 'state.json'));
+    assert('cleaned → exit 0', true, () => run('CI-clean2', cli));
+
+    // Context-budget gate: a ceiling that the trail exceeds must fail red.
+    writeFileSync(join(mdir, 'state.json'), JSON.stringify({ mission: 'selftest-mission' }));
+    writeFileSync(join(mdir, 'report.md'), 'x'.repeat(500) + '\n');
+    mkdirSync(join(tmp, '.mugiwara'), { recursive: true });
+    writeFileSync(join(tmp, '.mugiwara', 'config'), 'context_budget_chars=10\n');
+    assert('over context budget → exit 1', false, () => run('CI-budget', cli));
+    unlinkSync(join(tmp, '.mugiwara', 'config'));
+    assert('budget unset → exit 0', true, () => run('CI-budget2', cli));
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+// --- POLICY: an invalid mugiwara.policy.yml fails lane.sh closed ---
+console.log('\nPOLICY — fail-closed policy parsing');
+{
+  const repo = mkdtempSync(join(tmpdir(), 'mugi-policy-'));
+  // lane.sh must run INSIDE the sandbox repo, not this one
+  const runInRepo = (args: string): boolean => {
+    try { execSync(`bash ${join(root, 'scripts', 'lane.sh')} ${args}`, { cwd: repo, stdio: 'pipe', timeout: 60000 }); return true; }
+    catch { return false; }
+  };
+  try {
+    execSync('git init -q && git config user.email t@t.com && git config user.name T && git commit --allow-empty -qm base', { cwd: repo, stdio: 'pipe' });
+    writeFileSync(join(repo, 'changed.ts'), 'export {};\n');
+    // no policy file → normal behavior
+    assert('no policy → lane runs', true, () => runInRepo('HEAD --json'));
+    // unknown root key must fail loud, not silently disable itself
+    writeFileSync(join(repo, 'mugiwara.policy.yml'), 'lanez:\n  force_full: ["src/**"]\n');
+    assert('bogus policy key → exit 1', false, () => runInRepo('HEAD --json'));
+    // valid policy parses and can force full
+    writeFileSync(join(repo, 'mugiwara.policy.yml'), 'lanes:\n  force_full:\n    - "**/*.ts"\n');
+    assert('valid policy → lane runs', true, () => runInRepo('HEAD --json'));
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+  }
+}
+
+// --- T7: evidence-thin — fabricated PASS wave with empty body must fail ---
+console.log('\nT7 — evidence-thin gate');
+{
+  const tmp = mkdtempSync(join(tmpdir(), 'mugi-thin-'));
+  try {
+    const mdir = join(tmp, '.mugiwara', 'missions', 'selftest-thin');
+    mkdirSync(join(mdir, 'flows'), { recursive: true });
+    const cli = `bun src/cli.ts archive selftest-thin --project ${tmp}`;
+    writeFileSync(join(mdir, 'state.json'), JSON.stringify({ mission: 'selftest-thin', evidence: ['flows/04-gates.md'] }));
+    writeFileSync(join(mdir, 'report.md'), 'Verdict: PASS see [evidence](flows/04-gates.md)');
+    writeFileSync(join(mdir, 'flows', '04-gates.md'), 'all good'); // no command shape → thin
+    assert('fabricated PASS with empty body → exit 1', false, () => run('T7-thin', cli));
+    writeFileSync(join(mdir, 'flows', '04-gates.md'), 'ran `bun run test` → 2 passed, exit 0');
+    assert('with command output → exit 0', true, () => run('T7-good', cli));
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+// --- DOCLINKS: a relative .md link that does not resolve must fail the gate ---
+console.log('\nDOCLINKS — doc link resolution');
+{
+  const probe = join(root, 'docs', 'tmp-doclinks-probe.md');
+  try {
+    writeFileSync(probe, '[missing](./nowhere-at-all.md)\n');
+    assert('broken doc link → exit 1', false, () => run('DL-bad', 'bun scripts/check-doc-links.ts'));
+    unlinkSync(probe);
+    assert('cleaned → exit 0', true, () => run('DL-good', 'bun scripts/check-doc-links.ts'));
+  } finally {
+    if (existsSync(probe)) unlinkSync(probe);
+  }
+}
+
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed > 0 ? 1 : 0);

package/scripts/install.ps1

@@ -2,12 +2,13 @@
 $ErrorActionPreference = 'Stop'
 
 if (-not (Get-Command node -ErrorAction SilentlyContinue)) {
-  Write-Error 'mugiwara requires Node.js >= 20. Install it from https://nodejs.org first.'
+  Write-Error 'mugiwara requires Node.js >= 20.11. Install it from https://nodejs.org first.'
 }
 
-$major = [int](node -p 'process.versions.node.split(".")[0]')
-if ($major -lt 20) {
-  Write-Error "mugiwara requires Node.js >= 20 (found $(node --version))."
+# floor must match package.json "engines.node" exactly, and install.sh
+node -e 'const [a,b]=process.versions.node.split(".").map(Number);process.exit(a>20||(a===20&&b>=11)?0:1)'
+if ($LASTEXITCODE -ne 0) {
+  Write-Error "mugiwara requires Node.js >= 20.11 (found $(node --version))."
 }
 
 npx -y @ionivetech/mugiwara@latest @args

package/scripts/install.sh

@@ -4,13 +4,13 @@ set -euo pipefail
 PKG="@ionivetech/mugiwara"
 
 if ! command -v node >/dev/null 2>&1; then
-  echo "mugiwara requires Node.js >= 20. Install it first: https://nodejs.org" >&2
+  echo "mugiwara requires Node.js >= 20.11. Install it first: https://nodejs.org" >&2
   exit 1
 fi
 
-MAJOR="$(node -p 'process.versions.node.split(".")[0]')"
-if [ "$MAJOR" -lt 20 ]; then
-  echo "mugiwara requires Node.js >= 20 (found $(node --version))." >&2
+# floor must match package.json "engines.node" exactly, and install.ps1
+if ! node -e 'const [a,b]=process.versions.node.split(".").map(Number);process.exit(a>20||(a===20&&b>=11)?0:1)'; then
+  echo "mugiwara requires Node.js >= 20.11 (found $(node --version))." >&2
   exit 1
 fi
 

package/scripts/lane.sh

@@ -19,13 +19,46 @@ if ! git rev-parse "$BASE" >/dev/null 2>&1; then
   [ -n "$ALT" ] && BASE="$ALT" || BASE="HEAD~1"
 fi
 
-CHANGED=$(git diff --name-only "$BASE"..HEAD 2>/dev/null || git diff --name-only --cached 2>/dev/null || true)
-FILE_COUNT=0
-[ -n "$CHANGED" ] && FILE_COUNT=$(echo "$CHANGED" | wc -l | tr -d ' ')
+# lane_scope_glob (T5): monorepo scoping — when set, count only files matching the glob
+LANE_SCOPE_GLOB=""
+if [ -f .mugiwara/config ]; then
+  CFG_SCOPE=$(grep -E '^lane_scope_glob=' .mugiwara/config 2>/dev/null | head -1 | cut -d= -f2- | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' | tr -d '"' | tr -d "'")
+  [ -n "$CFG_SCOPE" ] && LANE_SCOPE_GLOB="$CFG_SCOPE"
+fi
 
+# union of committed + staged + unstaged + untracked (F) — see patterns.sh
+CHANGED=$(changed_files "$BASE")
+# sensitive-path escalation always evaluates the unfiltered set (safety never shrinks)
 SENSITIVE=$(echo "$CHANGED" | grep -E "$SENSITIVE_PATS" 2>/dev/null | tr '\n' ',' | sed 's/,$//' || true)
 HAS_SENSITIVE=0
 [ -n "$SENSITIVE" ] && HAS_SENSITIVE=1
+# scoped count for lane sizing (T5)
+SCOPED="$CHANGED"
+if [ -n "$LANE_SCOPE_GLOB" ] && [ -n "$CHANGED" ]; then
+  shopt -s extglob globstar 2>/dev/null || true
+  SCOPED=""
+  while IFS= read -r _f; do
+    [ -z "$_f" ] && continue
+    # shellcheck disable=SC2053
+    if [[ "$_f" == $LANE_SCOPE_GLOB ]]; then
+      SCOPED="${SCOPED}${SCOPED:+
+}$_f"
+    fi
+  done <<< "$CHANGED"
+fi
+FILE_COUNT=0
+[ -n "$SCOPED" ] && FILE_COUNT=$(echo "$SCOPED" | wc -l | tr -d ' ')
+# LOC for the 1-file rule also scopes to the glob (otherwise a single in-scope
+# file with <20 LOC could be inflated by out-of-scope churn)
+if [ -n "$LANE_SCOPE_GLOB" ]; then
+  read -r ADDED_INS ADDED_DEL <<EOF
+$( { echo "$SCOPED" | while IFS= read -r _sf; do [ -n "$_sf" ] && git diff --numstat "$BASE"..HEAD -- "$_sf" 2>/dev/null; git diff --numstat HEAD -- "$_sf" 2>/dev/null; done; echo "$SCOPED" | while IFS= read -r _uf; do [ -z "$_uf" ] && continue; if git ls-files --others --exclude-standard -- "$_uf" 2>/dev/null | grep -qx "$_uf"; then printf '%s\t0\t%s\n' "$(wc -l < "$_uf" 2>/dev/null | tr -d ' ' || echo 0)" "$_uf"; fi; done; } | awk '{ if ($1 ~ /^[0-9]+$/) i+=$1; if ($2 ~ /^[0-9]+$/) d+=$2 } END { print (i+0)" "(d+0) }')
+EOF
+else
+  read -r ADDED_INS ADDED_DEL <<EOF
+$(changed_loc "$BASE")
+EOF
+fi
 
 # lane logic
 LANE="direct"
@@ -35,7 +68,7 @@ if [ "$FILE_COUNT" -eq 0 ] 2>/dev/null; then
   LANE="direct"
   REASON="no changed files"
 elif [ "$FILE_COUNT" -le 1 ] 2>/dev/null; then
-  ADDED=$(git diff --numstat "$BASE"..HEAD 2>/dev/null | awk '{s+=$1} END {print s+0}' || echo 0)
+  ADDED="${ADDED_INS:-0}"
   if [ "$ADDED" -lt 20 ] 2>/dev/null; then
     LANE="direct"
     REASON="1 file, <20 LOC"
@@ -67,8 +100,9 @@ fi
 # 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.
-if [ "$LANE" = "full" ] && [ "$HAS_SENSITIVE" -eq 0 ] && [ -n "$CHANGED" ]; then
-  CODE_COUNT=$(echo "$CHANGED" | grep -E "$PRODUCT_PAT" 2>/dev/null | grep -c . || true)
+# With lane_scope_glob the check applies to the scoped set — sensitive still wins unfiltered.
+if [ "$LANE" = "full" ] && [ "$HAS_SENSITIVE" -eq 0 ] && [ -n "$SCOPED" ]; then
+  CODE_COUNT=$(echo "$SCOPED" | 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"
@@ -76,6 +110,22 @@ if [ "$LANE" = "full" ] && [ "$HAS_SENSITIVE" -eq 0 ] && [ -n "$CHANGED" ]; then
   fi
 fi
 
+# policy as code: mugiwara.policy.yml lanes.force_full pushes the lane UP to
+# full — always upward, never downward, and it wins over the docs-only
+# downgrade above. Optional by design: no policy file (or no bun) = no-op.
+if command -v bun >/dev/null 2>&1 && { [ -f mugiwara.policy.yml ] || [ -f mugiwara.policy.yaml ]; }; then
+  POLICY_HITS=$(printf '%s\n' "$CHANGED" | bun "$(dirname "$0")/policy-force.ts")
+  RC=$?
+  if [ "$RC" -ne 0 ]; then
+    echo "lane: mugiwara.policy.yml is invalid — fix or remove it (fail-closed)" >&2
+    exit 1
+  fi
+  if [ -n "$POLICY_HITS" ]; then
+    LANE="full"
+    REASON="policy force_full ($POLICY_HITS)"
+  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/,$//')

package/scripts/lib/patterns.sh

@@ -19,3 +19,92 @@ SENSITIVE_PATS="auth/|oauth2?/|payment/|payments/|billing/|crypto/|secrets/|cred
 # outside this surface are docs/config/asset and never escalate to full on
 # count alone (path-weighted sizing).
 PRODUCT_PAT="^content/|^src/|^scripts/|^test/|^hooks/|^\.opencode/|^\.claude/|^evals/"
+
+# Installed-harness rules dirs — what `mugiwara install` writes into a project
+# (~50 files across the 9 targets). In a CONSUMER project these are installed
+# config, no different from the crew's own .mugiwara/ bookkeeping: the first
+# savepoint after an install counted them and sized every fresh mission Lane 3
+# before a single line of the user's own work existed. In MUGIWARA'S OWN repo
+# the same dirs are the product surface (they are in PRODUCT_PAT), so the
+# exclusion is conditional on the repo identity, never unconditional.
+# Unanchored on purpose — call sites anchor with ^ (name lists) or a tab
+# (numstat rows).
+HARNESS_PAT="\.claude/|\.opencode/|\.github/(instructions|agents)/|\.gemini/mugiwara/|\.codex/mugiwara/|\.devin/rules/|\.clinerules/|\.kilo/rules/|\.agents/rules/"
+
+# lane_scope_glob — optional monorepo scoping (T5). When set in .mugiwara/config
+# as e.g.  lane_scope_glob=packages/app/**  lane sizing counts only changed
+# files matching the glob; sensitive-path escalation still evaluates the
+# unfiltered set (safety never shrinks).
+
+# harness_excluded — true (exit 0) when harness rules dirs must NOT count
+# toward mission sizing, i.e. this repo is not mugiwara itself. Identity comes
+# from the repo root package.json name ("mugiwara" or "@scope/mugiwara"), the
+# same manifest savepoint already trusts for skill_version.
+harness_excluded() {
+  local root
+  root=$(git rev-parse --show-toplevel 2>/dev/null || echo .)
+  ! grep -qE '"name"[[:space:]]*:[[:space:]]*"(@[^"/]+/)?mugiwara"' "$root/package.json" 2>/dev/null
+}
+
+# drop_harness <anchor> — filter stdin, dropping harness paths in consumer
+# repos and passing everything through in mugiwara's own.
+drop_harness() {
+  if harness_excluded; then grep -vE "$1($HARNESS_PAT)" || true; else cat; fi
+}
+
+# --- working-tree-aware change set (F) -------------------------------------
+# `git diff BASE..HEAD` alone is blind to uncommitted work, and the old
+# `|| git diff --cached` fallback was dead code (|| fires on non-zero exit,
+# never on empty output). With auto_commit=off nothing is committed, so lane
+# sizing and files_touched read 0 while the tree holds real changes.
+# These two helpers are the single source of truth for BOTH lane.sh and
+# savepoint.sh so the two can never drift (lane-integrity case 15).
+
+# Path of the crew's bookkeeping dir, relative to the repo root. MUGIWARA_DIR
+# may be absolute (the harness passes a full path); git reports repo-relative
+# paths, so normalize before comparing.
+mugiwara_rel() {
+  local d="${MUGIWARA_DIR:-.mugiwara}" root
+  case "$d" in
+    /*) root=$(git rev-parse --show-toplevel 2>/dev/null || true)
+        [ -n "$root" ] && d="${d#"$root"/}"
+        # symlinked repo roots (/var vs /private/var on macOS) defeat the
+        # prefix strip; fall back to the leaf name, which is what git reports.
+        case "$d" in /*) d=$(basename "$d") ;; esac ;;
+  esac
+  printf '%s' "$d"
+}
+
+# changed_files <base-ref> — union of committed (BASE..HEAD), staged, unstaged
+# and untracked files. .gitignore'd files are excluded (git status default),
+# and so is the crew's own .mugiwara/ bookkeeping: savepoint writes state on
+# every wave, and mission state must never size the mission it measures.
+changed_files() {
+  local base="${1:-}"
+  {
+    if [ -n "$base" ] && [ "$base" != "unknown" ]; then
+      git diff --name-only "$base"..HEAD 2>/dev/null || true
+    fi
+    # porcelain covers staged + unstaged + untracked in one pass; strip the
+    # 2-char status + space, and keep the destination side of a rename.
+    git status --porcelain --untracked-files=all 2>/dev/null | sed 's/^...//; s/^.* -> //' || true
+  } | grep -v '^[[:space:]]*$' | grep -v "^$(mugiwara_rel)/" | drop_harness '^' | sort -u
+}
+
+# changed_loc <base-ref> — echoes "<insertions> <deletions>" over the same
+# union. Untracked files count every line as an insertion.
+changed_loc() {
+  local base="${1:-}" MUGI_REL
+  MUGI_REL=$(mugiwara_rel)
+  {
+    if [ -n "$base" ] && [ "$base" != "unknown" ]; then
+      git diff --numstat "$base"..HEAD 2>/dev/null || true
+    fi
+    git diff --numstat HEAD 2>/dev/null || true
+    git ls-files --others --exclude-standard 2>/dev/null | while IFS= read -r f; do
+      [ -f "$f" ] || continue
+      case "$f" in "$MUGI_REL"/*) continue ;; esac
+      printf '%s\t0\t%s\n' "$(wc -l < "$f" 2>/dev/null | tr -d ' ' || echo 0)" "$f"
+    done
+  } | grep -v "	$MUGI_REL/" | drop_harness '	' | awk '{ if ($1 ~ /^[0-9]+$/) i+=$1; if ($2 ~ /^[0-9]+$/) d+=$2 } END { print (i+0)" "(d+0) }'
+}

package/scripts/policy-force.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+// scripts/policy-force.ts — policy-as-code helper for the bash lane logic.
+// Reads changed file paths on stdin, prints the mugiwara.policy.yml
+// `lanes.force_full` globs they match (comma-separated). Empty output = no
+// policy hit. Exits 0 even when nothing matches; a missing bun skips the
+// call site entirely (policy is optional by design).
+import { readFileSync } from 'node:fs';
+import { loadPolicy, matchedGlobs } from '../src/policy.ts';
+
+const input = readFileSync(0, 'utf8');
+const paths = input.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+if (!paths.length) process.exit(0);
+let policy;
+try {
+  policy = loadPolicy(process.cwd());
+} catch (e) {
+  // Fail closed: an unreadable rule must not look like "no rule".
+  console.error(`policy-force: ${(e as Error).message}`);
+  process.exit(2);
+}
+const hits = policy?.lanes?.force_full?.length ? matchedGlobs(paths, policy.lanes.force_full) : [];
+if (hits.length) process.stdout.write(hits.join(','));

package/scripts/retrieval-eval.ts

@@ -18,7 +18,7 @@ function tokenize(text: string): string[] {
   return text.toLowerCase()
     .replace(/[^a-z0-9\s-]/g, ' ')
     .split(/\s+/)
-    .filter(t => t.length > 1 && !['the', 'and', 'for', 'use', 'when', 'that', 'with', 'this', 'from', 'its', 'not', 'are', 'has'].includes(t));
+    .filter(t => t.length > 1 && !['the', 'and', 'for', 'use', 'when', 'that', 'with', 'this', 'from', 'its', 'not', 'are', 'has', 'to', 'is', 'it', 'of', 'in', 'on', 'at', 'be', 'or', 'as', 'an'].includes(t));
 }
 
 function buildIndex(): Index {