@ionivetech/mugiwara 0.6.2 → 0.6.4

package/references/wave-banners.md

@@ -0,0 +1,75 @@
+# Wave Banners — formats + crew colors
+
+The single source for wave-banner rendering and crew colors. The opencode
+plugin and the opencode-target generator derive agent UI colors from the table
+below — change a color HERE, never in code. This file is machine-parsed:
+keep the table format exact (one row per agent, pipes, no extra columns).
+
+## Terminal format (ANSI truecolor)
+
+Every wave opens with the banner line in the owning agent's color, and closes
+with a handoff line. Wrap the whole line in the ANSI truecolor of the agent:
+
+```
+\x1b[38;2;R;G;Bm==================== WAVE 3 — ZORO (EXECUTION) ====================\x1b[0m
+→ Wave 4 — Chopper (Checkpoint)
+```
+
+- RGB values come from the `hex` column below; R/G/B are the hex channels in
+  decimal (truecolor `38;2;R;G;B`). If the terminal lacks truecolor, use the
+  `ansi-256` index: `\x1b[38;5;Nm`.
+- Wave 9's handoff: `→ closure`.
+- The literal `WAVE N —` text must stay exact: `scripts/savepoint.sh` counts
+  heal cycles by grepping `wave 8` (case-insensitive) in the trace. A banner
+  that drops the literal silently resets the heal loop.
+- Never convey the wave by color alone — the crew name and emoji always
+  accompany the color.
+
+## UI format (markdown UIs)
+
+Rich UIs (Claude Code UI, VSCode, Codex) strip or garble ANSI escapes. Emit
+the emoji-heading form instead — no ANSI, no equals line:
+
+```
+## ⚔️ WAVE 3 — ZORO (EXECUTION)
+→ Wave 4 — Chopper (Checkpoint)
+```
+
+Same literal `WAVE N —` rule applies.
+
+## Crew colors
+
+| agent-id | role | hex | ansi-256 | emoji |
+|----------|------|-----|----------|-------|
+| luffy-orchestrator | Luffy | #ef4444 | 196 | 🏴‍☠️ |
+| usopp-brainstorm | Usopp | #b45309 | 130 | 🎯 |
+| nami-planner | Nami | #f97316 | 208 | 🧭 |
+| zoro-execution | Zoro | #22c55e | 34 | ⚔️ |
+| chopper-checkpoint | Chopper | #60a5fa | 75 | 🩺 |
+| sanji-quality | Sanji | #facc15 | 220 | 🍳 |
+| franky-gates | Franky | #06b6d4 | 45 | 🔧 |
+| robin-reviewer | Robin | #8b5cf6 | 99 | 📚 |
+| jinbe-security | Jinbe | #6366f1 | 63 | 🌊 |
+| brook-healing | Brook | #2dd4bf | 43 | 🎻 |
+| skeptic-verifier | Skeptic | #64748b | 245 | 🔍 |
+| eval-runner | EvalRunner | #14b8a6 | 37 | 🧪 |
+| resume-coordinator | Resume | #d97706 | 172 | 🔄 |
+| memory-keeper | MemoryKeeper | #d946ef | 200 | 🧠 |
+| onboarding-guide | Guide | #0ea5e9 | 75 | 🚀 |
+
+Skeptic, EvalRunner, Resume, MemoryKeeper and Guide are internal/dispatch or
+wizard agents — their banners appear only when a wave or worker names them.
+
+## Rules
+
+1. Banner before EVERY wave; handoff after it. No wave starts without its
+   banner (orchestration red flag).
+2. The color comes from this table only — never invent a hex mid-mission.
+3. Terminal variant when the session looks like a terminal; UI variant for
+   markdown-rendering UIs. When unsure, the UI variant is safe everywhere.
+4. Only the crew table's colors and the two SGR forms above (truecolor,
+   256-index) may appear in a banner — never other escape families (OSC,
+   title, cursor, other SGR codes). The banner is a fixed template, not a
+   formatting playground.
+5. Adding a crew member? Add the row here first; the plugin and target
+   generator pick it up automatically.

