dual-brain 0.2.16 → 0.2.18

package/CLAUDE.md

@@ -7,12 +7,14 @@ This project uses dual-provider orchestration. Config: `.claude/orchestrator.jso
 HEAD is the orchestration brain. Workers implement. This is enforced by architecture, not just policy.
 
 1. **HEAD plans, workers implement.** HEAD dispatches typed task contracts via agents. HEAD never edits files, runs implementation commands, or writes code directly.
-2. **Discuss before dispatching.** Every action task starts with intent classification. Ambiguous requests get clarified. Architecture decisions get discussed.
-3. **Typed contracts are mandatory.** Every dispatch includes: objective, scope, acceptance criteria, risk level, allowed operations. Use `src/templates.mjs` to generate prompts.
-4. **Dangerous work requires approval.** Auth, credentials, secrets, billing, migrations, destructive git — explicit user confirmation before dispatch.
-5. **Runtime state is source of truth.** HEAD's state machine (`src/head.mjs`) tracks phase, intent, confidence, and drift. Not CLAUDE.md text.
-6. **Hooks enforce boundaries.** head-guard blocks HEAD from implementing. enforce-tier ensures correct routing. Telemetry hooks observe but never block.
-7. **Subscription-only auth.** Users authenticate via `claude login` / `codex login`. No API keys.
+2. **Think before acting — always.** HEAD applies the same cognitive rigor to its own responses as it does to dispatches. Before proposing actions: assess depth, consider scope, check if the request needs thinking or just execution. Never list things to build without first determining if they should be built. This applies to conversations, not just agent calls.
+3. **Discuss before dispatching.** Every action task starts with intent classification. Ambiguous requests get clarified. Architecture decisions get discussed.
+4. **Typed contracts are mandatory.** Every dispatch includes: objective, scope, acceptance criteria, risk level, allowed operations. Use `src/templates.mjs` to generate prompts.
+5. **Dangerous work requires approval.** Auth, credentials, secrets, billing, migrations, destructive git — explicit user confirmation before dispatch.
+6. **Complete the cycle.** HEAD finishes what it starts: implement → test → commit → push → publish. Don't stop halfway and ask the user to do admin. If the system can do it, HEAD does it.
+7. **Runtime state is source of truth.** HEAD's state machine (`src/head.mjs`) tracks phase, intent, confidence, and drift. Not CLAUDE.md text.
+8. **Hooks enforce boundaries.** head-guard blocks HEAD from implementing. enforce-tier ensures correct routing. Telemetry hooks observe but never block.
+9. **Subscription-only auth.** Users authenticate via `claude login` / `codex login`. No API keys.
 
 ## Quick Reference
 

package/bin/dual-brain.mjs

@@ -571,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "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/scripts/verify-publish.mjs

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 import { readFileSync } from 'fs';
+import { execSync } from 'child_process';
+
 const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 const url = `https://registry.npmjs.org/dual-brain/${version}`;
 const maxWait = 30000;
@@ -10,17 +12,52 @@ async function check() {
     const res = await fetch(url);
     if (res.ok) {
       console.log(`✓ dual-brain@${version} verified on registry`);
-      return;
+      return true;
     }
   } catch {}
 
   if (Date.now() - start > maxWait) {
     console.log(`⚠ dual-brain@${version} published but CDN propagation may take a moment`);
-    return;
+    return true;
   }
 
   await new Promise(r => setTimeout(r, 3000));
   return check();
 }
 
-check();
+async function commitAndPush() {
+  try {
+    // Check if there are changes to commit
+    const status = execSync('git status --porcelain', { encoding: 'utf8' }).trim();
+    if (!status) return;
+
+    // Stage all tracked + new src/hooks/bin files (not .dualbrain/ runtime state)
+    execSync('git add src/ hooks/ bin/ scripts/ package.json CLAUDE.md .claude/ .replit .gitignore tests/ 2>/dev/null || true', { encoding: 'utf8' });
+
+    // Check if anything was staged
+    const staged = execSync('git diff --cached --stat', { encoding: 'utf8' }).trim();
+    if (!staged) return;
+
+    execSync(`git commit -m "${version}: publish"`, { encoding: 'utf8' });
+    console.log(`✓ committed ${version}`);
+
+    // Push with explicit credential helper (Replit persistence)
+    const ghDir = '/home/runner/workspace/.replit-tools/.gh-persistent';
+    const credHelper = `!GH_CONFIG_DIR=${ghDir} gh auth git-credential`;
+    execSync(`git -c 'credential.https://github.com.helper=${credHelper}' push`, {
+      encoding: 'utf8',
+      timeout: 15000,
+      env: { ...process.env, GH_CONFIG_DIR: ghDir },
+    });
+    console.log(`✓ pushed to origin`);
+  } catch (e) {
+    // Non-fatal — publish succeeded even if commit/push fails
+    const msg = e.message || '';
+    if (msg.includes('Authentication')) {
+      console.log(`⚠ push failed (git auth not configured) — commit is local`);
+    }
+  }
+}
+
+const verified = await check();
+if (verified) await commitAndPush();

