dual-brain 0.2.14 → 0.2.16

package/bin/dual-brain.mjs

@@ -95,6 +95,18 @@ async function getLivingDocs() {
   return _livingDocs;
 }
 
+let _cognitiveLoopCache = null;
+async function _getCognitiveLoop() {
+  if (!_cognitiveLoopCache) {
+    try {
+      _cognitiveLoopCache = await import('../src/cognitive-loop.mjs');
+    } catch {
+      _cognitiveLoopCache = null;
+    }
+  }
+  return _cognitiveLoopCache;
+}
+
 let _fx = null;
 async function getFx() {
   if (_fx !== null) return _fx;
@@ -492,6 +504,54 @@ async function cmdGo(args, opts = {}) {
     } catch { /* non-fatal */ }
   }
 
+  // ── 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;
+        // Use the full envelope prompt (includes context, preventions, debrief)
+        const firstAgent = loopResult.nextDispatch.agents?.[0];
+        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 {
+    // Cognitive loop unavailable or errored — proceed with original prompt
+  }
+
   // ── Dispatch visualization ─────────────────────────────────────────────────
   const fxGo = await getFx();
   let dispatchSpinner = null;
@@ -499,7 +559,7 @@ async function cmdGo(args, opts = {}) {
     dispatchSpinner = fxGo.spinner(`Dispatching agent...`).start();
   }
 
