dual-brain 0.2.2 → 0.2.3

package/bin/dual-brain.mjs

@@ -1668,6 +1668,141 @@ function makeBoxRow(content, W) {
   return `│ ${content}${' '.repeat(padding)} │`;
 }
 
+// ─── Command palette: input classifier ───────────────────────────────────────
+
+/**
+ * Classify user input into one of three tiers:
+ *   { tier: 'free', command, args }   — deterministic, zero tokens
+ *   { tier: 'cheap' }                 — question → haiku
+ *   { tier: 'full' }                  — work task → confirm then dispatch
+ */
+function classifyInput(input) {
+  const trimmed = input.trim();
+  const lower   = trimmed.toLowerCase();
+  const parts   = trimmed.split(/\s+/);
+  const cmd     = parts[0].toLowerCase();
+  const args    = parts.slice(1);
+
+  // Tier 1: FREE — exact command matches
+  const FREE_COMMANDS = new Map([
+    ['resume', 'resume'],
+    ['r',      'resume'],
+    ['status', 'status'],
+    ['sessions', 'sessions'],
+    ['ss',     'sessions'],
+    ['settings', 'settings'],
+    ['s',      'settings'],
+    ['team',   'team'],
+    ['t',      'team'],
+    ['doctor', 'doctor'],
+    ['d',      'doctor'],
+    ['health', 'health'],
+    ['h',      'health'],
+    ['projects', 'projects'],
+    ['p',      'projects'],
+    ['help',   'help'],
+    ['?',      'help'],
+    ['quit',   'quit'],
+    ['q',      'quit'],
+    ['exit',   'quit'],
+    ['budget', 'budget'],
+    ['b',      'budget'],
+  ]);
+
+  if (FREE_COMMANDS.has(cmd)) {
+    return { tier: 'free', command: FREE_COMMANDS.get(cmd), args };
+  }
+
+  // Multi-word free commands
+  if (lower.startsWith('search ')) {
+    return { tier: 'free', command: 'search', args: parts.slice(1) };
+  }
+  if (lower === 'init --replit') {
+    return { tier: 'free', command: 'init --replit', args: [] };
+  }
+
+  // Tier 2: CHEAP — question / diagnostic patterns → haiku
+  const QUESTION_WORDS = /^(why|what|how|where|when|who|is my|check|show me|explain|tell me|list|am i|are there|does|did|can i|will|should i)/i;
+  const QUESTION_CONTAINS = /\b(why|what|how is|how are|where is|where are|explain|tell me|show me)\b/i;
+  if (QUESTION_WORDS.test(lower) || QUESTION_CONTAINS.test(lower)) {
+    return { tier: 'cheap' };
+  }
+
+  // Tier 3: FULL — everything else is a work task
+  return { tier: 'full' };
+}
+
+// ─── Dashboard: resume state detection ───────────────────────────────────────
+
+/**
+ * Detect resumable state for dashboard contextual hint.
+ * Returns an object with type ('resumable' | 'fresh' | 'none') and detail fields.
+ * All checks are best-effort and fail silent.
+ */
+async function detectResumeState(cwd) {
+  const result = { type: 'none', label: null, ageLabel: null, nextAction: null };
+
+  // Check for recent receipt (< 24h)
+  try {
+    const { getLatestReceipt } = await import('../src/receipt.mjs');
+    const receipt = getLatestReceipt(cwd);
+    if (receipt) {
+      const ageMs = Date.now() - Date.parse(receipt.timestamp);
+      if (ageMs < 24 * 60 * 60 * 1000) {
+        const mins  = Math.round(ageMs / 60000);
+        const age   = mins < 60
+          ? `${mins}m ago`
+          : mins < 1440
+            ? `${Math.round(mins / 60)}h ago`
+            : `${Math.round(mins / 1440)}d ago`;
+        const fileCount = (receipt.filesChanged || []).length;
+        const filePart  = fileCount > 0 ? ` · ${fileCount} file${fileCount !== 1 ? 's' : ''}` : '';
+        result.type       = 'resumable';
+        result.label      = (receipt.goal || 'last session').slice(0, 40);
+        result.ageLabel   = age;
+        result.filePart   = filePart;
+        result.nextAction = (receipt.nextAction || '').slice(0, 35);
+        return result;
+      }
+    }
+  } catch { /* non-fatal */ }
+
+  // Check for open tasks in ledger
+  try {
+    const { getOpenTasks } = await import('../src/ledger.mjs');
+    const open = getOpenTasks(cwd);
+    if (open.length > 0) {
+      result.type       = 'resumable';
+      result.label      = (open[0].intent || 'open task').slice(0, 40);
+      result.ageLabel   = null;
+      result.filePart   = '';
+      result.nextAction = `${open.length} open task${open.length !== 1 ? 's' : ''}`;
+      return result;
+    }
+  } catch { /* non-fatal */ }
+
+  // Check if this is a fresh project (package.json but no dual-brain history)
+  try {
+    const { existsSync: exists } = await import('node:fs');
+    const { join: pjoin } = await import('node:path');
+    const hasPkg = exists(pjoin(cwd, 'package.json'));
+    const hasHistory = exists(pjoin(cwd, '.dual-brain', 'receipts'));
+    if (hasPkg && !hasHistory) {
+      let pkgName = 'this project';
+      try {
+        const { readFileSync: rfs } = await import('node:fs');
+        const pkg = JSON.parse(rfs(pjoin(cwd, 'package.json'), 'utf8'));
+        if (pkg.name) pkgName = pkg.name;
+      } catch {}
+      result.type  = 'fresh';
+      result.label = pkgName;
+      return result;
+    }
+  } catch { /* non-fatal */ }
+
+  return result;
+}
+
 // ─── Screen: mainScreen ───────────────────────────────────────────────────────
 
 async function mainScreen(rl, ask) {
@@ -1987,11 +2122,12 @@ async function mainScreen(rl, ask) {
       const rtInfo    = replitMod.inspectReplitTools(cwd);
       const authInfo  = replitMod.getAuthStatus(cwd);
       const archive   = replitMod.getSessionArchive(cwd);
-      const archCount = Array.isArray(archive) ? archive.length : (archive?.count ?? 0);
+      const archCount = Array.isArray(archive) ? archive.length : (archive?.totalSessions ?? archive?.count ?? 0);
       const secretNames = replitMod.listSecretNames();
       const secretCount = Array.isArray(secretNames) ? secretNames.length : 0;
       const verStr = rtInfo.version ? `v${rtInfo.version}` : (rtInfo.installed ? 'installed' : 'not installed');
-      const authStr = authInfo.authenticated ? '\x1b[32m✓\x1b[0m auth' : '\x1b[2mno auth\x1b[0m';
+      const isAuthenticated = authInfo.authenticated ?? (authInfo.available && authInfo.tokenStatus === 'valid');
+      const authStr = isAuthenticated ? '\x1b[32m✓\x1b[0m auth' : '\x1b[2mno auth\x1b[0m';
       replitAwarenessRows.push(row(`\x1b[2m🔧\x1b[0m Replit  replit-tools ${verStr}  ${authStr}`));
       replitAwarenessRows.push(row(`\x1b[2m   \x1b[0m ${archCount} archived session${archCount !== 1 ? 's' : ''}  ${secretCount} secret${secretCount !== 1 ? 's' : ''}`));
     }
@@ -2058,16 +2194,41 @@ async function mainScreen(rl, ask) {
     });
   }
 