package/src/cognitive-loop.mjs

@@ -114,12 +114,14 @@ export function enter(userMessage, context = {}) {
   // Phase 1: Full cognitive pipeline
   const turn = processTurn(headState, userMessage, context);
 
-  // Save situation for history
+  // Save situation for history (includes mode for turn-over-turn tracking)
+  const mode = turn.situation?.mode || { primary: 'work', confidence: 0.5 };
   loopState.situationHistory.push({
     ts: Date.now(),
     depth: turn.depth,
     action: turn.action.type,
     confidence: turn.result.confidence.score,
+    mode: mode.primary,
   });
 
   // Surface update notice as a noticing
@@ -145,6 +147,7 @@ export function enter(userMessage, context = {}) {
       surfaceNoticings: turn.result.surfaceNoticings,
       plan: null,
       nextDispatch: null,
+      mode,
     };
   }
 

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 ─────────────────────────────────────────────────────────
 
@@ -48,7 +49,7 @@ export function generateHandoff(sessionState) {
     },
     preferences: sessionState.activePreferences || [],
     resumeHint: sessionState.resumeHint || null,
-    narrative: sessionState.narrative || null,
+    narrative: sessionState.narrative || loadNarrative() || null,
   };
 }
 
@@ -169,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/src/head.mjs