package/scripts/evidence.sh

@@ -55,5 +55,14 @@ EVIDENCE_FILE="$RESULTS_DIR/${LABEL}-${HASH}.log"
 } > "$EVIDENCE_FILE"
 EXIT_CODE=$?
 
+# trailer: exit code + verdict (D6). The verdict is PASS/FAIL derived from the
+# exit code — the check's own outcome, not the harness's opinion.
+if [ "$EXIT_CODE" -eq 0 ]; then
+  VERDICT="PASS"
+else
+  VERDICT="FAIL"
+fi
+printf '# Exit: %s\n# Verdict: %s\n' "$EXIT_CODE" "$VERDICT" >> "$EVIDENCE_FILE"
+
 echo "$EVIDENCE_FILE"
 exit $EXIT_CODE

package/scripts/gate-selftest.ts

@@ -89,6 +89,160 @@ if (!existsSync(join(root, 'test', 'savepoint.test.ts'))) {
   }
 }
 
+// --- D1 mutation: break LANE_PREV resolve (require-style) → lane-integrity red ---
+console.log('\nD1 — LANE_PREV resolve mutation');
+const savepointFile = join(root, 'scripts', 'savepoint.sh');
+if (!existsSync(savepointFile)) {
+  console.log('  ⚠  savepoint.sh not found, skipping');
+} else {
+  const original = readFileSync(savepointFile, 'utf8');
+  try {
+    // reintroduce the D1 defect: read lane_prev with require() of a relative path
+    const broken = original.replace(
+      /PREV_JSON=\$\(node -e "try\{const fs=require\('fs'\);const s=JSON\.parse\(fs\.readFileSync\(process\.argv\[1\],'utf8'\)\);process\.stdout\.write\(JSON\.stringify\(\{mission:s\.mission\|\|'',lane:s\.lane\|\|'',peak:s\.lane_peak\|\|''\}\)\)\}catch\(e\)\{process\.stdout\.write\('\{\}'\)\}" "\$STATE_FILE" 2>\/dev\/null \|\| true\)/,
+      "PREV_JSON=$(node -e \"try{const s=require(process.argv[1]);process.stdout.write(JSON.stringify({mission:s.mission||'',lane:s.lane||'',peak:s.lane_peak||''}))}catch(e){process.stdout.write('{}')}\" \"$STATE_FILE\" 2>/dev/null || true)"
+    );
+    if (broken === original) {
+      console.log('  ⚠  D1 mutation pattern not found — skipping');
+    } else {
+      writeFileSync(savepointFile, broken);
+      assert('broken LANE_PREV resolve → lane-integrity fails', false, () => run('D1', 'bun run test -- lane-integrity -t "lane_prev"'));
+    }
+  } finally {
+    writeFileSync(savepointFile, original);
+    assert('restored → lane-integrity passes', true, () => run('D1', 'bun run test -- lane-integrity -t "lane_prev"'));
+  }
+}
+
+// --- D2 mutation: break monotonic clamp (drop lane_rank) → red ---
+console.log('\nD2 — monotonic clamp mutation');
+if (!existsSync(savepointFile)) {
+  console.log('  ⚠  savepoint.sh not found, skipping');
+} else {
+  const original = readFileSync(savepointFile, 'utf8');
+  try {
+    // neuter the clamp: make lane_rank always return 0 so a drop never holds
+    const broken = original.replace(
+      /lane_rank\(\) \{\n  case "\$1" in\n    direct\) echo 0 ;;[\s\S]*?\n  esac\n\}/,
+      'lane_rank() {\n  echo 0\n}'
+    );
+    if (broken === original) {
+      console.log('  ⚠  D2 mutation pattern not found — skipping');
+    } else {
+      writeFileSync(savepointFile, broken);
+      assert('broken clamp → lane-integrity fails', false, () => run('D2', 'bun run test -- lane-integrity -t "clamp"'));
+    }
+  } finally {
+    writeFileSync(savepointFile, original);
+    assert('restored → lane-integrity passes', true, () => run('D2', 'bun run test -- lane-integrity -t "clamp"'));
+  }
+}
+
+// --- D3 mutation: empty SENSITIVE_PATS → lane-integrity red ---
+console.log('\nD3 — sensitive patterns mutation');
+const patternsFile = join(root, 'scripts', 'lib', 'patterns.sh');
+if (!existsSync(patternsFile)) {
+  console.log('  ⚠  patterns.sh not found, skipping');
+} else {
+  const original = readFileSync(patternsFile, 'utf8');
+  try {
+    // reintroduce the D3 defect: singular-only list (no payments/, migrations/)
+    const broken = original.replace(
+      /SENSITIVE_PATS=.*/,
+      'SENSITIVE_PATS="auth/|payment/|billing/|crypto/|secrets/|\\.env$|config/.*key|migration/|\\.sql$|schema\\.|\\.prisma$|\\.terraform|\\.tf$"'
+    );
+    if (broken === original) {
+      console.log('  ⚠  D3 mutation pattern not found — skipping');
+    } else {
+      writeFileSync(patternsFile, broken);
+      assert('singular sensitive patterns → lane-integrity fails', false, () => run('D3', 'bun run test -- lane-integrity -t "payments"'));
+    }
+  } finally {
+    writeFileSync(patternsFile, original);
+    assert('restored → lane-integrity passes', true, () => run('D3', 'bun run test -- lane-integrity -t "payments"'));
+  }
+}
+
+// --- D3b mutation: strip the NEW pattern categories → lane-integrity red ---
+console.log('\nD3b — new category strip mutation');
+if (!existsSync(patternsFile)) {
+  console.log('  ⚠  patterns.sh not found, skipping');
+} else {
+  const original = readFileSync(patternsFile, 'utf8');
+  try {
+    // derive the broken list from the LIVE source, stripping the exact tokens
+    // of the v0.6.4 D3 families — a hard-coded baseline rots the moment a
+    // category is added (G3). New family tokens must be added here too.
+    const D3B_FAMILY_TOKENS = new Set([
+      // raw regex tokens as they appear in live SENSITIVE_PATS (backslashes included)
+      'oauth2?/', 'credential', 'sessions?/', 'tokens?/', 'rbac', 'permissions?/', 'acls?/', 'iam/',
+      '\\.p12$', '\\.key$', '\\.pem$', 'migrate/', 'Dockerfile', 'docker-compose', '\\.github/workflows/',
+      'webhooks?/', 'secret/', 'secrets?\\.ya?ml$', '\\.tfvars$', '\\.env$', '\\.env\\.',
+    ]);
+    const live = original.match(/SENSITIVE_PATS="([^"]+)"/)?.[1] ?? '';
+    const broken = live.split('|').filter(t => !D3B_FAMILY_TOKENS.has(t)).join('|');
+    const brokenLine = `SENSITIVE_PATS="${broken}"`;
+    if (broken === live || !live) {
+      console.log('  ⚠  D3b: no D3 family tokens found in live SENSITIVE_PATS — skipping');
+    } else {
+      writeFileSync(patternsFile, original.replace(/SENSITIVE_PATS="[^"]*"/, brokenLine));
+      assert('missing new categories → lane-integrity fails', false, () => run('D3b', 'bun run test -- lane-integrity -t "sensitive-paths"'));
+    }
+  } finally {
+    writeFileSync(patternsFile, original);
+    assert('restored → lane-integrity passes', true, () => run('D3b', 'bun run test -- lane-integrity -t "sensitive-paths"'));
+  }
+}
+
+// --- D4 mutation: zero LOC_TOKENS → lane-integrity red ---
+console.log('\nD4 — churn token mutation');
+if (!existsSync(savepointFile)) {
+  console.log('  ⚠  savepoint.sh not found, skipping');
+} else {
+  const original = readFileSync(savepointFile, 'utf8');
+  try {
+    // revert to delta-based (0 on deletions/refactors)
+    const broken = original.replace(
+      /LOC_TOKENS=\$\(\( LOC_CHURN \* 12 \)\)/,
+      'LOC_TOKENS=$(( LOC_DELTA > 0 ? LOC_DELTA * 12 : 0 ))'
+    );
+    if (broken === original) {
+      console.log('  ⚠  D4 mutation pattern not found — skipping');
+    } else {
+      writeFileSync(savepointFile, broken);
+      assert('zero churn tokens → lane-integrity fails', false, () => run('D4', 'bun run test -- lane-integrity -t "churn"'));
+    }
+  } finally {
+    writeFileSync(savepointFile, original);
+    assert('restored → lane-integrity passes', true, () => run('D4', 'bun run test -- lane-integrity -t "churn"'));
+  }
+}
+
+// --- D10 mutation: break continue writer → savepoint test red ---
+console.log('\nD10 — continue writer mutation');
+if (!existsSync(savepointFile)) {
+  console.log('  ⚠  savepoint.sh not found, skipping');
+} else {
+  const original = readFileSync(savepointFile, 'utf8');
+  try {
+    // silently drop the continue writer block (make it a no-op). Anchor on the
+    // D10 header comment so the regex hits the writer, not the STATE_FILE if.
+    const broken = original.replace(
+      /# --- continue\/<mission>\/<member>\.json \(D10\): machine-written resume point ---[\s\S]*?\nfi\n\n/,
+      '# --- continue writer disabled (D10) ---\n\n'
+    );
+    if (broken === original) {
+      console.log('  ⚠  D10 mutation pattern not found — skipping');
+    } else {
+      writeFileSync(savepointFile, broken);
+      assert('broken continue writer → savepoint fails', false, () => run('D10', 'bun run test -- savepoint -t "D10"'));
+    }
+  } finally {
+    writeFileSync(savepointFile, original);
+    assert('restored → savepoint passes', true, () => run('D10', 'bun run test -- savepoint -t "D10"'));
+  }
+}
+
 // --- Retrieval eval ratchet ---
 console.log('\nRetrieval eval ratchet');
 if (!existsSync(join(root, 'scripts', 'retrieval-eval.ts'))) {

package/scripts/lane-base.ts

@@ -0,0 +1,114 @@
+#!/usr/bin/env bun
+// scripts/lane-base.ts — G5: validate LANE_BASE constants against measured
+// content instruction load. Each lane loads a fixed set of skills + agents
+// (wave owners from docs/concepts/workflow.md). The honest base is the sum of
+// their body word-sums × 1.35 tokens/word. A constant that drifts more than
+// the tolerance from that load fails — content growth must be reflected in
+// lane-base.sh, or the estimate is a lie (D5).
+//
+// Run: bun scripts/lane-base.ts        — validate (CI gate)
+//      bun scripts/lane-base.ts --show — print computed load per lane
+
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const root = join(import.meta.dirname, '..');
+const skills = join(root, 'content', 'skills');
+const agents = join(root, 'content', 'agents');
+
+// wave → owning skill + agent (workflow.md rows)
+const WAVE_OWNER: Record<string, [string, string]> = {
+  '0': ['mugiwara-orchestration', 'luffy-orchestrator'],
+  '1': ['mugiwara-brainstorm', 'usopp-brainstorm'],
+  '2': ['mugiwara-planning', 'nami-planner'],
+  '3': ['mugiwara-execution', 'zoro-execution'],
+  '4': ['mugiwara-checkpoint', 'chopper-checkpoint'],
+  '4.5': ['mugiwara-claim-audit', 'skeptic-verifier'],
+  '5': ['mugiwara-quality', 'sanji-quality'],
+  '6': ['mugiwara-gates', 'franky-gates'],
+  '7': ['mugiwara-review', 'robin-reviewer'],
+  '8': ['mugiwara-healing', 'brook-healing'],
+};
+
+// skills always loaded regardless of lane: none — resume/lessons only load
+// mid-mission on interruption, too cheap to count as a lane base.
+const ALWAYS: Array<[string, string]> = [];
+
+const LANE_WAVES: Record<string, string[]> = {
+  direct: [],
+  lean: ['0', '3', '5'],
+  standard: ['0', '2', '3', '4', '7'],
+  full: ['0', '1', '2', '3', '4', '4.5', '5', '6', '7', '8'],
+  spike: ['0', '1'],
+};
+
+const TOKENS_PER_WORD = 1.35;
+const TOLERANCE = 0.2; // ±20% — a real drift, not rounding
+
+function wordCount(file: string): number {
+  if (!existsSync(file)) return 0;
+  return readFileSync(file, 'utf8').split(/\s+/).filter(Boolean).length;
+}
+
+function laneLoad(lane: string): number {
+  const waves = LANE_WAVES[lane] ?? [];
+  const owners: Array<[string, string]> = [...ALWAYS];
+  for (const w of waves) {
+    if (WAVE_OWNER[w]) owners.push(WAVE_OWNER[w]);
+  }
+  let words = 0;
+  for (const [skill, agent] of owners) {
+    words += wordCount(join(skills, skill, 'SKILL.md'));
+    words += wordCount(join(agents, agent + '.md'));
+  }
+  return Math.round(words * TOKENS_PER_WORD);
+}
+
+// constants live in scripts/lib/lane-base.sh — parse them, not hardcode
+function parseConstants(): Record<string, { base: number; budget: number }> {
+  const text = readFileSync(join(root, 'scripts', 'lib', 'lane-base.sh'), 'utf8');
+  const out: Record<string, { base: number; budget: number }> = {};
+  for (const lane of ['lean', 'standard', 'full', 'spike']) {
+    const base = text.match(new RegExp(`LANE_BASE_${lane}=(\\d+)`));
+    const budget = text.match(new RegExp(`BUDGET_${lane}=(\\d+)`));
+    out[lane] = {
+      base: base ? parseInt(base[1], 10) : 0,
+      budget: budget ? parseInt(budget[1], 10) : 0,
+    };
+  }
+  return out;
+}
+
+const SHOW = process.argv.includes('--show');
+const lanes = ['direct', 'lean', 'standard', 'full', 'spike'];
+let failures = 0;
+
+const constants = parseConstants();
+for (const lane of lanes) {
+  const computed = laneLoad(lane);
+  const declared = constants[lane]?.base ?? 0;
+  if (SHOW) {
+    console.log(`${lane.padEnd(9)} computed=${computed.toString().padEnd(6)} declared=${declared} budget=${constants[lane]?.budget ?? 0}`);
+  }
+  // direct runs no pipeline — base 0 is correct by design, skip
+  if (lane === 'direct') continue;
+  // spike is a deliberate floor (resize lane, brainstorm only) — not
+  // content-derived, never validated
+  if (lane === 'spike') continue;
+  if (declared === 0) {
+    console.log(`  ✗ ${lane}: LANE_BASE is 0 — missing constant in lane-base.sh`);
+    failures++;
+    continue;
+  }
+  const drift = Math.abs(computed - declared) / declared;
+  if (drift > TOLERANCE) {
+    console.log(`  ✗ ${lane}: LANE_BASE ${declared} drifts ${(drift * 100).toFixed(0)}% from computed load ${computed} — update lane-base.sh`);
+    failures++;
+  }
+}
+
+if (failures > 0) {
+  console.log(`\nlane-base: ${failures} constant(s) drifted from content load`);
+  process.exit(1);
+}
+console.log('\nlane-base: constants match content load');

package/scripts/lane.sh

@@ -3,6 +3,10 @@
 # Usage: lane.sh [base-ref] [--json]
 set -u
 
+# shared path patterns — single source of truth (D3)
+# shellcheck source=scripts/lib/patterns.sh
+source "$(dirname "$0")/lib/patterns.sh"
+
 BASE="${1:-main}"
 JSON_OUT=0
 [ "${2:-}" = "--json" ] && JSON_OUT=1
@@ -19,8 +23,7 @@ CHANGED=$(git diff --name-only "$BASE"..HEAD 2>/dev/null || git diff --name-only
 FILE_COUNT=0
 [ -n "$CHANGED" ] && FILE_COUNT=$(echo "$CHANGED" | wc -l | tr -d ' ')
 
-SENSITIVE_PATS="auth/|payment/|billing/|crypto/|secrets/|\.env$|config/.*key|migration/|\.sql$|schema\.|\.prisma$|\.terraform|\.tf$"
-SENSITIVE=$(echo "$CHANGED" | grep -E "$SENSITIVE_PATS" 2>/dev/null | head -5 | tr '\n' ',' | sed 's/,$//' || true)
+SENSITIVE=$(echo "$CHANGED" | grep -E "$SENSITIVE_PATS" 2>/dev/null | tr '\n' ',' | sed 's/,$//' || true)
 HAS_SENSITIVE=0
 [ -n "$SENSITIVE" ] && HAS_SENSITIVE=1
 
@@ -64,7 +67,6 @@ 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.
-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

package/scripts/lib/lane-base.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# scripts/lib/lane-base.sh — LANE_BASE + BUDGET constants, single source of
+# truth. Validated by scripts/lane-base.ts against measured content word-sums.
+# Change a constant here → run `bun scripts/lane-base.ts`; the gate fails if
+# the constant drifts from the honest instruction load (D5).
+
+# LANE_BASE: token estimate for skills/agents loaded in this lane. Derived
+# from content word-sums × 1.35 (see scripts/lane-base.ts). spike is a
+# resize, not a rise — small base, tiny budget.
+LANE_BASE_lean=7000
+LANE_BASE_standard=13000
+LANE_BASE_full=23000
+LANE_BASE_spike=1000
+
+# BUDGET: warn at 1.5×, stop at 3×.
+BUDGET_lean=12000
+BUDGET_standard=25000
+BUDGET_full=50000
+BUDGET_spike=3000

package/scripts/lib/patterns.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# scripts/lib/patterns.sh — single source of truth for lane path patterns.
+# Sourced by lane.sh and savepoint.sh. Extend here, never in the consumers.
+
+# Sensitive-path escalation patterns. A changed file matching any of these
+# always escalates to Lane 3 (Full), regardless of file count. Plural forms
+# included (payments/, migrations/) and, since v0.6.4, the D3 categories:
+# oauth, credential(s), session(s)/, token(s)/, rbac, permission(s), acl(s)/,
+# iam/, cert keys (.pem/.key/.p12), migrate/, Dockerfile, docker-compose,
+# .github/workflows/, webhooks?/, secret yaml, .tfvars, and .env variants
+# (.env.local, .env.production — .env$ alone missed them, D3 follow-up).
+# Dir-anchored (not bare): oauth2?/, permissions?/, tokens?/, sessions?/,
+# acls?/ — bare forms over-matched docs (oauth-guide.md, permissionless.ts).
+# Deliberately NOT matched: package.json (dependency churn is policy-as-code,
+# not a sensitive lane trigger), authors/ (contains "auth" but never auth/).
+SENSITIVE_PATS="auth/|oauth2?/|payment/|payments/|billing/|crypto/|secrets/|credential|sessions?/|tokens?/|rbac|permissions?/|acls?/|iam/|\.env$|\.env\.|config/.*key|\.p12$|\.key$|\.pem$|migration/|migrations/|migrate/|\.sql$|schema\.|\.prisma$|\.terraform|\.tf$|Dockerfile|docker-compose|\.github/workflows/|webhooks?/|secret/|secrets?\.ya?ml$|\.tfvars$"
+
+# Product surface: paths that count toward file-based lane sizing. Changes
+# 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/"

package/scripts/mission-report.sh

@@ -12,25 +12,38 @@ MISSION="${1:-}"
 case "$MISSION" in
   *[!a-zA-Z0-9._-]*) echo "mission-report: invalid mission name \"$MISSION\" (allowlist: [a-zA-Z0-9._-])" >&2; exit 1 ;;
 esac
+if [[ "$MISSION" =~ ^\.+$ ]]; then
+  echo "mission-report: invalid mission name \"$MISSION\" (allowlist: [a-zA-Z0-9._-], not a dot-path)" >&2; exit 1
+fi
 
 MUGIWARA_DIR="${MUGIWARA_DIR:-.mugiwara}"
-STATE_FILE="$MUGIWARA_DIR/state.json"
+# state lives per (mission, member): solo = state/<mission>/state.json;
+# MEMBER env selects a team member's state, else the solo state.
+MEMBER="${MEMBER:-}"
+case "$MEMBER" in
+  *[!a-zA-Z0-9._-]*) echo "mission-report: invalid member \"$MEMBER\" (allowlist: [a-zA-Z0-9._-])" >&2; exit 1 ;;
+esac
+if [ -n "$MEMBER" ]; then
+  STATE_FILE="$MUGIWARA_DIR/state/$MISSION/$MEMBER.json"
+else
+  STATE_FILE="$MUGIWARA_DIR/state/$MISSION/state.json"
+fi
 REPORT_DIR="$MUGIWARA_DIR/reports"
 RESULTS_DIR="$MUGIWARA_DIR/results/$MISSION"
 REVIEW_DIR="$MUGIWARA_DIR/review"
 ISSUES_DIR="$MUGIWARA_DIR/issues"
 
