dual-brain 7.1.15 → 7.1.16

package/bin/dual-brain.mjs

@@ -391,27 +391,6 @@ async function cmdGo(args) {
     }, cwd);
   } else {
     result = await dispatch({ decision, prompt, files, cwd });
-    if (result.status === 'completed' && result.type === 'native-agent') {
-      const nd = result.nativeDispatch || {};
-      const promptPreview = (nd.prompt || prompt).slice(0, 100);
-      const promptSuffix  = (nd.prompt || prompt).length > 100 ? '...' : '';
-      console.log(`\nRouted: ${decision.provider}/${nd.model || decision.model} (${decision.tier})`);
-      console.log('To dispatch, use the Agent tool with:');
-      console.log(`  model: ${nd.model || decision.model}`);
-      console.log(`  prompt: ${promptPreview}${promptSuffix}`);
-      if (nd.isolation)  console.log(`  isolation: ${nd.isolation}`);
-      if (nd.maxTurns)   console.log(`  maxTurns: ${nd.maxTurns}`);
-      saveSession({
-        objective:    prompt,
-        branch:       null,
-        filesChanged: files,
-        commandsRun:  [`dual-brain go "${prompt}"`],
-        lastResult:   { status: 'success', summary: `native-agent routed to ${nd.model || decision.model}` },
-        provider:     decision.provider,
-        nextAction:   null,
-      }, cwd);
-      return;
-    }
     const statusLine = result.status === 'completed' ? 'Done' : `Failed (exit ${result.exitCode})`;
     console.log(`\n${statusLine} in ${(result.durationMs / 1000).toFixed(1)}s`);
     if (result.summary) console.log(result.summary);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "7.1.15",
+  "version": "7.1.16",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -38,7 +38,7 @@
     "url": "https://github.com/1xmint/dual-brain.git"
   },
   "scripts": {
-    "test": "node hooks/test-orchestrator.mjs",
+    "test": "node .claude/hooks/test-orchestrator.mjs",
     "test:core": "node --test src/test.mjs",
     "postinstall": "echo 'dual-brain installed. Run: dual-brain install (in your project) to set up hooks.'"
   },

package/src/decide.mjs

@@ -71,49 +71,31 @@ const MODEL_CAPABILITIES = {
     effortLevels: ['low', 'medium', 'high'],
     costTier: 'medium',
   },
