dual-brain 0.2.15 → 0.2.16

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 {

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.16",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {

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

@@ -32,13 +32,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 +48,7 @@ export function generateHandoff(sessionState) {
     },
     preferences: sessionState.activePreferences || [],
     resumeHint: sessionState.resumeHint || null,
+    narrative: sessionState.narrative || null,
   };
 }