@ionivetech/mugiwara 0.8.0 → 0.8.1

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);
+}

package/src/cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // src/cli.ts
-import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
@@ -12,7 +12,7 @@ import { installTo, removeInstalled, VERSION, ensureProjectGitignore, removeProj
 import { manifestPath, readManifest, writeManifest, type Scope } from './manifest.ts';
 import { resetMission, archiveMission } from './mission.ts';
 import { runScript, RUNNABLE } from './run.ts';
-import { readContinue, readState, resolveContinue, formatTable, formatResume, gitActor } from './continue.ts';
+import { readContinue, readState, resolveContinue, formatTable, formatResume, gitActor, hasLegacyLayout, CURRENT_SCHEMA_VERSION } from './continue.ts';
 import { blamePath } from './provenance.ts';
 import { signReport, verifyReport, ensurePureKey, hasMinisign } from './sign.ts';
 import { ensureConfig } from './config.ts';
@@ -20,6 +20,7 @@ import { costEnvelope } from './cost.ts';
 import { computeLiveSlop } from './slop.ts';
 import { loadRegistry } from './evidence.ts';
 import { buildCostLedger, toCostJSON } from './reporting.ts';
+import { enforceHarnessPolicy } from './policy.ts';
 
 const str = (v: FlagValue): string | undefined => (typeof v === 'string' ? v : undefined);
 const flag = (v: FlagValue): boolean => v === true;
@@ -28,16 +29,20 @@ export async function run(argv: string[]): Promise<void> {
   const { command, flags, _ } = parseArgs(argv);
   if (flag(flags.help) || command === 'help') return help();
   if (flag(flags.version)) { console.log(`mugiwara ${VERSION}`); return; }
-  // `continue` and `status` are read-only position commands: dispatch before
-  // config bootstrap so a fresh project never gets a .mugiwara/config created
-  // and no setup chatter is printed before missions/members are listed.
-  if (command === 'continue' || command === 'status') {
-    return command === 'continue' ? continueCmd(flags, _) : statusCmd(flags);
+  // harness.require_enforcement — enterprise gate: refuse rules-based harnesses
+  // (only opencode is runtime-enforced). Covers run/savepoint/archive/status
+  // + other workflow commands; install/update/uninstall/list are setup and bypass.
+  {
+    const bypass = new Set(['install', 'update', 'uninstall', 'list']);
+    if (!bypass.has(command)) {
+      const projectDirForHarness = resolve(str(flags.project) ?? process.cwd());
+      enforceHarnessPolicy(projectDirForHarness);
+    }
   }
-  // A command on a fresh project must be immediately usable — bootstrap the
-  // default .mugiwara/config when it is missing (not only at install time).
-  // Skipped for install/update --dry-run: a dry run must not mutate the
-  // project (the installer writes the config itself on a real install).
+  // Bootstrap default .mugiwara/config on any command when missing — including
+  // `continue`/`status` — so tier-3 agents that only mkdir .mugiwara still get
+  // a config. Also covered by readConfig() auto-create for non-CLI entry.
+  // Skipped for install/update --dry-run: a dry run must not mutate the project.
   const isDryRunInstall = (command === 'install' || command === 'update') && flag(flags.dryRun);
   if (!isDryRunInstall) {
     const projectDir = resolve(str(flags.project) ?? process.cwd());
@@ -45,6 +50,9 @@ export async function run(argv: string[]): Promise<void> {
       console.log(`default .mugiwara/config written at ${join(projectDir, '.mugiwara', 'config')} (edit it to customise)`);
     }
   }
+  if (command === 'continue' || command === 'status') {
+    return command === 'continue' ? continueCmd(flags, _) : statusCmd(flags);
+  }
   switch (command) {
     case 'install': return install(flags);
     case 'update': return install({ ...flags, force: true });
@@ -61,6 +69,7 @@ export async function run(argv: string[]): Promise<void> {
     case 'blame': return blameCmd(flags, _);
     case 'handoff': return handoffCmd(flags, _);
     case 'sign': return signCmd(flags, _);
+    case 'migrate': return migrateCmd(flags);
     default: throw new Error(`Unknown command: ${command}`);
   }
 }
@@ -282,9 +291,27 @@ async function uninstall(flags: Args['flags']): Promise<void> {
   console.log(`OK removed ${removed.length} files`);
 }
 
+function legacyWarning(projectDir: string): void {
+  if (hasLegacyLayout(projectDir)) {
+    console.error('⚠ legacy layout detected (v0.6 .mugiwara/state/ — run `mugiwara migrate` to move to missions/)');
+  }
+}
+
+function schemaWarnings(projectDir: string): void {
+  const states = readState(projectDir);
+  for (const s of states) {
+    const v = s.schema_version;
+    if (v !== CURRENT_SCHEMA_VERSION) {
+      const wrote = v === null || v === undefined || v === '' ? 'unknown' : String(v);
+      console.error(`⚠ state written by v${wrote} (mission ${s.mission}${s.member ? `/${s.member}` : ''}) — current expects v${CURRENT_SCHEMA_VERSION} — run \`mugiwara migrate\``);
+    }
+  }
+}
+
 function list(flags: Args['flags']): void {
   const home = homedir();
   const projectDir = resolve(str(flags.project) ?? process.cwd());
+  legacyWarning(projectDir);
   let found = false;
   for (const [label, file] of [
     ['project', manifestPath({ scope: 'project', projectDir, home })],
@@ -316,6 +343,8 @@ function list(flags: Args['flags']): void {
  */
 function continueCmd(flags: Args['flags'], positionals: string[]): void {
   const projectDir = resolve(str(flags.project) ?? process.cwd());
+  legacyWarning(projectDir);
+  schemaWarnings(projectDir);
   const [mission, member] = positionals.slice(1);
   let entries = readContinue(projectDir);
 
@@ -358,6 +387,8 @@ function continueCmd(flags: Args['flags'], positionals: string[]): void {
 /** `mugiwara status` — one screen of computed mission state, no model needed. */
 function statusCmd(flags: Args['flags']): void {
   const projectDir = resolve(str(flags.project) ?? process.cwd());
+  legacyWarning(projectDir);
+  schemaWarnings(projectDir);
   const states = readState(projectDir);
   if (!states.length) { console.log('No mission state on disk.'); return; }
   const actor = flag(flags.all) ? null : gitActor(projectDir);
@@ -508,6 +539,88 @@ function handoffCmd(flags: Args['flags'], positionals: string[]): void {
   console.log(`\nwritten: ${out}`);
 }
 
+export function migrateCmd(flags: Args['flags']): void {
+  const projectDir = resolve(str(flags.project) ?? process.cwd());
+  const dryRun = flag(flags.dryRun);
+  const legacyState = join(projectDir, '.mugiwara', 'state');
+  const legacyContinue = join(projectDir, '.mugiwara', 'continue');
+  const missionsRoot = join(projectDir, '.mugiwara', 'missions');
+  const moves: Array<{ src: string; dest: string }> = [];
+
+  const collect = (srcRoot: string, isContinue: boolean) => {
+    if (!existsSync(srcRoot)) return;
+    const walk = (dir: string) => {
+      for (const e of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, e.name);
+        if (e.isDirectory()) walk(full);
+        else if (e.isFile() && e.name.endsWith('.json')) {
+          const rel = full.slice(srcRoot.length + 1);
+          let destRel: string;
+          if (isContinue) {
+            const parts = rel.split('/');
+            const file = parts.pop()!;
+            const mission = parts.join('/');
+            const stem = file.slice(0, -'.json'.length);
+            let destFile: string;
+            if (stem === 'state') destFile = 'continue.json';
+            else destFile = `continue-${stem}.json`;
+            destRel = mission ? join(mission, destFile) : destFile;
+          } else {
+            destRel = rel;
+          }
+          moves.push({ src: full, dest: join(missionsRoot, destRel) });
+        }
+      }
+    };
+    walk(srcRoot);
+  };
+  collect(legacyState, false);
+  collect(legacyContinue, true);
+
+  // legacy flat: .mugiwara/state.json style? treat any top-level .mugiwara/state*.json as not legacy missions but still warn
+  // Already covered by state/ dir; nothing more to collect.
+
+  if (!moves.length) {
+    if (!existsSync(legacyState) && !existsSync(legacyContinue)) {
+      console.log('no legacy layout found (.mugiwara/state/ does not exist)');
+    } else {
+      console.log('no legacy state files to migrate');
+    }
+    return;
+  }
+
+  for (const m of moves) {
+    console.log(`${dryRun ? 'would migrate' : 'migrated'} ${m.src} → ${m.dest}`);
+    if (!dryRun) {
+      mkdirSync(dirname(m.dest), { recursive: true });
+      try {
+        const raw = JSON.parse(readFileSync(m.src, 'utf8')) as Record<string, unknown>;
+        raw.schema_version = CURRENT_SCHEMA_VERSION;
+        writeFileSync(m.dest, JSON.stringify(raw, null, 2) + '\n');
+        rmSync(m.src, { force: true });
+      } catch {
+        try { renameSync(m.src, m.dest); } catch { /* ignore */ }
+      }
+    }
+  }
+  if (!dryRun) {
+    const prune = (root: string) => {
+      if (!existsSync(root)) return;
+      const walkPrune = (dir: string) => {
+        for (const e of readdirSync(dir, { withFileTypes: true })) {
+          if (e.isDirectory()) walkPrune(join(dir, e.name));
+        }
+        try { if (readdirSync(dir).length === 0) rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+      };
+      walkPrune(root);
+      try { if (existsSync(root) && readdirSync(root).length === 0) rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+    };
+    prune(legacyState);
+    prune(legacyContinue);
+  }
+  console.log(`${dryRun ? 'would migrate' : 'migrated'} ${moves.length} file(s)${dryRun ? ' (dry run)' : ''}`);
+}
+
 /** `mugiwara sign <mission>` / `--verify` / `--gen-key` — optional attestation. */
 function signCmd(flags: Args['flags'], _: string[]): void {
   const projectDir = resolve(str(flags.project) ?? process.cwd());
@@ -562,10 +675,12 @@ Usage:
   mugiwara sign <m>      attestation: sign report.md (auto/minisign/pure/off; --verify to check)
   mugiwara sign --gen-key [--backend pure|minisign]
                          create signing keys (pure ed25519 default)
+  mugiwara migrate [--dry-run] [--project <dir>]
+                          move legacy .mugiwara/state/ layout to .mugiwara/missions/
   mugiwara run <script> [args...]
-                         run a bundled harness script here (${RUNNABLE.join(', ')})
+                          run a bundled harness script here (${RUNNABLE.join(', ')})
   mugiwara savepoint <mission> [member] [flow] [mode]
-                         shorthand for: mugiwara run savepoint.sh ...
+                          shorthand for: mugiwara run savepoint.sh ...
   mugiwara --help        this help
   mugiwara --version     print version
 

package/src/config.ts

@@ -40,6 +40,12 @@ function configPaths(projectDir: string): string[] {
  * blank lines are skipped; values are trimmed.
  */
 export function readConfig(projectDir: string): Record<string, string> {
+  try {
+    const file = join(projectDir, '.mugiwara', 'config');
+    let exists = false;
+    try { exists = lstatSync(file).isFile() || lstatSync(file).isSymbolicLink(); } catch { exists = false; }
+    if (!exists) ensureConfig(projectDir);
+  } catch { /* best-effort: auto-create must not break reads */ }
   const out: Record<string, string> = {};
   for (const file of configPaths(projectDir)) {
     if (!existsSync(file)) continue;

package/src/continue.ts

@@ -14,6 +14,32 @@ import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join } from 'node:path';
 
+export const CURRENT_SCHEMA_VERSION = 2;
+
+/**
+ * v0.6 legacy layout: `.mugiwara/state/<mission>/<member>.json`
+ * (and `.mugiwara/continue/<mission>/...`) is invisible to v0.8
+ * `missions/` readers. Detect it so status/continue can warn.
+ */
+export function hasLegacyLayout(projectDir: string): boolean {
+  for (const legacy of [join(projectDir, '.mugiwara', 'state'), join(projectDir, '.mugiwara', 'continue')]) {
+    if (!existsSync(legacy)) continue;
+    try {
+      const walk = (dir: string): boolean => {
+        for (const e of readdirSync(dir, { withFileTypes: true })) {
+          if (e.isFile() && e.name.endsWith('.json')) return true;
+          if (e.isDirectory() && walk(join(dir, e.name))) return true;
+        }
+        return false;
+      };
+      if (walk(legacy)) return true;
+    } catch { /* ignore */ }
+  }
+  // also legacy flat files at .mugiwara/state.json style already handled by missions scan,
+  // but treat top-level .mugiwara/state/*.json absence as no legacy
+  return false;
+}
+
 /** Mission/member allowlist — identical to savepoint.sh and mission.ts. */
 const SAFE = /^[A-Za-z0-9._-]+$/;
 const isSafeKey = (s: string): boolean => SAFE.test(s) && !/^\.+$/.test(s);
@@ -51,6 +77,7 @@ export type StateEntry = ContinueEntry & {
   budget_status: string;
   files_touched: number;
   evidence: string[];
+  schema_version: number | string | null;
 };
 
 const num = (v: unknown): number => {
@@ -148,6 +175,7 @@ export function readContinue(projectDir: string): ContinueEntry[] {
 export function readState(projectDir: string): StateEntry[] {
   return scan(projectDir, 'state', (r, member) => {
     const tasks = (r.tasks ?? {}) as Record<string, unknown>;
+    const sv = r.schema_version;
     return {
       mission: text(r.mission),
       member,
@@ -178,6 +206,7 @@ export function readState(projectDir: string): StateEntry[] {
       budget_status: text(r.budget_status) || 'ok',
       files_touched: num(r.files_touched),
       evidence: Array.isArray(r.evidence) ? r.evidence.map(text).filter(Boolean) : [],
+      schema_version: typeof sv === 'number' || typeof sv === 'string' ? sv : null,
     };
   });
 }

package/src/cost.ts

@@ -149,6 +149,9 @@ export function appendCostEvent(missionDir: string, event: Omit<CostEvent, 'ts'>
   appendFileSync(join(missionDir, COST_EVENTS_FILE), JSON.stringify(line) + '\n', 'utf8');
 }
 
+// ── Auto-compress (T4) — compressed event kind ───────────────────────────────
+export const COMPRESSED_KIND = 'compressed';
+
 // ── Optimization decision records — structured rows in decisions.md ──
 
 export type OptDecision = {

package/src/integrity.ts

@@ -10,29 +10,73 @@
 //   3. Evidence — cited wave/evidence paths exist.
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { isAbsolute, join, relative } from 'node:path';
+import { loadPolicy } from './policy.ts';
 
-export type IntegrityIssue = { kind: 'dangling-path' | 'secret' | 'evidence' | 'evidence-thin'; detail: string };
+export type IntegrityIssue = {
+  kind: 'dangling-path' | 'secret' | 'secret-warn' | 'evidence' | 'evidence-thin';
+  detail: string;
+  severity?: 'block' | 'warn';
+};
 
-const SECRET_PATTERNS: Array<[RegExp, string]> = [
-  [/AKIA[0-9A-Z]{16}/, 'AWS access key id'],
-  [/-----BEGIN [A-Z ]*PRIVATE KEY-----/, 'private key block'],
-  [/gh[pousr]_[A-Za-z0-9]{20,}/, 'GitHub token'],
-  [/xox[baprs]-[A-Za-z0-9-]{10,}/, 'Slack token'],
-  [/sk-[A-Za-z0-9]{32,}/, 'API key (sk-…)'],
-  [/eyJhbGciOi[A-Za-z0-9_.-]{20,}/, 'JWT pasted verbatim'],
-  [/(api[_-]?key|secret|passwd|password)\s*[=:]\s*["'][^"'\s]{8,}["']/i, 'credential assignment'],
+export type SecretSeverity = 'block' | 'warn';
+export type SecretPattern = [RegExp, string, SecretSeverity];
+
+export const SECRET_PATTERNS: Array<SecretPattern> = [
+  [/AKIA[0-9A-Z]{16}/, 'AWS access key id', 'block'],
+  [/-----BEGIN [A-Z ]*PRIVATE KEY-----/, 'private key block', 'block'],
+  [/gh[pousr]_[A-Za-z0-9]{20,}/, 'GitHub token', 'block'],
+  [/xox[baprs]-[A-Za-z0-9-]{10,}/, 'Slack token', 'block'],
+  [/sk-[A-Za-z0-9]{32,}/, 'API key (sk-…)', 'block'],
+  [/eyJhbGciOi[A-Za-z0-9_.-]{20,}/, 'JWT pasted verbatim', 'block'],
+  [/(api[_-]?key|secret|passwd|password)\s*[=:]\s*["'][^"'\s]{8,}["']/i, 'credential assignment', 'block'],
+  [/AIza[0-9A-Za-z_-]{35}/, 'Google API key', 'block'],
+  [/ya29\.[0-9A-Za-z_-]{20,}/, 'Google OAuth token', 'block'],
+  [/\b[a-z][a-z0-9+.-]*:\/\/[^\s:@/]+:[^\s@/]{4,}@[^\s/]+/i, 'connection string with inline credential', 'block'],
+  [/\bAC[a-f0-9]{32}\b/, 'Twilio account SID', 'block'],
+  [/\bSK[a-f0-9]{32}\b/, 'Twilio API key', 'block'],
+  [/\bglpat-[A-Za-z0-9_-]{20,}/, 'GitLab token', 'block'],
+  [/\bnpm_[A-Za-z0-9]{36}\b/, 'npm token', 'block'],
+  [/\bdop_v1_[a-f0-9]{64}\b/, 'DigitalOcean token', 'block'],
+  [/\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})\b/, 'card-number shape (verify before committing)', 'warn'],
 ];
 
 const ALLOW_SECRET = 'mugiwara:allow-secret';
 
+function loadExtraPatterns(projectRoot: string): Array<SecretPattern> {
+  try {
+    const policy = loadPolicy(projectRoot);
+    const extras = (policy as unknown as { integrity?: { extra_secret_patterns?: Array<{ pattern: string; label: string; severity?: SecretSeverity }> } })?.integrity?.extra_secret_patterns;
+    if (!extras || !Array.isArray(extras)) return [];
+    const out: Array<SecretPattern> = [];
+    for (const e of extras) {
+      if (!e || typeof (e as Record<string, unknown>).pattern !== 'string' || typeof (e as Record<string, unknown>).label !== 'string') continue;
+      const rec = e as { pattern: string; label: string; severity?: SecretSeverity };
+      const sev: SecretSeverity = rec.severity === 'warn' ? 'warn' : 'block';
+      try {
+        const re = new RegExp(rec.pattern);
+        out.push([re, rec.label, sev]);
+      } catch {
+        // invalid regex — skip
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+
 /** Secret shapes per line; a line carrying the allow marker is skipped — deliberate examples stay possible. */
-function findSecrets(body: string): Array<{ label: string; hit: string }> {
-  const out: Array<{ label: string; hit: string }> = [];
+export function findSecrets(
+  body: string,
+  extra?: Array<SecretPattern>,
+): Array<{ label: string; hit: string; severity: SecretSeverity }> {
+  const out: Array<{ label: string; hit: string; severity: SecretSeverity }> = [];
+  const patterns: Array<SecretPattern> = extra ? [...SECRET_PATTERNS, ...extra] : SECRET_PATTERNS;
   for (const line of body.split(/\r?\n/)) {
     if (line.includes(ALLOW_SECRET)) continue;
-    for (const [re, label] of SECRET_PATTERNS) {
+    for (const [re, label, severity] of patterns) {
       const hit = line.match(re);
-      if (hit) out.push({ label, hit: hit[0] });
+      if (hit) out.push({ label, hit: hit[0], severity: (severity ?? 'block') as SecretSeverity });
     }
   }
   return out;
@@ -89,6 +133,7 @@ function collectPassCitedPaths(missionDir: string): string[] {
 export function checkTrail(missionDir: string, projectRoot: string): IntegrityIssue[] {
   const issues: IntegrityIssue[] = [];
   const files = trailFiles(missionDir);
+  const extraPatterns = loadExtraPatterns(projectRoot);
 
   // 1 + 2: per-file link resolution and secret scan
   for (const f of files) {
@@ -105,10 +150,12 @@ export function checkTrail(missionDir: string, projectRoot: string): IntegrityIs
         });
       }
     }
-    for (const { label, hit } of findSecrets(body)) {
+    for (const { label, hit, severity } of findSecrets(body, extraPatterns.length ? extraPatterns : undefined)) {
+      const isWarn = severity === 'warn';
       issues.push({
-        kind: 'secret',
+        kind: isWarn ? 'secret-warn' : 'secret',
         detail: `${relative(projectRoot, f)} matches ${label}: ${hit.slice(0, 12)}…`,
+        severity: isWarn ? 'warn' : 'block',
       });
     }
   }
@@ -139,6 +186,8 @@ export function checkTrail(missionDir: string, projectRoot: string): IntegrityIs
   const passCited = collectPassCitedPaths(missionDir);
   for (const e of passCited) {
     if (!e.trim() || isAbsolute(e)) continue;
+    // state/continue are machine-generated JSON, not evidence with command output — skip thin check
+    if (/(?:^|\/)(state|continue)(-[^\/]*)?\.json$/.test(e)) continue;
     const candMission = join(missionDir, e);
     const candRoot = join(projectRoot, e);
     const resolved = existsSync(candMission) ? candMission : existsSync(candRoot) ? candRoot : null;