dual-brain 5.0.1 → 6.0.0

package/CLAUDE.md

@@ -98,6 +98,19 @@ Auto mode classifies risk from file paths and adjusts routing in real-time:
 
 Casual natural language → structured work. The vibe coding system translates informal requests into properly routed, risk-classified, quality-gated work.
 
+**Wave Orchestrator** — the primary way to run multi-step work:
+```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>
+node .claude/hooks/wave-orchestrator.mjs --show <manifestId>
+```
+The wave orchestrator decomposes intent, plans dependency-aware waves, assigns file ownership to prevent conflicts, dispatches agents with transparent routing tables, checkpoints between waves, and supports resume on failure. Every dispatch shows: provider, model, tier, effort, agent type, and routing reason.
+
+Manifests persist to `.dualbrain/manifests/`, checkpoints to `.dualbrain/checkpoints/`.
+
+Also available via the control panel: `[w]` Vibe workflow.
+
 **Intent compiler** — decompose multi-task requests:
 ```bash
 node .claude/hooks/vibe-router.mjs "fix the login bug and also update the nav"
@@ -119,13 +132,31 @@ node .claude/hooks/vibe-memory.mjs --infer                      # preference sug
 ```
 Tracks preferred profile, risk tolerance, active threads, and learns from usage patterns.
 
+## Budget Balancer (Token-Based)
+
+The budget balancer tracks real token usage against actual subscription limits.
+
+**Subscription tiers** (configured in `orchestrator.json` → `subscriptions.*.plan`):
+- Claude: Pro $20, Max x5 $100, Max x20 $200
+- ChatGPT: Plus $20, Pro $100, Pro $200
+
+**Two rolling windows**: 5-hour and 7-day weekly. The higher pressure is the binding constraint.
+
+**Token tracking**: Uses actual `input_tokens + output_tokens` from usage logs when available, falls back to conservative estimates only when logs lack token data.
+
+```bash
+node .claude/hooks/budget-balancer.mjs
+```
+Shows per-provider per-tier pressure with real token counts (e.g., `136.0K/350.0K`), weekly pressure when binding, and routing recommendation with reason.
+
 ## Available Tools
 
+- `node .claude/hooks/wave-orchestrator.mjs "..."` — auto-wave orchestrator (plan, dispatch, test, review)
 - `node .claude/hooks/vibe-router.mjs "..."` — decompose casual requests into structured work
 - `node .claude/hooks/plan-generator.mjs --utterance "..."` — generate execution plans
 - `node .claude/hooks/vibe-memory.mjs` — persistent preferences and work threads
 - `node .claude/hooks/cost-report.mjs` — activity and cost estimates
 - `node .claude/hooks/health-check.mjs` — verify system health
-- `node .claude/hooks/budget-balancer.mjs` — provider balance status
+- `node .claude/hooks/budget-balancer.mjs` — provider balance (token-based, real limits)
 - `node .claude/hooks/decision-ledger.mjs` — routing outcome insights
 - `node .claude/hooks/test-orchestrator.mjs` — run self-tests (40 tests)

