dual-brain 0.2.6 → 0.2.8

package/src/dispatch.mjs

@@ -527,6 +527,60 @@ function getRetryBudget() {
   };
 }
 
+// ─── Preflight auth check ─────────────────────────────────────────────────────
+
+/**
+ * Verify a provider CLI is present and (optionally) responds to --version.
+ * Uses `which` for the fast path and a 3s-capped --version call to confirm.
+ *
+ * @param {'claude'|'openai'} provider
+ * @param {string} [cwd]  Working directory (unused, kept for signature parity)
+ * @returns {Promise<{ ready: boolean, provider: string, error?: string, suggestion?: string }>}
+ */
+async function preflightAuth(provider, _cwd) {
+  const bin = provider === 'openai' ? 'codex' : 'claude';
+
+  // Fast path: check binary existence with `which`
+  const whichResult = await new Promise((resolve) => {
+    const p = spawn('which', [bin], { stdio: 'pipe' });
+    p.on('error', () => resolve(false));
+    p.on('close', (code) => resolve(code === 0));
+    setTimeout(() => { try { p.kill(); } catch {} resolve(false); }, 2000);
+  });
+
+  if (!whichResult) {
+    const installHint = provider === 'openai'
+      ? 'Install: npm install -g @openai/codex'
+      : 'Install: npm install -g @anthropic-ai/claude-code';
+    return {
+      ready:      false,
+      provider,
+      error:      `${bin} CLI not found in PATH`,
+      suggestion: installHint,
+    };
+  }
+
+  // Version check: confirms the binary actually runs (catches broken installs)
+  const versionOk = await new Promise((resolve) => {
+    const p = spawn(bin, ['--version'], { stdio: 'pipe' });
+    p.on('error', () => resolve(false));
+    p.on('close', (code) => resolve(code === 0));
+    setTimeout(() => { try { p.kill(); } catch {} resolve(false); }, 3000);
+  });
+
+  if (!versionOk) {
+    const loginHint = provider === 'openai' ? 'Run: codex login' : 'Run: claude login';
+    return {
+      ready:      false,
+      provider,
+      error:      `${bin} --version failed (auth may have expired)`,
+      suggestion: loginHint,
+    };
+  }
+
+  return { ready: true, provider };
+}
+
 // ─── Command builder ──────────────────────────────────────────────────────────
 
 function buildCommand(decision, prompt, files = [], _cwd) {
@@ -840,6 +894,34 @@ async function dispatch(input = {}) {
     }
   }
 
+  // ── Preflight auth check ─────────────────────────────────────────────────
+  // Verify the target provider CLI is present and responsive before dispatching.
+  // Runs after model/provider resolution so we check the effective provider.
+  const preflight = await preflightAuth(effectiveProvider, cwd);
+  if (!preflight.ready) {
+    // Check if the other provider is available as a fallback
+    const otherProvider = effectiveProvider === 'claude' ? 'openai' : 'claude';
+    const otherPreflight = await preflightAuth(otherProvider, cwd);
+    const fallbackNote = otherPreflight.ready
+      ? ` Fallback available: ${otherProvider}.`
+      : '';
+    const errMsg = `${preflight.error}. ${preflight.suggestion}${fallbackNote}`;
+    return {
+      status:        'error',
+      provider:      effectiveProvider,
+      model:         effectiveModel,
+      command:       null,
+      exitCode:      null,
+      summary:       errMsg,
+      durationMs:    0,
+      usage:         null,
+      error:         errMsg,
+      authVerified:  false,
+      suggestion:    preflight.suggestion,
+    };
+  }
+  // ── End preflight auth check ─────────────────────────────────────────────
+
   // ── Feature 2: Dirty-worktree guard for execute-tier dispatches ──────────
   if (tier === 'execute' && decision.owns && !decision._force) {
     const wtCheck = await checkWorktreeClean(decision.owns, cwd);
@@ -902,6 +984,7 @@ async function dispatch(input = {}) {
         durationMs:    0,
         usage:         null,
         error:         null,
+        authVerified:  true,
       };
     }
 
