dual-brain 0.2.28 → 0.2.30

package/bin/dual-brain.mjs

@@ -1106,6 +1106,29 @@ async function cmdStatus(args = []) {
       if (rec.action) console.log(`     → ${rec.action}`);
     }
   } catch { /* non-blocking */ }
+
+  // Intelligence layer status
+  try {
+    const { getRoutingStats } = await import('../src/routing-advisor.mjs');
+    const { getThinkingStats } = await import('../src/think-engine.mjs');
+    const stats = getRoutingStats(cwd);
+    const thinkStats = getThinkingStats(cwd);
+
+    if (stats.totalObservations > 0 || thinkStats.totalDecisions > 0) {
+      console.log('');
+      console.log('  \x1b[2m─── Intelligence ───\x1b[0m');
+      if (stats.totalObservations > 0) {
+        console.log(`  Routing: ${stats.totalObservations} observations, learning ${stats.totalObservations >= 5 ? 'active' : 'warming up'}`);
+        if (stats.topPerformers?.length > 0) {
+          const top = stats.topPerformers[0];
+          console.log(`  Best: ${top.model} on ${top.cell} (${(top.ema * 100).toFixed(0)}% EMA, n=${top.observations})`);
+        }
+      }
+      if (thinkStats.totalDecisions > 0) {
+        console.log(`  Think: ${thinkStats.totalDecisions} decisions, ${(thinkStats.cacheHitRate * 100).toFixed(0)}% cache hit rate`);
+      }
+    }
+  } catch { /* non-blocking */ }
 }
 
 // ─── cmdHot / cmdCool ─────────────────────────────────────────────────────────