-  'gpt-5.2': {
+  'gpt-4o': {
     provider: 'openai',
-    tierFit: ['search', 'execute'],
-    contextWindow: 200_000,
+    tierFit: ['execute', 'think'],
+    contextWindow: 128_000,
+    strengths: ['refactor', 'debug', 'code-generation', 'test', 'multimodal'],
+    weaknesses: ['cost vs mini'],
+    effortLevels: ['low', 'medium', 'high'],
     costTier: 'medium',
-    strengths: ['code-generation', 'analysis'],
-    weaknesses: [],
-    effortLevels: null,
   },
-  'gpt-5.4-mini': {
+  'gpt-4o-mini': {
     provider: 'openai',
     tierFit: ['search'],
-    contextWindow: 200_000,
-    costTier: 'low',
-    strengths: ['quick-tasks', 'search'],
+    contextWindow: 128_000,
+    costTier: 'cheap',
+    strengths: ['quick-tasks', 'search', 'classification'],
     weaknesses: ['complex-edits', 'architecture'],
     effortLevels: null,
   },
-  'gpt-5.3-codex': {
-    provider: 'openai',
-    tierFit: ['execute'],
-    contextWindow: 200_000,
-    costTier: 'medium',
-    strengths: ['code-generation', 'refactoring'],
-    weaknesses: ['architecture', 'security'],
-    effortLevels: null,
-  },
-  'gpt-5.4': {
-    provider: 'openai',
-    tierFit: ['execute', 'think'],
-    contextWindow: 1_050_000,
-    strengths: ['refactor', 'debug', 'code-generation', 'test'],
-    weaknesses: ['cost'],
-    effortLevels: ['low', 'medium', 'high', 'xhigh'],
-    costTier: 'medium',
-  },
-  'gpt-5.5': {
+  'o3': {
     provider: 'openai',
     tierFit: ['think'],
-    contextWindow: 1_000_000,
-    strengths: ['architecture', 'security', 'review', 'planning', 'complex-debug'],
+    contextWindow: 200_000,
+    strengths: ['architecture', 'security', 'review', 'planning', 'complex-debug', 'deep-reasoning'],
     weaknesses: ['cost', 'latency'],
-    effortLevels: ['low', 'medium', 'high', 'xhigh'],
+    effortLevels: ['low', 'medium', 'high'],
     costTier: 'expensive',
   },
 };
@@ -127,9 +109,9 @@ const CLAUDE_MODELS_BY_PLAN = {
 };
 
 const OPENAI_MODELS_BY_PLAN = {
-  '$20':  ['gpt-4.1-mini', 'gpt-4.1', 'gpt-5.2', 'gpt-5.4-mini'],
-  '$100': ['gpt-4.1-mini', 'gpt-4.1', 'gpt-5.2', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.4', 'gpt-5.5'],
-  '$200': ['gpt-4.1-mini', 'gpt-4.1', 'gpt-5.2', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.4', 'gpt-5.5'],
+  '$20':  ['gpt-4o-mini', 'gpt-4.1-mini', 'gpt-4.1', 'gpt-4o'],
+  '$100': ['gpt-4o-mini', 'gpt-4.1-mini', 'gpt-4.1', 'gpt-4o', 'o4-mini', 'o3'],
+  '$200': ['gpt-4o-mini', 'gpt-4.1-mini', 'gpt-4.1', 'gpt-4o', 'o4-mini', 'o3'],
 };
 
 // Token fallback estimates per tier (no real usage data)
@@ -188,9 +170,9 @@ function getHealthScores(tier, cwd) {
   const claudeClass = tier === 'search' ? 'haiku'
     : tier === 'think' ? 'opus'
     : 'sonnet';
-  const openaiClass = tier === 'search' ? 'gpt-4.1-mini'
-    : tier === 'think' ? 'gpt-5.5'
-    : 'gpt-5.4';
+  const openaiClass = tier === 'search' ? 'gpt-4o-mini'
+    : tier === 'think' ? 'o3'
+    : 'gpt-4o';
 
   // Trigger cooldown expiry check (transitions hot→probing automatically)
   checkCooldown('claude', claudeClass, cwd);
@@ -208,26 +190,35 @@ function getHealthScores(tier, cwd) {
  * Return true if both providers should analyze this task.
  * Requires: (critical risk OR architecture/security intent OR complex+high-risk)
  * AND profile has both providers available with dual mode enabled.
- * @param {{ intent?: string, risk?: string, complexity?: string }} detection
+ *
+ * designImpact bypasses the hasBothProviders check — it is a mandatory review
+ * gate, not optional collaboration. When only one provider is available the
+ * caller should check degradedDualBrain on the decision output.
+ * @param {{ intent?: string, risk?: string, complexity?: string, designImpact?: boolean }} detection
  * @param {object} profile
  * @returns {boolean}
  */
 export function shouldDualBrain(detection, profile) {
   const { intent = '', risk = 'low', complexity = 'simple', designImpact = false } = detection;
   const dualEnabled = profile?.dual_brain_enabled !== false;
+  if (!dualEnabled) return false;
+
   const hasBothProviders = !!(
     profile?.providers?.claude?.enabled &&
     profile?.providers?.claude?.plan &&
     profile?.providers?.openai?.enabled &&
     profile?.providers?.openai?.plan
   );
-  if (!dualEnabled || !hasBothProviders) return false;
 
-  const criticalRisk      = risk === 'critical';
-  const archOrSecurity    = ['architecture', 'security'].includes(intent);
-  const complexHighRisk   = complexity === 'complex' && risk === 'high';
+  if (designImpact) return true;
+
+  if (!hasBothProviders) return false;
+
+  const criticalRisk    = risk === 'critical';
+  const archOrSecurity  = ['architecture', 'security'].includes(intent);
+  const complexHighRisk = complexity === 'complex' && risk === 'high';
 
-  return criticalRisk || archOrSecurity || complexHighRisk || designImpact;
+  return criticalRisk || archOrSecurity || complexHighRisk;
 }
 
 // ─── Internal: select model for provider ─────────────────────────────────────
@@ -251,18 +242,18 @@ function pickOpenAIModel(detection, available) {
   const needsMini   = SEARCH_INTENTS.includes(intent) && effort === 'low';
   const needsCodex  = ['refactor', 'debug'].includes(intent) && complexity !== 'trivial';
 
-  const pref = needsTop    ? 'gpt-5.5'
-             : needsMini   ? 'gpt-4.1-mini'
-             : needsCodex  ? 'gpt-5.3-codex'
-             : 'gpt-5.4';
+  const pref = needsTop    ? 'o3'
+             : needsMini   ? 'gpt-4o-mini'
+             : needsCodex  ? 'gpt-4o'
+             : 'gpt-4o';
 
   // Walk down rank until we find an available model
-  const rank = ['gpt-4.1-mini', 'gpt-4.1', 'gpt-5.2', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.4', 'gpt-5.5'];
+  const rank = ['gpt-4o-mini', 'gpt-4.1-mini', 'gpt-4.1', 'gpt-4o', 'o4-mini', 'o3'];
   const idx = rank.indexOf(pref);
   for (let i = idx; i >= 0; i--) {
     if (available.includes(rank[i])) return rank[i];
   }
-  return available[0] ?? 'gpt-4.1-mini';
+  return available[0] ?? 'gpt-4o-mini';
 }
 
 function applyHealthDowngrade(model, score, provider, available, isHighStakes) {
@@ -280,14 +271,14 @@ function applyHealthDowngrade(model, score, provider, available, isHighStakes) {
     }
     return available[0] ?? 'haiku';
   } else {
-    const oaiRank = ['gpt-4.1-mini', 'gpt-4.1', 'gpt-5.2', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.4', 'gpt-5.5'];
+    const oaiRank = ['gpt-4o-mini', 'gpt-4.1-mini', 'gpt-4.1', 'gpt-4o', 'o4-mini', 'o3'];
     const idx = oaiRank.indexOf(model);
     const steps = score === 0 ? 2 : 1;
     const downIdx = Math.max(0, idx - steps);
     for (let i = downIdx; i <= idx; i++) {
       if (available.includes(oaiRank[i])) return oaiRank[i];
     }
-    return available[0] ?? 'gpt-4.1-mini';
+    return available[0] ?? 'gpt-4o-mini';
   }
 }
 
@@ -297,7 +288,7 @@ function applyProfileBias(model, profile, provider, available, tier) {
     // Prefer cheapest available that also fits the required tier
     const ranks = {
       claude: ['haiku', 'sonnet', 'opus'],
-      openai: ['gpt-4.1-mini', 'gpt-4.1', 'gpt-5.2', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.4', 'gpt-5.5'],
+      openai: ['gpt-4o-mini', 'gpt-4.1-mini', 'gpt-4.1', 'gpt-4o', 'o4-mini', 'o3'],
     };
     for (const m of ranks[provider]) {
       if (!available.includes(m)) continue;
@@ -310,7 +301,7 @@ function applyProfileBias(model, profile, provider, available, tier) {
     // Prefer best available, keep current if already best
     const ranks = {
       claude: ['opus', 'sonnet', 'haiku'],
-      openai: ['gpt-5.5', 'gpt-5.4', 'gpt-5.3-codex', 'gpt-5.4-mini', 'gpt-5.2', 'gpt-4.1', 'gpt-4.1-mini'],
+      openai: ['o3', 'o4-mini', 'gpt-4o', 'gpt-4.1', 'gpt-4.1-mini', 'gpt-4o-mini'],
     };
     for (const m of ranks[provider]) {
       if (available.includes(m)) return m;
@@ -341,7 +332,7 @@ function pickEffort(model, detection) {
 function pickModes(model, detection) {
   const { intent = '', complexity = 'simple' } = detection;
   const caps = MODEL_CAPABILITIES[model] ?? {};
-  const thinkingModels = ['sonnet', 'opus', 'gpt-5.5', 'gpt-5.4'];
+  const thinkingModels = ['sonnet', 'opus', 'o3', 'gpt-4o'];
   const lightIntents   = ['search', 'format', 'explain', 'lookup'];
 
   return {
@@ -350,7 +341,7 @@ function pickModes(model, detection) {
       && !lightIntents.includes(intent),
     fastMode:         model === 'opus',
     extendedContext:  ['sonnet', 'opus'].includes(model),
-    webSearch:        ['gpt-4.1-mini', 'gpt-4.1', 'gpt-5.4-mini'].includes(model),
+    webSearch:        ['gpt-4o-mini', 'gpt-4.1-mini', 'gpt-4.1', 'gpt-4o'].includes(model),
   };
 }
 
@@ -583,12 +574,21 @@ export function decideRoute({ profile = {}, detection = {}, cwd } = {}) {
   const modes   = pickModes(model, detection);
   const sandbox = pickSandbox(model, detection);
 
+  const hasBothProviders = !!(
+    profile?.providers?.claude?.enabled &&
+    profile?.providers?.claude?.plan &&
+    profile?.providers?.openai?.enabled &&
+    profile?.providers?.openai?.plan
+  );
+  const degradedDualBrain = !!(dual && detection.designImpact && !hasBothProviders);
+
   const decision = {
     provider,
     model,
     effort,
     tier,
     dualBrain: dual,
+    ...(degradedDualBrain && { degradedDualBrain: true }),
     modes,
     sandbox,
     explanation: '',

package/src/dispatch.mjs

@@ -18,7 +18,7 @@ import { redact } from './redact.mjs';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const USAGE_DIR = join(__dirname, '..', '.dualbrain', 'usage');
 const TIER_TIMEOUT_MS = { search: 60_000, execute: 120_000, think: 180_000 };
-const CLAUDE_MODEL_IDS = { opus: 'claude-opus-4-5', sonnet: 'claude-sonnet-4-5', haiku: 'claude-haiku-4-5' };
+const CLAUDE_MODEL_IDS = { opus: 'claude-opus-4-6', sonnet: 'claude-sonnet-4-6', haiku: 'claude-haiku-4-5-20251001' };
 
 // ─── Median dispatch time tracker (in-process, for slow-response detection) ──
 // Rolling window of recent dispatch durations keyed by "provider:modelClass"
@@ -272,7 +272,7 @@ async function detectRuntime() {
 /** Valid CLI model flags per provider */
 const VALID_MODELS = {
   claude: ['opus', 'sonnet', 'haiku'],
-  openai: ['o4-mini', 'o3', 'gpt-4.1', 'gpt-4.1-mini', 'gpt-5.2', 'gpt-5.3-codex', 'gpt-5.3-codex-spark', 'gpt-5.4-mini', 'gpt-5.4', 'gpt-5.5'],
+  openai: ['o4-mini', 'o3', 'o1', 'o1-mini', 'gpt-4o', 'gpt-4o-mini', 'gpt-4.1', 'gpt-4.1-mini', 'gpt-4-turbo'],
 };
 
 /** Safest default model for a given provider + tier */
@@ -507,14 +507,15 @@ function compressResult(rawOutput = '', maxLength = 300) {
 }
 
 // ─── Core runner ──────────────────────────────────────────────────────────────
-function runProcess(cmd, cwd, timeoutMs) {
+function runProcess(cmd, cwd, timeoutMs, env) {
   return new Promise((resolve) => {
     const [bin, ...args] = cmd;
     const start = Date.now();
     let stdout = '';
     let stderr = '';
 
-    const proc = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    const spawnEnv = env ? { ...process.env, ...env } : undefined;
+    const proc = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], ...(spawnEnv ? { env: spawnEnv } : {}) });
 
     proc.stdout.on('data', (d) => { stdout += d; });
     proc.stderr.on('data', (d) => { stderr += d; });
@@ -633,31 +634,91 @@ async function dispatch(input = {}) {
   }
 
   // ── Native Claude Code dispatch ──────────────────────────────────────────────
-  // When running inside Claude Code AND the provider is claude, return a
-  // structured native-agent descriptor instead of spawning a subprocess.
-  // The caller (CLI or plugin) is responsible for actually invoking the Agent tool.
+  // When running inside Claude Code AND the provider is claude, execute via the
+  // claude CLI directly (foreground subprocess) so results are captured and returned.
+  // DUAL_BRAIN_DISPATCH=1 is set so the enforce-tier hook allows this agent call.
   if (isInsideClaude() && effectiveProvider === 'claude') {
     const nativeDescriptor = buildNativeDispatch(
       effectiveDecision,
       prompt,
       { worktree: input.worktree, maxTurns: input.maxTurns },
     );
+
+    const command = buildCommand(effectiveDecision, prompt, files, cwd);
+
     if (dryRun) {
-      return { status: 'dry-run', provider: effectiveProvider, model: effectiveModel, command: null, nativeDispatch: nativeDescriptor, exitCode: null, summary: null, durationMs: 0, usage: null, error: null };
+      return {
+        status:        'dry-run',
+        provider:      effectiveProvider,
+        model:         effectiveModel,
+        command,
+        nativeDispatch: nativeDescriptor,
+        exitCode:      null,
+        summary:       null,
+        durationMs:    0,
+        usage:         null,
+        error:         null,
+      };
     }
+
     _recordDispatchBudget(prompt);
+
+    const dispatchEnv = { DUAL_BRAIN_DISPATCH: '1' };
+    const { exitCode, stdout, stderr, durationMs } = await runProcess(command, cwd, timeoutMs, dispatchEnv);
+
+    // Extract token usage from JSON output if available
+    let usage = null;
+    try {
+      const parsed = JSON.parse(stdout);
+      if (parsed?.usage) {
+        usage = { inputTokens: parsed.usage.input_tokens ?? 0, outputTokens: parsed.usage.output_tokens ?? 0 };
+      }
+    } catch {}
+
+    const success = exitCode === 0;
+    const errorText = (stderr || stdout).slice(0, 500);
+    const summary = success ? compressResult(stdout) : compressResult(stderr || stdout);
+
+    // ── Health tracking ────────────────────────────────────────────────────
+    if (success) {
+      recordDuration(effectiveProvider, effectiveModel, durationMs);
+      const median = medianDuration(effectiveProvider, effectiveModel);
+      if (median !== null && durationMs > median * 3) {
+        markDegraded(effectiveProvider, effectiveModel, cwd);
+      } else {
+        markHealthy(effectiveProvider, effectiveModel, cwd);
+      }
+      const totalTokens = (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0);
+      recordDispatch(effectiveProvider, effectiveModel, totalTokens, cwd);
+    } else {
+      if (RATE_LIMIT_PATTERNS.test(errorText)) {
+        markHot(effectiveProvider, effectiveModel, cwd);
+      }
+    }
+    // ── End health tracking ────────────────────────────────────────────────
+
+    recordUsage({
+      provider: effectiveProvider,
+      model:    effectiveModel,
+      tier,
+      durationMs,
+      inputTokens:  usage?.inputTokens  ?? null,
+      outputTokens: usage?.outputTokens ?? null,
+      success,
+    });
+
     return {
-      status:        'completed',
+      status:        success ? 'completed' : 'failed',
       type:          'native-agent',
       provider:      effectiveProvider,
       model:         effectiveModel,
-      command:       null,
+      command,
       nativeDispatch: nativeDescriptor,
-      exitCode:      0,
-      summary:       `Routed to ${effectiveProvider}/${effectiveModel} (${effectiveDecision.tier})`,
-      durationMs:    0,
-      usage:         null,
-      error:         null,
+      exitCode,
+      summary,
+      durationMs,
+      usage,
+      error: success ? null : errorText.slice(0, 200),
     };
   }
 
@@ -743,7 +804,7 @@ async function dispatchDualBrain(input = {}) {
   const tier = decision.tier ?? 'execute';
 
   const claudeDecision = { ...decision, provider: 'claude', model: decision.model ?? 'sonnet', tier };
-  const _oaiDefault = tier === 'think' ? 'gpt-5.5' : tier === 'search' ? 'o4-mini' : 'gpt-5.4';
+  const _oaiDefault = tier === 'think' ? 'o3' : tier === 'search' ? 'gpt-4o-mini' : 'gpt-4o';
   const openaiDecision = { ...decision, provider: 'openai', model: decision.openaiModel ?? _oaiDefault, tier };
 
   const validatedClaude = validateDispatch(claudeDecision, rt);

package/src/profile.mjs

@@ -520,9 +520,9 @@ function isSoloBrain(profile) {
 function getHeadModel(profile) {
   const providers = getAvailableProviders(profile);
   if (providers.length === 0) return 'sonnet';
-  if (providers.length === 1) return providers[0].name === 'openai' ? 'gpt-5.4' : 'sonnet';
+  if (providers.length === 1) return providers[0].name === 'openai' ? 'gpt-4o' : 'sonnet';
   const top = providers.reduce((a, b) => (b.rank > a.rank ? b : a));
-  return top.name === 'openai' ? 'gpt-5.4' : 'sonnet';
+  return top.name === 'openai' ? 'gpt-4o' : 'sonnet';
 }
 
 // ---------------------------------------------------------------------------

package/src/session.mjs

@@ -228,6 +228,7 @@ function isRealPrompt(text) {
   if (/^[✅❌📦🔗⚠️🚀🎉🔧📝]/.test(t)) return false;
   if (/Claude (history|binary|versions) symlink/.test(t)) return false;
   if (t.startsWith('# AGENTS.md')) return false;
+  if (t === 'login' || t === 'logout') return false;
   if (t.startsWith('/')) return false;
   if (t.startsWith('[Pasted')) return false;
   return true;
@@ -462,8 +463,8 @@ export function importReplitSessions(cwd = process.cwd()) {
 
   // Build session list
   for (const [id, sess] of bySession) {
-    // Skip sessions outside the recency window (timestamps are in seconds)
-    if (sess.lastTimestamp * 1000 < cutoff) continue;
+    // Skip sessions outside the recency window (timestamps are in ms)
+    if (sess.lastTimestamp < cutoff) continue;
     // Derive display name
     let name = sess.firstPrompt;
     if (!name) {
@@ -802,7 +803,8 @@ export function buildSessionIndex(cwd = process.cwd()) {
 
             // Track timestamps
             if (entry.timestamp) {
-              const ts = typeof entry.timestamp === 'number' ? entry.timestamp : Date.parse(entry.timestamp) / 1000;
+              const raw = typeof entry.timestamp === 'number' ? entry.timestamp : Date.parse(entry.timestamp);
+              const ts = raw > 1e12 ? raw / 1000 : raw;
               if (ts > lastTimestamp) lastTimestamp = ts;
             }