@@ -1014,6 +1097,7 @@ async function dispatch(input = {}) {
       usage,
       worktreeUsed:  useWorktree,
       autoReview,
+      authVerified:  true,
       error: success ? null : errorText.slice(0, 200),
     };
   }
@@ -1021,7 +1105,7 @@ async function dispatch(input = {}) {
   const command = buildCommand(effectiveDecision, prompt, files, cwd);
 
   if (dryRun) {
-    return { status: 'dry-run', provider: effectiveProvider, model: effectiveModel, specialist: specialist ?? 'generic', command, exitCode: null, summary: null, durationMs: 0, usage: null, error: null };
+    return { status: 'dry-run', provider: effectiveProvider, model: effectiveModel, specialist: specialist ?? 'generic', command, exitCode: null, summary: null, durationMs: 0, usage: null, error: null, authVerified: true };
   }
 
   // Record this dispatch against the budget
@@ -1130,6 +1214,7 @@ async function dispatch(input = {}) {
     usage,
     worktreeUsed: useWorktree,
     autoReview,
+    authVerified: true,
     error: success ? null : errorText.slice(0, 200),
   };
 }
@@ -1221,4 +1306,4 @@ if (process.argv[1] && new URL(import.meta.url).pathname === process.argv[1]) {
   }
 }
 
-export { dispatch, buildCommand, detectRuntime, compressResult, dispatchDualBrain, validateDispatch, checkWorktreeClean, getRetryBudget, isInsideClaude, buildNativeDispatch, normalizeResult, loadSpecialistPrompt };
+export { dispatch, buildCommand, detectRuntime, compressResult, dispatchDualBrain, validateDispatch, checkWorktreeClean, getRetryBudget, isInsideClaude, buildNativeDispatch, normalizeResult, loadSpecialistPrompt, preflightAuth };

package/src/head.mjs

