dual-brain 0.2.4 → 0.2.6

package/bin/dual-brain.mjs

@@ -242,11 +242,19 @@ Commands:
   init                      First-time setup → flows into interactive REPL
   auth                      Show provider login and plan status
   install                   Install Claude Code hooks into the current project
+  install --global          Write hooks into ~/.claude/settings.json (absolute paths,
+                            fires from any working directory after shell restart)
+  uninstall --global        Remove dual-brain hooks from ~/.claude/settings.json
   go "task description"     Detect → decide → dispatch (alias for do)
     --dry-run               Show routing decision without executing
     --files a.mjs,b.mjs     Provide file context for risk classification
     --verbose, -v           Print routing trace (intent, risk, health, model selection)
   think "question"          Multi-round architecture decision with dual-brain
+  pr                        Show PR status for current branch
+  pr create                 Create PR from current branch with auto-generated description
+    --draft                 Create as a draft PR
+  pr list                   List open PRs (--closed, --all for other states)
+  pr view <N>               View PR #N details
   status                    Provider health, session stats, available models
     --verbose, -v           Also print profile file path and raw profile object
   hot <provider>            Manually mark all model classes for provider as hot
@@ -373,6 +381,26 @@ async function cmdInit(rl) {
   // --- Step 2b: Install hooks ---
   await cmdInstall(cwd);
 
+  // --- Step 2c: Suggest global install if not already done ---
+  try {
+    const { homedir } = await import('node:os');
+    const globalSettingsPath = join(homedir(), '.claude', 'settings.json');
+    const DB_MARKER = '# dual-brain-managed';
+    let alreadyGlobal = false;
+    if (existsSync(globalSettingsPath)) {
+      try {
+        const gs = JSON.parse(readFileSync(globalSettingsPath, 'utf8'));
+        const allHooks = [...(gs.hooks?.PreToolUse || []), ...(gs.hooks?.PostToolUse || [])];
+        alreadyGlobal = allHooks.some(e => e.hooks?.some(h => h.command?.includes(DB_MARKER)));
+      } catch {}
+    }
+    if (!alreadyGlobal) {
+      console.log('');
+      console.log('  Tip: run "dual-brain install --global" to load these hooks from');
+      console.log('  any directory — so dual-brain works when Replit restarts a shell.');
+    }
+  } catch {}
+
   // --- Step 3: Show dashboard ---
   console.log('');
   const repo    = loadRepoCache(cwd);
@@ -918,9 +946,7 @@ async function cmdStatus(args = []) {
       const archive = replit.getSessionArchive(cwd);
       const archiveCount = Array.isArray(archive) ? archive.length : (archive?.count ?? 0);
       console.log(`  session archive: ${archiveCount} session${archiveCount !== 1 ? 's' : ''}`);
-      const openaiPresent  = replit.hasSecret('OPENAI_API_KEY');
-      const anthropicPresent = replit.hasSecret('ANTHROPIC_API_KEY');
-      console.log(`  secrets       : OPENAI_API_KEY=${openaiPresent ? 'set' : 'unset'}  ANTHROPIC_API_KEY=${anthropicPresent ? 'set' : 'unset'}`);
+      // Subscription-only: no API key secrets to check
     }
   } catch { /* replit.mjs not available or not in Replit — skip silently */ }
 
@@ -991,6 +1017,139 @@ async function cmdInstall(cwd) {
   }
 }
 
