dual-brain 0.2.6 → 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 ───────────────────────────
 
@@ -1040,43 +1040,58 @@ async function installGlobal() {
     return;
   }
 
-  // Load existing settings (merge, never clobber)
-  let existing = {};
-  if (existsSync(globalSettingsPath)) {
-    try { existing = JSON.parse(readFileSync(globalSettingsPath, 'utf8')); } catch {}
-  }
-
-  // Ensure hooks structure exists
-  if (!existing.hooks) existing.hooks = {};
-  if (!existing.hooks.PreToolUse) existing.hooks.PreToolUse = [];
-  if (!existing.hooks.PostToolUse) existing.hooks.PostToolUse = [];
-
-  // Define dual-brain hooks with ownership marker
-  const DB_MARKER = '# dual-brain-managed';
-  const preToolHooks = [
-    { matcher: 'Edit',        hooks: [{ type: 'command', command: `node ${join(hooksDir, 'head-guard.mjs')} ${DB_MARKER}` }] },
-    { matcher: 'Write',       hooks: [{ type: 'command', command: `node ${join(hooksDir, 'head-guard.mjs')} ${DB_MARKER}` }] },
-    { matcher: 'NotebookEdit',hooks: [{ type: 'command', command: `node ${join(hooksDir, 'head-guard.mjs')} ${DB_MARKER}` }] },
-    { matcher: 'Bash',        hooks: [{ type: 'command', command: `node ${join(hooksDir, 'head-guard.mjs')} ${DB_MARKER}` }] },
-    { matcher: 'Agent',       hooks: [{ type: 'command', command: `node ${join(hooksDir, 'enforce-tier.mjs')} ${DB_MARKER}` }] },
-  ];
-  const postToolHooks = [
-    { matcher: '', hooks: [{ type: 'command', command: `node ${join(hooksDir, 'cost-logger.mjs')} ${DB_MARKER}` }] },
-    { matcher: '', hooks: [{ type: 'command', command: `node ${join(hooksDir, 'auto-update-wrapper.mjs')} ${DB_MARKER}` }] },
-  ];
-
-  // Remove any existing dual-brain hooks (idempotent)
-  const isDBHook = (entry) => entry.hooks?.some(h => h.command?.includes(DB_MARKER));
-  existing.hooks.PreToolUse  = existing.hooks.PreToolUse.filter(e => !isDBHook(e));
-  existing.hooks.PostToolUse = existing.hooks.PostToolUse.filter(e => !isDBHook(e));
+  // Check if project-local hooks already exist (avoids double-firing)
+  const projectLocalSettings = join(pkgRoot, '.claude', 'settings.local.json');
+  const hasProjectLocalHooks = (() => {
+    if (!existsSync(projectLocalSettings)) return false;
+    try {
+      const content = readFileSync(projectLocalSettings, 'utf8');
+      return content.includes('dual-brain') || content.includes('head-guard');
+    } catch { return false; }
+  })();
+
+  if (hasProjectLocalHooks) {
+    console.log('  hooks already configured project-locally, skipping global hooks');
+    console.log('  (project .claude/settings.local.json already contains dual-brain hooks)');
+  } else {
+    // Load existing settings (merge, never clobber)
+    let existing = {};
+    if (existsSync(globalSettingsPath)) {
+      try { existing = JSON.parse(readFileSync(globalSettingsPath, 'utf8')); } catch {}
+    }
 
-  // Add dual-brain hooks
-  existing.hooks.PreToolUse.push(...preToolHooks);
-  existing.hooks.PostToolUse.push(...postToolHooks);
+    // Ensure hooks structure exists
+    if (!existing.hooks) existing.hooks = {};
+    if (!existing.hooks.PreToolUse) existing.hooks.PreToolUse = [];
+    if (!existing.hooks.PostToolUse) existing.hooks.PostToolUse = [];
 
-  // Write merged settings
-  mkdirSync(globalClaudeDir, { recursive: true });
-  writeFileSync(globalSettingsPath, JSON.stringify(existing, null, 2) + '\n');
+    // Define dual-brain hooks with ownership marker
+    const DB_MARKER = '# dual-brain-managed';
+    const preToolHooks = [
+      { matcher: 'Edit',        hooks: [{ type: 'command', command: `node ${join(hooksDir, 'head-guard.mjs')} ${DB_MARKER}` }] },
+      { matcher: 'Write',       hooks: [{ type: 'command', command: `node ${join(hooksDir, 'head-guard.mjs')} ${DB_MARKER}` }] },
+      { matcher: 'NotebookEdit',hooks: [{ type: 'command', command: `node ${join(hooksDir, 'head-guard.mjs')} ${DB_MARKER}` }] },
+      { matcher: 'Bash',        hooks: [{ type: 'command', command: `node ${join(hooksDir, 'head-guard.mjs')} ${DB_MARKER}` }] },
+      { matcher: 'Agent',       hooks: [{ type: 'command', command: `node ${join(hooksDir, 'enforce-tier.mjs')} ${DB_MARKER}` }] },
+    ];
+    const postToolHooks = [
+      { matcher: '', hooks: [{ type: 'command', command: `node ${join(hooksDir, 'cost-logger.mjs')} ${DB_MARKER}` }] },
+      { matcher: '', hooks: [{ type: 'command', command: `node ${join(hooksDir, 'auto-update-wrapper.mjs')} ${DB_MARKER}` }] },
+    ];
+
+    // Remove any existing dual-brain hooks (idempotent)
+    const isDBHook = (entry) => entry.hooks?.some(h => h.command?.includes(DB_MARKER));
+    existing.hooks.PreToolUse  = existing.hooks.PreToolUse.filter(e => !isDBHook(e));
+    existing.hooks.PostToolUse = existing.hooks.PostToolUse.filter(e => !isDBHook(e));
+
+    // Add dual-brain hooks
+    existing.hooks.PreToolUse.push(...preToolHooks);
+    existing.hooks.PostToolUse.push(...postToolHooks);
+
+    // Write merged settings
+    mkdirSync(globalClaudeDir, { recursive: true });
+    writeFileSync(globalSettingsPath, JSON.stringify(existing, null, 2) + '\n');
+  }
 
   // Write minimal global CLAUDE.md (only if none exists, or append section)
   const globalClaudeMd = join(globalClaudeDir, 'CLAUDE.md');
