dual-brain 0.2.26 → 0.2.27

package/bin/dual-brain.mjs

@@ -1094,6 +1094,18 @@ async function cmdStatus(args = []) {
       }
     }
   } catch { /* network unavailable — skip */ }
+
+  // Show top recommendation if available
+  try {
+    const { getTopRecommendation } = await import('../src/recommendations.mjs');
+    const rec = getTopRecommendation(process.cwd());
+    if (rec) {
+      console.log('');
+      console.log(`  \x1b[33m💡 ${rec.title}\x1b[0m`);
+      console.log(`     ${rec.description}`);
+      if (rec.action) console.log(`     → ${rec.action}`);
+    }
+  } catch { /* non-blocking */ }
 }
 
 // ─── cmdHot / cmdCool ─────────────────────────────────────────────────────────
@@ -6532,6 +6544,18 @@ async function main() {
   }
 
   if (cmd === 'init') {
+    // init --reconfigure: run setup-flow reconfiguration
+    if (args.includes('--reconfigure')) {
+      try {
+        const { runSetup } = await import('../src/setup-flow.mjs');
+        await runSetup(process.cwd(), { reconfigure: true });
+      } catch (e) {
+        console.error('setup-flow.mjs not available — skipping reconfigure');
+        if (process.env.DEBUG) console.error(e.message);
+      }
+      return;
+    }
+
     // init --reset: clear credentials.json and re-run wizard
     if (args.includes('--reset')) {
       const cwd = process.cwd();
@@ -6593,6 +6617,23 @@ async function main() {
     return;
   }
 
+  if (cmd === 'setup') {
+    const { runSetup } = await import('../src/setup-flow.mjs');
+    await runSetup(process.cwd(), { reconfigure: args.includes('--reconfigure') });
+    return;
+  }
+
+  if (cmd === 'advice' || cmd === 'recommend') {
+    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.');
+    } else {
+      console.log(formatRecommendations(recs));
+    }
+    return;
+  }
+
   // One-shot commands — run and exit
   if (cmd === 'install') {
     if (args.includes('--global')) { await installGlobal(); return; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.26",
+  "version": "0.2.27",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -52,7 +52,8 @@
     "./routing-advisor": "./src/routing-advisor.mjs",
     "./subscription": "./src/subscription.mjs",
     "./recommendations": "./src/recommendations.mjs",
-    "./setup-flow": "./src/setup-flow.mjs"
+    "./setup-flow": "./src/setup-flow.mjs",
+    "./self-correct": "./src/self-correct.mjs"
   },
   "keywords": [
     "claude-code",
@@ -144,6 +145,7 @@
     "src/subscription.mjs",
     "src/recommendations.mjs",
     "src/setup-flow.mjs",
+    "src/self-correct.mjs",
     "bin/*.mjs",
     "hooks/enforce-tier.mjs",
     "hooks/cost-logger.mjs",

package/src/decide.mjs

@@ -49,6 +49,28 @@ function _loadModelRegistry() {
 // Kick off the load immediately so it is ready before the first routing call.
 _loadModelRegistry();
 
+// ─── Routing Advisor (optional, lazy-loaded) ──────────────────────────────────
+
+/**
+ * Cached reference to routing-advisor.mjs exports. Populated on first import.
+ * Remains null if unavailable — decideRoute skips advisor consultation in that case.
+ */
+let routingAdvisor = null;
+let _advisorLoadAttempted = false;
+
+function _loadRoutingAdvisor() {
+  if (_advisorLoadAttempted) return;
+  _advisorLoadAttempted = true;
+  import('./routing-advisor.mjs').then(mod => {
+    routingAdvisor = mod;
+  }).catch(() => {
+    // routing-advisor.mjs unavailable — skip learned routing
+  });
+}
+
+// Kick off the load immediately so it is ready before the first routing call.
+_loadRoutingAdvisor();
+
 // ─── Work Styles ─────────────────────────────────────────────────────────────
 
 /**
@@ -890,6 +912,28 @@ export function decideRoute({ profile = {}, detection = {}, cwd, thinkResult, se
   // If the pipeline changed the model (downgrade/bias/floor), resolve the new short name to a full ID.
   model = toFullModelId(model, provider, tier);
 
+  // ── Routing advisor: consult learned EMA model for this task type ─────────
+  // Non-blocking: only overrides when advisor has enough observations (confidence > 0.3).
+  // Uses short model names; advisor only covers Claude models (haiku/sonnet/opus).
+  let _advisorOverride = null;
+  if (routingAdvisor && provider === 'claude') {
+    try {
+      const advice = routingAdvisor.adviseModel(
+        { intent: detection.intent, tier, risk: detection.risk },
+        cwd
+      );
+      if (advice.confidence > 0.3 && advice.model) {
+        const advisorShort = advice.model; // advisor returns short names
+        const previousModel = toShortName(model, 'claude');
+        if (advisorShort !== previousModel && available.claude.includes(advisorShort)) {
+          const overrideFullId = toFullModelId(advisorShort, 'claude', tier);
+          _advisorOverride = { from: model, to: overrideFullId, reason: advice.reason, explored: advice.explored };
+          model = overrideFullId;
+        }
+      }
+    } catch { /* non-blocking */ }
+  }
+
   // ── Challenger / dual-brain decision ─────────────────────────────────────
   const hasBothProviders = !!(
     profile?.providers?.claude?.enabled &&
@@ -938,6 +982,7 @@ export function decideRoute({ profile = {}, detection = {}, cwd, thinkResult, se
     explanation: '',
     _healthScores: healthScores,
     _workStyle: workStyle,
+    ...(_advisorOverride   && { _advisorOverride }),
   };
 
   decision.explanation = explainDecision(decision, detection, profileWithEffectiveBias);

package/src/dispatch.mjs

@@ -1181,6 +1181,29 @@ async function dispatch(input = {}) {
       const { recordDispatchOutcome } = await import('./outcome.mjs');
       recordDispatchOutcome(input, nativeResult);
     } catch { /* never block */ }
+
+    // ── Self-correction: intelligent retry after failover exhaustion ──────────
+    if (!success) {
+      const attemptNumber = input._retryAttempt || 1;
+      try {
+        const { shouldRetry } = await import('./self-correct.mjs');
+        const retry = shouldRetry(nativeResult, decision, attemptNumber);
+        if (retry.retry && retry.decision) {
+          if (verbose) process.stderr.write(`[dual-brain] self-correct: ${retry.strategy} (attempt ${attemptNumber + 1}, reason: ${retry.reason})\n`);
+          return dispatch({
+            ...input,
+            decision: retry.decision,
+            _retryAttempt: attemptNumber + 1,
+            _skipPreDispatchThink: retry.strategy !== 'rethink',
+            _skipRelatedContext: true,
+          });
+        } else if (verbose) {
+          process.stderr.write(`[dual-brain] self-correct: giving up (${retry.reason})\n`);
+        }
+      } catch { /* non-blocking — if self-correct fails, return original failure */ }
+    }
+    // ── End self-correction ───────────────────────────────────────────────────
+
     return nativeResult;
   }
 
@@ -1303,6 +1326,29 @@ async function dispatch(input = {}) {
     const { recordDispatchOutcome } = await import('./outcome.mjs');
     recordDispatchOutcome(input, subResult);
   } catch { /* never block */ }
+
+  // ── Self-correction: intelligent retry after failover exhaustion ──────────
+  if (!success) {
+    const attemptNumber = input._retryAttempt || 1;
+    try {
+      const { shouldRetry } = await import('./self-correct.mjs');
+      const retry = shouldRetry(subResult, decision, attemptNumber);
+      if (retry.retry && retry.decision) {
+        if (verbose) process.stderr.write(`[dual-brain] self-correct: ${retry.strategy} (attempt ${attemptNumber + 1}, reason: ${retry.reason})\n`);
+        return dispatch({
+          ...input,
+          decision: retry.decision,
+          _retryAttempt: attemptNumber + 1,
+          _skipPreDispatchThink: retry.strategy !== 'rethink',
+          _skipRelatedContext: true,
+        });
+      } else if (verbose) {
+        process.stderr.write(`[dual-brain] self-correct: giving up (${retry.reason})\n`);
+      }
+    } catch { /* non-blocking — if self-correct fails, return original failure */ }
+  }
+  // ── End self-correction ───────────────────────────────────────────────────
+
   return subResult;
 }
 

package/src/outcome.mjs

@@ -45,6 +45,16 @@ function last7DaysFiles(cwd) {
   return files;
 }
 
+const INTENT_KEYWORDS = ['implement', 'fix', 'refactor', 'review', 'search', 'test'];
+
+function deriveIntent(prompt, tier) {
+  const lower = (prompt ?? '').toLowerCase();
+  for (const kw of INTENT_KEYWORDS) {
+    if (lower.includes(kw)) return kw;
+  }
+  return tier ?? 'execute';
+}
+
 export function recordDispatchOutcome(dispatchInput, result) {
   try {
     const cwd = dispatchInput.cwd ?? process.cwd();
@@ -69,6 +79,24 @@ export function recordDispatchOutcome(dispatchInput, result) {
 
     const filePath = join(outcomesDir(cwd), `outcome_${id}.json`);
     writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf8');
+
+    // Score the outcome for the routing advisor (non-blocking)
+    try {
+      import('./signal.mjs').then(({ scoreOutcome }) =>
+        import('./routing-advisor.mjs').then(({ recordReward }) => {
+          const scored = scoreOutcome(record);
+          const intent = deriveIntent(record.prompt, record.tier);
+          const cellKey = `${record.tier}:${intent}`;
+          // Normalize full model ID to short name for the advisor cell
+          const modelId = record.model ?? 'sonnet';
+          const shortModel = /haiku/i.test(modelId) ? 'haiku'
+            : /opus/i.test(modelId) ? 'opus'
+            : 'sonnet';
+          recordReward(cellKey, shortModel, scored.reward, cwd);
+        })
+      ).catch(() => { /* non-blocking */ });
+    } catch { /* non-blocking */ }
+
     return record;
   } catch {
     return null;

package/src/self-correct.mjs

@@ -0,0 +1,145 @@
+// self-correct.mjs — Failure analysis and retry strategy selection
+
+const MODEL_TIER = { 'haiku': 1, 'sonnet': 2, 'opus': 3 };
+const TIER_MODEL = { 1: 'haiku', 2: 'sonnet', 3: 'opus' };
+const MAX_ATTEMPTS = 3;
+
+function modelTier(model = '') {
+  const m = model.toLowerCase();
+  if (m.includes('haiku')) return 1;
+  if (m.includes('opus')) return 3;
+  return 2; // sonnet default
+}
+
+function matchesAny(text, keywords) {
+  const t = text.toLowerCase();
+  return keywords.some(k => t.includes(k));
+}
+
+// Export 1: classifyFailure(result)
+export function classifyFailure(result) {
+  try {
+    const err = String(result?.error || result?.stderr || '');
+    const out = String(result?.output || result?.stdout || '');
+    const combined = err + ' ' + out;
+    const duration = result?.durationMs ?? 0;
+    const timeoutThreshold = result?.timeoutMs ?? 60_000;
+
+    if (matchesAny(combined, ['rate limit', 'ratelimit', '429', 'quota exceeded', 'capacity'])) {
+      return { type: 'rate-limit', confidence: 0.95, retryable: true };
+    }
+    if (matchesAny(combined, ['timeout', 'timed out']) || duration > timeoutThreshold) {
+      return { type: 'timeout', confidence: 0.9, retryable: true };
+    }
+    if (matchesAny(combined, ['context length', 'token limit', 'too long', 'maximum context', 'context window'])) {
+      return { type: 'context-overflow', confidence: 0.9, retryable: true };
+    }
+    if (matchesAny(combined, ['ambiguous', 'unclear', 'did you mean', 'which one', 'could you clarify', 'please clarify'])) {
+      return { type: 'specification', confidence: 0.85, retryable: false };
+    }
+    if (matchesAny(combined, ['unable to', "i don't know how", 'beyond my', 'cannot complete', 'incomplete'])) {
+      return { type: 'capability', confidence: 0.8, retryable: true };
+    }
+    // Heuristic: low quality output without explicit error signals capability gap
+    const quality = result?.quality ?? result?.score ?? null;
+    if (quality !== null && quality < 0.5) {
+      return { type: 'capability', confidence: 0.7, retryable: true };
+    }
+
+    return { type: 'unknown', confidence: 0.5, retryable: true };
+  } catch {
+    return { type: 'unknown', confidence: 0, retryable: true };
+  }
+}
+
+// Export 2: selectStrategy(failure, originalDecision, attemptNumber)
+export function selectStrategy(failure, originalDecision, attemptNumber) {
+  try {
+    if (!failure.retryable) {
+      return { strategy: 'give-up', reason: `failure type '${failure.type}' requires user input` };
+    }
+    if (attemptNumber >= MAX_ATTEMPTS) {
+      return { strategy: 'give-up', reason: `max attempts (${MAX_ATTEMPTS}) reached` };
+    }
+
+    const tier = modelTier(originalDecision?.model);
+
+    if (attemptNumber === 1) {
+      switch (failure.type) {
+        case 'capability':
+          if (tier >= 3) return { strategy: 'split', newDecision: originalDecision, reason: 'already at max tier; decompose task' };
+          return { strategy: 'escalate', newDecision: originalDecision, reason: 'model lacked capability; escalating tier' };
+        case 'timeout':
+          return { strategy: 'wait-retry', newDecision: originalDecision, reason: 'timed out; retrying with delay' };
+        case 'rate-limit':
+          return { strategy: 'wait-retry', newDecision: originalDecision, reason: 'rate limited; retrying after delay' };
+        case 'context-overflow':
+          return { strategy: 'compress', newDecision: originalDecision, reason: 'context too large; compressing' };
+        case 'specification':
+          return { strategy: 'give-up', reason: 'ambiguous specification; user clarification needed' };
+        default: // unknown
+          return { strategy: 'escalate', newDecision: originalDecision, reason: 'unknown failure; escalating as precaution' };
+      }
+    }
+
+    if (attemptNumber === 2) {
+      if (tier >= 3) {
+        return { strategy: 'split', newDecision: originalDecision, reason: 'max tier reached; splitting task' };
+      }
+      return { strategy: 'escalate', newDecision: originalDecision, reason: 'retry failed; escalating one final tier' };
+    }
+
+    return { strategy: 'give-up', reason: 'exhausted retry budget' };
+  } catch {
+    return { strategy: 'give-up', reason: 'internal error in strategy selection' };
+  }
+}
+
+// Export 3: buildRetryDecision(originalDecision, strategy, failure)
+export function buildRetryDecision(originalDecision, strategy, failure) {
+  try {
+    const base = {
+      ...originalDecision,
+      _retryAttempt: (originalDecision?._retryAttempt ?? 0) + 1,
+      _retryReason: failure.type,
+      _retryStrategy: strategy,
+    };
+
+    switch (strategy) {
+      case 'escalate': {
+        const tier = modelTier(originalDecision?.model);
+        const nextTier = Math.min(tier + 1, 3);
+        return { ...base, model: TIER_MODEL[nextTier] };
+      }
+      case 'compress':
+        return { ...base, _contextBudget: 0.5 };
+      case 'wait-retry':
+        return { ...base, _delayMs: 5000 };
+      case 'rethink':
+        return { ...base, tier: 'think', _retryAsThink: true };
+      case 'split':
+        return { ...base, _shouldDecompose: true };
+      default:
+        return base;
+    }
+  } catch {
+    return { ...originalDecision, _retryAttempt: 1, _retryReason: 'error', _retryStrategy: strategy };
+  }
+}
+
+// Export 4: shouldRetry(result, originalDecision, attemptNumber)
+export function shouldRetry(result, originalDecision, attemptNumber = 1) {
+  try {
+    const failure = classifyFailure(result);
+    const { strategy, newDecision, reason } = selectStrategy(failure, originalDecision, attemptNumber);
+
+    if (strategy === 'give-up') {
+      return { retry: false, reason, strategy };
+    }
+
+    const decision = buildRetryDecision(newDecision ?? originalDecision, strategy, failure);
+    return { retry: true, decision, reason, strategy };
+  } catch {
+    return { retry: false, reason: 'internal error in shouldRetry', strategy: 'give-up' };
+  }
+}