dual-brain 3.7.2 → 3.8.1

package/README.md

@@ -1,6 +1,6 @@
 # Dual-Brain Orchestrator
 
-One command. Both brains. Auto-detected. Auto-configured.
+One command. Both brains. Auto-detected. Auto-configured. Default profile: **auto**.
 
 Dual-provider orchestration for Claude Code across Claude and OpenAI subscriptions. Routes search to cheap models, execution to mid-tier, thinking to the most capable. Dispatches work to GPT via Codex CLI. Dual-brain analysis for high-risk decisions.
 
@@ -36,9 +36,9 @@ npx -y dual-brain
 
 ## How it works
 
-**Two hooks fire automatically** (registered in `.claude/settings.json`):
+**Two advisory hooks** are registered in `.claude/settings.json` and fire on each tool use. They detect and recommend — they do not execute actions without user confirmation:
 
-- **enforce-tier.mjs** (PreToolUse on Agent): Classifies tasks, advises the correct model, detects duplicates, suggests cross-provider routing
+- **enforce-tier.mjs** (PreToolUse on Agent): Classifies tasks, recommends the correct model tier, detects duplicates, suggests cross-provider routing
 - **cost-logger.mjs** (PostToolUse on all tools): Logs usage to daily rotated files for cost tracking
 
 **Three tiers route work by complexity:**
@@ -49,7 +49,7 @@ npx -y dual-brain
 | Execute | Sonnet | GPT-5.4 | edits, tests, git ops |
 | Think | Opus | GPT-5.5 | architecture, review, planning |
 
-**Dual-brain** kicks in automatically for high-risk decisions — both providers think on the same problem independently.
+**Dual-brain** is recommended automatically for high-risk decisions — hooks detect the risk level and suggest dual-brain analysis, where both providers think on the same problem independently.
 
 ## Scripts
 
@@ -63,7 +63,7 @@ npx -y dual-brain
 | `hooks/gpt-work-dispatcher.mjs` | Dispatch execution tasks to GPT via Codex CLI |
 | `hooks/session-report.mjs` | Session-end summary: activity, compliance, quality |
 | `hooks/health-check.mjs` | Verify all hooks and dependencies are working |
-| `hooks/test-orchestrator.mjs` | Self-test harness (14 tests) |
+| `hooks/test-orchestrator.mjs` | Self-test harness (29 tests) |
 | `hooks/setup-wizard.mjs` | Interactive config (optional — for custom plans) |
 | `hooks/install-git-hooks.mjs` | Git pre-commit hook for quality gate |
 
@@ -85,6 +85,20 @@ After install, edit these files:
 - `review-rules.md` — project-specific rules for GPT code review
 - `settings.json` — hook registrations (auto-generated, safe to extend)
 
+## Profiles
+
+The active profile controls routing posture, budgets, and quality gate behavior. Default: **auto**.
+
+```bash
+npx dual-brain mode cost-saver   # switch profile
+npx dual-brain status            # check current profile and provider health
+```
+
+- **auto** (default): Adapts routing based on task risk, provider health, and outcomes. Auto-escalates tier on repeated failures.
+- **balanced**: Best model per tier, normal budgets, reviews at medium+ risk.
+- **cost-saver**: Prefer cheaper models, lower budgets, skip GPT for non-critical work.
+- **quality-first**: Dual-brain for medium+ risk, higher budgets, stricter reviews.
+
 ## Requirements
 
 - Node 20+

package/hooks/cost-logger.mjs