+async function installGlobal() {
+  const { homedir } = await import('node:os');
+  const globalClaudeDir = join(homedir(), '.claude');
+  const globalSettingsPath = join(globalClaudeDir, 'settings.json');
+
+  // Resolve absolute path to hooks directory via import.meta.url
+  const pkgRoot = join(__dirname, '..');
+  const hooksDir = join(pkgRoot, '.claude', 'hooks');
+
+  // Warn if running from npx (ephemeral path)
+  if (pkgRoot.includes('.npm/_npx') || pkgRoot.includes('npx-')) {
+    console.log('  Warning: Running from npx — paths will break after this session.');
+    console.log('    Install globally first: npm i -g dual-brain');
+    console.log('    Then run: dual-brain install --global');
+    return;
+  }
+
+  // Verify hooks exist at resolved path
+  if (!existsSync(join(hooksDir, 'head-guard.mjs'))) {
+    console.log('  Error: Could not resolve hook files at: ' + hooksDir);
+    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));
+
+  // 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');
+  const dbSection = `\n## Dual-Brain Global Hooks\n\nThis machine has dual-brain hooks installed globally.\nProject-local .claude/CLAUDE.md and settings take precedence.\nManaged by: dual-brain install --global\n`;
+
+  if (!existsSync(globalClaudeMd)) {
+    writeFileSync(globalClaudeMd, dbSection);
+  } else {
+    const content = readFileSync(globalClaudeMd, 'utf8');
+    if (!content.includes('Dual-Brain Global Hooks')) {
+      writeFileSync(globalClaudeMd, content + '\n' + dbSection);
+    }
+  }
+
+  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.');
+}
+
+async function uninstallGlobal() {
+  const { homedir } = await import('node:os');
+  const globalSettingsPath = join(homedir(), '.claude', 'settings.json');
+
+  if (!existsSync(globalSettingsPath)) {
+    console.log('  No global settings found.');
+    return;
+  }
+
+  let settings = {};
+  try { settings = JSON.parse(readFileSync(globalSettingsPath, 'utf8')); } catch { return; }
+
+  const DB_MARKER = '# dual-brain-managed';
+  const isDBHook = (entry) => entry.hooks?.some(h => h.command?.includes(DB_MARKER));
+
+  let removed = 0;
+  if (settings.hooks?.PreToolUse) {
+    const before = settings.hooks.PreToolUse.length;
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(e => !isDBHook(e));
+    removed += before - settings.hooks.PreToolUse.length;
+  }
+  if (settings.hooks?.PostToolUse) {
+    const before = settings.hooks.PostToolUse.length;
+    settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(e => !isDBHook(e));
+    removed += before - settings.hooks.PostToolUse.length;
+  }
+
+  // Clean up empty arrays/objects
+  if (settings.hooks?.PreToolUse?.length === 0)  delete settings.hooks.PreToolUse;
+  if (settings.hooks?.PostToolUse?.length === 0) delete settings.hooks.PostToolUse;
+  if (Object.keys(settings.hooks || {}).length === 0) delete settings.hooks;
+
+  writeFileSync(globalSettingsPath, JSON.stringify(settings, null, 2) + '\n');
+
+  // Remove dual-brain section from global CLAUDE.md
+  const globalClaudeMd = join(homedir(), '.claude', 'CLAUDE.md');
+  if (existsSync(globalClaudeMd)) {
+    let content = readFileSync(globalClaudeMd, 'utf8');
+    const dbSectionRegex = /\n## Dual-Brain Global Hooks\n[\s\S]*?Managed by: dual-brain install --global\n/;
+    content = content.replace(dbSectionRegex, '');
+    if (content.trim()) {
+      writeFileSync(globalClaudeMd, content);
+    } else {
+      unlinkSync(globalClaudeMd);
+    }
+  }
+
+  console.log(`  - removed ${removed} dual-brain hook${removed === 1 ? '' : 's'} from global settings`);
+  console.log('  Other settings preserved.');
+}
+
 function cmdRemember(text) {
   if (!text) err('Usage: dual-brain remember "preference text"');
   const profile = rememberPreference(text, { scope: 'project', cwd: process.cwd() });
@@ -1050,6 +1209,182 @@ function cmdBreakGlass(reason) {
   console.log('└' + '─'.repeat(inner) + '┘');
 }
 
+// ─── PR command ───────────────────────────────────────────────────────────────
+
+async function cmdPR(args) {
+  const cwd = process.cwd();
+  const sub = args[0] ?? '';
+
+  // Lazy import — only loaded when 'pr' is invoked
+  let prAgent;
+  try {
+    prAgent = await import('../src/pr-agent.mjs');
+  } catch (e) {
+    console.error('pr-agent module not available:', e.message);
+    process.exit(1);
+  }
+
+  const gh = prAgent.hasGitHub();
+  if (!gh.available) {
+    console.error('gh CLI not found. Install GitHub CLI: https://cli.github.com');
+    process.exit(1);
+  }
+
+  // ── dual-brain pr  (show current branch PR status) ──────────────────────────
+  if (!sub || sub === 'status') {
+    if (!gh.authenticated) {
+      console.log('gh CLI is available but not authenticated. Run: gh auth login');
+      return;
+    }
+    const info = prAgent.getBranchInfo(cwd);
+    console.log('\n── PR status ─────────────────────────────────────────────\n');
+    console.log(`  Branch:   ${info.branch ?? '(unknown)'}`);
+    console.log(`  Base:     ${info.defaultBranch}`);
+    console.log(`  Ahead:    ${info.ahead} commit(s)`);
+    console.log(`  Behind:   ${info.behind} commit(s)`);
+
+    if (info.isDefault) {
+      console.log('\n  On default branch — create a feature branch first.');
+      return;
+    }
+
+    // Check for an existing PR on this branch
+    try {
+      const { execSync: _exec } = await import('node:child_process');
+      const json = _exec(`gh pr list --head "${info.branch}" --json number,title,state,url`, {
+        cwd, encoding: 'utf8', timeout: 10000,
+      });
+      const prs = JSON.parse(json);
+      if (prs.length > 0) {
+        const pr = prs[0];
+        console.log(`\n  PR #${pr.number}: ${pr.title}`);
+        console.log(`  State: ${pr.state}`);
+        console.log(`  URL:   ${pr.url}`);
+      } else {
+        console.log('\n  No PR open for this branch.');
+        console.log(`  Create one: dual-brain pr create`);
+      }
+    } catch {
+      console.log('\n  (Could not check for existing PR — run: gh pr status)');
+    }
+    console.log('');
+    return;
+  }
+
+  // ── dual-brain pr list ───────────────────────────────────────────────────────
+  if (sub === 'list') {
+    if (!gh.authenticated) {
+      console.log('gh CLI not authenticated. Run: gh auth login');
+      return;
+    }
+    const state = args.includes('--closed') ? 'closed' : args.includes('--all') ? 'all' : 'open';
+    const prs = prAgent.listPRs(cwd, { state, limit: 20 });
+    if (prs.length === 0) {
+      console.log(`No ${state} PRs found.`);
+      return;
+    }
+    console.log(`\n── ${state} PRs ──────────────────────────────────────────────\n`);
+    for (const pr of prs) {
+      const draft = pr.isDraft ? ' [draft]' : '';
+      const date  = pr.createdAt ? new Date(pr.createdAt).toLocaleDateString() : '';
+      console.log(`  #${pr.number}  ${pr.title}${draft}`);
+      console.log(`       ${pr.headRefName}  by ${pr.author?.login ?? '?'}  ${date}`);
+    }
+    console.log('');
+    return;
+  }
+
+  // ── dual-brain pr view <N> ───────────────────────────────────────────────────
+  if (sub === 'view') {
+    const prNum = args[1];
+    if (!prNum || isNaN(Number(prNum))) {
+      console.error('Usage: dual-brain pr view <PR-number>');
+      process.exit(1);
+    }
+    const details = prAgent.getPRDetails(prNum, cwd);
+    if (!details) {
+      console.error(`PR #${prNum} not found or gh CLI error.`);
+      process.exit(1);
+    }
+    console.log(`\n── PR #${prNum}: ${details.title} ─────────────────────────────\n`);
+    console.log(`  State:    ${details.state}`);
+    console.log(`  Branch:   ${details.headRefName} → ${details.baseRefName}`);
+    console.log(`  Changes:  +${details.additions} -${details.deletions}  (${details.changedFiles} files)`);
+    if (details.statusCheckRollup?.length) {
+      const passing = details.statusCheckRollup.filter(c => c.conclusion === 'SUCCESS').length;
+      const total   = details.statusCheckRollup.length;
+      console.log(`  Checks:   ${passing}/${total} passing`);
+    }
+    if (details.body) {
+      console.log('\n  Body:\n');
+      console.log(details.body.split('\n').map(l => `    ${l}`).join('\n').slice(0, 1500));
+    }
+    console.log('');
+    return;
+  }
+
+  // ── dual-brain pr create ─────────────────────────────────────────────────────
+  if (sub === 'create') {
+    if (!gh.authenticated) {
+      console.log('gh CLI not authenticated. Run: gh auth login');
+      return;
+    }
+    const info = prAgent.getBranchInfo(cwd);
+    if (info.isDefault || !info.branch) {
+      console.error('You are on the default branch. Switch to a feature branch before creating a PR.');
+      process.exit(1);
+    }
+    if (info.ahead === 0) {
+      console.error('No commits ahead of the base branch. Make changes and commit first.');
+      process.exit(1);
+    }
+
+    const diff = prAgent.getDiffSummary(info.defaultBranch, cwd);
+    const draft = args.includes('--draft');
+
+    // Auto-generate a title from the branch name
+    const rawTitle = info.branch.replace(/^db\//, '').replace(/-/g, ' ');
+    const title = rawTitle.charAt(0).toUpperCase() + rawTitle.slice(1);
+
+    // Auto-generate body from diff
+    const body = prAgent.buildPRBody(title, {
+      filesChanged: diff.files,
+    });
+
+    console.log(`\n── Creating PR from ${info.branch} → ${info.defaultBranch} ────────────\n`);
+    console.log(`  Title:  ${title}`);
+    console.log(`  Files:  ${diff.fileCount} changed`);
+    if (diff.summary) console.log(`  Diff:   ${diff.summary}`);
+    if (draft) console.log('  Mode:   draft');
+    console.log('');
+
+    const result = prAgent.createPR({
+      title,
+      body,
+      baseBranch: info.defaultBranch,
+      draft,
+      cwd,
+    });
+
+    if (result.success) {
+      console.log(`  PR created: ${result.url}`);
+    } else {
+      console.error(`  Failed to create PR: ${result.error}`);
+      process.exit(1);
+    }
+    console.log('');
+    return;
+  }
+
+  // Unknown sub-subcommand
+  console.log(`Unknown pr subcommand: "${sub}"`);
+  console.log('Usage:');
+  console.log('  dual-brain pr              Show PR status for current branch');
+  console.log('  dual-brain pr create       Create PR from current branch');
+  console.log('  dual-brain pr list         List open PRs');
+  console.log('  dual-brain pr view <N>     View PR details');
+}
+
 // ─── Screen helpers ───────────────────────────────────────────────────────────
 
 /**
@@ -1644,13 +1979,9 @@ function buildProviderStatusLine(profile, auth, envReport = null) {
   const GREEN = '\x1b[32m●\x1b[0m';
   const RED   = '\x1b[31m●\x1b[0m';
 
-  // Use envReport secrets when available; fall back to auth detection
-  const claudeAvailable = envReport
-    ? envReport.secrets.ANTHROPIC_API_KEY || auth.claude.found
-    : auth.claude.found;
-  const openaiAvailable = envReport
-    ? envReport.secrets.OPENAI_API_KEY || auth.openai.found
-    : auth.openai.found;
+  // Subscription-only detection — no API key secrets
+  const claudeAvailable = auth.claude.found;
+  const openaiAvailable = auth.openai.found;
 
   const claudeDot = claudeAvailable ? GREEN : RED;
   const openaiDot = openaiAvailable ? GREEN : RED;
@@ -1971,13 +2302,9 @@ async function mainScreen(rl, ask) {
     envReport = scanEnvironment(cwd);
   } catch { /* non-fatal */ }
 
-  // ── Studio Console: resolve provider availability ────────────────────────
-  const claudeAvail = envReport
-    ? envReport.secrets?.ANTHROPIC_API_KEY || auth.claude.found
-    : auth.claude.found;
-  const openaiAvail = envReport
-    ? envReport.secrets?.OPENAI_API_KEY || auth.openai.found
-    : auth.openai.found;
+  // ── Studio Console: resolve provider availability (subscription-only) ───
+  const claudeAvail = auth.claude.found;
+  const openaiAvail = auth.openai.found;
 
   // ── Box 2 — Workspace: gather git data ───────────────────────────────────
   let gitBranch       = 'unknown';
@@ -3771,12 +4098,10 @@ async function runOnboardingWizard(_detection, cwd, rl) {
   let claudeAuthLabel = null;
   let claudeAuthType  = null;
   if (claudeReady) {
-    if (caps.claude.source === 'claude-code') {
+    if (caps.claude.source === 'claude-code' || caps.claude.source === 'claude-dir') {
       claudeAuthLabel = 'CLI OAuth'; claudeAuthType = 'cli_oauth';
-    } else if (caps.claude.source === 'env-key') {
-      claudeAuthLabel = 'API key'; claudeAuthType = 'api_key';
     } else {
-      claudeAuthLabel = caps.claude.source || 'detected'; claudeAuthType = 'unknown';
+      claudeAuthLabel = caps.claude.source || 'detected'; claudeAuthType = 'cli_oauth';
     }
     fx.success(`Claude CLI found · ${claudeAuthLabel}`);
   }
@@ -3784,10 +4109,7 @@ async function runOnboardingWizard(_detection, cwd, rl) {
   // OpenAI / Codex
   let openaiAuthLabel = null;
   let openaiAuthType  = null;
-  if (openaiReady) {
-    openaiAuthLabel = 'API key'; openaiAuthType = 'api_key';
-    fx.success('OpenAI detected · API key');
-  } else if (codexAvailable) {
+  if (openaiReady || codexAvailable) {
     openaiAuthLabel = 'CLI OAuth'; openaiAuthType = 'cli_oauth';
     fx.success('OpenAI Codex CLI found · authenticated');
   }
@@ -3830,7 +4152,6 @@ async function runOnboardingWizard(_detection, cwd, rl) {
     } else if (noProvChoice === 'o') {
       process.stdout.write('\n');
       dimLine('Run: codex login');
-      dimLine('Or add OPENAI_API_KEY to Replit Secrets if using API key auth.');
       dimLine('Then re-run: dual-brain init');
       process.stdout.write('\n');
     }
@@ -3850,9 +4171,7 @@ async function runOnboardingWizard(_detection, cwd, rl) {
   if (claudeReady) {
     process.stdout.write(`   ${GRAY}Claude${RST}  ${claudeAuthLabel}    ${GREEN}✓ authenticated${RST}\n`);
   }
-  if (openaiReady) {
-    process.stdout.write(`   ${GRAY}OpenAI${RST}  API key    ${GREEN}✓ OPENAI_API_KEY${RST}\n`);
-  } else if (codexAvailable) {
+  if (openaiReady || codexAvailable) {
     process.stdout.write(`   ${GRAY}OpenAI${RST}  CLI OAuth  ${GREEN}✓ authenticated${RST}\n`);
   }
 
@@ -3877,8 +4196,8 @@ async function runOnboardingWizard(_detection, cwd, rl) {
     process.stdout.write('\n');
   } else if (provChoice === 'a') {
     process.stdout.write('\n');
-    if (!claudeReady) dimLine('Claude: run `claude auth login` to authenticate');
-    if (!openaiReady && !codexAvailable) dimLine('OpenAI: set OPENAI_API_KEY or run `codex login`');
+    if (!claudeReady) dimLine('Claude: run `claude login` to authenticate');
+    if (!openaiReady && !codexAvailable) dimLine('OpenAI: run `codex login` to authenticate');
     process.stdout.write('\n');
     process.stdout.write(` ${GRAY}[Enter]${RST} continue with current providers\n\n`);
     await singleKey(['\r', 'q']);
@@ -3901,10 +4220,10 @@ async function runOnboardingWizard(_detection, cwd, rl) {
   }
   if (finalOpenaiEnabled) {
     credEntries.push({
-      id: openaiReady ? 'openai-apikey' : 'openai-codex',
+      id: 'openai-codex',
       provider: 'openai',
-      auth_type: openaiAuthType || 'api_key',
-      source: openaiReady ? 'env_var' : 'cli_oauth',
+      auth_type: 'cli_oauth',
+      source: 'cli_oauth',
       owner: 'user',
       scope: 'local',
       plan_hint: null,
@@ -3926,12 +4245,6 @@ async function runOnboardingWizard(_detection, cwd, rl) {
   const styleMap = { '1': 'auto', '2': 'quality-first', '3': 'cost-saver', '\r': 'auto' };
   const chosenBias = styleMap[styleKey] || 'auto';
 
-  // Metered API note (non-blocking)
-  if (openaiReady && caps.openai.metered) {
-    process.stdout.write('\n');
-    dimLine('OpenAI API key detected — usage is metered, guardrails enabled');
-  }
-
   process.stdout.write('\n');
 
   // Init living docs (non-fatal)
@@ -3957,7 +4270,7 @@ async function runOnboardingWizard(_detection, cwd, rl) {
 
   finalProfile.providers.claude = { enabled: finalClaudeEnabled };
   finalProfile.providers.openai = { enabled: finalOpenaiEnabled };
-  finalProfile.apiGuardrail     = caps.openai.metered;
+  finalProfile.apiGuardrail     = false;
   finalProfile.setupComplete    = true;
 
   const enabledCount = [finalClaudeEnabled, finalOpenaiEnabled].filter(Boolean).length;
@@ -5640,7 +5953,16 @@ async function main() {
   }
 
   // One-shot commands — run and exit
-  if (cmd === 'install')  { await cmdInstall(); return; }
+  if (cmd === 'install') {
+    if (args.includes('--global')) { await installGlobal(); return; }
+    await cmdInstall();
+    return;
+  }
+  if (cmd === 'uninstall') {
+    if (args.includes('--global')) { await uninstallGlobal(); return; }
+    console.log('Usage: dual-brain uninstall --global');
+    return;
+  }
   if (cmd === 'auth') {
     await cmdAuth(args.slice(1));
     return;
@@ -5651,6 +5973,7 @@ async function main() {
   if (cmd === 'think')    { await cmdThink(args.slice(1)); return; }
   if (cmd === 'review')   { await cmdReview(args.slice(1)); return; }
   if (cmd === 'ship')     { await cmdShip(); return; }
+  if (cmd === 'pr')       { await cmdPR(args.slice(1)); return; }
   if (cmd === 'status')   { await cmdStatus(args.slice(1)); return; }
   if (cmd === 'hot')      { cmdHot(args[1]); return; }
   if (cmd === 'cool')     { cmdCool(args[1]); return; }
@@ -5715,7 +6038,7 @@ fi
   // If cmd is not a recognized subcommand, treat the entire arg list as a task.
   // e.g. `dual-brain fix failing tests` → same as `dual-brain go "fix failing tests"`
   const KNOWN_COMMANDS = new Set([
-    'init', 'install', 'auth', 'go', 'do', 'plan', 'ship', 'think', 'review', 'status', 'hot', 'cool',
+    'init', 'install', 'uninstall', 'auth', 'go', 'do', 'plan', 'ship', 'think', 'review', 'pr', 'status', 'hot', 'cool',
     'remember', 'forget', 'break-glass', 'specialists', 'search', 'shell-hook', 'watch',
     '--help', '-h', '--version', '-v',
     ...Object.keys(loadSpecialistRegistry()),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -23,7 +23,11 @@
     "./calibration": "./src/calibration.mjs",
     "./models": "./src/models.mjs",
     "./prompt-intel": "./src/prompt-intel.mjs",
-    "./replit": "./src/replit.mjs"
+    "./replit": "./src/replit.mjs",
+    "./continuity": "./src/continuity.mjs",
+    "./checkpoint": "./src/checkpoint.mjs",
+    "./pr-agent": "./src/pr-agent.mjs",
+    "./ci-triage": "./src/ci-triage.mjs"
   },
   "keywords": [
     "claude-code",
@@ -86,6 +90,10 @@
     "src/prompt-intel.mjs",
     "src/replit.mjs",
     "src/fx.mjs",
+    "src/continuity.mjs",
+    "src/checkpoint.mjs",
+    "src/ci-triage.mjs",
+    "src/pr-agent.mjs",
     "bin/*.mjs",
     "hooks/enforce-tier.mjs",
     "hooks/cost-logger.mjs",

package/src/awareness.mjs

@@ -49,8 +49,6 @@ function detectContainerType() {
 
 function scanSecrets() {
   const keys = [
-    'OPENAI_API_KEY',
-    'ANTHROPIC_API_KEY',
     'NPM_TOKEN',
     'DATABASE_URL',
     'GITHUB_TOKEN',
@@ -282,8 +280,6 @@ export function formatEnvironment(report) {
   if (toolEntries.length) lines.push(`Tools: ${toolEntries.join('  ')}`);
 
   const secretMap = {
-    OPENAI_API_KEY: 'OpenAI',
-    ANTHROPIC_API_KEY: 'Anthropic',
     NPM_TOKEN: 'npm',
     GITHUB_TOKEN: 'GitHub',
     DATABASE_URL: 'PostgreSQL',
@@ -335,8 +331,6 @@ export function getCapabilitySummary(report) {
   if (report.tools.gh?.available) caps.push('github-cli');
   if (report.tools.rg?.available) caps.push('ripgrep');
 
-  if (report.secrets.OPENAI_API_KEY) caps.push('openai-key');
-  if (report.secrets.ANTHROPIC_API_KEY) caps.push('anthropic-key');
 
   if (report.replitTools.installed) {
     for (const c of report.replitTools.capabilities) {
@@ -358,3 +352,74 @@ export function invalidateCache() {
   _cache = null;
   _cacheTime = 0;
 }
+
+// ─── Ambiguity Detection ──────────────────────────────────────────────────────
+
+const TECHNICAL_TERMS = /\b(fix|bug|error|test|deploy|refactor|import|export|function|class|module|api|endpoint|auth|token|database|query|schema|migration|build|lint|type|interface|component|route|handler|middleware|config|env|secret|key|file|path|directory|repo|branch|commit|merge|pull|push|install|upgrade|package|dependency|version|release|publish|log|trace|debug|stack|exception|undefined|null|async|await|promise|fetch|request|response|status|server|client|socket|cache|session)\b/i;
+
+/**
+ * Detect whether a prompt is ambiguous and needs clarification before dispatch.
+ *
+ * A prompt is considered ambiguous when ALL of the following are true:
+ *   1. It is very short (under 4 words)
+ *   2. No file context is provided
+ *   3. It lacks specific technical terms that narrow the intent
+ *
+ * @param {string} prompt — the user's raw prompt
+ * @param {{ files?: string[] }} [context] — optional context (e.g. file paths)
+ * @returns {{ isAmbiguous: boolean, reason: string|null }}
+ */
+export function detectAmbiguity(prompt, context = {}) {
+  if (!prompt || typeof prompt !== 'string') {
+    return { isAmbiguous: true, reason: 'missing context: empty prompt' };
+  }
+
+  const words = prompt.trim().split(/\s+/).filter(Boolean);
+  const isTooShort = words.length < 4;
+  const hasFileContext = Array.isArray(context?.files) && context.files.length > 0;
+  const hasTechnicalTerms = TECHNICAL_TERMS.test(prompt);
+
+  if (isTooShort && !hasFileContext && !hasTechnicalTerms) {
+    return {
+      isAmbiguous: true,
+      reason: `unclear: prompt is vague ("${prompt.trim()}") — missing context about what to change and where`,
+    };
+  }
+
+  return { isAmbiguous: false, reason: null };
+}
+
+/**
+ * Detect whether a user prompt is too vague to act on confidently.
+ *
+ * Checks for:
+ *   - Very short prompts (under 10 chars)
+ *   - No file paths, function names, or specific identifiers
+ *   - Pronoun-only references without antecedents ("fix that thing", "change it")
+ *
+ * @param {string} prompt — the user's raw prompt
+ * @returns {{ ambiguous: boolean, reason: string|null, confidence: number }}
+ */
+export function isAmbiguous(prompt) {
+  if (!prompt || typeof prompt !== 'string') return { ambiguous: true, reason: 'empty-prompt', confidence: 1.0 };
+
+  const trimmed = prompt.trim();
+  if (trimmed.length < 10) return { ambiguous: true, reason: 'too-short', confidence: 0.9 };
+
+  // Check for file paths, function names, specific identifiers
+  const hasSpecifics = /[a-zA-Z_]\w*\.(mjs|js|ts|tsx|jsx|py|go|rs|java|rb|css|html|json|yaml|yml|md|sh)/.test(trimmed)
+    || /[a-zA-Z_]\w*\(\)/.test(trimmed)  // function calls
+    || /`[^`]+`/.test(trimmed)            // backtick-quoted identifiers
+    || /"[^"]{3,}"/.test(trimmed)         // quoted strings
+    || /\b(line|function|class|method|variable|module|component|endpoint|route|table|column)\s+\w+/i.test(trimmed);
+
+  // Vague pronoun patterns
+  const vaguePatterns = /^(fix|change|update|do|make|help|look at|check)\s+(this|that|it|the thing|stuff|things?)$/i;
+  if (vaguePatterns.test(trimmed)) return { ambiguous: true, reason: 'vague-reference', confidence: 0.85 };
+
+  if (!hasSpecifics && trimmed.split(/\s+/).length < 5) {
+    return { ambiguous: true, reason: 'lacks-specifics', confidence: 0.7 };
+  }
+
+  return { ambiguous: false, reason: null, confidence: 0.1 };
+}