dual-brain 0.2.9 → 0.2.11

package/bin/dual-brain.mjs

@@ -18,7 +18,21 @@ import {
   loadCredentials, saveCredentials, getCredentialSummary, detectCredentials, addCredential, removeCredential, checkCredentialHealth,
 } from '../src/profile.mjs';
 
-import { detectTask } from '../src/detect.mjs';
+import { detectTask, primeAgentRegistry } from '../src/detect.mjs';
+
+// ─── Agent/skill registry cache (populated at startup) ───────────────────────
+// These are set by _primeRegistryCache() so classifyInput can use them
+// synchronously without async overhead on each keystroke.
+let _cachedMatchSkill = null;
+let _cachedSkillToTaskBrief = null;
+
+async function _primeRegistryCache() {
+  try {
+    const reg = await import('../src/agents/registry.mjs');
+    _cachedMatchSkill = reg.matchSkill;
+    _cachedSkillToTaskBrief = reg.skillToTaskBrief;
+  } catch {}
+}
 
 import {
   decideRoute, getAvailableModels,
@@ -2034,11 +2048,56 @@ function makeBoxRow(content, W) {
 
 // ─── Command palette: input classifier ───────────────────────────────────────
 
+// HEAD state — loaded lazily, shared across REPL turns
+let _headState = null;
+let _headModuleCache = null;
+
+async function _getHeadModule() {
+  if (!_headModuleCache) {
+    try {
+      _headModuleCache = await import('../src/head.mjs');
+    } catch {
+      _headModuleCache = null;
+    }
+  }
+  return _headModuleCache;
+}
+
+function _getHeadState() {
+  if (!_headState) {
+    try {
+      const head = _headModuleCache;
+      _headState = head ? head.loadState() : null;
+    } catch {
+      _headState = null;
+    }
+  }
+  return _headState;
+}
+
+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'],
+  ['auto', 'auto'], ['automode', 'auto'],
+]);
+
 /**
- * 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
+ * Classify user input using HEAD's cognitive pipeline.
+ * Returns a tier-compatible object that maps HEAD's deliberation to the
+ * existing REPL routing: free/skill/cheap/full, plus HEAD judgment metadata.
+ *
+ *   { tier: 'free', command, args }            — deterministic, zero tokens
+ *   { tier: 'skill', skill, args, command }    — slash command
+ *   { tier: 'cheap', headJudgment }            — question → haiku
+ *   { tier: 'full', headJudgment, model }      — work task → dispatch
  */
 function classifyInput(input) {
   const trimmed = input.trim();
@@ -2047,37 +2106,23 @@ function classifyInput(input) {
   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'],
-  ]);
+  // Tier 0: SKILL — slash commands (checked first, deterministic)
+  if (trimmed.startsWith('/')) {
+    try {
+      if (typeof _cachedMatchSkill === 'function') {
+        const skill = _cachedMatchSkill(trimmed);
+        if (skill) {
+          const skillArgs = trimmed.replace(/^\/\w+\s*/, '');
+          return { tier: 'skill', skill, args: skillArgs, command: skill.command };
+        }
+      }
+    } catch {}
+  }
 
+  // Tier 1: FREE — exact command matches (zero tokens, no HEAD needed)
   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) };
   }
@@ -2085,14 +2130,65 @@ function classifyInput(input) {
     return { tier: 'free', command: 'init --replit', args: [] };
   }
 
-  // Tier 2: CHEAP — question / diagnostic patterns → haiku
+  // ── HEAD cognitive pipeline: replaces regex-based cheap/full split ──────
+  const head = _headModuleCache;
+  if (head) {
+    const state = _getHeadState() || head.freshState();
+    const turn = head.processTurn(state, trimmed, {});
+    _headState = state; // persist across turns
+
+    const judgment = {
+      depth: turn.depth,
+      action: turn.action,
+      shouldAskUser: turn.shouldAskUser,
+      shouldDispatch: turn.shouldDispatch,
+      shouldClarify: turn.shouldClarify,
+      shouldThink: turn.shouldThink,
+      rationale: turn.rationale,
+      confidence: turn.result.confidence,
+      obligations: turn.result.obligations,
+      surfaceNoticings: turn.result.surfaceNoticings,
+    };
+
+    // Map HEAD's depth → tier + model
+    if (turn.depth === 'reflexive' && !turn.shouldDispatch) {
+      return { tier: 'cheap', headJudgment: judgment };
+    }
+
+    // HEAD says clarify → cheap tier (ask a question, don't dispatch work)
+    if (turn.shouldClarify) {
+      return { tier: 'cheap', headJudgment: judgment };
+    }
+
+    // HEAD says think/plan → full tier with opus
+    if (turn.shouldThink) {
+      return { tier: 'full', headJudgment: judgment, model: 'opus' };
+    }
+
+    // HEAD says dispatch → full tier, model based on depth
+    if (turn.shouldDispatch) {
+      const model = turn.depth === 'deep' ? 'opus' : 'sonnet';
+      return { tier: 'full', headJudgment: judgment, model };
+    }
+
+    // HEAD says respond (not dispatch) → cheap
+    if (turn.action.type === 'respond') {
+      return { tier: 'cheap', headJudgment: judgment };
+    }
+
+    // Default: let depth drive it
+    if (turn.depth === 'light' || turn.depth === 'reflexive') {
+      return { tier: 'cheap', headJudgment: judgment };
+    }
+    return { tier: 'full', headJudgment: judgment };
+  }
+
+  // ── Fallback: HEAD not loaded, use simple heuristics ───────────────────
   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)) {
+  if (QUESTION_WORDS.test(lower)) {
     return { tier: 'cheap' };
   }
 
-  // Tier 3: FULL — everything else is a work task
   return { tier: 'full' };
 }
 
