dual-brain 3.9.0 → 4.0.1

package/CLAUDE.md

@@ -64,18 +64,49 @@ Profile persists to `.claude/dual-brain.profile.json` (gitignored).
 Switch profiles: `npx dual-brain mode cost-saver`
 Check status: `npx dual-brain status`
 
+Natural language aliases work everywhere: "go aggressive", "be careful", "cheap mode", "fast", "thorough", "smart". The system strips prefixes like "go"/"be"/"use" and resolves to the canonical profile name.
+
 ## Adaptive Routing (Auto Mode)
 
 Auto mode classifies risk from file paths and adjusts routing in real-time:
 
 - **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
+- **Failure detection**: 2+ failures on same prompt in 2 hours → auto-escalate tier or trigger dual-brain. Uses time-weighted decay (recent failures count more) and ledger pruning for entries >24hrs.
 - **Provider balance**: Routes to underused provider when one subscription is hot
+- **Burst awareness**: Suppresses duplicate warnings and balance hints during agent waves (3+ agents in 90s)
+
+## Vibe Coding
+
+Casual natural language → structured work. The vibe coding system translates informal requests into properly routed, risk-classified, quality-gated work.
+
+**Intent compiler** — decompose multi-task requests:
+```bash
+node .claude/hooks/vibe-router.mjs "fix the login bug and also update the nav"
+```
+Returns structured tasks with tier/risk classification, complexity level, quality gates, and wave strategy.
+
+**Plan generator** — Steve-style 3-part markdown plans:
+```bash
+node .claude/hooks/plan-generator.mjs --utterance "..." [--write]
+```
+Generates: (1) dependency-ordered task table, (2) user stories + edge cases, (3) questions with suggested answers. Pass `--write` to save to `.claude/plans/`.
+
+**Durable memory** — preferences persist across sessions:
+```bash
+node .claude/hooks/vibe-memory.mjs                              # show state
+node .claude/hooks/vibe-memory.mjs --set preferences.risk_tolerance=careful
+node .claude/hooks/vibe-memory.mjs --threads                    # active work
+node .claude/hooks/vibe-memory.mjs --infer                      # preference suggestions
+```
+Tracks preferred profile, risk tolerance, active threads, and learns from usage patterns.
 
 ## Available Tools
 
+- `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/decision-ledger.mjs` — routing outcome insights
-- `node .claude/hooks/test-orchestrator.mjs` — run self-tests
+- `node .claude/hooks/test-orchestrator.mjs` — run self-tests (40 tests)

package/README.md

@@ -51,10 +51,35 @@ npx -y dual-brain
 
 **Dual-brain** is recommended automatically for high-risk decisions — hooks detect the risk level and suggest dual-brain analysis, where both providers think on the same problem independently.
 
+## Vibe Coding
+
+Speak naturally. The orchestrator handles the structure.
+
+```bash
+# Decompose a casual request into structured work
+node .claude/hooks/vibe-router.mjs "fix the login bug and also update the nav"
+
+# Generate a Steve-style execution plan
+node .claude/hooks/plan-generator.mjs --utterance "refactor the auth flow" --write
+
+# Switch profiles with natural language
+npx dual-brain mode "go aggressive"
+npx dual-brain mode "be careful"
+npx dual-brain mode "cheap"
+
+# Check persistent preferences and work threads
+node .claude/hooks/vibe-memory.mjs --threads
+```
+
+The vibe-router splits multi-task requests, classifies risk, assigns tiers, and recommends quality gates. The plan-generator produces 3-part plans (dependency-ordered tasks, user stories, questions with suggested answers). Vibe-memory learns your preferences over time.
+
 ## Scripts
 
 | Script | Purpose |
 |--------|---------|
+| `hooks/vibe-router.mjs` | Decompose casual language into structured work orders |
+| `hooks/plan-generator.mjs` | Generate Steve-style 3-part execution plans |
+| `hooks/vibe-memory.mjs` | Persistent preferences, work threads, preference inference |
 | `hooks/cost-report.mjs` | Activity & cost estimates by model tier |
 | `hooks/dual-brain-review.mjs` | Send git diff to GPT for independent review |
 | `hooks/dual-brain-think.mjs` | Dual-perspective analysis on architecture decisions |
@@ -63,7 +88,7 @@ npx -y dual-brain
 | `hooks/gpt-work-dispatcher.mjs` | Dispatch execution tasks to GPT via Codex CLI |
 | `hooks/session-report.mjs` | Session-end summary: activity, compliance, quality |
 | `hooks/health-check.mjs` | Verify all hooks and dependencies are working |
-| `hooks/test-orchestrator.mjs` | Self-test harness (39 tests) |
+| `hooks/test-orchestrator.mjs` | Self-test harness (40 tests) |
 | `hooks/setup-wizard.mjs` | Interactive config (optional — for custom plans) |
 | `hooks/install-git-hooks.mjs` | Git pre-commit hook for quality gate |
 

package/hooks/enforce-tier.mjs

@@ -226,11 +226,11 @@ try {
     if (burstMode) {
       // In burst mode, only warn on exact hash matches (same description+prompt)
       if (duplicate.prompt_hash === promptHash) {
-        duplicateWarning = `**[Wave] [Duplicate Warning]** A similar agent task was dispatched ${minutesAgo} minute${minutesAgo !== 1 ? 's' : ''} ago. Reuse the prior result unless the scope changed.`;
+        duplicateWarning = `Heads up — a similar task ran ${minutesAgo} minute${minutesAgo !== 1 ? 's' : ''} ago (wave detected). Reuse that result if the scope hasn't changed.`;
       }
       // Otherwise suppress — similar-but-different agents in a wave are expected
     } else {
-      duplicateWarning = `**[Duplicate Warning]** A similar agent task was dispatched ${minutesAgo} minute${minutesAgo !== 1 ? 's' : ''} ago. Reuse the prior result unless the scope changed.`;
+      duplicateWarning = `Heads up — a similar task ran ${minutesAgo} minute${minutesAgo !== 1 ? 's' : ''} ago. Reuse that result if the scope hasn't changed.`;
     }
   }
 
