dual-brain 0.2.7 → 0.2.8

package/CLAUDE.md

@@ -2,146 +2,32 @@
 
 This project uses dual-provider orchestration. Config: `.claude/orchestrator.json`.
 
-## Core Architecture (v7)
-
-Four modules in `src/` form the decision pipeline:
-
-- **`profile.mjs`** — Load active profile, provider availability, preferences, and subscription plan
-- **`detect.mjs`** — Classify task intent, risk, complexity, and tier from prompt + file paths
-- **`decide.mjs`** — Route to provider/model/tier; handles budget pressure and dual-brain threshold
-- **`dispatch.mjs`** — Execute the decision: Claude subagent, GPT via Codex, or dual-brain flow
-
-The hooks layer (`/home/runner/workspace/.claude/hooks/`) wraps these modules for Claude Code integration and is still valid.
-
-## CLI Commands
-
-```bash
-dual-brain init                        # First-time setup
-dual-brain go "task description"       # Detect → decide → dispatch
-dual-brain go --dry-run "..."          # Show routing without executing
-dual-brain go --files a.mjs,b.mjs "..." # Provide file context for risk classification
-dual-brain status                      # Provider health, budget pressure, models
-dual-brain remember "preference"       # Save project-scoped preference
-dual-brain forget "preference"         # Remove preference by fuzzy match
-```
-
-## Tier Routing
-
-- **Search** (`haiku`): Read-only lookups, grep, explore. Return: files found, line refs, confidence.
-- **Execute** (`sonnet`): Edits, tests, git ops. Return: files changed, tests run, edge cases.
-- **Think** (main session, Opus): Architecture, review, planning. Return: decision, alternatives, risks.
-
-## Dual-Brain Collaboration
-
-Dual-brain is a multi-round conversation between Claude and GPT — not a single-shot dispatch.
-
-**Think flow** (architecture decisions):
-1. Round 1: `node .claude/hooks/dual-brain-think.mjs --question "..."` → GPT gives independent analysis
-2. You analyze the same question independently
-3. Round 2: `node .claude/hooks/dual-brain-think.mjs --question "..." --round 2 --claude-says "<your analysis>"` → GPT responds with agreements, pushback, refined recommendation
-4. You synthesize both rounds into a final decision
-
-**Review flow** (code review):
-1. Round 1: `node .claude/hooks/dual-brain-review.mjs` → GPT reviews the diff independently
-2. You review the same diff independently
-3. Round 2: `node .claude/hooks/dual-brain-review.mjs --round 2 --claude-review "<your findings>"` → GPT confirms shared findings, acknowledges misses
-4. You synthesize into a final review verdict
-
-## Routing Rules
-
-1. Tasks under 3 min → Claude (Codex startup overhead not worth it)
-2. Isolated tasks over 3 min → check balance: `node .claude/hooks/budget-balancer.mjs`
-3. High-risk decisions → dual-brain think
-4. When a task spans tiers: think > execute > search
-
-## Mandatory Workload Distribution
-
-**Claude MUST follow these rules before implementing multi-file changes:**
-
-1. **Before starting any batch of 3+ file edits**: run `node .claude/hooks/budget-balancer.mjs` to check provider balance, then `dual-brain go --dry-run "description"` to classify tasks
-2. **When budget-balancer recommends GPT**: dispatch via `src/dispatch.mjs` (or `node .claude/hooks/gpt-work-dispatcher.mjs --task "..." --tier execute`)
-3. **Security/auth/credential changes**: always require dual-brain think flow before implementation
-4. **Audit remediation batches**: plan waves with dual-brain think, dispatch execution to GPT, Claude reviews
-5. **Claude's role in multi-task work**: define acceptance criteria, dispatch agents, review results — not solo-implement everything
-
-**Triggers that require this workflow:** 3+ production files edited in one session · auth/credentials/tokens/secrets · changes to dispatcher, agent routing, or tier logic · audit remediation across multiple subsystems · Claude think capacity above 60% per budget-balancer.
-
-**Failure to route is itself a bug.**
-
-## Quality Gate
-
-Before ending a session with code changes:
-1. `node .claude/hooks/session-report.mjs` (allowed by head-guard for hook scripts)
-2. `node .claude/hooks/quality-gate.mjs`
-
-Gate statuses: `pass` (safe to end), `issues_found` (fix first), `needs_human_review` (GPT unavailable).
-
-## Profiles
-
-Profile persists to `.dualbrain/profile.json` (project-scoped, gitignored).
-
-- **auto** (default): Adapts routing based on task risk, provider health, and outcomes
-- **balanced**: Best model per tier, normal budgets, reviews at medium+ risk
-- **cost-saver**: Prefer cheaper models, lower budgets, skip GPT for non-critical
-- **quality-first**: Dual-brain for medium+ risk, higher budgets, stricter reviews
-
-Switch via the interactive Profile screen in `dual-brain`, or set `bias` in `.dualbrain/profile.json`.
-
-## Adaptive Routing (Auto Mode)
-
-- **Risk classification**: auth/secrets→critical, billing/migrations→high, tests/utils→medium, docs→low
-- **Failure detection**: 2+ failures on same prompt in 2 hours → auto-escalate tier or trigger dual-brain
-- **Provider balance**: Routes to underused provider when one subscription is hot
-- **Burst awareness**: Suppresses duplicate warnings during agent waves (3+ agents in 90s)
-
-## Budget Balancer
-
-`src/decide.mjs` handles routing decisions using the same token data internally. For inspection:
-
-```bash
-node .claude/hooks/budget-balancer.mjs
-```
-
-Tracks 5-hour and 7-day rolling windows against subscription limits (Claude Pro/Max, ChatGPT Plus/Pro). The higher pressure window is the binding constraint. Uses actual `input_tokens + output_tokens` from usage logs.
-
-**Subscription tiers** (configured in `orchestrator.json` → `subscriptions.*.plan`):
-- Claude: Pro $20, Max x5 $100, Max x20 $200
-- ChatGPT: Plus $20, Pro $100, Pro $200
-
-## Multi-Step Work
-
-The wave orchestrator is available for complex multi-step tasks:
-
-```bash
-node .claude/hooks/wave-orchestrator.mjs "fix the login bug and update the nav"
-node .claude/hooks/wave-orchestrator.mjs --dry-run "refactor auth module"
-node .claude/hooks/wave-orchestrator.mjs --resume <manifestId>
-```
-
-For most tasks, prefer `dual-brain go "..."` — it runs the same detect→decide→dispatch pipeline with less overhead.
-
-## Available Tools
-
-| Tool | Purpose |
-|------|---------|
-| `dual-brain go "..."` | Primary entry point: detect, decide, dispatch |
-| `dual-brain status` | Provider health, budget, models |
-| `node .claude/hooks/budget-balancer.mjs` | Token usage and routing recommendation |
-| `node .claude/hooks/dual-brain-think.mjs` | Multi-round architecture decisions with GPT |
-| `node .claude/hooks/dual-brain-review.mjs` | Multi-round code review with GPT |
-| `node .claude/hooks/wave-orchestrator.mjs "..."` | Dependency-aware multi-wave dispatch |
-| `node .claude/hooks/session-report.mjs` | End-of-session summary |
-| `node .claude/hooks/quality-gate.mjs` | Gate check before ending session |
-| `node .claude/hooks/health-check.mjs` | System health |
-| `node .claude/hooks/test-orchestrator.mjs` | Self-tests (40 tests) |
-| `node .claude/hooks/vibe-memory.mjs` | Persistent preferences across sessions |
-| `dual-brain search "..."` | Search across all previous sessions |
-
-## Cross-Session Context
-
-When the user references past work ("we did this before", "yesterday we worked on", "remember when we", "didn't we already fix"), use the session search to find relevant context:
-
-1. Run `dual-brain search "keyword"` to search the session index
-2. Or use the MCP tool `dual_brain_search` if available
-
-This surfaces previous conversations so HEAD can provide continuity across sessions without the user having to re-explain.
+## HEAD Constitution
+
+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.
+
+## Quick Reference
+
+| Command | Purpose |
+|---------|---------|
+| `dual-brain go "..."` | Detect → decide → dispatch |
+| `dual-brain status` | Provider health, budget |
+| `dual-brain install --global` | Set dual-brain as default for all sessions |
+| `node .claude/hooks/dual-brain-think.mjs --question "..."` | Multi-round architecture decisions |
+| `node .claude/hooks/dual-brain-review.mjs` | Multi-round code review |
+
+## Modules
+
+Core pipeline: `profile.mjs` → `detect.mjs` → `decide.mjs` → `dispatch.mjs` → `pipeline.mjs`
+HEAD brain: `head.mjs` (state machine, intent, confidence, drift)
+Templates: `templates.mjs` (typed prompt generation)
+Integrity: `integrity.mjs` (atomic writes, locks)
+Quality: `prompt-audit.mjs` (prompt scoring, exchange logging)