-  const { plan, result } = await runPipeline('go', prompt, {
+  const { plan, result } = await runPipeline('go', loopEnhancedPrompt, {
     files,
     cwd,
     verbose,
@@ -511,6 +571,23 @@ async function cmdGo(args, opts = {}) {
     dispatchSpinner.succeed(`Agent dispatched: ${prompt.slice(0, 50)}`);
   }
 
+  // ── Cognitive loop: advance after dispatch completes ─────────────────────────
+  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 });
+        if (verbose && advanceResult) {
+          console.log(`  [cognitive-loop] Next phase: ${advanceResult.phase}, rationale: ${advanceResult.rationale || '-'}`);
+        }
+      }
+    } catch {
+      // Non-fatal — loop advance failure doesn't affect the completed dispatch
+    }
+  }
+
   if (dryRun) {
     // formatExecutionPlan already printed by pipeline when verbose/dryRun=true
     console.log('\n(dry-run — not executing)');
@@ -2149,6 +2226,48 @@ function classifyInput(input) {
   }
 
   // ── HEAD cognitive pipeline: replaces regex-based cheap/full split ──────
+  // Try cognitive loop first (wraps HEAD with wave planning + predictions)
+  if (_cognitiveLoopCache) {
+    try {
+      const loopResult = _cognitiveLoopCache.enter(trimmed, {});
+
+      const judgment = {
+        depth: loopResult.action?.depth || 'full',
+        action: loopResult.action,
+        shouldAskUser: loopResult.shouldAskUser,
+        shouldDispatch: loopResult.phase === 'dispatch',
+        shouldClarify: loopResult.action?.type === 'clarify',
+        shouldThink: loopResult.action?.type === 'think',
+        rationale: loopResult.rationale,
+        confidence: loopResult.action?.confidence,
+        obligations: loopResult.action?.obligations,
+        surfaceNoticings: loopResult.surfaceNoticings,
+        // Cognitive loop extensions
+        _loopResult: loopResult,
+        _plan: loopResult.plan,
+        _nextDispatch: loopResult.nextDispatch,
+      };
+
+      // Loop says respond — no dispatch needed
+      if (loopResult.phase === 'respond') {
+        return { tier: 'cheap', headJudgment: judgment };
+      }
+
+      // Loop says dispatch — full tier, use plan's first agent tier to pick model
+      if (loopResult.phase === 'dispatch') {
+        const firstAgent = loopResult.nextDispatch?.agents?.[0];
+        const model = firstAgent?.tier === 'deep' || firstAgent?.tier === 'opus' ? 'opus' : 'sonnet';
+        return { tier: 'full', headJudgment: judgment, model };
+      }
+
+      // Default: cheap
+      return { tier: 'cheap', headJudgment: judgment };
+    } catch {
+      // Cognitive loop failed — fall through to direct HEAD
+    }
+  }
+
+  // Direct HEAD fallback (when cognitive loop unavailable or errored)
   const head = _headModuleCache;
   if (head) {
     const state = _getHeadState() || head.freshState();
@@ -2722,6 +2841,19 @@ async function mainScreen(rl, ask) {
     return signalLine(item.ok ? 'success' : 'warning', `${DIM}${item.text}${RST}`);
   });
 
+  // ── Cognitive loop status (appended to signals) ────────────────────────────
+  try {
+    const cogLoop = await _getCognitiveLoop();
+    if (cogLoop) {
+      const loopStatus = cogLoop.getLoopStatus();
+      if (loopStatus.hasActivePlan) {
+        const wavePart = `${loopStatus.completedWaves}/${loopStatus.totalWaves} waves`;
+        const replanPart = loopStatus.replans > 0 ? ` · ${loopStatus.replans} replan${loopStatus.replans !== 1 ? 's' : ''}` : '';
+        recentLines.push(signalLine('info', `${DIM}[loop] ${wavePart}${replanPart}${RST}`));
+      }
+    }
+  } catch { /* non-fatal */ }
+
   // ── Resolve dashboard spinner before rendering ────────────────────────────
   if (_spinnerTimeout) clearTimeout(_spinnerTimeout);
   if (dashSpinner) dashSpinner.succeed('Dashboard ready');
@@ -3064,6 +3196,18 @@ async function mainScreen(rl, ask) {
         process.stdout.write('\n');
       }
 
+      // Show cognitive loop plan info if available
+      if (hj?._plan) {
+        const plan = hj._plan;
+        const waveCount = plan.waves?.length || 0;
+        const agentCount = plan.waves?.reduce((sum, w) => sum + (w.agents?.length || 0), 0) || 0;
+        process.stdout.write(`\n  \x1b[2m[plan] ${waveCount} wave${waveCount !== 1 ? 's' : ''}, ${agentCount} agent${agentCount !== 1 ? 's' : ''}\x1b[0m`);
+        if (hj._nextDispatch?.warnings?.length > 0) {
+          process.stdout.write(`  \x1b[33m${hj._nextDispatch.warnings.length} warning(s)\x1b[0m`);
+        }
+        process.stdout.write('\n');
+      }
+
       // HEAD's shouldAskUser gates the dispatch — dangerous/irreversible ops
       if (hj?.shouldAskUser) {
         const reason = hj.obligations?.find(o => o.type === 'askBeforeIrreversi')?.description || hj.rationale;
@@ -3073,14 +3217,14 @@ async function mainScreen(rl, ask) {
         process.stdout.write(`  \x1b[36mEnter\x1b[0m proceed  \x1b[36mn\x1b[0m cancel\n\n`);
         const confirm = (await ask('  > ')).trim().toLowerCase();
         if (confirm === 'n' || confirm === 'no') return { next: 'main' };
-        return { next: 'go', prompt: input, model };
+        return { next: 'go', prompt: input, model, _loopResult: hj._loopResult };
       }
 
       // Automode: if HEAD says it's safe, just go — no confirmation needed
       const automode = profile.automode ?? profile.settings?.automode ?? false;
       if (automode) {
         process.stdout.write(`\n  \x1b[36m⚡\x1b[0m ${summary}  (${model}, depth: ${hj?.depth || '?'})\n`);
-        return { next: 'go', prompt: input, model };
+        return { next: 'go', prompt: input, model, _loopResult: hj._loopResult };
       }
 
       // Manual mode — show depth, wait for confirmation
@@ -3089,7 +3233,7 @@ async function mainScreen(rl, ask) {
       process.stdout.write(`  \x1b[36mEnter\x1b[0m go  \x1b[36mn\x1b[0m cancel\n\n`);
       const confirm = (await ask('  > ')).trim().toLowerCase();
       if (confirm === 'n' || confirm === 'no') return { next: 'main' };
-      return { next: 'go', prompt: input, model };
+      return { next: 'go', prompt: input, model, _loopResult: hj._loopResult };
     }
 
     // Default fallback
@@ -6202,6 +6346,7 @@ async function main() {
   primeAgentRegistry().catch(() => {});
   _primeRegistryCache().catch(() => {});
   _getHeadModule().catch(() => {});
+  _getCognitiveLoop().catch(() => {});
 
   const args = process.argv.slice(2);
   const cmd  = args[0];

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