@@ -100,6 +100,9 @@ export function perceive(message, context = {}) {
   // Relationship signals — should HEAD ask, act, or advise?
   const relationship = _assessRelationship(message, context, taskShape);
 
+  // Mode sensing — what energy is the user bringing?
+  const mode = detectMode(message, context);
+
   return {
     raw: message,
     explicitAsk: message.trim(),
@@ -111,6 +114,7 @@ export function perceive(message, context = {}) {
     taskShape,
     material,
     relationship,
+    mode,
 
     // Depth signals for adaptive processing
     ambiguity: taskShape.ambiguity,
@@ -125,6 +129,109 @@ export function perceive(message, context = {}) {
   };
 }
 
+// ── Mode Sensing ────────────────────────────────────────────────────────────
+// Detects user energy/intent mode. Re-evaluated every turn. Never announced.
+// Shapes HEAD's response style, not its decisions.
+
+const MODE_EXECUTE_WORDS = /^(go|do it|ship it|fix it|run it|push|merge|deploy|yes|ok do it|lets go|make it|just do it|ship|publish)$/i;
+const MODE_IDEATE_WORDS = /\b(what if|imagine|wouldn't it be|picture this|feels like|i feel like|sort of like|wild idea|crazy thought|could we maybe|vibe)\b/i;
+const MODE_EXPLORE_WORDS = /\b(how does|what is|where is|why does|explain|walk me through|show me|tell me about|i don't understand|new to)\b/i;
+const MODE_DISCUSS_WORDS = /\b(what do you think|should we|tradeoffs?|pros and cons|is it better|alternatively|option|or should|concerns?|worry|weigh)\b/i;
+const MODE_WORK_SIGNALS = /(`[^`]+`|\.mjs|\.ts|\.js|\.py|src\/|hooks\/|bin\/|\bfunction\b|\bclass\b|\bimport\b)/;
+
+/**
+ * Detect user's conversational mode from message signals.
+ * Returns a probability distribution with the dominant mode.
+ *
+ * @param {string} message
+ * @param {object} context
+ * @returns {{primary: string, confidence: number, scores: object, signals: string[]}}
+ */
+export function detectMode(message, context = {}) {
+  const scores = { execute: 0, ideate: 0, work: 0, explore: 0, discuss: 0 };
+  const signals = [];
+  const words = message.trim().split(/\s+/);
+  const len = words.length;
+
+  // ── Length signal (most predictive single feature) ──
+  if (len <= 4) { scores.execute += 3; signals.push('very-short'); }
+  else if (len <= 10) { scores.execute += 1; scores.work += 1; }
+  else if (len >= 80) { scores.ideate += 2; signals.push('long-message'); }
+  else if (len >= 40) { scores.ideate += 1; scores.discuss += 1; }
+
+  // ── Lexical signals ──
+  if (MODE_EXECUTE_WORDS.test(message.trim())) { scores.execute += 4; signals.push('execute-word'); }
+  if (MODE_IDEATE_WORDS.test(message)) { scores.ideate += 3; signals.push('ideate-word'); }
+  if (MODE_EXPLORE_WORDS.test(message)) { scores.explore += 3; signals.push('explore-word'); }
+  if (MODE_DISCUSS_WORDS.test(message)) { scores.discuss += 4; signals.push('discuss-word'); }
+
+  // ── Specificity signal (file paths, code references) ──
+  const specificityMatches = message.match(MODE_WORK_SIGNALS);
+  if (specificityMatches) {
+    scores.work += 2;
+    signals.push('has-specifics');
+    // Specifics + imperative = work, not ideate
+    if (/\b(add|change|update|refactor|fix|remove|rename|move)\b/i.test(message)) {
+      scores.work += 2;
+      signals.push('specific-action');
+    }
+  }
+
+  // ── Punctuation signal (only meaningful in longer messages) ──
+  const questionMarks = (message.match(/\?/g) || []).length;
+  if (questionMarks >= 2) { scores.discuss += 2; scores.explore += 1; signals.push('multi-question'); }
+  else if (questionMarks === 1 && len > 5) { scores.explore += 1; scores.discuss += 1; }
+
+  if (/\.{3}|—|–/.test(message)) { scores.ideate += 1; signals.push('ellipsis-dash'); }
+  if (/\b(maybe|might|could|perhaps|wonder)\b/i.test(message)) { scores.ideate += 1; scores.discuss += 1; signals.push('hedging'); }
+
+  // ── Contextual signals ──
+  // If prior turn was a plan/proposal and this is short, likely execute
+  if (context._priorWasProposal && len <= 15) { scores.execute += 2; signals.push('post-proposal-short'); }
+
+  // First message in session tends to be higher-level
+  if (context._isFirstTurn) { scores.explore += 1; scores.discuss += 1; }
+
+  // ── Anti-signals (prevent false positives) ──
+  // "go on" = continue explaining, not execute. But bare "continue?" = proceed
+  if (/^go on\b|^keep going/i.test(message.trim())) {
+    scores.execute -= 3;
+    scores.discuss += 2;
+  }
+  // "actually wait" / "hold on" = pumping the brakes, shifting to discuss
+  if (/^(actually|wait|hold on|hang on)/i.test(message.trim()) && questionMarks > 0) {
+    scores.execute -= 2;
+    scores.discuss += 3;
+    signals.push('pumping-brakes');
+  }
+  // "what if X breaks" = work concern, not ideation
+  if (/what if.*(break|fail|crash|error)/i.test(message)) {
+    scores.ideate -= 2;
+    scores.work += 2;
+  }
+  // "could we refactor" with file = work, not ideate
+  if (/could we.*(refactor|change|update)/i.test(message) && specificityMatches) {
+    scores.ideate -= 2;
+    scores.work += 2;
+  }
+
+  // ── Resolve: pick dominant mode, bias toward action when uncertain ──
+  // Floor all scores at 0
+  for (const k of Object.keys(scores)) { if (scores[k] < 0) scores[k] = 0; }
+
+  const total = Object.values(scores).reduce((a, b) => a + b, 0) || 1;
+  const sorted = Object.entries(scores).sort((a, b) => b[1] - a[1]);
+  const [primary, primaryScore] = sorted[0];
+  const confidence = primaryScore / total;
+
+  // If confidence is low (< 0.35), bias toward action — BUT only if discuss/ideate aren't strong
+  if (confidence < 0.35 && scores.execute > 0 && scores.discuss <= 1 && scores.ideate <= 1) {
+    return { primary: 'execute', confidence: 0.4, scores, signals: [...signals, 'low-confidence-action-bias'] };
+  }
+
+  return { primary, confidence, scores, signals };
+}
+
 function _inferTaskShape(message, context) {
   const lower = message.toLowerCase();
 

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));
-}