dual-brain 3.8.1 → 3.9.0

package/README.md

@@ -63,7 +63,7 @@ npx -y dual-brain
 | `hooks/gpt-work-dispatcher.mjs` | Dispatch execution tasks to GPT via Codex CLI |
 | `hooks/session-report.mjs` | Session-end summary: activity, compliance, quality |
 | `hooks/health-check.mjs` | Verify all hooks and dependencies are working |
-| `hooks/test-orchestrator.mjs` | Self-test harness (29 tests) |
+| `hooks/test-orchestrator.mjs` | Self-test harness (39 tests) |
 | `hooks/setup-wizard.mjs` | Interactive config (optional — for custom plans) |
 | `hooks/install-git-hooks.mjs` | Git pre-commit hook for quality gate |
 

package/hooks/control-panel.mjs

@@ -437,16 +437,40 @@ function showProfilePicker(rl) {
 
     rl.question('  Choice: ', (answer) => {
       const names = Object.keys(PROFILES);
-      const idx = parseInt(answer, 10) - 1;
+      const trimmed = answer.trim();
+      let selectedName = null;
+
+      // Try numeric selection first
+      const idx = parseInt(trimmed, 10) - 1;
       if (idx >= 0 && idx < names.length) {
+        selectedName = names[idx];
+      }
+
+      // Try natural language alias resolution
+      if (!selectedName && trimmed && trimmed !== 'q') {
+        const PANEL_ALIASES = {
+          'auto': 'auto', 'adaptive': 'auto', 'smart': 'auto', 'default': 'auto', 'normal': 'auto',
+          'balanced': 'balanced', 'even': 'balanced', 'equal': 'balanced',
+          'cost-saver': 'cost-saver', 'cheap': 'cost-saver', 'save': 'cost-saver', 'conservative': 'cost-saver', 'frugal': 'cost-saver', 'budget': 'cost-saver',
+          'quality-first': 'quality-first', 'aggressive': 'quality-first', 'quality': 'quality-first', 'max': 'quality-first', 'full': 'quality-first', 'both': 'quality-first',
+        };
+        const cleaned = trimmed.toLowerCase()
+          .replace(/^(go|be|use|switch to|set|mode)\s+/i, '')
+          .replace(/\s+mode$/i, '');
+        selectedName = PANEL_ALIASES[cleaned] || null;
+      }
+
+      if (selectedName) {
         let customOverrides = null;
         try {
           const existing = JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
           if (existing.custom_overrides?.budgets) customOverrides = { budgets: existing.custom_overrides.budgets };
         } catch {}
-        saveProfile(names[idx], customOverrides);
-        const pf = PROFILES[names[idx]];
+        saveProfile(selectedName, customOverrides);
+        const pf = PROFILES[selectedName];
         console.log(`  ✅ Switched to ${pf.emoji}  ${pf.uiLabel}`);
+      } else if (trimmed && trimmed !== 'q') {
+        console.log(`  Unknown profile: ${trimmed}. Try: cheap, aggressive, quality, balanced, auto`);
       }
       resolve();
     });

package/hooks/cost-logger.mjs

@@ -8,7 +8,6 @@
  * Output contract: must print "{}" to stdout and exit 0 within ~100 ms.
  */
 
-import { createHash } from "crypto";
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
@@ -265,8 +264,8 @@ async function main() {
   // Record failures for adaptive routing (failure-loop detection)
   if (status === 'error' && toolName === 'Agent') {
     try {
-      const { recordFailure, pruneOldFailures } = await import('./failure-detector.mjs');
-      const promptHash = createHash('md5').update(JSON.stringify(toolInput)).digest('hex').slice(0, 12);
+      const { computePromptHash, recordFailure, pruneOldFailures } = await import('./failure-detector.mjs');
+      const promptHash = computePromptHash(toolInput);
       recordFailure(promptHash, tier, payload?.error || 'agent_error');
       // Best-effort cleanup of stale failure entries (>24h old)
       try { pruneOldFailures(); } catch {}

package/hooks/enforce-tier.mjs

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
 import { readFileSync, writeFileSync, appendFileSync, renameSync } from 'fs';
-import { createHash } from 'crypto';
 import { dirname, resolve, join } from 'path';
 import { fileURLToPath } from 'url';
 import { classifyRisk, extractPaths } from './risk-classifier.mjs';
-import { checkFailureLoop, recordFailure } from './failure-detector.mjs';
+import { computePromptHash, checkFailureLoop, recordFailure } from './failure-detector.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CONFIG_FILE = resolve(__dirname, '..', 'orchestrator.json');
@@ -214,7 +213,7 @@ try {
   const currentModel = (ti.model || '').toLowerCase();
 
   // Compute prompt hash early for duplicate detection and logging
-  const promptHash = createHash('sha256').update(text).digest('hex').slice(0, 12);
+  const promptHash = computePromptHash(ti);
 
   // Burst detection — suppress noise during wave launches (3+ agents in 90s)
   const burstMode = detectBurst();
@@ -316,7 +315,7 @@ try {
   }
 
   // Failure loop detection
-  const failureCheck = checkFailureLoop(promptHash, tier);
+  const failureCheck = checkFailureLoop(promptHash);
   let failureMessage = null;
   if (failureCheck.isLoop) {
     if (failureCheck.suggestion === 'promote_tier' && tier === 'execute') {

package/hooks/failure-detector.mjs

@@ -8,6 +8,7 @@
  *   pruneOldFailures() → { pruned, remaining }
  */
 
+import { createHash } from 'crypto';
 import { readFileSync, appendFileSync, writeFileSync, renameSync, unlinkSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
@@ -16,6 +17,19 @@ import { fileURLToPath } from 'url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const LEDGER_FILE = join(__dirname, 'decision-ledger.jsonl');
 
+/**
+ * Canonical prompt hash used by all hooks for failure-loop correlation.
+ * Both enforce-tier (PreToolUse) and cost-logger (PostToolUse) must use this
+ * same function so that recorded failures can be matched during escalation.
+ *
+ * @param {object} toolInput — the raw tool_input from the hook payload
+ * @returns {string} 12-char hex hash
+ */
+function computePromptHash(toolInput) {
+  const text = (toolInput?.description || '') + (toolInput?.prompt || '');
+  return createHash('sha256').update(text).digest('hex').slice(0, 12);
+}
+
 /**
  * Compute a decay weight based on failure age.
  * 0-30 min → 1.0, 30-60 min → 0.5, 60-120 min → 0.25, >120 min → 0 (excluded by window)
@@ -121,4 +135,4 @@ function pruneOldFailures() {
   return { pruned, remaining };
 }
 
-export { checkFailureLoop, recordFailure, pruneOldFailures };
+export { computePromptHash, checkFailureLoop, recordFailure, pruneOldFailures };

package/hooks/profiles.mjs

@@ -20,6 +20,25 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const PROFILE_FILE = join(__dirname, '..', 'dual-brain.profile.json');
 const CONFIG_FILE = join(__dirname, '..', 'orchestrator.json');
 
+const ALIASES = {
+  // auto
+  'auto': 'auto', 'adaptive': 'auto', 'smart': 'auto', 'default': 'auto', 'normal': 'auto',
+  // balanced
+  'balanced': 'balanced', 'even': 'balanced', 'equal': 'balanced',
+  // cost-saver
+  'cost-saver': 'cost-saver', 'cheap': 'cost-saver', 'save': 'cost-saver', 'conservative': 'cost-saver', 'frugal': 'cost-saver', 'budget': 'cost-saver',
+  // quality-first
+  'quality-first': 'quality-first', 'aggressive': 'quality-first', 'quality': 'quality-first', 'max': 'quality-first', 'full': 'quality-first', 'both': 'quality-first',
+};
+
+function resolveProfileName(input) {
+  if (!input) return null;
+  const cleaned = input.toLowerCase().trim()
+    .replace(/^(go|be|use|switch to|set|mode)\s+/i, '')
+    .replace(/\s+mode$/i, '');
+  return ALIASES[cleaned] || null;
+}
+
 const PROFILES = {
   auto: {
     description: 'Adapts routing based on task risk, provider health, and outcomes',
@@ -140,12 +159,22 @@ function getActiveProfile() {
 }
 
 function setActiveProfile(name, customOverrides = null) {
-  if (!PROFILES[name]) {
-    return { ok: false, error: `Unknown profile: ${name}. Available: ${Object.keys(PROFILES).join(', ')}` };
+  let resolved = name;
+  if (!PROFILES[resolved]) {
+    const alias = resolveProfileName(name);
+    if (alias) {
+      resolved = alias;
+    } else {
+      const aliasHint = Object.entries(ALIASES)
+        .filter(([k, v]) => k !== v)
+        .map(([k, v]) => `${k} → ${v}`)
+        .join(', ');
+      return { ok: false, error: `Unknown profile: ${name}. Available: ${Object.keys(PROFILES).join(', ')}. Aliases: ${aliasHint}` };
+    }
   }
 
   const data = {
-    active: name,
+    active: resolved,
     switched_at: new Date().toISOString(),
   };
   if (customOverrides) data.custom_overrides = customOverrides;
@@ -154,7 +183,7 @@ function setActiveProfile(name, customOverrides = null) {
     const tmp = PROFILE_FILE + '.tmp.' + process.pid;
     writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
     renameSync(tmp, PROFILE_FILE);
-    return { ok: true, profile: PROFILES[name] };
+    return { ok: true, profile: PROFILES[resolved], resolvedName: resolved };
   } catch (err) {
     return { ok: false, error: `Failed to write profile: ${err.message}` };
   }
@@ -216,6 +245,8 @@ function getProfileOverrides(system) {
 
 export {
   PROFILES,
+  ALIASES,
+  resolveProfileName,
   getActiveProfile,
   setActiveProfile,
   setBudgetOverrides,

package/hooks/test-orchestrator.mjs

@@ -1007,6 +1007,70 @@ test('failure decay: pruneOldFailures removes stale entries', () => {
   }
 });
 
+// ─── Test 40: adaptive loop end-to-end hash match ─────────────────────────
+test('adaptive loop: end-to-end hash match', () => {
+  const LEDGER = resolve(HOOKS, 'decision-ledger.jsonl');
+  const backup = existsSync(LEDGER) ? readFileSync(LEDGER, 'utf8') : null;
+
+  try {
+    // Start with a clean ledger so prior failures don't interfere
+    writeFileSync(LEDGER, '', 'utf8');
+
+    // Step 1: Define a specific Agent payload used consistently across all steps
+    const toolInput = { prompt: 'fix the auth bug', description: 'patch auth module' };
+    const agentPayload = JSON.stringify({ tool_name: 'Agent', tool_input: toolInput });
+
+    // Step 2: Run enforce-tier with this payload (computes and may log a promptHash)
+    const firstRun = run(ENFORCE_TIER, agentPayload);
+    if (firstRun.status !== 0) return `first enforce-tier run failed with status: ${firstRun.status}`;
+    if (!firstRun.parsed) return `first enforce-tier run produced no valid JSON`;
+
+    // Step 3: Simulate 2 failures via cost-logger with the SAME tool_input
+    const errorPayload = JSON.stringify({
+      tool_name: 'Agent',
+      tool_input: toolInput,
+      error: 'test failure',
+    });
+
+    const fail1 = runStream(COST_LOGGER, errorPayload);
+    if (fail1.status !== 0) return `first cost-logger failure run failed with status: ${fail1.status}`;
+
+    const fail2 = runStream(COST_LOGGER, errorPayload);
+    if (fail2.status !== 0) return `second cost-logger failure run failed with status: ${fail2.status}`;
+
+    // Verify cost-logger actually wrote failure entries to the ledger
+    if (!existsSync(LEDGER)) return 'ledger file not created after cost-logger failures';
+    const ledgerLines = readFileSync(LEDGER, 'utf8').split('\n').filter(Boolean);
+    const failureEntries = ledgerLines
+      .map(l => { try { return JSON.parse(l); } catch { return null; } })
+      .filter(e => e && e.type === 'failure' && e.success === false);
+    if (failureEntries.length < 2)
+      return `expected >= 2 failure entries in ledger, got: ${failureEntries.length}`;
+
+    // Step 4: Run enforce-tier again with the same Agent payload
+    const secondRun = run(ENFORCE_TIER, agentPayload);
+    if (secondRun.status !== 0) return `second enforce-tier run failed with status: ${secondRun.status}`;
+    if (!secondRun.parsed) return `second enforce-tier run produced no valid JSON`;
+
+    // Step 5: The second enforce-tier run should detect the failure loop
+    // and mention escalation or failure loop in its systemMessage
+    const msg = (secondRun.parsed.systemMessage || '').toLowerCase();
+    if (!msg.includes('failure') && !msg.includes('escalat') && !msg.includes('loop') && !msg.includes('dual-brain'))
+      return `expected failure loop / escalation in second enforce-tier systemMessage, got: "${secondRun.parsed.systemMessage || '(empty)'}"`;
+
+    // Bonus: verify the hashes match — the failure entries recorded by cost-logger
+    // should have the same prompt_hash that enforce-tier uses for checkFailureLoop
+    const failureHashes = [...new Set(failureEntries.map(e => e.prompt_hash))];
+    if (failureHashes.length !== 1)
+      return `expected all failure entries to share one hash, got ${failureHashes.length} distinct hashes: ${failureHashes.join(', ')}`;
+
+    return true;
+  } finally {
+    if (backup !== null) writeFileSync(LEDGER, backup, 'utf8');
+    else try { writeFileSync(LEDGER, '', 'utf8'); } catch {}
+  }
+});
+
 // ─── Summary ─────────────────────────────────────────────────────────────────
 const total = passed + failed;
 console.log(`\n${passed}/${total} tests passed`);

package/install.mjs

@@ -58,7 +58,8 @@ if (flag('--help') || flag('-h')) {
     --help       Show this help
 
   🎛️  Routing modes:
-    ⚖️  Default        Auto-routes, uses both providers evenly
+    🤖 Auto (default) Adapts routing based on risk, health, outcomes
+    ⚖️  Balanced       Auto-routes, uses both providers evenly
     🛡️  Conservative   Fewer GPT dispatches, sticks to Claude
     🚀 Aggressive     Maximizes both subscriptions, dual-brain for medium+
 
@@ -453,7 +454,7 @@ const PROFILES = {
 function loadProfile(workspace) {
   try {
     const data = JSON.parse(readFileSync(profilePath(workspace), 'utf8'));
-    const name = data.active && PROFILES[data.active] ? data.active : 'balanced';
+    const name = data.active && PROFILES[data.active] ? data.active : 'auto';
     const profile = PROFILES[name];
     const custom = data.custom_overrides || {};
     return {
@@ -464,7 +465,7 @@ function loadProfile(workspace) {
       switched_at: data.switched_at || null,
     };
   } catch {
-    return { name: 'balanced', ...PROFILES.balanced, switched_at: null };
+    return { name: 'auto', ...PROFILES.auto, switched_at: null };
   }
 }
 
@@ -497,8 +498,8 @@ function cmdMode() {
 
   if (!modeArg || modeArg === 'list') {
     const current = loadProfile(workspace);
-    const PEMOJIS = { balanced: '⚖️ ', 'cost-saver': '🛡️', 'quality-first': '🚀' };
-    const UI_NAMES = { balanced: 'Default', 'cost-saver': 'Conservative', 'quality-first': 'Aggressive' };
+    const PEMOJIS = { auto: '🤖', balanced: '⚖️ ', 'cost-saver': '🛡️', 'quality-first': '🚀' };
+    const UI_NAMES = { auto: 'Auto (default)', balanced: 'Balanced', 'cost-saver': 'Conservative', 'quality-first': 'Aggressive' };
     console.log('');
     console.log('  🎛️  Routing modes:');
     console.log('');
@@ -513,13 +514,28 @@ function cmdMode() {
     return;
   }
 
-  if (!PROFILES[modeArg]) {
-    console.error(`  Unknown profile: ${modeArg}`);
-    console.error(`  Available: ${Object.keys(PROFILES).join(', ')}`);
-    process.exit(1);
+  let resolvedMode = modeArg;
+  if (!PROFILES[resolvedMode]) {
+    // Try natural language alias resolution
+    const cleaned = resolvedMode.toLowerCase().trim()
+      .replace(/^(go|be|use|switch to|set|mode)\s+/i, '')
+      .replace(/\s+mode$/i, '');
+    const MODE_ALIASES = {
+      'auto': 'auto', 'adaptive': 'auto', 'smart': 'auto', 'default': 'auto', 'normal': 'auto',
+      'balanced': 'balanced', 'even': 'balanced', 'equal': 'balanced',
+      'cost-saver': 'cost-saver', 'cheap': 'cost-saver', 'save': 'cost-saver', 'conservative': 'cost-saver', 'frugal': 'cost-saver', 'budget': 'cost-saver',
+      'quality-first': 'quality-first', 'aggressive': 'quality-first', 'quality': 'quality-first', 'max': 'quality-first', 'full': 'quality-first', 'both': 'quality-first',
+    };
+    resolvedMode = MODE_ALIASES[cleaned] || null;
+    if (!resolvedMode) {
+      console.error(`  Unknown profile: ${modeArg}`);
+      console.error(`  Available: ${Object.keys(PROFILES).join(', ')}`);
+      console.error(`  Aliases: cheap, aggressive, quality, budget, frugal, smart, adaptive, ...`);
+      process.exit(1);
+    }
   }
 
-  const profile = PROFILES[modeArg];
+  const profile = PROFILES[resolvedMode];
 
   let customOverrides = null;
   try {
@@ -529,12 +545,12 @@ function cmdMode() {
     }
   } catch {}
 
-  saveProfile(workspace, modeArg, customOverrides);
+  saveProfile(workspace, resolvedMode, customOverrides);
 
-  const PEMOJIS = { balanced: '⚖️ ', 'cost-saver': '🛡️', 'quality-first': '🚀' };
-  const UI_NAMES = { balanced: 'Default', 'cost-saver': 'Conservative', 'quality-first': 'Aggressive' };
+  const PEMOJIS = { auto: '🤖', balanced: '⚖️ ', 'cost-saver': '🛡️', 'quality-first': '🚀' };
+  const UI_NAMES = { auto: 'Auto (default)', balanced: 'Balanced', 'cost-saver': 'Conservative', 'quality-first': 'Aggressive' };
   console.log('');
-  console.log(`  ✅ Mode switched: ${PEMOJIS[modeArg] || ''} ${UI_NAMES[modeArg] || modeArg}`);
+  console.log(`  ✅ Mode switched: ${PEMOJIS[resolvedMode] || ''} ${UI_NAMES[resolvedMode] || resolvedMode}`);
   console.log(`  ${profile.description}`);
   console.log('');
   console.log('  🧭 Routing changes:');
@@ -586,7 +602,7 @@ function cmdBudget() {
   };
 
   const data = {
-    active: existing.active || 'balanced',
+    active: existing.active || 'auto',
     switched_at: existing.switched_at || new Date().toISOString(),
     custom_overrides: customOverrides,
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "3.8.1",
+  "version": "3.9.0",
   "description": "Dual-provider orchestration for Claude Code — tiered routing, budget balancing, and GPT dual-brain review across Claude + OpenAI subscriptions",
   "type": "module",
   "bin": {