dual-brain 0.1.22 → 0.2.0

package/src/cost-tracker.mjs

@@ -0,0 +1,184 @@
+// cost-tracker.mjs — Lightweight cost estimation and efficiency tracking for .dual-brain/costs.jsonl.
+
+import { readFileSync, appendFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const TOKEN_COSTS = {
+  'claude-opus-4-6':           0.03,
+  'claude-sonnet-4-6':         0.006,
+  'claude-haiku-4-5-20251001': 0.001,
+  'gpt-5.5':                   0.04,
+  'o3':                        0.03,
+  'gpt-4o':                    0.005,
+  'gpt-4o-mini':               0.0003,
+  'default':                   0.01,
+};
+
+export function estimateTokenCost(model, tokens) {
+  const rate = TOKEN_COSTS[model] ?? TOKEN_COSTS['default'];
+  return (tokens / 1000) * rate;
+}
+
+export function trackCost(action, cwd = process.cwd()) {
+  try {
+    const dir = join(cwd, '.dual-brain');
+    mkdirSync(dir, { recursive: true });
+    const entry = {
+      timestamp:      new Date().toISOString(),
+      action:         action.action         ?? 'execute',
+      model:          action.model          ?? 'default',
+      tokensEstimated: action.tokensEstimated ?? 0,
+      costEstimated:  estimateTokenCost(action.model ?? 'default', action.tokensEstimated ?? 0),
+      tier:           action.tier           ?? 'standard',
+      wasCacheHit:    action.wasCacheHit    ?? false,
+      tokensSaved:    action.tokensSaved    ?? 0,
+    };
+    appendFileSync(join(dir, 'costs.jsonl'), JSON.stringify(entry) + '\n', 'utf8');
+    return entry;
+  } catch {
+    return null;
+  }
+}
+
+function readCostLines(cwd) {
+  const p = join(cwd, '.dual-brain', 'costs.jsonl');
+  if (!existsSync(p)) return [];
+  try {
+    return readFileSync(p, 'utf8').trim().split('\n').filter(Boolean).flatMap(line => {
+      try { return [JSON.parse(line)]; } catch { return []; }
+    });
+  } catch { return []; }
+}
+
+export function getCostSummary(cwd = process.cwd(), days = 7) {
+  const cutoff = new Date(Date.now() - days * 86400000).toISOString();
+  const all    = readCostLines(cwd).filter(e => e.timestamp >= cutoff);
+
+  if (all.length === 0) {
+    return {
+      period: `${days} days`,
+      totalCost: 0, totalTokens: 0, totalActions: 0,
+      cacheHits: 0, tokensSaved: 0, costSaved: 0, savingsRate: 0,
+      byTier: {}, byModel: {}, trend: 'stable',
+    };
+  }
+
+  let totalCost = 0, totalTokens = 0, cacheHits = 0, tokensSaved = 0;
+  const byTier  = {};
+  const byModel = {};
+
+  for (const e of all) {
+    totalCost    += e.costEstimated   ?? 0;
+    totalTokens  += e.tokensEstimated ?? 0;
+    if (e.wasCacheHit) { cacheHits++; tokensSaved += e.tokensSaved ?? 0; }
+
+    const tier = e.tier ?? 'standard';
+    if (!byTier[tier]) byTier[tier] = { count: 0, tokens: 0, cost: 0 };
+    byTier[tier].count  += 1;
+    byTier[tier].tokens += e.tokensEstimated ?? 0;
+    byTier[tier].cost   += e.costEstimated   ?? 0;
+
+    const model = e.model ?? 'default';
+    if (!byModel[model]) byModel[model] = { count: 0, tokens: 0, cost: 0 };
+    byModel[model].count  += 1;
+    byModel[model].tokens += e.tokensEstimated ?? 0;
+    byModel[model].cost   += e.costEstimated   ?? 0;
+  }
+
+  const costSaved    = estimateTokenCost('default', tokensSaved);
+  const savingsRate  = (tokensSaved + totalTokens) > 0
+    ? tokensSaved / (tokensSaved + totalTokens)
+    : 0;
+
+  // Trend: compare first half vs second half savings rate
+  const mid   = Math.floor(all.length / 2);
+  const first = all.slice(0, mid);
+  const second = all.slice(mid);
+  const halfSavings = (half) => {
+    const ts = half.reduce((s, e) => s + (e.tokensSaved ?? 0), 0);
+    const tt = half.reduce((s, e) => s + (e.tokensEstimated ?? 0), 0);
+    return (ts + tt) > 0 ? ts / (ts + tt) : 0;
+  };
+  let trend = 'stable';
+  if (all.length >= 4) {
+    const delta = halfSavings(second) - halfSavings(first);
+    if (delta > 0.05)       trend = 'improving';
+    else if (delta < -0.05) trend = 'degrading';
+  }
+
+  return {
+    period: `${days} days`,
+    totalCost, totalTokens, totalActions: all.length,
+    cacheHits, tokensSaved, costSaved, savingsRate,
+    byTier, byModel, trend,
+  };
+}
+
+export function formatCostReport(summary) {
+  const {
+    period, totalCost, totalTokens, totalActions,
+    cacheHits, tokensSaved, costSaved, savingsRate,
+    byTier, byModel, trend,
+  } = summary;
+
+  const lines = [`COST EFFICIENCY (${period})`];
+
+  const fmtK = (n) => n >= 1000 ? `${Math.round(n / 1000)}K` : String(Math.round(n));
+  const fmtD = (n) => `~$${n.toFixed(2)}`;
+
+  lines.push(`  Total: ${fmtD(totalCost)} (${fmtK(totalTokens)} tokens, ${totalActions} actions)`);
+
+  if (cacheHits > 0) {
+    const pct = Math.round(savingsRate * 100);
+    lines.push(`  Saved: ${fmtD(costSaved)} (${fmtK(tokensSaved)} tokens from ${cacheHits} cache hits)`);
+    lines.push(`  Savings rate: ${pct}%`);
+  }
+
+  const tierOrder = ['recall', 'quick', 'standard', 'deep', 'ultra'];
+  const tierKeys  = [...new Set([...tierOrder, ...Object.keys(byTier)])].filter(k => byTier[k]);
+  if (tierKeys.length > 0) {
+    lines.push('');
+    lines.push('  Tier breakdown:');
+    for (const tier of tierKeys) {
+      const t = byTier[tier];
+      const isRecall = tier === 'recall' && (t.cost < 0.001 || t.tokens === 0);
+      const costStr  = isRecall ? '$0.00  (cache hits!)' : fmtD(t.cost);
+      lines.push(`    ${tier.padEnd(10)}${String(t.count).padStart(4)} actions  ${costStr}`);
+    }
+  }
+
+  const trendIcon = trend === 'improving' ? '↗' : trend === 'degrading' ? '↘' : '→';
+  lines.push('');
+  if (trend !== 'stable') {
+    const pct = Math.round(Math.abs(savingsRate) * 100);
+    lines.push(`  Trend: ${trendIcon} ${trend} (savings rate ${trend === 'improving' ? 'up' : 'down'} vs last half)`);
+  } else {
+    lines.push(`  Trend: ${trendIcon} stable`);
+  }
+
+  return lines.join('\n');
+}
+
+export function getEfficiencyScore(cwd = process.cwd()) {
+  const summary = getCostSummary(cwd, 7);
+  if (summary.totalActions === 0) return 50;
+
+  const TIER_WEIGHTS = { recall: 0, quick: 1, standard: 2, deep: 4, ultra: 6 };
+  const totalTierCost = Object.entries(summary.byTier).reduce((s, [tier, v]) => {
+    return s + (TIER_WEIGHTS[tier] ?? 2) * v.count;
+  }, 0);
+  const maxPossible = summary.totalActions * (TIER_WEIGHTS['ultra'] ?? 6);
+  const tierScore   = maxPossible > 0 ? 1 - (totalTierCost / maxPossible) : 0.5;
+
+  const cacheScore = summary.savingsRate;
+  const trendBonus = summary.trend === 'improving' ? 10 : summary.trend === 'degrading' ? -10 : 0;
+
+  const raw = Math.round(
+    tierScore   * 40 +
+    cacheScore  * 40 +
+    20          +
+    trendBonus
+  );
+
+  return Math.max(1, Math.min(100, raw));
+}

package/src/decide.mjs

@@ -21,6 +21,34 @@ import { getProviderScore, checkCooldown } from './health.mjs';
 const __dirname  = dirname(fileURLToPath(import.meta.url));
 const WORKSPACE  = join(__dirname, '..');
 
+// ─── Model Registry (optional, lazy-loaded) ───────────────────────────────────
+
+/**
+ * Cached reference to models.mjs exports. Populated on first successful import.
+ * Remains null if models.mjs is unavailable — all callers fall back to
+ * the existing hardcoded model selection logic in that case.
+ */
+let modelRegistry = null;
+let _registryLoadAttempted = false;
+
+/**
+ * Attempt to load models.mjs once. Subsequent calls return immediately.
+ * This is intentionally fire-and-forget: decideRoute stays synchronous and
+ * reads `modelRegistry` after the Promise resolves.
+ */
+function _loadModelRegistry() {
+  if (_registryLoadAttempted) return;
+  _registryLoadAttempted = true;
+  import('./models.mjs').then(mod => {
+    modelRegistry = mod;
+  }).catch(() => {
+    // models.mjs unavailable — fall back to hardcoded logic
+  });
+}
+
+// Kick off the load immediately so it is ready before the first routing call.
+_loadModelRegistry();
+
 // ─── Work Styles ─────────────────────────────────────────────────────────────
 
 /**
@@ -362,6 +390,46 @@ function pickOpenAIModel(detection, available) {
   return available[0] ?? 'gpt-4o-mini';
 }
 
+/**
+ * Normalize a full model ID (e.g. 'claude-sonnet-4-6') to the short name used
+ * by the internal ranking arrays (e.g. 'sonnet'). Pass-through for names already
+ * in short form or OpenAI model IDs that don't need normalization.
+ * @param {string} model
+ * @param {string} provider  'claude'|'openai'
+ * @returns {string}
+ */
+function toShortName(model, provider) {
+  if (!model) return model;
+  const m = model.toLowerCase();
+  if (provider === 'claude') {
+    if (m.includes('haiku'))  return 'haiku';
+    if (m.includes('opus'))   return 'opus';
+    if (m.includes('sonnet')) return 'sonnet';
+  }
+  // OpenAI and already-short names pass through unchanged
+  return model;
+}
+
+/**
+ * Resolve a short model name back to the best full model ID from the registry.
+ * Used after the internal pipeline (health downgrade, profile bias, etc.) finalizes
+ * the short name, to restore the full ID when the registry is available.
+ * @param {string} shortName  e.g. 'sonnet', 'opus', 'haiku'
+ * @param {string} provider   'claude'|'openai'
+ * @param {string} tier       'search'|'execute'|'think'
+ * @returns {string}          Full model ID, or shortName if registry unavailable
+ */
+function toFullModelId(shortName, provider, tier) {
+  if (!modelRegistry) return shortName;
+  const registryProvider = provider === 'claude' ? 'anthropic' : 'openai';
+  // Map short name back to a taskType for the registry lookup
+  const taskType = tier === 'search' ? 'search' : tier === 'think' ? 'think' : 'execute';
+  const candidates = modelRegistry.getModelsForTask(taskType, registryProvider);
+  // Find the registry entry whose name substring matches the short name
+  const match = candidates.find(m => m.id.toLowerCase().includes(shortName.toLowerCase()));
+  return match ? match.id : shortName;
+}
+
 function applyHealthDowngrade(model, score, provider, available, isHighStakes) {
   // score=100 healthy, score=50 degraded, score=25 probing, score=0 hot
   // If score is 0 (hot) and this isn't high-stakes, downgrade one tier
@@ -614,10 +682,10 @@ function applyCriticalRiskFloor(model, provider, available, risk) {
 
 /**
  * Main routing decision function.
- * @param {{ profile: object, detection: object, cwd?: string }} input
+ * @param {{ profile: object, detection: object, cwd?: string, thinkResult?: object }} input
  * @returns {object} Routing decision
  */
-export function decideRoute({ profile = {}, detection = {}, cwd } = {}) {
+export function decideRoute({ profile = {}, detection = {}, cwd, thinkResult } = {}) {
   const available = getAvailableModels(profile);
 
   // Resolve active work style
@@ -665,24 +733,104 @@ export function decideRoute({ profile = {}, detection = {}, cwd } = {}) {
   // Select base model using work style worker assignments.
   // For Claude primary: use complexWorker (opus) on deep reasoning, defaultWorker (sonnet) otherwise.
   // For OpenAI primary: mirror the same logic using GPT equivalents.
-  let model;
-  if (provider === 'claude') {
+  //
+  // Hardcoded fallback models (used when model registry is unavailable):
+  const _fallbackClaude = (() => {
     const wantOpus = needsDeepReasoning && workStyle.key !== 'fast';
-    model = wantOpus && available.claude.includes('opus') ? 'opus' : 'sonnet';
-    if (!available.claude.includes(model)) model = available.claude[available.claude.length - 1] ?? 'sonnet';
-  } else {
-    // OpenAI primary — use o3 for deep reasoning in fullpower, gpt-4o otherwise
+    const fb = wantOpus && available.claude.includes('opus') ? 'opus' : 'sonnet';
+    return available.claude.includes(fb) ? fb : (available.claude[available.claude.length - 1] ?? 'sonnet');
+  })();
+  const _fallbackOpenAI = (() => {
     const wantO3 = needsDeepReasoning && workStyle.key === 'fullpower';
-    model = wantO3 && available.openai.includes('o3') ? 'o3' : 'gpt-4o';
-    if (!available.openai.includes(model)) model = available.openai[available.openai.length - 1] ?? 'gpt-4o';
+    const fb = wantO3 && available.openai.includes('o3') ? 'o3' : 'gpt-4o';
+    return available.openai.includes(fb) ? fb : (available.openai[available.openai.length - 1] ?? 'gpt-4o');
+  })();
+
+  let model;
+  if (modelRegistry) {
+    // Use registry to pick best model for the tier/provider.
+    // Map decide.mjs tier to registry taskType and constraints.
+    const registryProvider = provider === 'claude' ? 'anthropic' : 'openai';
+    const taskType = tier === 'search' ? 'search'
+      : tier === 'think'  ? 'think'
+      : 'execute';
+    const constraints = {
+      provider: registryProvider,
+      ...(tier === 'search' && { preferSpeed: true }),
+      ...(tier === 'think'  && { requireReasoning: true }),
+      ...(!needsDeepReasoning && workStyle.key === 'fast' && { maxCost: 'medium' }),
+    };
+    const registryResult = modelRegistry.getBestModel(taskType, constraints);
+    if (registryResult) {
+      // Registry returns full model IDs (e.g. 'claude-sonnet-4-6').
+      // dispatch.mjs mapToAgentModel handles both short names and full IDs.
+      model = registryResult.id;
+    } else {
+      // Registry found no match — use hardcoded fallback
+      model = provider === 'claude' ? _fallbackClaude : _fallbackOpenAI;
+    }
+  } else {
+    // Registry unavailable — use existing hardcoded selection
+    model = provider === 'claude' ? _fallbackClaude : _fallbackOpenAI;
   }
 
+  // The internal pipeline (health downgrade, profile bias, safety floor) operates on
+  // short model names ('haiku', 'sonnet', 'opus', 'gpt-4o', etc.) and the available[]
+  // arrays use the same short names. Normalize a full model ID to short name first so
+  // that rank lookups work correctly, then restore the full ID at the end.
+  model = toShortName(model, provider);
+
   // Apply health-based downgrade (only if score < 50 and not high-stakes)
   model = applyHealthDowngrade(model, healthScores[provider], provider, available[provider], isHighStakes);
 
   // Apply profile mode bias (cost-saver / quality-first / preferences) using patched profile
   model = applyProfileBias(model, profileWithEffectiveBias, provider, available[provider], detection.tier);
 
+  // Think-engine tier hint: use as a HINT to allow cheaper model when think-engine
+  // classifies the task as recall/quick. Never escalate — only downgrade when safe to do so.
+  let thinkTier = null;
+  try {
+    if (thinkResult?.tier) thinkTier = thinkResult.tier;
+  } catch (e) {}
+
+  if (thinkTier && !isHighStakes) {
+    const claudeRankAsc = ['haiku', 'sonnet', 'opus'];
+    const openaiRankAsc = ['gpt-4o-mini', 'gpt-4.1-mini', 'gpt-4.1', 'gpt-4o', 'o4-mini', 'o3'];
+
+    if (thinkTier === 'recall' && provider === 'claude') {
+      // recall → haiku is fine if available
+      const target = 'haiku';
+      const currentIdx = claudeRankAsc.indexOf(model);
+      const targetIdx  = claudeRankAsc.indexOf(target);
+      if (targetIdx !== -1 && targetIdx < currentIdx && available.claude.includes(target)) {
+        model = target;
+      }
+    } else if (thinkTier === 'recall' && provider === 'openai') {
+      const target = 'gpt-4o-mini';
+      const currentIdx = openaiRankAsc.indexOf(model);
+      const targetIdx  = openaiRankAsc.indexOf(target);
+      if (targetIdx !== -1 && targetIdx < currentIdx && available.openai.includes(target)) {
+        model = target;
+      }
+    } else if (thinkTier === 'quick' && provider === 'claude') {
+      // quick → sonnet is sufficient
+      const target = 'sonnet';
+      const currentIdx = claudeRankAsc.indexOf(model);
+      const targetIdx  = claudeRankAsc.indexOf(target);
+      if (targetIdx !== -1 && targetIdx < currentIdx && available.claude.includes(target)) {
+        model = target;
+      }
+    } else if (thinkTier === 'quick' && provider === 'openai') {
+      const target = 'gpt-4o';
+      const currentIdx = openaiRankAsc.indexOf(model);
+      const targetIdx  = openaiRankAsc.indexOf(target);
+      if (targetIdx !== -1 && targetIdx < currentIdx && available.openai.includes(target)) {
+        model = target;
+      }
+    }
+    // 'standard', 'deep', 'ultra' — leave model unchanged; existing routing already picked correctly
+  }
+
   // Safety floor: critical-risk tasks must never use haiku/gpt-4.1-mini even in cost-saver mode
   model = applyCriticalRiskFloor(model, provider, available[provider], detection.risk);
 
@@ -694,6 +842,10 @@ export function decideRoute({ profile = {}, detection = {}, cwd } = {}) {
     }
   }
 
+  // Restore full model ID from registry if the pipeline kept the same short name it started with.
+  // If the pipeline changed the model (downgrade/bias/floor), resolve the new short name to a full ID.
+  model = toFullModelId(model, provider, tier);
+
   // ── Challenger / dual-brain decision ─────────────────────────────────────
   const hasBothProviders = !!(
     profile?.providers?.claude?.enabled &&

package/src/dispatch.mjs

@@ -702,6 +702,17 @@ async function dispatch(input = {}) {
   // that this agent call came through the official pipeline.
   prompt = _prependDispatchMarker(prompt);
 
+  // ── Situation brief injection ────────────────────────────────────────────────
+  // Prepend a compact project-state summary when provided by the pipeline.
+  // This gives every dispatched agent immediate context about the project reality.
+  const situationBrief = typeof input.situationBrief === 'string' && input.situationBrief.trim()
+    ? input.situationBrief.trim()
+    : null;
+  if (situationBrief) {
+    prompt = `--- SITUATION BRIEF ---\n${situationBrief}\n--- END BRIEF ---\n\n${prompt}`;
+  }
+  // ── End situation brief ──────────────────────────────────────────────────────
+
   // ── Specialist prompt injection ──────────────────────────────────────────────
   const specialist = decision.specialist && decision.specialist !== 'generic'
     ? decision.specialist
@@ -764,8 +775,26 @@ async function dispatch(input = {}) {
   }
 
   const effectiveProvider = validated.provider;
-  const effectiveModel    = validated.model ?? decision.model ?? 'sonnet';
-  const effectiveDecision = { ...validated };
+  let effectiveModel    = validated.model ?? decision.model ?? 'sonnet';
+  let effectiveDecision = { ...validated };
+
+  // modelSuggestion influence: if the pipeline provided a model suggestion from models.mjs,
+  // apply it when the current model is a tier default/fallback (not an explicit override).
+  // The suggestion is advisory — it only applies when the decision didn't pin a specific model.
+  if (input.modelSuggestion?.model && effectiveProvider === 'claude') {
+    const TIER_DEFAULTS = new Set(['haiku', 'sonnet', 'opus']);
+    const decisionModelExplicit = decision._explicit?.model ?? false;
+    const isDefault = !decisionModelExplicit && TIER_DEFAULTS.has(effectiveModel);
+    if (isDefault) {
+      const suggestedAlias = mapToAgentModel(input.modelSuggestion.model, effectiveDecision.tier ?? 'execute');
+      const validList = VALID_MODELS[effectiveProvider] ?? [];
+      if (validList.includes(suggestedAlias)) {
+        effectiveModel = suggestedAlias;
+        effectiveDecision = { ...effectiveDecision, model: suggestedAlias };
+        if (verbose) process.stderr.write(`\x1b[2m[dual-brain] modelSuggestion applied: ${suggestedAlias} (${input.modelSuggestion.reason})\x1b[0m\n`);
+      }
+    }
+  }
 
   // ── Feature 2: Dirty-worktree guard for execute-tier dispatches ──────────
   if (tier === 'execute' && decision.owns && !decision._force) {
@@ -1018,6 +1047,15 @@ async function dispatchDualBrain(input = {}) {
   // Stamp with dispatch marker so enforce-tier.mjs allows this Agent call
   prompt = _prependDispatchMarker(prompt);
 
+  // ── Situation brief injection ────────────────────────────────────────────────
+  const _dualBrainBrief = typeof input.situationBrief === 'string' && input.situationBrief.trim()
+    ? input.situationBrief.trim()
+    : null;
+  if (_dualBrainBrief) {
+    prompt = `--- SITUATION BRIEF ---\n${_dualBrainBrief}\n--- END BRIEF ---\n\n${prompt}`;
+  }
+  // ── End situation brief ──────────────────────────────────────────────────────
+
   // Feature 1: Validate both sub-decisions before spawning anything
   const rt = await detectRuntime();
   const tier = decision.tier ?? 'execute';