package/bin/dual-brain.mjs

@@ -35,7 +35,7 @@ import { runPipeline, buildExecutionPlan, formatExecutionPlan } from '../src/pip
 import { loadRepoCache } from '../src/repo.mjs';
 import { loadSession, saveSession, formatSessionCard, importReplitSessions, getSessionMeta, saveSessionMeta, renameSession, pinSession, unpinSession, categorizeSession, enrichSessions, archiveSession, getArchivedSessions } from '../src/session.mjs';
 
-import { box, bar, badge, menu, separator } from '../src/tui.mjs';
+import { box, bar, badge, menu, separator, panel, divider, statusChip, headerBar, prompt as tuiPrompt, signalLine } from '../src/tui.mjs';
 
 // ─── Dynamic imports for receipts + failure memory ───────────────────────────
 
@@ -2594,8 +2594,7 @@ async function mainScreen(rl, ask) {
 
   // ── Recent work items (dim, max 3) ────────────────────────────────────────
   const recentLines = recentWorkItems.slice(0, 3).map(item => {
-    const prefix = item.ok ? `${GRN}✓${RST}` : `${RED}!${RST}`;
-    return ` ${DIM}${prefix} ${item.text}${RST}`;
+    return signalLine(item.ok ? 'success' : 'warning', `${DIM}${item.text}${RST}`);
   });
 
   // ── Resolve dashboard spinner before rendering ────────────────────────────
@@ -2606,26 +2605,48 @@ async function mainScreen(rl, ask) {
     process.stdout.write(`${DIM}${staleCount} stale sessions (>7d) — type "sessions" to manage${RST}\n`);
   }
 
-  // ── Render Studio Console ─────────────────────────────────────────────────
-  const out = [];
-  out.push('');                          // breathing room
-  out.push(statusBar);                   // project  branch  Claude ●  GPT ●  v0.2.3
-  out.push('');
-  out.push(mainQuestion);                // Resume previous work? / What do you want to build?
-  if (lastSummary) out.push(lastSummary);
-  out.push(` \x1b[1m›\x1b[0m`);         // bright prompt cursor
-  out.push('');
-  out.push(suggestLine);                 // contextual suggestions
+  // ── Render Studio Console (paneled layout) ────────────────────────────────
+  const CYAN = '\x1b[36m';
+  const panelW = Math.min(sepW + 2, 72);
+
+  // Header panel — project, branch, providers, version
+  const headerLeft  = `${DIM}${projectName}${RST}  ${BOLD}${branchStr}${RST}  ${DIM}Claude${RST} ${claudeDot}  ${DIM}GPT${RST} ${openaiDot}`;
+  const headerRight = `${DIM}v${version}${RST}`;
+  const headerContent = [headerBar(headerLeft, headerRight, panelW - 4)];
+  process.stdout.write('\n' + panel('dual-brain', headerContent, { width: panelW, titleColor: CYAN }) + '\n\n');
+
+  // Resume / prompt panel (only when there is something to show)
+  if (isReturning || !anyProviderAvail) {
+    const resumeContent = [];
+    if (!anyProviderAvail) {
+      resumeContent.push(`${BOLD}Connect a provider to start working${RST}`);
+    } else {
+      const labelTrunc = (resumeState.label || 'last session').slice(0, 45);
+      const agePart    = resumeState.ageLabel ? ` · ${resumeState.ageLabel}` : '';
+      const nextPart   = resumeState.nextAction ? ` · next: ${resumeState.nextAction}` : '';
+      resumeContent.push(`${DIM}Last task${RST}   ${BOLD}${labelTrunc}${RST}${DIM}${agePart}${RST}`);
+      if (nextPart) resumeContent.push(`${DIM}Next step${RST}   ${nextPart.replace(/^ · /, '')}`);
+    }
+    resumeContent.push('');
+    resumeContent.push(`  ${CYAN}›${RST} ${BOLD}${suggestions[0]}${RST}    ${DIM}${suggestions[1] || ''}${RST}    ${DIM}${suggestions[2] || ''}${RST}`);
+    process.stdout.write(panel(isReturning ? 'Resume work' : 'Get started', resumeContent, { width: panelW }) + '\n\n');
+  } else {
+    // Fresh / no-resume state — just show suggestions inline
+    const suggestContent = [`  ${CYAN}›${RST} ${BOLD}${suggestions[0]}${RST}    ${DIM}${suggestions[1] || ''}${RST}    ${DIM}${suggestions[2] || ''}${RST}`];
+    process.stdout.write(panel('Get started', suggestContent, { width: panelW }) + '\n\n');
+  }
+
+  // Signals panel — recent work items (only when there are items)
   if (recentLines.length > 0) {
-    out.push('');
-    out.push(...recentLines);            // ✓ / ! recent work items
+    process.stdout.write(panel('Signals', recentLines, { width: panelW }) + '\n\n');
   }
-  out.push('');
-  out.push(` ${sepLine}`);              // ━━━━ separator
-  // Input bar rendered inline — the key handler will overwrite this line
-  out.push(` ${DIM}> task or command...${RST}${' '.repeat(Math.max(1, sepW - 22))}${DIM}[?] help${RST}`);
 
-  process.stdout.write(out.join('\n') + '\n');
+  // Input bar — rendered below panels; the key handler will overwrite this line
+  const inputHint = `${DIM}[?] help${RST}`;
+  const inputLeft = tuiPrompt('task or command...');
+  const inputLeftW = (inputLeft + ' task or command...').replace(/\x1b\[[0-9;]*m/g, '').length;
+  const inputGap = Math.max(1, panelW - inputLeftW - 8);
+  process.stdout.write(` ${inputLeft}${' '.repeat(inputGap)}${inputHint}\n`);
 
   // ── Key handling ──────────────────────────────────────────────────────────
   // Use raw keypress mode so we can show a live type-to-start buffer.
@@ -3563,28 +3584,38 @@ async function settingsScreen(rl, ask) {
     `  ${DIM}Doctor${RESET}        ${doctorStr}`,
   ];
 
-  // ── Render ────────────────────────────────────────────────────────────────
-  const out = [
-    '',
-    `  ${BOLD}Settings${RESET}`,
-    '',
-    `  ${DIM}Subscriptions${RESET}`,
-    ...subsLines,
-    `  ${DIM}[a] add  [r] remove  [h] health check${RESET}`,
-    '',
-    `  ${DIM}Work style${RESET}`,
-    ...wsLines,
-    `  ${DIM}[1-3] change${RESET}`,
+  // ── Render (paneled layout) ───────────────────────────────────────────────
+  const CYAN = '\x1b[36m';
+  const settingsPanelW = 70;
+
+  const subsContent = [
+    ...subsLines.map(l => l.replace(/^  /, '')),
     '',
-    `  ${DIM}System${RESET}`,
-    ...sysLines,
-    `  ${DIM}[d] run doctor  [x] diagnostics${RESET}`,
+    signalLine('info', `${DIM}[a] add  [r] remove  [h] health check${RESET}`),
+  ];
+
+  const wsContent = [
+    ...wsLines.map(l => l.replace(/^  /, '')),
     '',
-    `  ${DIM}[e] sessions  [m] subscriptions  [b] back${RESET}`,
-    ...(settingsPRs.length > 0 ? [`  ${DIM}[p] PR triage (${settingsPRs.length} open)${RESET}`] : []),
+    signalLine('info', `${DIM}[1-3] change${RESET}`),
+  ];
+
+  const sysContent = [
+    ...sysLines.map(l => l.replace(/^  /, '')),
     '',
+    signalLine('info', `${DIM}[d] run doctor  [x] diagnostics${RESET}`),
   ];
-  process.stdout.write(out.join('\n') + '\n');
+
+  const navContent = [
+    `${DIM}[e]${RESET} sessions  ${DIM}[m]${RESET} subscriptions  ${DIM}[b]${RESET} back`,
+    ...(settingsPRs.length > 0 ? [`${DIM}[p]${RESET} PR triage ${DIM}(${settingsPRs.length} open)${RESET}`] : []),
+  ];
+
+  process.stdout.write('\n');
+  process.stdout.write(panel('Subscriptions', subsContent, { width: settingsPanelW, titleColor: CYAN }) + '\n\n');
+  process.stdout.write(panel('Work style', wsContent, { width: settingsPanelW, titleColor: CYAN }) + '\n\n');
+  process.stdout.write(panel('System', sysContent, { width: settingsPanelW, titleColor: CYAN }) + '\n\n');
+  process.stdout.write(panel('Navigation', navContent, { width: settingsPanelW }) + '\n\n');
 
   const raw    = (await ask('  Choice: ')).trim();
   const choice = raw.toLowerCase();
@@ -4045,15 +4076,20 @@ async function askDefaultShell(cwd, rl, fx) {
   const cl = fx.colors || {};
   const DIM = cl.dim || '';
   const BOLD = cl.bold || '';
-  const GRAY = cl.gray || '';
+  const CYAN = cl.cyan || '\x1b[36m';
+  const YLW  = cl.yellow || '\x1b[33m';
   const GREEN = cl.green || '';
   const RST = cl.reset || '';
 
-  process.stdout.write('\n');
-  process.stdout.write(` ${BOLD}Shell startup${RST}\n\n`);
-  process.stdout.write(` ${DIM}dual-brain can start automatically when your shell opens.${RST}\n`);
-  process.stdout.write(` ${DIM}This modifies .replit onBoot. You can change it anytime in Settings.${RST}\n\n`);
-  process.stdout.write(` ${GRAY}[y]${RST} Yes, set as default  ${GRAY}[n]${RST} No, I'll run it manually\n\n`);
+  const setupContent = [
+    `${DIM}Start dual-brain automatically when this Replit opens?${RST}`,
+    '',
+    `  ${DIM}modifies${RST}  ${YLW}.replit onBoot${RST}`,
+    `  ${DIM}undo${RST}      Settings → System → Startup`,
+    '',
+    `  ${CYAN}[Y]${RST} Start on boot     ${DIM}[n] Run manually${RST}`,
+  ];
+  process.stdout.write('\n' + panel('dual-brain setup', setupContent) + '\n');
 
   const answer = await new Promise(res => rl.question('  ', (a) => res(a.trim().toLowerCase())));
   const yes = !answer || answer.startsWith('y');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -27,7 +27,11 @@
     "./continuity": "./src/continuity.mjs",
     "./checkpoint": "./src/checkpoint.mjs",
     "./pr-agent": "./src/pr-agent.mjs",
-    "./ci-triage": "./src/ci-triage.mjs"
+    "./ci-triage": "./src/ci-triage.mjs",
+    "./integrity": "./src/integrity.mjs",
+    "./prompt-audit": "./src/prompt-audit.mjs",
+    "./head": "./src/head.mjs",
+    "./templates": "./src/templates.mjs"
   },
   "keywords": [
     "claude-code",
@@ -94,6 +98,10 @@
     "src/checkpoint.mjs",
     "src/ci-triage.mjs",
     "src/pr-agent.mjs",
+    "src/integrity.mjs",
+    "src/prompt-audit.mjs",
+    "src/head.mjs",
+    "src/templates.mjs",
     "bin/*.mjs",
     "hooks/enforce-tier.mjs",
     "hooks/cost-logger.mjs",

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