dual-brain 2.0.0

package/hooks/test-orchestrator.mjs

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+/**
+ * test-orchestrator.mjs — Self-test harness for all dual-brain orchestrator hooks.
+ *
+ * Usage:  node .claude/hooks/test-orchestrator.mjs
+ *
+ * Runs a suite of fast tests against the hook scripts, prints PASS/FAIL per
+ * test, and exits with code 0 if all pass, 1 if any fail.
+ */
+
+import { execSync, spawnSync } from 'child_process';
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HOOKS = __dirname;
+
+const ENFORCE_TIER  = resolve(HOOKS, 'enforce-tier.mjs');
+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`);
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/**
+ * Run a hook script, passing stdinData through a shell pipe so that
+ * readFileSync('/dev/stdin') inside the script can read it correctly.
+ *
+ * We use `sh -c "echo '<json>' | node <script>"` so that /dev/stdin is a
+ * real pipe file descriptor, not a spawnSync input buffer.
+ */
+function run(scriptPath, stdinData, extraEnv = {}) {
+  // Escape single quotes in the JSON payload for use inside single-quoted shell string
+  const escaped = (stdinData || '').replace(/'/g, "'\\''");
+  const shellCmd = `printf '%s' '${escaped}' | ${process.execPath} ${scriptPath}`;
+
+  const proc = spawnSync('sh', ['-c', shellCmd], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { ...process.env, ...extraEnv },
+    timeout: 8_000,
+  });
+
+  let parsed = null;
+  try { parsed = JSON.parse((proc.stdout || '').trim()); } catch {}
+  return { raw: proc.stdout || '', stderr: proc.stderr || '', parsed, status: proc.status };
+}
+
+/**
+ * Run a hook that reads from a for-await stdin loop (cost-logger style),
+ * using spawnSync with the input option (works for stream-based reads).
+ */
+function runStream(scriptPath, stdinData, extraEnv = {}) {
+  const proc = spawnSync(process.execPath, [scriptPath], {
+    input: stdinData || '',
+    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env, ...extraEnv },
+    timeout: 8_000,
+  });
+  let parsed = null;
+  try { parsed = JSON.parse((proc.stdout || '').trim()); } catch {}
+  return { raw: proc.stdout || '', stderr: proc.stderr || '', parsed, status: proc.status };
+}
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    const result = fn();
+    if (result === true) {
+      console.log(`PASS  ${name}`);
+      passed++;
+    } else {
+      console.log(`FAIL  ${name}${result ? ` — ${result}` : ''}`);
+      failed++;
+    }
+  } catch (err) {
+    console.log(`FAIL  ${name} — threw: ${err?.message ?? String(err)}`);
+    failed++;
+  }
+}
+
+// ─── Test 1: enforce-tier: search with opus ───────────────────────────────────
+test('enforce-tier: search with opus', () => {
+  const payload = JSON.stringify({
+    tool_name: 'Agent',
+    tool_input: { prompt: 'find 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)}`;
+  if (!parsed.systemMessage.toLowerCase().includes('haiku'))
+    return `expected "haiku" in systemMessage, got: ${parsed.systemMessage}`;
+  return true;
+});
+
+// ─── Test 2: enforce-tier: correct tier ──────────────────────────────────────
+test('enforce-tier: correct tier', () => {
+  const payload = JSON.stringify({
+    tool_name: 'Agent',
+    tool_input: { prompt: `unique test prompt ${Date.now()}`, model: 'sonnet' },
+  });
+  const { parsed } = run(ENFORCE_TIER, payload);
+  if (!parsed) return 'no valid JSON output';
+  // Should return {} or at most a drift warning (not a tier mismatch)
+  if (parsed.systemMessage && parsed.systemMessage.includes('Tier Enforcer'))
+    return `unexpected tier mismatch: ${parsed.systemMessage}`;
+  return true;
+});
+
+// ─── Test 3: enforce-tier: think task on haiku ───────────────────────────────
+test('enforce-tier: think on haiku', () => {
+  const payload = JSON.stringify({
+    tool_name: 'Agent',
+    tool_input: { prompt: 'review security', model: 'haiku' },
+  });
+  const { parsed } = run(ENFORCE_TIER, payload);
+  if (!parsed) return 'no valid JSON output';
+  if (!parsed.systemMessage)
+    return `expected systemMessage warning, got: ${JSON.stringify(parsed)}`;
+  return true;
+});
+
+// ─── Test 4: enforce-tier: non-Agent tool ────────────────────────────────────
+test('enforce-tier: non-Agent tool', () => {
+  const payload = JSON.stringify({
+    tool_name: 'Bash',
+    tool_input: { command: 'ls' },
+  });
+  const { parsed } = run(ENFORCE_TIER, payload);
+  if (!parsed) return 'no valid JSON output';
+  if (Object.keys(parsed).length !== 0)
+    return `expected {}, got: ${JSON.stringify(parsed)}`;
+  return true;
+});
+
+// ─── Test 5: enforce-tier: missing config (bad JSON in config path) ───────────
+test('enforce-tier: missing config', () => {
+  // enforce-tier catches config read errors and falls back to {} — verify that
+  // an Agent payload still exits cleanly when config can't be parsed.
+  // We set HOME to /tmp/nonexistent-orch-test so readFileSync of the hardcoded
+  // config path will fail (the path is hardcoded, but we can't easily redirect
+  // it). Instead, verify that sending a model string that matches no known tier
+  // still results in a clean non-crashing exit.
+  const payload = JSON.stringify({
+    tool_name: 'Agent',
+    tool_input: { prompt: 'do something', model: 'unknown-model-xyz' },
+  });
+  const { parsed, status } = run(ENFORCE_TIER, payload);
+  // Should exit 0 and produce valid JSON (either {} or a systemMessage)
+  if (status !== 0) return `non-zero exit: ${status}`;
+  if (!parsed) return 'no valid JSON output';
+  return true;
+});
+
+// ─── Test 6: cost-logger: logs entry ─────────────────────────────────────────
+test('cost-logger: logs entry', () => {
+  // Record current line count of usage.jsonl before the test.
+  let linesBefore = 0;
+  if (existsSync(USAGE_JSONL)) {
+    linesBefore = readFileSync(USAGE_JSONL, 'utf8').split('\n').filter(Boolean).length;
+  }
+
+  const payload = JSON.stringify({
+    tool_name: 'Read',
+    tool_input: { file_path: '/some/file.ts' },
+  });
+  // 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)}`;
+
+  if (!existsSync(USAGE_JSONL)) return 'daily usage log was not created';
+
+  const lines = readFileSync(USAGE_JSONL, 'utf8').split('\n').filter(Boolean);
+  const linesAfter = lines.length;
+  if (linesAfter <= linesBefore) return 'no new line was appended to daily usage log';
+
+  // Validate the new entry is valid JSON with expected fields
+  const lastLine = lines[linesAfter - 1];
+  let entry;
+  try { entry = JSON.parse(lastLine); } catch { return `last line not valid JSON: ${lastLine}`; }
+  if (!entry.timestamp) return 'entry missing timestamp';
+  if (!entry.tier)      return 'entry missing tier';
+  if (!entry.tool)      return 'entry missing tool';
+
+  // Clean up the test line we just added
+  try {
+    const kept = lines.slice(0, linesBefore).join('\n');
+    writeFileSync(USAGE_JSONL, kept ? kept + '\n' : '', 'utf8');
+  } catch {
+    // Best-effort cleanup; don't fail the test over it
+  }
+
+  return true;
+});
+
+// ─── Test 7: dual-brain: valid output ────────────────────────────────────────
+test('dual-brain: valid output', () => {
+  // Run dual-brain-review.mjs in a temp git repo with no changes so the test
+  // is deterministic and never triggers codex/API calls on a dirty working tree.
+  const tmpDir = spawnSync('mktemp', ['-d'], { encoding: 'utf8' }).stdout.trim();
+  try {
+    execSync(
+      `git init -q "${tmpDir}" && git -C "${tmpDir}" commit --allow-empty -m init -q`,
+      { stdio: 'pipe' }
+    );
+    const proc = spawnSync(process.execPath, [DUAL_BRAIN], {
+      cwd: tmpDir,
+      encoding: 'utf8',
+      timeout: 10_000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    // status null means the process was killed (timeout/signal) — treat as fail
+    if (proc.status == null) return `process killed or timed out (signal/null status)`;
+    if (proc.status !== 0) return `non-zero exit: ${proc.status}`;
+    let parsed = null;
+    try { parsed = JSON.parse((proc.stdout || '').trim()); } catch {}
+    if (!parsed) return `no valid JSON output; raw: ${(proc.stdout || '').slice(0, 200)}`;
+    if (typeof parsed.review !== 'string') return `expected review string, got: ${JSON.stringify(parsed)}`;
+    return true;
+  } finally {
+    spawnSync('rm', ['-rf', tmpDir], { stdio: 'pipe' });
+  }
+});
+
+// ─── Test 8: orchestrator.json: valid JSON ────────────────────────────────────
+test('orchestrator.json: valid JSON', () => {
+  if (!existsSync(ORCHESTRATOR)) return 'orchestrator.json not found';
+  let config;
+  try {
+    config = JSON.parse(readFileSync(ORCHESTRATOR, 'utf8'));
+  } catch (err) {
+    return `invalid JSON: ${err.message}`;
+  }
+  if (!config.quality_gate)  return 'missing quality_gate section';
+  if (!config.tiers)         return 'missing tiers section';
+  if (!config.subscriptions) return 'missing subscriptions section';
+  return true;
+});
+
+// ─── Test 9: enforce-tier: think on gpt-4.1-mini ─────────────────────────────
+test('enforce-tier: think on gpt-4.1-mini', () => {
+  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';
+  if (!parsed.systemMessage) return `expected systemMessage warning, got: ${JSON.stringify(parsed)}`;
+  if (!parsed.systemMessage.toLowerCase().includes('think'))
+    return `expected "think" in systemMessage, got: ${parsed.systemMessage}`;
+  return true;
+});
+
+// ─── Test 10: orchestrator.json: model_intelligence ──────────────────────────
+test('orchestrator.json: model_intelligence', () => {
+  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';
+  return true;
+});
+
+// ─── Test 11: orchestrator.json: pricing_verified ────────────────────────────
+test('orchestrator.json: pricing_verified', () => {
+  const config = JSON.parse(readFileSync(resolve(__dirname, '..', 'orchestrator.json'), 'utf8'));
+  if (!config.pricing_verified) return 'pricing_verified field missing';
+  if (isNaN(Date.parse(config.pricing_verified))) return `pricing_verified is not a valid date: ${config.pricing_verified}`;
+  return true;
+});
+
+// ─── Test 12: budget-balancer: loads and runs ────────────────────────────────
+test('budget-balancer: loads and runs', () => {
+  const proc = spawnSync(process.execPath, [resolve(__dirname, 'budget-balancer.mjs')], {
+    encoding: 'utf8',
+    timeout: 10000,
+    cwd: resolve(__dirname, '..', '..'),
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  if (proc.status !== 0) return `exit code ${proc.status}: ${proc.stderr}`;
+  if (!proc.stdout.includes('Provider Balance')) return 'missing output header';
+  return true;
+});
+
+// ─── Test 13: orchestrator.json: providers configured ────────────────────────
+test('orchestrator.json: providers configured', () => {
+  const config = JSON.parse(readFileSync(resolve(__dirname, '..', 'orchestrator.json'), 'utf8'));
+  if (!config.providers?.claude?.enabled) return 'claude provider not enabled';
+  if (!config.providers?.openai?.enabled) return 'openai provider not enabled';
+  if (!config.routing?.strategy) return 'routing strategy missing';
+  return true;
+});
+
+// ─── Test 14: orchestrator.json: dual_thinking configured ────────────────────
+test('orchestrator.json: dual_thinking configured', () => {
+  const config = JSON.parse(readFileSync(resolve(__dirname, '..', 'orchestrator.json'), 'utf8'));
+  if (!config.dual_thinking?.enabled) return 'dual_thinking not enabled';
+  if (!config.dual_thinking?.auto_triggers?.length) return 'no auto_triggers';
+  if (!config.dual_thinking?.sensitive_paths?.length) return 'no sensitive_paths';
+  return true;
+});
+
+// ─── Summary ─────────────────────────────────────────────────────────────────
+const total = passed + failed;
+console.log(`\n${passed}/${total} tests passed`);
+process.exit(failed > 0 ? 1 : 0);

package/install.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+/**
+ * dual-brain — Install the Dual-Brain Orchestrator into your project.
+ *
+ * Usage:
+ *   npx dual-brain init [--force]
+ *   npx dual-brain --help
+ */
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const args = process.argv.slice(2);
+const command = args.find(a => !a.startsWith('-'));
+const force = args.includes('--force');
+
+const W = 50;
+const border = (l, r) => l + '═'.repeat(W) + r;
+const line = (text) => {
+  const padded = String(text).padEnd(W - 2);
+  return `║ ${padded.slice(0, W - 2)} ║`;
+};
+
+if (args.includes('--help') || args.includes('-h') || (!command && !force)) {
+  console.log('');
+  console.log('  Usage: npx dual-brain init [--force]');
+  console.log('');
+  console.log('  Commands:');
+  console.log('    init       Install orchestrator into .claude/');
+  console.log('');
+  console.log('  Options:');
+  console.log('    --force    Overwrite existing .claude/ hooks');
+  console.log('    --help     Show this help message');
+  console.log('');
+  process.exit(0);
+}
+
+if (command && command !== 'init') {
+  console.error(`  Unknown command: ${command}`);
+  console.error('  Run: npx dual-brain --help');
+  process.exit(1);
+}
+
+const TARGET = resolve(process.cwd(), '.claude');
+
+console.log('');
+console.log(`  ${border('╔', '╗')}`);
+console.log(`  ${line('Dual-Brain Orchestrator Installer')}`);
+console.log(`  ${border('╚', '╝')}`);
+console.log('');
+
+if (existsSync(TARGET) && !force) {
+  console.log('  .claude/ directory already exists.');
+  console.log('  Use --force to overwrite, or run the setup wizard:');
+  console.log('  node .claude/hooks/setup-wizard.mjs');
+  console.log('');
+  process.exit(1);
+}
+
+mkdirSync(join(TARGET, 'hooks'), { recursive: true });
+
+const HOOKS = [
+  'enforce-tier.mjs', 'cost-logger.mjs', 'cost-report.mjs',
+  'dual-brain-review.mjs', 'dual-brain-think.mjs', 'quality-gate.mjs',
+  'test-orchestrator.mjs', 'setup-wizard.mjs', 'health-check.mjs',
+  'install-git-hooks.mjs', 'session-report.mjs', 'budget-balancer.mjs',
+  'gpt-work-dispatcher.mjs',
+];
+
+for (const hook of HOOKS) {
+  cpSync(join(__dirname, 'hooks', hook), join(TARGET, 'hooks', hook));
+}
+console.log(`  ✓ Copied ${HOOKS.length} hook scripts`);
+
+const CONFIGS = [
+  'orchestrator.json',
+  'CLAUDE.md',
+  'hookify.orchestrator-route.local.md',
+  'hookify.orchestrator-gate.local.md',
+  'hookify.orchestrator-cost.local.md',
+];
+
+for (const cfg of CONFIGS) {
+  cpSync(join(__dirname, cfg), join(TARGET, cfg));
+}
+console.log('  ✓ Copied orchestrator config');
+
+const rulesTarget = join(TARGET, 'review-rules.md');
+if (!existsSync(rulesTarget)) {
+  cpSync(join(__dirname, 'review-rules.md'), rulesTarget);
+  console.log('  ✓ Created review-rules.md template');
+} else {
+  console.log('  ⊘ review-rules.md already exists, skipping');
+}
+
+const settingsPath = join(TARGET, 'settings.json');
+let settings = {};
+try { settings = JSON.parse(readFileSync(settingsPath, 'utf8')); } catch {}
+
+const hooksConfig = {
+  PreToolUse: [
+    {
+      matcher: 'Agent',
+      hooks: [{ type: 'command', command: `node ${join('.claude', 'hooks', 'enforce-tier.mjs')}` }],
+    },
+  ],
+  PostToolUse: [
+    {
+      matcher: '',
+      hooks: [{ type: 'command', command: `node ${join('.claude', 'hooks', 'cost-logger.mjs')}` }],
+    },
+  ],
+};
+
+settings.hooks = { ...(settings.hooks || {}), ...hooksConfig };
+writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+console.log('  ✓ Registered hooks in .claude/settings.json');
+
+const gitignorePath = resolve(process.cwd(), '.gitignore');
+const ignoreEntries = [
+  '.claude/hooks/usage-*.jsonl',
+  '.claude/hooks/usage.jsonl',
+  '.claude/reviews/',
+  '.claude/hooks/.drift-warned',
+  '.claude/hooks/.budget-alerted',
+];
+
+let gitignore = '';
+try { gitignore = readFileSync(gitignorePath, 'utf8'); } catch {}
+
+const newEntries = ignoreEntries.filter(e => !gitignore.includes(e));
+if (newEntries.length > 0) {
+  const block = '\n# Dual-Brain Orchestrator\n' + newEntries.join('\n') + '\n';
+  writeFileSync(gitignorePath, gitignore + block);
+  console.log('  ✓ Updated .gitignore');
+}
+
+console.log('');
+console.log(`  ${border('╔', '╗')}`);
+console.log(`  ${line('Installed!')}`);
+console.log(`  ${border('╠', '╣')}`);
+console.log(`  ${line('Next steps:')}`);
+console.log(`  ${line('1. node .claude/hooks/setup-wizard.mjs')}`);
+console.log(`  ${line('2. Restart your Claude Code session')}`);
+console.log(`  ${line('3. node .claude/hooks/health-check.mjs')}`);
+console.log(`  ${border('╠', '╣')}`);
+console.log(`  ${line('Optional:')}`);
+console.log(`  ${line('• Edit .claude/review-rules.md for your repo')}`);
+console.log(`  ${line('• node .claude/hooks/install-git-hooks.mjs')}`);
+console.log(`  ${line('• node .claude/hooks/test-orchestrator.mjs')}`);
+console.log(`  ${border('╚', '╝')}`);
+console.log('');

package/orchestrator.json

@@ -0,0 +1,215 @@
+{
+  "subscriptions": {
+    "claude": {
+      "plan": "$100",
+      "models": {
+        "opus":   { "tier": "think",   "input_per_mtok": 5.0,   "output_per_mtok": 25.0,  "context_window": 1000000, "max_output": 128000 },
+        "sonnet": { "tier": "execute", "input_per_mtok": 3.0,   "output_per_mtok": 15.0,  "context_window": 1000000, "max_output": 64000 },
+        "haiku":  { "tier": "search",  "input_per_mtok": 1.0,   "output_per_mtok": 5.0,   "context_window": 200000,  "max_output": 64000 }
+      }
+    },
+    "openai": {
+      "plan": "$100",
+      "models": {
+        "gpt-5.5":      { "tier": "think",   "input_per_mtok": 5.0,   "output_per_mtok": 30.0,  "context_window": 1000000, "max_output": 128000 },
+        "gpt-5.4":      { "tier": "execute", "input_per_mtok": 2.5,   "output_per_mtok": 15.0,  "context_window": 1000000, "max_output": 128000 },
+        "gpt-4.1-mini": { "tier": "search",  "input_per_mtok": 0.40,  "output_per_mtok": 1.60,  "context_window": 1047576, "max_output": 32768 }
+      }
+    }
+  },
+
+  "model_intelligence": {
+    "opus": {
+      "model_id": "claude-opus-4-6",
+      "strengths": ["agentic coding", "complex reasoning", "tool use", "error recovery", "architecture decisions"],
+      "weaknesses": ["higher latency", "tokenizer tax on 4.7 (12-35% more tokens)"],
+      "best_for": "architecture, security review, complex debugging, multi-step planning",
+      "avoid_for": "simple file reads, grep, formatting — wasteful at this tier"
+    },
+    "sonnet": {
+      "model_id": "claude-sonnet-4-6",
+      "strengths": ["best speed/intelligence ratio", "precise minimal diffs", "1M context", "extended thinking"],
+      "weaknesses": ["less reliable on complex multi-step reasoning than Opus"],
+      "best_for": "implementation, refactoring, test writing, code edits, git operations",
+      "avoid_for": "architecture decisions, security audits — upgrade to think tier"
+    },
+    "haiku": {
+      "model_id": "claude-haiku-4-5-20251001",
+      "strengths": ["fastest latency", "cheapest", "good enough for read-only tasks"],
+      "weaknesses": ["200k context (vs 1M for others)", "weaker reasoning", "older knowledge cutoff"],
+      "best_for": "file lookups, grep, explore, read-only research, listing files",
+      "avoid_for": "any task requiring edits, reasoning, or judgment"
+    },
+    "gpt-5.5": {
+      "model_id": "gpt-5.5",
+      "strengths": ["complex reasoning", "fast interactive responses", "strong code review", "independent perspective from Claude"],
+      "weaknesses": ["different failure modes than Claude — feature not bug for dual-brain"],
+      "best_for": "independent code review (dual-brain), second opinions on architecture",
+      "codex_compatible": true
+    },
+    "gpt-5.4": {
+      "model_id": "gpt-5.4",
+      "strengths": ["good speed/cost ratio", "1M context", "strong instruction following"],
+      "weaknesses": ["less capable reasoning than gpt-5.5"],
+      "best_for": "implementation and execution tasks via Codex",
+      "codex_compatible": true
+    },
+    "gpt-4.1-mini": {
+      "model_id": "gpt-4.1-mini",
+      "strengths": ["extremely cheap", "good instruction following", "1M context"],
+      "weaknesses": ["32k max output", "no reasoning chain"],
+      "best_for": "cheap search/lookup tasks via Codex",
+      "codex_compatible": true
+    }
+  },
+
+  "tiers": {
+    "search": {
+      "description": "Read-only lookups, exploration, grep, find, file reads",
+      "prefer": "cheapest available model",
+      "tasks": ["explore", "grep", "find", "ls", "read_file", "git_log", "git_status"]
+    },
+    "execute": {
+      "description": "Implementation, edits, test runs, git operations, linting",
+      "prefer": "mid-tier model",
+      "tasks": ["edit", "write", "test_run", "lint", "format", "simple_fix", "refactor_small"]
+    },
+    "think": {
+      "description": "Architecture, review, planning, security, complex debugging",
+      "prefer": "most capable model",
+      "tasks": ["architecture", "review", "planning", "security", "complex_debug", "design"]
+    }
+  },
+
+  "quality_gate": {
+    "enabled": true,
+    "trigger_extensions": [".ts", ".tsx", ".js", ".jsx", ".py", ".rs", ".go", ".java", ".rb", ".swift", ".kt"],
+    "skip_patterns": ["test", "__tests__", "spec", ".md", ".json", ".yaml", ".toml", ".txt"]
+  },
+
+  "routing_rules": {
+    "subagent_defaults": {
+      "Explore": "search",
+      "general-purpose": "execute",
+      "Plan": "think",
+      "code-reviewer": "think"
+    },
+    "max_concurrent_think": 1,
+    "max_concurrent_execute": 3,
+    "max_concurrent_search": 4,
+    "model_routing_note": "Claude Code model: param may be silently ignored (issue #43869). Set CLAUDE_CODE_SUBAGENT_MODEL env var as fallback if subagents all run on parent model."
+  },
+
+  "codex_skills": {
+    "review": {
+      "description": "Independent GPT code review via ChatGPT subscription",
+      "command": "node .claude/hooks/dual-brain-review.mjs",
+      "requires": "codex_auth"
+    },
+    "quality_gate": {
+      "description": "Config-driven quality gate with review artifacts",
+      "command": "node .claude/hooks/quality-gate.mjs"
+    },
+    "cost_report": {
+      "description": "Session activity and cost estimate by model tier",
+      "command": "node .claude/hooks/cost-report.mjs"
+    },
+    "test": {
+      "description": "Self-test harness for all orchestrator hooks",
+      "command": "node .claude/hooks/test-orchestrator.mjs"
+    },
+    "health_check": {
+      "description": "Verify all hooks are wired and system is healthy",
+      "command": "node .claude/hooks/health-check.mjs"
+    },
+    "session_report": {
+      "description": "Comprehensive session-end summary: activity by tier, routing compliance, quality gate status, data quality, drift warnings",
+      "command": "node .claude/hooks/session-report.mjs"
+    },
+    "setup_wizard": {
+      "description": "Interactive setup wizard — configures Claude Code hooks, dual-provider routing (Claude + OpenAI/Codex), subscription tiers, and cost-tracking settings",
+      "command": "node .claude/hooks/setup-wizard.mjs"
+    },
+    "gpt_dispatch": {
+      "description": "Dispatch execution tasks to GPT via Codex CLI",
+      "command": "node .claude/hooks/gpt-work-dispatcher.mjs"
+    },
+    "budget_balance": {
+      "description": "Show provider balance status and routing recommendations",
+      "command": "node .claude/hooks/budget-balancer.mjs"
+    }
+  },
+
+  "pricing_verified": "2026-05-13",
+
+  "budgets": {
+    "session_warn_usd": 5.00,
+    "session_limit_usd": 10.00,
+    "daily_warn_usd": 20.00,
+    "daily_limit_usd": 50.00,
+    "alert_cooldown_minutes": 15
+  },
+
+  "routing": {
+    "strategy": "hybrid-specialized-balanced",
+    "codex_startup_penalty_ms": 20000,
+    "min_codex_task_ms": 180000,
+    "dual_thinking_permission_threshold": {
+      "estimated_tokens": 50000,
+      "agent_count": 2
+    }
+  },
+
+  "providers": {
+    "claude": {
+      "enabled": true,
+      "subscription": "max-5x",
+      "models": {
+        "think": "opus",
+        "execute": "sonnet",
+        "search": "haiku"
+      },
+      "rolling_window_hours": 5,
+      "pressure_thresholds": {
+        "warm": 0.65,
+        "hot": 0.82,
+        "throttled": 0.95
+      }
+    },
+    "openai": {
+      "enabled": true,
+      "subscription": "pro",
+      "codex_command": "codex",
+      "models": {
+        "think": "gpt-5.5",
+        "execute": "gpt-5.4",
+        "search": "gpt-4.1-mini"
+      },
+      "rolling_window_hours": 5,
+      "pressure_thresholds": {
+        "warm": 0.65,
+        "hot": 0.82,
+        "throttled": 0.95
+      }
+    }
+  },
+
+  "dual_thinking": {
+    "enabled": true,
+    "auto_triggers": [
+      "architecture",
+      "security",
+      "database-migration",
+      "public-api",
+      "large-refactor",
+      "dependency-upgrade",
+      "production-incident"
+    ],
+    "sensitive_paths": [
+      "auth", "security", "middleware/auth", "payment", "billing",
+      "migration", "schema", "permissions", "secrets", "crypto",
+      "api/public", ".env"
+    ],
+    "conflict_resolver": "least-pressured-think-model"
+  }
+}