@@ -0,0 +1,353 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const STATE_FILE = join(process.cwd(), '.dualbrain', 'head-state.json');
+
+// ── Conversation phases ──────────────────────────────────────────────────────
+const PHASES = ['clarify', 'discuss', 'plan', 'dispatch', 'review', 'close'];
+
+const VALID_TRANSITIONS = {
+  clarify:  ['discuss', 'plan', 'close'],
+  discuss:  ['plan', 'dispatch', 'clarify', 'close'],
+  plan:     ['dispatch', 'discuss', 'close'],
+  dispatch: ['review', 'dispatch', 'close'],
+  review:   ['dispatch', 'discuss', 'close'],
+  close:    ['clarify'],
+};
+
+// ── Intent classification ────────────────────────────────────────────────────
+const INTENT_PATTERNS = {
+  information: [
+    /\b(what|where|which|how many|show me|list|find|search|grep|explain)\b/i,
+    /\?$/,
+  ],
+  discussion: [
+    /\b(should we|what do you think|thoughts on|opinion|brainstorm|consider|tradeoff|approach)\b/i,
+    /\b(idea|strategy|philosophy|design|architecture)\b/i,
+  ],
+  action: [
+    /\b(build|create|fix|implement|add|remove|update|refactor|deploy|publish|ship|go|do it)\b/i,
+    /\b(parallel agents|dispatch|bump|install)\b/i,
+  ],
+  approval: [
+    /^(yes|y|ok|sure|do it|go|approved|lgtm|ship it)\s*$/i,
+    /\b(go ahead|sounds good|let's do it|proceed)\b/i,
+  ],
+  correction: [
+    /\b(no|stop|wait|hold|wrong|not that|don't|shouldn't|instead)\b/i,
+    /\b(actually|but|however)\b/i,
+  ],
+};
+
+/**
+ * Classify user intent from their message.
+ * Returns { intent, confidence, signals }
+ */
+export function classifyIntent(message) {
+  const scores = { information: 0, discussion: 0, action: 0, approval: 0, correction: 0 };
+  const signals = [];
+
+  for (const [intent, patterns] of Object.entries(INTENT_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (pattern.test(message)) {
+        scores[intent] += 1;
+        signals.push({ intent, pattern: pattern.source });
+      }
+    }
+  }
+
+  // Short messages that are just "yes"/"go" are almost always approval
+  if (message.trim().split(/\s+/).length <= 3) {
+    scores.approval += 1;
+  }
+
+  // Find highest scoring intent
+  const sorted = Object.entries(scores).sort((a, b) => b[1] - a[1]);
+  const top = sorted[0];
+  const second = sorted[1];
+
+  // Confidence based on margin between top two
+  const margin = top[1] - second[1];
+  const confidence = top[1] === 0 ? 0.3 : margin >= 2 ? 0.95 : margin >= 1 ? 0.8 : 0.6;
+
+  return {
+    intent: top[1] > 0 ? top[0] : 'unknown',
+    confidence,
+    scores,
+    signals,
+    ambiguous: confidence < 0.7,
+  };
+}
+
+// ── Conversation state ───────────────────────────────────────────────────────
+
+/**
+ * Load current HEAD state from disk.
+ */
+export function loadState() {
+  try {
+    if (existsSync(STATE_FILE)) {
+      const data = JSON.parse(readFileSync(STATE_FILE, 'utf8'));
+      // Reset stale sessions (>30 min gap)
+      if (Date.now() - (data.lastActivity || 0) > 30 * 60 * 1000) {
+        return freshState();
+      }
+      return data;
+    }
+  } catch {}
+  return freshState();
+}
+
+function freshState() {
+  return {
+    sessionId: Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
+    phase: 'clarify',
+    intent: 'unknown',
+    confidence: 0,
+    userGoal: null,
+    activeTasks: [],
+    decisions: [],
+    contextEstimate: { messages: 0, estimatedTokens: 0, compactionRisk: 'low' },
+    driftSignals: [],
+    lastActivity: Date.now(),
+    created: Date.now(),
+  };
+}
+
+/**
+ * Save HEAD state to disk.
+ */
+export function saveState(state) {
+  state.lastActivity = Date.now();
+  mkdirSync(join(process.cwd(), '.dualbrain'), { recursive: true });
+  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+// ── Phase transitions ────────────────────────────────────────────────────────
+
+/**
+ * Attempt a phase transition. Returns { allowed, from, to, reason? }
+ */
+export function transition(state, targetPhase) {
+  const from = state.phase;
+  const allowed = VALID_TRANSITIONS[from]?.includes(targetPhase) || false;
+
+  if (allowed) {
+    state.phase = targetPhase;
+    state.decisions.push({
+      type: 'phase-transition',
+      from,
+      to: targetPhase,
+      timestamp: Date.now(),
+    });
+  }
+
+  return {
+    allowed,
+    from,
+    to: targetPhase,
+    reason: allowed ? null : `Cannot transition from ${from} to ${targetPhase}. Valid: ${(VALID_TRANSITIONS[from] || []).join(', ')}`,
+  };
+}
+
+/**
+ * Suggest the appropriate phase based on intent and current state.
+ */
+export function suggestPhase(state, intent) {
+  const map = {
+    information: state.phase === 'clarify' ? 'clarify' : 'discuss',
+    discussion: 'discuss',
+    action: state.phase === 'discuss' || state.phase === 'plan' ? 'dispatch' : 'plan',
+    approval: state.phase === 'plan' ? 'dispatch' : state.phase,
+    correction: state.phase === 'dispatch' ? 'review' : 'clarify',
+    unknown: 'clarify',
+  };
+  return map[intent] || 'clarify';
+}
+
+// ── Confidence tracker ───────────────────────────────────────────────────────
+
+/**
+ * Run the 4-question confidence check before dispatching.
+ * Returns { ready, score, checks }
+ */
+export function checkConfidence(state) {
+  const checks = {
+    understandIntent: {
+      pass: !!(state.userGoal && state.intent !== 'unknown'),
+      question: 'Do I understand the user\'s intent?',
+    },
+    discussedApproach: {
+      pass: state.decisions.some(d => d.type === 'phase-transition' && d.to === 'discuss') || state.phase === 'plan',
+      question: 'Have we discussed the approach?',
+    },
+    honestAboutUnknowns: {
+      pass: state.driftSignals.length === 0 || state.driftSignals.every(s => s.resolved),
+      question: 'Am I honest about unknowns?',
+    },
+    reversible: {
+      pass: true, // default; caller should override for high-risk
+      question: 'Is this reversible?',
+    },
+  };
+
+  const passing = Object.values(checks).filter(c => c.pass).length;
+  const total = Object.values(checks).length;
+
+  return {
+    ready: passing === total,
+    score: passing / total,
+    passing,
+    total,
+    checks,
+  };
+}
+
+// ── Drift detection ──────────────────────────────────────────────────────────
+
+/**
+ * Check if HEAD's current action is consistent with its declared phase.
+ */
+export function detectDrift(state, action) {
+  const signals = [];
+
+  // Acting while in discuss phase
+  if (state.phase === 'clarify' && action.type === 'dispatch') {
+    signals.push({ signal: 'dispatch-before-discuss', severity: 'high', msg: 'Dispatching work before discussing approach' });
+  }
+
+  // Dispatching without acceptance criteria
+  if (action.type === 'dispatch' && (!action.task?.acceptanceCriteria || action.task.acceptanceCriteria.length === 0)) {
+    signals.push({ signal: 'no-acceptance-criteria', severity: 'medium', msg: 'Dispatch without acceptance criteria' });
+  }
+
+  // HEAD doing implementation work
+  if (['edit', 'write', 'bash-impl'].includes(action.type)) {
+    signals.push({ signal: 'head-implementing', severity: 'critical', msg: 'HEAD attempting direct implementation' });
+  }
+
+  // Repeated dispatch failures
+  const recentFailures = (state.activeTasks || []).filter(t => t.status === 'failed' && Date.now() - t.endedAt < 300000);
+  if (recentFailures.length >= 2) {
+    signals.push({ signal: 'repeated-failures', severity: 'high', msg: `${recentFailures.length} recent dispatch failures — consider changing approach` });
+  }
+
+  // Context getting large
+  if (state.contextEstimate.estimatedTokens > 150000) {
+    signals.push({ signal: 'context-pressure', severity: 'medium', msg: 'Context estimate exceeding 150k tokens — compaction risk' });
+  }
+
+  if (signals.length > 0) {
+    state.driftSignals.push(...signals.map(s => ({ ...s, timestamp: Date.now(), resolved: false })));
+  }
+
+  return signals;
+}
+
+// ── Context budget ───────────────────────────────────────────────────────────
+
+/**
+ * Update context estimate. Called after each turn.
+ */
+export function updateContextEstimate(state, opts = {}) {
+  const { messageCount, lastResponseTokens } = opts;
+
+  if (messageCount) state.contextEstimate.messages = messageCount;
+  if (lastResponseTokens) state.contextEstimate.estimatedTokens += lastResponseTokens;
+
+  // Rough compaction risk
+  const tokens = state.contextEstimate.estimatedTokens;
+  state.contextEstimate.compactionRisk =
+    tokens > 180000 ? 'critical' :
+    tokens > 120000 ? 'high' :
+    tokens > 80000 ? 'medium' : 'low';
+
+  return state.contextEstimate;
+}
+
+// ── Task tracking ────────────────────────────────────────────────────────────
+
+/**
+ * Register a dispatched task.
+ */
+export function trackTask(state, task) {
+  state.activeTasks.push({
+    id: task.id || Date.now().toString(36),
+    objective: task.objective,
+    tier: task.tier,
+    provider: task.provider,
+    status: 'dispatched',
+    startedAt: Date.now(),
+    endedAt: null,
+    result: null,
+  });
+  return state;
+}
+
+/**
+ * Update a task's status.
+ */
+export function completeTask(state, taskId, result) {
+  const task = state.activeTasks.find(t => t.id === taskId);
+  if (task) {
+    task.status = result.success ? 'completed' : 'failed';
+    task.endedAt = Date.now();
+    task.result = result;
+  }
+  return state;
+}
+
+// ── Decision logging ─────────────────────────────────────────────────────────
+
+/**
+ * Log a HEAD decision.
+ */
+export function logDecision(state, decision) {
+  state.decisions.push({
+    ...decision,
+    timestamp: Date.now(),
+  });
+  return state;
+}
+
+// ── Convenience: process a user message ──────────────────────────────────────
+
+/**
+ * Full turn processor: classify intent, suggest phase, detect drift, update state.
+ * Returns guidance for HEAD on what to do next.
+ */
+export function processTurn(state, userMessage) {
+  const intent = classifyIntent(userMessage);
+  const suggestedPhase = suggestPhase(state, intent.intent);
+
+  state.intent = intent.intent;
+  state.confidence = intent.confidence;
+
+  // Auto-transition if the suggested phase is valid
+  const transitionResult = suggestedPhase !== state.phase
+    ? transition(state, suggestedPhase)
+    : { allowed: true, from: state.phase, to: state.phase };
+
+  // Check confidence if we're about to dispatch
+  const confidenceCheck = suggestedPhase === 'dispatch' ? checkConfidence(state) : null;
+
+  // Build guidance
+  const guidance = {
+    intent,
+    phase: state.phase,
+    suggestedPhase,
+    transitioned: transitionResult.allowed && transitionResult.from !== transitionResult.to,
+    confidenceCheck,
+    shouldDispatch: suggestedPhase === 'dispatch' && (!confidenceCheck || confidenceCheck.ready),
+    shouldClarify: intent.ambiguous || intent.intent === 'unknown',
+    shouldDiscuss: intent.intent === 'discussion' || (suggestedPhase === 'dispatch' && confidenceCheck && !confidenceCheck.ready),
+  };
+
+  saveState(state);
+  return guidance;
+}
+
+// ── Exports summary ──────────────────────────────────────────────────────────
+// classifyIntent, loadState, saveState, freshState (via loadState),
+// transition, suggestPhase, checkConfidence, detectDrift,
+// updateContextEstimate, trackTask, completeTask, logDecision, processTurn

package/src/health.mjs

@@ -11,6 +11,7 @@
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
 
 // ─── Auth status (delegates to replit-tools when available) ──────────────────
 
@@ -370,3 +371,158 @@ export function remainingCooldownMinutes(provider, modelClass, cwd) {
   const remaining = cooldownMs - elapsedMs;
   return remaining > 0 ? Math.ceil(remaining / 60_000) : 0;
 }
+
+// ─── Hook health check ────────────────────────────────────────────────────────
+
+/**
+ * Extract the file path from a hook command string.
+ * Handles patterns like `node /path/to/hook.mjs` or `node /path/to/hook.mjs --flag`.
+ * Returns null if the pattern doesn't match.
+ * @param {string} command
+ * @returns {string|null}
+ */
+function extractHookPath(command) {
+  if (typeof command !== 'string') return null;
+  const match = command.match(/node\s+([^\s]+\.mjs)/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Collect all hook entries from a settings object, returning
+ * [{ command, eventType }] pairs.
+ * @param {object} settings
+ * @returns {{ command: string, eventType: string }[]}
+ */
+function collectHookCommands(settings) {
+  const entries = [];
+  const hooks = settings?.hooks ?? {};
+  for (const [eventType, matchers] of Object.entries(hooks)) {
+    if (!Array.isArray(matchers)) continue;
+    for (const matcher of matchers) {
+      for (const hook of (matcher?.hooks ?? [])) {
+        if (hook?.type === 'command' && typeof hook.command === 'string') {
+          entries.push({ command: hook.command, eventType });
+        }
+      }
+    }
+  }
+  return entries;
+}
+
+/**
+ * Load and parse a JSON settings file.  Returns {} on any error.
+ * @param {string} filePath
+ * @returns {object}
+ */
+function loadSettings(filePath) {
+  if (!existsSync(filePath)) return {};
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Check the health of all hook files referenced in project-local and global
+ * Claude Code settings.
+ *
+ * @param {string} [cwd] — project root (defaults to process.cwd())
+ * @returns {{
+ *   healthy: boolean,
+ *   hooks: Array<{ path: string, exists: boolean, syntaxValid: boolean, source: 'local'|'global', duplicate: boolean }>,
+ *   conflicts: string[],
+ *   degraded: string[],
+ *   missing: string[],
+ * }}
+ */
+export function checkHookHealth(cwd) {
+  const root = cwd ?? process.cwd();
+  const home = process.env.HOME || '/root';
+
+  const localSettingsPath  = join(root, '.claude', 'settings.local.json');
+  const globalSettingsPath = join(home, '.claude', 'settings.json');
+
+  const localSettings  = loadSettings(localSettingsPath);
+  const globalSettings = loadSettings(globalSettingsPath);
+
+  const localCommands  = collectHookCommands(localSettings);
+  const globalCommands = collectHookCommands(globalSettings);
+
+  // Build a set of hook paths from local settings for duplicate detection
+  const localPaths  = new Set(localCommands.map(e => extractHookPath(e.command)).filter(Boolean));
+  const globalPaths = new Set(globalCommands.map(e => extractHookPath(e.command)).filter(Boolean));
+
+  // Paths that appear in both local and global are conflicts
+  const conflictPaths = new Set([...localPaths].filter(p => globalPaths.has(p)));
+
+  const hookResults = [];
+  const conflicts = [];
+  const degraded  = [];
+  const missing   = [];
+
+  function processEntry(entry, source) {
+    const path = extractHookPath(entry.command);
+    if (!path) return; // non-node hook — skip
+
+    const fileExists = existsSync(path);
+    const isDuplicate = conflictPaths.has(path);
+
+    let syntaxValid = false;
+    if (fileExists) {
+      try {
+        const check = spawnSync('node', ['--check', path], {
+          timeout: 3000,
+          encoding: 'utf8',
+        });
+        syntaxValid = check.status === 0;
+      } catch {
+        syntaxValid = false;
+      }
+    }
+
+    const record = { path, exists: fileExists, syntaxValid, source, duplicate: isDuplicate };
+    hookResults.push(record);
+
+    if (!fileExists) {
+      missing.push(`${source}: ${path} (file not found)`);
+    } else if (!syntaxValid) {
+      degraded.push(`${source}: ${path} (syntax error)`);
+    }
+
+    if (isDuplicate && source === 'global') {
+      // Only report the conflict once (when we encounter it from the global side)
+      conflicts.push(`Hook defined in both local and global settings: ${path}`);
+    }
+  }
+
+  for (const entry of localCommands)  processEntry(entry, 'local');
+  for (const entry of globalCommands) processEntry(entry, 'global');
+
+  const healthy = missing.length === 0 && degraded.length === 0 && conflicts.length === 0;
+
+  return { healthy, hooks: hookResults, conflicts, degraded, missing };
+}
+
+// ─── Hook smoke test ──────────────────────────────────────────────────────────
+
+/**
+ * Run a hook with deliberately malformed input to verify it fails open
+ * (exits 0 even on bad input, so it never blocks the Claude Code flow).
+ *
+ * @param {string} hookPath
+ * @returns {{ path: string, failsOpen: boolean, stderr?: string, error?: string }}
+ */
+export function runHookSmoke(hookPath) {
+  try {
+    const result = spawnSync('node', [hookPath], {
+      input: 'not valid json',
+      timeout: 5000,
+      encoding: 'utf8',
+    });
+    // Exit 0 = fails open (good), Exit non-0 = fails closed (bad)
+    return { path: hookPath, failsOpen: result.status === 0, stderr: (result.stderr || '').slice(0, 200) };
+  } catch {
+    return { path: hookPath, failsOpen: false, error: 'smoke test crashed' };
+  }
+}