@@ -2176,11 +2272,16 @@ async function mainScreen(rl, ask) {
   const auth    = await detectAuth();
 
   // ── Dashboard load animation (full mode only) ─────────────────────────────
-  const fx = await getFx();
+  let fx = null;
+  try { fx = await Promise.race([getFx(), new Promise(r => setTimeout(() => r(null), 3000))]); } catch {}
   let dashSpinner = null;
   if (fx && fx.getMode && fx.getMode() === 'full') {
     dashSpinner = fx.spinner('Loading dashboard...').start();
   }
+  // Safety: kill spinner after 8s no matter what
+  const _spinnerTimeout = dashSpinner ? setTimeout(() => {
+    if (dashSpinner) { try { dashSpinner.stop(); } catch {} dashSpinner = null; }
+  }, 8000) : null;
 
   // ── One-time default shell prompt for returning users (never asked before) ─
   if (profile.setupComplete && !profile.defaultShellAsked) {
@@ -2199,10 +2300,10 @@ async function mainScreen(rl, ask) {
   const claudeExpired = claudeSub?.expiresAt && Date.parse(claudeSub.expiresAt) < now;
   const openaiExpired = openaiSub?.expiresAt && Date.parse(openaiSub.expiresAt) < now;
 
-  // Silent OAuth token auto-refresh
+  // Silent OAuth token auto-refresh (3s timeout — never block dashboard)
   try {
     const { autoRefreshToken } = await import('../src/profile.mjs');
-    await autoRefreshToken(cwd);
+    await Promise.race([autoRefreshToken(cwd), new Promise(r => setTimeout(r, 3000))]);
   } catch {}
 
   // Append-only session archive sync
@@ -2258,7 +2359,7 @@ async function mainScreen(rl, ask) {
     } else {
       process.stdout.write(` ${DIM}${interrupted.reason} · ${interrupted.ageLabel}${RST}\n`);
     }
-    process.stdout.write(` ${DIM}[Enter] resume  [n] new  [s] skip${RST}\n\n`);
+    process.stdout.write(` \x1b[36mEnter\x1b[0m resume  \x1b[36mn\x1b[0m new  \x1b[36ms\x1b[0m skip\n\n`);
 
     // Wait for a keypress to decide what to do with the card
     const readline2 = await import('node:readline');
@@ -2598,6 +2699,7 @@ async function mainScreen(rl, ask) {
   });
 
   // ── Resolve dashboard spinner before rendering ────────────────────────────
+  if (_spinnerTimeout) clearTimeout(_spinnerTimeout);
   if (dashSpinner) dashSpinner.succeed('Dashboard ready');
 
   // ── Stale hint ────────────────────────────────────────────────────────────
@@ -2641,12 +2743,22 @@ async function mainScreen(rl, ask) {
     process.stdout.write(panel('Signals', recentLines, { width: panelW }) + '\n\n');
   }
 
-  // Input bar — rendered below panels; the key handler will overwrite this line
-  const inputHint = `${DIM}[?] help${RST}`;
+  // Shortcut bar — always visible so the user never has to guess
+  const autoLabel = profile.automode ? `\x1b[32m⚡auto\x1b[0m` : `${DIM}auto${RST}`;
+  const shortcutItems = [
+    `${CYAN}Enter${RST} resume`,
+    `${CYAN}n${RST} new`,
+    `${CYAN}/${RST} search`,
+    `${CYAN}s${RST} settings`,
+    `${CYAN}d${RST} doctor`,
+    autoLabel,
+    `${CYAN}q${RST} quit`,
+  ];
+  process.stdout.write(` ${DIM}${shortcutItems.join('  ')}${RST}\n\n`);
+
+  // Input bar — rendered below shortcut bar
   const inputLeft = tuiPrompt('task or command...');
-  const inputLeftW = (inputLeft + ' task or command...').replace(/\x1b\[[0-9;]*m/g, '').length;
-  const inputGap = Math.max(1, panelW - inputLeftW - 8);
-  process.stdout.write(` ${inputLeft}${' '.repeat(inputGap)}${inputHint}\n`);
+  process.stdout.write(` ${inputLeft}\n`);
 
   // ── Key handling ──────────────────────────────────────────────────────────
   // Use raw keypress mode so we can show a live type-to-start buffer.
@@ -2848,6 +2960,17 @@ async function mainScreen(rl, ask) {
         await ask('\n  Press Enter to continue...');
         return { next: 'main' };
       }
+      if (cmd === 'auto') {
+        const cwd2 = process.cwd();
+        const prof = loadProfile(cwd2);
+        prof.automode = !prof.automode;
+        saveProfile(prof, { cwd: cwd2 });
+        const state = prof.automode ? '\x1b[32mON\x1b[0m' : '\x1b[2mOFF\x1b[0m';
+        process.stdout.write(`\n  Automode: ${state}\n`);
+        process.stdout.write(`  ${prof.automode ? 'Tasks dispatch immediately (HEAD still gates dangerous ops)' : 'Tasks require Enter to confirm'}\n\n`);
+        await ask('  Press Enter to continue...');
+        return { next: 'main' };
+      }
       if (cmd === 'init --replit') {
         await cmdInit(rl);
         return { next: 'main' };
@@ -2855,20 +2978,94 @@ async function mainScreen(rl, ask) {
       // fallthrough: unknown free command → treat as full task
     }
 
-    // Tier 2: CHEAP — question/diagnostic, route to haiku
+    // Tier 0.5: SKILL — slash command routed through agent registry
+    if (classified.tier === 'skill') {
+      const skill = classified.skill;
+      const skillArgs = classified.args || '';
+
+      // Free skills (e.g. /status) run deterministically with no agent
+      if (skill.tier === 'free' || !skill.agent) {
+        if (skill.command === 'status') {
+          await cmdStatus([]);
+          await ask('\n  Press Enter to continue...');
+          return { next: 'main' };
+        }
+        return { next: 'main' };
+      }
+
+      // Build the task brief from the skill declaration
+      let brief = null;
+      try {
+        if (typeof _cachedSkillToTaskBrief === 'function') {
+          brief = _cachedSkillToTaskBrief(input, skillArgs);
+        }
+      } catch {}
+
+      const model  = brief?.model || skill.model || 'sonnet';
+      const prompt = brief?.objective || `/${skill.command} ${skillArgs}`.trim();
+
+      process.stdout.write(`\n  Skill: /${skill.command}  Agent: ${skill.agent}  Model: ${model}\n`);
+      if (skill.description) process.stdout.write(`  ${skill.description}\n`);
+      process.stdout.write(`  \x1b[36mEnter\x1b[0m run  \x1b[36mn\x1b[0m cancel\n\n`);
+      const skillConfirm = (await ask('  > ')).trim().toLowerCase();
+      if (skillConfirm === 'n' || skillConfirm === 'no') return { next: 'main' };
+
+      return { next: 'go', prompt, model };
+    }
+
+    // Tier 2: CHEAP — question/diagnostic/reflexive
     if (classified.tier === 'cheap') {
-      process.stdout.write(`\n  Routing to haiku for quick answer...\n`);
-      return { next: 'go', prompt: input, model: 'haiku' };
+      const hj = classified.headJudgment;
+      const model = hj ? 'haiku' : 'haiku';
+      if (hj?.surfaceNoticings?.length > 0) {
+        for (const n of hj.surfaceNoticings) {
+          process.stdout.write(`\n  \x1b[33m[HEAD]\x1b[0m ${n.observation}\n`);
+        }
+      }
+      process.stdout.write(`\n  Routing to ${model} for quick answer...\n`);
+      return { next: 'go', prompt: input, model };
     }
 
-    // Tier 3: FULL — work task, confirm before dispatching
+    // Tier 3: FULL — work task, HEAD-informed dispatch
     if (classified.tier === 'full') {
+      const hj = classified.headJudgment;
+      const model = classified.model || 'sonnet';
       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`);
+
+      // Surface HEAD noticings before confirming
+      if (hj?.surfaceNoticings?.length > 0) {
+        for (const n of hj.surfaceNoticings) {
+          process.stdout.write(`\n  \x1b[33m[HEAD]\x1b[0m ${n.observation}`);
+        }
+        process.stdout.write('\n');
+      }
+
+      // HEAD's shouldAskUser gates the dispatch — dangerous/irreversible ops
+      if (hj?.shouldAskUser) {
+        const reason = hj.obligations?.find(o => o.type === 'askBeforeIrreversi')?.description || hj.rationale;
+        process.stdout.write(`\n  \x1b[31m⚠ CAUTION\x1b[0m ${reason}\n`);
+        process.stdout.write(`  Task: ${summary}\n`);
+        process.stdout.write(`  Depth: ${hj.depth}  Model: ${model}\n`);
+        process.stdout.write(`  \x1b[36mEnter\x1b[0m proceed  \x1b[36mn\x1b[0m cancel\n\n`);
+        const confirm = (await ask('  > ')).trim().toLowerCase();
+        if (confirm === 'n' || confirm === 'no') return { next: 'main' };
+        return { next: 'go', prompt: input, model };
+      }
+
+      // Automode: if HEAD says it's safe, just go — no confirmation needed
+      const automode = profile.automode ?? profile.settings?.automode ?? false;
+      if (automode) {
+        process.stdout.write(`\n  \x1b[36m⚡\x1b[0m ${summary}  (${model}, depth: ${hj?.depth || '?'})\n`);
+        return { next: 'go', prompt: input, model };
+      }
+
+      // Manual mode — show depth, wait for confirmation
+      process.stdout.write(`\n  Launch: ${summary}\n`);
+      process.stdout.write(`  Depth: ${hj?.depth || '?'}  Model: ${model}\n`);
+      process.stdout.write(`  \x1b[36mEnter\x1b[0m go  \x1b[36mn\x1b[0m cancel\n\n`);
       const confirm = (await ask('  > ')).trim().toLowerCase();
       if (confirm === 'n' || confirm === 'no') return { next: 'main' };
-      return { next: 'go', prompt: input };
+      return { next: 'go', prompt: input, model };
     }
 
     // Default fallback
@@ -2983,27 +3180,36 @@ async function paletteHelpScreen(rl, ask) {
   const DIM   = '\x1b[2m';
   const RESET = '\x1b[0m';
 
+  const CYAN = '\x1b[36m';
   const lines = [
     top,
-    row('Command Palette'),
+    row(`${CYAN}Keyboard Shortcuts${RESET} (single key, no Enter needed)`),
+    sep,
+    row(`${CYAN}Enter${RESET}   Resume last session`),
+    row(`${CYAN}n${RESET}       New coding session`),
+    row(`${CYAN}1-9${RESET}     Resume session by number`),
+    row(`${CYAN}/${RESET}       Search session history`),
+    row(`${CYAN}s${RESET}       Settings`),
+    row(`${CYAN}d${RESET}       Doctor (repo diagnostics)`),
+    row(`${CYAN}t${RESET}       Team`),
+    row(`${CYAN}i${RESET}       Import sessions`),
+    row(`${CYAN}q${RESET}       Quit`),
+    row(`${CYAN}?${RESET}       This help`),
+    sep,
+    row(`${CYAN}Typed Commands${RESET} (type then Enter)`),
     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}sessions${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`),
+    row(`${DIM}budget${RESET}           Token usage + routing`),
+    row(`${DIM}health${RESET}           System health check`),
     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}`),
+    row(`${CYAN}Natural Language${RESET} (just type)`),
     sep,
-    row(`${DIM}[Enter] go back${RESET}`),
+    row(`Questions → quick answer (haiku)`),
+    row(`Work tasks → HEAD evaluates, then dispatches`),
+    sep,
+    row(`${DIM}Enter${RESET} go back`),
     bot,
   ];
 
@@ -5967,6 +6173,12 @@ async function cmdSpecialistGo(specialist, args) {
 // ─── Entry point ─────────────────────────────────────────────────────────────
 
 async function main() {
+  // Prime agent + skill registries early so detectTask and classifyInput
+  // can match agents/skills synchronously during interactive sessions.
+  primeAgentRegistry().catch(() => {});
+  _primeRegistryCache().catch(() => {});
+  _getHeadModule().catch(() => {});
+
   const args = process.argv.slice(2);
   const cmd  = args[0];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -31,7 +31,10 @@
     "./integrity": "./src/integrity.mjs",
     "./prompt-audit": "./src/prompt-audit.mjs",
     "./head": "./src/head.mjs",
-    "./templates": "./src/templates.mjs"
+    "./templates": "./src/templates.mjs",
+    "./agents": "./src/agents/registry.mjs",
+    "./collaboration": "./src/collaboration.mjs",
+    "./provider-context": "./src/provider-context.mjs"
   },
   "keywords": [
     "claude-code",
@@ -102,6 +105,9 @@
     "src/prompt-audit.mjs",
     "src/head.mjs",
     "src/templates.mjs",
+    "src/agents/registry.mjs",
+    "src/collaboration.mjs",
+    "src/provider-context.mjs",
     "bin/*.mjs",
     "hooks/enforce-tier.mjs",
     "hooks/cost-logger.mjs",