@@ -265,9 +265,11 @@ async function main() {
   // Record failures for adaptive routing (failure-loop detection)
   if (status === 'error' && toolName === 'Agent') {
     try {
-      const { recordFailure } = await import('./failure-detector.mjs');
+      const { recordFailure, pruneOldFailures } = await import('./failure-detector.mjs');
       const promptHash = createHash('md5').update(JSON.stringify(toolInput)).digest('hex').slice(0, 12);
       recordFailure(promptHash, tier, payload?.error || 'agent_error');
+      // Best-effort cleanup of stale failure entries (>24h old)
+      try { pruneOldFailures(); } catch {}
     } catch {}
   }
 

package/hooks/enforce-tier.mjs

@@ -10,6 +10,17 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const CONFIG_FILE = resolve(__dirname, '..', 'orchestrator.json');
 const PROFILE_FILE = resolve(__dirname, '..', 'dual-brain.profile.json');
 const DRIFT_STATE = resolve(__dirname, '.drift-warned');
+const BURST_FILE = resolve(__dirname, '.burst-state');
+
+function detectBurst() {
+  const now = Date.now();
+  let state = { count: 0, window_start: now };
+  try { state = JSON.parse(readFileSync(BURST_FILE, 'utf8')); } catch {}
+  if (now - state.window_start > 90_000) state = { count: 0, window_start: now };
+  state.count++;
+  try { writeFileSync(BURST_FILE, JSON.stringify(state)); } catch {}
+  return state.count >= 3;
+}
 
 function loadProfile() {
   try {
@@ -205,12 +216,23 @@ try {
   // Compute prompt hash early for duplicate detection and logging
   const promptHash = createHash('sha256').update(text).digest('hex').slice(0, 12);
 
+  // Burst detection — suppress noise during wave launches (3+ agents in 90s)
+  const burstMode = detectBurst();
+
   // Check for duplicate agent dispatch before tier classification
   const duplicate = checkDuplicate(promptHash);
   let duplicateWarning = null;
   if (duplicate) {
     const minutesAgo = Math.round((Date.now() - Date.parse(duplicate.timestamp)) / 60000);
-    duplicateWarning = `**[Duplicate Warning]** A similar agent task was dispatched ${minutesAgo} minute${minutesAgo !== 1 ? 's' : ''} ago. Reuse the prior result unless the scope changed.`;
+    if (burstMode) {
+      // In burst mode, only warn on exact hash matches (same description+prompt)
+      if (duplicate.prompt_hash === promptHash) {
+        duplicateWarning = `**[Wave] [Duplicate Warning]** A similar agent task was dispatched ${minutesAgo} minute${minutesAgo !== 1 ? 's' : ''} ago. Reuse the prior result unless the scope changed.`;
+      }
+      // Otherwise suppress — similar-but-different agents in a wave are expected
+    } else {
+      duplicateWarning = `**[Duplicate Warning]** A similar agent task was dispatched ${minutesAgo} minute${minutesAgo !== 1 ? 's' : ''} ago. Reuse the prior result unless the scope changed.`;
+    }
   }
 
   let config;
@@ -294,7 +316,7 @@ try {
   }
 
   // Failure loop detection
-  const failureCheck = checkFailureLoop(promptHash);
+  const failureCheck = checkFailureLoop(promptHash, tier);
   let failureMessage = null;
   if (failureCheck.isLoop) {
     if (failureCheck.suggestion === 'promote_tier' && tier === 'execute') {
@@ -315,7 +337,8 @@ try {
   }
 
   // Compute balance hint now that tier is resolved
-  {
+  // In burst mode, skip balance hints — one hint per wave is enough
+  if (!burstMode) {
     const currentProvider = detectProvider(currentModel);
     if (currentProvider === 'claude') {
       const balance = quickPressureCheck(tier);

package/hooks/failure-detector.mjs

@@ -3,22 +3,38 @@
  * failure-detector.mjs — Detects repeated failure loops for adaptive routing.
  *
  * Exports:
- *   checkFailureLoop(promptHash) → { isLoop, count, suggestion }
+ *   checkFailureLoop(promptHash, tier?) → { isLoop, count, weightedScore, suggestion }
  *   recordFailure(promptHash, tier, reason) → void
+ *   pruneOldFailures() → { pruned, remaining }
  */
 
-import { readFileSync, appendFileSync } from 'fs';
+import { readFileSync, appendFileSync, writeFileSync, renameSync, unlinkSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const LEDGER_FILE = join(__dirname, 'decision-ledger.jsonl');
 
-function checkFailureLoop(promptHash) {
-  if (!promptHash) return { isLoop: false, count: 0, suggestion: null };
+/**
+ * Compute a decay weight based on failure age.
+ * 0-30 min → 1.0, 30-60 min → 0.5, 60-120 min → 0.25, >120 min → 0 (excluded by window)
+ */
+function decayWeight(timestampMs, now) {
+  const ageMs = now - timestampMs;
+  const ageMin = ageMs / (60 * 1000);
+  if (ageMin <= 30) return 1.0;
+  if (ageMin <= 60) return 0.5;
+  return 0.25; // 60-120 min
+}
+
+function checkFailureLoop(promptHash, tier) {
+  if (!promptHash) return { isLoop: false, count: 0, weightedScore: 0, suggestion: null };
 
-  const twoHoursAgo = Date.now() - 2 * 60 * 60 * 1000;
-  let failures = 0;
+  const now = Date.now();
+  const twoHoursAgo = now - 2 * 60 * 60 * 1000;
+  let count = 0;
+  let weightedScore = 0;
   let lastTier = null;
 
   try {
@@ -27,22 +43,26 @@ function checkFailureLoop(promptHash) {
       try {
         const entry = JSON.parse(line);
         if (entry.prompt_hash !== promptHash) continue;
-        if (Date.parse(entry.timestamp) < twoHoursAgo) continue;
-        if (entry.success === false) {
-          failures++;
-          lastTier = entry.tier;
-        }
+        const entryTime = Date.parse(entry.timestamp);
+        if (entryTime < twoHoursAgo) continue;
+        if (entry.success !== false) continue;
+        // If tier is provided, only count matching tiers
+        if (tier && entry.tier && entry.tier !== tier) continue;
+
+        count++;
+        weightedScore += decayWeight(entryTime, now);
+        lastTier = entry.tier;
       } catch {}
     }
   } catch {}
 
-  if (failures < 2) return { isLoop: false, count: failures, suggestion: null };
+  if (weightedScore < 2.0) return { isLoop: false, count, weightedScore, suggestion: null };
 
   const suggestion = lastTier === 'execute'
     ? 'promote_tier'
     : 'escalate_to_dual_brain';
 
-  return { isLoop: true, count: failures, suggestion };
+  return { isLoop: true, count, weightedScore, suggestion };
 }
 
 function recordFailure(promptHash, tier, reason) {
@@ -59,4 +79,46 @@ function recordFailure(promptHash, tier, reason) {
   } catch {}
 }
 
-export { checkFailureLoop, recordFailure };
+/**
+ * Remove failure entries older than 24 hours from the ledger.
+ * Uses atomic write (tmp file + rename) to avoid corruption.
+ */
+function pruneOldFailures() {
+  const twentyFourHoursAgo = Date.now() - 24 * 60 * 60 * 1000;
+  let pruned = 0;
+  let remaining = 0;
+  const kept = [];
+
+  try {
+    const lines = readFileSync(LEDGER_FILE, 'utf8').split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        const entryTime = Date.parse(entry.timestamp);
+        if (entry.type === 'failure' && entryTime < twentyFourHoursAgo) {
+          pruned++;
+        } else {
+          kept.push(line);
+          remaining++;
+        }
+      } catch {
+        // Keep unparseable lines to avoid data loss
+        kept.push(line);
+        remaining++;
+      }
+    }
+
+    const tmpFile = LEDGER_FILE + `.tmp.${process.pid}`;
+    writeFileSync(tmpFile, kept.length > 0 ? kept.join('\n') + '\n' : '');
+    renameSync(tmpFile, LEDGER_FILE);
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      try { unlinkSync(LEDGER_FILE + `.tmp.${process.pid}`); } catch {}
+    }
+    return { pruned: 0, remaining: 0 };
+  }
+
+  return { pruned, remaining };
+}
+
+export { checkFailureLoop, recordFailure, pruneOldFailures };

package/hooks/test-orchestrator.mjs

@@ -27,6 +27,7 @@ const COST_LOGGER   = resolve(HOOKS, 'cost-logger.mjs');
 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');
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -335,7 +336,7 @@ test('profiles: consistent across modules', () => {
 test('failure-detector: ignores followed=false', () => {
   const src = readFileSync(resolve(__dirname, 'failure-detector.mjs'), 'utf8');
   if (src.includes('followed === false')) return 'still conflates followed=false with failure';
-  if (!src.includes('success === false')) return 'missing success===false check';
+  if (!src.includes('success === false') && !src.includes('success !== false')) return 'missing success check';
   return true;
 });
 
@@ -649,6 +650,363 @@ test('adaptive: cost-logger records Agent errors', () => {
   }
 });
 
+// ─── Test 30: enforce-tier: burst detection activates on 3+ agents ─────────
+test('enforce-tier: burst detection activates on 3+ agents', () => {
+  try {
+    // Write burst state at count 2, within window
+    writeFileSync(BURST_FILE, JSON.stringify({ count: 2, window_start: Date.now() }));
+    const payload = JSON.stringify({
+      tool_name: 'Agent',
+      tool_input: { prompt: `burst activation test ${Date.now()}`, model: 'sonnet' },
+    });
+    const { parsed, status } = run(ENFORCE_TIER, payload);
+    if (status !== 0) return `non-zero exit: ${status}`;
+    if (!parsed) return 'no valid JSON output';
+
+    // Read burst state — count should have incremented to >= 3
+    if (!existsSync(BURST_FILE)) return '.burst-state file was removed unexpectedly';
+    let state;
+    try { state = JSON.parse(readFileSync(BURST_FILE, 'utf8')); } catch (e) { return `.burst-state not valid JSON: ${e.message}`; }
+    if (state.count < 3) return `expected count >= 3, got: ${state.count}`;
+    return true;
+  } finally {
+    try { unlinkSync(BURST_FILE); } catch {}
+  }
+});
+
+// ─── Test 31: enforce-tier: burst mode suppresses duplicate warnings ───────
+test('enforce-tier: burst mode suppresses duplicate warnings', () => {
+  try {
+    // Pre-set burst mode (count=5, active window)
+    writeFileSync(BURST_FILE, JSON.stringify({ count: 5, window_start: Date.now() }));
+    const payload = JSON.stringify({
+      tool_name: 'Agent',
+      tool_input: { prompt: 'burst duplicate test identical prompt', model: 'sonnet' },
+    });
+
+    // First call — establishes the prompt hash
+    run(ENFORCE_TIER, payload);
+    // Second identical call — in burst mode, duplicate warning should be suppressed or [Wave]-prefixed
+    const { parsed, status } = run(ENFORCE_TIER, payload);
+    if (status !== 0) return `non-zero exit: ${status}`;
+    if (!parsed) return 'no valid JSON output';
+
+    // In burst mode: either no duplicate warning at all, or a [Wave]-prefixed one
+    const msg = parsed.systemMessage || '';
+    const hasDuplicateWarning = msg.toLowerCase().includes('duplicate');
+    if (hasDuplicateWarning && !msg.includes('[Wave]'))
+      return `expected no duplicate warning or [Wave]-prefixed in burst mode, got: ${msg}`;
+    return true;
+  } finally {
+    try { unlinkSync(BURST_FILE); } catch {}
+  }
+});
+
+// ─── Test 32: enforce-tier: non-burst mode still warns on duplicates ───────
+test('enforce-tier: non-burst mode still warns on duplicates', () => {
+  try {
+    // 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({
+      tool_name: 'Agent',
+      tool_input: { prompt: 'non-burst duplicate test identical prompt', model: 'sonnet' },
+    });
+
+    // First call — establishes the prompt hash
+    run(ENFORCE_TIER, payload);
+    // Second identical call — should trigger duplicate warning
+    const { parsed, status } = run(ENFORCE_TIER, payload);
+    if (status !== 0) return `non-zero exit: ${status}`;
+    if (!parsed) return 'no valid JSON output';
+
+    const msg = parsed.systemMessage || '';
+    if (!msg.toLowerCase().includes('duplicate'))
+      return `expected duplicate warning in non-burst mode, got: ${msg || '(empty)'}`;
+    return true;
+  } finally {
+    try { unlinkSync(BURST_FILE); } catch {}
+  }
+});
+
+// ─── Test 33: install preserves existing hooks ─────────────────────────────
+test('install: preserves existing hooks', () => {
+  const installSrc = readFileSync(resolve(__dirname, '..', 'install.mjs'), 'utf8');
+
+  // install.mjs must define DUAL_BRAIN_CMDS to identify its own hooks
+  if (!installSrc.includes('DUAL_BRAIN_CMDS'))
+    return 'install.mjs missing DUAL_BRAIN_CMDS constant for filtering';
+
+  // It must filter out only dual-brain hooks (not all hooks) before merging
+  if (!installSrc.includes('.filter'))
+    return 'install.mjs missing .filter() call — may clobber non-dual-brain hooks';
+
+  // The merge logic should spread existingEntries first, then add dual-brain hooks
+  if (!installSrc.includes('existingEntries'))
+    return 'install.mjs missing existingEntries variable — may not preserve other hooks';
+
+  // Verify it reads existing settings before overwriting
+  if (!installSrc.includes('existing') || !installSrc.includes('settings.json'))
+    return 'install.mjs does not read existing settings.json before writing';
+
+  return true;
+});
+
+// ─── Test 34: gitignore entries don't conflict with data-tools ─────────────
+test('install: gitignore entries scoped to dual-brain', () => {
+  const installSrc = readFileSync(resolve(__dirname, '..', 'install.mjs'), 'utf8');
+
+  // Extract the generateGitignoreEntries function body
+  const fnMatch = installSrc.match(/generateGitignoreEntries[\s\S]*?const entries\s*=\s*\[([\s\S]*?)\]/);
+  if (!fnMatch) return 'could not find generateGitignoreEntries entries array';
+
+  const entriesBlock = fnMatch[1];
+
+  // Extract individual entry strings
+  const entryStrings = [...entriesBlock.matchAll(/'([^']+)'/g)].map(m => m[1]);
+  if (entryStrings.length === 0) return 'no gitignore entries found in install.mjs';
+
+  // Each entry must be scoped — no broad patterns like *.json, *.jsonl, .claude/hooks/
+  const broadPatterns = ['*.json', '*.jsonl', '*.mjs', '.claude/', '.claude/hooks/'];
+  for (const entry of entryStrings) {
+    for (const bad of broadPatterns) {
+      if (entry === bad)
+        return `gitignore entry "${entry}" is too broad — could match data-tools files`;
+    }
+  }
+
+  // Each entry should reference dual-brain-specific names
+  const validScopes = ['dual-brain', 'usage-', 'usage.jsonl', 'decision-ledger', 'drift-warned', 'budget-alerted', 'summary-', 'reviews/', '.launched'];
+  for (const entry of entryStrings) {
+    const isScoped = validScopes.some(scope => entry.includes(scope));
+    if (!isScoped)
+      return `gitignore entry "${entry}" may not be scoped to dual-brain files`;
+  }
+
+  return true;
+});
+
+// ─── Test 35: hooks use isolated file paths ────────────────────────────────
+test('hooks: output files use dual-brain-namespaced paths', () => {
+  const validNames = ['dual-brain', 'usage-', 'usage.jsonl', 'decision-ledger', 'summary-checkpoint', '.drift-warned', '.burst-state', '.budget-alerted', 'orchestrator.json', '.launched'];
+
+  const hookFiles = {
+    'enforce-tier.mjs': ['DRIFT_STATE', 'BURST_FILE', 'PROFILE_FILE'],
+    'cost-logger.mjs': ['usage-', 'PROFILE_FILE'],
+    'summary-checkpoint.mjs': ['usage-summary-', 'usage-'],
+  };
+
+  for (const [hookFile, expectedRefs] of Object.entries(hookFiles)) {
+    const src = readFileSync(resolve(__dirname, hookFile), 'utf8');
+
+    // Find all file paths the hook writes to (writeFileSync / appendFileSync targets)
+    const writeTargets = [...src.matchAll(/(?:writeFileSync|appendFileSync|renameSync)\(\s*([^,)]+)/g)].map(m => m[1].trim());
+
+    if (writeTargets.length === 0) return `${hookFile}: no write targets found`;
+
+    // Verify none of the write targets use generic names
+    // They should resolve to variables defined with dual-brain-specific names
+    const genericNames = ['config.json', 'state.json', 'log.jsonl', 'data.json', 'output.json'];
+    for (const target of writeTargets) {
+      for (const bad of genericNames) {
+        if (target.includes(`'${bad}'`) || target.includes(`"${bad}"`))
+          return `${hookFile}: writes to generic filename "${bad}" — could collide with other tools`;
+      }
+    }
+  }
+
+  // Verify the actual file path constants in enforce-tier use dual-brain-scoped names
+  const enforceSrc = readFileSync(resolve(__dirname, 'enforce-tier.mjs'), 'utf8');
+  if (!enforceSrc.includes('dual-brain.profile.json'))
+    return 'enforce-tier.mjs PROFILE_FILE does not reference dual-brain namespace';
+  if (!enforceSrc.includes('.drift-warned'))
+    return 'enforce-tier.mjs DRIFT_STATE does not use scoped filename';
+  if (!enforceSrc.includes('.burst-state'))
+    return 'enforce-tier.mjs BURST_FILE does not use scoped filename';
+
+  // Verify cost-logger writes to usage-dated files, not generic names
+  const costSrc = readFileSync(resolve(__dirname, 'cost-logger.mjs'), 'utf8');
+  if (!costSrc.includes('usage-'))
+    return 'cost-logger.mjs does not write to usage-prefixed files';
+  if (!costSrc.includes('dual-brain.profile.json'))
+    return 'cost-logger.mjs PROFILE_FILE does not reference dual-brain namespace';
+
+  return true;
+});
+
+// ─── Test 36: failure decay weights recent failures higher ─────────────────
+test('failure decay: recent failures score high', () => {
+  const LEDGER = resolve(HOOKS, 'decision-ledger.jsonl');
+  const backup = existsSync(LEDGER) ? readFileSync(LEDGER, 'utf8') : null;
+
+  try {
+    const hash = 'decay_recent_' + Date.now();
+    const fiveMinAgo = new Date(Date.now() - 5 * 60 * 1000).toISOString();
+    const entry = JSON.stringify({
+      type: 'failure', timestamp: fiveMinAgo, prompt_hash: hash,
+      tier: 'execute', reason: 'test_decay', success: false,
+    });
+    writeFileSync(LEDGER, entry + '\n' + entry + '\n', 'utf8');
+
+    const script = `
+      import { checkFailureLoop } from './failure-detector.mjs';
+      const result = checkFailureLoop('${hash}');
+      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.isLoop) return `expected isLoop=true for recent failures, got: ${JSON.stringify(result)}`;
+    if (typeof result.weightedScore !== 'number' || result.weightedScore < 2.0)
+      return `expected weightedScore >= 2.0, got: ${result.weightedScore}`;
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(LEDGER, backup, 'utf8');
+    else try { writeFileSync(LEDGER, '', 'utf8'); } catch {}
+  }
+});
+
+// ─── Test 37: failure decay reduces old failure weight ─────────────────────
+test('failure decay: old failures score low', () => {
+  const LEDGER = resolve(HOOKS, 'decision-ledger.jsonl');
+  const backup = existsSync(LEDGER) ? readFileSync(LEDGER, 'utf8') : null;
+
+  try {
+    const hash = 'decay_old_' + Date.now();
+    const ninetyMinAgo = new Date(Date.now() - 90 * 60 * 1000).toISOString();
+    const entry = JSON.stringify({
+      type: 'failure', timestamp: ninetyMinAgo, prompt_hash: hash,
+      tier: 'execute', reason: 'test_decay_old', success: false,
+    });
+    writeFileSync(LEDGER, entry + '\n' + entry + '\n', 'utf8');
+
+    const script = `
+      import { checkFailureLoop } from './failure-detector.mjs';
+      const result = checkFailureLoop('${hash}');
+      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.isLoop) return `expected isLoop=false for old failures (weightedScore should be ~0.5), got: ${JSON.stringify(result)}`;
+    if (typeof result.weightedScore !== 'number')
+      return `expected weightedScore in result, got: ${JSON.stringify(result)}`;
+    if (result.weightedScore >= 2.0)
+      return `expected weightedScore < 2.0 for 90-min-old failures, got: ${result.weightedScore}`;
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(LEDGER, backup, 'utf8');
+    else try { writeFileSync(LEDGER, '', 'utf8'); } catch {}
+  }
+});
+
+// ─── Test 38: failure scoping by tier ──────────────────────────────────────
+test('failure decay: scoping by tier', () => {
+  const LEDGER = resolve(HOOKS, 'decision-ledger.jsonl');
+  const backup = existsSync(LEDGER) ? readFileSync(LEDGER, 'utf8') : null;
+
+  try {
+    const hash = 'tier_scope_' + Date.now();
+    const now = new Date().toISOString();
+    const mkEntry = (tier) => JSON.stringify({
+      type: 'failure', timestamp: now, prompt_hash: hash,
+      tier, reason: 'test_tier_scope', success: false,
+    });
+    const content = [
+      mkEntry('execute'), mkEntry('execute'),
+      mkEntry('search'), mkEntry('search'),
+    ].join('\n') + '\n';
+    writeFileSync(LEDGER, content, 'utf8');
+
+    const checkTier = (tier) => {
+      const script = `
+        import { checkFailureLoop } from './failure-detector.mjs';
+        const result = checkFailureLoop('${hash}', '${tier}');
+        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 { error: `script failed for tier=${tier}: ${proc.stderr}` };
+      try { return JSON.parse(proc.stdout.trim()); } catch { return { error: `output not JSON for tier=${tier}: ${proc.stdout}` }; }
+    };
+
+    const execResult = checkTier('execute');
+    if (execResult.error) return execResult.error;
+    if (!execResult.isLoop) return `expected isLoop=true for execute tier, got: ${JSON.stringify(execResult)}`;
+
+    const searchResult = checkTier('search');
+    if (searchResult.error) return searchResult.error;
+    if (!searchResult.isLoop) return `expected isLoop=true for search tier, got: ${JSON.stringify(searchResult)}`;
+
+    const thinkResult = checkTier('think');
+    if (thinkResult.error) return thinkResult.error;
+    if (thinkResult.isLoop) return `expected isLoop=false for think tier (no think failures), got: ${JSON.stringify(thinkResult)}`;
+
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(LEDGER, backup, 'utf8');
+    else try { writeFileSync(LEDGER, '', 'utf8'); } catch {}
+  }
+});
+
+// ─── Test 39: pruneOldFailures removes stale entries ───────────────────────
+test('failure decay: pruneOldFailures removes stale entries', () => {
+  const LEDGER = resolve(HOOKS, 'decision-ledger.jsonl');
+  const backup = existsSync(LEDGER) ? readFileSync(LEDGER, 'utf8') : null;
+
+  try {
+    const twentyFiveHoursAgo = new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString();
+    const oneHourAgo = new Date(Date.now() - 1 * 60 * 60 * 1000).toISOString();
+    const staleEntry = JSON.stringify({
+      type: 'failure', timestamp: twentyFiveHoursAgo, prompt_hash: 'stale',
+      tier: 'execute', reason: 'old', success: false,
+    });
+    const recentEntry = JSON.stringify({
+      type: 'failure', timestamp: oneHourAgo, prompt_hash: 'recent',
+      tier: 'execute', reason: 'new', success: false,
+    });
+    const content = [staleEntry, staleEntry, recentEntry, recentEntry].join('\n') + '\n';
+    writeFileSync(LEDGER, content, 'utf8');
+
+    const script = `
+      import { pruneOldFailures } from './failure-detector.mjs';
+      pruneOldFailures();
+    `;
+    const proc = spawnSync(process.execPath, [
+      '--input-type=module',
+      '-e', script,
+    ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+    if (proc.status !== 0) return `pruneOldFailures script failed: ${proc.stderr}`;
+    if (!existsSync(LEDGER)) return 'ledger file was deleted instead of pruned';
+
+    const lines = readFileSync(LEDGER, 'utf8').split('\n').filter(Boolean);
+    if (lines.length !== 2) return `expected 2 entries after prune, got: ${lines.length}`;
+
+    for (const line of lines) {
+      let entry;
+      try { entry = JSON.parse(line); } catch { return `pruned ledger has invalid JSON: ${line}`; }
+      if (entry.prompt_hash !== 'recent')
+        return `expected only recent entries to remain, found prompt_hash=${entry.prompt_hash}`;
+    }
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(LEDGER, backup, 'utf8');
+    else try { writeFileSync(LEDGER, '', 'utf8'); } catch {}
+  }
+});
+
 // ─── Summary ─────────────────────────────────────────────────────────────────
 const total = passed + failed;
 console.log(`\n${passed}/${total} tests passed`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "3.7.2",
+  "version": "3.8.1",
   "description": "Dual-provider orchestration for Claude Code — tiered routing, budget balancing, and GPT dual-brain review across Claude + OpenAI subscriptions",
   "type": "module",
   "bin": {
@@ -22,6 +22,9 @@
     "type": "git",
     "url": "https://github.com/1xmint/dual-brain.git"
   },
+  "scripts": {
+    "test": "node hooks/test-orchestrator.mjs"
+  },
   "engines": {
     "node": ">=20.0.0"
   },