dual-brain 0.1.7 → 0.1.8

package/package.json

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

package/src/decide.mjs

@@ -6,21 +6,40 @@
  * to use and explains why in one sentence.
  *
  * Exports: decideRoute, getModelCapabilities, getAvailableModels,
- *          estimateBudgetPressure, shouldDualBrain, explainDecision, getFailoverOrder
+ *          estimateBudgetPressure, shouldDualBrain, explainDecision, getFailoverOrder,
+ *          getOptimalSub
  *
  * CLI: node src/decide.mjs --profile /path/to/profile.json \
  *        --detection '{"intent":"edit","risk":"low","complexity":"simple","effort":"medium","tier":"execute"}'
  */
 
-import { existsSync, readFileSync } from 'fs';
+import { appendFileSync, existsSync, mkdirSync, 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 FIVE_HRS_MS = 5 * 60 * 60 * 1000;
+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. */
+const SUB_QUOTAS = {
+  claude: {
+    '$20':  { fiveHr: 402_500,   weekly: 2_750_000  },
+    '$100': { fiveHr: 1_638_000, weekly: 11_100_000  },
+    '$200': { fiveHr: 4_120_000, weekly: 27_500_000  },
+  },
+  openai: {
+    '$20':  { fiveHr: 400_000,   weekly: 2_700_000  },
+    '$100': { fiveHr: 1_050_000, weekly: 6_750_000  },
+    '$200': { fiveHr: 1_900_000, weekly: 17_500_000  },
+  },
+};
 
 // ─── Slim Model Capabilities (routing-relevant only) ─────────────────────────
 
@@ -470,6 +489,217 @@ 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 ───────────────────────────
 
 /**
@@ -582,6 +812,9 @@ 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,
@@ -589,6 +822,8 @@ 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: '',

package/src/dispatch.mjs

@@ -644,6 +644,23 @@ function _prependDispatchMarker(prompt) {
   return `<!-- dual-brain-dispatch: ${runId} -->\n${prompt}`;
 }
 
+// ─── Related session age label ────────────────────────────────────────────────
+
+/**
+ * Human-readable age label for a related session date string.
+ * @param {string} isoDate
+ * @returns {string}
+ */
+function _relatedSessionAge(isoDate) {
+  const diff = Date.now() - Date.parse(isoDate);
+  const mins = Math.floor(diff / 60000);
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
 // ─── Main dispatch ────────────────────────────────────────────────────────────
 async function dispatch(input = {}) {
   const { files = [], cwd = process.cwd(), dryRun = false, verbose = false } = input;
@@ -655,6 +672,32 @@ async function dispatch(input = {}) {
   // Safety gate: redact secrets before anything reaches a subprocess or log
   prompt = redact(prompt);
 
+  // ── Related session context injection ────────────────────────────────────────
+  // Find past sessions related to this task and prepend a context block.
+  // Only injected when confidence is high (score > 5). Fast: index-only, no JSONL parsing.
+  if (!input._skipRelatedContext) {
+    try {
+      const { findRelatedSessions } = await import('./session.mjs');
+      const related = findRelatedSessions(prompt, files, cwd);
+      const highConfidence = related.filter(r => r.score > 5);
+      if (highConfidence.length > 0) {
+        const lines = highConfidence.map(r => {
+          const dateLabel = r.date ? _relatedSessionAge(r.date) : null;
+          const datePart  = dateLabel ? `, ${dateLabel}` : '';
+          const msgPart   = r.messageCount > 0 ? `, ${r.messageCount} messages` : '';
+          const fileList  = r.matchedFiles.length > 0
+            ? `: touched ${r.matchedFiles.map(f => f.split('/').pop()).join(', ')}`
+            : '';
+          return `- "${r.smartName}"${datePart}${msgPart}${fileList}`;
+        });
+        const contextBlock = `[Prior context from related sessions:]\n${lines.join('\n')}\n[End prior context]\n\n`;
+        prompt = contextBlock + prompt;
+        if (verbose) process.stderr.write(`[dual-brain] injected related session context (${highConfidence.length} sessions)\n`);
+      }
+    } catch { /* non-fatal — never block dispatch */ }
+  }
+  // ── End related session context ──────────────────────────────────────────────
+
   // Stamp the prompt with the dispatch marker so enforce-tier.mjs can recognise
   // that this agent call came through the official pipeline.
   prompt = _prependDispatchMarker(prompt);

package/src/session.mjs

@@ -1207,6 +1207,112 @@ export function searchSessions(query, cwd = process.cwd()) {
   return results.sort((a, b) => b._score - a._score);
 }
 
+/**
+ * Find sessions related to a new task prompt and file list.
+ * Uses the session index (topics + files) — does not parse full JSONL files.
+ *
+ * Scoring:
+ *   +3 for each file in common between the new task and a past session
+ *   +2 for each topic keyword in common
+ *   +1 for matching intent words (fix, refactor, test, etc.)
+ *
+ * Returns top 3 matches with score > 3, sorted by score desc.
+ * Excludes sessions from the last hour (likely the current session).
+ *
+ * @param {string}   prompt  New task prompt
+ * @param {string[]} files   File paths from the new task
+ * @param {string}   [cwd]
+ * @returns {Array<{
+ *   sessionId: string, smartName: string, score: number,
+ *   matchedFiles: string[], matchedTopics: string[],
+ *   date: string|null, messageCount: number
+ * }>}
+ */
+export function findRelatedSessions(prompt, files = [], cwd = process.cwd()) {
+  const indexPath = join(cwd, '.dualbrain', 'session-index.json');
+  let index = {};
+  try { index = JSON.parse(readFileSync(indexPath, 'utf8')); } catch { return []; }
+
+  if (Object.keys(index).length === 0) return [];
+
+  // Intent words for +1 scoring
+  const INTENT_WORDS = ['fix', 'refactor', 'test', 'add', 'update', 'review', 'debug', 'build', 'remove', 'migrate', 'deploy', 'implement', 'create'];
+
+  // Normalize the new task's prompt into words
+  const promptLower = (prompt || '').toLowerCase();
+  const promptWords = new Set(promptLower.split(/\W+/).filter(w => w.length > 3));
+
+  // Normalize the new task's file paths for comparison
+  const normalizeFile = (f) => (f || '').split('/').pop().toLowerCase().replace(/\.[^.]+$/, '');
+  const newFileNames = new Set((files || []).map(normalizeFile).filter(Boolean));
+
+  // One-hour cutoff for excluding likely-current session
+  const oneHourAgo = Date.now() - 60 * 60 * 1000;
+
+  const results = [];
+
+  for (const session of Object.values(index)) {
+    // Skip archived sessions
+    if (session.archived) continue;
+
+    // Skip sessions from the last hour
+    const sessionTs = session.date ? Date.parse(session.date) : 0;
+    if (sessionTs > oneHourAgo) continue;
+
+    let score = 0;
+    const matchedFiles = [];
+    const matchedTopics = [];
+
+    // +3 for each file in common
+    for (const sessionFile of (session.files || [])) {
+      const sessionFileName = normalizeFile(sessionFile);
+      if (sessionFileName && newFileNames.has(sessionFileName)) {
+        score += 3;
+        matchedFiles.push(sessionFile);
+      }
+    }
+
+    // +2 for each topic keyword in common with prompt words
+    for (const topic of (session.topics || [])) {
+      if (topic && promptWords.has(topic)) {
+        score += 2;
+        matchedTopics.push(topic);
+      }
+    }
+
+    // +1 for matching intent words found in both prompt and session topics/prompts
+    const sessionText = [
+      ...(session.topics || []),
+      session.prompts?.first || '',
+      session.prompts?.last  || '',
+    ].join(' ').toLowerCase();
+
+    for (const word of INTENT_WORDS) {
+      if (promptLower.includes(word) && sessionText.includes(word)) {
+        score += 1;
+        break; // only +1 total for intent words
+      }
+    }
+
+    if (score > 3) {
+      results.push({
+        sessionId:     session.id,
+        smartName:     session.smartName || session.prompts?.first?.slice(0, 40) || session.id.slice(0, 8),
+        score,
+        matchedFiles,
+        matchedTopics,
+        date:          session.date,
+        messageCount:  session.messageCount || 0,
+      });
+    }
+  }
+
+  // Return top 3 sorted by score descending
+  return results
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 3);
+}
+
 /**
  * Get detailed context for a session (for smart resume preview).
  * Reads the last 20 lines of the session JSONL to surface the most recent prompt