+  // ── Resume state detection ────────────────────────────────────────────────
+  let resumeStateRows = [];
+  const resumeState = await detectResumeState(cwd);
+  if (resumeState.type === 'resumable') {
+    const DIM   = '\x1b[2m';
+    const RESET = '\x1b[0m';
+    const CYAN  = '\x1b[36m';
+    const labelTrunc = resumeState.label || 'last session';
+    const agePart    = resumeState.ageLabel ? ` (${resumeState.ageLabel})` : '';
+    const filePart   = resumeState.filePart || '';
+    const nextPart   = resumeState.nextAction ? ` · next: ${resumeState.nextAction}` : '';
+    resumeStateRows = [
+      row(`${CYAN}Last:${RESET} "${labelTrunc}"${agePart}${filePart}${nextPart}`),
+      row(`${DIM}[Enter] resume  [n] new  [?] help${RESET}`),
+    ];
+  } else if (resumeState.type === 'fresh' && recentSessions.length === 0) {
+    const DIM   = '\x1b[2m';
+    const RESET = '\x1b[0m';
+    resumeStateRows = [
+      row(`New project: ${resumeState.label}`),
+      row(`${DIM}Type what you want to do  [?] help${RESET}`),
+    ];
+  }
+
   // ── Box 5 — Input bar ──────────────────────────────────────────────────
-  const actionsContent = '> type anything...   [s] settings  [t] team  [q] quit';
+  const actionsContent = '> task or command...   [?] help  [q] quit';
   const actionsRow     = row(actionsContent);
 
   // ── Print the full 5-box layout ───────────────────────────────────────────
   // Box 1: header (title + provider dots + work style)
   // Box 2: workspace (branch · uncommitted · ahead, last commit, open PRs)
   // Box 3: awareness (observer, roadmap, risk)
-  // Box 4: sessions
+  // Box 4: sessions (+ resume state hint if applicable)
   // Box 5: input bar
