dual-brain 0.2.17 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.17",
+  "version": "0.2.18",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {

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/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();