-export STATE_FILE REPORT_DIR RESULTS_DIR REVIEW_DIR ISSUES_DIR MISSION
+export STATE_FILE REPORT_DIR RESULTS_DIR REVIEW_DIR ISSUES_DIR MISSION MUGIWARA_DIR
 node << 'NODE'
 const fs = require('fs');
 const path = require('path');
 
-const stateFile = process.env.STATE_FILE || ".mugiwara/state.json";
+const stateFile = process.env.STATE_FILE || ".mugiwara/state/unknown/state.json";
 const reportDir = process.env.REPORT_DIR || ".mugiwara/reports";
 const resultsDir = process.env.RESULTS_DIR || ".mugiwara/results/unknown";
 const reviewDir = process.env.REVIEW_DIR || ".mugiwara/review";
 const issuesDir = process.env.ISSUES_DIR || ".mugiwara/issues";
-const mugiDir = path.dirname(stateFile);
+const mugiDir = process.env.MUGIWARA_DIR || ".mugiwara";
 const mission = process.env.MISSION || "unknown";
 
 fs.mkdirSync(reportDir, { recursive: true });
@@ -56,6 +69,7 @@ const val = (obj, key, dflt) => {
 const now = new Date().toISOString().slice(0, 10);
 const reportFile = path.join(reportDir, now + "-" + mission + ".md");
 const lane = val(s, 'lane', 'n/a');
+const lanePeak = val(s, 'lane_peak', 'n/a');
 const laneReason = val(s, 'lane_reason', 'n/a');
 const mode = val(s, 'mode', 'n/a');
 const actor = val(s, 'actor', 'n/a');
@@ -63,6 +77,7 @@ const branch = val(s, 'branch', 'n/a');
 const wave = val(s, 'wave', 'n/a');
 const filesTouched = val(s, 'files_touched', 0);
 const locDelta = val(s, 'loc_delta', 0);
+const locChurn = val(s, 'loc_churn', 0);
 const sensitive = s ? (s.sensitive_paths || []) : [];
 const tasks = s ? (s.tasks || {}) : {};
 const blockers = val(s, 'blockers_open', 0);
@@ -213,6 +228,7 @@ report += "## Mission header\n\n| Field | Value |\n|-------|-------|\n";
 report += "| Mission | " + mission + " |\n";
 report += "| Branch | " + branch + " |\n";
 report += "| Lane | " + lane + " |\n";
+report += "| Lane peak | " + lanePeak + " |\n";
 report += "| Lane reason | " + laneReason + " |\n";
 report += "| Mode | " + mode + " |\n";
 report += "| Wave | " + wave + " |\n";
@@ -232,7 +248,7 @@ report += "| Total | " + tasksTotal + " |\n";
 report += "| Source | " + tasksSource + " |\n\n";
 
 report += "## What changed\n\n";
-report += filesTouched + " files, +" + locDelta + " LOC";
+report += filesTouched + " files, +" + locDelta + " LOC (" + locChurn + " churn)";
 if (sensitive.length) report += "\nSensitive paths: " + sensitive.join(", ");
 report += "\n\n";