package/bin/dual-brain.mjs

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+// dual-brain — CLI entry point. Commands: init, go, status, remember, forget
+
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+
+import {
+  ensureProfile, loadProfile, runOnboarding,
+  rememberPreference, forgetPreference, getActivePreferences,
+  getAvailableProviders, isSoloBrain, getHeadModel,
+} from '../src/profile.mjs';
+
+import { detectTask } from '../src/detect.mjs';
+
+import {
+  decideRoute, getAvailableModels, estimateBudgetPressure,
+} from '../src/decide.mjs';
+
+import { dispatch, detectRuntime, dispatchDualBrain } from '../src/dispatch.mjs';
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_PATH  = join(__dirname, '..', 'package.json');
+
+function readVersion() {
+  try { return JSON.parse(readFileSync(PKG_PATH, 'utf8')).version; } catch { return '0.0.0'; }
+}
+function flag(args, name) { const i = args.indexOf(name); return i !== -1 ? (args[i + 1] ?? true) : null; }
+function err(msg) { process.stderr.write(`Error: ${msg}\n`); process.exit(1); }
+
+function printHelp() {
+  console.log(`
+dual-brain <command> [options]
+
+Commands:
+  init                      First-time setup (providers, plans, optimization)
+  go "task description"     Detect → decide → dispatch a task
+    --dry-run               Show routing decision without executing
+    --files a.mjs,b.mjs     Provide file context for risk classification
+  status                    Provider health, budget pressure, available models
+  remember "preference"     Save a project-scoped preference
+  forget "preference"       Remove a preference by fuzzy match
+
+Options:
+  --version                 Print version
+  --help                    Show this help
+`.trim());
+}
+
+// ─── Commands ─────────────────────────────────────────────────────────────────
+
+async function cmdInit() {
+  const profile = await runOnboarding({ interactive: true });
+  const rt = await detectRuntime();
+  const providers = getAvailableProviders(profile);
+  const providerSummary = providers.length
+    ? providers.map(p => `${p.name === 'claude' ? 'Claude' : 'OpenAI'} (${p.plan})`).join(', ')
+    : 'none';
+  console.log(`Profile saved. Providers: ${providerSummary}. Mode: ${profile.mode}. Runtime: ${rt.runtime}`);
+}
+
+async function cmdGo(args) {
+  const dryRun  = args.includes('--dry-run');
+  const filesRaw = flag(args, '--files');
+  const files   = filesRaw && typeof filesRaw === 'string'
+    ? filesRaw.split(',').map(f => f.trim()).filter(Boolean)
+    : [];
+
+  // prompt is the first non-flag argument (or value after --dry-run which is boolean)
+  const prompt = args.find(a => !a.startsWith('--') && a !== (filesRaw ?? ''));
+  if (!prompt) err('Usage: dual-brain go "task description" [--dry-run] [--files a,b]');
+
+  const cwd     = process.cwd();
+  const profile = await ensureProfile(cwd);
+  const detection = detectTask({ prompt, files });
+
+  // Print the one-sentence classification
+  console.log(detection.explanation);
+
+  const decision = decideRoute({ profile, detection, cwd });
+
+  // Print routing table
+  console.log(`  provider   : ${decision.provider}`);
+  console.log(`  model      : ${decision.model}${decision.effort ? ' (' + decision.effort + ')' : ''}`);
+  console.log(`  tier       : ${decision.tier}`);
+  console.log(`  dual-brain : ${decision.dualBrain ? 'yes' : 'no'}`);
+  console.log(`  reason     : ${decision.explanation}`);
+
+  if (dryRun) {
+    console.log('\n(dry-run — not executing)');
+    return;
+  }
+
+  console.log('\nDispatching...');
+  let result;
+  if (decision.dualBrain) {
+    result = await dispatchDualBrain({ decision, prompt, files, cwd });
+    console.log(`\nConsensus: ${result.consensus}`);
+    if (result.claude?.summary) console.log(`Claude : ${result.claude.summary}`);
+    if (result.openai?.summary) console.log(`OpenAI : ${result.openai.summary}`);
+  } else {
+    result = await dispatch({ decision, prompt, files, cwd });
+    const statusLine = result.status === 'completed' ? 'Done' : `Failed (exit ${result.exitCode})`;
+    console.log(`\n${statusLine} in ${(result.durationMs / 1000).toFixed(1)}s`);
+    if (result.summary) console.log(result.summary);
+    if (result.error)   process.stderr.write(`${result.error}\n`);
+    if (result.status !== 'completed') process.exit(1); }
+}
+
+async function cmdStatus() {
+  const cwd     = process.cwd();
+  const profile = loadProfile(cwd);
+  const rt      = await detectRuntime();
+  const providers = getAvailableProviders(profile);
+  const pressure  = estimateBudgetPressure(profile, cwd);
+  const available = getAvailableModels(profile);
+  const prefs     = getActivePreferences(cwd);
+
+  console.log('=== Dual-Brain Status ===\n');
+
+  // Providers
+  console.log('Providers:');
+  if (providers.length === 0) {
+    console.log('  (none configured — run: dual-brain init)');
+  } else {
+    for (const p of providers) {
+      const label = p.name === 'claude' ? 'Claude' : 'OpenAI';
+      const pct   = Math.round((pressure[p.name] ?? 0) * 100);
+      console.log(`  ${label}  plan=${p.plan}  budget=${pct}% used`);
+    }
+  }
+
+  // Models
+  console.log('\nAvailable models:');
+  if (available.claude.length) console.log(`  Claude : ${available.claude.join(', ')}`);
+  if (available.openai.length) console.log(`  OpenAI : ${available.openai.join(', ')}`);
+
+  // Head model
+  console.log(`\nHead model : ${getHeadModel(profile)}`);
+  console.log(`Mode       : ${profile.mode}`);
+  console.log(`Solo brain : ${isSoloBrain(profile) ? 'yes' : 'no'}`);
+
+  // Runtime
+  console.log('\nRuntime:');
+  console.log(`  claude CLI : ${rt.claudeAvailable ? 'available' : 'not found'}`);
+  console.log(`  codex CLI  : ${rt.codexAvailable  ? 'available' : 'not found'}`);
+  console.log(`  detected   : ${rt.runtime}`);
+
+  // Preferences
+  console.log(`\nPreferences: ${prefs.length ? '' : '(none)'}`);
+  for (const p of prefs) console.log(`  [${p.scope}] ${p.text}`);
+
+  // Update check
+  try {
+    const localVer  = readVersion();
+    const remoteVer = execSync('npm view dual-brain version 2>/dev/null', { timeout: 5000 }).toString().trim();
+    if (remoteVer && remoteVer !== localVer) {
+      console.log(`\nUpdate available: npm i -g dual-brain@latest  (${localVer} → ${remoteVer})`);
+    }
+  } catch { /* network unavailable — skip */ }
+}
+
+function cmdRemember(text) {
+  if (!text) err('Usage: dual-brain remember "preference text"');
+  const profile = rememberPreference(text, { scope: 'project', cwd: process.cwd() });
+  console.log(`Preference saved. Total active: ${profile.preferences.filter(p => p.enabled).length}`);
+}
+
+function cmdForget(text) {
+  if (!text) err('Usage: dual-brain forget "preference text"');
+  forgetPreference(text, process.cwd());
+  console.log('Preference removed (if matched).');
+}
+
+// ─── Entry point ─────────────────────────────────────────────────────────────
+
+async function main() {
+  const args = process.argv.slice(2);
+  const cmd  = args[0];
+
+  if (!cmd || cmd === '--help' || cmd === '-h') { printHelp(); return; }
+  if (cmd === '--version' || cmd === '-v')      { console.log(readVersion()); return; }
+
+  if (cmd === 'init')     { await cmdInit(); return; }
+  if (cmd === 'go')       { await cmdGo(args.slice(1)); return; }
+  if (cmd === 'status')   { await cmdStatus(); return; }
+  if (cmd === 'remember') { cmdRemember(args[1]); return; }
+  if (cmd === 'forget')   { cmdForget(args[1]); return; }
+
+  process.stderr.write(`Unknown command: ${cmd}\nRun "dual-brain --help" for usage.\n`);
+  process.exit(1);
+}
+
+main().catch(e => {
+  process.stderr.write(`${e.message}\n`);
+  process.exit(1);
+});