@@ -6510,6 +6533,12 @@ async function main() {
   const args = process.argv.slice(2);
   const cmd  = args[0];
 
+  // Session start marker — feeds routing advisor with cross-session timing signals
+  try {
+    const { markSessionStart } = await import('../src/routing-advisor.mjs');
+    markSessionStart(process.cwd());
+  } catch { /* non-blocking */ }
+
   if (cmd === '--help' || cmd === '-h') { printHelp(); return; }
   if (cmd === '--version' || cmd === '-v') { console.log(readVersion()); return; }
 
@@ -6651,13 +6680,55 @@ async function main() {
     const { generateRecommendations, formatRecommendations } = await import('../src/recommendations.mjs');
     const recs = generateRecommendations(process.cwd());
     if (recs.length === 0) {
-      console.log('  No recommendations yet. Need 20+ dispatches to generate advice.');
+      console.log('');
+      console.log('  \x1b[2m─── HEAD Analysis ───\x1b[0m');
+      console.log('');
+      const { getRoutingStats } = await import('../src/routing-advisor.mjs');
+      const stats = getRoutingStats(process.cwd());
+      if (stats.totalObservations < 20) {
+        console.log(`  Need more data: ${stats.totalObservations}/20 observations before recommendations.`);
+        console.log(`  Keep dispatching — the system learns from every task.`);
+      } else {
+        console.log('  No recommendations — current configuration is performing well.');
+      }
+      console.log('');
     } else {
       console.log(formatRecommendations(recs));
     }
     return;
   }
 
+  if (cmd === 'stats' || cmd === 'intelligence') {
+    const { getRoutingStats } = await import('../src/routing-advisor.mjs');
+    const { getThinkingStats } = await import('../src/think-engine.mjs');
+    const stats = getRoutingStats(process.cwd());
+    const thinkStats = getThinkingStats(process.cwd());
+
+    console.log('');
+    console.log('  \x1b[1mdual-brain intelligence report\x1b[0m');
+    console.log('');
+    console.log(`  Routing observations: ${stats.totalObservations}`);
+    if (stats.topPerformers?.length > 0) {
+      console.log('  Top performers:');
+      for (const p of stats.topPerformers.slice(0, 5)) {
+        console.log(`    ${p.cell} → ${p.model} (${(p.ema * 100).toFixed(0)}%, n=${p.observations})`);
+      }
+    }
+    if (stats.worstPerformers?.length > 0) {
+      console.log('  Underperformers:');
+      for (const p of stats.worstPerformers.slice(0, 3)) {
+        console.log(`    ${p.cell} → ${p.model} (${(p.ema * 100).toFixed(0)}%, n=${p.observations})`);
+      }
+    }
+    console.log('');
+    console.log(`  Think decisions: ${thinkStats.totalDecisions}`);
+    console.log(`  Cache hit rate: ${(thinkStats.cacheHitRate * 100).toFixed(0)}%`);
+    console.log(`  Tokens saved: ~${(thinkStats.totalTokensSaved / 1000).toFixed(0)}K`);
+    console.log(`  Tier distribution: recall=${thinkStats.tierDistribution.recall}, quick=${thinkStats.tierDistribution.quick}, standard=${thinkStats.tierDistribution.standard}, deep=${thinkStats.tierDistribution.deep}, ultra=${thinkStats.tierDistribution.ultra}`);
+    console.log('');
+    return;
+  }
+
   if (cmd === 'revert' || cmd === 'undo') {
     const { runRevert } = await import('../src/revert.mjs');
     await runRevert(process.cwd());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.28",
+  "version": "0.2.30",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {

package/src/context-intel.mjs

@@ -3,7 +3,8 @@ import { join, resolve } from 'node:path';
 
 export const MODEL_FORMAT = {
   claude: 'xml', sonnet: 'xml', haiku: 'xml', opus: 'xml',
-  gpt: 'markdown', o3: 'markdown', 'o4-mini': 'markdown',
+  gpt: 'markdown', 'o4-mini': 'markdown',
+  o3: 'prose',
 };
 
 function detectFormat(targetModel, role) {
@@ -14,6 +15,7 @@ function detectFormat(targetModel, role) {
 }
 
 export function selectRelevant(pack, role) {
+  if (!pack) return { intent: '', constraints: [], acceptanceCriteria: [] };
   const { intent, constraints, priorAttempts, repoState, fileSummaries,
           acceptanceCriteria, files } = pack;
   if (role === 'thinker') {
@@ -134,7 +136,7 @@ export function attachOutputSchema(role) {
   return 'Return JSON: { pass: boolean, findings: [{ severity, file, line, issue, fix }] }';
 }
 
-export function shapeForRole(pack, role, targetModel, tokenBudget) {
+export function shapeForRole(pack, role, targetModel = 'sonnet', tokenBudget = 8000) {
   const sections = selectRelevant(pack, role);
 
   if (role === 'worker' && sections.inScope?.length) {

package/src/handoff.mjs

@@ -22,10 +22,11 @@ function validate(from, to, data) {
 export function createHandoff(fromStage, toStage, data, runId, cwd) {
   try {
     validate(fromStage, toStage, data);
+    const safeRunId = String(runId).replace(/[^a-z0-9_-]/gi, '_').slice(0, 50);
     const dir = hDir(cwd);
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    const record = { fromStage, toStage, runId, createdAt: new Date().toISOString(), data };
-    const dest = hPath(runId, fromStage, toStage, cwd); const tmp = dest + '.tmp';
+    const record = { fromStage, toStage, runId: safeRunId, createdAt: new Date().toISOString(), data };
+    const dest = hPath(safeRunId, fromStage, toStage, cwd); const tmp = dest + '.tmp';
     writeFileSync(tmp, JSON.stringify(record, null, 2), 'utf8');
     try { renameSync(tmp, dest); } catch { writeFileSync(dest, JSON.stringify(record, null, 2), 'utf8'); }
     return record;
@@ -34,7 +35,8 @@ export function createHandoff(fromStage, toStage, data, runId, cwd) {
 
 export function consumeHandoff(runId, fromStage, toStage, cwd) {
   try {
-    const p = hPath(runId, fromStage, toStage, cwd);
+    const safeRunId = String(runId).replace(/[^a-z0-9_-]/gi, '_').slice(0, 50);
+    const p = hPath(safeRunId, fromStage, toStage, cwd);
     if (!existsSync(p)) return null;
     const record = JSON.parse(readFileSync(p, 'utf8'));
     try { unlinkSync(p); } catch { /* best-effort */ }

package/src/outcome.mjs

@@ -1,4 +1,4 @@
-import { mkdirSync, appendFileSync, writeFileSync, readFileSync, existsSync, readdirSync } from 'fs';
+import { mkdirSync, appendFileSync, writeFileSync, readFileSync, existsSync, readdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { randomUUID } from 'crypto';
 import { execSync } from 'child_process';
@@ -55,6 +55,19 @@ function deriveIntent(prompt, tier) {
   return tier ?? 'execute';
 }
 
+function pruneOutcomes(cwd) {
+  const dir = join(cwd, '.dualbrain', 'outcomes');
+  try {
+    const files = readdirSync(dir).filter(f => f.startsWith('outcome_')).sort();
+    if (files.length > 500) {
+      const toDelete = files.slice(0, files.length - 400);
+      for (const f of toDelete) {
+        try { unlinkSync(join(dir, f)); } catch {}
+      }
+    }
+  } catch {}
+}
+
 export function recordDispatchOutcome(dispatchInput, result) {
   try {
     const cwd = dispatchInput.cwd ?? process.cwd();
@@ -97,6 +110,7 @@ export function recordDispatchOutcome(dispatchInput, result) {
       ).catch(() => { /* non-blocking */ });
     } catch { /* non-blocking */ }
 
+    pruneOutcomes(cwd);
     return record;
   } catch {
     return null;

package/src/pipeline.mjs

@@ -1270,6 +1270,17 @@ export async function runPipeline(trigger, prompt, options = {}) {
         run._thinkRefinedFiles   = thinkRefinement.files;
         decision                 = thinkRefinement.decision;
 
+        // Record the think→work handoff for cross-agent context continuity
+        try {
+          const { createHandoff } = await import('./handoff.mjs');
+          createHandoff('thinker', 'worker', {
+            objective: thinkRefinement.prompt,
+            files: thinkRefinement.files,
+            criteria: thinkRefinement.decision?.criteria || [],
+            confidence: thinkRefinement.confidence,
+          }, run.id || Date.now().toString(36), cwd);
+        } catch { /* non-blocking */ }
+
         // Cascade: if think agent is highly confident and task is simple, downgrade worker model
         if (thinkRefinement.decision) {
           const thinkConf = thinkRefinement.confidence || 0;
@@ -1288,6 +1299,17 @@ export async function runPipeline(trigger, prompt, options = {}) {
       }
     }
 
+    // Strategy selection — may override dispatch pattern
+    try {
+      const { selectStrategy } = await import('./strategy.mjs');
+      const strategyResult = selectStrategy(run.context.detection, decision, run.context.profile);
+      if (strategyResult.strategy !== 'direct') {
+        decision._strategy = strategyResult.strategy;
+        decision._strategyReason = strategyResult.reason;
+        if (verbose) process.stderr.write(`[dual-brain] strategy: ${strategyResult.strategy} (${strategyResult.reason})\n`);
+      }
+    } catch { /* non-blocking */ }
+
     // Resolve the (possibly refined) prompt and file list for dispatch
     const dispatchPrompt = run._thinkRefinedPrompt ?? effectivePrompt;
     const dispatchFiles  = run._thinkRefinedFiles  ?? files;

package/src/recommendations.mjs

@@ -67,6 +67,7 @@ function thinkROI(metrics) {
 function modelMismatch(routingState) {
   const recs = [];
   for (const [taskType, models] of Object.entries(routingState)) {
+    if (taskType.startsWith('_')) continue; // skip metadata keys
     for (const [model, stats] of Object.entries(models)) {
       const { ema, observations } = stats || {};
       if (observations >= 10 && ema < 0.4) {
@@ -156,12 +157,16 @@ function subscriptionUtilization(subscription, routingState) {
   const { tier, maxMultiplier } = subscription;
   if (!tier) return null;
 
-  const opusUses = Object.values(routingState)
+  const routingCells = Object.entries(routingState)
+    .filter(([k]) => !k.startsWith('_')) // skip metadata keys
+    .map(([, v]) => v);
+
+  const opusUses = routingCells
     .flatMap(m => Object.entries(m))
     .filter(([model]) => model === 'opus' || model.includes('opus'))
     .reduce((s, [, stats]) => s + (stats.observations || 0), 0);
 
-  const totalUses = Object.values(routingState)
+  const totalUses = routingCells
     .flatMap(m => Object.values(m))
     .reduce((s, stats) => s + (stats.observations || 0), 0);
 
@@ -267,7 +272,7 @@ export function formatRecommendations(recs) {
   const line = (content) => `│ ${pad(content)} │`;
 
   const lines = [
-    '╭─ Recommendations ' + '─'.repeat(WIDTH - 19) + '╮',
+    '╭─ Recommendations ' + '─'.repeat(WIDTH - 20) + '╮',
     line(''),
   ];
 

package/src/routing-advisor.mjs

@@ -29,7 +29,11 @@ function stateFile(cwd) { return join(cwd || process.cwd(), '.dualbrain', 'routi
 function loadState(cwd) {
   try {
     const p = stateFile(cwd);
-    return existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : {};
+    if (!existsSync(p)) return {};
+    const raw = readFileSync(p, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
+    return parsed;
   } catch { return {}; }
 }
 

package/src/self-correct.mjs

@@ -78,6 +78,7 @@ export function selectStrategy(failure, originalDecision, attemptNumber) {
         case 'specification':
           return { strategy: 'give-up', reason: 'ambiguous specification; user clarification needed' };
         default: // unknown
+          if (tier >= 3) return { strategy: 'split', newDecision: originalDecision, reason: 'unknown failure at max tier; decomposing' };
           return { strategy: 'escalate', newDecision: originalDecision, reason: 'unknown failure; escalating as precaution' };
       }
     }
@@ -130,6 +131,7 @@ export function buildRetryDecision(originalDecision, strategy, failure) {
 // Export 4: shouldRetry(result, originalDecision, attemptNumber)
 export function shouldRetry(result, originalDecision, attemptNumber = 1) {
   try {
+    if (attemptNumber >= MAX_ATTEMPTS) return { retry: false, reason: `max attempts (${MAX_ATTEMPTS}) reached`, strategy: 'give-up' };
     const failure = classifyFailure(result);
     const { strategy, newDecision, reason } = selectStrategy(failure, originalDecision, attemptNumber);
 

package/src/setup-flow.mjs

@@ -148,6 +148,14 @@ async function askYN(rl, question, defaultYes = true) {
 export async function runSetup(cwd, options = {}) {
   const detected = detectEnvironment(cwd);
 
+  // Non-TTY fast path — stdin is piped or in CI
+  if (!process.stdin.isTTY && !options.nonInteractive) {
+    process.stderr.write('[dual-brain] Non-interactive terminal detected. Use --non-interactive flag or run in a TTY.\n');
+    const config = buildConfig({ subscription: 'claude-pro', workStyle: 'balanced' }, detected);
+    saveConfig(config, cwd);
+    return config;
+  }
+
   // Non-interactive fast path
   if (options.nonInteractive) {
     const config = buildConfig({

package/src/signal.mjs

@@ -9,8 +9,9 @@ export const EXPECTED_DURATION_MS = { search: 15000, execute: 45000, think: 3000
 
 export function scoreDurationRatio(durationMs, tier) {
   try {
-    const expected = EXPECTED_DURATION_MS[tier] ?? EXPECTED_DURATION_MS.execute;
-    const ratio = durationMs / expected;
+    if (durationMs <= 0) return null;
+    const expectedMs = EXPECTED_DURATION_MS[tier] || EXPECTED_DURATION_MS.execute;
+    const ratio = durationMs / expectedMs;
     if (ratio >= 0.5 && ratio <= 1.5) return 1.0;
     if (ratio < 0.2) return 0.5;
     if (ratio > 3.0) return 0.3;
@@ -71,7 +72,7 @@ export function scoreOutcome(outcome, context = {}) {
     // Signal 3: token efficiency (weight 0.25)
     let effVal = null;
     const filesChanged = outcome.filesChanged ?? 0;
-    const fileCount = typeof filesChanged === 'number' ? filesChanged : filesChanged.length;
+    const fileCount = Array.isArray(filesChanged) ? filesChanged.length : (typeof filesChanged === 'number' ? filesChanged : 0);
     if (!(fileCount === 0 && tier === 'think')) {
       const tokensUsed =
         outcome.tokensUsed?.output ??