dual-brain 0.1.8 → 0.1.9

package/bin/dual-brain.mjs

@@ -1241,107 +1241,22 @@ function detectInterruptedWork(sessions, cwd) {
   };
 }
 
-// ─── Budget sparkline helpers ─────────────────────────────────────────────────
-
-/** Token quotas per plan (5-hour window aggregate). Mirrors src/decide.mjs SUB_QUOTAS. */
-const _SPARKLINE_QUOTAS = {
-  claude: { '$20': 402_500, '$100': 1_638_000, '$200': 4_120_000 },
-  openai: { '$20': 400_000, '$100': 1_050_000, '$200': 1_900_000 },
-};
+// ─── Provider status helpers ───────────────────────────────────────────────────
 
 const _PLAN_PRICE_MAP = {
   pro: '$20', max5: '$100', max20: '$200',
   plus: '$20', pro100: '$100', pro200: '$200',
 };
 
-/**
- * Read 5-hour usage entries from .dualbrain/usage/ logs.
- * @param {string} cwd
- * @returns {Array<object>}
- */
-function _readFiveHrUsage(cwd) {
-  const FIVE_HRS_MS = 5 * 60 * 60 * 1000;
-  const now    = Date.now();
-  const cutoff = now - FIVE_HRS_MS;
-  const usageDir = join(cwd, '.dualbrain', 'usage');
-  const entries = [];
-  for (let i = 0; i <= 1; i++) {
-    const date = new Date(now - i * 86_400_000).toISOString().slice(0, 10);
-    const file = join(usageDir, `usage-${date}.jsonl`);
-    if (!existsSync(file)) continue;
-    let raw;
-    try { raw = readFileSync(file, 'utf8'); } catch { continue; }
-    for (const line of raw.split('\n')) {
-      if (!line.trim()) continue;
-      let rec;
-      try { rec = JSON.parse(line); } catch { continue; }
-      const ts = Date.parse(rec.timestamp);
-      if (!isNaN(ts) && ts >= cutoff) entries.push(rec);
-    }
-  }
-  return entries;
-}
-
-/**
- * Build a 5-char sparkline bar: \u2593\u2593\u2593\u2591\u2591 where \u2593 = used quota.
- * @param {number} used  tokens used
- * @param {number} quota total token quota
- * @returns {string}
- */
-function _sparkBar(used, quota) {
-  if (!quota || quota <= 0) return '\u2591\u2591\u2591\u2591\u2591';
-  const filled = Math.min(5, Math.round((used / quota) * 5));
-  return '\u2593'.repeat(filled) + '\u2591'.repeat(5 - filled);
-}
-
-/**
- * Return per-sub usage bar strings for a provider.
- * @param {string} provKey  'claude' | 'openai'
- * @param {object} profile
- * @param {Array<object>} fiveHrEntries
- * @returns {string}  e.g. "$100 \u2593\u2593\u2591\u2591\u2591  $100 \u2593\u2591\u2591\u2591\u2591"
- */
-function _buildSubBars(provKey, profile, fiveHrEntries) {
-  const providerCfg = profile?.providers?.[provKey];
-  if (!providerCfg) return '';
-
-  const rawSubs = providerCfg.subs?.length
-    ? providerCfg.subs
-    : providerCfg.plan
-      ? [{ plan: providerCfg.plan }]
-      : [];
-  if (rawSubs.length === 0) return '';
-
-  let totalUsed = 0;
-  for (const e of fiveHrEntries) {
-    if (e.provider !== provKey) continue;
-    const inp = e.input_tokens ?? 0;
-    const out = e.output_tokens ?? 0;
-    totalUsed += inp + out > 0 ? inp + out : 8_000;
-  }
-  const perSub = rawSubs.length > 1 ? Math.round(totalUsed / rawSubs.length) : totalUsed;
-
-  return rawSubs.map(s => {
-    const planKey   = _PLAN_PRICE_MAP[s.plan] || s.plan || '$100';
-    const quota     = _SPARKLINE_QUOTAS[provKey]?.[planKey] ?? 1_000_000;
-    const sparkline = _sparkBar(perSub, quota);
-    return `${planKey} ${sparkline}`;
-  }).join('  ');
-}
-
 /**
  * Build a provider status string for the dashboard status line.
- * Shows per-sub usage sparkline bars: "\u25cf Claude $100 \u2593\u2593\u2591\u2591\u2591  \u25cf OpenAI $100 \u2593\u2591\u2591\u2591\u2591"
+ * Shows: "● Claude $100  ● OpenAI $100"
  * Uses ANSI color codes for the dots (no emoji width issues).
  */
 function buildProviderStatusLine(profile, auth) {
-  const GREEN = '\x1b[32m\u25cf\x1b[0m';
-  const RED   = '\x1b[31m\u25cf\x1b[0m';
+  const GREEN = '●';
+  const RED   = '●';
   const now   = Date.now();
-  const cwd   = process.cwd();
-
-  let fiveHrEntries = [];
-  try { fiveHrEntries = _readFiveHrUsage(cwd); } catch {}
 
   function providerSegment(provKey, displayName) {
     const sub    = profile?.providers?.[provKey];
@@ -1351,11 +1266,18 @@ function buildProviderStatusLine(profile, auth) {
     const expired = sub?.expiresAt && Date.parse(sub.expiresAt) < now;
     if (expired)  return `${RED} ${displayName}: expired`;
 
-    const dot  = GREEN;
-    const bars = _buildSubBars(provKey, profile, fiveHrEntries);
-    return bars
-      ? `${dot} ${displayName} ${bars}`
-      : `${dot} ${displayName}: connected`;
+    const rawSubs = sub?.subs?.length
+      ? sub.subs
+      : sub?.plan
+        ? [{ plan: sub.plan }]
+        : [];
+    const planLabel = rawSubs.length > 0
+      ? rawSubs.map(s => _PLAN_PRICE_MAP[s.plan] || s.plan || '$100').join(' + ')
+      : null;
+
+    return planLabel
+      ? `${GREEN} ${displayName} ${planLabel}`
+      : `${GREEN} ${displayName}: connected`;
   }
 
   const parts = [];

package/hooks/budget-balancer.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 /**
- * budget-balancer.mjs — Core budget balancing module for the Dual-Brain Orchestrator.
+ * budget-balancer.mjs — Session-level provider balance tracker for the Dual-Brain Orchestrator.
  *
- * Tracks rolling usage pressure across Claude and OpenAI providers and recommends
- * which provider should handle incoming work.
+ * Tracks relative usage of Claude vs OpenAI within the current session (5-hour window)
+ * and recommends which provider to use next based on imbalance — not fake subscription math.
  *
  * Exported API:
- *   getProviderStatus()          → current pressure per provider/tier
+ *   getProviderStatus()          → session call counts and lean direction per provider/tier
  *   chooseProvider(taskProfile)  → recommended provider + model + rationale
  *   recordUsageEvent(event)      → append a usage event to today's log
  *
@@ -28,26 +28,6 @@ const ORCHESTRATOR_CONFIG = join(__dirname, "..", "orchestrator.json");
 // ---------------------------------------------------------------------------
 
 const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
-const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
-
-/**
- * Subscription tier definitions with real token budgets.
- * Token limits are per-model-class per rolling window.
- * Sources: Anthropic pricing page, OpenAI subscription docs (May 2025).
- * These are best-effort estimates — providers adjust limits dynamically.
- */
-const SUBSCRIPTION_TIERS = {
-  claude: {
-    "$20":  { label: "Claude Pro $20",     fiveHr: { think: 22_000,  execute: 80_000,   search: 300_000 },   weekly: { think: 150_000,   execute: 600_000,   search: 2_000_000 } },
-    "$100": { label: "Claude Max x5",     fiveHr: { think: 88_000,  execute: 350_000,  search: 1_200_000 }, weekly: { think: 600_000,   execute: 2_500_000, search: 8_000_000 } },
-    "$200": { label: "Claude Max x20",    fiveHr: { think: 220_000, execute: 900_000,  search: 3_000_000 }, weekly: { think: 1_500_000, execute: 6_000_000, search: 20_000_000 } },
-  },
-  openai: {
-    "$20":  { label: "ChatGPT Plus $20",  fiveHr: { think: 20_000,  execute: 80_000,   search: 300_000 },   weekly: { think: 140_000,   execute: 560_000,   search: 2_000_000 } },
-    "$100": { label: "ChatGPT Pro $100", fiveHr: { think: 50_000,  execute: 200_000,  search: 800_000 },   weekly: { think: 350_000,   execute: 1_400_000, search: 5_000_000 } },
-    "$200": { label: "ChatGPT Pro $200", fiveHr: { think: 100_000, execute: 400_000,  search: 1_500_000 }, weekly: { think: 700_000,   execute: 2_800_000, search: 10_000_000 } },
-  },
-};
 
 /** Fallback tokens-per-call when usage log has no real token data for an entry */
 const TOKENS_PER_CALL_FALLBACK = {
@@ -56,23 +36,6 @@ const TOKENS_PER_CALL_FALLBACK = {
   think:  15_000,
 };
 
-function getSubscriptionBudgets(config) {
-  const claudePlan = config?.subscriptions?.claude?.plan || "$100";
-  const openaiPlan = config?.subscriptions?.openai?.plan || "$20";
-  const claudeTier = SUBSCRIPTION_TIERS.claude[claudePlan] || SUBSCRIPTION_TIERS.claude["$100"];
-  const openaiTier = SUBSCRIPTION_TIERS.openai[openaiPlan] || SUBSCRIPTION_TIERS.openai["$20"];
-  return {
-    claude: { fiveHr: claudeTier.fiveHr, weekly: claudeTier.weekly, label: claudeTier.label },
-    openai: { fiveHr: openaiTier.fiveHr, weekly: openaiTier.weekly, label: openaiTier.label },
-  };
-}
-
-const DEFAULT_THRESHOLDS = {
-  warm:      0.55,
-  hot:       0.75,
-  throttled: 0.90,
-};
-
 /** Default model mapping when orchestrator.json is missing provider config */
 const DEFAULT_MODELS = {
   claude: { think: "opus", execute: "sonnet", search: "haiku" },
@@ -91,12 +54,6 @@ function loadConfig() {
   }
 }
 
-function getThresholds(config, provider) {
-  return (
-    config?.providers?.[provider]?.pressure_thresholds || DEFAULT_THRESHOLDS
-  );
-}
-
 function getProviderModels(config, provider) {
   return config?.providers?.[provider]?.models || DEFAULT_MODELS[provider];
 }
@@ -212,30 +169,22 @@ function readEntriesInWindow(windowMs) {
   return entries;
 }
 
-function readRecentEntries() {
-  return readEntriesInWindow(FIVE_HOURS_MS);
-}
-
 // ---------------------------------------------------------------------------
-// Exported: getProviderStatus()
+// Session usage aggregation
 // ---------------------------------------------------------------------------
 
 /**
- * Sum actual tokens from usage entries for a provider/tier.
- * Uses real input_tokens + output_tokens when available, falls back to estimate.
+ * Count calls and tokens per provider/tier from usage entries.
+ * Returns raw counts only — no percentage math against unknowable quota.
  */
-function sumTokens(entries) {
-  const tokens = {
-    claude: { think: 0, execute: 0, search: 0 },
-    openai: { think: 0, execute: 0, search: 0 },
-  };
+function aggregateUsage(entries) {
   const calls = {
-    claude: { think: 0, execute: 0, search: 0 },
-    openai: { think: 0, execute: 0, search: 0 },
+    claude: { think: 0, execute: 0, search: 0, total: 0 },
+    openai: { think: 0, execute: 0, search: 0, total: 0 },
   };
-  const realTokenCalls = {
-    claude: { think: 0, execute: 0, search: 0 },
-    openai: { think: 0, execute: 0, search: 0 },
+  const tokens = {
+    claude: { think: 0, execute: 0, search: 0, total: 0 },
+    openai: { think: 0, execute: 0, search: 0, total: 0 },
   };
 
   for (const entry of entries) {
@@ -250,85 +199,61 @@ function sumTokens(entries) {
       }
     }
 
-    if (!provider || !tier || !tokens[provider] || tokens[provider][tier] === undefined) continue;
+    if (!provider || !calls[provider]) continue;
+    const t = (tier && calls[provider][tier] !== undefined) ? tier : null;
 
-    calls[provider][tier]++;
+    calls[provider].total++;
+    if (t) calls[provider][t]++;
 
     const inp = entry.input_tokens;
     const out = entry.output_tokens;
-    if (inp != null && out != null && (inp > 0 || out > 0)) {
-      tokens[provider][tier] += inp + out;
-      realTokenCalls[provider][tier]++;
-    } else {
-      tokens[provider][tier] += TOKENS_PER_CALL_FALLBACK[tier] || 8_000;
-    }
+    const tokCount = (inp != null && out != null && (inp > 0 || out > 0))
+      ? inp + out
+      : TOKENS_PER_CALL_FALLBACK[t] || 8_000;
+
+    tokens[provider].total += tokCount;
+    if (t) tokens[provider][t] += tokCount;
   }
 
-  return { tokens, calls, realTokenCalls };
+  return { calls, tokens };
 }
 
 /**
- * Compute rolling pressure for each provider/tier using actual token sums
- * against real subscription budgets. Returns both 5hr and weekly pressure.
- *
- * @returns {object} Status keyed by provider → tier → { pressure, weeklyPressure, state, calls, tokens, budget, weeklyBudget }
+ * Determine lean direction: which provider has been used more this session.
+ * Returns "claude", "openai", or "balanced".
  */
-function getProviderStatus() {
-  const config = loadConfig();
-  const budgets = getSubscriptionBudgets(config);
-
-  const fiveHrEntries = readEntriesInWindow(FIVE_HOURS_MS);
-  const weeklyEntries = readEntriesInWindow(SEVEN_DAYS_MS);
-
-  const fiveHr = sumTokens(fiveHrEntries);
-  const weekly = sumTokens(weeklyEntries);
-
-  const status = {};
-
-  for (const provider of ["claude", "openai"]) {
-    const thresholds = getThresholds(config, provider);
-    status[provider] = {};
-
-    for (const tier of ["think", "execute", "search"]) {
-      const tokensUsed = fiveHr.tokens[provider][tier];
-      const budget = budgets[provider].fiveHr[tier];
-      const pressure = budget > 0 ? tokensUsed / budget : 0;
-
-      const weeklyTokens = weekly.tokens[provider][tier];
-      const weeklyBudget = budgets[provider].weekly[tier];
-      const weeklyPressure = weeklyBudget > 0 ? weeklyTokens / weeklyBudget : 0;
-
-      const effectivePressure = Math.max(pressure, weeklyPressure);
-
-      let state;
-      if (effectivePressure >= (thresholds.throttled ?? DEFAULT_THRESHOLDS.throttled)) {
-        state = "throttled";
-      } else if (effectivePressure >= (thresholds.hot ?? DEFAULT_THRESHOLDS.hot)) {
-        state = "hot";
-      } else if (effectivePressure >= (thresholds.warm ?? DEFAULT_THRESHOLDS.warm)) {
-        state = "warm";
-      } else {
-        state = "healthy";
-      }
+function sessionLean(calls) {
+  const c = calls.claude.total;
+  const o = calls.openai.total;
+  const total = c + o;
+  if (total === 0) return "balanced";
+  const claudeShare = c / total;
+  if (claudeShare > 0.65) return "claude";
+  if (claudeShare < 0.35) return "openai";
+  return "balanced";
+}
 
-      status[provider][tier] = {
-        pressure,
-        weeklyPressure,
-        effectivePressure,
-        state,
-        calls: fiveHr.calls[provider][tier],
-        tokens: tokensUsed,
-        budget,
-        weeklyTokens,
-        weeklyBudget,
-        realTokenCalls: fiveHr.realTokenCalls[provider][tier],
-      };
-    }
+// ---------------------------------------------------------------------------
+// Exported: getProviderStatus()
+// ---------------------------------------------------------------------------
 
-    status[provider]._label = budgets[provider].label;
-  }
+/**
+ * Return session-level usage summary per provider/tier.
+ * No subscription quota math — just raw counts from the 5-hour window.
+ *
+ * @returns {object} { claude: { calls, tokens, lean }, openai: { calls, tokens, lean }, sessionLean }
+ */
+function getProviderStatus() {
+  const entries = readEntriesInWindow(FIVE_HOURS_MS);
+  const { calls, tokens } = aggregateUsage(entries);
+  const lean = sessionLean(calls);
 
-  return status;
+  return {
+    claude: { calls: calls.claude, tokens: tokens.claude },
+    openai: { calls: calls.openai, tokens: tokens.openai },
+    sessionLean: lean,
+    totalCalls: calls.claude.total + calls.openai.total,
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -336,7 +261,8 @@ function getProviderStatus() {
 // ---------------------------------------------------------------------------
 
 /**
- * Recommend a provider for an incoming task.
+ * Recommend a provider for an incoming task based on session imbalance,
+ * task characteristics, and profile bias.
  *
  * @param {object} taskProfile
  * @param {string} taskProfile.tier                  - search | execute | think
@@ -367,34 +293,39 @@ function chooseProvider(taskProfile = {}) {
     }
   } catch {}
 
-  const PRESSURE_PENALTY = {
-    healthy:   0,
-    warm:     15,
-    hot:      40,
-    throttled: 100,
-  };
+  const claudeCalls = status.claude.calls.total;
+  const openaiCalls = status.openai.calls.total;
+  const totalCalls  = claudeCalls + openaiCalls;
 
   const scores = {};
 
   for (const provider of ["claude", "openai"]) {
-    const tierStatus = status[provider]?.[tier] || { effectivePressure: 0, state: "healthy" };
-    const otherProvider = provider === "claude" ? "openai" : "claude";
-    const otherTierStatus = status[otherProvider]?.[tier] || { effectivePressure: 0, state: "healthy" };
-
     let score = 50;
 
+    // Context coupling: Claude handles tightly-coupled context better
     if (provider === "claude") {
       if (contextCoupling === "high")   score += 20;
       else if (contextCoupling === "medium") score += 10;
     } else {
+      // OpenAI better for isolated tasks
       if (isolation === "high")   score += 20;
       else if (isolation === "medium") score += 10;
     }
 
-    score -= PRESSURE_PENALTY[tierStatus.state] ?? 0;
+    // Session imbalance: reward the underused provider
+    if (totalCalls >= 4) {
+      const thisShare = provider === "claude"
+        ? claudeCalls / totalCalls
+        : openaiCalls / totalCalls;
+      // If heavily overused (>65% share), penalise; if underused (<35%), reward
+      if (thisShare > 0.65) score -= 20;
+      else if (thisShare < 0.35) score += 15;
+    }
 
+    // Profile bias applies to openai (positive = prefer openai more)
     if (provider === 'openai') score += profileBias;
 
+    // Penalise OpenAI for short tasks (startup overhead not worth it)
     if (provider === "openai") {
       let minTaskMs = 180_000;
       try {
@@ -416,33 +347,9 @@ function chooseProvider(taskProfile = {}) {
       }
     }
 
-    if (
-      tierStatus.effectivePressure < 0.3 &&
-      otherTierStatus.effectivePressure > 0.5
-    ) {
-      score += 20;
-    }
-
     scores[provider] = Math.round(score);
   }
 
-  // Both-providers-throttled hard stop
-  const claudeState = status.claude?.[tier]?.state;
-  const openaiState = status.openai?.[tier]?.state;
-  if (claudeState === 'throttled' && openaiState === 'throttled') {
-    const claudeP = status.claude[tier].effectivePressure;
-    const openaiP = status.openai[tier].effectivePressure;
-    const lessThrottled = claudeP <= openaiP ? 'claude' : 'openai';
-    const m = getProviderModels(config, lessThrottled);
-    return {
-      provider: lessThrottled,
-      model: m?.[tier] || DEFAULT_MODELS[lessThrottled][tier],
-      reason: `BOTH PROVIDERS THROTTLED (claude ${Math.round(claudeP * 100)}%, openai ${Math.round(openaiP * 100)}%). Using ${lessThrottled} as least-throttled. Consider waiting or downgrading tier.`,
-      scores,
-      bothThrottled: true,
-    };
-  }
-
   const winner = scores.claude >= scores.openai ? "claude" : "openai";
   const loser  = winner === "claude" ? "openai" : "claude";
 
@@ -451,12 +358,11 @@ function chooseProvider(taskProfile = {}) {
 
   // Gate model by subscription tier
   if (!isModelAvailable(model, winner, config)) {
-    const downgraded = downgradeModel(model, winner, config);
-    model = downgraded;
+    model = downgradeModel(model, winner, config);
   }
 
-  const ws = status[winner]?.[tier] || {};
-  const ls = status[loser]?.[tier] || {};
+  const winnerCalls = winner === "claude" ? claudeCalls : openaiCalls;
+  const loserCalls  = winner === "claude" ? openaiCalls : claudeCalls;
 
   let reasonParts = [];
   if (winner === "claude" && contextCoupling !== "low") {
@@ -465,13 +371,8 @@ function chooseProvider(taskProfile = {}) {
   if (winner === "openai" && isolation !== "low") {
     reasonParts.push(`isolated task`);
   }
-  const wp = (ws.effectivePressure ?? 0);
-  const lp = (ls.effectivePressure ?? 0);
-  if (wp < lp) {
-    reasonParts.push(`${winner} ${Math.round(wp * 100)}% vs ${loser} ${Math.round(lp * 100)}%`);
-  }
-  if (ws.weeklyPressure > ws.pressure) {
-    reasonParts.push(`weekly limit is binding (${Math.round(ws.weeklyPressure * 100)}%)`);
+  if (totalCalls >= 4 && winnerCalls < loserCalls) {
+    reasonParts.push(`${winner} less used this session (${winnerCalls} vs ${loserCalls} calls)`);
   }
   if (!reasonParts.length) {
     reasonParts.push(`${winner} scored ${scores[winner]} vs ${scores[loser]}`);
@@ -485,40 +386,6 @@ function chooseProvider(taskProfile = {}) {
   };
 }
 
-// ---------------------------------------------------------------------------
-// Exported: estimateWaveCost(tasks)
-// ---------------------------------------------------------------------------
-
-function estimateWaveCost(tasks) {
-  const config = loadConfig();
-  const budgets = getSubscriptionBudgets(config);
-  const status = getProviderStatus();
-
-  let totalTokens = { claude: 0, openai: 0 };
-  for (const task of tasks) {
-    const provider = task.provider || 'claude';
-    const tier = task.tier || 'execute';
-    const estimate = TOKENS_PER_CALL_FALLBACK[tier] || 8_000;
-    totalTokens[provider] += estimate;
-  }
-
-  const impact = {};
-  for (const provider of ['claude', 'openai']) {
-    if (totalTokens[provider] === 0) continue;
-    const tierStatus = status[provider]?.execute || {};
-    const remaining = Math.max(0, (tierStatus.budget || 0) - (tierStatus.tokens || 0));
-    const pctOfBudget = tierStatus.budget > 0 ? (totalTokens[provider] / tierStatus.budget) * 100 : 0;
-    impact[provider] = {
-      estimatedTokens: totalTokens[provider],
-      remaining,
-      pctOfBudget: Math.round(pctOfBudget * 10) / 10,
-      wouldExceed: totalTokens[provider] > remaining,
-    };
-  }
-
-  return { totalTokens, impact, taskCount: tasks.length };
-}
-
 // ---------------------------------------------------------------------------
 // Exported: estimateTokensForTask(task)
 // ---------------------------------------------------------------------------
@@ -570,90 +437,60 @@ function recordUsageEvent(event = {}) {
 }
 
 // ---------------------------------------------------------------------------
-// CLI rendering helpers
+// CLI rendering
 // ---------------------------------------------------------------------------
 
-function pressureBar(pressure, width = 10) {
-  const filled = Math.min(width, Math.round(pressure * width));
-  return "█".repeat(filled) + "░".repeat(width - filled);
-}
-
-function stateLabel(state) {
-  return state.padEnd(8);
-}
-
-function formatPercent(pressure) {
-  return String(Math.round(pressure * 100)).padStart(3) + "%";
-}
-
 function formatTokens(n) {
   if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
   if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
   return String(n);
 }
 
-function printStatusTable(status) {
+function printStatus(status, rec) {
   const LINE_WIDTH = 62;
   const border = "═".repeat(LINE_WIDTH - 2);
-  const blank  = " ".repeat(LINE_WIDTH - 4);
 
   const h = (text) => {
     const padded = ` ${text}`.padEnd(LINE_WIDTH - 4);
     return `║ ${padded} ║`;
   };
 
-  const row = (label, tier) => {
-    const s = status[label]?.[tier] || { effectivePressure: 0, pressure: 0, state: "healthy", tokens: 0, budget: 0 };
-    const bar = pressureBar(s.effectivePressure);
-    const pct = formatPercent(s.effectivePressure);
-    const lbl = stateLabel(s.state);
-    const used = formatTokens(s.tokens || 0);
-    const cap = formatTokens(s.budget || 0);
-    const tierLabel = tier.charAt(0).toUpperCase() + tier.slice(1);
-    const line = `  ${tierLabel.padEnd(7)}: ${bar} ${pct} ${lbl} ${used}/${cap}`;
-    return h(line);
+  const providerRow = (provider) => {
+    const s = status[provider];
+    const total = s.calls.total;
+    const toks  = formatTokens(s.tokens.total);
+    const breakdown = ["think", "execute", "search"]
+      .filter(t => s.calls[t] > 0)
+      .map(t => `${t}: ${s.calls[t]}`)
+      .join(", ");
+    const label = provider === "claude" ? "Claude" : "OpenAI";
+    const detail = breakdown ? ` (${breakdown})` : "";
+    return h(`  ${label.padEnd(7)}: ${total} calls, ~${toks} tokens${detail}`);
   };
 
-  const weeklyRow = (label, tier) => {
-    const s = status[label]?.[tier] || {};
-    if (!s.weeklyPressure || s.weeklyPressure <= 0) return null;
-    const pct = Math.round((s.weeklyPressure || 0) * 100);
-    const used = formatTokens(s.weeklyTokens || 0);
-    const cap = formatTokens(s.weeklyBudget || 0);
-    return h(`          weekly: ${pct}% (${used}/${cap})`);
-  };
-
-  const claudeLabel = status.claude?._label || "Claude Max $100";
-  const openaiLabel = status.openai?._label || "ChatGPT Plus $20";
+  const lean = status.sessionLean;
+  const leanText = lean === "balanced"
+    ? "Balanced — either provider fine"
+    : `Leaning on ${lean} — consider routing more to ${lean === "claude" ? "OpenAI" : "Claude"}`;
 
-  const rec = chooseProvider({ tier: "execute", estimatedDurationMs: 300_000, isolation: "high", contextCoupling: "low" });
   const recText = `Route execution to ${rec.provider === "openai" ? "OpenAI" : "Claude"}`;
 
   const lines = [
     `╔${border}╗`,
     h("           Provider Balance Status"),
-    h("           (token-based, real limits)"),
+    h("           (session-relative, last 5 hours)"),
     `╠${border}╣`,
-    h(claudeLabel),
-    row("claude", "think"),
-    weeklyRow("claude", "think"),
-    row("claude", "execute"),
-    weeklyRow("claude", "execute"),
-    row("claude", "search"),
-    h(blank),
-    h(openaiLabel),
-    row("openai", "think"),
-    weeklyRow("openai", "think"),
-    row("openai", "execute"),
-    weeklyRow("openai", "execute"),
-    row("openai", "search"),
+    h("Session usage:"),
+    providerRow("claude"),
+    providerRow("openai"),
     `╠${border}╣`,
+    h(`Session lean: ${leanText}`),
     h(`Recommendation: ${recText}`),
     h(`Reason: ${rec.reason}`),
     `╚${border}╝`,
   ];
 
-  console.log(lines.filter(Boolean).join("\n"));
+  console.log(lines.join("\n"));
 }
 
 // ---------------------------------------------------------------------------
@@ -662,7 +499,8 @@ function printStatusTable(status) {
 
 async function main() {
   const status = getProviderStatus();
-  printStatusTable(status);
+  const rec = chooseProvider({ tier: "execute", estimatedDurationMs: 300_000, isolation: "high", contextCoupling: "low" });
+  printStatus(status, rec);
 }
 
 // Run as CLI only when invoked directly
@@ -676,4 +514,4 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
 // ---------------------------------------------------------------------------
 // Exports
 // ---------------------------------------------------------------------------
-export { getProviderStatus, chooseProvider, recordUsageEvent, getSubscriptionBudgets, estimateWaveCost, estimateTokensForTask, isModelAvailable, downgradeModel, SUBSCRIPTION_TIERS };
+export { getProviderStatus, chooseProvider, recordUsageEvent, estimateTokensForTask, isModelAvailable, downgradeModel, classifyModel };

package/hooks/wave-orchestrator.mjs

@@ -3,7 +3,7 @@
 import { classifyRisk, extractPaths } from './risk-classifier.mjs';
 import { resolveDependencies } from './plan-generator.mjs';
 import { dispatchGptTask } from './gpt-work-dispatcher.mjs';
-import { getProviderStatus, chooseProvider, estimateWaveCost, estimateTokensForTask } from './budget-balancer.mjs';
+import { getProviderStatus, chooseProvider, estimateTokensForTask } from './budget-balancer.mjs';
 import { recordDecision, recordOutcome } from './decision-ledger.mjs';
 import { classifyTask, selectModelEffort } from './task-classifier.mjs';
 import { getCapabilities, getDispatchConfig, recommendEffort } from './model-registry.mjs';
@@ -507,11 +507,12 @@ function routeTasks(tasks) {
     // Use task-classifier for capability-aware model+effort selection
     const profile = classifyTask(task.description, { files });
     const estimatedTokens = estimateTokensForTask({ tier, effort: profile.effort, fileCount: files.length });
+    // Derive rough pressure from session call imbalance (0=balanced, 1=all one provider)
+    const totalSessionCalls = (status.claude?.calls?.total ?? 0) + (status.openai?.calls?.total ?? 0);
+    const claudeShare = totalSessionCalls > 0 ? (status.claude?.calls?.total ?? 0) / totalSessionCalls : 0.5;
+    const sessionImbalance = Math.abs(claudeShare - 0.5) * 2; // 0=balanced, 1=fully one-sided
     const selection = selectModelEffort(profile, {
-      budgetPressure: Math.max(
-        status.claude?.[tier]?.effectivePressure ?? 0,
-        status.openai?.[tier]?.effectivePressure ?? 0,
-      ) / 100,
+      budgetPressure: sessionImbalance * 0.5, // scale to [0, 0.5] — soft signal only
       estimatedTokens,
       isIterating: (task.retryCount || 0) > 0,
     });
@@ -1227,20 +1228,23 @@ async function orchestrate(utterance, opts = {}) {
     saveManifest(manifest);
     printDispatchTable(manifest);
 
-    // Pre-dispatch spend estimate
+    // Pre-dispatch token estimate (indicative only — no subscription quota math)
     const allTasks = manifest.waves.flatMap(w => w.tasks);
-    const costEstimate = estimateWaveCost(allTasks);
-    if (costEstimate.impact.claude || costEstimate.impact.openai) {
-      console.log('\n--- Pre-dispatch cost estimate ---');
-      for (const [prov, est] of Object.entries(costEstimate.impact)) {
+    const tokensByProvider = { claude: 0, openai: 0 };
+    for (const task of allTasks) {
+      const prov = task.provider || 'claude';
+      if (tokensByProvider[prov] !== undefined) {
+        tokensByProvider[prov] += estimateTokensForTask({ tier: task.tier, effort: task.effort, files: task.files });
+      }
+    }
+    console.log('\n--- Pre-dispatch token estimate ---');
+    for (const [prov, toks] of Object.entries(tokensByProvider)) {
+      if (toks > 0) {
         const label = prov === 'claude' ? 'Claude' : 'OpenAI';
-        console.log(`  ${label}: ~${(est.estimatedTokens / 1000).toFixed(1)}K tokens (${est.pctOfBudget}% of 5hr budget, ${(est.remaining / 1000).toFixed(1)}K remaining)`);
-        if (est.wouldExceed) {
-          console.log(`  WARNING: Estimated usage EXCEEDS remaining ${label} budget!`);
-        }
+        console.log(`  ${label}: ~${(toks / 1000).toFixed(1)}K tokens estimated`);
       }
-      console.log('');
     }
+    console.log('');
 
     if (opts.dryRun) {
       manifest.status = 'dry-run';
@@ -1251,7 +1255,6 @@ async function orchestrate(utterance, opts = {}) {
     // Auto-confirm in non-interactive mode (--yes flag or piped input)
     if (!opts.confirmed && !opts.yes) {
       manifest.status = 'awaiting-confirmation';
-      manifest.costEstimate = costEstimate;
       saveManifest(refreshCounts(manifest));
       console.log(`Dispatch plan ready. Execute with: node hooks/wave-orchestrator.mjs --resume ${manifest.manifestId}`);
       console.log('Or pass --yes to skip confirmation.');
@@ -1275,18 +1278,18 @@ async function orchestrate(utterance, opts = {}) {
       const wave = manifest.waves[i];
       if (wave.status === 'completed') continue;
 
-      // Per-wave spend check
-      const waveCost = estimateWaveCost(wave.tasks);
-      for (const [prov, est] of Object.entries(waveCost.impact)) {
-        if (est.wouldExceed) {
-          console.error(`[SPEND CAP] Wave ${wave.waveId} would exceed ${prov} budget (${(est.estimatedTokens / 1000).toFixed(1)}K estimated, ${(est.remaining / 1000).toFixed(1)}K remaining). Pausing.`);
-          manifest.status = 'paused';
-          manifest.pauseReason = `spend_cap:${prov}`;
-          saveManifest(refreshCounts(manifest));
-          console.error(`Resume with: node hooks/wave-orchestrator.mjs --resume ${manifest.manifestId}`);
-          return manifest;
+      // Per-wave token estimate (informational — no quota enforcement since quota is unknowable)
+      const waveTokens = { claude: 0, openai: 0 };
+      for (const task of wave.tasks) {
+        const prov = task.provider || 'claude';
+        if (waveTokens[prov] !== undefined) {
+          waveTokens[prov] += estimateTokensForTask({ tier: task.tier, effort: task.effort, files: task.files });
         }
       }
+      const waveTotalK = Object.values(waveTokens).reduce((s, v) => s + v, 0) / 1000;
+      if (waveTotalK > 0) {
+        console.log(`[wave ${wave.waveId}] Estimated ~${waveTotalK.toFixed(1)}K tokens across providers`);
+      }
 
       wave.checkpoint = gitCheckpoint(manifest, wave.waveId);
       saveManifest(refreshCounts(manifest));

package/package.json

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

package/src/decide.mjs

@@ -6,25 +6,19 @@
  * to use and explains why in one sentence.
  *
  * Exports: decideRoute, getModelCapabilities, getAvailableModels,
- *          estimateBudgetPressure, shouldDualBrain, explainDecision, getFailoverOrder,
- *          getOptimalSub
+ *          estimateBudgetPressure, shouldDualBrain, explainDecision, getFailoverOrder
  *
  * CLI: node src/decide.mjs --profile /path/to/profile.json \
  *        --detection '{"intent":"edit","risk":"low","complexity":"simple","effort":"medium","tier":"execute"}'
  */
 
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'fs';
+import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { getProviderScore, checkCooldown } from './health.mjs';
 
 const __dirname  = dirname(fileURLToPath(import.meta.url));
 const WORKSPACE  = join(__dirname, '..');
-const USAGE_DIR  = join(WORKSPACE, '.dualbrain', 'usage');
-const AUDIT_DIR  = join(WORKSPACE, '.dualbrain', 'audit');
-const FIVE_HRS_MS  = 5 * 60 * 60 * 1000;
-const SEVEN_DAY_MS = 7 * 24 * 60 * 60 * 1000;
-
 // ─── Subscription token quotas (mirrors budget-balancer.mjs) ─────────────────
 
 /** Per-plan aggregate token budgets for the two rolling windows. */
@@ -133,9 +127,6 @@ const OPENAI_MODELS_BY_PLAN = {
   '$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)
-const TOKEN_FALLBACK = { search: 2_500, execute: 8_000, think: 15_000 };
-
 // ─── Exported: getModelCapabilities ──────────────────────────────────────────
 
 /**
@@ -489,217 +480,6 @@ export function parsePreferences(preferences) {
   return signals;
 }
 
-// ─── Exported: getOptimalSub ─────────────────────────────────────────────────
-
-/**
- * Read usage log entries within a given window (ms).
- * Scans .dualbrain/usage/usage-YYYY-MM-DD.jsonl files.
- * @param {number} windowMs
- * @returns {Array<object>}
- */
-function _readUsageInWindow(windowMs) {
-  const now = Date.now();
-  const cutoff = now - windowMs;
-  const entries = [];
-  const daysBack = Math.ceil(windowMs / 86_400_000) + 1;
-  const seen = new Set();
-  for (let i = 0; i < daysBack; i++) {
-    const date = new Date(now - i * 86_400_000).toISOString().slice(0, 10);
-    if (seen.has(date)) continue;
-    seen.add(date);
-    const file = join(USAGE_DIR, `usage-${date}.jsonl`);
-    if (!existsSync(file)) continue;
-    let raw;
-    try { raw = readFileSync(file, 'utf8'); } catch { continue; }
-    for (const line of raw.split('\n')) {
-      if (!line.trim()) continue;
-      let rec;
-      try { rec = JSON.parse(line); } catch { continue; }
-      const ts = Date.parse(rec.timestamp);
-      if (!isNaN(ts) && ts >= cutoff) entries.push(rec);
-    }
-  }
-  return entries;
-}
-
-/**
- * Sum tokens used by a specific provider from usage entries.
- * @param {Array<object>} entries
- * @param {string} provider
- * @returns {number}
- */
-function _sumProviderTokens(entries, provider) {
-  let total = 0;
-  for (const e of entries) {
-    if (e.provider !== provider) continue;
-    const inp = e.input_tokens ?? 0;
-    const out = e.output_tokens ?? 0;
-    total += inp + out > 0 ? inp + out : 8_000; // fallback estimate
-  }
-  return total;
-}
-
-/**
- * Log an autopilot routing decision to .dualbrain/audit/budget-autopilot.jsonl.
- * @param {object} entry
- */
-function _logAutopilot(entry) {
-  try {
-    if (!existsSync(AUDIT_DIR)) mkdirSync(AUDIT_DIR, { recursive: true });
-    const line = JSON.stringify({ ts: new Date().toISOString(), ...entry });
-    appendFileSync(join(AUDIT_DIR, 'budget-autopilot.jsonl'), line + '\n', 'utf8');
-  } catch {
-    // Non-fatal: logging should never block routing
-  }
-}
-
-/**
- * Given a provider and profile, pick the subscription with the most remaining
- * quota — use-it-or-lose-it scoring: `remaining * (1 / hoursUntilReset)`.
- *
- * Handles single-sub and multi-sub profiles uniformly. When only one sub
- * exists, returns it immediately (no log written for single-sub case since
- * there is no real routing decision to make).
- *
- * @param {'claude'|'openai'} provider
- * @param {'search'|'execute'|'think'} tier
- * @param {object} profile
- * @returns {{
- *   subIndex: number,
- *   plan: string,
- *   label: string|null,
- *   fiveHrUsed: number,
- *   weeklyUsed: number,
- *   fiveHrQuota: number,
- *   weeklyQuota: number,
- *   fiveHrRemaining: number,
- *   weeklyRemaining: number,
- *   score: number,
- *   reason: string,
- * }|null}
- */
-export function getOptimalSub(provider, tier, profile) {
-  const providerCfg = profile?.providers?.[provider];
-  if (!providerCfg) return null;
-
-  // Normalise to an array of subs
-  const subs = providerCfg.subs?.length
-    ? providerCfg.subs
-    : providerCfg.plan
-      ? [{ plan: providerCfg.plan, label: providerCfg.label || null }]
-      : [];
-
-  if (subs.length === 0) return null;
-
-  // Short-circuit for single-sub: skip usage read and logging overhead
-  if (subs.length === 1) {
-    const s = subs[0];
-    const plan = s.plan || '$100';
-    const quotas = SUB_QUOTAS[provider]?.[plan] ?? { fiveHr: 1_000_000, weekly: 7_000_000 };
-    return {
-      subIndex: 0,
-      plan,
-      label: s.label ?? null,
-      fiveHrUsed: 0,
-      weeklyUsed: 0,
-      fiveHrQuota: quotas.fiveHr,
-      weeklyQuota: quotas.weekly,
-      fiveHrRemaining: quotas.fiveHr,
-      weeklyRemaining: quotas.weekly,
-      score: quotas.fiveHr,
-      reason: 'only sub available',
-    };
-  }
-
-  // Multi-sub: read usage logs once for both windows
-  const fiveHrEntries = _readUsageInWindow(FIVE_HRS_MS);
-  const weeklyEntries = _readUsageInWindow(SEVEN_DAY_MS);
-
-  // We cannot distinguish sub-level usage from the log (no subIndex field),
-  // so we divide total provider usage evenly across subs as a best-effort proxy.
-  const fiveHrTotal = _sumProviderTokens(fiveHrEntries, provider);
-  const weeklyTotal = _sumProviderTokens(weeklyEntries, provider);
-  const perSubFiveHr = Math.round(fiveHrTotal / subs.length);
-  const perSubWeekly = Math.round(weeklyTotal / subs.length);
-
-  // Score each sub
-  const now = Date.now();
-  const fiveHrResetMs = FIVE_HRS_MS; // window always resets from now in a rolling sense
-  const weeklyResetMs = SEVEN_DAY_MS;
-
-  let best = null;
-  let bestScore = -Infinity;
-  const alternatives = [];
-
-  subs.forEach((s, i) => {
-    const plan = s.plan || '$100';
-    const quotas = SUB_QUOTAS[provider]?.[plan] ?? { fiveHr: 1_000_000, weekly: 7_000_000 };
-
-    const fiveHrRemaining = Math.max(0, quotas.fiveHr - perSubFiveHr);
-    const weeklyRemaining = Math.max(0, quotas.weekly - perSubWeekly);
-
-    // Binding constraint: whichever window is tighter
-    const remaining = Math.min(fiveHrRemaining, weeklyRemaining);
-
-    // Hours until the tighter window resets (rolling → effectively "now + window")
-    const hoursUntilReset = fiveHrRemaining <= weeklyRemaining
-      ? (fiveHrResetMs / 3_600_000)
-      : (weeklyResetMs / 3_600_000);
-
-    // Use-it-or-lose-it: higher score = more remaining + resets sooner
-    const score = hoursUntilReset > 0 ? remaining * (1 / hoursUntilReset) : remaining;
-
-    const pctRemaining = quotas.fiveHr > 0
-      ? Math.round((fiveHrRemaining / quotas.fiveHr) * 100)
-      : 100;
-    const resets = fiveHrRemaining <= weeklyRemaining ? '5h' : '7d';
-    const reason = `${pctRemaining}% remaining, resets in ${resets === '5h' ? 5 : 168}h`;
-
-    const info = {
-      subIndex: i,
-      plan,
-      label: s.label ?? null,
-      fiveHrUsed: perSubFiveHr,
-      weeklyUsed: perSubWeekly,
-      fiveHrQuota: quotas.fiveHr,
-      weeklyQuota: quotas.weekly,
-      fiveHrRemaining,
-      weeklyRemaining,
-      score,
-      reason,
-    };
-
-    alternatives.push(info);
-
-    if (score > bestScore) {
-      bestScore = score;
-      best = info;
-    }
-  });
-
-  // Log the autopilot decision
-  if (best) {
-    _logAutopilot({
-      provider,
-      tier,
-      subIndex: best.subIndex,
-      plan: best.plan,
-      label: best.label,
-      reason: best.reason,
-      alternatives: alternatives.map(a => ({
-        subIndex: a.subIndex,
-        plan: a.plan,
-        label: a.label,
-        score: Math.round(a.score),
-        fiveHrRemaining: a.fiveHrRemaining,
-        weeklyRemaining: a.weeklyRemaining,
-      })),
-    });
-  }
-
-  return best;
-}
-
 // ─── Internal: safety floor for critical-risk tasks ───────────────────────────
 
 /**
@@ -812,9 +592,6 @@ export function decideRoute({ profile = {}, detection = {}, cwd } = {}) {
   );
   const degradedDualBrain = !!(dual && detection.designImpact && !hasBothProviders);
 
-  // Budget autopilot: pick optimal sub when multiple subs exist for chosen provider
-  const optimalSub = getOptimalSub(provider, tier, profile);
-
   const decision = {
     provider,
     model,
@@ -822,8 +599,6 @@ export function decideRoute({ profile = {}, detection = {}, cwd } = {}) {
     tier,
     dualBrain: dual,
     ...(degradedDualBrain && { degradedDualBrain: true }),
-    ...(optimalSub && optimalSub.label != null && { subLabel: optimalSub.label }),
-    ...(optimalSub && { subIndex: optimalSub.subIndex }),
     modes,
     sandbox,
     explanation: '',