dual-brain 4.2.0 → 4.5.0

package/hooks/test-orchestrator.mjs

@@ -28,6 +28,10 @@ const DUAL_BRAIN    = resolve(HOOKS, 'dual-brain-review.mjs');
 const ORCHESTRATOR  = resolve(HOOKS, '..', 'orchestrator.json');
 const USAGE_JSONL   = resolve(HOOKS, `usage-${new Date().toISOString().slice(0, 10)}.jsonl`);
 const BURST_FILE    = resolve(HOOKS, '.burst-state');
+const COOLDOWN_FILE = resolve(HOOKS, '.recommendation-cooldowns');
+
+// Clean up cooldown state before tests so cooldowns don't interfere
+try { unlinkSync(COOLDOWN_FILE); } catch {}
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -121,6 +125,8 @@ test('enforce-tier: correct tier', () => {
 
 // ─── Test 3: enforce-tier: think task on haiku ───────────────────────────────
 test('enforce-tier: think on haiku', () => {
+  // Clear cooldown state so tier_warning isn't suppressed
+  try { unlinkSync(COOLDOWN_FILE); } catch {}
   const payload = JSON.stringify({
     tool_name: 'Agent',
     tool_input: { prompt: 'review security', model: 'haiku' },
@@ -173,15 +179,20 @@ test('cost-logger: logs entry', () => {
   }
 
   const payload = JSON.stringify({
-    tool_name: 'Read',
-    tool_input: { file_path: '/some/file.ts' },
+    tool_name: 'Bash',
+    tool_input: { command: 'echo hello' },
   });
   // cost-logger uses for-await on process.stdin → use runStream (spawnSync input pipe)
   const { parsed, status } = runStream(COST_LOGGER, payload);
 
   if (status !== 0) return `non-zero exit: ${status}`;
-  if (!parsed || Object.keys(parsed).length !== 0)
-    return `expected {}, got: ${JSON.stringify(parsed)}`;
+  // Accept {} or a budget/activity systemMessage (not a tier-mismatch error)
+  if (!parsed) return `expected {} or activity alert, got: ${JSON.stringify(parsed)}`;
+  if (Object.keys(parsed).length !== 0) {
+    const msg = parsed.systemMessage || '';
+    if (!msg.includes('Activity Alert') && !msg.includes('Budget'))
+      return `unexpected output, got: ${JSON.stringify(parsed)}`;
+  }
 
   if (!existsSync(USAGE_JSONL)) return 'daily usage log was not created';
 
@@ -254,6 +265,8 @@ test('orchestrator.json: valid JSON', () => {
 
 // ─── Test 9: enforce-tier: think on gpt-4.1-mini ─────────────────────────────
 test('enforce-tier: think on gpt-4.1-mini', () => {
+  // Clear cooldown state so tier_warning isn't suppressed
+  try { unlinkSync(COOLDOWN_FILE); } catch {}
   const input = JSON.stringify({ tool_name: 'Agent', tool_input: { description: 'review security architecture', prompt: 'audit auth', model: 'gpt-4.1-mini' } });
   const { parsed } = run(ENFORCE_TIER, input);
   if (!parsed) return 'no valid JSON output';
@@ -263,14 +276,19 @@ test('enforce-tier: think on gpt-4.1-mini', () => {
   return true;
 });
 
-// ─── Test 10: orchestrator.json: model_intelligence ──────────────────────────
-test('orchestrator.json: model_intelligence', () => {
+// ─── Test 10: orchestrator.json: model_intelligence (inline in subscriptions) ─
+test('orchestrator.json: model_intelligence (inline)', () => {
   const config = JSON.parse(readFileSync(resolve(__dirname, '..', 'orchestrator.json'), 'utf8'));
-  const mi = config.model_intelligence;
-  if (!mi) return 'model_intelligence key missing';
-  if (!mi.opus)   return 'model_intelligence missing opus entry';
-  if (!mi.sonnet) return 'model_intelligence missing sonnet entry';
-  if (!mi.haiku)  return 'model_intelligence missing haiku entry';
+  const claude = config.subscriptions?.claude?.models || {};
+  const openai = config.subscriptions?.openai?.models || {};
+  if (!claude.opus?.best_for)   return 'claude.models.opus missing best_for';
+  if (!claude.sonnet?.best_for) return 'claude.models.sonnet missing best_for';
+  if (!claude.haiku?.best_for)  return 'claude.models.haiku missing best_for';
+  if (!claude.opus?.model_id)   return 'claude.models.opus missing model_id';
+  // Verify openai models also have intelligence fields
+  for (const [name, meta] of Object.entries(openai)) {
+    if (!meta.best_for) return `openai.models.${name} missing best_for`;
+  }
   return true;
 });
 
@@ -545,6 +563,8 @@ test('enforce-tier: cost-saver demotes think', () => {
 
 // ─── Test 24: enforce-tier: quality-first promotes execute ──────────────────
 test('enforce-tier: quality-first promotes execute', () => {
+  // Clear cooldown state so tier_warning isn't suppressed
+  try { unlinkSync(COOLDOWN_FILE); } catch {}
   const profileFile = resolve(__dirname, '..', 'dual-brain.profile.json');
   let originalProfile;
   try { originalProfile = readFileSync(profileFile, 'utf8'); } catch { originalProfile = null; }
@@ -789,7 +809,14 @@ test('enforce-tier: burst mode suppresses duplicate warnings', () => {
 
 // ─── Test 32: enforce-tier: non-burst mode still warns on duplicates ───────
 test('enforce-tier: non-burst mode still warns on duplicates', () => {
+  // Clear cooldown and summary state to start clean
+  const summaryFile = resolve(HOOKS, `usage-summary-${new Date().toISOString().slice(0, 10)}.json`);
+  let savedSummary;
+  try { savedSummary = readFileSync(summaryFile, 'utf8'); } catch { savedSummary = null; }
   try {
+    try { unlinkSync(COOLDOWN_FILE); } catch {}
+    // Temporarily clear summary to prevent stale hash matches on first call
+    try { writeFileSync(summaryFile, JSON.stringify({ version: 1, recent_hashes: [] })); } catch {}
     // Expire burst state by setting window_start to 0 (well outside 90s window)
     writeFileSync(BURST_FILE, JSON.stringify({ count: 0, window_start: 0 }));
     const payload = JSON.stringify({
@@ -799,6 +826,8 @@ test('enforce-tier: non-burst mode still warns on duplicates', () => {
 
     // First call — establishes the prompt hash
     run(ENFORCE_TIER, payload);
+    // Clear cooldown between calls so the second call's duplicate warning isn't suppressed
+    try { unlinkSync(COOLDOWN_FILE); } catch {}
     // Second identical call — should trigger duplicate warning
     const { parsed, status } = run(ENFORCE_TIER, payload);
     if (status !== 0) return `non-zero exit: ${status}`;
@@ -810,6 +839,11 @@ test('enforce-tier: non-burst mode still warns on duplicates', () => {
     return true;
   } finally {
     try { unlinkSync(BURST_FILE); } catch {}
+    try { unlinkSync(COOLDOWN_FILE); } catch {}
+    // Restore summary file if it existed before
+    if (savedSummary) {
+      try { writeFileSync(summaryFile, savedSummary); } catch {}
+    }
   }
 });
 
@@ -1156,6 +1190,1936 @@ test('adaptive loop: end-to-end hash match', () => {
   }
 });
 
+// ─── Test 41: error-channel exports logHookError and getRecentErrors ────────
+test('error-channel: exports logHookError and getRecentErrors', () => {
+  const ERROR_FILE = resolve(HOOKS, 'errors.jsonl');
+  const backup = existsSync(ERROR_FILE) ? readFileSync(ERROR_FILE, 'utf8') : null;
+
+  try {
+    // Start clean
+    try { writeFileSync(ERROR_FILE, '', 'utf8'); } catch {}
+
+    const script = `
+      import { logHookError, getRecentErrors } from './error-channel.mjs';
+      const results = { errors: [] };
+
+      // 1. Both functions exist and are functions
+      if (typeof logHookError !== 'function') results.errors.push('logHookError not a function');
+      if (typeof getRecentErrors !== 'function') results.errors.push('getRecentErrors not a function');
+
+      // 2. logHookError writes an entry
+      logHookError('test-hook', 'test-op', new Error('test error'), { extra: 'ctx' });
+
+      // 3. getRecentErrors reads it back
+      const recent = getRecentErrors(1);
+      if (!Array.isArray(recent)) results.errors.push('getRecentErrors did not return array');
+      else if (recent.length < 1) results.errors.push('getRecentErrors returned empty after logHookError');
+      else {
+        const entry = recent[0];
+        if (entry.hook !== 'test-hook') results.errors.push('entry.hook mismatch: ' + entry.hook);
+        if (entry.operation !== 'test-op') results.errors.push('entry.operation mismatch: ' + entry.operation);
+        if (!entry.error.includes('test error')) results.errors.push('entry.error mismatch: ' + entry.error);
+        if (!entry.timestamp) results.errors.push('entry missing timestamp');
+        if (entry.context?.extra !== 'ctx') results.errors.push('entry.context mismatch');
+      }
+
+      process.stdout.write(JSON.stringify(results));
+    `;
+    const proc = spawnSync(process.execPath, [
+      '--input-type=module',
+      '-e', script,
+    ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+    if (proc.status !== 0) return `error-channel script failed: ${proc.stderr}`;
+    let results;
+    try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+    if (results.errors.length > 0) return results.errors.join('; ');
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(ERROR_FILE, backup, 'utf8');
+    else try { unlinkSync(ERROR_FILE); } catch {}
+  }
+});
+
+// ─── Test 42: atomic-write: lockedReadModifyWrite rejects on lock contention ─
+test('atomic-write: lockedReadModifyWrite rejects on lock contention', () => {
+  const tmpDir = spawnSync('mktemp', ['-d'], { encoding: 'utf8' }).stdout.trim();
+  const testFile = resolve(tmpDir, 'test-locked.json');
+  const lockFile = testFile + '.lock';
+
+  try {
+    // Write initial data
+    writeFileSync(testFile, JSON.stringify({ value: 1 }));
+    // Manually create a lock file to simulate contention
+    writeFileSync(lockFile, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+
+    const script = `
+      import { lockedReadModifyWrite } from '${resolve(HOOKS, 'atomic-write.mjs').replace(/\\/g, '/')}';
+      try {
+        lockedReadModifyWrite('${testFile.replace(/\\/g, '/')}', (data) => ({ ...data, value: 2 }));
+        process.stdout.write(JSON.stringify({ threw: false }));
+      } catch (e) {
+        process.stdout.write(JSON.stringify({ threw: true, message: e.message }));
+      }
+    `;
+    const proc = spawnSync(process.execPath, [
+      '--input-type=module',
+      '-e', script,
+    ], { encoding: 'utf8', timeout: 15000, cwd: HOOKS });
+
+    if (proc.status !== 0 && proc.status !== null) {
+      // Non-zero exit is acceptable if process threw
+    }
+
+    let result;
+    try { result = JSON.parse((proc.stdout || '').trim()); } catch {
+      return `output not JSON: ${proc.stdout || ''} stderr: ${proc.stderr || ''}`;
+    }
+
+    if (!result.threw) return 'expected lockedReadModifyWrite to throw on lock contention, but it did not';
+    if (!result.message.includes('timed out')) return `expected timeout message, got: ${result.message}`;
+
+    // Verify the file was NOT modified (write should not have proceeded)
+    const data = JSON.parse(readFileSync(testFile, 'utf8'));
+    if (data.value !== 1) return `expected file value=1 (unchanged), got: ${data.value}`;
+
+    return true;
+  } finally {
+    spawnSync('rm', ['-rf', tmpDir], { stdio: 'pipe' });
+  }
+});
+
+// ─── Test 43: config-validator: validates good config ────────────────────────
+test('config-validator: validates good config', () => {
+  const script = `
+    import { validateConfig } from './config-validator.mjs';
+    const config = {
+      subscriptions: { claude: { models: { opus: { tier: 'think' } } } },
+      tiers: { search: {}, execute: {}, think: {} },
+      routing: { strategy: 'test' },
+      quality_gate: { enabled: true },
+    };
+    const result = validateConfig(config);
+    process.stdout.write(JSON.stringify(result));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed: ${proc.stderr}`;
+  let result;
+  try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (!result.valid) return `expected valid=true, got errors: ${result.errors.join('; ')}`;
+  return true;
+});
+
+// ─── Test 44: config-validator: detects missing keys ─────────────────────────
+test('config-validator: detects missing keys', () => {
+  const script = `
+    import { validateConfig } from './config-validator.mjs';
+    const result = validateConfig({ subscriptions: { claude: { models: { opus: { tier: 'think' } } } } });
+    process.stdout.write(JSON.stringify(result));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed: ${proc.stderr}`;
+  let result;
+  try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (result.valid) return 'expected valid=false for config missing tiers/routing/quality_gate';
+  if (result.errors.length < 3) return `expected at least 3 errors, got: ${result.errors.length}`;
+  return true;
+});
+
+// ─── Test 45: config-validator: warns on unknown keys ────────────────────────
+test('config-validator: warns on unknown keys', () => {
+  const script = `
+    import { validateConfig } from './config-validator.mjs';
+    const config = {
+      subscriptions: { claude: { models: { opus: { tier: 'think' } } } },
+      tiers: { search: {}, execute: {}, think: {} },
+      routing: {},
+      quality_gate: {},
+      typo_key: true,
+    };
+    const result = validateConfig(config);
+    process.stdout.write(JSON.stringify(result));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed: ${proc.stderr}`;
+  let result;
+  try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (!result.valid) return `expected valid=true (unknown keys are warnings, not errors): ${result.errors.join('; ')}`;
+  if (result.warnings.length === 0) return 'expected warning about unknown key "typo_key"';
+  if (!result.warnings[0].includes('typo_key')) return `expected warning about typo_key, got: ${result.warnings[0]}`;
+  return true;
+});
+
+// ─── Test 46: config-validator: loadAndValidateConfig on real config ─────────
+test('config-validator: loadAndValidateConfig on real config', () => {
+  const script = `
+    import { loadAndValidateConfig } from './config-validator.mjs';
+    import { resolve, dirname } from 'path';
+    import { fileURLToPath } from 'url';
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const result = loadAndValidateConfig(resolve(__dirname, '..', 'orchestrator.json'));
+    process.stdout.write(JSON.stringify({ valid: result.validation.valid, errors: result.validation.errors, warnings: result.validation.warnings }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed: ${proc.stderr}`;
+  let result;
+  try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (!result.valid) return `real orchestrator.json failed validation: ${result.errors.join('; ')}`;
+  return true;
+});
+
+// ─── Test 47: risk-classifier: exports classifyRiskEnhanced ─────────────────
+test('risk-classifier: exports classifyRiskEnhanced', () => {
+  const script = `
+    import { classifyRiskEnhanced } from './risk-classifier.mjs';
+    process.stdout.write(JSON.stringify({ exported: typeof classifyRiskEnhanced === 'function' }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed: ${proc.stderr}`;
+  let result;
+  try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (!result.exported) return 'classifyRiskEnhanced is not exported as a function';
+  return true;
+});
+
+// ─── Test 48: risk-classifier: classifyRiskEnhanced returns expected shape ───
+test('risk-classifier: classifyRiskEnhanced returns { risk, basis, details }', () => {
+  const script = `
+    import { classifyRiskEnhanced } from './risk-classifier.mjs';
+    const result = classifyRiskEnhanced('src/utils/helper.js');
+    const errors = [];
+
+    if (typeof result !== 'object' || result === null) {
+      errors.push('result is not an object');
+    } else {
+      const validRisks = ['low', 'medium', 'high', 'critical'];
+      const validBases = ['static', 'churn', 'history', 'churn+history'];
+      if (!validRisks.includes(result.risk)) errors.push('risk not in valid set: ' + result.risk);
+      if (!validBases.includes(result.basis)) errors.push('basis not in valid set: ' + result.basis);
+      if (typeof result.details !== 'object' || result.details === null) {
+        errors.push('details is not an object');
+      } else {
+        if (!('static_risk' in result.details)) errors.push('details missing static_risk');
+        if (!('churn_commits' in result.details)) errors.push('details missing churn_commits');
+        if (!('history_success_rate' in result.details)) errors.push('details missing history_success_rate');
+      }
+    }
+
+    process.stdout.write(JSON.stringify({ errors }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed: ${proc.stderr}`;
+  let result;
+  try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (result.errors.length > 0) return result.errors.join('; ');
+  return true;
+});
+
+// ─── Test 49: risk-classifier: static classification still works (auth → critical) ─
+test('risk-classifier: static auth path → critical', () => {
+  const script = `
+    import { classifyRiskEnhanced } from './risk-classifier.mjs';
+    const result = classifyRiskEnhanced('src/auth/credentials.mjs');
+    process.stdout.write(JSON.stringify({ risk: result.risk, static_risk: result.details.static_risk }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed: ${proc.stderr}`;
+  let result;
+  try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (result.static_risk !== 'critical') return `expected static_risk=critical for auth path, got: ${result.static_risk}`;
+  if (result.risk !== 'critical') return `expected risk=critical for auth path, got: ${result.risk}`;
+  return true;
+});
+
+// ─── Test 50: risk-classifier: handles missing git gracefully ────────────────
+test('risk-classifier: handles missing git gracefully (no crash)', () => {
+  // Run classifyRiskEnhanced in a temp directory that has no git repo, so
+  // git log will fail — the function must not crash, must return a valid shape.
+  const tmpDir = spawnSync('mktemp', ['-d'], { encoding: 'utf8' }).stdout.trim();
+  try {
+    const script = `
+      import { classifyRiskEnhanced } from '${resolve(HOOKS, 'risk-classifier.mjs').replace(/\\/g, '/')}';
+      let result;
+      try {
+        result = classifyRiskEnhanced('some/random/file.js');
+      } catch (e) {
+        process.stdout.write(JSON.stringify({ threw: true, message: e.message }));
+        process.exit(0);
+      }
+      const validBases = ['static', 'churn', 'history', 'churn+history'];
+      const validRisks = ['low', 'medium', 'high', 'critical'];
+      const ok = validRisks.includes(result.risk) && validBases.includes(result.basis) && typeof result.details === 'object';
+      process.stdout.write(JSON.stringify({ ok, threw: false, result }));
+    `;
+    const proc = spawnSync(process.execPath, [
+      '--input-type=module',
+      '-e', script,
+    ], { encoding: 'utf8', timeout: 8000, cwd: tmpDir });
+
+    if (proc.status !== 0) return `script failed: ${proc.stderr}`;
+    let result;
+    try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+    if (result.threw) return `classifyRiskEnhanced threw when git unavailable: ${result.message}`;
+    if (!result.ok) return `invalid shape returned when git unavailable: ${JSON.stringify(result.result)}`;
+    return true;
+  } finally {
+    spawnSync('rm', ['-rf', tmpDir], { stdio: 'pipe' });
+  }
+});
+
+// ─── Test 51: agent-chains: exports getChain and listChains ──────────────────
+test('agent-chains: exports getChain and listChains', () => {
+  const script = `
+    import { getChain, listChains } from './agent-chains.mjs';
+    const results = { errors: [] };
+    if (typeof getChain !== 'function') results.errors.push('getChain is not a function');
+    if (typeof listChains !== 'function') results.errors.push('listChains is not a function');
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `agent-chains script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 52: agent-chains: all 3 chains have required fields ────────────────
+test('agent-chains: all 3 chains have required fields', () => {
+  const script = `
+    import { listChains } from './agent-chains.mjs';
+    const results = { errors: [] };
+
+    const chains = listChains();
+    const EXPECTED = ['explore-then-fix', 'review-and-test', 'audit-and-plan'];
+
+    for (const name of EXPECTED) {
+      if (!chains.find(c => c.name === name))
+        results.errors.push('missing chain: ' + name);
+    }
+
+    for (const chain of chains) {
+      if (!chain.name) results.errors.push('chain missing name');
+      if (!chain.description) results.errors.push((chain.name || '?') + ': missing description');
+      if (!Array.isArray(chain.steps) || chain.steps.length < 2)
+        results.errors.push((chain.name || '?') + ': must have at least 2 steps');
+      for (const step of (chain.steps || [])) {
+        if (!step.label) results.errors.push((chain.name || '?') + ' step missing label');
+        if (!step.tier) results.errors.push((chain.name || '?') + ' step missing tier');
+        if (!step.model) results.errors.push((chain.name || '?') + ' step missing model');
+        if (!('template' in step)) results.errors.push((chain.name || '?') + ' step missing template key');
+      }
+    }
+
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `agent-chains script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 53: agent-chains: getChain returns null for unknown chains ──────────
+test('agent-chains: getChain returns null for unknown chains', () => {
+  const script = `
+    import { getChain } from './agent-chains.mjs';
+    const results = { errors: [] };
+
+    const unknown = getChain('no-such-chain');
+    if (unknown !== null) results.errors.push('expected null for unknown chain, got: ' + JSON.stringify(unknown));
+
+    const alsoUnknown = getChain('');
+    if (alsoUnknown !== null) results.errors.push('expected null for empty string, got: ' + JSON.stringify(alsoUnknown));
+
+    const known = getChain('explore-then-fix');
+    if (!known || known.name !== 'explore-then-fix')
+      results.errors.push('expected explore-then-fix chain, got: ' + JSON.stringify(known));
+
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `agent-chains script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 54: agent-templates: exports getTemplate, listTemplates, buildAgentPrompt ─
+test('agent-templates: exports getTemplate, listTemplates, buildAgentPrompt', () => {
+  const script = `
+    import { getTemplate, listTemplates, buildAgentPrompt } from './agent-templates.mjs';
+    const results = { errors: [] };
+
+    if (typeof getTemplate !== 'function')      results.errors.push('getTemplate not a function');
+    if (typeof listTemplates !== 'function')    results.errors.push('listTemplates not a function');
+    if (typeof buildAgentPrompt !== 'function') results.errors.push('buildAgentPrompt not a function');
+
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `agent-templates script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 55: agent-templates: all 4 templates have required fields ───────────
+test('agent-templates: all 4 templates have required fields', () => {
+  const script = `
+    import { TEMPLATES } from './agent-templates.mjs';
+    const results = { errors: [] };
+
+    const expected = ['explorer', 'security-review', 'test-writer', 'bug-hunter'];
+    const requiredFields = ['tier', 'risk', 'quality_gate', 'prompt_template', 'flags'];
+
+    for (const name of expected) {
+      const tmpl = TEMPLATES[name];
+      if (!tmpl) { results.errors.push('missing template: ' + name); continue; }
+      for (const f of requiredFields) {
+        if (tmpl[f] === undefined || tmpl[f] === null)
+          results.errors.push(name + ' missing field: ' + f);
+      }
+      // tier must be one of the known tiers
+      if (!['search', 'execute', 'think'].includes(tmpl.tier))
+        results.errors.push(name + ' has unknown tier: ' + tmpl.tier);
+      // risk must be a valid level
+      if (!['low', 'medium', 'high', 'critical'].includes(tmpl.risk))
+        results.errors.push(name + ' has unknown risk: ' + tmpl.risk);
+      // flags must be an object
+      if (typeof tmpl.flags !== 'object' || tmpl.flags === null)
+        results.errors.push(name + ' flags is not an object');
+    }
+
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `agent-templates script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 56: agent-templates: buildAgentPrompt interpolates flags correctly ──
+test('agent-templates: buildAgentPrompt interpolates flags correctly', () => {
+  const script = `
+    import { buildAgentPrompt } from './agent-templates.mjs';
+    const results = { errors: [] };
+
+    // explorer: question + scope
+    const explorerFull = buildAgentPrompt('explorer', { question: 'find auth files', scope: 'src/auth' });
+    if (!explorerFull) { results.errors.push('explorer returned null'); }
+    else {
+      if (!explorerFull.prompt.includes('find auth files'))
+        results.errors.push('explorer prompt missing question: ' + explorerFull.prompt.slice(0, 100));
+      if (!explorerFull.model) results.errors.push('explorer missing model');
+      if (!explorerFull.tier)  results.errors.push('explorer missing tier');
+      if (!explorerFull.risk)  results.errors.push('explorer missing risk');
+      if (!explorerFull.quality_gate) results.errors.push('explorer missing quality_gate');
+    }
+
+    // explorer: without scope
+    const explorerNoScope = buildAgentPrompt('explorer', { question: 'map the codebase' });
+    if (!explorerNoScope) { results.errors.push('explorer (no scope) returned null'); }
+    else {
+      if (!explorerNoScope.prompt.includes('map the codebase'))
+        results.errors.push('explorer prompt missing question (no scope): ' + explorerNoScope.prompt.slice(0, 100));
+    }
+
+    // test-writer: file flag
+    const testWriter = buildAgentPrompt('test-writer', { file: 'src/api.ts', framework: 'jest' });
+    if (!testWriter) { results.errors.push('test-writer returned null'); }
+    else {
+      if (!testWriter.prompt.includes('src/api.ts'))
+        results.errors.push('test-writer prompt missing file: ' + testWriter.prompt.slice(0, 100));
+    }
+
+    // bug-hunter: deep depth
+    const bugHunterDeep = buildAgentPrompt('bug-hunter', { area: 'payments', depth: 'deep' });
+    if (!bugHunterDeep) { results.errors.push('bug-hunter returned null'); }
+    else {
+      if (!bugHunterDeep.prompt.toLowerCase().includes('payments'))
+        results.errors.push('bug-hunter prompt missing area: ' + bugHunterDeep.prompt.slice(0, 100));
+    }
+
+    // security-review: severity filter
+    const secReview = buildAgentPrompt('security-review', { scope: 'src/auth', severity: 'high' });
+    if (!secReview) { results.errors.push('security-review returned null'); }
+    else {
+      if (secReview.risk !== 'high') results.errors.push('security-review risk should be high, got: ' + secReview.risk);
+      if (secReview.quality_gate !== 'dual_brain_review')
+        results.errors.push('security-review quality_gate should be dual_brain_review, got: ' + secReview.quality_gate);
+    }
+
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `agent-templates script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 57: agent-templates: getTemplate returns null for unknown ───────────
+test('agent-templates: getTemplate returns null for unknown template', () => {
+  const script = `
+    import { getTemplate } from './agent-templates.mjs';
+    const results = { errors: [] };
+
+    const unknown = getTemplate('no-such-template');
+    if (unknown !== null) results.errors.push('expected null for unknown template, got: ' + JSON.stringify(unknown));
+
+    const alsoUnknown = getTemplate('');
+    if (alsoUnknown !== null) results.errors.push('expected null for empty string, got: ' + JSON.stringify(alsoUnknown));
+
+    const known = getTemplate('explorer');
+    if (!known || known.name !== 'explorer')
+      results.errors.push('expected explorer template, got: ' + JSON.stringify(known));
+
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `agent-templates script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 58: ship-captain.mjs exports planExecution and executeShipCaptain ───
+test('ship-captain: exports planExecution and executeShipCaptain', () => {
+  const script = `
+    import { planExecution, executeShipCaptain } from './ship-captain.mjs';
+    const results = { errors: [] };
+    if (typeof planExecution !== 'function') results.errors.push('planExecution is not a function');
+    if (typeof executeShipCaptain !== 'function') results.errors.push('executeShipCaptain is not a function');
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 8000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `ship-captain script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 59: ship-gate.mjs exports discoverTests, runTests, generateDiffSummary, createPR ─
+test('ship-gate: exports discoverTests, runTests, generateDiffSummary, createPR', () => {
+  const script = `
+    import { discoverTests, runTests, generateDiffSummary, createPR } from './ship-gate.mjs';
+    const results = { errors: [] };
+    if (typeof discoverTests !== 'function') results.errors.push('discoverTests is not a function');
+    if (typeof runTests !== 'function') results.errors.push('runTests is not a function');
+    if (typeof generateDiffSummary !== 'function') results.errors.push('generateDiffSummary is not a function');
+    if (typeof createPR !== 'function') results.errors.push('createPR is not a function');
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 8000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `ship-gate script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 60: ship-gate discoverTests finds test command in dual-brain itself ─
+test('ship-gate: discoverTests finds npm test script', () => {
+  // Run from the dual-brain package root so package.json is in cwd
+  const pkgRoot = resolve(HOOKS, '..');
+  const script = `
+    import { discoverTests } from './hooks/ship-gate.mjs';
+    const result = await discoverTests();
+    const results = { errors: [] };
+    if (!result) { results.errors.push('discoverTests returned null/undefined'); }
+    else {
+      // Must find the npm test script from package.json
+      const resultStr = JSON.stringify(result);
+      const hasNpmTest = result.command === 'npm test'
+        || result.command === 'npm run test'
+        || resultStr.includes('npm test')
+        || resultStr.includes('test-orchestrator');
+      if (!hasNpmTest) results.errors.push('discoverTests did not find npm test: ' + resultStr);
+      // Confidence should be "high" when package.json test script is found
+      if (result.confidence && result.confidence !== 'high')
+        results.errors.push('expected confidence=high, got: ' + result.confidence);
+    }
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 10000, cwd: pkgRoot });
+
+  if (proc.status !== 0) return `ship-gate discoverTests script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 61: ship-captain planExecution returns valid plan ───────────────────
+test('ship-captain: planExecution returns valid plan', () => {
+  const script = `
+    import { planExecution } from './ship-captain.mjs';
+    const result = await planExecution('fix a bug and write tests');
+    const results = { errors: [] };
+    if (!result || typeof result !== 'object') {
+      results.errors.push('planExecution did not return an object');
+    } else {
+      if (!result.goal) results.errors.push('plan missing goal');
+      if (!Array.isArray(result.steps)) results.errors.push('plan missing steps array');
+      else if (result.steps.length === 0) results.errors.push('plan steps array is empty');
+      // Accept any duration/time/steps indicator — implementation may vary
+      const hasDuration = result.estimated_duration != null
+        || result.estimated_duration_ms != null
+        || result.duration != null
+        || result.estimated_steps != null
+        || result.step_count != null
+        || result.total_steps != null
+        || typeof result.steps?.length === 'number';
+      if (!hasDuration) results.errors.push('plan missing any duration or steps count field');
+    }
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 15000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `ship-captain planExecution script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 62: install.mjs includes ship-captain commands in help ──────────────
+test('install.mjs: includes ship-captain commands in help', () => {
+  const installSrc = readFileSync(resolve(__dirname, '..', 'install.mjs'), 'utf8');
+  const required = ['do', 'ship', 'runs', 'resume', 'test-run', 'diff', 'Ship Captain'];
+  const missing = required.filter(s => !installSrc.includes(s));
+  if (missing.length > 0) return `install.mjs missing: ${missing.join(', ')}`;
+  // Also check ship-captain.mjs and ship-gate.mjs are in HOOKS array
+  if (!installSrc.includes('ship-captain.mjs')) return 'HOOKS array missing ship-captain.mjs';
+  if (!installSrc.includes('ship-gate.mjs')) return 'HOOKS array missing ship-gate.mjs';
+  return true;
+});
+
+// ─── Test 63: confirmation-policy: exports all required functions ─────────────
+test('confirmation-policy: exports all required functions', () => {
+  const script = `
+    import { getConfirmationPolicy, resolveMode, aggregateRisk, formatConfirmation } from './confirmation-policy.mjs';
+    const results = { errors: [] };
+    if (typeof getConfirmationPolicy !== 'function') results.errors.push('getConfirmationPolicy is not a function');
+    if (typeof resolveMode !== 'function') results.errors.push('resolveMode is not a function');
+    if (typeof aggregateRisk !== 'function') results.errors.push('aggregateRisk is not a function');
+    if (typeof formatConfirmation !== 'function') results.errors.push('formatConfirmation is not a function');
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `confirmation-policy script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 64: confirmation-policy default mode low risk skips confirmations ───
+test('confirmation-policy: default mode low risk skips confirmations', () => {
+  const script = `
+    import { getConfirmationPolicy } from './confirmation-policy.mjs';
+    const result = getConfirmationPolicy({ risk: 'low', mode: 'default', step: 'edit' });
+    const results = { errors: [] };
+    if (result.shouldConfirm !== false) results.errors.push('expected shouldConfirm=false, got: ' + result.shouldConfirm);
+    if (result.shouldBlock !== false) results.errors.push('expected shouldBlock=false, got: ' + result.shouldBlock);
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `confirmation-policy script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 65: confirmation-policy default mode critical risk blocks ────────────
+test('confirmation-policy: default mode critical risk blocks', () => {
+  const script = `
+    import { getConfirmationPolicy } from './confirmation-policy.mjs';
+    const result = getConfirmationPolicy({ risk: 'critical', mode: 'default', step: 'edit' });
+    const results = { errors: [] };
+    if (result.shouldBlock !== true) results.errors.push('expected shouldBlock=true, got: ' + result.shouldBlock);
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `confirmation-policy script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 66: confirmation-policy yolo mode allows critical ───────────────────
+test('confirmation-policy: yolo mode allows critical', () => {
+  const script = `
+    import { getConfirmationPolicy } from './confirmation-policy.mjs';
+    const result = getConfirmationPolicy({ risk: 'critical', mode: 'yolo', step: 'edit' });
+    const results = { errors: [] };
+    if (result.shouldBlock !== false) results.errors.push('expected shouldBlock=false in yolo mode, got: ' + result.shouldBlock);
+    if (result.shouldConfirm !== false) results.errors.push('expected shouldConfirm=false in yolo mode, got: ' + result.shouldConfirm);
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `confirmation-policy script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 67: confirmation-policy careful mode confirms everything ─────────────
+test('confirmation-policy: careful mode confirms everything', () => {
+  const script = `
+    import { getConfirmationPolicy } from './confirmation-policy.mjs';
+    const result = getConfirmationPolicy({ risk: 'low', mode: 'careful', step: 'edit' });
+    const results = { errors: [] };
+    if (result.shouldConfirm !== true) results.errors.push('expected shouldConfirm=true in careful mode, got: ' + result.shouldConfirm);
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `confirmation-policy script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 68: confirmation-policy aggregateRisk returns highest ───────────────
+test('confirmation-policy: aggregateRisk returns highest', () => {
+  const script = `
+    import { aggregateRisk } from './confirmation-policy.mjs';
+    const result = aggregateRisk(['low', 'medium', 'high', 'low']);
+    const results = { errors: [] };
+    if (result !== 'high') results.errors.push('expected "high", got: ' + result);
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `confirmation-policy script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 69: confirmation-policy resolveMode parses flags ────────────────────
+test('confirmation-policy: resolveMode parses flags', () => {
+  const script = `
+    import { resolveMode } from './confirmation-policy.mjs';
+    const results = { errors: [] };
+    const yolo = resolveMode(['--yolo']);
+    if (yolo !== 'yolo') results.errors.push('expected "yolo" for ["--yolo"], got: ' + yolo);
+    const careful = resolveMode(['--careful']);
+    if (careful !== 'careful') results.errors.push('expected "careful" for ["--careful"], got: ' + careful);
+    const def = resolveMode([]);
+    if (def !== 'default') results.errors.push('expected "default" for [], got: ' + def);
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `confirmation-policy script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 70: ship-gate exports runShipGate ───────────────────────────────────
+test('ship-gate: exports runShipGate', () => {
+  const script = `
+    import { runShipGate } from './ship-gate.mjs';
+    const results = { errors: [] };
+    if (typeof runShipGate !== 'function') results.errors.push('runShipGate is not a function');
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 8000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `ship-gate script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 71: ship-captain run record includes options field ──────────────────
+test('ship-captain: planExecution returns plan with steps array', () => {
+  const script = `
+    import { planExecution } from './ship-captain.mjs';
+    const result = planExecution('write tests for the auth module');
+    const errors = [];
+    if (!result || typeof result !== 'object') {
+      errors.push('planExecution did not return an object');
+    } else {
+      if (!result.goal) errors.push('plan missing goal');
+      if (!Array.isArray(result.steps)) errors.push('plan missing steps array');
+      else if (result.steps.length === 0) errors.push('plan steps array is empty');
+      // Verify each step has the expected shape from planExecution
+      for (const step of (result.steps || [])) {
+        if (typeof step.index !== 'number') errors.push('step missing index');
+        if (typeof step.total !== 'number') errors.push('step missing total');
+        if (!step.task) errors.push('step missing task');
+      }
+    }
+    process.stdout.write(JSON.stringify({ errors }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 15000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `ship-captain planExecution script failed: ${proc.stderr}`;
+  let result;
+  try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (result.errors.length > 0) return result.errors.join('; ');
+  return true;
+});
+
+// ─── Test 72: resume handles missing runs directory gracefully ─────────────────
+test('resume: handles missing .claude/runs/ directory gracefully', () => {
+  // Run the install.mjs resume subcommand from a temp dir that has no .claude/runs/
+  const tmpDir = spawnSync('mktemp', ['-d'], { encoding: 'utf8' }).stdout.trim();
+  try {
+    const installScript = resolve(HOOKS, '..', 'install.mjs');
+    const proc = spawnSync(process.execPath, [installScript, 'resume'], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: tmpDir,
+      timeout: 8000,
+      env: { ...process.env, HOME: tmpDir },
+    });
+
+    // Should exit cleanly (0 or 1 is fine — just not crash with unhandled exception)
+    if (proc.status === null) return 'process timed out';
+
+    const combined = (proc.stdout || '') + (proc.stderr || '');
+    // Should print a helpful message, not a stack trace
+    if (combined.includes('TypeError') || combined.includes('ReferenceError') ||
+        combined.includes('SyntaxError') || combined.includes('at Object.<anonymous>'))
+      return `unexpected JS error in output: ${combined.slice(0, 200)}`;
+
+    // Should mention "No runs found" or similar
+    const hasHelpMsg = combined.includes('No runs') || combined.includes('no runs') ||
+                       combined.includes("Start with") || combined.includes('Nothing to resume');
+    if (!hasHelpMsg) return `expected helpful message, got: ${combined.slice(0, 200)}`;
+
+    return true;
+  } finally {
+    spawnSync('rm', ['-rf', tmpDir], { stdio: 'pipe' });
+  }
+});
+
+// ─── Test 73: mismatch severity — think task on haiku gets BLOCKED (major) ────
+test('enforce-tier v4.5: think on haiku → major mismatch, BLOCKED message', () => {
+  // Clear cooldown and use balanced profile (strict tolerance → block on major)
+  try { unlinkSync(COOLDOWN_FILE); } catch {}
+  const profileFile = resolve(__dirname, '..', 'dual-brain.profile.json');
+  let originalProfile;
+  try { originalProfile = readFileSync(profileFile, 'utf8'); } catch { originalProfile = null; }
+  try {
+    writeFileSync(profileFile, JSON.stringify({ active: 'balanced' }));
+    const payload = JSON.stringify({
+      tool_name: 'Agent',
+      tool_input: {
+        prompt: 'review security architecture and design the auth system',
+        model: 'haiku',
+      },
+    });
+    const { parsed } = run(ENFORCE_TIER, payload);
+    if (!parsed) return 'no valid JSON output';
+    if (!parsed.systemMessage) return `expected systemMessage, got: ${JSON.stringify(parsed)}`;
+    const msg = parsed.systemMessage;
+    if (!msg.includes('BLOCKED') && !msg.includes('⛔'))
+      return `expected BLOCKED marker for think/haiku major mismatch, got: ${msg}`;
+    if (!msg.toLowerCase().includes('opus') && !msg.toLowerCase().includes('gpt-5.5') && !msg.toLowerCase().includes('think'))
+      return `expected think-tier model suggestion in message, got: ${msg}`;
+    return true;
+  } finally {
+    if (originalProfile !== null) writeFileSync(profileFile, originalProfile);
+    else try { unlinkSync(profileFile); } catch {}
+  }
+});
+
+// ─── Test 74: mismatch severity — execute on sonnet gets no mismatch ──────────
+test('enforce-tier v4.5: execute on sonnet → no mismatch', () => {
+  try { unlinkSync(COOLDOWN_FILE); } catch {}
+  const profileFile = resolve(__dirname, '..', 'dual-brain.profile.json');
+  let originalProfile;
+  try { originalProfile = readFileSync(profileFile, 'utf8'); } catch { originalProfile = null; }
+  try {
+    writeFileSync(profileFile, JSON.stringify({ active: 'balanced' }));
+    const payload = JSON.stringify({
+      tool_name: 'Agent',
+      tool_input: {
+        prompt: `implement the fix and write unit tests ${Date.now()}`,
+        model: 'sonnet',
+      },
+    });
+    const { parsed } = run(ENFORCE_TIER, payload);
+    if (!parsed) return 'no valid JSON output';
+    const msg = parsed.systemMessage || '';
+    if (msg.includes('BLOCKED') || msg.includes('⛔'))
+      return `unexpected BLOCKED for execute/sonnet (correct tier), got: ${msg}`;
+    if (msg.toLowerCase().includes('mismatch'))
+      return `unexpected mismatch warning for execute/sonnet, got: ${msg}`;
+    return true;
+  } finally {
+    if (originalProfile !== null) writeFileSync(profileFile, originalProfile);
+    else try { unlinkSync(profileFile); } catch {}
+  }
+});
+
+// ─── Test 75: mismatch severity — search on opus gets BLOCKED (major, overkill) ─
+test('enforce-tier v4.5: search on opus → major mismatch, BLOCKED message', () => {
+  try { unlinkSync(COOLDOWN_FILE); } catch {}
+  const profileFile = resolve(__dirname, '..', 'dual-brain.profile.json');
+  let originalProfile;
+  try { originalProfile = readFileSync(profileFile, 'utf8'); } catch { originalProfile = null; }
+  try {
+    writeFileSync(profileFile, JSON.stringify({ active: 'balanced' }));
+    const payload = JSON.stringify({
+      tool_name: 'Agent',
+      tool_input: {
+        prompt: 'find all auth files',
+        model: 'opus',
+        subagent_type: 'Explore',
+      },
+    });
+    const { parsed } = run(ENFORCE_TIER, payload);
+    if (!parsed) return 'no valid JSON output';
+    if (!parsed.systemMessage) return `expected systemMessage, got: ${JSON.stringify(parsed)}`;
+    const msg = parsed.systemMessage;
+    if (!msg.includes('BLOCKED') && !msg.includes('⛔'))
+      return `expected BLOCKED marker for search/opus major mismatch (overkill), got: ${msg}`;
+    if (!msg.toLowerCase().includes('haiku') && !msg.toLowerCase().includes('gpt-4.1-mini') && !msg.toLowerCase().includes('search'))
+      return `expected search-tier model suggestion in message, got: ${msg}`;
+    return true;
+  } finally {
+    if (originalProfile !== null) writeFileSync(profileFile, originalProfile);
+    else try { unlinkSync(profileFile); } catch {}
+  }
+});
+
+// ─── Test 76: mismatch severity — think on sonnet gets minor WARNING (not block) ─
+test('enforce-tier v4.5: think on sonnet → minor mismatch, warning not block', () => {
+  try { unlinkSync(COOLDOWN_FILE); } catch {}
+  const profileFile = resolve(__dirname, '..', 'dual-brain.profile.json');
+  let originalProfile;
+  try { originalProfile = readFileSync(profileFile, 'utf8'); } catch { originalProfile = null; }
+  try {
+    writeFileSync(profileFile, JSON.stringify({ active: 'balanced' }));
+    const payload = JSON.stringify({
+      tool_name: 'Agent',
+      tool_input: {
+        prompt: 'review architecture and plan the migration strategy',
+        model: 'sonnet',
+      },
+    });
+    const { parsed } = run(ENFORCE_TIER, payload);
+    if (!parsed) return 'no valid JSON output';
+    if (!parsed.systemMessage) return `expected systemMessage warning, got: ${JSON.stringify(parsed)}`;
+    const msg = parsed.systemMessage;
+    // Minor mismatch under balanced profile → warn, not block
+    if (msg.includes('⛔') || msg.includes('BLOCKED'))
+      return `expected warning (not BLOCKED) for think/sonnet minor mismatch, got: ${msg}`;
+    if (!msg.toLowerCase().includes('think') && !msg.toLowerCase().includes('mismatch') && !msg.toLowerCase().includes('opus'))
+      return `expected think-tier mention in warning, got: ${msg}`;
+    return true;
+  } finally {
+    if (originalProfile !== null) writeFileSync(profileFile, originalProfile);
+    else try { unlinkSync(profileFile); } catch {}
+  }
+});
+
+// ─── Test 76: ship-gate exports selfHealGate as a function ───────────────────
+test('ship-gate: exports selfHealGate as a function', () => {
+  const script = `
+    import { selfHealGate } from './ship-gate.mjs';
+    const results = { errors: [] };
+    if (typeof selfHealGate !== 'function') results.errors.push('selfHealGate is not a function');
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 8000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `ship-gate script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test 77: confirmation-policy handles 'heal' step correctly ───────────────
+test('confirmation-policy: heal step auto-proceeds in default mode', () => {
+  const script = `
+    import { getConfirmationPolicy } from './confirmation-policy.mjs';
+    const results = { errors: [] };
+
+    // Default mode: heal should auto-proceed at all risk levels
+    const healLow = getConfirmationPolicy({ risk: 'low', mode: 'default', step: 'heal' });
+    if (healLow.shouldBlock !== false) results.errors.push('default/low heal: expected shouldBlock=false, got: ' + healLow.shouldBlock);
+    if (healLow.shouldConfirm !== false) results.errors.push('default/low heal: expected shouldConfirm=false, got: ' + healLow.shouldConfirm);
+
+    const healHigh = getConfirmationPolicy({ risk: 'high', mode: 'default', step: 'heal' });
+    if (healHigh.shouldBlock !== false) results.errors.push('default/high heal: expected shouldBlock=false, got: ' + healHigh.shouldBlock);
+    if (healHigh.shouldConfirm !== false) results.errors.push('default/high heal: expected shouldConfirm=false, got: ' + healHigh.shouldConfirm);
+
+    const healCritical = getConfirmationPolicy({ risk: 'critical', mode: 'default', step: 'heal' });
+    if (healCritical.shouldBlock !== false) results.errors.push('default/critical heal: expected shouldBlock=false, got: ' + healCritical.shouldBlock);
+
+    // Careful mode: heal should require confirmation
+    const healCareful = getConfirmationPolicy({ risk: 'low', mode: 'careful', step: 'heal' });
+    if (healCareful.shouldConfirm !== true) results.errors.push('careful heal: expected shouldConfirm=true, got: ' + healCareful.shouldConfirm);
+
+    // Yolo mode: heal should auto-proceed
+    const healYolo = getConfirmationPolicy({ risk: 'critical', mode: 'yolo', step: 'heal' });
+    if (healYolo.shouldBlock !== false) results.errors.push('yolo heal: expected shouldBlock=false, got: ' + healYolo.shouldBlock);
+    if (healYolo.shouldConfirm !== false) results.errors.push('yolo heal: expected shouldConfirm=false, got: ' + healYolo.shouldConfirm);
+
+    // Plan-only mode: heal should be blocked (no mutations)
+    const healPlanOnly = getConfirmationPolicy({ risk: 'low', mode: 'plan-only', step: 'heal' });
+    if (healPlanOnly.shouldBlock !== true) results.errors.push('plan-only heal: expected shouldBlock=true, got: ' + healPlanOnly.shouldBlock);
+
+    process.stdout.write(JSON.stringify(results));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `confirmation-policy script failed: ${proc.stderr}`;
+  let results;
+  try { results = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (results.errors.length > 0) return results.errors.join('; ');
+  return true;
+});
+
+// ─── Test E2E-1: ship-captain plan-only mode returns without executing ────────
+test('E2E: ship-captain plan-only mode (no agent calls, no file changes)', () => {
+  // executeShipCaptain prints the plan via console.log to stdout before returning.
+  // Redirect console.log to stderr so process.stdout has only our JSON result.
+  const script = `
+    import { executeShipCaptain } from './ship-captain.mjs';
+    console.log = (...a) => process.stderr.write(a.join(' ') + '\\n');
+    console.error = (...a) => process.stderr.write(a.join(' ') + '\\n');
+    const result = await executeShipCaptain('fix a bug and write tests', { planOnly: true });
+    const errors = [];
+    if (!result || typeof result !== 'object') {
+      errors.push('executeShipCaptain did not return an object');
+    } else {
+      if (result.status !== 'dry_run') errors.push('expected status=dry_run, got: ' + result.status);
+      if (result.id !== null && result.id !== undefined) errors.push('expected id=null in plan-only, got: ' + result.id);
+      if (!result.goal) errors.push('result missing goal field');
+      if (!Array.isArray(result.steps)) errors.push('result.steps not array, got: ' + typeof result.steps);
+    }
+    process.stdout.write(JSON.stringify({ errors }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 20000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed (exit ${proc.status}): ${(proc.stderr || '').slice(0, 300)}`;
+  let result;
+  try { result = JSON.parse((proc.stdout || '').trim()); } catch { return `output not JSON: ${(proc.stdout || '').slice(0, 300)}`; }
+  if (result.errors.length > 0) return result.errors.join('; ');
+  return true;
+});
+
+// ─── Test E2E-2: ship-captain planExecution produces valid plan ───────────────
+test('E2E: planExecution("review security and write tests for auth") returns valid plan', () => {
+  const script = `
+    import { planExecution } from './ship-captain.mjs';
+    const plan = planExecution('review security and write tests for auth');
+    const errors = [];
+
+    if (!plan || typeof plan !== 'object') {
+      errors.push('planExecution did not return an object');
+    } else {
+      if (!plan.goal) errors.push('plan missing goal');
+      if (!Array.isArray(plan.steps)) {
+        errors.push('plan.steps is not an array');
+      } else {
+        if (plan.steps.length === 0) errors.push('plan.steps is empty');
+        for (const step of plan.steps) {
+          if (!step.task) { errors.push('step missing task field'); continue; }
+          if (!step.task.title && !step.task.task) errors.push('step.task missing title/task');
+          if (!step.task.tier) errors.push('step.task missing tier');
+          if (!step.task.risk) errors.push('step.task missing risk');
+          if (step.templateName === undefined && step.chainName === undefined)
+            errors.push('step missing templateName/chainName');
+        }
+      }
+    }
+
+    process.stdout.write(JSON.stringify({ errors }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 15000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed (exit ${proc.status}): ${(proc.stderr || '').slice(0, 400)}`;
+  let result;
+  try { result = JSON.parse((proc.stdout || '').trim()); } catch { return `output not JSON: ${(proc.stdout || '').slice(0, 200)}`; }
+  if (result.errors.length > 0) return result.errors.join('; ');
+  return true;
+});
+
+// ─── Test E2E-3: ship-gate discoverTests + generateDiffSummary (real repo) ────
+test('E2E: discoverTests finds npm test + generateDiffSummary returns valid shape', () => {
+  const pkgRoot = resolve(HOOKS, '..');
+  const script = `
+    import { discoverTests, generateDiffSummary } from './hooks/ship-gate.mjs';
+    const errors = [];
+
+    const discovery = discoverTests();
+    if (!discovery || typeof discovery !== 'object') {
+      errors.push('discoverTests did not return an object');
+    } else {
+      if (discovery.command !== 'npm test')
+        errors.push('expected command=npm test, got: ' + discovery.command);
+      if (discovery.confidence !== 'high')
+        errors.push('expected confidence=high, got: ' + discovery.confidence);
+    }
+
+    const diff = generateDiffSummary();
+    if (!diff || typeof diff !== 'object') {
+      errors.push('generateDiffSummary did not return an object');
+    } else {
+      if (!Array.isArray(diff.files_added)) errors.push('diff missing files_added array');
+      if (!Array.isArray(diff.files_modified)) errors.push('diff missing files_modified array');
+      if (!Array.isArray(diff.files_deleted)) errors.push('diff missing files_deleted array');
+      if (typeof diff.stats !== 'string') errors.push('diff.stats is not a string, got: ' + typeof diff.stats);
+    }
+
+    process.stdout.write(JSON.stringify({ errors }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 20000, cwd: pkgRoot });
+
+  if (proc.status !== 0) return `script failed (exit ${proc.status}): ${(proc.stderr || '').slice(0, 400)}`;
+  let result;
+  try { result = JSON.parse((proc.stdout || '').trim()); } catch { return `output not JSON: ${(proc.stdout || '').slice(0, 200)}`; }
+  if (result.errors.length > 0) return result.errors.join('; ');
+  return true;
+});
+
+// ─── Test E2E-4: runShipGate with no-pr returns structured result ─────────────
+test('E2E: runShipGate({ noPr: true, yes: true }) returns status + tests + diff', () => {
+  const pkgRoot = resolve(HOOKS, '..');
+  const script = `
+    import { runShipGate } from './hooks/ship-gate.mjs';
+    const errors = [];
+    let result;
+    try {
+      result = await runShipGate({ goal: 'E2E test run', noPr: true, yes: true });
+    } catch (e) {
+      errors.push('runShipGate threw: ' + e.message);
+      process.stdout.write(JSON.stringify({ errors }));
+      process.exit(0);
+    }
+
+    if (!result || typeof result !== 'object') {
+      errors.push('runShipGate did not return an object');
+    } else {
+      if (typeof result.status !== 'string')
+        errors.push('result.status is not a string, got: ' + typeof result.status);
+      if (!result.tests || typeof result.tests !== 'object')
+        errors.push('result.tests is missing or not an object');
+      else if (typeof result.tests.ran !== 'boolean')
+        errors.push('result.tests.ran is not a boolean');
+      if (!result.diff || typeof result.diff !== 'object')
+        errors.push('result.diff is missing or not an object');
+    }
+
+    process.stdout.write(JSON.stringify({ errors }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 180000, cwd: pkgRoot });
+
+  if (proc.status === null) return 'process timed out';
+  let result;
+  try { result = JSON.parse((proc.stdout || '').trim()); } catch { return `output not JSON: ${(proc.stdout || '').slice(0, 200)} stderr: ${(proc.stderr || '').slice(0, 200)}`; }
+  if (result.errors.length > 0) return result.errors.join('; ');
+  return true;
+});
+
+// ─── Test E2E-5: intent classification coverage (10 goals, ≥ 8/10 correct) ───
+test('E2E: classifyGoalIntent — 10 goals, at least 8/10 match expected intent', () => {
+  const script = `
+    import { classifyGoalIntent } from './ship-captain.mjs';
+    const errors = [];
+
+    const cases = [
+      { goal: 'should we use Redis or Postgres?',      expected: ['think'] },
+      { goal: 'review this PR for security issues',    expected: ['review'] },
+      { goal: 'how does the auth system work?',        expected: ['explore', 'think'] },
+      { goal: 'ship it',                               expected: ['ship'] },
+      { goal: 'fix the login bug',                     expected: ['execute'] },
+      { goal: "what's the best approach for caching?", expected: ['think'] },
+      { goal: 'find where the API key is stored',      expected: ['explore'] },
+      { goal: 'refactor the payment module',           expected: ['execute'] },
+      { goal: 'audit the architecture',                expected: ['think', 'review'] },
+      { goal: 'write tests for the API',               expected: ['execute'] },
+    ];
+
+    let correct = 0;
+    const mismatches = [];
+
+    for (const { goal, expected } of cases) {
+      const result = classifyGoalIntent(goal);
+      if (!result || typeof result !== 'object') {
+        errors.push('returned non-object for: ' + goal);
+        continue;
+      }
+      if (!result.intent) errors.push('result missing intent for: ' + goal);
+      if (!result.confidence) errors.push('result missing confidence for: ' + goal);
+      if (!result.reason) errors.push('result missing reason for: ' + goal);
+
+      if (expected.includes(result.intent)) {
+        correct++;
+      } else {
+        mismatches.push(goal + ' → got ' + result.intent + ' (expected: ' + expected.join('|') + ')');
+      }
+    }
+
+    if (correct < 8) {
+      errors.push('Only ' + correct + '/10 intents matched. Mismatches: ' + mismatches.join('; '));
+    }
+
+    process.stdout.write(JSON.stringify({ errors, correct }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 10000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed (exit ${proc.status}): ${(proc.stderr || '').slice(0, 400)}`;
+  let result;
+  try { result = JSON.parse((proc.stdout || '').trim()); } catch { return `output not JSON: ${(proc.stdout || '').slice(0, 200)}`; }
+  if (result.errors.length > 0) return result.errors.join('; ');
+  return true;
+});
+
+// ─── Test E2E-6: confirmation-policy full matrix 4x4x5 = 80 combos ───────────
+test('E2E: confirmation-policy full matrix — 80 combos, all return valid shape + invariants', () => {
+  const script = `
+    import { getConfirmationPolicy } from './confirmation-policy.mjs';
+    const errors = [];
+
+    const modes = ['default', 'yolo', 'careful', 'plan-only'];
+    const risks = ['low', 'medium', 'high', 'critical'];
+    const steps = ['edit', 'test', 'gate', 'pr', 'heal'];
+
+    for (const mode of modes) {
+      for (const risk of risks) {
+        for (const step of steps) {
+          let result;
+          try {
+            result = getConfirmationPolicy({ risk, mode, step });
+          } catch (e) {
+            errors.push('threw for ' + mode + '/' + risk + '/' + step + ': ' + e.message);
+            continue;
+          }
+
+          if (!result || typeof result !== 'object') {
+            errors.push('non-object for ' + mode + '/' + risk + '/' + step);
+            continue;
+          }
+          if (typeof result.shouldConfirm !== 'boolean')
+            errors.push('shouldConfirm not boolean for ' + mode + '/' + risk + '/' + step);
+          if (typeof result.shouldBlock !== 'boolean')
+            errors.push('shouldBlock not boolean for ' + mode + '/' + risk + '/' + step);
+          if (typeof result.reason !== 'string')
+            errors.push('reason not string for ' + mode + '/' + risk + '/' + step);
+
+          // Invariant: yolo — shouldBlock never true
+          if (mode === 'yolo' && result.shouldBlock === true)
+            errors.push('yolo/shouldBlock must never be true, got true for ' + risk + '/' + step);
+
+          // Invariant: careful — edit and pr steps always confirm
+          if (mode === 'careful' && (step === 'edit' || step === 'pr') && result.shouldConfirm !== true)
+            errors.push('careful/' + step + '/' + risk + ': expected shouldConfirm=true, got: ' + result.shouldConfirm);
+
+          // Invariant: plan-only — edit/test/gate/pr all blocked
+          if (mode === 'plan-only' && ['edit', 'test', 'gate', 'pr'].includes(step) && result.shouldBlock !== true)
+            errors.push('plan-only/' + step + '/' + risk + ': expected shouldBlock=true, got: ' + result.shouldBlock);
+
+          // Invariant: default + critical + edit → blocked
+          if (mode === 'default' && risk === 'critical' && step === 'edit' && result.shouldBlock !== true)
+            errors.push('default/critical/edit: expected shouldBlock=true, got: ' + result.shouldBlock);
+        }
+      }
+    }
+
+    process.stdout.write(JSON.stringify({ errors }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 10000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed (exit ${proc.status}): ${(proc.stderr || '').slice(0, 400)}`;
+  let result;
+  try { result = JSON.parse((proc.stdout || '').trim()); } catch { return `output not JSON: ${(proc.stdout || '').slice(0, 200)}`; }
+  if (result.errors.length > 0) return result.errors.join('; ');
+  return true;
+});
+
+// ─── Test E2E-7: selfHealGate + selfHealTests API and noHeal short-circuit ────
+test('E2E: selfHealGate and selfHealTests — async, correct noHeal short-circuit', () => {
+  const script = `
+    import { selfHealGate } from './ship-gate.mjs';
+    import { selfHealTests } from './ship-captain.mjs';
+    const errors = [];
+
+    if (typeof selfHealGate !== 'function') errors.push('selfHealGate is not a function');
+    if (typeof selfHealTests !== 'function') errors.push('selfHealTests is not a function');
+
+    // Call with noHeal=true — should return immediately without spawning claude
+    const gatePromise = selfHealGate({ gate: 'issues_found' }, { noHeal: true });
+    const testsPromise = selfHealTests({ passed: false, output: 'test error', exit_code: 1 }, { noHeal: true });
+
+    if (!gatePromise || typeof gatePromise.then !== 'function')
+      errors.push('selfHealGate did not return a Promise');
+    if (!testsPromise || typeof testsPromise.then !== 'function')
+      errors.push('selfHealTests did not return a Promise');
+
+    const gateRes = await gatePromise;
+    const testsRes = await testsPromise;
+
+    if (gateRes.healed !== false) errors.push('selfHealGate noHeal: expected healed=false, got: ' + gateRes.healed);
+    if (gateRes.attempts !== 0) errors.push('selfHealGate noHeal: expected attempts=0, got: ' + gateRes.attempts);
+    if (!('finalGateResult' in gateRes)) errors.push('selfHealGate missing finalGateResult field');
+
+    if (testsRes.healed !== false) errors.push('selfHealTests noHeal: expected healed=false, got: ' + testsRes.healed);
+    if (testsRes.attempts !== 0) errors.push('selfHealTests noHeal: expected attempts=0, got: ' + testsRes.attempts);
+    if (!('finalTestResult' in testsRes)) errors.push('selfHealTests missing finalTestResult field');
+
+    process.stdout.write(JSON.stringify({ errors }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module',
+    '-e', script,
+  ], { encoding: 'utf8', timeout: 15000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed (exit ${proc.status}): ${(proc.stderr || '').slice(0, 400)}`;
+  let result;
+  try { result = JSON.parse((proc.stdout || '').trim()); } catch { return `output not JSON: ${(proc.stdout || '').slice(0, 200)}`; }
+  if (result.errors.length > 0) return result.errors.join('; ');
+  return true;
+});
+
+// ─── Test E2E-8: resume handles various run record states ─────────────────────
+test('E2E: resume logic handles completed/failed/aborted run records', () => {
+  const tmpDir = spawnSync('mktemp', ['-d'], { encoding: 'utf8' }).stdout.trim();
+  try {
+    const script = `
+      import { mkdirSync, writeFileSync, readFileSync, readdirSync } from 'fs';
+      import { resolve } from 'path';
+
+      const tmpDir = ${JSON.stringify(tmpDir)};
+      const runsDir = resolve(tmpDir, '.claude', 'runs');
+      mkdirSync(runsDir, { recursive: true });
+
+      const completedRecord = {
+        id: 'run-2026-01-01T00-00-00',
+        goal: 'fix the login bug',
+        status: 'completed',
+        steps: [
+          { task: 'Explore codebase', status: 'done' },
+          { task: 'Fix bug', status: 'done' },
+        ],
+        started_at: '2026-01-01T00:00:00.000Z',
+        completed_at: '2026-01-01T00:10:00.000Z',
+      };
+      writeFileSync(resolve(runsDir, 'run-completed.json'), JSON.stringify(completedRecord, null, 2), 'utf8');
+
+      const failedRecord = {
+        id: 'run-2026-01-01T01-00-00',
+        goal: 'refactor auth module',
+        status: 'failed',
+        steps: [
+          { task: 'Explore auth module', status: 'done' },
+          { task: 'Refactor code', status: 'failed', error: 'compilation error' },
+          { task: 'Write tests', status: 'pending' },
+        ],
+        started_at: '2026-01-01T01:00:00.000Z',
+        completed_at: null,
+      };
+      writeFileSync(resolve(runsDir, 'run-failed.json'), JSON.stringify(failedRecord, null, 2), 'utf8');
+
+      const abortedRecord = {
+        id: 'run-2026-01-01T02-00-00',
+        goal: 'write tests for API',
+        status: 'aborted',
+        steps: [
+          { task: 'Discover test files', status: 'done' },
+        ],
+        started_at: '2026-01-01T02:00:00.000Z',
+        completed_at: null,
+      };
+      writeFileSync(resolve(runsDir, 'run-aborted.json'), JSON.stringify(abortedRecord, null, 2), 'utf8');
+
+      const errors = [];
+
+      const completedBack = JSON.parse(readFileSync(resolve(runsDir, 'run-completed.json'), 'utf8'));
+      if (completedBack.status !== 'completed')
+        errors.push('completed record: wrong status: ' + completedBack.status);
+      const allDone = completedBack.steps.every(s => s.status === 'done');
+      if (!allDone) errors.push('completed record: not all steps done');
+
+      const failedBack = JSON.parse(readFileSync(resolve(runsDir, 'run-failed.json'), 'utf8'));
+      if (failedBack.status !== 'failed')
+        errors.push('failed record: wrong status: ' + failedBack.status);
+      const failedStepIdx = failedBack.steps.findIndex(s => s.status === 'failed');
+      if (failedStepIdx !== 1)
+        errors.push('failed record: expected failed step at index 1, got: ' + failedStepIdx);
+
+      const abortedBack = JSON.parse(readFileSync(resolve(runsDir, 'run-aborted.json'), 'utf8'));
+      if (abortedBack.status !== 'aborted')
+        errors.push('aborted record: wrong status: ' + abortedBack.status);
+
+      const files = readdirSync(runsDir).filter(f => f.endsWith('.json'));
+      if (files.length !== 3) errors.push('expected 3 run records, got: ' + files.length);
+
+      process.stdout.write(JSON.stringify({ errors }));
+    `;
+    const proc = spawnSync(process.execPath, [
+      '--input-type=module',
+      '-e', script,
+    ], { encoding: 'utf8', timeout: 10000, cwd: HOOKS });
+
+    if (proc.status !== 0) return `script failed (exit ${proc.status}): ${(proc.stderr || '').slice(0, 400)}`;
+    let result;
+    try { result = JSON.parse((proc.stdout || '').trim()); } catch { return `output not JSON: ${(proc.stdout || '').slice(0, 200)}`; }
+    if (result.errors.length > 0) return result.errors.join('; ');
+    return true;
+  } finally {
+    spawnSync('rm', ['-rf', tmpDir], { stdio: 'pipe' });
+  }
+});
+
+// ─── Test scale-1: large JSONL ledger performance ─────────────────────────────
+test('scale: large JSONL ledger (1000 entries) completes in < 2000ms', () => {
+  const LEDGER = resolve(HOOKS, 'decision-ledger.jsonl');
+  const backup = existsSync(LEDGER) ? readFileSync(LEDGER, 'utf8') : null;
+
+  try {
+    // Build 1000 paired entries spanning 48 hours.
+    // Each pair: one 'decision' + one 'outcome' linked by id/decision_id.
+    // Pairs 0-499 are older than 24h; pairs 500-999 are within 24h.
+    // getOutcomeStats merges decisions with outcomes, so both types are needed.
+    const lines = [];
+    const now = Date.now();
+    for (let i = 0; i < 1000; i++) {
+      const ageMs = (1000 - i) * (48 * 60 * 60 * 1000 / 1000);
+      const ts = new Date(now - ageMs).toISOString();
+      const tier = i % 3 === 0 ? 'search' : i % 3 === 1 ? 'execute' : 'think';
+      const provider = i % 2 === 0 ? 'claude' : 'openai';
+      lines.push(JSON.stringify({
+        type: 'decision',
+        timestamp: ts,
+        id: `scale-test-${i}`,
+        tier,
+        provider,
+        model: provider === 'claude' ? 'sonnet' : 'gpt-5.4',
+      }));
+      lines.push(JSON.stringify({
+        type: 'outcome',
+        timestamp: ts,
+        decision_id: `scale-test-${i}`,
+        success: i % 5 !== 0,
+      }));
+    }
+    writeFileSync(LEDGER, lines.join('\n') + '\n', 'utf8');
+
+    const script = `
+      import { getOutcomeStats } from './decision-ledger.mjs';
+      const start = Date.now();
+      const stats = getOutcomeStats();
+      const elapsed = Date.now() - start;
+      process.stdout.write(JSON.stringify({ elapsed, total_outcomes: stats.total_outcomes }));
+    `;
+    const proc = spawnSync(process.execPath, [
+      '--input-type=module', '-e', script,
+    ], { encoding: 'utf8', timeout: 10000, cwd: HOOKS });
+
+    if (proc.status !== 0) return `script failed: ${proc.stderr}`;
+    let result;
+    try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+
+    if (result.elapsed >= 2000) return `took ${result.elapsed}ms — expected < 2000ms`;
+    if (result.total_outcomes < 400 || result.total_outcomes > 600)
+      return `expected ~500 outcomes in last 24h, got: ${result.total_outcomes}`;
+
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(LEDGER, backup, 'utf8');
+    else try { writeFileSync(LEDGER, '', 'utf8'); } catch {}
+  }
+});
+
+// ─── Test scale-2: large usage log (500 entries) doesn't crash ────────────────
+test('scale: large usage JSONL (500 entries) loads without crash', () => {
+  const today = new Date().toISOString().slice(0, 10);
+  const usageFile = resolve(HOOKS, `usage-${today}.jsonl`);
+  const backup = existsSync(usageFile) ? readFileSync(usageFile, 'utf8') : null;
+
+  try {
+    const lines = [];
+    const now = Date.now();
+    for (let i = 0; i < 500; i++) {
+      const ts = new Date(now - i * 60 * 1000).toISOString();
+      lines.push(JSON.stringify({
+        timestamp: ts,
+        tier: i % 3 === 0 ? 'search' : i % 3 === 1 ? 'execute' : 'think',
+        tool: 'Agent',
+        status: i % 10 === 0 ? 'error' : 'ok',
+        duration_ms: 500 + i * 10,
+      }));
+    }
+    writeFileSync(usageFile, lines.join('\n') + '\n', 'utf8');
+
+    const script = `
+      import { rebuildSummary } from './summary-checkpoint.mjs';
+      let ok = false;
+      try {
+        rebuildSummary();
+        ok = true;
+      } catch (e) {
+        process.stdout.write(JSON.stringify({ ok: false, error: e.message }));
+        process.exit(0);
+      }
+      process.stdout.write(JSON.stringify({ ok }));
+    `;
+    const proc = spawnSync(process.execPath, [
+      '--input-type=module', '-e', script,
+    ], { encoding: 'utf8', timeout: 10000, cwd: HOOKS });
+
+    if (proc.status !== 0) return `script failed: ${proc.stderr}`;
+    let result;
+    try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+    if (!result.ok) return `rebuildSummary crashed: ${result.error}`;
+
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(usageFile, backup, 'utf8');
+    else try { writeFileSync(usageFile, '', 'utf8'); } catch {}
+  }
+});
+
+// ─── Test scale-3: 100 run records in .claude/runs/ ──────────────────────────
+test('scale: 100 run records read and listed in < 1000ms', () => {
+  const tmpDir = spawnSync('mktemp', ['-d'], { encoding: 'utf8' }).stdout.trim();
+  try {
+    const runsDir = resolve(tmpDir, '.claude', 'runs');
+    spawnSync('mkdir', ['-p', runsDir], { stdio: 'pipe' });
+
+    // 90 completed, 5 failed, 3 aborted, 2 running (incomplete)
+    const now = Date.now();
+    for (let i = 0; i < 100; i++) {
+      let status;
+      if (i < 90) status = 'completed';
+      else if (i < 95) status = 'failed';
+      else if (i < 98) status = 'aborted';
+      else status = 'running';
+
+      const ts = new Date(now - i * 10 * 60 * 1000).toISOString();
+      const rec = {
+        id: `run-${String(i).padStart(3, '0')}`,
+        goal: `test goal ${i}`,
+        status,
+        steps: status === 'running' ? [{ task: 'step1', done: false }] : [],
+        started_at: ts,
+        completed_at: status !== 'running' ? new Date(now - i * 10 * 60 * 1000 + 5000).toISOString() : null,
+        duration_ms: status !== 'running' ? 5000 : null,
+      };
+      const fname = `${ts.slice(0, 19).replace(/:/g, '-')}-run-${String(i).padStart(3, '0')}.json`;
+      writeFileSync(resolve(runsDir, fname), JSON.stringify(rec, null, 2), 'utf8');
+    }
+
+    const installScript = resolve(HOOKS, '..', 'install.mjs');
+    const startMs = Date.now();
+    const proc = spawnSync(process.execPath, [installScript, 'runs'], {
+      encoding: 'utf8',
+      timeout: 10000,
+      cwd: tmpDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const elapsed = Date.now() - startMs;
+
+    if (proc.status === null) return 'process timed out';
+    if (elapsed >= 1000) return `runs command took ${elapsed}ms — expected < 1000ms`;
+
+    const output = proc.stdout || '';
+    if (!output.includes('100') && !output.toLowerCase().includes('run'))
+      return `expected output mentioning runs, got: ${output.slice(0, 200)}`;
+
+    // Verify resume can identify failed/incomplete runs without crashing
+    const resumeProc = spawnSync(process.execPath, [installScript, 'resume'], {
+      encoding: 'utf8',
+      timeout: 10000,
+      cwd: tmpDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (resumeProc.status === null) return 'resume process timed out';
+    const resumeOut = (resumeProc.stdout || '') + (resumeProc.stderr || '');
+    if (resumeOut.includes('TypeError') || resumeOut.includes('ReferenceError'))
+      return `unexpected JS error in resume: ${resumeOut.slice(0, 200)}`;
+
+    return true;
+  } finally {
+    spawnSync('rm', ['-rf', tmpDir], { stdio: 'pipe' });
+  }
+});
+
+// ─── Test scale-4: burst-state survives 10 rapid sequential writes ────────────
+test('scale: burst-state valid JSON after 10 rapid sequential writes', () => {
+  const burstFile = resolve(HOOKS, '.burst-state');
+  const backup = existsSync(burstFile) ? readFileSync(burstFile, 'utf8') : null;
+
+  try {
+    for (let i = 1; i <= 10; i++) {
+      writeFileSync(burstFile, JSON.stringify({ count: i, window_start: Date.now() }), 'utf8');
+    }
+
+    if (!existsSync(burstFile)) return '.burst-state file not found after writes';
+    let state;
+    try {
+      state = JSON.parse(readFileSync(burstFile, 'utf8'));
+    } catch (e) {
+      return `.burst-state not valid JSON after 10 writes: ${e.message}`;
+    }
+
+    if (typeof state.count !== 'number') return `expected numeric count, got: ${JSON.stringify(state)}`;
+    if (typeof state.window_start !== 'number') return `expected numeric window_start, got: ${JSON.stringify(state)}`;
+    if (state.count !== 10) return `expected count=10 after 10 writes, got: ${state.count}`;
+
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(burstFile, backup, 'utf8');
+    else try { unlinkSync(burstFile); } catch {}
+  }
+});
+
+// ─── Test scale-5: atomic-write lock-contention then success (round-trip) ─────
+test('scale: atomic-write lock-contention then success (round-trip)', () => {
+  const tmpDir = spawnSync('mktemp', ['-d'], { encoding: 'utf8' }).stdout.trim();
+  const testFile = resolve(tmpDir, 'counter.json');
+  const lockFile = testFile + '.lock';
+
+  try {
+    writeFileSync(testFile, JSON.stringify({ count: 0 }), 'utf8');
+
+    // Phase 1: pre-create lock → expect timeout throw
+    writeFileSync(lockFile, JSON.stringify({ pid: 99999999, ts: Date.now() }), 'utf8');
+
+    const atomicPath = resolve(HOOKS, 'atomic-write.mjs').replace(/\\/g, '/');
+    const filePath = testFile.replace(/\\/g, '/');
+
+    const script1 = `
+      import { lockedReadModifyWrite } from '${atomicPath}';
+      try {
+        lockedReadModifyWrite('${filePath}', d => ({ ...d, count: d.count + 1 }));
+        process.stdout.write(JSON.stringify({ threw: false }));
+      } catch (e) {
+        process.stdout.write(JSON.stringify({ threw: true, msg: e.message }));
+      }
+    `;
+    const proc1 = spawnSync(process.execPath, [
+      '--input-type=module', '-e', script1,
+    ], { encoding: 'utf8', timeout: 15000, cwd: HOOKS });
+
+    let r1;
+    try { r1 = JSON.parse((proc1.stdout || '').trim()); } catch {
+      return `phase1 output not JSON: ${proc1.stdout} stderr: ${proc1.stderr}`;
+    }
+    if (!r1.threw) return 'expected throw on lock contention, but did not throw';
+    if (!r1.msg.includes('timed out')) return `expected timeout message, got: ${r1.msg}`;
+
+    const afterContention = JSON.parse(readFileSync(testFile, 'utf8'));
+    if (afterContention.count !== 0)
+      return `file modified during contention — expected count=0, got: ${afterContention.count}`;
+
+    // Phase 2: remove lock → expect success
+    try { unlinkSync(lockFile); } catch {}
+
+    const script2 = `
+      import { lockedReadModifyWrite } from '${atomicPath}';
+      try {
+        const result = lockedReadModifyWrite('${filePath}', d => ({ ...d, count: d.count + 1 }));
+        process.stdout.write(JSON.stringify({ threw: false, count: result.count }));
+      } catch (e) {
+        process.stdout.write(JSON.stringify({ threw: true, msg: e.message }));
+      }
+    `;
+    const proc2 = spawnSync(process.execPath, [
+      '--input-type=module', '-e', script2,
+    ], { encoding: 'utf8', timeout: 15000, cwd: HOOKS });
+
+    let r2;
+    try { r2 = JSON.parse((proc2.stdout || '').trim()); } catch {
+      return `phase2 output not JSON: ${proc2.stdout} stderr: ${proc2.stderr}`;
+    }
+    if (r2.threw) return `unexpected throw after lock removed: ${r2.msg}`;
+    if (r2.count !== 1) return `expected count=1 after successful write, got: ${r2.count}`;
+
+    const final = JSON.parse(readFileSync(testFile, 'utf8'));
+    if (final.count !== 1) return `file on disk: expected count=1, got: ${final.count}`;
+
+    return true;
+  } finally {
+    spawnSync('rm', ['-rf', tmpDir], { stdio: 'pipe' });
+  }
+});
+
+// ─── Test scale-6: config validation with 50 unknown keys ─────────────────────
+test('scale: config-validator handles 50 unknown keys without crash', () => {
+  const script = `
+    import { validateConfig } from './config-validator.mjs';
+
+    const config = {
+      subscriptions: { claude: { models: { opus: { tier: 'think' } } } },
+      tiers: { search: {}, execute: {}, think: {} },
+      routing: { strategy: 'test' },
+      quality_gate: { enabled: true },
+    };
+
+    for (let i = 0; i < 50; i++) {
+      config['unknown_key_' + i] = { value: i, nested: { deep: true } };
+    }
+
+    const result = validateConfig(config);
+    process.stdout.write(JSON.stringify({
+      valid: result.valid,
+      errorCount: result.errors.length,
+      warnCount: result.warnings.length,
+    }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module', '-e', script,
+  ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script failed: ${proc.stderr}`;
+  let result;
+  try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (!result.valid) return `expected valid=true (unknown keys are warnings), errors present`;
+  if (result.warnCount < 50) return `expected >= 50 warnings for 50 unknown keys, got: ${result.warnCount}`;
+  return true;
+});
+
+// ─── Test scale-7: risk-classifier edge case paths don't crash ────────────────
+test('scale: risk-classifier edge case paths (empty, long, special chars, null)', () => {
+  const script = `
+    import { classifyRisk, classifyRiskEnhanced } from './risk-classifier.mjs';
+    const errors = [];
+
+    // 1. Empty string
+    try {
+      const r = classifyRiskEnhanced('');
+      if (!r || typeof r.risk !== 'string') errors.push('empty string: invalid result: ' + JSON.stringify(r));
+    } catch (e) {
+      errors.push('empty string threw: ' + e.message);
+    }
+
+    // 2. Very long path (500 chars)
+    const longPath = 'src/' + 'a'.repeat(490) + '.js';
+    try {
+      const r = classifyRiskEnhanced(longPath);
+      if (!r || typeof r.risk !== 'string') errors.push('long path: invalid result: ' + JSON.stringify(r));
+    } catch (e) {
+      errors.push('long path threw: ' + e.message);
+    }
+
+    // 3. Path with special characters
+    try {
+      const r = classifyRiskEnhanced('src/auth/my-file!@#$%^&*().mjs');
+      if (!r || typeof r.risk !== 'string') errors.push('special chars: invalid result: ' + JSON.stringify(r));
+    } catch (e) {
+      errors.push('special chars threw: ' + e.message);
+    }
+
+    // 4. null — acceptable to throw, must not crash process
+    try { classifyRiskEnhanced(null); } catch { /* acceptable */ }
+
+    // 5. undefined — acceptable to throw
+    try { classifyRiskEnhanced(undefined); } catch { /* acceptable */ }
+
+    // 6. classifyRisk (batch) with empty array — returns object { level, reason }
+    try {
+      const r = classifyRisk([]);
+      if (!r || typeof r !== 'object') errors.push('classifyRisk([]): expected object result, got: ' + typeof r);
+      else if (typeof r.level !== 'string') errors.push('classifyRisk([]): expected result.level string, got: ' + JSON.stringify(r));
+    } catch (e) {
+      errors.push('classifyRisk([]) threw: ' + e.message);
+    }
+
+    process.stdout.write(JSON.stringify({ errors }));
+  `;
+  const proc = spawnSync(process.execPath, [
+    '--input-type=module', '-e', script,
+  ], { encoding: 'utf8', timeout: 8000, cwd: HOOKS });
+
+  if (proc.status !== 0) return `script crashed: ${proc.stderr}`;
+  let result;
+  try { result = JSON.parse(proc.stdout.trim()); } catch { return `output not JSON: ${proc.stdout}`; }
+  if (result.errors.length > 0) return result.errors.join('; ');
+  return true;
+});
+
+// ─── Test scale-8: enforce-tier 10 rapid sequential Agent calls ───────────────
+test('scale: enforce-tier 10 rapid sequential Agent calls all produce valid JSON', () => {
+  try {
+    // Pre-seed burst state so we start in burst mode (suppresses duplicate warnings)
+    writeFileSync(BURST_FILE, JSON.stringify({ count: 5, window_start: Date.now() }));
+
+    const errors = [];
+    for (let i = 0; i < 10; i++) {
+      const payload = JSON.stringify({
+        tool_name: 'Agent',
+        tool_input: {
+          prompt: `rapid sequential task ${i} - implement feature ${Date.now()}`,
+          model: 'sonnet',
+        },
+      });
+      const { parsed, status } = run(ENFORCE_TIER, payload);
+      if (status !== 0) errors.push(`call ${i}: non-zero exit ${status}`);
+      if (!parsed) errors.push(`call ${i}: no valid JSON output`);
+    }
+
+    if (errors.length > 0) return errors.join('; ');
+
+    // Verify burst-state is still valid JSON after 10 rapid calls
+    if (!existsSync(BURST_FILE)) return '.burst-state missing after 10 rapid calls';
+    let state;
+    try {
+      state = JSON.parse(readFileSync(BURST_FILE, 'utf8'));
+    } catch (e) {
+      return `.burst-state corrupted after 10 rapid calls: ${e.message}`;
+    }
+    if (typeof state.count !== 'number') return `burst-state.count not a number: ${JSON.stringify(state)}`;
+
+    return true;
+  } finally {
+    try { unlinkSync(BURST_FILE); } catch {}
+  }
+});
+
 // ─── Summary ─────────────────────────────────────────────────────────────────
 const total = passed + failed;
 console.log(`\n${passed}/${total} tests passed`);