@ionivetech/mugiwara 0.8.0 → 0.8.1

package/src/mission.ts

@@ -7,9 +7,11 @@ import { checkTrail, formatIssues } from './integrity.ts';
 import { checkMissionArtifacts } from './check-artifacts.ts';
 import { generateRollback } from './rollback.ts';
 import { writeProvenance } from './provenance.ts';
+import { loadPolicy } from './policy.ts';
+import { verifyReport } from './sign.ts';
 import { rankFiles, renderRouting } from './routing.ts';
-import { formatFootprint, measureContextChars, readBudgetConfig } from './budget.ts';
-import { budgetForLane, costEnvelope, appendCostEvent } from './cost.ts';
+import { formatFootprint, measureContextChars, readBudgetConfig, shouldCompress, compressThreshold } from './budget.ts';
+import { budgetForLane, costEnvelope, appendCostEvent, COMPRESSED_KIND } from './cost.ts';
 import { loadRegistry } from './evidence.ts';
 import { computeContextMetrics, contextStatus } from './context.ts';
 import { buildCostLedger, renderAdaptationSection } from './reporting.ts';
@@ -31,6 +33,52 @@ function primaryState(dir: string, files: string[]): Record<string, unknown> | n
   }
 }
 
+/** Extract tasks from state.json — handles nested tasks:{done,total} (current savepoint) and legacy flat fields. */
+function tasksFromState(state: Record<string, unknown> | null): { done: number; total: number } {
+  if (!state) return { done: 0, total: 0 };
+  const t = (state as Record<string, unknown>).tasks as { done?: unknown; total?: unknown } | undefined;
+  if (t && typeof t.done === 'number' && typeof t.total === 'number') return { done: t.done, total: t.total };
+  const done = Number((state as Record<string, unknown>).tasks_done);
+  const total = Number((state as Record<string, unknown>).tasks_total);
+  return { done: Number.isFinite(done) ? done : 0, total: Number.isFinite(total) ? total : 0 };
+}
+
+/** Fresh task counts from plan.md, with sub-plan fallback for large campaigns (>3 phases). */
+function countPlanTasks(missionDir: string): { done: number; total: number } {
+  let total = 0;
+  let done = 0;
+  const planFile = join(missionDir, 'plan.md');
+  if (existsSync(planFile)) {
+    try {
+      const text = readFileSync(planFile, 'utf8');
+      for (const line of text.split(/\r?\n/)) {
+        if (/^\s*-\s*\[[ xX]\]/.test(line)) {
+          total++;
+          if (/^\s*-\s*\[[xX]\]/.test(line)) done++;
+        }
+      }
+    } catch { /* best-effort */ }
+  }
+  if (total === 0) {
+    const subPlanDir = join(missionDir, 'sub-plan');
+    if (existsSync(subPlanDir)) {
+      try {
+        for (const f of readdirSync(subPlanDir)) {
+          if (!f.endsWith('.md')) continue;
+          const text = readFileSync(join(subPlanDir, f), 'utf8');
+          for (const line of text.split(/\r?\n/)) {
+            if (/^\s*-\s*\[[ xX]\]/.test(line)) {
+              total++;
+              if (/^\s*-\s*\[[xX]\]/.test(line)) done++;
+            }
+          }
+        }
+      } catch { /* best-effort */ }
+    }
+  }
+  return { done, total };
+}
+
 /** Files the mission changed, base..branch. Empty on any git failure — routing is best-effort. */
 function changedFiles(projectDir: string, state: Record<string, unknown> | null): string[] {
   const base = typeof state?.base_sha === 'string' ? state.base_sha : '';
@@ -101,6 +149,11 @@ export function resetMission(projectDir: string, keepLogs: boolean, force?: bool
     if (existsSync(join(root, 'lessons.md'))) kept.push('lessons.md');
     else if (existsSync(join(root, join('logs', 'lessons.md')))) kept.push(join('logs', 'lessons.md'));
   }
+  // index.md is the archive history — after a full reset (missions gone) its entries are dangling (point to deleted report.md). A reset is a fresh start, so clear it; next archive recreates "# Mission index" header.
+  if (removed.includes('missions') && existsSync(join(root, 'index.md'))) {
+    rmSync(join(root, 'index.md'));
+    removed.push('index.md');
+  }
   for (const f of ['config', 'manifest.json', 'backup']) {
     if (existsSync(join(root, f))) kept.push(f);
   }
@@ -122,10 +175,20 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
 
   // Closure integrity gate: the trail validates itself before it
   // folds. Dangling links, secrets, or missing evidence fail the archive.
+  // Card-number shapes are warn-only — they do not block archive.
   if (!dryRun) {
     const issues = checkTrail(dir, projectDir);
-    if (issues.length) {
-      throw new Error(`closure integrity gate failed — fix these before archiving:\n${formatIssues(issues)}`);
+    const blocking = issues.filter((i) => i.kind !== 'secret-warn' && i.severity !== 'warn');
+    if (blocking.length) {
+      throw new Error(`closure integrity gate failed — fix these before archiving:\n${formatIssues(blocking)}`);
+    }
+    if (issues.length && blocking.length === 0) {
+      // warn-only — log but do not fail
+      // console.warn is best-effort; archive proceeds
+      try {
+        const warnText = formatIssues(issues);
+        if (warnText) console.warn(`closure integrity warnings (non-blocking):\n${warnText}`);
+      } catch { /* ignore */ }
     }
     // Artifact gate (roadmap v0.8 item 4): Lane 2+ missions must carry
     // plan.md + flows/* evidence — a mission without its trail does not fold.
@@ -133,6 +196,20 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
     if (!artifacts.ok) {
       throw new Error(`archive artifact gate failed — missing: ${artifacts.missing.join(', ')} (lane ${artifacts.lane}). Write the evidence trail before archiving.`);
     }
+    // Attestation gate (D4): when attestation.required true, report must be signed and trusted.
+    try {
+      const policy = loadPolicy(projectDir);
+      if (policy?.attestation?.required) {
+        const v = verifyReport(projectDir, dir);
+        if (!v.ok) {
+          throw new Error(`closure integrity gate failed — attestation required but report not signed/trusted: ${v.message}`);
+        }
+      }
+    } catch (e) {
+      if ((e as Error).message.startsWith('closure integrity gate failed — attestation required')) throw e;
+      if ((e as Error).message.startsWith('unknown policy key')) throw e;
+      // other policy load errors are best-effort — do not block archive
+    }
   }
 
   const files = readdirSync(dir);
@@ -249,6 +326,38 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
       costSection += renderAdaptationSection(dir);
     } catch { /* best-effort */ }
 
+    // T4: auto-compress when context >80% budget — compress flows → stub, not throw
+    // (record compressed event; closure still recorded; hard gate only at 100%)
+    if (shouldCompress(budget, chars)) {
+      try {
+        const flowsDir = join(dir, 'flows');
+        const wavesDir = join(dir, 'waves');
+        const targetDir = existsSync(flowsDir) ? flowsDir : existsSync(wavesDir) ? wavesDir : null;
+        if (targetDir && existsSync(targetDir)) {
+          const flowFiles = readdirSync(targetDir).filter(f => f.endsWith('.md'));
+          if (flowFiles.length) {
+            const pct = Math.round((chars / budget) * 100);
+            const stub = `# Compressed trail\n\nTrail ${chars} chars exceeds ${pct}% of budget ${budget} (threshold ${compressThreshold(budget)}) — flows archived as stub to preserve budget. Original flows: ${flowFiles.join(', ')}\n`;
+            for (const f of flowFiles) {
+              try { rmSync(join(targetDir, f), { force: true }); } catch {}
+            }
+            writeFileSync(join(targetDir, '00-compressed.md'), stub);
+          }
+        }
+        appendCostEvent(dir, {
+          kind: COMPRESSED_KIND,
+          mission,
+          tokens_est: est,
+          budget: laneBudget,
+          status: 'compressed',
+          context_chars: chars,
+          context_status: ctxStatus,
+          context_metrics: metrics,
+        });
+        costSection += `\n| **Compressed** | yes — ${chars} chars >80% of ${budget} — flows stubbed as 00-compressed.md |`;
+      } catch { /* compress best-effort — never blocks archive */ }
+    }
+
     // Cost Governor: record the closure cost event — the mission's final
     // cost snapshot, folded into report.md with the rest of the trail.
     // (Phase 1 — native cost governor; pure append, never rewrites state.)
@@ -265,6 +374,7 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
     // M2: the closure event (with context_status possibly 'over') is recorded
     // BEFORE the hard gate throws — an over-budget closure still leaves a
     // ledger row so the over-budget condition is observable, never erased.
+    // T4: over 80% already compressed above; hard fail only at 100% preserves gate-selftest.
     if (budget && chars > budget) {
       throw new Error(`closure context budget failed — ${footprintLine}. Trim the trail or raise context_budget_chars.`);
     }
@@ -368,17 +478,23 @@ export function archiveMission(projectDir: string, mission: string, opts: { dryR
       });
       if (rb) kept.push(join('missions', mission, rb.file));
       try {
+        const st = tasksFromState(state);
+        const pt = countPlanTasks(dir);
+        const tasks_done = pt.total > 0 ? pt.done : st.done;
+        const tasks_total = pt.total > 0 ? pt.total : st.total;
+        const baseShaForNote = typeof state.base_sha === 'string' ? state.base_sha : undefined;
         writeProvenance(projectDir, dir, {
           mission,
           actor: typeof state.actor === 'string' ? state.actor : '',
           lane: typeof state.lane === 'string' ? state.lane : '',
           mode: typeof state.mode === 'string' ? state.mode : '',
           branch: state.branch,
-          tasks_done: Number(state.tasks_done) || 0,
-          tasks_total: Number(state.tasks_total) || 0,
+          tasks_done,
+          tasks_total,
           evidence: Array.isArray(state.evidence) ? (state.evidence as string[]) : [],
           models: stageModels,
-        });
+          base_sha: baseShaForNote,
+        } as never, baseShaForNote);
         kept.push(join('missions', mission, 'provenance.md'));
       } catch { /* provenance is additive; archive proceeds */ }
     }