@@ -278,10 +278,10 @@ try {
     ].filter(Boolean);
 
     if (detectedTiers.length > 1) {
-      const splitMsg = `**[Tier Enforcer]** This spans **${detectedTiers.join(' + ')}** work. Consider splitting: ` +
+      const splitMsg = `This spans ${detectedTiers.join(' + ')} work. Consider splitting: ` +
         (hasSearch ? 'search first (haiku), ' : '') +
         (hasExecute ? 'then execute edits (sonnet), ' : '') +
-        (hasThink ? 'keep planning/review on think tier (opus).' : '');
+        (hasThink ? 'keep planning/review on the main session (opus).' : '');
       const fullMsg = prependWarnings(splitMsg.replace(/, $/, '.'));
       logRecommendation({
         tier: detectedTiers.join('+'),
@@ -310,8 +310,8 @@ try {
   if ((riskResult.level === 'critical' || riskResult.level === 'high') && tier !== 'think') {
     tier = 'think';
     autoStatus = riskResult.level === 'critical'
-      ? `Dual-brain: dual-brain review recommended — ${riskResult.reason.split(':')[0]} detected`
-      : `Dual-brain: promoting to think tier — ${riskResult.reason.split(':')[0]}`;
+      ? `This touches ${riskResult.reason.split(':')[0].toLowerCase()} — recommending dual-brain review for safety.`
+      : `Promoting to think tier — this is ${riskResult.reason.split(':')[0].toLowerCase()}.`;
   }
 
   // Failure loop detection
@@ -320,11 +320,11 @@ try {
   if (failureCheck.isLoop) {
     if (failureCheck.suggestion === 'promote_tier' && tier === 'execute') {
       tier = 'think';
-      autoStatus = 'Dual-brain: escalating to think tier — previous attempt failed';
+      autoStatus = 'Escalating to think tier — this has failed before, let\'s take a different approach.';
     } else if (failureCheck.suggestion === 'escalate_to_dual_brain') {
-      autoStatus = 'Dual-brain: dual-brain review recommended — repeated failures detected';
+      autoStatus = 'Repeated failures detected — recommending dual-brain review to diagnose the issue.';
     }
-    failureMessage = `**[Failure Loop]** ${failureCheck.count} failed attempts in 2hrs. Consider: \`node .claude/hooks/dual-brain-think.mjs --question "why is this failing?"\``;
+    failureMessage = `⚠️ This has failed ${failureCheck.count} times in the last 2 hours. Consider a dual-brain think session to diagnose the root cause.`;
   }
 
   // Apply profile-driven tier adjustments
@@ -344,7 +344,7 @@ try {
       const biasThreshold = profileSettings.bias >= 0 ? 10 : 20;
       if (balance && balance.claudeCalls > balance.openaiCalls * 2 && balance.claudeCalls > biasThreshold) {
         const dispatchModel = tier === 'think' ? 'gpt-5.5' : tier === 'execute' ? 'gpt-5.4' : 'gpt-4.1-mini';
-        balanceHint = `\n\n💡 **Balance tip:** Claude has ${balance.claudeCalls} ${tier} calls vs OpenAI's ${balance.openaiCalls} in the last 5hrs. Consider dispatching isolated work to GPT: \`node .claude/hooks/gpt-work-dispatcher.mjs --task "..." --model ${dispatchModel}\``;
+        balanceHint = `\n\n💡 Claude is handling most work right now (${balance.claudeCalls} ${tier} calls vs ${balance.openaiCalls} GPT). For isolated tasks, consider routing to GPT to balance subscriptions.`;
       }
     }
   }
@@ -374,8 +374,7 @@ try {
     // If we get here, a non-think model is being used for think work
     const thinkBestFor = intelligence[expected || 'opus']?.best_for;
     const thinkBestForSuffix = thinkBestFor ? ` (best for: ${thinkBestFor})` : '';
-    const msg = `**[Tier Enforcer]** This looks like **think** work (architecture/review/planning). ` +
-      `Don't send it to "${currentModel}" — keep it on the main session (${expected || 'opus'}${thinkBestForSuffix}) for best results.`;
+    const msg = `This looks like think-level work (architecture/review/planning) — better kept on the main session (${expected || 'opus'}${thinkBestForSuffix}) rather than delegated to ${currentModel}.`;
     logRecommendation({
       tier,
       recommended: expected,
@@ -406,8 +405,7 @@ try {
     const savings = tier === 'search' ? 'Haiku is 19x cheaper than Opus for read-only lookups.' : 'Sonnet is 5x cheaper than Opus for implementation work.';
     const bestFor = intelligence[expected]?.best_for;
     const bestForSuffix = bestFor ? ` (best for: ${bestFor})` : '';
-    const msg = `**[Tier Enforcer]** This looks like **${tier}** work. ` +
-      `Use \`model: "${expected}"\`${bestForSuffix} instead of "${currentModel || 'opus (inherited)'}". ${savings}`;
+    const msg = `This looks like ${tier} work — use ${expected}${bestForSuffix} instead of ${currentModel || 'opus (inherited)'}. ${savings}`;
     logRecommendation({
       tier,
       recommended: expected,