dual-brain 0.2.8 → 0.2.10

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,55 @@ 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'],
+]);
+
 /**
- * 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 +2105,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 +2129,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' };
 }
 
@@ -2855,20 +2950,85 @@ 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(`  [Enter] to run, [n] to 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;
+
+      // 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[HEAD GATE]\x1b[0m ${reason}\n`);
+        process.stdout.write(`  Task: ${summary}\n`);
+        process.stdout.write(`  Depth: ${hj.depth}  Model: ${model}  [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, model };
+      }
+
+      // Normal dispatch — show depth but don't block
       process.stdout.write(`\n  Launch coding session: ${summary}\n`);
-      process.stdout.write(`  Model: sonnet  [Enter] to proceed, [n] to cancel\n\n`);
+      process.stdout.write(`  Depth: ${hj?.depth || '?'}  Model: ${model}  [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 };
+      return { next: 'go', prompt: input, model };
     }
 
     // Default fallback
@@ -5967,6 +6127,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.8",
+  "version": "0.2.10",
   "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",
@@ -129,6 +135,7 @@
     "hooks/task-classifier.mjs",
     "hooks/model-registry.mjs",
     "hooks/auto-update-wrapper.mjs",
+    "hooks/session-end.mjs",
     "hooks/head-guard.mjs",
     "hooks/auto-update.sh",
     "mcp-server/*.mjs",