dual-brain 3.7.1 → 3.8.0

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/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;
@@ -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/test-orchestrator.mjs

@@ -10,8 +10,10 @@
 
 import { execSync, spawnSync } from 'child_process';
 import {
+  appendFileSync,
   existsSync,
   readFileSync,
+  unlinkSync,
   writeFileSync,
 } from 'fs';
 import { dirname, resolve } from 'path';
@@ -25,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 ─────────────────────────────────────────────────────────────────
 
@@ -337,6 +340,394 @@ test('failure-detector: ignores followed=false', () => {
   return true;
 });
 
+// ─── Test 17: enforce-tier: malformed stdin ─────────────────────────────────
+test('enforce-tier: malformed stdin', () => {
+  const { parsed, status } = run(ENFORCE_TIER, 'this is not json at all {{{');
+  if (status !== 0) return `non-zero exit: ${status}`;
+  if (!parsed) return 'no valid JSON output';
+  return true;
+});
+
+// ─── Test 18: enforce-tier: missing tool_input ──────────────────────────────
+test('enforce-tier: missing tool_input', () => {
+  const payload = JSON.stringify({ tool_name: 'Agent' });
+  const { parsed, status } = run(ENFORCE_TIER, payload);
+  if (status !== 0) return `non-zero exit: ${status}`;
+  if (!parsed) return 'no valid JSON output';
+  return true;
+});
+
+// ─── Test 19: enforce-tier: non-Agent tool passthrough ──────────────────────
+test('enforce-tier: non-Agent tool passthrough', () => {
+  const payload = JSON.stringify({ tool_name: 'Read', tool_input: { file_path: '/foo' } });
+  const { parsed, status } = run(ENFORCE_TIER, payload);
+  if (status !== 0) return `non-zero exit: ${status}`;
+  if (!parsed) return 'no valid JSON output';
+  if (Object.keys(parsed).length !== 0)
+    return `expected {}, got: ${JSON.stringify(parsed)}`;
+  return true;
+});
+
+// ─── Test 20: cost-logger: malformed stdin ──────────────────────────────────
+test('cost-logger: malformed stdin', () => {
+  const { parsed, status } = runStream(COST_LOGGER, 'not json garbage >>>');
+  if (status !== 0) return `non-zero exit: ${status}`;
+  if (!parsed) return 'no valid JSON output';
+  return true;
+});
+
+// ─── Test 21: cost-logger: missing fields ───────────────────────────────────
+test('cost-logger: missing fields', () => {
+  let linesBefore = 0;
+  if (existsSync(USAGE_JSONL)) {
+    linesBefore = readFileSync(USAGE_JSONL, 'utf8').split('\n').filter(Boolean).length;
+  }
+
+  const { parsed, status } = runStream(COST_LOGGER, '{}');
+  if (status !== 0) return `non-zero exit: ${status}`;
+  if (!parsed) return 'no valid JSON output';
+
+  if (!existsSync(USAGE_JSONL)) return 'daily usage log was not created';
+  const lines = readFileSync(USAGE_JSONL, 'utf8').split('\n').filter(Boolean);
+  if (lines.length <= linesBefore) return 'no new line was appended to daily usage log';
+
+  // Clean up the test line
+  try {
+    const kept = lines.slice(0, linesBefore).join('\n');
+    writeFileSync(USAGE_JSONL, kept ? kept + '\n' : '', 'utf8');
+  } catch {}
+
+  return true;
+});
+
+// ─── Test 22: cost-logger: error status recorded ────────────────────────────
+test('cost-logger: error status recorded', () => {
+  let linesBefore = 0;
+  if (existsSync(USAGE_JSONL)) {
+    linesBefore = readFileSync(USAGE_JSONL, 'utf8').split('\n').filter(Boolean).length;
+  }
+
+  const payload = JSON.stringify({
+    tool_name: 'Agent',
+    tool_input: { prompt: 'test' },
+    error: 'something failed',
+  });
+  const { parsed, status } = runStream(COST_LOGGER, payload);
+  if (status !== 0) return `non-zero exit: ${status}`;
+  if (!parsed) return 'no valid JSON output';
+
+  if (!existsSync(USAGE_JSONL)) return 'daily usage log was not created';
+  const lines = readFileSync(USAGE_JSONL, 'utf8').split('\n').filter(Boolean);
+  if (lines.length <= linesBefore) return 'no new line was appended to daily usage log';
+
+  const lastLine = lines[lines.length - 1];
+  let entry;
+  try { entry = JSON.parse(lastLine); } catch { return `last line not valid JSON: ${lastLine}`; }
+  if (entry.status !== 'error') return `expected status "error", got: "${entry.status}"`;
+
+  // Clean up the test line
+  try {
+    const kept = lines.slice(0, linesBefore).join('\n');
+    writeFileSync(USAGE_JSONL, kept ? kept + '\n' : '', 'utf8');
+  } catch {}
+
+  return true;
+});
+
+// ─── Test 23: enforce-tier: cost-saver demotes think ────────────────────────
+test('enforce-tier: cost-saver demotes think', () => {
+  const profileFile = resolve(__dirname, '..', 'dual-brain.profile.json');
+  let originalProfile;
+  try { originalProfile = readFileSync(profileFile, 'utf8'); } catch { originalProfile = null; }
+  try {
+    writeFileSync(profileFile, JSON.stringify({ active: 'cost-saver' }));
+    // "edit the README file" — execute-like text, no think words
+    // cost-saver's demote_think=true demotes think→execute when text lacks think words
+    const payload = JSON.stringify({
+      tool_name: 'Agent',
+      tool_input: { prompt: 'edit the README file', model: 'opus' },
+    });
+    const { parsed, status } = run(ENFORCE_TIER, payload);
+    if (status !== 0) return `non-zero exit: ${status}`;
+    if (!parsed) return 'no valid JSON output';
+    // With demote_think, the tier stays execute, so opus on execute work exits 0 with valid JSON
+    return true;
+  } finally {
+    if (originalProfile !== null) writeFileSync(profileFile, originalProfile);
+    else try { unlinkSync(profileFile); } catch {}
+  }
+});
+
+// ─── Test 24: enforce-tier: quality-first promotes execute ──────────────────
+test('enforce-tier: quality-first promotes execute', () => {
+  const profileFile = resolve(__dirname, '..', 'dual-brain.profile.json');
+  let originalProfile;
+  try { originalProfile = readFileSync(profileFile, 'utf8'); } catch { originalProfile = null; }
+  try {
+    writeFileSync(profileFile, JSON.stringify({ active: 'quality-first' }));
+    // Think-like description on sonnet model — quality-first's promote_execute=true
+    // promotes to think when text matches think words
+    const payload = JSON.stringify({
+      tool_name: 'Agent',
+      tool_input: { prompt: 'review architecture and plan the migration', model: 'sonnet' },
+    });
+    const { parsed, status } = run(ENFORCE_TIER, payload);
+    if (status !== 0) return `non-zero exit: ${status}`;
+    if (!parsed) return 'no valid JSON output';
+    if (!parsed.systemMessage) return `expected systemMessage, got: ${JSON.stringify(parsed)}`;
+    if (!parsed.systemMessage.toLowerCase().includes('think'))
+      return `expected "think" in systemMessage, got: ${parsed.systemMessage}`;
+    return true;
+  } finally {
+    if (originalProfile !== null) writeFileSync(profileFile, originalProfile);
+    else try { unlinkSync(profileFile); } catch {}
+  }
+});
+
+// ─── Test 25: enforce-tier: auto profile with high-risk file ────────────────
+test('enforce-tier: auto profile with high-risk file', () => {
+  const profileFile = resolve(__dirname, '..', 'dual-brain.profile.json');
+  let originalProfile;
+  try { originalProfile = readFileSync(profileFile, 'utf8'); } catch { originalProfile = null; }
+  try {
+    writeFileSync(profileFile, JSON.stringify({ active: 'auto' }));
+    // Description with auth/credentials path → risk classifier detects critical risk → promote to think
+    const payload = JSON.stringify({
+      tool_name: 'Agent',
+      tool_input: { description: 'update src/auth/credentials.mjs', prompt: 'change the token logic', model: 'sonnet' },
+    });
+    const { parsed, status } = run(ENFORCE_TIER, payload);
+    if (status !== 0) return `non-zero exit: ${status}`;
+    if (!parsed) return 'no valid JSON output';
+    if (!parsed.systemMessage) return `expected systemMessage, got: ${JSON.stringify(parsed)}`;
+    const msg = parsed.systemMessage.toLowerCase();
+    if (!msg.includes('think') && !msg.includes('dual-brain'))
+      return `expected "think" or "dual-brain" in systemMessage, got: ${parsed.systemMessage}`;
+    return true;
+  } finally {
+    // Always restore profile to auto so subsequent tests aren't affected
+    writeFileSync(profileFile, JSON.stringify({ active: 'auto' }));
+  }
+});
+
+// ─── Test 26: adaptive: recordFailure writes to ledger ─────────────────────
+test('adaptive: recordFailure writes to ledger', () => {
+  const LEDGER = resolve(HOOKS, 'decision-ledger.jsonl');
+  const backup = existsSync(LEDGER) ? readFileSync(LEDGER, 'utf8') : null;
+
+  try {
+    const script = `
+      import { recordFailure } from './failure-detector.mjs';
+      recordFailure('testhash123', 'execute', 'test_error');
+    `;
+    const proc = spawnSync(process.execPath, [
+      '--input-type=module',
+      '-e', script,
+    ], { encoding: 'utf8', timeout: 5000, cwd: HOOKS });
+
+    if (proc.status !== 0) return `recordFailure script failed: ${proc.stderr}`;
+    if (!existsSync(LEDGER)) return 'ledger file not created';
+
+    const lines = readFileSync(LEDGER, 'utf8').split('\n').filter(Boolean);
+    const lastLine = lines[lines.length - 1];
+    let entry;
+    try { entry = JSON.parse(lastLine); } catch { return `last line not valid JSON: ${lastLine}`; }
+    if (entry.prompt_hash !== 'testhash123') return `expected prompt_hash=testhash123, got: ${entry.prompt_hash}`;
+    if (entry.success !== false) return `expected success=false, got: ${entry.success}`;
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(LEDGER, backup, 'utf8');
+    else try { writeFileSync(LEDGER, '', 'utf8'); } catch {}
+  }
+});
+
+// ─── Test 27: adaptive: checkFailureLoop detects 2+ failures ───────────────
+test('adaptive: checkFailureLoop detects 2+ failures', () => {
+  const LEDGER = resolve(HOOKS, 'decision-ledger.jsonl');
+  const backup = existsSync(LEDGER) ? readFileSync(LEDGER, 'utf8') : null;
+
+  try {
+    const hash = 'looptest_' + Date.now();
+    const now = new Date().toISOString();
+    const failEntry = JSON.stringify({
+      type: 'failure', timestamp: now, prompt_hash: hash,
+      tier: 'execute', reason: 'test', success: false,
+    });
+    const content = (backup || '') + failEntry + '\n' + failEntry + '\n';
+    writeFileSync(LEDGER, content, '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 `checkFailureLoop 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, got: ${JSON.stringify(result)}`;
+    if (result.count < 2) return `expected count>=2, got: ${result.count}`;
+    if (result.suggestion !== 'promote_tier' && result.suggestion !== 'escalate_to_dual_brain')
+      return `unexpected suggestion: ${result.suggestion}`;
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(LEDGER, backup, 'utf8');
+    else try { writeFileSync(LEDGER, '', 'utf8'); } catch {}
+  }
+});
+
+// ─── Test 28: adaptive: checkFailureLoop ignores old failures ──────────────
+test('adaptive: checkFailureLoop ignores old failures', () => {
+  const LEDGER = resolve(HOOKS, 'decision-ledger.jsonl');
+  const backup = existsSync(LEDGER) ? readFileSync(LEDGER, 'utf8') : null;
+
+  try {
+    const hash = 'oldtest_' + Date.now();
+    const threeHoursAgo = new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString();
+    const oldEntry = JSON.stringify({
+      type: 'failure', timestamp: threeHoursAgo, prompt_hash: hash,
+      tier: 'execute', reason: 'old_test', success: false,
+    });
+    writeFileSync(LEDGER, oldEntry + '\n' + oldEntry + '\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 `checkFailureLoop 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, got: ${JSON.stringify(result)}`;
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(LEDGER, backup, 'utf8');
+    else try { writeFileSync(LEDGER, '', 'utf8'); } catch {}
+  }
+});
+
+// ─── Test 29: adaptive: cost-logger records Agent errors ───────────────────
+test('adaptive: cost-logger records Agent errors', () => {
+  const LEDGER = resolve(HOOKS, 'decision-ledger.jsonl');
+  const backup = existsSync(LEDGER) ? readFileSync(LEDGER, 'utf8') : null;
+
+  try {
+    let linesBefore = 0;
+    if (existsSync(LEDGER)) {
+      linesBefore = readFileSync(LEDGER, 'utf8').split('\n').filter(Boolean).length;
+    }
+
+    const payload = JSON.stringify({
+      tool_name: 'Agent',
+      tool_input: { prompt: 'failing task hash test' },
+      error: 'test failure',
+    });
+    const { status } = runStream(COST_LOGGER, payload);
+    if (status !== 0) return `non-zero exit: ${status}`;
+
+    if (!existsSync(LEDGER)) return 'ledger file not created';
+    const lines = readFileSync(LEDGER, 'utf8').split('\n').filter(Boolean);
+    if (lines.length <= linesBefore) return 'no new failure entry appended to ledger';
+
+    const newEntry = lines[lines.length - 1];
+    let entry;
+    try { entry = JSON.parse(newEntry); } catch { return `last line not valid JSON: ${newEntry}`; }
+    if (entry.success !== false) return `expected success=false, got: ${entry.success}`;
+    if (entry.type !== 'failure') return `expected type=failure, got: ${entry.type}`;
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(LEDGER, backup, 'utf8');
+    else try { writeFileSync(LEDGER, '', 'utf8'); } catch {}
+  }
+});
+
+// ─── 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 {}
+  }
+});
+
 // ─── 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.1",
+  "version": "3.8.0",
   "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"
   },