@@ -1091,12 +1106,16 @@ async function installGlobal() {
     }
   }
 
-  console.log('  + dual-brain hooks installed globally');
-  console.log('    hooks dir: ' + hooksDir);
-  console.log('    settings:  ' + globalSettingsPath);
-  console.log('');
-  console.log('  All new Claude sessions will load dual-brain hooks.');
-  console.log('  Run "dual-brain uninstall --global" to remove.');
+  if (!hasProjectLocalHooks) {
+    console.log('  + dual-brain hooks installed globally');
+    console.log('    hooks dir: ' + hooksDir);
+    console.log('    settings:  ' + globalSettingsPath);
+    console.log('');
+    console.log('  All new Claude sessions will load dual-brain hooks.');
+    console.log('  Run "dual-brain uninstall --global" to remove.');
+  }
+  console.log('  + global CLAUDE.md updated');
+  console.log('    path: ' + globalClaudeDir);
 }
 
 async function uninstallGlobal() {
@@ -2163,6 +2182,15 @@ async function mainScreen(rl, ask) {
     dashSpinner = fx.spinner('Loading dashboard...').start();
   }
 
+  // ── One-time default shell prompt for returning users (never asked before) ─
+  if (profile.setupComplete && !profile.defaultShellAsked) {
+    if (dashSpinner) { dashSpinner.stop(); dashSpinner = null; }
+    const wantsDefault = await askDefaultShell(cwd, rl, fx);
+    profile.defaultShellAsked = true;
+    profile.isDefaultShell = wantsDefault;
+    saveProfile(profile, { cwd });
+  }
+
   const claudeSub = profile?.providers?.claude;
   const openaiSub = profile?.providers?.openai;
 
@@ -2566,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 ────────────────────────────
@@ -2578,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.
@@ -3535,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}`),
+  ];
+
+  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(out.join('\n') + '\n');
+
+  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();
@@ -3984,6 +4043,67 @@ function saveWizardCredentials(cwd, detectedProviders) {
  * @param {object} rl  readline interface
  * @returns {object|null}  profile object to save, or null if cancelled/skipped
  */
+function setAsDefaultShell(cwd) {
+  const root = cwd || process.cwd();
+  const replitPath = join(root, '.replit');
+  if (!existsSync(replitPath)) return;
+
+  let content = readFileSync(replitPath, 'utf8');
+  const newOnBoot = 'onBoot = "source /home/runner/workspace/.replit-tools/scripts/setup-claude-code.sh 2>/dev/null || true; ln -sf /home/runner/workspace/.replit-tools/.npm-persistent/.npmrc ~/.npmrc 2>/dev/null || true; dual-brain install --global 2>/dev/null || true"';
+
+  if (content.match(/^onBoot\s*=/m)) {
+    content = content.replace(/^onBoot\s*=.*$/m, newOnBoot);
+  } else {
+    content += '\n' + newOnBoot + '\n';
+  }
+  writeFileSync(replitPath, content);
+}
+
+function removeAsDefaultShell(cwd) {
+  const root = cwd || process.cwd();
+  const replitPath = join(root, '.replit');
+  if (!existsSync(replitPath)) return;
+
+  let content = readFileSync(replitPath, 'utf8');
+  const origOnBoot = 'onBoot = "source /home/runner/workspace/.replit-tools/scripts/setup-claude-code.sh 2>/dev/null || true"';
+  if (content.match(/^onBoot\s*=/m)) {
+    content = content.replace(/^onBoot\s*=.*$/m, origOnBoot);
+    writeFileSync(replitPath, content);
+  }
+}
+
+async function askDefaultShell(cwd, rl, fx) {
+  const cl = fx.colors || {};
+  const DIM = cl.dim || '';
+  const BOLD = cl.bold || '';
+  const CYAN = cl.cyan || '\x1b[36m';
+  const YLW  = cl.yellow || '\x1b[33m';
+  const GREEN = cl.green || '';
+  const RST = cl.reset || '';
+
+  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');
+
+  if (yes) {
+    setAsDefaultShell(cwd);
+    process.stdout.write(` ${GREEN}+${RST} ${DIM}dual-brain will start on boot. Change anytime in Settings.${RST}\n`);
+  } else {
+    process.stdout.write(` ${DIM}No problem. Run dual-brain anytime from the command line.${RST}\n`);
+  }
+
+  return yes;
+}
+
 async function runOnboardingWizard(_detection, cwd, rl) {
   const fx  = await getFx();
   const cl  = fx.colors || {};
@@ -4278,6 +4398,23 @@ async function runOnboardingWizard(_detection, cwd, rl) {
   finalProfile.bias      = chosenBias;
   finalProfile.workStyle = chosenBias;
 
+  // Ask about default shell (only on first wizard run)
+  if (!finalProfile.defaultShellAsked) {
+    const wantsDefault = await askDefaultShell(cwd, rl, fx);
+    finalProfile.defaultShellAsked = true;
+    finalProfile.isDefaultShell = wantsDefault;
+    saveProfile(finalProfile, { cwd });
+
+    // Also run global install if they said yes
+    if (wantsDefault) {
+      try {
+        execSync('node ' + join(dirname(fileURLToPath(import.meta.url)), 'dual-brain.mjs') + ' install --global', {
+          cwd, stdio: 'pipe', timeout: 10000,
+        });
+      } catch {}
+    }
+  }
+
   return finalProfile;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.6",
+  "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",