dual-brain 0.2.15 → 0.2.17

package/bin/dual-brain.mjs

@@ -504,29 +504,48 @@ async function cmdGo(args, opts = {}) {
     } catch { /* non-fatal */ }
   }
 
-  // ── Cognitive loop: enhance prompt with debrief + preventions if available ──
+  // ── Cognitive loop: drive dispatch decisions ──────────────────────────────
   let loopEnhancedPrompt = prompt;
   let loopDispatchMeta = null;
   try {
     const cogLoop = await _getCognitiveLoop();
     if (cogLoop) {
       const loopResult = cogLoop.enter(prompt, { files });
+
+      if (loopResult.phase === 'readonly') {
+        console.log('\n⚠ Another dual-brain session is active. This session is read-only.');
+        return;
+      }
+
       if (loopResult.phase === 'dispatch' && loopResult.nextDispatch) {
         loopDispatchMeta = loopResult;
-        // Append debrief instructions and preventions from first agent to prompt
+        // Use the full envelope prompt (includes context, preventions, debrief)
         const firstAgent = loopResult.nextDispatch.agents?.[0];
-        if (firstAgent) {
-          const extras = [];
-          if (firstAgent.preventions) extras.push(firstAgent.preventions);
-          if (firstAgent.debriefInstruction) extras.push(firstAgent.debriefInstruction);
-          if (extras.length > 0) {
-            loopEnhancedPrompt = prompt + '\n\n' + extras.join('\n\n');
-          }
+        if (firstAgent?.prompt) {
+          loopEnhancedPrompt = firstAgent.prompt;
         }
         if (verbose && loopResult.plan) {
           const wc = loopResult.plan.waves?.length || 0;
           console.log(`  [cognitive-loop] Plan: ${wc} wave(s), phase: ${loopResult.phase}`);
         }
+      } else if (loopResult.phase === 'blocked') {
+        console.log(`\n⚠ Dispatch blocked: ${loopResult.suggestion || 'readiness check failed'}`);
+        if (loopResult.surfaceNoticings?.length) {
+          loopResult.surfaceNoticings.forEach(n => console.log(`  → ${n}`));
+        }
+        return;
+      } else if (loopResult.phase === 'respond') {
+        // HEAD decided no dispatch needed — show rationale
+        if (loopResult.rationale) console.log(`\n${loopResult.rationale}`);
+        if (loopResult.surfaceNoticings?.length) {
+          loopResult.surfaceNoticings.forEach(n => console.log(`  → ${n}`));
+        }
+        return;
+      }
+
+      // Surface noticings (includes update notices, diagnostics)
+      if (loopResult.surfaceNoticings?.length && verbose) {
+        loopResult.surfaceNoticings.forEach(n => console.log(`  → ${n}`));
       }
     }
   } catch {
@@ -552,20 +571,38 @@ async function cmdGo(args, opts = {}) {
     dispatchSpinner.succeed(`Agent dispatched: ${prompt.slice(0, 50)}`);
   }
 
-  // ── Cognitive loop: advance after dispatch completes ─────────────────────────
+  // ── Cognitive loop: advance through waves until done ─────────────────────────
   if (loopDispatchMeta && result && !dryRun) {
     try {
       const cogLoop = await _getCognitiveLoop();
       if (cogLoop) {
-        const waveId = loopDispatchMeta.nextDispatch.waveId;
-        const rawResults = [result.summary || result.output || ''];
-        const advanceResult = cogLoop.advance(rawResults, waveId, { files });
+        let waveId = loopDispatchMeta.nextDispatch.waveId;
+        let rawResults = [result.summary || result.output || ''];
+        let advanceResult = cogLoop.advance(rawResults, waveId, { files });
+
+        // Loop through remaining waves
+        while (advanceResult && advanceResult.phase === 'dispatch' && advanceResult.nextDispatch) {
+          if (verbose) {
+            console.log(`  [cognitive-loop] Wave ${advanceResult.rationale || 'next'}`);
+          }
+
+          // Dispatch the next wave
+          const nextAgent = advanceResult.nextDispatch.agents?.[0];
+          const nextPrompt = nextAgent?.prompt || prompt;
+          const nextResult = await runPipeline('go', nextPrompt, { files, cwd, verbose, dryRun: false });
+
+          // Advance again
+          waveId = advanceResult.nextDispatch.waveId;
+          rawResults = [nextResult.result?.summary || nextResult.result?.output || ''];
+          advanceResult = cogLoop.advance(rawResults, waveId, { files });
+        }
+
         if (verbose && advanceResult) {
-          console.log(`  [cognitive-loop] Next phase: ${advanceResult.phase}, rationale: ${advanceResult.rationale || '-'}`);
+          console.log(`  [cognitive-loop] Final: ${advanceResult.phase}, ${advanceResult.rationale || '-'}`);
         }
       }
     } catch {
-      // Non-fatal — loop advance failure doesn't affect the completed dispatch
+      // Non-fatal — loop advance failure doesn't affect completed dispatches
     }
   }
 

package/hooks/auto-update-wrapper.mjs

@@ -1,59 +1,58 @@
 #!/usr/bin/env node
-// auto-update-wrapper.mjs — PostToolUse hook (Node.js entry point).
-// Runs once per session, checks for dual-brain updates, installs silently.
-// The parent exits immediately; all npm work happens in a detached child.
+// auto-update-wrapper.mjs — PostToolUse hook.
+// Checks for updates once per session. If found, installs immediately (no wait,
+// no question) and writes a notice so HEAD can mention it naturally.
+// "Oh, I updated to 0.2.16" — not a prompt, just awareness.
 
-import { spawn } from 'child_process';
+import { spawnSync } from 'child_process';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const WORKSPACE   = resolve(__dirname, '..');
-const STATE_DIR   = join(WORKSPACE, '.dualbrain');
-const LOCK_FILE   = join(STATE_DIR, '.update-checked');
-const TWENTY_FOUR_HOURS = 24 * 60 * 60 * 1000;
+const WORKSPACE = resolve(__dirname, '..');
+const STATE_DIR = join(WORKSPACE, '.dualbrain');
+const LOCK_FILE = join(STATE_DIR, '.update-checked');
+const NOTICE_FILE = join(STATE_DIR, '.update-notice');
+const SESSION_TTL = 30 * 60 * 1000; // Once per 30 min session
 
-// ── 1. Already checked recently? ─────────────────────────────────────────────
+// ── 1. Already checked this session? ─────────────────────────────────────────
 if (existsSync(LOCK_FILE)) {
   try {
     const lastCheck = parseInt(readFileSync(LOCK_FILE, 'utf8').trim(), 10);
-    if (Number.isFinite(lastCheck) && Date.now() - lastCheck < TWENTY_FOUR_HOURS) {
+    if (Number.isFinite(lastCheck) && Date.now() - lastCheck < SESSION_TTL) {
+      // Output empty JSON (no hook action)
+      process.stdout.write('{}\n');
       process.exit(0);
     }
-  } catch {
-    // Corrupt lock file — proceed with check
-  }
+  } catch {}
 }
 
-// ── 2. Write lock BEFORE spawning (prevents concurrent session races) ─────────
+// ── 2. Mark as checked ───────────────────────────────────────────────────────
 try {
   mkdirSync(STATE_DIR, { recursive: true });
   writeFileSync(LOCK_FILE, String(Date.now()));
 } catch {
-  process.exit(0); // Can't write state — bail silently
+  process.stdout.write('{}\n');
+  process.exit(0);
 }
 
-// ── 3. Resolve local version ─────────────────────────────────────────────────
+// ── 3. Get local version ─────────────────────────────────────────────────────
 let localVersion = '';
 try {
   const pkg = JSON.parse(readFileSync(join(WORKSPACE, 'package.json'), 'utf8'));
   localVersion = pkg.version || '';
 } catch {
+  process.stdout.write('{}\n');
   process.exit(0);
 }
 
-if (!localVersion) process.exit(0);
-
-// ── 4. Detach background worker — parent returns immediately ─────────────────
-// The worker script is inlined as a node -e string to avoid needing a temp file.
-const workerScript = `
-import { spawnSync } from 'child_process';
-import { readFileSync } from 'fs';
-
-const localVersion = ${JSON.stringify(localVersion)};
+if (!localVersion) {
+  process.stdout.write('{}\n');
+  process.exit(0);
+}
 
-// 3-second timeout npm check
+// ── 4. Check registry (fast, 3s timeout) ─────────────────────────────────────
 const npmResult = spawnSync('npm', ['view', 'dual-brain', 'version'], {
   encoding: 'utf8',
   stdio: ['pipe', 'pipe', 'pipe'],
@@ -61,42 +60,41 @@ const npmResult = spawnSync('npm', ['view', 'dual-brain', 'version'], {
 });
 
 const latestVersion = (npmResult.stdout || '').trim();
-if (!latestVersion) process.exit(0);
-
-// Compare: is latest strictly greater than local?
-function versionGt(a, b) {
-  const ap = a.replace(/^v/i, '').split('.').map(n => parseInt(n, 10) || 0);
-  const bp = b.replace(/^v/i, '').split('.').map(n => parseInt(n, 10) || 0);
-  const len = Math.max(ap.length, bp.length);
-  for (let i = 0; i < len; i++) {
-    const diff = (bp[i] || 0) - (ap[i] || 0);
-    if (diff !== 0) return diff > 0;
-  }
-  return false;
+if (!latestVersion || !_isNewer(localVersion, latestVersion)) {
+  process.stdout.write('{}\n');
+  process.exit(0);
 }
 
-if (!versionGt(localVersion, latestVersion)) process.exit(0);
+// ── 5. Install immediately — no detach, no background, just do it ────────────
+process.stderr.write(`[dual-brain] updating ${localVersion} → ${latestVersion}\n`);
 
-// Newer version found — print notice then install
-process.stderr.write('dual-brain: updating v' + localVersion + ' → ' + latestVersion + '...\\n');
-
-spawnSync('npx', ['-y', 'dual-brain@latest', '--quiet'], {
-  stdio: 'ignore',
-  timeout: 120000,
+const installResult = spawnSync('npm', ['install', '-g', `dual-brain@${latestVersion}`], {
+  encoding: 'utf8',
+  stdio: ['pipe', 'pipe', 'pipe'],
+  timeout: 30000,
 });
-`;
 
-const child = spawn(
-  process.execPath,
-  ['--input-type=module'],
-  {
-    detached: true,
-    stdio: ['pipe', 'ignore', 'ignore'],
-  }
-);
-
-child.stdin.write(workerScript);
-child.stdin.end();
-child.unref(); // Let parent exit without waiting
+if (installResult.status === 0) {
+  // Write notice for HEAD to pick up
+  const notice = { from: localVersion, to: latestVersion, ts: Date.now() };
+  writeFileSync(NOTICE_FILE, JSON.stringify(notice));
+  process.stderr.write(`[dual-brain] updated to ${latestVersion}\n`);
+} else {
+  process.stderr.write(`[dual-brain] update failed, continuing with ${localVersion}\n`);
+}
 
+process.stdout.write('{}\n');
 process.exit(0);
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function _isNewer(local, remote) {
+  const lp = local.split('.').map(Number);
+  const rp = remote.split('.').map(Number);
+  for (let i = 0; i < Math.max(lp.length, rp.length); i++) {
+    const diff = (rp[i] || 0) - (lp[i] || 0);
+    if (diff > 0) return true;
+    if (diff < 0) return false;
+  }
+  return false;
+}

package/hooks/diagnostic-companion.mjs

@@ -285,7 +285,7 @@ function detectStuckLoop(state) {
   }
 
   for (const [sig, count] of signatures) {
-    if (count >= 3) {
+    if (count >= 5) {
       return {
         ts: Date.now(),
         type: 'stuck-loop',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -150,11 +150,9 @@
     "hooks/control-panel.mjs",
     "hooks/risk-classifier.mjs",
     "hooks/failure-detector.mjs",
-    "hooks/vibe-router.mjs",
     "hooks/plan-generator.mjs",
     "hooks/vibe-memory.mjs",
     "hooks/wave-orchestrator.mjs",
-    "hooks/task-classifier.mjs",
     "hooks/model-registry.mjs",
     "hooks/auto-update-wrapper.mjs",
     "hooks/session-end.mjs",

package/src/cognitive-loop.mjs

@@ -86,6 +86,9 @@ export function enter(userMessage, context = {}) {
   const headState = loadState();
   const loopState = loadLoopState();
 
+  // Check if we just auto-updated — surface it naturally
+  _checkUpdateNotice(context);
+
   // Immersion: load memory tiers so HEAD is "in the song"
   const memory = memoryTiers.assemble({
     userMessage,
@@ -119,6 +122,12 @@ export function enter(userMessage, context = {}) {
     confidence: turn.result.confidence.score,
   });
 
+  // Surface update notice as a noticing
+  if (context._updateNotice) {
+    turn.result.surfaceNoticings = turn.result.surfaceNoticings || [];
+    turn.result.surfaceNoticings.unshift(context._updateNotice);
+  }
+
   // Narrative evolution: update HEAD's running understanding
   _evolveNarrative(turn, userMessage, context);
 
@@ -504,6 +513,22 @@ function _postWaveReflection(waveSummary, loopState) {
   narrative.evolve(parts.join(' '));
 }
 
+/**
+ * Check for update notice and surface it to HEAD's awareness.
+ */
+function _checkUpdateNotice(context) {
+  try {
+    const noticeFile = join(LOOP_STATE_DIR, '.update-notice');
+    if (!existsSync(noticeFile)) return;
+    const notice = JSON.parse(readFileSync(noticeFile, 'utf8'));
+    if (Date.now() - notice.ts < 5 * 60 * 1000) {
+      context._updateNotice = `Updated dual-brain ${notice.from} → ${notice.to}`;
+    }
+    // Clear it after reading (one-shot)
+    try { writeFileSync(noticeFile, ''); } catch {}
+  } catch {}
+}
+
 // ── Query functions ─────────────────────────────────────────────────────────
 
 export function getActivePlan() {

package/src/continuity.mjs

@@ -9,6 +9,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
+import { load as loadNarrative } from './narrative.mjs';
 
 // ─── Session chaining ─────────────────────────────────────────────────────────
 
@@ -32,13 +33,13 @@ import { join } from 'node:path';
  */
 export function generateHandoff(sessionState) {
   return {
-    version: 1,
+    version: 2,
     timestamp: new Date().toISOString(),
     task: sessionState.taskDescription || null,
     progress: {
       filesChanged: (sessionState.filesChanged || []).slice(0, 20),
       testsRun: sessionState.testsRun || [],
-      decisions: (sessionState.decisions || []).slice(0, 5), // most recent routing decisions
+      decisions: (sessionState.decisions || []).slice(0, 5),
     },
     unresolved: (sessionState.unresolved || []).slice(0, 5),
     routing: {
@@ -48,6 +49,7 @@ export function generateHandoff(sessionState) {
     },
     preferences: sessionState.activePreferences || [],
     resumeHint: sessionState.resumeHint || null,
+    narrative: sessionState.narrative || loadNarrative() || null,
   };
 }
 
@@ -168,6 +170,11 @@ export function buildResumeBrief(cwd) {
 
   lines.push(`Resuming from previous session (${ageLabel}):`);
 
+  // Narrative first — most valuable context for immersion
+  if (handoff.narrative) {
+    lines.push(`  Context: ${handoff.narrative.slice(0, 300)}`);
+  }
+
   if (handoff.task) lines.push(`  Task: ${handoff.task}`);
   if (handoff.resumeHint) lines.push(`  Next: ${handoff.resumeHint}`);
   if (handoff.progress?.filesChanged?.length) {

package/hooks/task-classifier.mjs

@@ -1,328 +0,0 @@
-#!/usr/bin/env node
-/**
- * task-classifier.mjs — Analyze work descriptions and return model + effort + mode config.
- *
- * Uses model-registry capabilities to make informed routing decisions:
- * - Which model (per provider) handles this task best
- * - What effort/reasoning level to use
- * - Whether to enable extended thinking, fast mode, extended context, web search
- * - How to dispatch (Claude Agent vs Codex exec)
- *
- * Exports: classifyTask, selectModelEffort, INTENTS
- * CLI:     node hooks/task-classifier.mjs "description" [--files a,b] [--budget-pressure 0.8]
- */
-
-import { classifyRisk, extractPaths } from './risk-classifier.mjs';
-import {
-  MODEL_CAPABILITIES, getCapabilities, getDispatchConfig,
-  recommendEffort, shouldUseExtendedContext, shouldUseFastMode,
-  getBestModelFor,
-} from './model-registry.mjs';
-
-// ─── Intent definitions ───────────────────────────────────────────────────────
-
-const INTENTS = {
-  search:       /\b(grep|find|locate|where is|where are|list|explore|read|look up|look for|check|what is|show me|display)\b/i,
-  explain:      /\b(explain|walk me through|what does|how does|describe|summarize|understand|clarify)\b/i,
-  compare:      /\b(compare|contrast|difference|versus|vs\.?|trade.?off|which is better|pros and cons|benchmark|performance)\b/i,
-  document:     /\b(document|docs?|readme|jsdoc|typedoc|api docs|write docs|add docs|update docs)\b/i,
-  format:       /\b(format|lint|prettier|style|indent|whitespace|typo|typos|comment[s]?|reformat)\b/i,
-  planning:     /\b(plan|roadmap|strategy|prioritize|break down|decompose|prioritise)\b/i,
-  architecture: /\b(design|architect|architecture|propose|how should we|system design|system architecture)\b/i,
-  security:     /\b(auth|credential|secret|token|password|encrypt|permission[s]?|vulnerability|vulnerabilities|CVE|oauth|jwt|api.?key)\b/i,
-  review:       /\b(review|audit|check for issues|evaluate|assess|inspect code|code review)\b/i,
-  debug:        /\b(debug|investigate|why (is|does|isn't|doesn't)|trace|diagnose|figure out|broken|not working|failing|regression)\b/i,
-  test:         /\b(test[s]?|spec[s]?|add test|fix test|test coverage|unit test|e2e|integration test|jest|vitest|mocha)\b/i,
-  refactor:     /\b(refactor|restructure|reorganize|reorganise|extract|split|consolidate|clean up|cleanup|dedupe|dedup)\b/i,
-  edit:         /\b(fix|add|update|modify|change|rename|move|replace|write|implement|create|remove|delete|insert)\b/i,
-};
-
-const INTENT_PRIORITY = [
-  'security', 'architecture', 'planning', 'compare', 'review',
-  'debug', 'refactor', 'test', 'explain', 'document', 'format', 'search', 'edit',
-];
-
-// ─── Risk keyword detection (description-level) ──────────────────────────────
-
-const RISK_KEYWORDS = [
-  { level: 'critical', regex: /\b(auth|secret|credential|token|password|encrypt|certificate|oauth|jwt|api.?key|vulnerability|CVE)\b/i },
-  { level: 'high',     regex: /\b(billing|payment|migration|deploy|ci.?cd|security|permission|policy|schema|openapi|swagger|production|prod)\b/i },
-  { level: 'medium',   regex: /\b(test|spec|config|shared|util|lib|integration|public.?api)\b/i },
-  { level: 'low',      regex: /\b(readme|docs?|comment|format|lint|changelog|typo|whitespace)\b/i },
-];
-
-const LEVEL_ORDER = { critical: 3, high: 2, medium: 1, low: 0 };
-
-function detectKeywordRisk(description) {
-  for (const { level, regex } of RISK_KEYWORDS) {
-    if (regex.test(description)) return level;
-  }
-  return 'low';
-}
-
-function higherRisk(a, b) {
-  return LEVEL_ORDER[a] >= LEVEL_ORDER[b] ? a : b;
-}
-
-// ─── classifyTask ─────────────────────────────────────────────────────────────
-
-function classifyTask(description, options = {}) {
-  const { files = [], priorFailures = 0 } = options;
-
-  // 1. Intent detection
-  let intent = 'edit';
-  for (const key of INTENT_PRIORITY) {
-    if (INTENTS[key].test(description)) {
-      intent = key;
-      break;
-    }
-  }
-
-  // 2. Risk detection
-  const allPaths = [...files, ...extractPaths(description)];
-  const pathRisk = allPaths.length > 0 ? classifyRisk(allPaths).level : 'low';
-  const keywordRisk = detectKeywordRisk(description);
-  const risk = higherRisk(pathRisk, keywordRisk);
-
-  // 3. File count
-  const fileCount = files.length;
-
-  // 4. Complexity detection
-  let complexity;
-  const isAmbiguous = description.length > 120 || /\b(and also|as well as|plus|additionally|also)\b/i.test(description);
-
-  if (priorFailures >= 2 || intent === 'architecture' || risk === 'critical' || fileCount >= 6 || isAmbiguous && risk === 'critical') {
-    complexity = 'complex';
-  } else if (fileCount >= 3 || intent === 'refactor' || intent === 'debug' || risk === 'high' || isAmbiguous) {
-    complexity = 'moderate';
-  } else if (fileCount <= 2 && (risk === 'low' || risk === 'medium')) {
-    if (intent === 'format' || fileCount <= 1 && risk === 'low') {
-      complexity = 'trivial';
-    } else {
-      complexity = 'simple';
-    }
-  } else {
-    complexity = 'moderate';
-  }
-
-  // 5. Effort selection
-  const baseEffort = { trivial: 'low', simple: 'medium', moderate: 'high', complex: 'high' }[complexity];
-  const effortOrder = ['low', 'medium', 'high', 'xhigh'];
-
-  function bumpEffort(e, n = 1) {
-    return effortOrder[Math.min(effortOrder.indexOf(e) + n, effortOrder.length - 1)];
-  }
-
-  let effort = baseEffort;
-
-  if (risk === 'critical' && LEVEL_ORDER[effort] < LEVEL_ORDER['high']) effort = 'high';
-
-  if (priorFailures >= 2) {
-    effort = 'xhigh';
-  } else if (priorFailures === 1) {
-    effort = bumpEffort(effort, 1);
-  }
-
-  if (intent === 'format' || intent === 'search') {
-    if (LEVEL_ORDER[effort] > LEVEL_ORDER['medium']) effort = 'medium';
-  }
-  if ((intent === 'architecture' || intent === 'security') && LEVEL_ORDER[effort] < LEVEL_ORDER['high']) {
-    effort = 'high';
-  }
-
-  // 6. Reason
-  const reasons = [];
-  if (fileCount > 0) reasons.push(`${fileCount} file(s)`);
-  if (risk !== 'low') reasons.push(`${risk} risk`);
-  if (priorFailures > 0) reasons.push(`${priorFailures} prior failure(s)`);
-  reasons.push(`intent=${intent}, complexity=${complexity}`);
-  const reason = reasons.join('; ');
-
-  return { intent, risk, complexity, fileCount, effort, reason };
-}
-
-// ─── selectModelEffort ────────────────────────────────────────────────────────
-
-function selectModelEffort(taskProfile, options = {}) {
-  const { budgetPressure = 0, userBudgetTier = '$100', isIterating = false, estimatedTokens = 0 } = options;
-  const { intent, risk, effort, complexity } = taskProfile;
-
-  // ── Intent classification for routing ──
-  const thinkIntents = ['architecture', 'security', 'review', 'planning', 'compare'];
-  const searchIntents = ['search', 'format', 'explain'];
-  const lightIntents = ['document', 'explain', 'format', 'search'];
-
-  const needsOpus = thinkIntents.includes(intent)
-    || risk === 'critical'
-    || effort === 'xhigh';
-
-  const needsHaiku = searchIntents.includes(intent) && effort === 'low';
-
-  let claudeModel = needsOpus ? 'opus' : needsHaiku ? 'haiku' : 'sonnet';
-
-  // ── Claude effort (from registry, null-safe for haiku) ──
-  const caps = getCapabilities(claudeModel);
-  let claudeEffort = caps?.reasoning?.effortLevels
-    ? (recommendEffort(claudeModel, complexity, risk) || effort)
-    : null;
-
-  // ── Claude modes ──
-  const claudeModes = {
-    extendedThinking: caps?.reasoning?.extendedThinking
-      && (complexity === 'moderate' || complexity === 'complex')
-      && !lightIntents.includes(intent),
-    fastMode: shouldUseFastMode(claudeModel, isIterating),
-    extendedContext: shouldUseExtendedContext(claudeModel, estimatedTokens),
-    ultrathink: claudeModel === 'opus'
-      && (risk === 'critical' || (complexity === 'complex' && thinkIntents.includes(intent))),
-  };
-
-  // ── OpenAI model selection (all models reachable) ──
-  let openaiModel;
-  if (needsOpus) {
-    openaiModel = 'gpt-5.5';
-  } else if (searchIntents.includes(intent) && effort === 'low') {
-    openaiModel = 'gpt-4.1-mini';
-  } else if (['edit', 'test', 'document'].includes(intent) && ['simple', 'trivial'].includes(complexity)) {
-    openaiModel = 'gpt-4.1';
-  } else if (intent === 'explain' && complexity !== 'trivial') {
-    openaiModel = 'gpt-5.2';
-  } else if (['edit', 'document'].includes(intent) && complexity === 'moderate') {
-    openaiModel = 'gpt-5.3-codex';
-  } else if (intent === 'test' && complexity === 'moderate') {
-    openaiModel = 'gpt-5.4-mini';
-  } else if (['refactor', 'debug'].includes(intent)) {
-    openaiModel = complexity === 'complex' ? 'gpt-5.4' : 'gpt-5.3-codex';
-  } else {
-    openaiModel = 'gpt-5.4';
-  }
-
-  // ── OpenAI effort (from registry) ──
-  let openaiEffort = recommendEffort(openaiModel, complexity, risk) || effort;
-
-  // ── OpenAI modes ──
-  const openaiCaps = getCapabilities(openaiModel);
-  const openaiModes = {
-    webSearch: openaiCaps?.modes?.webSearch ?? false,
-    sandbox: openaiCaps?.modes?.sandbox?.[
-      thinkIntents.includes(intent) ? 'think' : searchIntents.includes(intent) ? 'search' : 'execute'
-    ] ?? 'danger-full-access',
-  };
-
-  // ── Outcome learning override ──
-  // If we have enough empirical data, let it influence model selection
-  const empiricalClaude = getBestModelFor(intent, 'claude', { minSamples: 5 });
-  if (empiricalClaude && empiricalClaude.successRate !== null && empiricalClaude.successRate > 0.8) {
-    const caps = getCapabilities(empiricalClaude.model);
-    if (caps && !caps.avoidFor?.includes(intent)) {
-      claudeModel = empiricalClaude.model;
-    }
-  }
-
-  const empiricalOpenai = getBestModelFor(intent, 'openai', { minSamples: 5 });
-  if (empiricalOpenai && empiricalOpenai.successRate !== null && empiricalOpenai.successRate > 0.8) {
-    const caps = getCapabilities(empiricalOpenai.model);
-    if (caps && !caps.avoidFor?.includes(intent)) {
-      openaiModel = empiricalOpenai.model;
-    }
-  }
-
-  // ── Budget pressure adjustments ──
-  const reasons = [];
-  const isHighStakes = risk === 'critical' || risk === 'high';
-  const openaiModelRank = [
-    'gpt-4.1-mini', 'gpt-4.1', 'gpt-5.2', 'gpt-5.4-mini',
-    'gpt-5.3-codex', 'gpt-5.3-codex-spark', 'gpt-5.4', 'gpt-5.5',
-  ];
-
-  if (budgetPressure > 0.9 && !isHighStakes) {
-    claudeModel = claudeModel === 'opus' ? 'sonnet' : 'haiku';
-    const oaiIdx = openaiModelRank.indexOf(openaiModel);
-    openaiModel = openaiModelRank[Math.max(0, oaiIdx - 2)] || 'gpt-4.1-mini';
-    claudeModes.fastMode = false;
-    claudeModes.extendedContext = false;
-    claudeModes.extendedThinking = false;
-    reasons.push('near limit, aggressive downgrade for non-critical task');
-  } else if (budgetPressure > 0.7 && !isHighStakes) {
-    claudeModel = claudeModel === 'opus' ? 'sonnet' : claudeModel === 'sonnet' ? 'haiku' : 'haiku';
-    const oaiIdx = openaiModelRank.indexOf(openaiModel);
-    openaiModel = openaiModelRank[Math.max(0, oaiIdx - 1)] || 'gpt-4.1-mini';
-    claudeModes.fastMode = false;
-    reasons.push('downgraded due to budget pressure');
-  }
-
-  // Recalculate efforts after potential model change
-  const newCaps = getCapabilities(claudeModel);
-  claudeEffort = newCaps?.reasoning?.effortLevels
-    ? (recommendEffort(claudeModel, complexity, risk) || effort)
-    : null;
-  openaiEffort = recommendEffort(openaiModel, complexity, risk) || effort;
-
-  // ── Preferred provider (think→claude, isolated execute→openai) ──
-  const preferred = thinkIntents.includes(intent) ? 'claude' : 'openai';
-
-  // ── Dual-brain recommendation ──
-  const dualBrain = risk === 'critical'
-    || (thinkIntents.includes(intent) && (complexity === 'complex' || complexity === 'moderate'))
-    || intent === 'security'
-    || (intent === 'review' && risk !== 'low')
-    || (intent === 'refactor' && risk === 'critical');
-
-  if (reasons.length === 0) {
-    reasons.push(`${claudeModel}/${openaiModel} matched to ${intent} @ ${complexity} complexity`);
-  }
-  if (empiricalClaude?.successRate !== null) reasons.push(`claude empirical: ${empiricalClaude.model} ${Math.round(empiricalClaude.successRate * 100)}%`);
-  if (empiricalOpenai?.successRate !== null) reasons.push(`openai empirical: ${empiricalOpenai.model} ${Math.round(empiricalOpenai.successRate * 100)}%`);
-
-  return {
-    claude: {
-      model: claudeModel,
-      effort: claudeEffort,
-      modes: claudeModes,
-      dispatch: getDispatchConfig(claudeModel),
-    },
-    openai: {
-      model: openaiModel,
-      effort: openaiEffort,
-      modes: openaiModes,
-      dispatch: getDispatchConfig(openaiModel),
-    },
-    preferred,
-    dualBrain,
-    reason: reasons.join('; '),
-  };
-}
-
-// ─── CLI ──────────────────────────────────────────────────────────────────────
-
-if (process.argv[1] && new URL(import.meta.url).pathname === process.argv[1]) {
-  const args = process.argv.slice(2);
-  const description = args.find(a => !a.startsWith('--')) || '';
-  const filesArg = args.find(a => a.startsWith('--files=')) || args[args.indexOf('--files') + 1];
-  const budgetArg = args.find(a => a.startsWith('--budget-pressure=')) || args[args.indexOf('--budget-pressure') + 1];
-  const failuresArg = args.find(a => a.startsWith('--failures=')) || args[args.indexOf('--failures') + 1];
-
-  const files = (filesArg && !filesArg.startsWith('--'))
-    ? filesArg.replace(/^--files=/, '').split(',').map(f => f.trim())
-    : [];
-
-  const budgetPressure = budgetArg
-    ? parseFloat(budgetArg.replace(/^--budget-pressure=/, ''))
-    : 0;
-
-  const priorFailures = failuresArg
-    ? parseInt(failuresArg.replace(/^--failures=/, ''), 10)
-    : 0;
-
-  if (!description) {
-    console.error('Usage: node hooks/task-classifier.mjs "task description" [--files a,b] [--budget-pressure 0.8] [--failures 1]');
-    process.exit(1);
-  }
-
-  const profile = classifyTask(description, { files, priorFailures });
-  const selection = selectModelEffort(profile, { budgetPressure });
-
-  console.log(JSON.stringify({ profile, selection }, null, 2));
-}
-
-export { classifyTask, selectModelEffort, INTENTS };

package/hooks/vibe-router.mjs

@@ -1,387 +0,0 @@
-#!/usr/bin/env node
-/**
- * vibe-router.mjs — Intent compiler for vibe coding.
- * Decomposes casual natural language into structured work orders.
- *
- * Export: routeVibe(utterance) → { tasks, profile_hint, quality_gates }
- * CLI: node vibe-router.mjs "fix login bug and update the nav"
- */
-
-import { classifyRisk, extractPaths } from './risk-classifier.mjs';
-
-// ─── Tier Detection Patterns ───────────────────────────────────────────────
-// Aligned with enforce-tier.mjs SEARCH_WORDS, THINK_WORDS, and execute patterns.
-
-const SEARCH_WORDS = /\b(explore|search|find|grep|locate|where\s+is|list\s+files|read[-\s]?only|lookup|scan|check|look|where|what)\b/i;
-const THINK_WORDS = /\b(review|plan|design|architect|decide|analyze|audit|security|code[-\s]?review|threat[-\s]?model|complex[-\s]?debug|evaluate|compare|assess)\b/i;
-const EXECUTE_WORDS = /\b(fix|build|add|update|edit|implement|refactor|delete|commit|test|run|create|modify|write|change|remove|rename|move|install|deploy|migrate|convert|replace|rewrite)\b/i;
-
-// ─── Risk Keyword Patterns ─────────────────────────────────────────────────
-
-const RISK_KEYWORDS = [
-  { level: 'critical', regex: /\b(auth|credential|secret|\.env|key[s]?|token[s]?|password|encrypt|certificate)\b/i, label: 'security-sensitive' },
-  { level: 'high', regex: /\b(login|payment|billing|deploy|migration|ci[-/]?cd|permission|policy|schema|api[-_]?contract)\b/i, label: 'high-impact' },
-  { level: 'medium', regex: /\b(test|spec|config|integration|shared|util|lib)\b/i, label: 'shared/tested code' },
-  { level: 'low', regex: /\b(readme|docs?|comment|format|lint|style|typo|changelog|nav|ui|css|color|font|margin|padding)\b/i, label: 'docs/UI' },
-];
-
-const LEVEL_ORDER = { critical: 3, high: 2, medium: 1, low: 0 };
-
-// ─── Task Splitting ────────────────────────────────────────────────────────
-
-const TASK_SEPARATORS = /\b(?:and\s+(?:also\s+)?|also\s+|plus\s+|then\s+|after\s+that\s+|,\s*(?:and\s+)?)/i;
-
-/**
- * Split a casual utterance into individual task segments.
- * Handles "and", "also", "plus", "then", "after that", and comma separators.
- */
-function splitTasks(utterance) {
-  if (!utterance) return [];
-
-  const segments = utterance
-    .split(TASK_SEPARATORS)
-    .map(s => s.trim())
-    .filter(s => s.length > 2);
-
-  // If no split happened, the whole utterance is a single task
-  return segments.length === 0 ? [utterance.trim()] : segments;
-}
-
-// ─── Per-Task Classification ───────────────────────────────────────────────
-
-function classifyTier(text) {
-  if (THINK_WORDS.test(text)) return 'think';
-  if (EXECUTE_WORDS.test(text)) return 'execute';
-  if (SEARCH_WORDS.test(text)) return 'search';
-  return 'execute'; // default
-}
-
-function classifyKeywordRisk(text) {
-  let highest = { level: 'low', reason: 'general task' };
-
-  for (const pattern of RISK_KEYWORDS) {
-    const match = text.match(pattern.regex);
-    if (match && LEVEL_ORDER[pattern.level] > LEVEL_ORDER[highest.level]) {
-      highest = { level: pattern.level, reason: `${pattern.label} (${match[0]})` };
-      if (pattern.level === 'critical') return highest;
-    }
-  }
-
-  return highest;
-}
-
-function classifyTask(segment) {
-  const tier = classifyTier(segment);
-
-  // Check keyword-based risk
-  const keywordRisk = classifyKeywordRisk(segment);
-
-  // Check file-path-based risk (uses risk-classifier.mjs)
-  const paths = extractPaths(segment);
-  const pathRisk = classifyRisk(paths);
-
-  // Take the higher of keyword risk and path risk
-  const risk = LEVEL_ORDER[pathRisk.level] > LEVEL_ORDER[keywordRisk.level]
-    ? pathRisk
-    : keywordRisk;
-
-  // Generate a clean title: capitalize first letter, trim trailing punctuation
-  const title = segment.charAt(0).toUpperCase() + segment.slice(1).replace(/[.!?]+$/, '');
-
-  return {
-    title,
-    tier,
-    risk: risk.level,
-    reason: risk.reason,
-  };
-}
-
-// ─── Profile Hint Detection ────────────────────────────────────────────────
-
-const QUALITY_HINT_WORDS = /\b(be\s+careful|take\s+your\s+time|thorough|deep\s+dive|carefully|exhaustive|comprehensive)\b/i;
-const COST_HINT_WORDS = /\b(quick|fast|just|quickly|rapid|simple|straightforward)\b/i;
-
-function detectProfileHint(utterance) {
-  if (QUALITY_HINT_WORDS.test(utterance)) return 'quality-first';
-  if (COST_HINT_WORDS.test(utterance)) return 'cost-saver';
-  return null;
-}
-
-// ─── Quality Gates ─────────────────────────────────────────────────────────
-
-function determineQualityGates(tasks) {
-  const gates = new Set();
-
-  let highestRisk = 'low';
-  for (const task of tasks) {
-    if (LEVEL_ORDER[task.risk] > LEVEL_ORDER[highestRisk]) {
-      highestRisk = task.risk;
-    }
-  }
-
-  switch (highestRisk) {
-    case 'critical':
-      gates.add('dual_brain_required');
-      gates.add('tests');
-      gates.add('user_permission');
-      break;
-    case 'high':
-      gates.add('dual_brain_review');
-      gates.add('tests');
-      break;
-    case 'medium':
-      gates.add('tests');
-      break;
-    case 'low':
-      gates.add('self_check');
-      break;
-  }
-
-  return [...gates];
-}
-
-// ─── Ordered Language Detection ───────────────────────────────────────────
-
-const DEPENDENCY_MARKERS = /\b(then|after\s+that|once\s+\S+\s+is\s+done|before|first|next|finally|afterwards|subsequently|followed\s+by|depends?\s+on|requires?)\b/i;
-
-// ─── Subsystem Detection ─────────────────────────────────────────────────
-
-const SUBSYSTEM_PATTERNS = [
-  { key: 'auth', regex: /\b(auth|login|sign[-\s]?in|sign[-\s]?up|session|credential|password|oauth|jwt|token)\b/i },
-  { key: 'billing', regex: /\b(billing|payment|subscription|invoice|charge|stripe|pricing)\b/i },
-  { key: 'api', regex: /\b(api|endpoint|route|controller|handler|middleware|rest|graphql)\b/i },
-  { key: 'ui', regex: /\b(ui|nav|button|page|component|layout|style|css|modal|form|menu|sidebar|header|footer|dashboard)\b/i },
-  { key: 'db', regex: /\b(database|db|schema|migration|model|query|table|column|index|sql|prisma|sequelize|knex)\b/i },
-  { key: 'infra', regex: /\b(deploy|ci|cd|docker|k8s|terraform|infra|pipeline|build|config|env)\b/i },
-  { key: 'test', regex: /\b(test|spec|fixture|mock|stub|assert|coverage)\b/i },
-  { key: 'docs', regex: /\b(doc|readme|changelog|guide|tutorial|comment)\b/i },
-];
-
-function detectSubsystems(text) {
-  const subs = new Set();
-  for (const pat of SUBSYSTEM_PATTERNS) {
-    if (pat.regex.test(text)) subs.add(pat.key);
-  }
-  return subs;
-}
-
-// ─── Risk Domain Extraction ──────────────────────────────────────────────
-
-function getRiskDomains(task) {
-  const domains = new Set();
-  // Use subsystem as risk domain
-  const subs = detectSubsystems(task.title);
-  for (const s of subs) domains.add(s);
-  // Also include explicit risk reason label
-  if (task.reason) {
-    const match = task.reason.match(/^([^(]+)/);
-    if (match) domains.add(match[1].trim().toLowerCase());
-  }
-  return domains;
-}
-
-// ─── Complexity + Wave Recommendation ──────────────────────────────────────
-
-function determineComplexity(tasks) {
-  const highestRisk = tasks.reduce(
-    (max, t) => LEVEL_ORDER[t.risk] > LEVEL_ORDER[max] ? t.risk : max,
-    'low'
-  );
-
-  if (tasks.length >= 4 || highestRisk === 'high' || highestRisk === 'critical') {
-    return 'complex';
-  }
-  if (tasks.length >= 2 || highestRisk === 'medium') {
-    return 'structured';
-  }
-  return 'simple';
-}
-
-/**
- * determineWave — Sequential by default, parallel only when tasks are truly independent.
- *
- * Returns { wave, reasons } where reasons is an array of reason codes:
- *   shared_surface  — tasks likely touch same files
- *   high_risk       — risky work should be sequential for review
- *   dependency_marker — ordered language detected in utterance
- *   same_subsystem  — tasks in same domain/subsystem
- *   independent     — truly independent, safe for parallel
- */
-function determineWave(tasks, complexity, utterance) {
-  if (tasks.length === 1) return { wave: 'single', reasons: [] };
-
-  const reasons = [];
-
-  // 1. Check for ordered language in the original utterance
-  if (utterance && DEPENDENCY_MARKERS.test(utterance)) {
-    reasons.push('dependency_marker');
-  }
-
-  // 2. Check for high/critical risk tasks
-  const hasHighRisk = tasks.some(t => t.risk === 'high' || t.risk === 'critical');
-  if (hasHighRisk) {
-    reasons.push('high_risk');
-  }
-
-  // 3. Check for overlapping subsystems between tasks
-  const taskSubsystems = tasks.map(t => detectSubsystems(t.title));
-  let hasSharedSubsystem = false;
-  for (let i = 0; i < taskSubsystems.length; i++) {
-    for (let j = i + 1; j < taskSubsystems.length; j++) {
-      for (const sub of taskSubsystems[i]) {
-        if (taskSubsystems[j].has(sub)) {
-          hasSharedSubsystem = true;
-          break;
-        }
-      }
-      if (hasSharedSubsystem) break;
-    }
-    if (hasSharedSubsystem) break;
-  }
-  if (hasSharedSubsystem) {
-    reasons.push('same_subsystem');
-  }
-
-  // 4. Check for overlapping file paths / shared surface area
-  const taskPaths = tasks.map(t => extractPaths(t.title));
-  let hasSharedPaths = false;
-  for (let i = 0; i < taskPaths.length; i++) {
-    for (let j = i + 1; j < taskPaths.length; j++) {
-      for (const p of taskPaths[i]) {
-        // Check if any path from task j shares a directory prefix or exact match
-        for (const q of taskPaths[j]) {
-          if (p === q || p.startsWith(q + '/') || q.startsWith(p + '/') ||
-              p.split('/').slice(0, -1).join('/') === q.split('/').slice(0, -1).join('/')) {
-            hasSharedPaths = true;
-            break;
-          }
-        }
-        if (hasSharedPaths) break;
-      }
-      if (hasSharedPaths) break;
-    }
-    if (hasSharedPaths) break;
-  }
-  if (hasSharedPaths) {
-    reasons.push('shared_surface');
-  }
-
-  // 5. Check for shared risk domains
-  const taskDomains = tasks.map(t => getRiskDomains(t));
-  let hasSharedDomain = false;
-  for (let i = 0; i < taskDomains.length; i++) {
-    for (let j = i + 1; j < taskDomains.length; j++) {
-      for (const d of taskDomains[i]) {
-        if (taskDomains[j].has(d)) {
-          hasSharedDomain = true;
-          break;
-        }
-      }
-      if (hasSharedDomain) break;
-    }
-    if (hasSharedDomain) break;
-  }
-  // Only add same_subsystem if not already added (risk domains overlap with subsystems)
-  if (hasSharedDomain && !reasons.includes('same_subsystem')) {
-    reasons.push('same_subsystem');
-  }
-
-  // Decision: parallel ONLY when no sequential reasons found
-  if (reasons.length === 0) {
-    reasons.push('independent');
-    return { wave: 'parallel', reasons };
-  }
-
-  return { wave: 'sequential', reasons };
-}
-
-// ─── Summary Generation ────────────────────────────────────────────────────
-
-function generateSummary(tasks, complexity, wave, qualityGates, profileHint) {
-  const parts = [];
-
-  if (tasks.length === 1) {
-    const t = tasks[0];
-    parts.push(`Single ${t.tier} task: ${t.title} (${t.risk} risk).`);
-  } else {
-    const taskDescs = tasks.map(t => `${t.title.toLowerCase()} (${t.risk} risk, ${t.tier})`);
-    parts.push(`Split into ${tasks.length} tasks: ${taskDescs.join(' + ')}.`);
-  }
-
-  if (wave === 'parallel' && tasks.length > 1) {
-    parts.push('Recommend parallel agents.');
-  } else if (wave === 'sequential') {
-    parts.push('Recommend sequential execution.');
-  }
-
-  if (qualityGates.includes('dual_brain_required')) {
-    parts.push('Dual-brain review required for critical changes.');
-  } else if (qualityGates.includes('dual_brain_review')) {
-    parts.push('Dual-brain review recommended for high-risk changes.');
-  }
-
-  if (profileHint) {
-    parts.push(`Profile hint: ${profileHint}.`);
-  }
-
-  return parts.join(' ');
-}
-
-// ─── Main Entry Point ──────────────────────────────────────────────────────
-
-/**
- * routeVibe(utterance) — Decompose a casual natural language utterance
- * into structured work orders with tier, risk, and quality gate assignments.
- *
- * @param {string} utterance - The user's casual description
- * @returns {{ complexity, tasks, profile_hint, quality_gates, wave_recommendation, summary }}
- */
-function routeVibe(utterance) {
-  if (!utterance || typeof utterance !== 'string' || !utterance.trim()) {
-    return {
-      complexity: 'simple',
-      tasks: [],
-      profile_hint: null,
-      quality_gates: ['self_check'],
-      wave_recommendation: 'single',
-      summary: 'No input provided.',
-    };
-  }
-
-  const segments = splitTasks(utterance);
-  const tasks = segments.map(classifyTask);
-  const profileHint = detectProfileHint(utterance);
-  const qualityGates = determineQualityGates(tasks);
-  const complexity = determineComplexity(tasks);
-  const { wave, reasons } = determineWave(tasks, complexity, utterance);
-  const summary = generateSummary(tasks, complexity, wave, qualityGates, profileHint);
-
-  return {
-    complexity,
-    tasks,
-    profile_hint: profileHint,
-    quality_gates: qualityGates,
-    wave_recommendation: wave,
-    wave_reasons: reasons,
-    summary,
-  };
-}
-
-export { routeVibe, splitTasks, classifyTask, detectProfileHint };
-
-// ─── CLI ───────────────────────────────────────────────────────────────────
-
-const isMain = process.argv[1] && (
-  process.argv[1].endsWith('vibe-router.mjs') ||
-  process.argv[1].endsWith('vibe-router')
-);
-
-if (isMain) {
-  const utterance = process.argv.slice(2).join(' ');
-  if (!utterance) {
-    console.error('Usage: node vibe-router.mjs "fix the login bug and also update the nav"');
-    process.exit(1);
-  }
-  const result = routeVibe(utterance);
-  console.log(JSON.stringify(result, null, 2));
-}