+  const hasResumeHint = resumeStateRows.length > 0;
   const lines = [
     top,
     row(`🧠 dual-brain v${version}`),
@@ -2078,6 +2239,7 @@ async function mainScreen(rl, ask) {
     ...awarenessRows,
     sep,
     ...sessionRows,
+    ...(hasResumeHint ? [sep, ...resumeStateRows] : []),
     sep,
     actionsRow,
     bot,
@@ -2177,7 +2339,7 @@ async function mainScreen(rl, ask) {
       // Single-key commands only fire when buffer is empty
       if (taskBuffer.length === 0) {
         const lower = str.toLowerCase();
-        const singleKeySet = new Set(['n', 's', 't', 'q', '/', 'i']);
+        const singleKeySet = new Set(['n', 's', 't', 'q', '/', 'i', '?', 'h', 'd']);
         if (singleKeySet.has(lower)) {
           cleanup();
           process.stdout.write('\n');
@@ -2203,15 +2365,124 @@ async function mainScreen(rl, ask) {
 
   const choice = typeof raw === 'string' ? raw.toLowerCase() : '';
 
-  // Typed task → dispatch as "dual-brain go"
+  // ── Typed input — run through command palette ─────────────────────────────
   if (raw.startsWith('__task__:')) {
-    const prompt = raw.slice('__task__:'.length).trim();
-    if (prompt) {
-      return { next: 'go', prompt };
+    const input = raw.slice('__task__:'.length).trim();
+    if (!input) return { next: 'main' };
+
+    const classified = classifyInput(input);
+
+    // Tier 1: FREE — deterministic, zero tokens
+    if (classified.tier === 'free') {
+      const cmd  = classified.command;
+      const args = classified.args;
+
+      if (cmd === 'resume' || cmd === 'r') {
+        if (recentSessions.length === 0) return { next: 'new-session' };
+        return { next: 'sessions' };
+      }
+      if (cmd === 'status' || cmd === 's') {
+        await cmdStatus([]);
+        await ask('\n  Press Enter to continue...');
+        return { next: 'main' };
+      }
+      if (cmd === 'sessions' || cmd === 'ss') {
+        return { next: 'sessions' };
+      }
+      if (cmd === 'settings') {
+        return { next: 'settings' };
+      }
+      if (cmd === 'team' || cmd === 't') {
+        return { next: 'team' };
+      }
+      if (cmd === 'doctor' || cmd === 'd') {
+        return { next: 'diagnostics' };
+      }
+      if (cmd === 'health' || cmd === 'h') {
+        const hooksDir  = join(cwd, '.claude', 'hooks');
+        const healthScript = join(hooksDir, 'health-check.mjs');
+        const { spawnSync: sp } = await import('node:child_process');
+        if (existsSync(healthScript)) {
+          sp('node', [healthScript], { stdio: 'inherit', cwd });
+        } else {
+          process.stdout.write('\n  health-check.mjs not found — run: dual-brain install\n');
+        }
+        await ask('\n  Press Enter to continue...');
+        return { next: 'main' };
+      }
+      if (cmd === 'help' || cmd === '?') {
+        return { next: 'palette-help' };
+      }
+      if (cmd === 'quit' || cmd === 'q') {
+        return { next: 'exit' };
+      }
+      if (cmd === 'search') {
+        const query = args.join(' ');
+        if (!query) {
+          const q2 = (await ask('  Search: ')).trim();
+          if (!q2) return { next: 'main' };
+          args.push(q2);
+        }
+        const { searchSessions, buildSessionIndex } = await import('../src/session.mjs');
+        try { buildSessionIndex(cwd); } catch {}
+        const results = searchSessions(args.join(' '), cwd);
+        if (results.length === 0) {
+          process.stdout.write(`\n  No sessions matching "${args.join(' ')}"\n\n`);
+          await ask('  Press Enter to continue...');
+          return { next: 'main' };
+        }
+        process.stdout.write(`\n  Found ${results.length} session${results.length === 1 ? '' : 's'}:\n`);
+        results.slice(0, 9).forEach((sess, i) => {
+          const tool   = sess.tool === 'codex' ? 'cdx' : 'cld';
+          const date   = sess.date ? new Date(sess.date).toLocaleDateString() : '?';
+          process.stdout.write(`  [${i + 1}] ${tool}  ${date}  ${sess.prompts.first || sess.id.slice(0, 8)}\n`);
+        });
+        process.stdout.write('\n');
+        const pick = (await ask('  Enter number to resume (or Enter to cancel): ')).trim();
+        const num  = parseInt(pick, 10);
+        if (!isNaN(num) && num >= 1 && num <= Math.min(results.length, 9)) {
+          const sess = results[num - 1];
+          const { spawnSync: sp2 } = await import('node:child_process');
+          const tool = sess.tool === 'codex' ? 'codex' : 'claude';
+          process.stdout.write(`\n  Launching: ${tool} --resume ${sess.id}\n\n`);
+          sp2(tool, ['--resume', sess.id], { stdio: 'inherit' });
+        }
+        return { next: 'main' };
+      }
+      if (cmd === 'budget') {
+        await cmdStatus([]);
+        await ask('\n  Press Enter to continue...');
+        return { next: 'main' };
+      }
+      if (cmd === 'init --replit') {
+        await cmdInit(rl);
+        return { next: 'main' };
+      }
+      // fallthrough: unknown free command → treat as full task
     }
-    return { next: 'main' };
+
+    // Tier 2: CHEAP — question/diagnostic, route to haiku
+    if (classified.tier === 'cheap') {
+      process.stdout.write(`\n  Routing to haiku for quick answer...\n`);
+      return { next: 'go', prompt: input, model: 'haiku' };
+    }
+
+    // Tier 3: FULL — work task, confirm before dispatching
+    if (classified.tier === 'full') {
+      const summary = input.length > 60 ? input.slice(0, 57) + '...' : input;
+      process.stdout.write(`\n  Launch coding session: ${summary}\n`);
+      process.stdout.write(`  Model: sonnet  [Enter] to proceed, [n] to cancel\n\n`);
+      const confirm = (await ask('  > ')).trim().toLowerCase();
+      if (confirm === 'n' || confirm === 'no') return { next: 'main' };
+      return { next: 'go', prompt: input };
+    }
+
+    // Default fallback
+    return { next: 'go', prompt: input };
   }
 
+  // ── Single-key shortcuts ───────────────────────────────────────────────────
+
   // Enter (empty) → resume most recent session
   if (raw === '' || choice === '\r') {
     if (recentSessions.length === 0) {
@@ -2225,7 +2496,7 @@ async function mainScreen(rl, ask) {
     return { next: 'main' };
   }
 
-  // Number 1-3 → resume that session
+  // Number 1-9 → resume that session
   const numChoice = parseInt(raw, 10);
   if (!isNaN(numChoice) && numChoice >= 1 && numChoice <= recentSessions.length) {
     const sess = recentSessions[numChoice - 1];
@@ -2245,6 +2516,8 @@ async function mainScreen(rl, ask) {
   }
 
   if (choice === 'n') { return { next: 'new-session' }; }
+  if (choice === '?' || choice === 'h') { return { next: 'palette-help' }; }
+  if (choice === 'd') { return { next: 'diagnostics' }; }
 
   if (choice === '/') {
     const query = (await ask('  Search: ')).trim();
@@ -2303,6 +2576,48 @@ async function newSessionScreen(rl, ask) {
   return { next: 'main' };
 }
 
+// ─── Screen: paletteHelpScreen ───────────────────────────────────────────────
+
+async function paletteHelpScreen(rl, ask) {
+  const termW = process.stdout.columns || 60;
+  const boxW  = Math.min(termW - 2, 60);
+  const W     = boxW - 4;
+  const top   = `┌${'─'.repeat(boxW - 2)}┐`;
+  const sep   = `├${'─'.repeat(boxW - 2)}┤`;
+  const bot   = `└${'─'.repeat(boxW - 2)}┘`;
+  const row   = (content) => makeBoxRow(content, W);
+  const DIM   = '\x1b[2m';
+  const RESET = '\x1b[0m';
+
+  const lines = [
+    top,
+    row('Command Palette'),
+    sep,
+    row(`${DIM}resume  r${RESET}        Resume last session`),
+    row(`${DIM}status${RESET}           Provider health + budget`),
+    row(`${DIM}sessions  ss${RESET}     List recent sessions`),
+    row(`${DIM}search <query>${RESET}   Search session history`),
+    row(`${DIM}budget  b${RESET}        Token usage + routing`),
+    row(`${DIM}health  h${RESET}        System health check`),
+    row(`${DIM}doctor  d${RESET}        Repo diagnostics`),
+    row(`${DIM}settings  s${RESET}      Settings screen`),
+    row(`${DIM}team  t${RESET}          Team screen`),
+    row(`${DIM}help  ?${RESET}          Show this help`),
+    row(`${DIM}quit  q${RESET}          Exit`),
+    sep,
+    row('Or type any task to launch a coding session'),
+    row(`${DIM}Questions (why/how/what) → haiku (cheap)${RESET}`),
+    row(`${DIM}Work tasks → confirm then dispatch${RESET}`),
+    sep,
+    row(`${DIM}[Enter] go back${RESET}`),
+    bot,
+  ];
+
+  process.stdout.write('\n' + lines.join('\n') + '\n\n');
+  await ask('');
+  return { next: 'main' };
+}
+
 // ─── Screen: importPickerScreen ──────────────────────────────────────────────
 
 async function importPickerScreen() {
@@ -4476,6 +4791,7 @@ const SCREENS = {
   welcome:          welcomeScreen,
   main:             mainScreen,
   'new-session':    newSessionScreen,
+  'palette-help':   paletteHelpScreen,
   settings:         settingsScreen,
   team:             teamScreen,
   'import-picker':  importPickerScreen,
@@ -4502,7 +4818,21 @@ async function runScreens(startScreen = 'dashboard') {
     if (current === 'go' && ctx.prompt) {
       const prompt = ctx.prompt;
       const dryRun = ctx.dryRun || false;
-      await cmdGo([prompt], { dryRun });
+      // Haiku tier: dispatch with model override for cheap question answers
+      if (ctx.model === 'haiku') {
+        process.stdout.write('\n');
+        try {
+          const { runPipeline: rp } = await import('../src/pipeline.mjs');
+          const { result } = await rp('go', prompt, { cwd: process.cwd(), dryRun, forceDepth: 'shallow' });
+          if (result?.output) process.stdout.write('\n' + String(result.output).trim() + '\n\n');
+          else process.stdout.write('  (no output)\n\n');
+        } catch (e) {
+          // Fall back to normal dispatch on error
+          await cmdGo([prompt], { dryRun });
+        }
+      } else {
+        await cmdGo([prompt], { dryRun });
+      }
       current = 'main';
       ctx = {};
       continue;
@@ -4515,7 +4845,7 @@ async function runScreens(startScreen = 'dashboard') {
       current = result?.next || 'exit';
       // Pass through context (e.g. selected session, typed prompt, openPRs) to next screen
       ctx = result?.session   ? { session: result.session }
-          : result?.prompt    ? { prompt: result.prompt }
+          : result?.prompt    ? { prompt: result.prompt, model: result.model }
           : result?.openPRs   ? { openPRs: result.openPRs }
           : {};
     } catch (e) {

package/package.json

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

package/src/dispatch.mjs

@@ -672,6 +672,20 @@ async function dispatch(input = {}) {
   // Safety gate: redact secrets before anything reaches a subprocess or log
   prompt = redact(prompt);
 
+  // ── Resume brief injection ───────────────────────────────────────────────────
+  // Inject the last session's receipt as context when no situationBrief is already set.
+  // This closes the receipt → brief → next session loop automatically.
+  if (!input.situationBrief) {
+    try {
+      const { buildResumeBrief } = await import('./receipt.mjs');
+      const brief = buildResumeBrief(cwd);
+      if (brief) {
+        input = { ...input, situationBrief: brief };
+      }
+    } catch { /* non-blocking */ }
+  }
+  // ── End resume brief injection ───────────────────────────────────────────────
+
   // ── 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.

package/src/pipeline.mjs

@@ -1134,6 +1134,12 @@ export async function runPipeline(trigger, prompt, options = {}) {
       return { success: false, gateFailure: 'outcome', reason: run.gates.outcome.reason, run };
     }
 
+    // Post-session receipt — capture what happened and seed next session's context
+    try {
+      const { generateReceipt } = await import('./receipt.mjs');
+      generateReceipt(run, cwd);
+    } catch { /* non-blocking */ }
+
     // Persist decision for future recall
     if (run.result && !run.result?.error) {
       try {

package/src/profile.mjs

@@ -818,6 +818,282 @@ function listSubscriptions(cwd) {
 // CLI
 // ---------------------------------------------------------------------------
 
+// ---------------------------------------------------------------------------
+// Capability Manifest — single runtime view of all provider/subscription state
+// ---------------------------------------------------------------------------
+
+/** 60-second in-process cache for the manifest. */
+let _manifestCache = null;
+let _manifestCachedAt = 0;
+const MANIFEST_TTL_MS = 60_000;
+
+/**
+ * Build a normalized capability manifest that consolidates provider health,
+ * subscription config, user preferences, policy, and learning data.
+ *
+ * @param {string} [cwd]
+ * @returns {Promise<object>}
+ */
+export async function getCapabilityManifest(cwd = process.cwd()) {
+  const now = Date.now();
+  if (_manifestCache && now - _manifestCachedAt < MANIFEST_TTL_MS) {
+    return _manifestCache;
+  }
+
+  // ── Read orchestrator.json for subscription config ─────────────────────
+  let orchConfig = {};
+  try {
+    const orchPath = join(cwd, 'orchestrator.json');
+    orchConfig = JSON.parse(readFileSync(orchPath, 'utf8'));
+  } catch { /* missing or malformed — fall through */ }
+
+  const orchSubs   = orchConfig.subscriptions ?? {};
+  const orchProv   = orchConfig.providers     ?? {};
+
+  // ── Plan normalizer (orchestrator.json uses "$100", "max-5x", "pro" etc) ─
+  function normalizePlan(raw) {
+    if (!raw) return 'unknown';
+    const s = String(raw).toLowerCase();
+    if (s.includes('max') && s.includes('20')) return 'max20';
+    if (s.includes('max') && (s.includes('5') || s.includes('5x'))) return 'max5';
+    if (s.includes('pro')) return 'pro';
+    if (s.includes('plus')) return 'plus';
+    if (s === '$20' || s === '20') return 'pro';
+    if (s === '$100' || s === '100') return 'max5';
+    if (s === '$200' || s === '200') return 'max20';
+    return 'unknown';
+  }
+
+  // ── Health states ──────────────────────────────────────────────────────
+  let healthStates = {};
+  try {
+    const { getHealth } = await import('./health.mjs');
+    healthStates = getHealth(cwd).states ?? {};
+  } catch { /* health.mjs unavailable */ }
+
+  function deriveHealth(providerKey) {
+    // Aggregate across all model classes for the provider
+    const entries = Object.entries(healthStates)
+      .filter(([k]) => k.startsWith(providerKey + ':'))
+      .map(([, v]) => v?.status ?? 'healthy');
+    if (entries.length === 0) return 'healthy';
+    if (entries.some(s => s === 'hot'))      return 'rate-limited';
+    if (entries.some(s => s === 'degraded')) return 'degraded';
+    if (entries.some(s => s === 'probing'))  return 'degraded';
+    return 'healthy';
+  }
+
+  // ── Budget pressure from health file (simple proxy) ────────────────────
+  function deriveBudget(providerKey) {
+    const hotEntries = Object.entries(healthStates)
+      .filter(([k]) => k.startsWith(providerKey + ':'))
+      .filter(([, v]) => v?.status === 'hot');
+    if (hotEntries.length === 0) return { pressure5h: 0, pressure7d: 0 };
+    // Clamp to 0.9 when hot — we don't have real token data here
+    const pressure = Math.min(0.9, 0.5 + hotEntries.length * 0.15);
+    return { pressure5h: pressure, pressure7d: pressure * 0.6 };
+  }
+
+  // ── Claude provider ────────────────────────────────────────────────────
+  const claudeProvider = { available: false, authenticated: false, plan: 'unknown',
+    models: ['opus', 'sonnet', 'haiku'], health: 'healthy',
+    budget: { pressure5h: 0, pressure7d: 0 }, source: 'none' };
+
+  try {
+    // available: claude CLI or CLAUDE_CODE env or replit-tools claude dir
+    const claudeDir       = join(homedir(), '.claude');
+    const replitClaudeDir = join(cwd, '.replit-tools', '.claude-persistent');
+    if (process.env.CLAUDE_CODE || process.env.ANTHROPIC_API_KEY) {
+      claudeProvider.available = true;
+      claudeProvider.source    = process.env.ANTHROPIC_API_KEY ? 'env' : 'credentials';
+    } else if (existsSync(claudeDir) || existsSync(replitClaudeDir)) {
+      claudeProvider.available = true;
+      claudeProvider.source    = existsSync(replitClaudeDir) ? 'replit-tools' : 'credentials';
+    } else {
+      try { execSync('which claude', { stdio: 'pipe', timeout: 2000 }); claudeProvider.available = true; claudeProvider.source = 'credentials'; } catch { /* not found */ }
+    }
+
+    // authenticated: use getAuthHealthStatus
+    const { getAuthHealthStatus } = await import('./health.mjs');
+    const authStatus = await getAuthHealthStatus(cwd);
+    claudeProvider.authenticated = authStatus.ok;
+    if (authStatus.source === 'replit-tools') claudeProvider.source = 'replit-tools';
+  } catch { /* getAuthHealthStatus unavailable */ }
+
+  claudeProvider.plan   = normalizePlan(orchProv.claude?.subscription ?? orchSubs.claude?.plan);
+  claudeProvider.health = claudeProvider.authenticated ? deriveHealth('claude') : 'down';
+  claudeProvider.budget = deriveBudget('claude');
+
+  // ── OpenAI provider ────────────────────────────────────────────────────
+  const openaiProvider = { available: false, authenticated: false, plan: 'unknown',
+    models: ['gpt-5.5', 'o3', 'gpt-4o', 'gpt-4o-mini'], health: 'healthy',
+    budget: { pressure5h: 0, pressure7d: 0 }, source: 'none' };
+
+  try {
+    let hasSecret = false;
+    try { const { hasSecret: hs } = await import('./replit.mjs'); hasSecret = hs('OPENAI_API_KEY'); } catch { hasSecret = !!(process.env.OPENAI_API_KEY); }
+
+    let codexAvailable = false;
+    try { execSync('which codex', { stdio: 'pipe', timeout: 2000 }); codexAvailable = true; } catch { /* not in PATH */ }
+
+    openaiProvider.available      = hasSecret || codexAvailable;
+    openaiProvider.authenticated  = hasSecret;
+    openaiProvider.source         = hasSecret ? 'env' : codexAvailable ? 'codex-config' : 'none';
+  } catch { /* detection failed */ }
+
+  openaiProvider.plan   = normalizePlan(orchProv.openai?.subscription ?? orchSubs.openai?.plan);
+  openaiProvider.health = openaiProvider.authenticated ? deriveHealth('openai') : 'down';
+  openaiProvider.budget = deriveBudget('openai');
+
+  // ── Preferences ────────────────────────────────────────────────────────
+  let preferences = { bias: 'auto', forbiddenModels: [], preferredModels: [],
+    costBias: 0.5, confirmBeforeExpensive: false };
+  try {
+    const profile = loadProfile(cwd);
+    const bias = profile.bias ?? profile.workStyle ?? 'auto';
+    preferences.bias = ['auto','balanced','cost-saver','quality-first'].includes(bias) ? bias : 'auto';
+    preferences.forbiddenModels    = profile.forbiddenModels  ?? [];
+    preferences.preferredModels    = profile.preferredModels  ?? [];
+    preferences.costBias           = profile.costBias         ?? (bias === 'cost-saver' ? 0.8 : bias === 'quality-first' ? 0.1 : 0.5);
+    preferences.confirmBeforeExpensive = profile.apiGuardrail ?? false;
+  } catch { /* profile unavailable */ }
+
+  // ── Policy ─────────────────────────────────────────────────────────────
+  const policy = {
+    highRiskRequiresBestAvailable: true,
+    failoverMode: 'tell',
+    dualBrainThreshold: 'high',
+  };
+
+  // ── Learning ───────────────────────────────────────────────────────────
+  let learning = {};
+  try {
+    const { getModelSuccessRates } = await import('./doctor.mjs');
+    learning = getModelSuccessRates(cwd);
+  } catch { /* doctor.mjs unavailable */ }
+
+  // ── Setup summary ──────────────────────────────────────────────────────
+  const hasAnyProvider = (claudeProvider.available && claudeProvider.authenticated) ||
+                         (openaiProvider.available && openaiProvider.authenticated);
+
+  let recommendedAction = null;
+  if (!claudeProvider.available && !openaiProvider.available) {
+    recommendedAction = 'connect-claude';
+  } else if (!claudeProvider.authenticated && !openaiProvider.authenticated) {
+    recommendedAction = 'refresh-auth';
+  } else if (!openaiProvider.available) {
+    recommendedAction = 'connect-openai';
+  }
+
+  const manifest = {
+    providers: { claude: claudeProvider, openai: openaiProvider },
+    preferences,
+    policy,
+    learning,
+    setup: {
+      hasAnyProvider,
+      recommendedAction,
+      zeroProviderMode: !hasAnyProvider,
+    },
+    timestamp: new Date().toISOString(),
+  };
+
+  _manifestCache    = manifest;
+  _manifestCachedAt = now;
+  return manifest;
+}
+
+/**
+ * Compute the effective routing policy for a specific task, applying rules in order:
+ * 1. Safety constraints (high-risk → best available model)
+ * 2. Provider availability
+ * 3. Task tier fit (search→haiku, execute→sonnet, think→opus)
+ * 4. User preferences (cost bias, forbidden models)
+ * 5. Learning (prefer models with ≥90% success rate for this task type)
+ *
+ * @param {object} manifest — from getCapabilityManifest()
+ * @param {{ tier?: string, risk?: string, taskType?: string }} taskContext
+ * @returns {{ provider: string, model: string, tier: string, reason: string, overrides: string[] }}
+ */
+export function getEffectivePolicy(manifest, taskContext = {}) {
+  const { providers, preferences, policy, learning } = manifest;
+  const tier     = taskContext.tier     ?? 'execute';
+  const risk     = taskContext.risk     ?? 'medium';
+  const taskType = taskContext.taskType ?? 'general';
+  const overrides = [];
+
+  // Tier → default model mapping
+  const tierModelMap = { search: 'haiku', execute: 'sonnet', think: 'opus' };
+  let preferredModel    = tierModelMap[tier] ?? 'sonnet';
+  let preferredProvider = 'claude';
+
+  // 1. Safety: high/critical risk → best available model
+  if (policy.highRiskRequiresBestAvailable && (risk === 'high' || risk === 'critical')) {
+    preferredModel = 'opus';
+    overrides.push(`risk=${risk} → upgraded to opus`);
+  }
+
+  // 2. Provider availability — fall back to openai if claude is down
+  const claudeOk = providers.claude.available && providers.claude.authenticated &&
+                   providers.claude.health !== 'down';
+  const openaiOk = providers.openai.available && providers.openai.authenticated &&
+                   providers.openai.health !== 'down';
+
+  if (!claudeOk && openaiOk) {
+    preferredProvider = 'openai';
+    // Remap model names for openai
+    const openaiTierMap = { search: 'gpt-4o-mini', execute: 'gpt-4o', think: 'gpt-5.5' };
+    preferredModel = risk === 'high' || risk === 'critical' ? 'gpt-5.5' : (openaiTierMap[tier] ?? 'gpt-4o');
+    overrides.push('claude unavailable → routed to openai');
+  } else if (!claudeOk && !openaiOk) {
+    return { provider: 'none', model: 'none', tier, reason: 'no providers available', overrides };
+  }
+
+  // 3. Task fit already applied via tierModelMap above
+
+  // 4. User preferences: forbidden models, cost bias
+  const forbidden = preferences.forbiddenModels ?? [];
+  if (forbidden.includes(preferredModel)) {
+    // Downgrade one step
+    const fallback = preferredProvider === 'claude'
+      ? (preferredModel === 'opus' ? 'sonnet' : 'haiku')
+      : (preferredModel === 'gpt-5.5' ? 'gpt-4o' : 'gpt-4o-mini');
+    overrides.push(`${preferredModel} forbidden → downgraded to ${fallback}`);
+    preferredModel = fallback;
+  }
+
+  if (preferences.costBias > 0.7 && preferredModel === 'opus' && risk !== 'high' && risk !== 'critical') {
+    preferredModel = 'sonnet';
+    overrides.push('cost-bias > 0.7 → downgraded from opus to sonnet');
+  }
+
+  // 5. Learning: if another model has ≥90% success for this task type, prefer it
+  const successRates = learning ?? {};
+  let bestLearnedModel = null;
+  let bestRate = 0.9; // threshold
+  for (const [model, stats] of Object.entries(successRates)) {
+    if (stats.rate >= bestRate && stats.total >= 5 && !forbidden.includes(model)) {
+      // Only prefer if it's on the right provider
+      const isClaudeModel = ['opus', 'sonnet', 'haiku'].includes(model);
+      if ((preferredProvider === 'claude' && isClaudeModel) ||
+          (preferredProvider === 'openai' && !isClaudeModel)) {
+        bestLearnedModel = model;
+        bestRate = stats.rate;
+      }
+    }
+  }
+  if (bestLearnedModel && bestLearnedModel !== preferredModel) {
+    overrides.push(`learning: ${bestLearnedModel} has ${Math.round(bestRate * 100)}% success → preferred`);
+    preferredModel = bestLearnedModel;
+  }
+
+  const reason = overrides.length > 0
+    ? overrides[0]
+    : `tier=${tier} → ${preferredProvider}/${preferredModel}`;
+
+  return { provider: preferredProvider, model: preferredModel, tier, reason, overrides };
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const cwd  = process.cwd();

package/src/receipt.mjs

@@ -1,3 +1,7 @@
+import { mkdirSync, writeFileSync, appendFileSync, readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+
 const DIM   = '\x1b[2m';
 const GREEN = '\x1b[32m';
 const YELLOW= '\x1b[33m';
@@ -105,6 +109,215 @@ export function formatFailureReceipt(receipt, failureContext) {
   return lines.join('\n');
 }
 
+// ─── Persistent session receipt ──────────────────────────────────────────────
+
+const RECEIPTS_DIR = '.dual-brain/receipts';
+
+function receiptsDir(cwd) {
+  return join(cwd, RECEIPTS_DIR);
+}
+
+function gitChangedFiles(cwd) {
+  try {
+    const out = execSync('git diff --name-only HEAD', { cwd, stdio: ['ignore', 'pipe', 'pipe'] })
+      .toString().trim();
+    if (!out) return [];
+    return out.split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function readDecisionsRecent(cwd, limit = 5) {
+  try {
+    const raw = readFileSync(join(cwd, '.dual-brain', 'decisions.jsonl'), 'utf8');
+    const lines = raw.split('\n').filter(l => l.trim());
+    return lines.slice(-limit).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function ageLabel(ms) {
+  const mins = Math.round(ms / 60000);
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.round(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  return `${Math.round(hours / 24)}d ago`;
+}
+
+/**
+ * Generate a persistent session receipt and append it to the receipts store.
+ * @param {object} run  PipelineRun object (or any outcome object with compatible fields)
+ * @param {string} cwd  Working directory
+ * @returns {object}    The receipt object
+ */
+export function generateReceipt(run = {}, cwd = process.cwd()) {
+  const now = new Date();
+  const ts = now.toISOString();
+
+  // Derive files changed — prefer run.result, fall back to git diff
+  const filesChanged = (run.result?.filesChanged?.length > 0)
+    ? run.result.filesChanged
+    : gitChangedFiles(cwd);
+
+  // Recent decisions from living docs
+  const decisionEntries = readDecisionsRecent(cwd, 5);
+  const decisions = decisionEntries.map(d => d.question || d.decision || '').filter(Boolean).slice(0, 3);
+
+  // Test results
+  const testsRun = run.verification?.ok !== undefined
+    ? (run.verification.ok ? 'passed' : 'failed')
+    : null;
+
+  // Unresolved risks from plan
+  const risksUnresolved = [];
+  if (run.plan?.approvalRequired && !run.outcome?.approved) {
+    risksUnresolved.push('approval required but not obtained');
+  }
+  if (run.verification && !run.verification.ok) {
+    risksUnresolved.push('verification failed');
+  }
+  const verNotes = run.verification?.notes ?? [];
+  for (const note of verNotes) {
+    if (/warn|risk|unverif|no file changes/i.test(note)) risksUnresolved.push(note.slice(0, 80));
+  }
+
+  // Blockers — gates that failed
+  const blockers = [];
+  for (const [name, g] of Object.entries(run.gates ?? {})) {
+    if (g && !g.passed) blockers.push(`${name}: ${g.reason?.slice(0, 80)}`);
+  }
+  if (run.result?.error) blockers.push(run.result.error.slice(0, 80));
+
+  // Derive status
+  const success = run.result && !run.result.error && (run.verification?.ok !== false);
+  const status = !run.result ? 'incomplete'
+    : blockers.length > 0 ? 'failed'
+    : success ? 'success'
+    : 'partial';
+
+  // Next action (reuse existing logic)
+  let nextAction = 'review the output';
+  if (status === 'success' && filesChanged.length > 0) {
+    nextAction = run.verification?.testsRun ? 'commit changes' : 'run tests, then commit';
+  } else if (status === 'failed') {
+    nextAction = 'investigate failure, retry with adjusted approach';
+  } else if (status === 'partial') {
+    nextAction = 'check partial output, verify manually';
+  }
+
+  const duration = (run.completedAt && run.startedAt)
+    ? Math.round((run.completedAt - run.startedAt) / 1000)
+    : null;
+
+  const receipt = {
+    timestamp: ts,
+    goal: (run.prompt ?? '').slice(0, 200),
+    filesChanged,
+    decisions,
+    testsRun,
+    risksUnresolved,
+    blockers,
+    nextAction,
+    provider: run.plan?.primaryProvider ?? run.result?.provider ?? null,
+    model: run.plan?.primaryModel ?? run.result?.model ?? null,
+    duration,
+    status,
+  };
+
+  // Store receipt
+  try {
+    const dir = receiptsDir(cwd);
+    mkdirSync(dir, { recursive: true });
+
+    const filename = ts.replace(/[:.]/g, '-').slice(0, 19) + '.json';
+    writeFileSync(join(dir, filename), JSON.stringify(receipt, null, 2));
+
+    // One-line summary for fast scanning
+    const summary = {
+      ts,
+      goal: receipt.goal.slice(0, 80),
+      status,
+      files: filesChanged.length,
+      next: nextAction.slice(0, 60),
+    };
+    appendFileSync(join(dir, 'index.jsonl'), JSON.stringify(summary) + '\n');
+  } catch {
+    // Storage failure is non-blocking
+  }
+
+  return receipt;
+}
+
+/**
+ * Read the most recent receipt(s) and build a compact resume brief (max 500 chars).
+ * @param {string} cwd
+ * @returns {string|null}
+ */
+export function buildResumeBrief(cwd = process.cwd()) {
+  try {
+    const dir = receiptsDir(cwd);
+    if (!existsSync(dir)) return null;
+
+    // Find the most recent receipt JSON file
+    const files = readdirSync(dir)
+      .filter(f => f.endsWith('.json') && f !== 'index.json')
+      .sort()
+      .reverse();
+
+    if (files.length === 0) return null;
+
+    const raw = readFileSync(join(dir, files[0]), 'utf8');
+    const r = JSON.parse(raw);
+
+    const age = ageLabel(Date.now() - Date.parse(r.timestamp));
+    const filesSummary = r.filesChanged?.length > 0
+      ? r.filesChanged.slice(0, 3).map(f => f.split('/').pop()).join(', ')
+        + (r.filesChanged.length > 3 ? ` +${r.filesChanged.length - 3}` : '')
+      : 'no files changed';
+    const riskLine = r.risksUnresolved?.length > 0
+      ? `Risk: ${r.risksUnresolved[0].slice(0, 60)}`
+      : null;
+
+    const lines = [
+      'RESUME CONTEXT:',
+      `Last session: ${age}`,
+      `Goal: ${(r.goal || 'unknown').slice(0, 80)}`,
+      `Done: ${filesSummary}`,
+      `Status: ${r.status}${r.testsRun ? ', tests ' + r.testsRun : ''}`,
+    ];
+    if (riskLine) lines.push(riskLine);
+    lines.push(`Next: ${(r.nextAction || '').slice(0, 80)}`);
+
+    const brief = lines.join('\n');
+    return brief.length > 500 ? brief.slice(0, 497) + '...' : brief;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Return the most recent receipt object, or null if none exists or the store is empty.
+ * @param {string} cwd
+ * @returns {object|null}
+ */
+export function getLatestReceipt(cwd = process.cwd()) {
+  try {
+    const dir = receiptsDir(cwd);
+    if (!existsSync(dir)) return null;
+    const files = readdirSync(dir)
+      .filter(f => f.endsWith('.json') && f !== 'index.json')
+      .sort()
+      .reverse();
+    if (files.length === 0) return null;
+    const raw = readFileSync(join(dir, files[0]), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
 export function buildReceiptFromOutcome(outcome = {}) {
   const result = {
     success: outcome.success ?? outcome.result?.success ?? false,