package/src/policy.ts

@@ -20,10 +20,17 @@ export type MugiwaraPolicy = {
     require_human_approval?: string[];
   };
   evidence?: { required?: string[] };
+  integrity?: { extra_secret_patterns?: Array<{ pattern: string; label: string; severity?: 'block' | 'warn' }> };
+  attestation?: {
+    required?: boolean;
+    trusted_keys?: Array<{ id: string; pubkey: string; added?: string }>;
+    revoked?: Array<{ id: string; revoked?: string; reason?: string; pubkey?: string }>;
+  };
+  harness?: { require_enforcement?: boolean };
 };
 
 const POLICY_FILES = ['mugiwara.policy.yml', 'mugiwara.policy.yaml'];
-const KNOWN_ROOTS = ['lanes', 'gates', 'evidence'];
+const KNOWN_ROOTS = ['lanes', 'gates', 'evidence', 'integrity', 'attestation', 'harness'];
 
 /**
  * Minimal YAML subset: maps, `- item` string lists, scalars.
@@ -97,11 +104,238 @@ function scalar(v: string): unknown {
   return t;
 }
 
+/**
+ * Dedicated extractor for integrity.extra_secret_patterns list-of-maps.
+ * The minimal YAML subset parser only handles scalar lists; this scans the raw
+ * text line-by-line for map items so both forms work:
+ *   - { pattern: "\\b...\\b", label: "NIK" }
+ *   - - pattern: "\\b...\\b"
+ *     label: "NIK"
+ *     severity: warn
+ */
+export function extractExtraSecretPatterns(text: string): Array<{ pattern: string; label: string; severity?: string }> {
+  const lines = text.split(/\r?\n/);
+  let inBlock = false;
+  let baseIndent = -1;
+  const out: Array<Record<string, string>> = [];
+  let current: Record<string, string> | null = null;
+  let currentIndent = -1;
+  for (const rawLine of lines) {
+    const noComment = rawLine.replace(/(^|\s)#.*$/, '');
+    if (!noComment.trim()) continue;
+    const indent = noComment.length - noComment.trimStart().length;
+    const trimmed = noComment.trim();
+    if (!inBlock) {
+      if (trimmed.startsWith('extra_secret_patterns:')) {
+        inBlock = true;
+        baseIndent = indent;
+        continue;
+      }
+    } else {
+      // exit if a sibling key at same or shallower indent (not a list item) appears
+      if (indent <= baseIndent && !trimmed.startsWith('-') && trimmed.includes(':')) {
+        break;
+      }
+      if (trimmed.startsWith('-')) {
+        if (current) out.push(current);
+        current = {};
+        currentIndent = indent;
+        const afterDash = trimmed.slice(1).trim();
+        if (!afterDash) continue;
+        if (afterDash.startsWith('{') && afterDash.endsWith('}')) {
+          const inner = afterDash.slice(1, -1);
+          for (const part of inner.split(',')) {
+            const colon = part.indexOf(':');
+            if (colon === -1) continue;
+            const k = part.slice(0, colon).trim();
+            const v = part.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+            if (k && v) current[k] = v;
+          }
+        } else if (afterDash.includes(':')) {
+          const colon = afterDash.indexOf(':');
+          const k = afterDash.slice(0, colon).trim();
+          const v = afterDash.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+          if (k && v) current[k] = v;
+        } else {
+          const v = afterDash.replace(/^["']|["']$/g, '');
+          if (v) current['pattern'] = v;
+        }
+      } else if (current && trimmed.includes(':')) {
+        if (indent > currentIndent) {
+          const colon = trimmed.indexOf(':');
+          const k = trimmed.slice(0, colon).trim();
+          const v = trimmed.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+          if (k && v) current[k] = v;
+        } else if (indent <= baseIndent) {
+          break;
+        }
+      }
+    }
+  }
+  if (current) out.push(current);
+  return out.filter((o) => typeof o.pattern === 'string' && typeof o.label === 'string' && o.pattern.length > 0) as Array<{ pattern: string; label: string; severity?: string }>;
+}
+
+/**
+ * Extract attestation block: handles both inline `{ id: "...", pubkey: "ed25519:..." }`
+ * and multiline lists. Scans inside `attestation:` indented block so
+ * `evidence: required:` is not confused.
+ */
+export function extractAttestation(text: string): {
+  required?: boolean;
+  trusted_keys?: Array<Record<string, string>>;
+  revoked?: Array<Record<string, string>>;
+} | null {
+  const lines = text.split(/\r?\n/);
+  let attBase = -1;
+  let inAtt = false;
+  let required: boolean | undefined;
+  const trusted: Array<Record<string, string>> = [];
+  const revoked: Array<Record<string, string>> = [];
+  // collection state
+  let collecting: 'trusted' | 'revoked' | null = null;
+  let collectBase = -1;
+  let current: Record<string, string> | null = null;
+  let curIndent = -1;
+
+  const flush = () => {
+    if (!current) return;
+    if (collecting === 'trusted') trusted.push(current);
+    else if (collecting === 'revoked') revoked.push(current);
+    current = null;
+  };
+
+  for (let idx = 0; idx < lines.length; idx++) {
+    const rawLine = lines[idx];
+    const noComment = rawLine.replace(/(^|\s)#.*$/, '');
+    if (!noComment.trim()) continue;
+    const indent = noComment.length - noComment.trimStart().length;
+    const trimmed = noComment.trim();
+
+    if (!inAtt) {
+      if (trimmed === 'attestation:' || trimmed.startsWith('attestation:')) {
+        // handle `attestation: { ... }` inline — not used, but parse required if present
+        const after = trimmed.slice('attestation:'.length).trim();
+        if (after.startsWith('{')) {
+          // inline map form not needed for MVP
+          return null;
+        }
+        inAtt = true;
+        attBase = indent;
+        // if there is a value after colon on same line (e.g., attestation: foo) ignore
+        continue;
+      }
+      continue;
+    }
+
+    // inside attestation block
+    // exit attestation when sibling root key at same/shallower indent
+    if (indent <= attBase && !trimmed.startsWith('-') && trimmed.includes(':')) {
+      flush();
+      break;
+    }
+
+    // handle collecting state first
+    if (collecting) {
+      // exiting collection to sibling key inside attestation (e.g., revoked: after trusted_keys:)
+      if (indent <= collectBase && !trimmed.startsWith('-') && trimmed.includes(':')) {
+        flush();
+        collecting = null;
+        // fall through to process this line as att child
+      } else if (trimmed.startsWith('-')) {
+        flush();
+        current = {};
+        curIndent = indent;
+        const afterDash = trimmed.slice(1).trim();
+        if (!afterDash) continue;
+        if (afterDash.startsWith('{') && afterDash.endsWith('}')) {
+          const inner = afterDash.slice(1, -1);
+          for (const part of inner.split(',')) {
+            const colon = part.indexOf(':');
+            if (colon === -1) continue;
+            const k = part.slice(0, colon).trim();
+            const v = part.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+            if (k && v) current[k] = v;
+          }
+        } else if (afterDash.includes(':')) {
+          const colon = afterDash.indexOf(':');
+          const k = afterDash.slice(0, colon).trim();
+          const v = afterDash.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+          if (k && v) current[k] = v;
+        } else {
+          const v = afterDash.replace(/^["']|["']$/g, '');
+          if (v) current['id'] = v;
+        }
+        continue;
+      } else if (current && trimmed.includes(':')) {
+        if (indent > curIndent) {
+          const colon = trimmed.indexOf(':');
+          const k = trimmed.slice(0, colon).trim();
+          const v = trimmed.slice(colon + 1).trim().replace(/^["']|["']$/g, '');
+          if (k && v) current[k] = v;
+          continue;
+        }
+      }
+      // if still collecting but line is not part of current item, skip?
+      if (collecting) continue;
+    }
+
+    // not collecting (or just exited) — look for att children
+    if (trimmed.startsWith('required:')) {
+      const v = trimmed.slice('required:'.length).trim().replace(/^["']|["']$/g, '');
+      if (v === 'true') required = true;
+      else if (v === 'false') required = false;
+      continue;
+    }
+    if (trimmed.startsWith('trusted_keys:')) {
+      const after = trimmed.slice('trusted_keys:'.length).trim();
+      // handle inline empty `[]`
+      if (after === '[]') continue;
+      collecting = 'trusted';
+      collectBase = indent;
+      current = null;
+      // if inline list with one map on same line? e.g., trusted_keys: [{ id: "a", pubkey: "x" }]
+      // MVP not needed; empty case already handled
+      continue;
+    }
+    if (trimmed.startsWith('revoked:')) {
+      const after = trimmed.slice('revoked:'.length).trim();
+      if (after === '[]') continue;
+      collecting = 'revoked';
+      collectBase = indent;
+      current = null;
+      continue;
+    }
+  }
+  flush();
+  if (required === undefined && trusted.length === 0 && revoked.length === 0) return null;
+  const out: { required?: boolean; trusted_keys?: Array<Record<string, string>>; revoked?: Array<Record<string, string>> } = {};
+  if (required !== undefined) out.required = required;
+  if (trusted.length) out.trusted_keys = trusted;
+  if (revoked.length) out.revoked = revoked;
+  return out;
+}
+
 export function loadPolicy(projectDir: string): MugiwaraPolicy | null {
   for (const name of POLICY_FILES) {
     const file = join(projectDir, name);
     if (!existsSync(file)) continue;
-    return normalize(parsePolicyYaml(readFileSync(file, 'utf8')));
+    const text = readFileSync(file, 'utf8');
+    const raw = parsePolicyYaml(text);
+    const extra = extractExtraSecretPatterns(text);
+    if (extra.length) {
+      if (!raw.integrity || typeof raw.integrity !== 'object' || Array.isArray(raw.integrity)) raw.integrity = {};
+      (raw.integrity as Record<string, unknown>).extra_secret_patterns = extra;
+    }
+    const att = extractAttestation(text);
+    if (att) {
+      if (!raw.attestation || typeof raw.attestation !== 'object' || Array.isArray(raw.attestation)) raw.attestation = {};
+      const a = raw.attestation as Record<string, unknown>;
+      if (att.required !== undefined) a.required = att.required;
+      if (att.trusted_keys) a.trusted_keys = att.trusted_keys;
+      if (att.revoked) a.revoked = att.revoked;
+    }
+    return normalize(raw);
   }
   return null;
 }
@@ -128,6 +362,58 @@ function normalize(raw: Record<string, unknown>): MugiwaraPolicy {
   }
   const evidence = raw.evidence as Record<string, unknown> | undefined;
   if (evidence && Array.isArray(evidence.required)) out.evidence = { required: strings(evidence.required) };
+  const integrity = raw.integrity as Record<string, unknown> | undefined;
+  if (integrity && Array.isArray(integrity.extra_secret_patterns)) {
+    const arr = integrity.extra_secret_patterns as unknown[];
+    const cleaned: Array<{ pattern: string; label: string; severity?: 'block' | 'warn' }> = [];
+    for (const e of arr) {
+      if (!e || typeof e !== 'object') continue;
+      const rec = e as Record<string, unknown>;
+      if (typeof rec.pattern !== 'string' || typeof rec.label !== 'string') continue;
+      const sev = rec.severity === 'warn' ? 'warn' as const : rec.severity === 'block' ? 'block' as const : undefined;
+      const entry: { pattern: string; label: string; severity?: 'block' | 'warn' } = { pattern: rec.pattern, label: rec.label };
+      if (sev) entry.severity = sev;
+      cleaned.push(entry);
+    }
+    if (cleaned.length) out.integrity = { extra_secret_patterns: cleaned };
+  }
+  const att = raw.attestation as Record<string, unknown> | undefined;
+  if (att) {
+    const a: NonNullable<MugiwaraPolicy['attestation']> = {};
+    if (typeof att.required === 'boolean') a.required = att.required;
+    if (Array.isArray(att.trusted_keys)) {
+      const cleanedTk: Array<{ id: string; pubkey: string; added?: string }> = [];
+      for (const e of att.trusted_keys as unknown[]) {
+        if (!e || typeof e !== 'object') continue;
+        const rec = e as Record<string, unknown>;
+        if (typeof rec.id !== 'string' || typeof rec.pubkey !== 'string') continue;
+        if (!rec.id.trim() || !rec.pubkey.trim()) continue;
+        const entry: { id: string; pubkey: string; added?: string } = { id: rec.id.trim(), pubkey: rec.pubkey.trim() };
+        if (typeof rec.added === 'string' && rec.added.trim()) entry.added = rec.added.trim();
+        cleanedTk.push(entry);
+      }
+      if (cleanedTk.length) a.trusted_keys = cleanedTk;
+    }
+    if (Array.isArray(att.revoked)) {
+      const cleanedRv: Array<{ id: string; revoked?: string; reason?: string; pubkey?: string }> = [];
+      for (const e of att.revoked as unknown[]) {
+        if (!e || typeof e !== 'object') continue;
+        const rec = e as Record<string, unknown>;
+        if (typeof rec.id !== 'string' || !rec.id.trim()) continue;
+        const entry: { id: string; revoked?: string; reason?: string; pubkey?: string } = { id: rec.id.trim() };
+        if (typeof rec.revoked === 'string' && rec.revoked.trim()) entry.revoked = rec.revoked.trim();
+        if (typeof rec.reason === 'string' && rec.reason.trim()) entry.reason = rec.reason.trim();
+        if (typeof rec.pubkey === 'string' && rec.pubkey.trim()) entry.pubkey = rec.pubkey.trim();
+        cleanedRv.push(entry);
+      }
+      if (cleanedRv.length) a.revoked = cleanedRv;
+    }
+    if (a.required !== undefined || a.trusted_keys || a.revoked) out.attestation = a;
+  }
+  const harness = raw.harness as Record<string, unknown> | undefined;
+  if (harness && typeof harness.require_enforcement === 'boolean') {
+    out.harness = { require_enforcement: harness.require_enforcement };
+  }
   return out;
 }
 
@@ -154,3 +440,70 @@ export function matchedGlobs(paths: string[], globs: string[]): string[] {
 export function effectiveThreshold(configured: number, policyValue: number | undefined): number {
   return Math.max(configured, policyValue ?? 0);
 }
+
+// ── Harness enforcement (D8) ────────────────────────────────────────────────
+// Only opencode has runtime write-scope enforcement; the other 11 harnesses
+// are rules-based. `harness.require_enforcement: true` refuses to run where
+// the harness is not enforced.
+
+/** Detect current harness. Mirrors savepoint.sh logic. */
+export function detectHarness(projectDir?: string): string {
+  const e = process.env;
+  const has = (v: string | undefined) => v !== undefined && v !== '';
+  if (has(e.CLAUDECODE) || has(e.CLAUDE_CODE_ENTRYPOINT) || (typeof e.ANTHROPIC_MODEL === 'string' && /claude/i.test(e.ANTHROPIC_MODEL))) return 'claude';
+  if (has(e.OPENCODE) || has(e.OPENCODE_TOKENS_FILE)) return 'opencode';
+  const candidates = [
+    projectDir ? join(projectDir, '.opencode', 'config.json') : null,
+    join(process.cwd(), '.opencode', 'config.json'),
+  ].filter(Boolean) as string[];
+  for (const p of candidates) {
+    try { if (existsSync(p)) return 'opencode'; } catch { /* ignore */ }
+  }
+  if (has(e.CURSOR) || has(e.VSCODE_GIT_ASKPASS_NODE)) return 'cursor';
+  return 'unknown';
+}
+
+/** Only opencode is runtime-enforced. */
+export function isEnforcedHarness(projectDir?: string): boolean {
+  return detectHarness(projectDir) === 'opencode';
+}
+
+/** Pure check: returns error message when policy requires enforcement but harness is rules-based, else null. */
+export function getHarnessEnforcementError(projectDir: string): string | null {
+  let policy: MugiwaraPolicy | null;
+  try { policy = loadPolicy(projectDir); } catch (e) { throw e; }
+  if (!policy?.harness?.require_enforcement) return null;
+  if (isEnforcedHarness(projectDir)) return null;
+  const h = detectHarness(projectDir);
+  return `harness enforcement required but current harness is rules-based only \u2014 use opencode or set harness.require_enforcement:false (detected: ${h})`;
+}
+
+/** Fail closed when policy requires enforcement but harness is rules-based. */
+export function enforceHarnessPolicy(projectDir: string): void {
+  const err = getHarnessEnforcementError(projectDir);
+  if (!err) return;
+  console.error(`\u2717 ${err}`);
+  process.exit(1);
+}
+
+/** Alias for CLI import convenience. */
+export const checkHarnessEnforcement = enforceHarnessPolicy;
+
+// ── Lane-aware gates (T3) ───────────────────────────────────────────────────
+// Direct → minimal (typecheck+build only), lean → +validate-content, standard+
+// → +evals/retrieval/conformance/benchmark. Single source for gate-selftest
+// and the franky-gates skill doc. Full = 12 steps, direct = 3 steps.
+export const GATE_STEPS_BY_LANE: Record<string, string[]> = {
+  direct: ['build-hooks:check', 'typecheck', 'build'],
+  lean: ['build-hooks:check', 'typecheck', 'build', 'validate-content', 'lane-base', 'check-doc-links'],
+  standard: ['build-hooks:check', 'typecheck', 'build', 'validate-content', 'lane-base', 'check-doc-links', 'test:coverage', 'coverage-gate', 'verify-install'],
+  full: ['build-hooks:check', 'typecheck', 'build', 'validate-content', 'lane-base', 'check-doc-links', 'test:coverage', 'coverage-gate', 'verify-install', 'run-evals', 'retrieval-eval', 'conformance'],
+};
+
+export function gatesForLane(lane: string): string[] {
+  return GATE_STEPS_BY_LANE[lane] ?? GATE_STEPS_BY_LANE.full;
+}
+
+export function isLaneAwareGateStep(step: string, lane: string): boolean {
+  return gatesForLane(lane).includes(step);
+}

package/src/provenance.ts

@@ -75,16 +75,34 @@ export function renderProvenanceMd(note: string, sha: string | null): string {
   return lines.join('\n') + '\n';
 }
 
-export function attachGitNote(projectDir: string, branch: string, note: string): { sha: string } | null {
+export function attachGitNote(projectDir: string, branch: string, note: string, baseSha?: string): { sha: string; count: number } | null {
   try {
-    let sha: string;
+    const range = baseSha ? `${baseSha}..${branch}` : branch;
+    let shas: string[] = [];
     try {
-      sha = git(projectDir, ['rev-parse', '--verify', branch]);
+      const raw = git(projectDir, ['rev-list', range]);
+      shas = raw.split('\n').filter(Boolean);
     } catch {
-      sha = git(projectDir, ['rev-parse', 'HEAD']);
+      // rev-list failed (unknown baseSha/branch) — fall back to single head
+      shas = [];
     }
-    git(projectDir, ['notes', '--ref=mugiwara', 'add', '-f', '-m', note, sha]);
-    return { sha };
+    // ponytail: cap at 200 commits, fallback to head-only beyond
+    if (shas.length > 200) {
+      console.warn(`attachGitNote: range ${shas.length} >200, falling back to head-only`);
+      shas = [];
+    }
+    let targets = shas;
+    if (!targets.length) {
+      try {
+        targets = [git(projectDir, ['rev-parse', '--verify', branch])];
+      } catch {
+        targets = [git(projectDir, ['rev-parse', 'HEAD'])];
+      }
+    }
+    for (const sha of targets) {
+      git(projectDir, ['notes', '--ref=mugiwara', 'add', '-f', '-m', note, sha]);
+    }
+    return { sha: targets[0], count: targets.length };
   } catch {
     // not a repo, detached oddities, or notes disabled — degrade honestly
     return null;
@@ -104,13 +122,15 @@ export function blamePath(projectDir: string, path: string): string {
     const note = git(projectDir, ['notes', '--ref=mugiwara', 'show', sha]);
     return `${path} @ ${sha.slice(0, 7)}\n${note}`;
   } catch {
-    return `${path} @ ${sha.slice(0, 7)}\n(no mugiwara provenance note on this commit)`;
+    return `${path} @ ${sha.slice(0, 7)}\nno per-commit note — see .mugiwara/missions/<m>/provenance.md`;
   }
 }
 
 /** Closure hook: write provenance.md + attach the git note. */
-export function writeProvenance(projectDir: string, missionDir: string, state: NoteSource): void {
+export function writeProvenance(projectDir: string, missionDir: string, state: NoteSource & { base_sha?: string }, baseSha?: string): void {
   const note = buildNote(state);
-  const attached = attachGitNote(projectDir, state.branch, note);
+  const resolvedBase = baseSha ?? (typeof (state as Record<string, unknown>).base_sha === 'string' ? (state as Record<string, unknown>).base_sha as string : undefined);
+  const cleanBase = resolvedBase && resolvedBase !== 'unknown' ? resolvedBase : undefined;
+  const attached = attachGitNote(projectDir, state.branch, note, cleanBase);
   writeFileSync(join(missionDir, 'provenance.md'), renderProvenanceMd(note, attached ? attached.sha : null));
 }