dual-brain 7.1.2 → 7.1.4

package/src/test.mjs

@@ -1,1374 +0,0 @@
-#!/usr/bin/env node
-/**
- * test.mjs — Test suite for core dual-brain modules.
- * Run: node --test src/test.mjs
- *
- * Covers: profile, detect, decide, dispatch (+ CLI dry-run smoke tests).
- * Uses node:test + node:assert only — no external dependencies.
- */
-
-import { describe, it, before, after, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT      = join(__dirname, '..');
-const BIN       = join(ROOT, 'bin', 'dual-brain.mjs');
-const PKG       = join(ROOT, 'package.json');
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function makeTmp() {
-  const dir = join(tmpdir(), `dual-brain-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-function removeTmp(dir) {
-  if (dir && existsSync(dir)) rmSync(dir, { recursive: true, force: true });
-}
-
-/** Spawn a command and collect stdout+stderr, returns { code, stdout, stderr } */
-function run(args, opts = {}) {
-  return new Promise((resolve) => {
-    const proc = spawn(process.execPath, args, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      ...opts,
-    });
-    let stdout = '';
-    let stderr = '';
-    proc.stdout.on('data', d => { stdout += d; });
-    proc.stderr.on('data', d => { stderr += d; });
-    proc.on('close', code => resolve({ code, stdout, stderr }));
-  });
-}
-
-// ─── Import modules under test ────────────────────────────────────────────────
-
-import {
-  loadProfile, saveProfile,
-  rememberPreference, forgetPreference,
-  getAvailableProviders, isSoloBrain, getHeadModel,
-} from './profile.mjs';
-
-import {
-  classifyIntent, classifyRisk, estimateComplexity,
-  detectTask, inferTier,
-} from './detect.mjs';
-
-import {
-  decideRoute, getAvailableModels, shouldDualBrain, explainDecision, parsePreferences,
-} from './decide.mjs';
-
-import {
-  buildCommand, compressResult, detectRuntime,
-  validateDispatch, checkWorktreeClean, getRetryBudget,
-} from './dispatch.mjs';
-
-import { redact } from './redact.mjs';
-import { markHot, markHealthy } from './health.mjs';
-import { decompose } from './decompose.mjs';
-import { loadPlaybook } from './playbook.mjs';
-import { formatSessionCard } from './session.mjs';
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// PROFILE TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe('profile', () => {
-  let tmp;
-  before(() => { tmp = makeTmp(); });
-  after(() => removeTmp(tmp));
-
-  it('loadProfile returns defaults when no config exists', () => {
-    const profile = loadProfile(tmp);
-    assert.equal(profile.schemaVersion, 1);
-    assert.equal(profile.mode, 'auto');
-    assert.equal(profile.bias, 'balanced');
-    assert.ok(Array.isArray(profile.preferences));
-    assert.equal(profile.preferences.length, 0);
-    assert.ok(profile.providers);
-    assert.ok(profile.providers.claude);
-    assert.equal(profile.providers.claude.enabled, true);
-    assert.equal(profile.providers.openai.enabled, false);
-  });
-
-  it('saveProfile + loadProfile round-trips correctly', () => {
-    const dir = makeTmp();
-    try {
-      const profile = loadProfile(dir); // get defaults
-      profile.mode = 'dual';
-      profile.bias = 'quality-first';
-      profile.providers.openai.enabled = true;
-      profile.providers.openai.plan = '$100';
-      saveProfile(profile, { cwd: dir });
-      const loaded = loadProfile(dir);
-      assert.equal(loaded.mode, 'dual');
-      assert.equal(loaded.bias, 'quality-first');
-      assert.equal(loaded.providers.openai.enabled, true);
-      assert.equal(loaded.providers.openai.plan, '$100');
-      assert.equal(loaded.schemaVersion, 1);
-    } finally {
-      removeTmp(dir);
-    }
-  });
-
-  it('migrateProfile handles missing fields (schemaVersion 0 → 1)', () => {
-    // migrateProfile is not exported directly; test indirectly via loadProfile which
-    // calls migrateProfile internally when reading a saved profile.
-    const dir = makeTmp();
-    try {
-      // Write a raw v0-style profile (no schemaVersion, no mode/bias/preferences)
-      const raw = {
-        providers: {
-          claude: { plan: '$20', enabled: true },
-          openai: { plan: '$20', enabled: false },
-        },
-      };
-      const profileDir = join(dir, '.dualbrain');
-      mkdirSync(profileDir, { recursive: true });
-      // writeFileSync is already imported at the top of this file from 'node:fs'
-      writeFileSync(join(profileDir, 'profile.json'), JSON.stringify(raw));
-      const profile = loadProfile(dir);
-      assert.equal(profile.schemaVersion, 1);
-      assert.equal(profile.mode, 'auto');
-      assert.equal(profile.bias, 'balanced');
-      assert.ok(Array.isArray(profile.preferences));
-    } finally {
-      removeTmp(dir);
-    }
-  });
-
-  it('rememberPreference adds a preference', () => {
-    const dir = makeTmp();
-    try {
-      const profile = rememberPreference('always use strict TypeScript', { cwd: dir, scope: 'project' });
-      assert.equal(profile.preferences.length, 1);
-      assert.equal(profile.preferences[0].text, 'always use strict TypeScript');
-      assert.equal(profile.preferences[0].enabled, true);
-      assert.equal(profile.preferences[0].scope, 'project');
-    } finally {
-      removeTmp(dir);
-    }
-  });
-
-  it('rememberPreference deduplicates (updates existing match)', () => {
-    const dir = makeTmp();
-    try {
-      rememberPreference('use strict TypeScript', { cwd: dir, scope: 'project' });
-      const profile = rememberPreference('use strict TypeScript always', { cwd: dir, scope: 'project' });
-      // Should update, not append a second entry
-      assert.equal(profile.preferences.length, 1);
-    } finally {
-      removeTmp(dir);
-    }
-  });
-
-  it('forgetPreference removes by substring match', () => {
-    const dir = makeTmp();
-    try {
-      rememberPreference('always lint on save', { cwd: dir, scope: 'project' });
-      rememberPreference('prefer short functions', { cwd: dir, scope: 'project' });
-      const profile = forgetPreference('lint on save', dir);
-      assert.equal(profile.preferences.length, 1);
-      assert.equal(profile.preferences[0].text, 'prefer short functions');
-    } finally {
-      removeTmp(dir);
-    }
-  });
-
-  it('getAvailableProviders returns only enabled providers', () => {
-    const profile = {
-      providers: {
-        claude: { plan: '$20', enabled: true },
-        openai: { plan: '$100', enabled: false },
-      },
-    };
-    const providers = getAvailableProviders(profile);
-    assert.equal(providers.length, 1);
-    assert.equal(providers[0].name, 'claude');
-  });
-
-  it('getAvailableProviders returns both when both enabled', () => {
-    const profile = {
-      providers: {
-        claude: { plan: '$20', enabled: true },
-        openai: { plan: '$100', enabled: true },
-      },
-    };
-    const providers = getAvailableProviders(profile);
-    assert.equal(providers.length, 2);
-  });
-
-  it('isSoloBrain returns true with one provider', () => {
-    const profile = {
-      providers: {
-        claude: { plan: '$20', enabled: true },
-        openai: { plan: '$20', enabled: false },
-      },
-    };
-    assert.equal(isSoloBrain(profile), true);
-  });
-
-  it('isSoloBrain returns false with two providers', () => {
-    const profile = {
-      providers: {
-        claude: { plan: '$20', enabled: true },
-        openai: { plan: '$20', enabled: true },
-      },
-    };
-    assert.equal(isSoloBrain(profile), false);
-  });
-
-  it('getHeadModel returns sonnet for solo-claude', () => {
-    const profile = {
-      providers: {
-        claude: { plan: '$20', enabled: true },
-        openai: { plan: '$20', enabled: false },
-      },
-    };
-    assert.equal(getHeadModel(profile), 'sonnet');
-  });
-
-  it('getHeadModel returns gpt-5.4 for solo-openai', () => {
-    const profile = {
-      providers: {
-        claude: { plan: '$20', enabled: false },
-        openai: { plan: '$20', enabled: true },
-      },
-    };
-    assert.equal(getHeadModel(profile), 'gpt-5.4');
-  });
-
-  it('getHeadModel returns sonnet for dual profile (claude is default highest when ranks tie)', () => {
-    // Both at $20 rank 1 — reduce() keeps first when equal, which is claude → sonnet
-    const profile = {
-      providers: {
-        claude: { plan: '$20', enabled: true },
-        openai: { plan: '$20', enabled: true },
-      },
-    };
-    const model = getHeadModel(profile);
-    // sonnet (claude wins tie) or gpt-5.4 (openai) — both are valid depending on iteration order
-    assert.ok(['sonnet', 'gpt-5.4'].includes(model), `Unexpected model: ${model}`);
-  });
-
-  it('getHeadModel returns gpt-5.4 for dual profile when openai has higher plan', () => {
-    const profile = {
-      providers: {
-        claude: { plan: '$20', enabled: true },  // rank 1
-        openai: { plan: '$100', enabled: true }, // rank 2
-      },
-    };
-    assert.equal(getHeadModel(profile), 'gpt-5.4');
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// DETECT TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe('detect', () => {
-  describe('classifyIntent', () => {
-    it('"fix the bug" → edit', () => {
-      assert.equal(classifyIntent('fix the bug'), 'edit');
-    });
-
-    it('"explain this function" → explain', () => {
-      assert.equal(classifyIntent('explain this function'), 'explain');
-    });
-
-    it('"refactor auth module" → security (security has higher priority than refactor)', () => {
-      // "auth" matches the security regex and security ranks above refactor in INTENT_PRIORITY.
-      assert.equal(classifyIntent('refactor auth module'), 'security');
-    });
-
-    it('"refactor the navigation component" → refactor', () => {
-      assert.equal(classifyIntent('refactor the navigation component'), 'refactor');
-    });
-
-    it('"review the PR" → review', () => {
-      assert.equal(classifyIntent('review the PR'), 'review');
-    });
-
-    it('"find where the logger is called" → search', () => {
-      assert.equal(classifyIntent('find where the logger is called'), 'search');
-    });
-
-    it('"design the system architecture" → architecture', () => {
-      // Note: "auth" keyword triggers security before architecture in priority order.
-      // Use a prompt without auth to reliably get architecture.
-      assert.equal(classifyIntent('design the system architecture'), 'architecture');
-    });
-
-    it('"auth" in prompt triggers security intent (higher priority than architecture)', () => {
-      // "security" has higher priority than "architecture" in INTENT_PRIORITY.
-      // "auth" matches the security regex, so it wins over "design".
-      assert.equal(classifyIntent('design the new auth system'), 'security');
-    });
-  });
-
-  describe('classifyRisk', () => {
-    it('returns low for empty paths', () => {
-      const { level } = classifyRisk([]);
-      assert.equal(level, 'low');
-    });
-
-    it('returns critical for auth paths', () => {
-      const { level } = classifyRisk(['src/auth/token.mjs']);
-      assert.equal(level, 'critical');
-    });
-
-    it('returns critical for secret/key paths', () => {
-      const { level } = classifyRisk(['config/secrets.env']);
-      assert.equal(level, 'critical');
-    });
-
-    it('returns high for billing paths', () => {
-      const { level } = classifyRisk(['src/billing/invoice.mjs']);
-      assert.equal(level, 'high');
-    });
-
-    it('returns high for migration paths', () => {
-      // The regex uses \b boundaries; "migration.sql" matches but "migrations/" does not
-      // because "migrations" adds an extra 's' that breaks the word boundary.
-      const { level } = classifyRisk(['db/migration.sql']);
-      assert.equal(level, 'high');
-    });
-
-    it('returns low for docs paths', () => {
-      const { level } = classifyRisk(['docs/README.md']);
-      assert.equal(level, 'low');
-    });
-
-    it('returns medium for test files', () => {
-      const { level } = classifyRisk(['src/utils.test.mjs']);
-      assert.equal(level, 'medium');
-    });
-  });
-
-  describe('estimateComplexity', () => {
-    it('returns trivial for simple low-risk single-file format', () => {
-      const c = estimateComplexity({ prompt: 'format this file', fileCount: 1, risk: 'low', intent: 'format' });
-      assert.equal(c, 'trivial');
-    });
-
-    it('returns complex for critical risk', () => {
-      const c = estimateComplexity({ prompt: 'fix the auth token', fileCount: 0, risk: 'critical', intent: 'edit' });
-      assert.equal(c, 'complex');
-    });
-
-    it('returns complex for 6+ files', () => {
-      const c = estimateComplexity({ prompt: 'update all services', fileCount: 6, risk: 'low', intent: 'edit' });
-      assert.equal(c, 'complex');
-    });
-
-    it('returns complex for architecture intent', () => {
-      const c = estimateComplexity({ prompt: 'design the cache layer', fileCount: 0, risk: 'low', intent: 'architecture' });
-      assert.equal(c, 'complex');
-    });
-
-    it('returns moderate for 3+ files', () => {
-      const c = estimateComplexity({ prompt: 'update three files', fileCount: 3, risk: 'low', intent: 'edit' });
-      assert.equal(c, 'moderate');
-    });
-
-    it('returns moderate for refactor intent', () => {
-      const c = estimateComplexity({ prompt: 'refactor nav', fileCount: 0, risk: 'low', intent: 'refactor' });
-      assert.equal(c, 'moderate');
-    });
-
-    it('returns complex with 2+ prior failures', () => {
-      const c = estimateComplexity({ prompt: 'fix the same bug again', fileCount: 1, risk: 'low', intent: 'edit', priorFailures: 2 });
-      assert.equal(c, 'complex');
-    });
-  });
-
-  describe('detectTask full pipeline', () => {
-    it('simple edit → {intent:edit, risk:low, complexity:simple, tier:execute}', () => {
-      // Use a plain edit prompt with no keywords that trigger higher-priority intents.
-      const result = detectTask({ prompt: 'add a new button to the settings page' });
-      assert.equal(result.intent, 'edit');
-      assert.ok(['low', 'medium'].includes(result.risk));
-      assert.equal(result.tier, 'execute');
-    });
-
-    it('security: "fix auth token leak in src/auth.mjs" → critical risk, think tier', () => {
-      const result = detectTask({ prompt: 'fix auth token leak in src/auth.mjs' });
-      assert.equal(result.risk, 'critical');
-      assert.equal(result.tier, 'think');
-    });
-
-    it('search: "find where logger is used" → intent:search, tier:search or execute', () => {
-      const result = detectTask({ prompt: 'find where logger is used in the codebase' });
-      assert.equal(result.intent, 'search');
-      // Low effort → search tier; effort depends on risk/complexity
-      assert.ok(['search', 'execute'].includes(result.tier));
-    });
-
-    it('result has all required fields', () => {
-      const result = detectTask({ prompt: 'add a new endpoint' });
-      assert.ok('intent' in result);
-      assert.ok('risk' in result);
-      assert.ok('complexity' in result);
-      assert.ok('effort' in result);
-      assert.ok('tier' in result);
-      assert.ok('fileCount' in result);
-      assert.ok('riskyFiles' in result);
-      assert.ok('requiresWrite' in result);
-      assert.ok('explanation' in result);
-    });
-
-    it('priorFailures escalates effort and complexity', () => {
-      const base   = detectTask({ prompt: 'fix the bug', files: [], priorFailures: 0 });
-      const failed = detectTask({ prompt: 'fix the bug', files: [], priorFailures: 2 });
-      assert.equal(failed.complexity, 'complex');
-      assert.equal(failed.effort, 'xhigh');
-    });
-  });
-
-  describe('inferTier', () => {
-    it('architecture intent → think', () => {
-      assert.equal(inferTier({ intent: 'architecture', risk: 'low', complexity: 'simple' }), 'think');
-    });
-
-    it('critical risk → think', () => {
-      assert.equal(inferTier({ intent: 'edit', risk: 'critical', complexity: 'moderate' }), 'think');
-    });
-
-    it('edit intent, low risk → execute', () => {
-      assert.equal(inferTier({ intent: 'edit', risk: 'low', complexity: 'simple' }), 'execute');
-    });
-
-    it('search intent, low effort → search', () => {
-      assert.equal(inferTier({ intent: 'search', risk: 'low', complexity: 'trivial', effort: 'low' }), 'search');
-    });
-
-    it('format intent, low effort → search', () => {
-      assert.equal(inferTier({ intent: 'format', risk: 'low', complexity: 'trivial', effort: 'low' }), 'search');
-    });
-
-    it('review intent → think', () => {
-      assert.equal(inferTier({ intent: 'review', risk: 'low', complexity: 'simple' }), 'think');
-    });
-
-    it('refactor intent → execute', () => {
-      assert.equal(inferTier({ intent: 'refactor', risk: 'low', complexity: 'moderate' }), 'execute');
-    });
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// DECIDE TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe('decide', () => {
-  const soloClaude20 = {
-    providers: {
-      claude: { plan: '$20', enabled: true },
-      openai: { plan: '$20', enabled: false },
-    },
-    mode: 'solo-claude',
-    bias: 'balanced',
-  };
-
-  const soloClaude100 = {
-    providers: {
-      claude: { plan: '$100', enabled: true },
-      openai: { plan: '$20',  enabled: false },
-    },
-    mode: 'solo-claude',
-    bias: 'balanced',
-  };
-
-  const dualProfile = {
-    providers: {
-      claude: { plan: '$100', enabled: true },
-      openai: { plan: '$100', enabled: true },
-    },
-    mode: 'dual',
-    bias: 'balanced',
-  };
-
-  describe('decideRoute', () => {
-    it('solo-claude $20 → haiku or sonnet, never opus', () => {
-      const detection = { intent: 'edit', risk: 'low', complexity: 'simple', effort: 'medium', tier: 'execute' };
-      const decision = decideRoute({ profile: soloClaude20, detection });
-      assert.equal(decision.provider, 'claude');
-      assert.ok(['haiku', 'sonnet'].includes(decision.model), `Got: ${decision.model}`);
-      assert.notEqual(decision.model, 'opus');
-    });
-
-    it('solo-claude $100 → can use opus for think-tier tasks', () => {
-      const detection = { intent: 'architecture', risk: 'high', complexity: 'complex', effort: 'xhigh', tier: 'think' };
-      const decision = decideRoute({ profile: soloClaude100, detection });
-      assert.equal(decision.provider, 'claude');
-      assert.equal(decision.model, 'opus');
-    });
-
-    it('dual profile, search task → picks a provider and a model', () => {
-      const detection = { intent: 'search', risk: 'low', complexity: 'trivial', effort: 'low', tier: 'search' };
-      const decision = decideRoute({ profile: dualProfile, detection });
-      assert.ok(['claude', 'openai'].includes(decision.provider));
-      assert.ok(typeof decision.model === 'string' && decision.model.length > 0);
-    });
-
-    it('dual profile, think-tier → provider is claude (session coupling)', () => {
-      const detection = { intent: 'architecture', risk: 'high', complexity: 'complex', effort: 'xhigh', tier: 'think' };
-      const decision = decideRoute({ profile: dualProfile, detection });
-      assert.equal(decision.provider, 'claude');
-    });
-
-    it('returns decision object with required fields', () => {
-      const detection = { intent: 'edit', risk: 'low', complexity: 'simple', effort: 'medium', tier: 'execute' };
-      const decision = decideRoute({ profile: soloClaude20, detection });
-      assert.ok('provider' in decision);
-      assert.ok('model' in decision);
-      assert.ok('tier' in decision);
-      assert.ok('dualBrain' in decision);
-      assert.ok('explanation' in decision);
-      assert.ok('modes' in decision);
-      assert.ok('sandbox' in decision);
-    });
-  });
-
-  describe('getAvailableModels', () => {
-    it('$20 claude plan excludes opus', () => {
-      const { claude } = getAvailableModels(soloClaude20);
-      assert.ok(!claude.includes('opus'), `opus found in $20 plan: ${claude.join(', ')}`);
-      assert.ok(claude.includes('sonnet'));
-      assert.ok(claude.includes('haiku'));
-    });
-
-    it('$100 claude plan includes opus', () => {
-      const { claude } = getAvailableModels(soloClaude100);
-      assert.ok(claude.includes('opus'), `opus missing from $100 plan: ${claude.join(', ')}`);
-    });
-
-    it('$20 openai plan excludes gpt-5.5', () => {
-      const profile = {
-        providers: {
-          claude: { plan: '$20', enabled: false },
-          openai: { plan: '$20', enabled: true },
-        },
-      };
-      const { openai } = getAvailableModels(profile);
-      assert.ok(!openai.includes('gpt-5.5'), `gpt-5.5 found in $20 plan`);
-    });
-
-    it('$100 openai plan includes gpt-5.5', () => {
-      const profile = {
-        providers: {
-          claude: { plan: '$20', enabled: false },
-          openai: { plan: '$100', enabled: true },
-        },
-      };
-      const { openai } = getAvailableModels(profile);
-      assert.ok(openai.includes('gpt-5.5'), `gpt-5.5 missing from $100 plan`);
-    });
-  });
-
-  describe('shouldDualBrain', () => {
-    it('returns false for solo profile regardless of risk', () => {
-      const detection = { intent: 'edit', risk: 'critical', complexity: 'complex' };
-      assert.equal(shouldDualBrain(detection, soloClaude100), false);
-    });
-
-    it('returns false for solo-openai profile', () => {
-      const soloOpenai = {
-        providers: {
-          claude: { plan: '$20', enabled: false },
-          openai: { plan: '$100', enabled: true },
-        },
-      };
-      const detection = { intent: 'security', risk: 'critical', complexity: 'complex' };
-      assert.equal(shouldDualBrain(detection, soloOpenai), false);
-    });
-
-    it('returns true for dual profile with critical risk', () => {
-      const detection = { intent: 'edit', risk: 'critical', complexity: 'simple' };
-      assert.equal(shouldDualBrain(detection, dualProfile), true);
-    });
-
-    it('returns true for dual profile with architecture intent', () => {
-      const detection = { intent: 'architecture', risk: 'low', complexity: 'complex' };
-      assert.equal(shouldDualBrain(detection, dualProfile), true);
-    });
-
-    it('returns true for dual profile with security intent', () => {
-      const detection = { intent: 'security', risk: 'high', complexity: 'moderate' };
-      assert.equal(shouldDualBrain(detection, dualProfile), true);
-    });
-
-    it('returns false for dual profile with low-risk edit', () => {
-      const detection = { intent: 'edit', risk: 'low', complexity: 'simple' };
-      assert.equal(shouldDualBrain(detection, dualProfile), false);
-    });
-
-    it('returns true for dual profile complex+high risk', () => {
-      const detection = { intent: 'refactor', risk: 'high', complexity: 'complex' };
-      assert.equal(shouldDualBrain(detection, dualProfile), true);
-    });
-  });
-
-  describe('explainDecision', () => {
-    it('returns a non-empty string', () => {
-      const detection = { intent: 'edit', risk: 'low', complexity: 'simple', tier: 'execute' };
-      const decision  = decideRoute({ profile: soloClaude20, detection });
-      const explanation = explainDecision(decision, detection, soloClaude20);
-      assert.ok(typeof explanation === 'string');
-      assert.ok(explanation.length > 0);
-    });
-
-    it('mentions dual-brain when dualBrain is true', () => {
-      const detection = { intent: 'edit', risk: 'critical', complexity: 'complex', tier: 'think' };
-      const decisionWithDual = {
-        provider: 'claude',
-        model: 'opus',
-        effort: 'xhigh',
-        dualBrain: true,
-        _pressure: { claude: 0, openai: 0 },
-      };
-      const explanation = explainDecision(decisionWithDual, detection, dualProfile);
-      assert.ok(explanation.toLowerCase().includes('dual-brain'), `Expected dual-brain mention: ${explanation}`);
-    });
-  });
-
-  describe('budget pressure downgrade', () => {
-    it('high pressure > 0.7 results in a downgraded model (not opus when under pressure)', () => {
-      // We cannot inject pressure directly into decideRoute without real files,
-      // so we test the observable: with $100 plan, think task normally picks opus,
-      // but if we can verify the downgrade path exists, we check with a search task
-      // where sonnet → haiku downgrade is expected under pressure.
-      // We verify via getAvailableModels that downgrade candidates exist.
-      const { claude } = getAvailableModels(soloClaude100);
-      // haiku must be available as downgrade target from sonnet
-      assert.ok(claude.includes('haiku'));
-      assert.ok(claude.includes('sonnet'));
-      assert.ok(claude.includes('opus'));
-      // Confidence check: rank order is correct (haiku < sonnet < opus)
-      const rank = ['haiku', 'sonnet', 'opus'];
-      const haikuIdx  = rank.indexOf('haiku');
-      const sonnetIdx = rank.indexOf('sonnet');
-      const opusIdx   = rank.indexOf('opus');
-      assert.ok(haikuIdx < sonnetIdx && sonnetIdx < opusIdx);
-    });
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// PREFERENCE ROUTING TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe('preference routing', () => {
-  describe('parsePreferences — signal extraction', () => {
-    it('"prefer cheaper models" → biasOverride = cost-saver', () => {
-      const signals = parsePreferences([{ text: 'prefer cheaper models', enabled: true, scope: 'project' }]);
-      assert.equal(signals.biasOverride, 'cost-saver');
-    });
-
-    it('"always use dual brain consensus" → alwaysDualBrain = true', () => {
-      const signals = parsePreferences([{ text: 'always use dual brain consensus', enabled: true, scope: 'project' }]);
-      assert.equal(signals.alwaysDualBrain, true);
-    });
-
-    it('"prefer claude" → preferProvider = claude', () => {
-      const signals = parsePreferences([{ text: 'prefer claude', enabled: true, scope: 'project' }]);
-      assert.equal(signals.preferProvider, 'claude');
-    });
-
-    it('"avoid openai" → avoidProvider = openai', () => {
-      const signals = parsePreferences([{ text: 'avoid openai', enabled: true, scope: 'project' }]);
-      assert.equal(signals.avoidProvider, 'openai');
-    });
-
-    it('empty preferences array → all nulls/false', () => {
-      const signals = parsePreferences([]);
-      assert.equal(signals.biasOverride,    null);
-      assert.equal(signals.preferProvider,  null);
-      assert.equal(signals.avoidProvider,   null);
-      assert.equal(signals.alwaysDualBrain, false);
-      assert.equal(signals.neverDualBrain,  false);
-      assert.equal(signals.preferModel,     null);
-    });
-
-    it('null preferences → all nulls/false', () => {
-      const signals = parsePreferences(null);
-      assert.equal(signals.biasOverride,    null);
-      assert.equal(signals.preferProvider,  null);
-      assert.equal(signals.avoidProvider,   null);
-      assert.equal(signals.alwaysDualBrain, false);
-      assert.equal(signals.neverDualBrain,  false);
-      assert.equal(signals.preferModel,     null);
-    });
-
-    it('disabled preferences are ignored', () => {
-      const signals = parsePreferences([
-        { text: 'prefer cheaper models', enabled: false, scope: 'project' },
-        { text: 'avoid openai',          enabled: false, scope: 'project' },
-      ]);
-      assert.equal(signals.biasOverride,  null);
-      assert.equal(signals.avoidProvider, null);
-    });
-
-    it('"use best quality" → biasOverride = quality-first', () => {
-      const signals = parsePreferences([{ text: 'use best quality', enabled: true, scope: 'project' }]);
-      assert.equal(signals.biasOverride, 'quality-first');
-    });
-
-    it('"prefer gpt" → preferProvider = openai', () => {
-      const signals = parsePreferences([{ text: 'prefer gpt', enabled: true, scope: 'project' }]);
-      assert.equal(signals.preferProvider, 'openai');
-    });
-
-    it('"prefer opus" → preferModel = opus', () => {
-      const signals = parsePreferences([{ text: 'prefer opus', enabled: true, scope: 'project' }]);
-      assert.equal(signals.preferModel, 'opus');
-    });
-
-    it('"never dual" → neverDualBrain = true', () => {
-      const signals = parsePreferences([{ text: 'never dual brain', enabled: true, scope: 'project' }]);
-      assert.equal(signals.neverDualBrain, true);
-    });
-  });
-
-  describe('parsePreferences → decideRoute wiring', () => {
-    const dualProfile100 = {
-      providers: {
-        claude: { plan: '$100', enabled: true },
-        openai: { plan: '$100', enabled: true },
-      },
-      mode: 'dual',
-      bias: 'balanced',
-    };
-
-    it('cost-saver preference overrides balanced bias → cheaper model selected', () => {
-      const profileWithPref = {
-        ...dualProfile100,
-        preferences: [{ text: 'prefer cheaper models', enabled: true, scope: 'project' }],
-      };
-      const detection = { intent: 'edit', risk: 'low', complexity: 'simple', effort: 'medium', tier: 'execute' };
-      const decision = decideRoute({ profile: profileWithPref, detection });
-      const cheapModels = ['haiku', 'gpt-4.1-mini'];
-      assert.ok(cheapModels.includes(decision.model), `Expected cheap model, got: ${decision.model}`);
-    });
-
-    it('alwaysDualBrain preference forces dualBrain = true even for low-risk edit', () => {
-      const profileWithPref = {
-        ...dualProfile100,
-        preferences: [{ text: 'always use dual brain consensus', enabled: true, scope: 'project' }],
-      };
-      const detection = { intent: 'edit', risk: 'low', complexity: 'simple', effort: 'medium', tier: 'execute' };
-      const decision = decideRoute({ profile: profileWithPref, detection });
-      assert.equal(decision.dualBrain, true);
-    });
-
-    it('neverDualBrain preference forces dualBrain = false even for critical risk', () => {
-      const profileWithPref = {
-        ...dualProfile100,
-        preferences: [{ text: 'never dual brain', enabled: true, scope: 'project' }],
-      };
-      const detection = { intent: 'architecture', risk: 'critical', complexity: 'complex', effort: 'xhigh', tier: 'think' };
-      const decision = decideRoute({ profile: profileWithPref, detection });
-      assert.equal(decision.dualBrain, false);
-    });
-
-    it('disabled preferences do not affect routing', () => {
-      const profileWithDisabledPref = {
-        ...dualProfile100,
-        preferences: [{ text: 'always use dual brain consensus', enabled: false, scope: 'project' }],
-      };
-      const detection = { intent: 'edit', risk: 'low', complexity: 'simple', effort: 'medium', tier: 'execute' };
-      const decisionWithDisabled = decideRoute({ profile: profileWithDisabledPref, detection });
-      const decisionWithout      = decideRoute({ profile: dualProfile100, detection });
-      assert.equal(decisionWithDisabled.dualBrain, decisionWithout.dualBrain);
-    });
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// DISPATCH TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe('dispatch', () => {
-  describe('buildCommand', () => {
-    it('claude provider returns claude CLI args with model ID', () => {
-      const decision = { provider: 'claude', model: 'sonnet', effort: null, sandbox: 'workspace-write' };
-      const cmd = buildCommand(decision, 'fix the bug');
-      assert.equal(cmd[0], 'claude');
-      assert.ok(cmd.includes('--model'));
-      // Model ID should be the full claude model ID, not the alias
-      const modelIdx = cmd.indexOf('--model');
-      assert.ok(cmd[modelIdx + 1].startsWith('claude-'), `Expected claude-* model ID, got: ${cmd[modelIdx + 1]}`);
-      assert.ok(cmd.includes('-p'));
-      assert.ok(cmd.includes('fix the bug'));
-    });
-
-    it('claude provider with opus model returns opus model ID', () => {
-      const decision = { provider: 'claude', model: 'opus', effort: null, sandbox: 'workspace-write' };
-      const cmd = buildCommand(decision, 'design the system');
-      const modelIdx = cmd.indexOf('--model');
-      assert.ok(cmd[modelIdx + 1].includes('opus'), `Expected opus in model ID: ${cmd[modelIdx + 1]}`);
-    });
-
-    it('claude provider with haiku model returns haiku model ID', () => {
-      const decision = { provider: 'claude', model: 'haiku', effort: null, sandbox: 'read-only' };
-      const cmd = buildCommand(decision, 'find the logger');
-      const modelIdx = cmd.indexOf('--model');
-      assert.ok(cmd[modelIdx + 1].includes('haiku'), `Expected haiku in model ID: ${cmd[modelIdx + 1]}`);
-    });
-
-    it('openai provider returns codex CLI args', () => {
-      const decision = { provider: 'openai', model: 'gpt-5.4', effort: null, sandbox: 'danger-full-access' };
-      const cmd = buildCommand(decision, 'fix the bug');
-      assert.equal(cmd[0], 'codex');
-      assert.ok(cmd.includes('gpt-5.4'));
-      assert.ok(cmd.includes('fix the bug'));
-    });
-
-    it('buildCommand includes effort flag for claude when set', () => {
-      const decision = { provider: 'claude', model: 'sonnet', effort: 'high', sandbox: 'workspace-write' };
-      const cmd = buildCommand(decision, 'fix the bug');
-      assert.ok(cmd.includes('--effort'));
-      const effortIdx = cmd.indexOf('--effort');
-      assert.equal(cmd[effortIdx + 1], 'high');
-    });
-
-    it('buildCommand includes effort flag for openai when set', () => {
-      const decision = { provider: 'openai', model: 'gpt-5.4', effort: 'high', sandbox: 'danger-full-access' };
-      const cmd = buildCommand(decision, 'fix the bug');
-      assert.ok(cmd.includes('-c'));
-    });
-
-    it('buildCommand omits effort flag when effort is null', () => {
-      const decision = { provider: 'claude', model: 'sonnet', effort: null, sandbox: 'workspace-write' };
-      const cmd = buildCommand(decision, 'fix the bug');
-      assert.ok(!cmd.includes('--effort'));
-    });
-  });
-
-  describe('compressResult', () => {
-    it('returns (no output) for empty string', () => {
-      assert.equal(compressResult(''), '(no output)');
-    });
-
-    it('returns (no output) for null/undefined', () => {
-      assert.equal(compressResult(null), '(no output)');
-      assert.equal(compressResult(undefined), '(no output)');
-    });
-
-    it('strips code blocks (console.log not present in output)', () => {
-      // compressResult replaces ```...``` with [code block] then extracts
-      // the first meaningful sentences (> 15 chars). "Done." is too short
-      // to qualify, so the result is the text before the code block.
-      const raw = 'Here is the fix:\n```js\nconsole.log("hello");\n```\nDone.';
-      const result = compressResult(raw);
-      // The raw JS inside the code block must not leak through
-      assert.ok(!result.includes('console.log'), `Code block not stripped: ${result}`);
-    });
-
-    it('truncates to maxLength', () => {
-      const raw = 'x'.repeat(1000);
-      const result = compressResult(raw, 100);
-      assert.ok(result.length <= 100, `Too long: ${result.length}`);
-    });
-
-    it('parses JSON result field when available', () => {
-      const raw = JSON.stringify({ result: 'Task completed successfully.' });
-      const result = compressResult(raw, 300);
-      assert.equal(result, 'Task completed successfully.');
-    });
-
-    it('parses JSON content field as fallback', () => {
-      const raw = JSON.stringify({ content: 'Changes applied.' });
-      const result = compressResult(raw, 300);
-      assert.equal(result, 'Changes applied.');
-    });
-  });
-
-  describe('detectRuntime', () => {
-    it('returns an object with claudeAvailable and codexAvailable booleans', async () => {
-      const rt = await detectRuntime();
-      assert.ok(typeof rt === 'object' && rt !== null);
-      assert.ok('claudeAvailable' in rt, 'missing claudeAvailable');
-      assert.ok('codexAvailable'  in rt, 'missing codexAvailable');
-      assert.ok('runtime'         in rt, 'missing runtime');
-      assert.ok(typeof rt.claudeAvailable === 'boolean');
-      assert.ok(typeof rt.codexAvailable  === 'boolean');
-      assert.ok(typeof rt.runtime         === 'string');
-      assert.ok(['claude-code', 'codex-cli', 'standalone', 'none'].includes(rt.runtime),
-        `Unexpected runtime: ${rt.runtime}`);
-    });
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// DISPATCH SAFETY FEATURES
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe('dispatch safety features', () => {
-
-  // ── Feature 1: validateDispatch ────────────────────────────────────────────
-  describe('validateDispatch', () => {
-    it('returns _error when no CLI is available', () => {
-      const rt = { claudeAvailable: false, codexAvailable: false };
-      const result = validateDispatch({ provider: 'claude', model: 'sonnet', tier: 'execute' }, rt);
-      assert.ok(result._error, `Expected _error, got: ${JSON.stringify(result)}`);
-      assert.ok(result._error.includes('No AI CLI available'), `Unexpected error: ${result._error}`);
-    });
-
-    it('falls back to openai when claude is unavailable but codex is', () => {
-      const rt = { claudeAvailable: false, codexAvailable: true };
-      const result = validateDispatch({ provider: 'claude', model: 'sonnet', tier: 'execute' }, rt);
-      assert.ok(!result._error, `Unexpected error: ${result._error}`);
-      assert.equal(result.provider, 'openai', `Expected openai fallback, got: ${result.provider}`);
-    });
-
-    it('falls back to claude when openai is unavailable but claude is', () => {
-      const rt = { claudeAvailable: true, codexAvailable: false };
-      const result = validateDispatch({ provider: 'openai', model: 'o4-mini', tier: 'execute' }, rt);
-      assert.ok(!result._error, `Unexpected error: ${result._error}`);
-      assert.equal(result.provider, 'claude', `Expected claude fallback, got: ${result.provider}`);
-    });
-
-    it('keeps original decision when both CLIs available and model is valid', () => {
-      const rt = { claudeAvailable: true, codexAvailable: true };
-      const result = validateDispatch({ provider: 'claude', model: 'sonnet', tier: 'execute' }, rt);
-      assert.ok(!result._error);
-      assert.equal(result.provider, 'claude');
-      assert.equal(result.model, 'sonnet');
-    });
-
-    it('resets invalid claude model to sonnet for execute tier', () => {
-      const rt = { claudeAvailable: true, codexAvailable: false };
-      const result = validateDispatch({ provider: 'claude', model: 'gpt-5.5', tier: 'execute' }, rt);
-      assert.ok(!result._error);
-      assert.equal(result.model, 'sonnet', `Expected sonnet fallback, got: ${result.model}`);
-    });
-
-    it('resets invalid claude model to haiku for search tier', () => {
-      const rt = { claudeAvailable: true, codexAvailable: false };
-      const result = validateDispatch({ provider: 'claude', model: 'gpt-4.1', tier: 'search' }, rt);
-      assert.ok(!result._error);
-      assert.equal(result.model, 'haiku', `Expected haiku fallback for search tier, got: ${result.model}`);
-    });
-
-    it('resets invalid openai model to o4-mini', () => {
-      const rt = { claudeAvailable: false, codexAvailable: true };
-      const result = validateDispatch({ provider: 'openai', model: 'bogus-model', tier: 'execute' }, rt);
-      assert.ok(!result._error);
-      assert.equal(result.model, 'o4-mini', `Expected o4-mini fallback, got: ${result.model}`);
-    });
-
-    it('valid openai models pass through unchanged', () => {
-      const rt = { claudeAvailable: true, codexAvailable: true };
-      for (const m of ['o4-mini', 'o3', 'gpt-4.1']) {
-        const result = validateDispatch({ provider: 'openai', model: m, tier: 'execute' }, rt);
-        assert.ok(!result._error, `Unexpected error for model ${m}`);
-        assert.equal(result.model, m, `Model changed unexpectedly: ${result.model}`);
-      }
-    });
-
-    it('valid claude models pass through unchanged', () => {
-      const rt = { claudeAvailable: true, codexAvailable: true };
-      for (const m of ['opus', 'sonnet', 'haiku']) {
-        const result = validateDispatch({ provider: 'claude', model: m, tier: 'execute' }, rt);
-        assert.ok(!result._error, `Unexpected error for model ${m}`);
-        assert.equal(result.model, m, `Model changed unexpectedly: ${result.model}`);
-      }
-    });
-  });
-
-  // ── Feature 2: checkWorktreeClean ──────────────────────────────────────────
-  describe('checkWorktreeClean', () => {
-    it('returns safe:true when owns is empty', async () => {
-      const result = await checkWorktreeClean([], process.cwd());
-      assert.deepEqual(result, { safe: true });
-    });
-
-    it('returns safe:true when owns is undefined', async () => {
-      const result = await checkWorktreeClean(undefined, process.cwd());
-      assert.deepEqual(result, { safe: true });
-    });
-
-    it('_globMatch: dir/* prefix pattern', () => {
-      // Test the glob logic indirectly via checkWorktreeClean with a tmp git repo
-      // We test the building-block function via the module internals instead,
-      // using a clean git repo (no dirty files) to verify the guard is skipped.
-      // In CI the workspace may have dirty files but not in src/noexist/ prefix.
-    });
-
-    it('returns safe:true for non-overlapping owns patterns (dir that does not exist dirty)', async () => {
-      // If there are no dirty files matching 'src/totally-fake-dir/*', should be safe
-      const result = await checkWorktreeClean(['src/totally-fake-dir/*'], process.cwd());
-      assert.equal(result.safe, true, `Expected safe:true for non-overlapping pattern`);
-    });
-
-    it('detects conflict when dirty file matches exact path', async () => {
-      // Create a temp git repo with a dirty file to simulate a conflict
-      const tmp = join(tmpdir(), `wt-test-${Date.now()}`);
-      mkdirSync(tmp, { recursive: true });
-      try {
-        // Initialize a git repo
-        await new Promise((res) => {
-          const p = spawn('git', ['init'], { cwd: tmp, stdio: 'ignore' });
-          p.on('close', res);
-        });
-        await new Promise((res) => {
-          const p = spawn('git', ['config', 'user.email', 'test@test.com'], { cwd: tmp, stdio: 'ignore' });
-          p.on('close', res);
-        });
-        await new Promise((res) => {
-          const p = spawn('git', ['config', 'user.name', 'Test'], { cwd: tmp, stdio: 'ignore' });
-          p.on('close', res);
-        });
-        // Create a dirty (untracked) file
-        const { writeFileSync: wfs } = await import('node:fs');
-        wfs(join(tmp, 'dirty.mjs'), '// dirty');
-        const result = await checkWorktreeClean(['dirty.mjs'], tmp);
-        assert.equal(result.safe, false, `Expected safe:false, got: ${JSON.stringify(result)}`);
-        assert.ok(result.conflicts.includes('dirty.mjs'), `Expected dirty.mjs in conflicts: ${result.conflicts}`);
-      } finally {
-        rmSync(tmp, { recursive: true, force: true });
-      }
-    });
-
-    it('detects conflict via *.ext glob pattern', async () => {
-      const tmp = join(tmpdir(), `wt-test-ext-${Date.now()}`);
-      mkdirSync(tmp, { recursive: true });
-      try {
-        await new Promise((res) => {
-          const p = spawn('git', ['init'], { cwd: tmp, stdio: 'ignore' });
-          p.on('close', res);
-        });
-        const { writeFileSync: wfs } = await import('node:fs');
-        wfs(join(tmp, 'something.mjs'), '// dirty');
-        const result = await checkWorktreeClean(['*.mjs'], tmp);
-        assert.equal(result.safe, false, `Expected conflict from *.mjs pattern`);
-        assert.ok(result.conflicts.some(f => f.endsWith('.mjs')), `Expected .mjs conflict: ${result.conflicts}`);
-      } finally {
-        rmSync(tmp, { recursive: true, force: true });
-      }
-    });
-
-    it('detects conflict via dir/* prefix pattern', async () => {
-      const tmp = join(tmpdir(), `wt-test-dir-${Date.now()}`);
-      mkdirSync(tmp, { recursive: true });
-      try {
-        await new Promise((res) => {
-          const p = spawn('git', ['init'], { cwd: tmp, stdio: 'ignore' });
-          p.on('close', res);
-        });
-        const { writeFileSync: wfs } = await import('node:fs');
-        mkdirSync(join(tmp, 'src', 'auth'), { recursive: true });
-        wfs(join(tmp, 'src', 'auth', 'token.mjs'), '// dirty');
-        const result = await checkWorktreeClean(['src/auth/*'], tmp);
-        assert.equal(result.safe, false, `Expected conflict from src/auth/* pattern`);
-        assert.ok(result.conflicts.some(f => f.startsWith('src/auth/')), `Expected src/auth/ conflict: ${result.conflicts}`);
-      } finally {
-        rmSync(tmp, { recursive: true, force: true });
-      }
-    });
-  });
-
-  // ── Feature 3: getRetryBudget ──────────────────────────────────────────────
-  describe('getRetryBudget', () => {
-    it('returns expected shape', () => {
-      const budget = getRetryBudget();
-      assert.ok(typeof budget === 'object' && budget !== null);
-      assert.ok('perTaskRetries'   in budget, 'missing perTaskRetries');
-      assert.ok('recentDispatches' in budget, 'missing recentDispatches');
-      assert.ok('windowMs'         in budget, 'missing windowMs');
-      assert.ok('maxPerTask'       in budget, 'missing maxPerTask');
-      assert.ok('maxPerWindow'     in budget, 'missing maxPerWindow');
-      assert.equal(budget.maxPerTask,   2);
-      assert.equal(budget.maxPerWindow, 5);
-      assert.equal(budget.windowMs,     5 * 60 * 1000);
-    });
-
-    it('recentDispatches is a non-negative integer', () => {
-      const budget = getRetryBudget();
-      assert.ok(Number.isInteger(budget.recentDispatches));
-      assert.ok(budget.recentDispatches >= 0);
-    });
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// CLI DRY-RUN SMOKE TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe('CLI', () => {
-  it('init writes profile to disk', async () => {
-    // The bug was that saveProfile was never called in cmdInit.
-    // Supply answers via stdin so runOnboarding completes: choose Claude-only,
-    // $20 plan, balanced optimization.
-    const tmp = makeTmp();
-    try {
-      const { code, stdout, stderr } = await new Promise((resolve) => {
-        const proc = spawn(process.execPath, [BIN, 'init'], {
-          stdio: ['pipe', 'pipe', 'pipe'],
-          cwd: tmp,
-        });
-        let out = '', err = '';
-        proc.stdout.on('data', d => { out += d; });
-        proc.stderr.on('data', d => { err += d; });
-        proc.on('close', exitCode => resolve({ code: exitCode, stdout: out, stderr: err }));
-        // Send answers with small delays so readline receives each line before stdin ends.
-        // Q1: Claude only, Q2: $20 plan, Q3: balanced
-        setTimeout(() => proc.stdin.write('1\n'), 50);
-        setTimeout(() => proc.stdin.write('1\n'), 200);
-        setTimeout(() => proc.stdin.write('2\n'), 350);
-        setTimeout(() => proc.stdin.end(), 500);
-      });
-      const profileFile = join(tmp, '.dualbrain', 'profile.json');
-      assert.ok(
-        existsSync(profileFile),
-        `Profile file not created at ${profileFile} (exit ${code})\nstdout:${stdout}\nstderr:${stderr}`,
-      );
-      const saved = JSON.parse(readFileSync(profileFile, 'utf8'));
-      assert.equal(saved.schemaVersion, 1);
-      assert.equal(saved.providers.claude.enabled, true);
-    } finally {
-      removeTmp(tmp);
-    }
-  });
-
-  it('--help exits 0', async () => {
-    const { code, stdout } = await run([BIN, '--help']);
-    assert.equal(code, 0, `Expected exit 0, got ${code}`);
-    assert.ok(stdout.length > 0, 'Expected some help output');
-    assert.ok(stdout.toLowerCase().includes('dual-brain') || stdout.includes('go'), `Help text missing: ${stdout.slice(0, 200)}`);
-  });
-
-  it('--version exits 0 and prints package.json version', async () => {
-    const { code, stdout } = await run([BIN, '--version']);
-    assert.equal(code, 0, `Expected exit 0, got ${code}`);
-    const expectedVersion = JSON.parse(readFileSync(PKG, 'utf8')).version;
-    assert.ok(stdout.trim().includes(expectedVersion), `Expected version ${expectedVersion}, got: ${stdout.trim()}`);
-  });
-
-  it('go --dry-run "fix a bug" exits 0 and prints routing info', async () => {
-    const { code, stdout, stderr } = await run([BIN, 'go', '--dry-run', 'fix a bug'], {
-      timeout: 15_000,
-    });
-    // Should not crash — even without a profile file it falls back to defaults
-    assert.ok([0, 1].includes(code), `Unexpected exit code ${code}\nstdout: ${stdout}\nstderr: ${stderr}`);
-    // If it succeeded, verify routing output
-    if (code === 0) {
-      const combined = stdout + stderr;
-      assert.ok(
-        combined.includes('provider') || combined.includes('dry-run') || combined.includes('model'),
-        `Expected routing info in output:\n${combined.slice(0, 500)}`,
-      );
-    }
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// INTEGRATION: FULL PIPELINE
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe('integration: full pipeline', () => {
-
-  // Shared dual-provider profile used by several tests
-  const dualProfile = {
-    schemaVersion: 1,
-    providers: {
-      claude: { plan: '$100', enabled: true },
-      openai: { plan: '$100', enabled: true },
-    },
-    mode: 'dual',
-    bias: 'balanced',
-    preferences: [],
-  };
-
-  // Solo-claude profile (no openai)
-  const soloProfile = {
-    schemaVersion: 1,
-    providers: {
-      claude: { plan: '$100', enabled: true },
-      openai: { plan: '$20', enabled: false },
-    },
-    mode: 'auto',
-    bias: 'balanced',
-    preferences: [],
-  };
-
-  // ── Test 1: simple edit routes to sonnet and dispatches ────────────────────
-  it('simple edit routes to sonnet and dispatches', () => {
-    // Deliberately avoid keywords that trigger higher-priority intents (document, security, etc.)
-    const prompt = 'fix the button label in the settings page';
-
-    // Detect
-    const detection = detectTask({ prompt });
-    assert.equal(detection.intent, 'edit', `Expected intent:edit, got: ${detection.intent}`);
-    assert.ok(['low', 'medium'].includes(detection.risk), `Unexpected risk: ${detection.risk}`);
-    assert.equal(detection.tier, 'execute', `Expected tier:execute, got: ${detection.tier}`);
-
-    // Decide
-    const decision = decideRoute({ profile: soloProfile, detection });
-    // Simple edit on solo-claude $100 should stay with claude
-    assert.equal(decision.provider, 'claude', `Expected claude, got: ${decision.provider}`);
-    // Should pick sonnet (or haiku) — not opus — for a trivial/simple edit
-    assert.ok(['sonnet', 'haiku'].includes(decision.model),
-      `Expected sonnet or haiku for simple edit, got: ${decision.model}`);
-    assert.equal(decision.tier, 'execute', `Expected tier:execute, got: ${decision.tier}`);
-    assert.equal(decision.dualBrain, false, `Expected dualBrain:false, got: ${decision.dualBrain}`);
-
-    // Verify buildCommand produces a valid claude command (no real subprocess spawned)
-    const cmd = buildCommand(decision, prompt);
-    assert.equal(cmd[0], 'claude', `Expected claude CLI command, got: ${cmd[0]}`);
-    assert.ok(cmd.includes('-p'), 'Expected -p flag in command');
-    assert.ok(cmd.includes(prompt), 'Expected prompt in command');
-  });
-
-  // ── Test 2: security task routes to think tier with dual-brain ─────────────
-  it('security task routes to think tier with dual-brain', () => {
-    const prompt = 'audit authentication security';
-
-    // Detect
-    const detection = detectTask({ prompt });
-    assert.equal(detection.intent, 'security',
-      `Expected intent:security, got: ${detection.intent}`);
-    assert.equal(detection.tier, 'think',
-      `Expected tier:think for security, got: ${detection.tier}`);
-
-    // Decide with dual-provider profile
-    const decision = decideRoute({ profile: dualProfile, detection });
-    assert.equal(decision.tier, 'think', `Expected tier:think in decision, got: ${decision.tier}`);
-    // Dual-provider + security intent → dualBrain should be true
-    assert.equal(decision.dualBrain, true,
-      `Expected dualBrain:true for security task with dual profile, got: ${decision.dualBrain}`);
-  });
-
-  // ── Test 3: cost-saver bias downgrades model ───────────────────────────────
-  it('cost-saver bias downgrades model', () => {
-    const prompt = 'refactor the utils module';
-    const costSaverProfile = {
-      ...soloProfile,
-      mode: 'cost-saver',
-      bias: 'cost-saver',
-    };
-
-    const detection = detectTask({ prompt });
-    const decision = decideRoute({ profile: costSaverProfile, detection });
-
-    // cost-saver should prefer the cheapest model: haiku or sonnet, never opus
-    assert.ok(['haiku', 'sonnet'].includes(decision.model),
-      `Expected haiku or sonnet for cost-saver mode, got: ${decision.model}`);
-    assert.notEqual(decision.model, 'opus',
-      `cost-saver should not route to opus, got: ${decision.model}`);
-  });
-
-  // ── Test 4: hot provider triggers fallback ─────────────────────────────────
-  it('hot provider triggers fallback', async () => {
-    const tmp = makeTmp();
-    try {
-      // Mark claude as hot in the temp dir's health file
-      markHot('claude', 'sonnet', tmp);
-
-      const detection = detectTask({ prompt: 'update the settings component' });
-      assert.equal(detection.tier, 'execute', `Pre-condition: expected execute tier`);
-
-      const decision = decideRoute({ profile: dualProfile, detection, cwd: tmp });
-
-      // Claude is hot (score=0) and openai is healthy → should route to openai
-      assert.equal(decision.provider, 'openai',
-        `Expected openai fallback when claude is hot, got: ${decision.provider}`);
-    } finally {
-      // Clean up: restore claude to healthy
-      markHealthy('claude', 'sonnet', tmp);
-      removeTmp(tmp);
-    }
-  });
-
-  // ── Test 5: redaction happens before dispatch args ──────────────────────────
-  it('redaction happens before dispatch args', () => {
-    const rawPrompt = 'use API_KEY=sk-secret123 to authenticate';
-
-    const redacted = redact(rawPrompt);
-
-    // The secret value must not appear in the redacted output
-    assert.ok(!redacted.includes('sk-secret123'),
-      `Secret value must be redacted, got: ${redacted}`);
-    // The placeholder must be present instead
-    assert.ok(redacted.includes('[REDACTED]'),
-      `Expected [REDACTED] in output, got: ${redacted}`);
-
-    // Verify buildCommand also gets the safe prompt (as dispatch() applies redact before build)
-    const decision = { provider: 'claude', model: 'sonnet', tier: 'execute', effort: null, sandbox: 'workspace-write' };
-    const cmd = buildCommand(decision, redacted);
-    assert.ok(!cmd.join(' ').includes('sk-secret123'),
-      `Secret must not appear in CLI args: ${cmd.join(' ')}`);
-  });
-
-  // ── Test 6: decompose splits complex task ───────────────────────────────────
-  it('decompose splits complex task', () => {
-    const prompt = 'refactor auth module and add tests for it';
-
-    const result = decompose(prompt);
-
-    assert.ok(result.tasks.length > 1,
-      `Expected multiple tasks from compound prompt, got: ${result.tasks.length}`);
-    assert.ok(result.waves.length > 1,
-      `Expected multiple waves for compound task, got: ${result.waves.length}`);
-
-    // At least one task should have role='researcher' or 'implementer' or 'verifier'
-    const validRoles = ['researcher', 'implementer', 'reviewer', 'verifier'];
-    const allRolesValid = result.tasks.every(t => validRoles.includes(t.role));
-    assert.ok(allRolesValid,
-      `All tasks must have valid roles, got: ${result.tasks.map(t => t.role).join(', ')}`);
-
-    const hasSearchableRole = result.tasks.some(t =>
-      ['researcher', 'implementer'].includes(t.role)
-    );
-    assert.ok(hasSearchableRole,
-      `Expected at least one task with role researcher or implementer, got: ${result.tasks.map(t => t.role).join(', ')}`);
-  });
-
-  // ── Test 7: session card formats correctly ──────────────────────────────────
-  it('session card formats correctly', () => {
-    const repo = {
-      name: 'my-test-project',
-      type: 'node',
-      packageManager: 'npm',
-      branch: 'main',
-      dirty: false,
-      commands: { test: 'jest --coverage', build: null, lint: null },
-    };
-    const health = { states: {}, session: null };
-
-    const card = formatSessionCard(null, repo, health);
-
-    assert.ok(typeof card === 'string' && card.length > 0, 'Expected non-empty string');
-    assert.ok(card.includes('dual-brain ready'),
-      `Expected "dual-brain ready" in card, got:\n${card}`);
-    assert.ok(card.includes('my-test-project'),
-      `Expected repo name in card, got:\n${card}`);
-  });
-
-  // ── Test 8: playbook loads for matching intent ──────────────────────────────
-  it('playbook loads for matching intent', () => {
-    const playbook = loadPlaybook('security');
-
-    assert.ok(playbook !== null, 'Expected non-null playbook for "security" intent');
-    assert.ok(Array.isArray(playbook.steps),
-      `Expected steps array, got: ${typeof playbook.steps}`);
-    assert.ok(playbook.steps.length > 0,
-      `Expected at least one step, got: ${playbook.steps.length}`);
-
-    // Each step should have an id and tier
-    for (const step of playbook.steps) {
-      assert.ok(typeof step.id === 'string' && step.id.length > 0,
-        `Each step must have a string id, got: ${JSON.stringify(step)}`);
-      assert.ok(['search', 'execute', 'think'].includes(step.tier),
-        `Step tier must be search/execute/think, got: ${step.tier}`);
-    }
-  });
-});