@ionivetech/mugiwara 0.8.0 → 0.8.2

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

package/scripts/savepoint.sh

@@ -8,6 +8,18 @@ set -u
 
 die() { echo "savepoint: $*" >&2; exit 1; }
 
+# count_boxes <file> <char-class> — count markdown checkboxes.
+# Anchored so prose mentioning "- [x]" is not counted; skips fenced code blocks
+# so documentation examples are not counted; matches [x] and [X] alike. (B3)
+count_boxes() {
+  [ -f "$1" ] || { echo 0; return; }
+  awk -v pat="$2" '
+    /^[[:space:]]*```/ { inblock = !inblock; next }
+    !inblock && $0 ~ ("^[[:space:]]*-[[:space:]]*\\[" pat "\\]") { n++ }
+    END { print n+0 }
+  ' "$1"
+}
+
 MUGIWARA_DIR="${MUGIWARA_DIR:-.mugiwara}"
 
 # optional provider-reported tokens file (T4): --tokens-file <path> JSON {input_tokens, output_tokens}
@@ -154,6 +166,11 @@ esac
 # (BSD/macOS-safe: no \+ BRE).
 BRANCH_SLUG=$(echo "$BRANCH" | tr '/' '-' | tr -cd 'A-Za-z0-9._-' | sed 's/^\.\{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) || die "not a git repository"
+cd "$REPO_ROOT" || die "cannot enter repo root"
+
 # state + continue live in the mission dir. Solo (member empty) → state.json
 # + continue.json; team writes <member>.json + continue-<member>.json so
 # parallel members never clobber each other.
@@ -167,7 +184,6 @@ else
 fi
 
 [ -z "$MISSION" ] && die "usage: savepoint.sh <mission> [member] [wave] [mode] [lane]"
-[ -d .git ] || die "not a git repository"
 
 # --- computed fields ---
 BASE_SHA=$(git merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null || git merge-base HEAD "$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's|refs/remotes/origin/||')" 2>/dev/null || git rev-parse HEAD~1 2>/dev/null || echo "unknown")
@@ -328,9 +344,23 @@ if [ -n "$PLAN_FILE" ] && [ -f "$PLAN_FILE" ]; then
   # total counts ALL task lines (checked + unchecked); done counts checked only.
   # A fully-completed plan must read total=N done=N, never total=0 (the old
   # unchecked-only grep degenerated a done plan to tasks.total=0).
-  TASKS_TOTAL=$(grep -cE '^\s*-\s*\[[ xX]\]' "$PLAN_FILE" 2>/dev/null || true)
-  TASKS_DONE=$(grep -c '\[x\]' "$PLAN_FILE" 2>/dev/null || true)
+  TASKS_TOTAL=$(count_boxes "$PLAN_FILE" '[ xX]')
+  TASKS_DONE=$(count_boxes "$PLAN_FILE" '[xX]')
+fi
+# Fallback for large campaigns (>3 phases, >1500 lines) where master plan.md is an index
+# and tasks live in sub-plan/*.md — only when plan.md has zero checkbox tasks to
+# keep simple missions unchanged.
+if [ "${TASKS_TOTAL:-0}" -eq 0 ] 2>/dev/null && [ -d "$MISSION_DIR/sub-plan" ]; then
+  TASKS_TOTAL=0; TASKS_DONE=0
+  for _sp in "$MISSION_DIR"/sub-plan/*.md; do
+    [ -f "$_sp" ] || continue
+    TASKS_TOTAL=$(( TASKS_TOTAL + $(count_boxes "$_sp" '[ xX]') ))
+    TASKS_DONE=$(( TASKS_DONE + $(count_boxes "$_sp" '[xX]') ))
+  done
 fi
+# done ≤ total is an invariant of the audit trail — never let a report show
+# progress above 100%, whatever the plan file contains. (B3)
+[ "${TASKS_DONE:-0}" -gt "${TASKS_TOTAL:-0}" ] 2>/dev/null && TASKS_DONE="$TASKS_TOTAL"
 
 # blocker count
 BLOCKERS_FILE="$MISSION_DIR/blockers.md"
@@ -365,6 +395,16 @@ if [ "$HEAL_CYCLE" -ge "$HEAL_MAX_CYCLES" ] 2>/dev/null; then
   HEAL_HALT=true
 fi
 
+# slop — context (repeated reads) per cost-governor §§21-24,31-32 — T5 wire all crews Luffy/Nami/Zoro/Brook
+REPEATED_READS=0
+REPEATED_THRESHOLD=3
+REGISTRY_FILE="$MISSION_DIR/context-registry.jsonl"
+if [ -f "$REGISTRY_FILE" ]; then
+  REPEATED_READS=$(node -e "try{const fs=require('fs');const t=fs.readFileSync(process.argv[1],'utf8');let s=0;for(const l of t.split(/\r?\n/)){if(!l.trim())continue;try{const e=JSON.parse(l);if(typeof e.reads==='number'&&e.reads>=2)s+=Math.floor(e.reads)-1}catch{}}console.log(s)}catch(e){console.log(0)}" "$REGISTRY_FILE" 2>/dev/null || echo 0)
+  REPEATED_READS=$(( ${REPEATED_READS:-0} + 0 ))
+fi
+# repeated_reads > threshold → context slop — crew must skip re-read/compress before dispatch (§22,31); heal_cycle≥max → halt/escalate (§21.7/32) — cost-governor §§20,21-24
+
 # depth flags — advisory → measured (roadmap v0.8 item 4). Read from config
 # like the other keys; computed into state.json so enforcement is a fact the
 # gates flow stage can read, not prose.
@@ -523,7 +563,9 @@ const data = {
   budget_status: process.argv[19],
   skill_version: process.argv[20],
   evidence: process.argv[21] ? process.argv[21].split(',').filter(Boolean) : [],
-  updated_at: process.argv[22]
+  updated_at: process.argv[22],
+  schema_version: 2,
+  repeated_reads: parseInt(process.argv[41], 10) || 0
 };
 require('fs').writeFileSync(process.argv[23], JSON.stringify(data, null, 2) + '\n');
 " \
@@ -536,7 +578,8 @@ require('fs').writeFileSync(process.argv[23], JSON.stringify(data, null, 2) + '\
   "$STATE_FILE" "$LANE_PREV" "$LANE_ROSE" "$TOKENS_SOURCE" "$LANE_PEAK" \
   "$LOC_INS" "$LOC_DEL" "$LOC_CHURN" "$MEMBER" "$VERBOSITY" \
   "$HEAL_MAX_CYCLES" "$HEAL_HALT" "$DELEGATE_THRESHOLD" "$DELEGATE_DUE" \
-  "$MODEL" "$DEPTH_REVIEW" "$DEPTH_QUALITY" "$DEPTH_VERIFY"
+  "$MODEL" "$DEPTH_REVIEW" "$DEPTH_QUALITY" "$DEPTH_VERIFY" \
+  "$REPEATED_READS"
 
 if [ "$LANE_ROSE" = true ]; then
   echo "⚠ LANE ROSE: $LANE_PREV → $LANE ($LANE_REASON) — escalate per check-in protocol"

package/scripts/validate-content.ts

@@ -417,6 +417,66 @@ if (integrityArg !== -1) {
 }
 }
 
+// --- README metrics gate (D3): README table must match .metrics/latest.json ---
+if (process.argv.includes('--check-readme-metrics')) {
+  const metricsPath = join(import.meta.dirname, '..', '.metrics', 'latest.json');
+  if (!existsSync(metricsPath)) {
+    errors.push(`README metrics: ${metricsPath} not found — run bun scripts/write-metrics.ts`);
+  } else {
+    let metrics: any;
+    try { metrics = JSON.parse(readFileSync(metricsPath, 'utf8')); }
+    catch (e) { errors.push(`README metrics: invalid JSON in ${metricsPath}: ${e}`); }
+    if (metrics) {
+      const readmePath = join(import.meta.dirname, '..', 'README.md');
+      if (!existsSync(readmePath)) {
+        errors.push('README metrics: README.md not found');
+      } else {
+        const readme = readFileSync(readmePath, 'utf8');
+        // rank-1: **95.9%**, 216 probes
+        const rankMatch = readme.match(/Retrieval routing rank-1[^\n]*?(\d+\.\d+)%[^\n]*?(\d+)\s+probes/i);
+        if (!rankMatch) {
+          errors.push('README metrics: could not parse Retrieval routing rank-1 row (expected "**X.Y%**, N probes")');
+        } else {
+          const readmeRank = parseFloat(rankMatch[1]);
+          const readmeProbes = parseInt(rankMatch[2], 10);
+          const wantRank = Number(metrics.retrieval_rank1);
+          const wantProbes = Number(metrics.retrieval_probes);
+          if (Math.abs(readmeRank - wantRank) > 0.05) {
+            errors.push(`README metrics: rank-1 ${readmeRank}% != metrics ${wantRank}% (probes ${readmeProbes} vs ${wantProbes}) — run bun scripts/write-metrics.ts and update README`);
+          }
+          if (readmeProbes !== wantProbes) {
+            errors.push(`README metrics: probes ${readmeProbes} != metrics ${wantProbes} (rank ${readmeRank}% vs ${wantRank}%) — run bun scripts/write-metrics.ts and update README`);
+          }
+        }
+        // pointers: **286/286**, 9 targets (or tiers)
+        const ptrMatch = readme.match(/Reference pointers resolve[^\n]*?\*\*(\d+)\/(\d+)\*\*[^\n]*?(\d+)\s+(tiers|targets)/i);
+        if (!ptrMatch) {
+          errors.push('README metrics: could not parse Reference pointers row (expected "**N/N**, M targets")');
+        } else {
+          const a = parseInt(ptrMatch[1], 10);
+          const b = parseInt(ptrMatch[2], 10);
+          const count = parseInt(ptrMatch[3], 10);
+          const wantTotal = Number(metrics.pointers_total);
+          const wantTargets = Number(metrics.pointers_targets);
+          if (a !== wantTotal || b !== wantTotal) {
+            errors.push(`README metrics: pointers ${a}/${b} != metrics ${wantTotal}/${wantTotal} — run bun scripts/write-metrics.ts and update README`);
+          }
+          if (count !== wantTargets) {
+            errors.push(`README metrics: targets/tiers ${count} != metrics ${wantTargets} — run bun scripts/write-metrics.ts and update README (expected ${wantTargets} targets)`);
+          }
+        }
+        // sanity: table still claims "Nothing in this table is an estimate"
+        if (!readme.includes('Nothing in this table is an estimate')) {
+          errors.push('README metrics: missing "Nothing in this table is an estimate" line');
+        }
+        if (errors.filter(e => e.startsWith('README metrics:')).length === 0) {
+          console.log(`✓ README metrics match .metrics/latest.json (rank-1 ${metrics.retrieval_rank1}% ${metrics.retrieval_probes} probes, ${metrics.pointers_total}/${metrics.pointers_total} pointers, ${metrics.pointers_targets} targets)`);
+        }
+      }
+    }
+  }
+}
+
 // Conditional-assertion guard: an expect() reachable only inside a truthiness
 // check silently passes when the value is absent. This class produced 9 defects.
 // Allowed: checks keyed on a declared invariant (tier, fixture keys).

package/scripts/verify-install.ts

@@ -18,6 +18,7 @@ import { targets, TARGET_IDS } from '../src/targets/index.ts';
 
 const repoRoot = join(import.meta.dirname, '..');
 const fail: string[] = [];
+const isJson = process.argv.includes('--json');
 
 function findMd(root: string, out: string[] = []): string[] {
   if (!existsSync(root)) return out;
@@ -169,6 +170,25 @@ if (orphans.length > ORPHAN_BASELINE) {
 }
 
 // ---------------------------------------------------------------------------
+if (isJson) {
+  const payload = {
+    pointers_total: pointers,
+    pointers_targets: TARGET_IDS.length,
+    pointers_broken: brokenPointers,
+    prose_paths: prosePaths,
+    prose_files: proseFiles.length,
+    orphans,
+    orphans_count: orphans.length,
+    ref_files: refFiles.length,
+    targets: TARGET_IDS.length,
+    pointers: pointers,
+    broken_pointers: brokenPointers,
+  };
+  console.log(JSON.stringify(payload, null, 2));
+  if (fail.length) process.exit(1);
+  process.exit(0);
+}
+
 console.log(`  ${pointers} pointers checked across ${TARGET_IDS.length} targets`);
 console.log(`  ${prosePaths} prose paths checked in ${proseFiles.length} files`);
 console.log(`  ${orphans.length}/${refFiles.length} reference files unreachable (baseline ${ORPHAN_BASELINE})`);

package/scripts/write-metrics.ts

@@ -0,0 +1,73 @@
+#!/usr/bin/env bun
+// scripts/write-metrics.ts — generate .metrics/latest.json from gate outputs
+// Deterministic, no network. Runs retrieval-eval --json and verify-install --json.
+
+import { execSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const root = join(import.meta.dirname, '..');
+
+function extractJson(output: string): any {
+  const idx = output.indexOf('{');
+  if (idx === -1) throw new Error('no JSON found in output: ' + output.slice(0, 200));
+  return JSON.parse(output.slice(idx));
+}
+
+function runJson(cmd: string): any {
+  // execSync returns stdout only; retrieval prints a rank line before JSON on stdout
+  // so we slice from first '{'
+  const out = execSync(cmd, { cwd: root, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+  return extractJson(out);
+}
+
+// retrieval: need probes, rank1_rate, index_size
+let ret: any;
+let ver: any;
+try {
+  ret = runJson('bun scripts/retrieval-eval.ts --json');
+} catch (e: any) {
+  // if process exits non-zero, stdout still contains JSON + rank line; try to parse from error stdout
+  const out = e.stdout?.toString() ?? e.message ?? '';
+  if (out.includes('{')) ret = extractJson(out);
+  else throw e;
+}
+
+try {
+  ver = runJson('bun scripts/verify-install.ts --json');
+} catch (e: any) {
+  const out = e.stdout?.toString() ?? e.message ?? '';
+  if (out.includes('{')) ver = extractJson(out);
+  else throw e;
+}
+
+const rank1Str: string = ret.rank1_rate ?? ret.rank1 ?? '';
+const rank1Num = typeof rank1Str === 'string' ? parseFloat(rank1Str.replace('%', '')) : Number(rank1Str);
+const probes = ret.probes ?? ret.totalProbes ?? 0;
+const pointersTotal = ver.pointers_total ?? ver.pointers ?? 0;
+const pointersTargets = ver.pointers_targets ?? ver.targets ?? 0;
+const indexSize = ret.index_size ?? 0;
+const updated = new Date().toISOString().split('T')[0];
+
+const metrics = {
+  retrieval_rank1: rank1Num,
+  retrieval_rank1_rate: rank1Str,
+  retrieval_probes: probes,
+  retrieval_rank1_count: ret.rank1_count ?? null,
+  retrieval_positives: ret.positives ?? null,
+  retrieval_negatives: ret.negatives ?? null,
+  retrieval_index_size: indexSize,
+  retrieval_index_terms: ret.index_terms ?? null,
+  pointers_total: pointersTotal,
+  pointers_targets: pointersTargets,
+  pointers_broken: ver.pointers_broken ?? ver.broken_pointers ?? 0,
+  index_size: indexSize,
+  updated,
+};
+
+const outDir = join(root, '.metrics');
+mkdirSync(outDir, { recursive: true });
+const outPath = join(outDir, 'latest.json');
+writeFileSync(outPath, JSON.stringify(metrics, null, 2) + '\n');
+console.log(`✓ wrote ${outPath}`);
+console.log(JSON.stringify(metrics, null, 2));

package/src/budget.ts

@@ -45,3 +45,14 @@ export function formatFootprint(chars: number, budget: number): string {
     ? `${base} — OVER budget ${budget}`
     : `${base} (budget ${budget})`;
 }
+
+// ── Auto-compress threshold (T4) — 80% of budget ───────────────────────────
+export const COMPRESS_THRESHOLD_PCT = 0.8;
+
+export function shouldCompress(budget: number, chars: number): boolean {
+  return budget > 0 && chars > Math.floor(budget * COMPRESS_THRESHOLD_PCT);
+}
+
+export function compressThreshold(budget: number): number {
+  return Math.floor(budget * COMPRESS_THRESHOLD_PCT);
+}