dual-brain 0.2.30 → 0.3.0

package/src/envelope.mjs

@@ -1,139 +0,0 @@
-// envelope.mjs — Dispatch envelopes that carry understanding to workers.
-//
-// Instead of workers getting bare instructions ("edit file X, add Y"),
-// they get an envelope containing:
-// 1. Context preamble — narrative excerpt explaining the "why"
-// 2. Contract — the typed task (objective, scope, acceptance criteria)
-// 3. Preventions — predicted failure modes and how to avoid them
-// 4. Debrief format — how to report back
-//
-// This is the difference between "do this thing" and "here's where we are,
-// here's why this matters, here's what to do, here's what to watch for."
-
-import * as narrative from './narrative.mjs';
-
-/**
- * @typedef {object} Envelope
- * @property {string} preamble - Narrative context for the worker
- * @property {string} contract - The actual task specification
- * @property {string} preventions - Predicted failure modes and mitigations
- * @property {string} debriefFormat - How to report back
- * @property {string} full - Complete prompt ready to send
- */
-
-/**
- * Build a dispatch envelope for a worker agent.
- *
- * @param {object} agentSpec - From wave-planner
- * @param {string} agentSpec.objective - What to accomplish
- * @param {string[]} agentSpec.scope - Files/areas in scope
- * @param {string} agentSpec.tier - Worker tier (execute, search, review, etc)
- * @param {object} opts
- * @param {string} opts.preventions - From predictive.mjs
- * @param {string} opts.debriefInstruction - From debrief.mjs
- * @param {string} opts.inboxBrief - Messages for this worker
- * @param {object} opts.contract - Additional contract fields (acceptance criteria, risk, allowed ops)
- * @returns {Envelope}
- */
-export function build(agentSpec, opts = {}) {
-  const { preventions, debriefInstruction, inboxBrief, contract } = opts;
-
-  // Get narrative excerpt — the "being in the song" piece
-  const preamble = _buildPreamble(agentSpec);
-
-  // Build contract section
-  const contractText = _buildContract(agentSpec, contract);
-
-  // Assemble full prompt
-  const sections = [];
-
-  if (preamble) {
-    sections.push(`## Context\n${preamble}`);
-  }
-
-  sections.push(`## Task\n${contractText}`);
-
-  if (inboxBrief) {
-    sections.push(`## Notes\n${inboxBrief}`);
-  }
-
-  if (preventions) {
-    sections.push(`## Watch For\n${preventions}`);
-  }
-
-  if (debriefInstruction) {
-    sections.push(`## When Done\n${debriefInstruction}`);
-  }
-
-  const full = sections.join('\n\n');
-
-  return {
-    preamble,
-    contract: contractText,
-    preventions: preventions || '',
-    debriefFormat: debriefInstruction || '',
-    full,
-  };
-}
-
-/**
- * Build a lightweight envelope for simple/fast dispatches.
- * Used when the task is straightforward and doesn't need full context.
- *
- * @param {string} objective
- * @param {string[]} scope
- * @returns {string} Simple prompt string
- */
-export function buildLight(objective, scope = []) {
-  const parts = [objective];
-  if (scope.length > 0) {
-    parts.push(`Scope: ${scope.join(', ')}`);
-  }
-  return parts.join('\n');
-}
-
-// ── Internal ──────────────────────────────────────────────────────────────────
-
-function _buildPreamble(agentSpec) {
-  const narr = narrative.excerpt(400);
-  if (!narr) return '';
-
-  // Tailor the preamble based on tier
-  const tier = (agentSpec.tier || '').toLowerCase();
-
-  if (tier === 'search' || tier === 'recon') {
-    // Search agents need less context, more focus on what to look for
-    return narr.length > 200 ? narr.slice(-200) : narr;
-  }
-
-  // Implementation agents get fuller context
-  return narr;
-}
-
-function _buildContract(agentSpec, extra = {}) {
-  const parts = [];
-
-  parts.push(agentSpec.objective);
-
-  if (agentSpec.scope?.length) {
-    parts.push(`\nScope: ${agentSpec.scope.join(', ')}`);
-  }
-
-  if (extra?.acceptanceCriteria) {
-    parts.push(`\nDone when: ${extra.acceptanceCriteria}`);
-  }
-
-  if (extra?.risk) {
-    parts.push(`\nRisk level: ${extra.risk}`);
-  }
-
-  if (extra?.allowedOps) {
-    parts.push(`\nAllowed: ${extra.allowedOps.join(', ')}`);
-  }
-
-  if (agentSpec.conditionalPivot) {
-    parts.push(`\nConditional: if ${agentSpec.conditionalPivot.if} → ${agentSpec.conditionalPivot.then}`);
-  }
-
-  return parts.join('');
-}

package/src/failure-memory.mjs

@@ -1,178 +0,0 @@
-#!/usr/bin/env node
-/**
- * failure-memory.mjs — Track task failures and enable automatic escalation.
- *
- * Exports: recordFailure, checkFailureHistory, formatEscalation,
- *          clearFailures, getFailureStats
- */
-
-import { readFileSync, appendFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-
-const STOP_WORDS = new Set(['the','a','an','is','in','on','at','to','for','of','and','or','with','this','that','it','be','was','are','were','has','have','had','do','does','did','not','from','by','as','if','but','we','i','you']);
-const WINDOW_48H = 48 * 60 * 60 * 1000;
-
-const DEPTH_ORDER = ['low', 'medium', 'high', 'ultra'];
-const MODEL_ORDER = ['haiku', 'sonnet', 'opus'];
-
-function failuresPath(cwd) {
-  const dir = join(cwd, '.dualbrain');
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  return join(dir, 'failures.jsonl');
-}
-
-function categorizeError(error = '') {
-  const e = error.toLowerCase();
-  if (/test|assert|expect/.test(e))             return 'test-failure';
-  if (/timeout|timed out/.test(e))              return 'timeout';
-  if (/syntax|parse|unexpected token/.test(e))  return 'syntax-error';
-  if (/permission|eacces/.test(e))              return 'permission-error';
-  if (/not found|enoent/.test(e))               return 'not-found';
-  return 'unknown';
-}
-
-function tokenize(text = '') {
-  return text.toLowerCase().split(/\W+/).filter(w => w.length > 2 && !STOP_WORDS.has(w));
-}
-
-function similarity(promptA, promptB, filesA = [], filesB = []) {
-  const wordsA = new Set(tokenize(promptA));
-  const wordsB = new Set(tokenize(promptB));
-  if (!wordsA.size && !wordsB.size) return 0;
-  const shared = [...wordsA].filter(w => wordsB.has(w)).length;
-  const wordScore = shared / Math.max(wordsA.size, wordsB.size);
-  const sharedFiles = filesA.some(f => filesB.includes(f));
-  return sharedFiles ? Math.max(wordScore, 0.5) : wordScore;
-}
-
-function readFailures(cwd) {
-  const path = failuresPath(cwd);
-  if (!existsSync(path)) return [];
-  return readFileSync(path, 'utf8')
-    .split('\n')
-    .filter(Boolean)
-    .map(line => { try { return JSON.parse(line); } catch { return null; } })
-    .filter(Boolean);
-}
-
-function writeAll(cwd, records) {
-  writeFileSync(failuresPath(cwd), records.map(r => JSON.stringify(r)).join('\n') + '\n');
-}
-
-function bumpDepth(depth) {
-  const idx = DEPTH_ORDER.indexOf(depth);
-  return idx === -1 || idx >= DEPTH_ORDER.length - 1 ? 'ultra' : DEPTH_ORDER[idx + 1];
-}
-
-function bumpModel(model = '') {
-  const m = model.toLowerCase();
-  const match = MODEL_ORDER.find(k => m.includes(k)) ?? 'sonnet';
-  const idx = MODEL_ORDER.indexOf(match);
-  return idx >= MODEL_ORDER.length - 1 ? `claude-opus-4-5` : `claude-${MODEL_ORDER[idx + 1]}-4-5`;
-}
-
-// ─── Exports ──────────────────────────────────────────────────────────────────
-
-export async function recordFailure(prompt, plan = {}, error = '', cwd = process.cwd()) {
-  const record = {
-    id: randomUUID(),
-    timestamp: Date.now(),
-    prompt,
-    promptWords: tokenize(prompt),
-    model: plan.model ?? null,
-    reasoningDepth: plan.reasoningDepth ?? null,
-    tier: plan.tier ?? null,
-    error: String(error),
-    errorCategory: categorizeError(error),
-    files: plan.files ?? [],
-    escalatedFrom: plan.escalatedFrom ?? null,
-    resolved: false,
-  };
-  appendFileSync(failuresPath(cwd), JSON.stringify(record) + '\n');
-  return record;
-}
-
-export async function checkFailureHistory(prompt, files = [], cwd = process.cwd()) {
-  const cutoff = Date.now() - WINDOW_48H;
-  const all = readFailures(cwd);
-  const recent = all.filter(r => !r.resolved && r.timestamp >= cutoff);
-  const matches = recent
-    .map(r => ({ r, score: similarity(prompt, r.prompt, files, r.files ?? []) }))
-    .filter(({ score }) => score >= 0.4)
-    .sort((a, b) => b.r.timestamp - a.r.timestamp);
-
-  const count = matches.length;
-  const last = matches[0]?.r ?? null;
-
-  const escalation = { recommended: false, fromModel: null, toModel: null, fromDepth: null, toDepth: null, useChallenger: false, reason: '' };
-
-  if (count >= 1) {
-    escalation.recommended = true;
-    escalation.fromModel = last.model;
-    escalation.fromDepth = last.reasoningDepth;
-
-    if (count === 1) {
-      escalation.toDepth = bumpDepth(last.reasoningDepth ?? 'medium');
-      escalation.toModel = last.model;
-      escalation.useChallenger = false;
-      escalation.reason = `1 prior failure on similar task, bumping depth to ${escalation.toDepth}`;
-    } else if (count === 2) {
-      escalation.toDepth = 'ultra';
-      escalation.toModel = last.model?.includes('opus') ? last.model : bumpModel(last.model);
-      escalation.useChallenger = false;
-      escalation.reason = `2 prior failures on similar task, escalating to Opus + ultrathink`;
-    } else {
-      escalation.toDepth = 'ultra';
-      escalation.toModel = last.model?.includes('opus') ? last.model : bumpModel(last.model);
-      escalation.useChallenger = true;
-      escalation.reason = `${count} prior failures on similar task, forcing dual-brain`;
-    }
-  }
-
-  return { hasPriorFailures: count > 0, failureCount: count, lastFailure: last, escalation };
-}
-
-export function formatEscalation(escalation) {
-  if (!escalation?.recommended) return '';
-  const prev = [escalation.fromModel, escalation.fromDepth].filter(Boolean).join(', ') || 'unknown';
-  const next = [escalation.toModel, escalation.toDepth, escalation.useChallenger ? 'GPT challenger' : null].filter(Boolean).join(' + ');
-  return `⚡ Strategy changed\n  Previous: failed (${prev})\n  Escalated: ${next}\n  Reason: ${escalation.reason}`;
-}
-
-export async function clearFailures(prompt, cwd = process.cwd()) {
-  const all = readFailures(cwd);
-  const promptWords = tokenize(prompt);
-  const fakePrompt = promptWords.join(' ');
-  let changed = false;
-  const updated = all.map(r => {
-    if (!r.resolved && similarity(fakePrompt, r.prompt) >= 0.4) {
-      changed = true;
-      return { ...r, resolved: true };
-    }
-    return r;
-  });
-  if (changed) writeAll(cwd, updated);
-}
-
-export async function getFailureStats(cwd = process.cwd()) {
-  const all = readFailures(cwd);
-  const byCategory = {};
-  let resolved = 0;
-  let escalationSum = 0;
-  let escalationCount = 0;
-
-  for (const r of all) {
-    if (r.resolved) resolved++;
-    byCategory[r.errorCategory] = (byCategory[r.errorCategory] ?? 0) + 1;
-    if (r.escalatedFrom) { escalationSum++; escalationCount++; }
-  }
-
-  return {
-    total: all.length,
-    resolved,
-    unresolved: all.length - resolved,
-    byCategory,
-    avgEscalationsToResolve: escalationCount ? +(escalationSum / escalationCount).toFixed(2) : 0,
-  };
-}

package/src/fx.mjs

@@ -1,276 +0,0 @@
-// fx.mjs — zero-dependency animated shell effects for dual-brain CLI
-
-const isTTY = process.stdout.isTTY && !process.env.CI;
-const hasColor = isTTY && !process.env.NO_COLOR;
-const isUnicode = process.platform !== 'win32' || process.env.WT_SESSION;
-
-const c = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan: '\x1b[36m',
-  white: '\x1b[37m',
-  gray: '\x1b[90m',
-  bgGreen: '\x1b[42m',
-  bgRed: '\x1b[41m',
-  bgYellow: '\x1b[43m',
-  bgBlue: '\x1b[44m',
-  bgMagenta: '\x1b[45m',
-  clearLine: '\x1b[2K',
-  cursorUp: '\x1b[1A',
-  cursorHide: '\x1b[?25l',
-  cursorShow: '\x1b[?25h',
-  saveCursor: '\x1b[s',
-  restoreCursor: '\x1b[u'
-};
-
-function color(text, ...styles) {
-  if (!hasColor) return text;
-  return styles.join('') + text + c.reset;
-}
-
-export const colors = c;
-
-export function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-export function clearScreen() {
-  if (isTTY) process.stdout.write('\x1b[2J\x1b[H');
-}
-
-export function nl(n = 1) {
-  process.stdout.write('\n'.repeat(n));
-}
-
-export function getMode() {
-  if (process.env.CI) return 'ci';
-  if (!process.stdout.isTTY) return 'plain';
-  if (process.env.DUAL_BRAIN_FX === 'subtle') return 'subtle';
-  return 'full';
-}
-
-export function spinner(text) {
-  const frames = isUnicode ? ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'] : ['|','/','-','\\'];
-  let i = 0, interval = null, currentText = text;
-
-  return {
-    start() {
-      if (!isTTY) { process.stdout.write(currentText + '\n'); return this; }
-      process.stdout.write(c.cursorHide);
-      interval = setInterval(() => {
-        process.stdout.write(`\r${c.clearLine}  ${color(frames[i % frames.length], c.cyan)} ${currentText}`);
-        i++;
-      }, 80);
-      return this;
-    },
-    update(newText) { currentText = newText; return this; },
-    succeed(msg) {
-      if (interval) clearInterval(interval);
-      const sym = isUnicode ? '✓' : '+';
-      process.stdout.write(`\r${c.clearLine}  ${color(sym, c.green)} ${msg || currentText}\n`);
-      if (isTTY) process.stdout.write(c.cursorShow);
-      return this;
-    },
-    fail(msg) {
-      if (interval) clearInterval(interval);
-      const sym = isUnicode ? '✗' : 'x';
-      process.stdout.write(`\r${c.clearLine}  ${color(sym, c.red)} ${msg || currentText}\n`);
-      if (isTTY) process.stdout.write(c.cursorShow);
-      return this;
-    },
-    warn(msg) {
-      if (interval) clearInterval(interval);
-      const sym = isUnicode ? '⚠' : '!';
-      process.stdout.write(`\r${c.clearLine}  ${color(sym, c.yellow)} ${msg || currentText}\n`);
-      if (isTTY) process.stdout.write(c.cursorShow);
-      return this;
-    },
-    stop() {
-      if (interval) clearInterval(interval);
-      process.stdout.write(`\r${c.clearLine}`);
-      if (isTTY) process.stdout.write(c.cursorShow);
-      return this;
-    }
-  };
-}
-
-export function progress(current, total, label = '', width = 30) {
-  const pct = Math.min(1, current / total);
-  if (!isTTY) {
-    process.stdout.write(`${Math.round(pct * 100)}% ${label}\n`);
-    return;
-  }
-  const filled = Math.round(pct * width);
-  const empty = width - filled;
-  const bar = isUnicode
-    ? color('█'.repeat(filled) + '░'.repeat(empty), c.cyan)
-    : color('#'.repeat(filled) + '-'.repeat(empty), c.cyan);
-  const pctStr = String(Math.round(pct * 100)).padStart(3) + '%';
-  process.stdout.write(`\r${c.clearLine}  ${bar}  ${color(pctStr, c.bold)} ${label}`);
-  if (current >= total) process.stdout.write('\n');
-}
-
-export function success(text) {
-  const sym = isUnicode ? '✓' : '+';
-  process.stdout.write(`  ${color(sym, c.green)} ${text}\n`);
-}
-
-export function error(text) {
-  const sym = isUnicode ? '✗' : 'x';
-  process.stdout.write(`  ${color(sym, c.red)} ${text}\n`);
-}
-
-export function warn(text) {
-  const sym = isUnicode ? '⚠' : '!';
-  process.stdout.write(`  ${color(sym, c.yellow)} ${text}\n`);
-}
-
-export function info(text) {
-  const sym = isUnicode ? 'ℹ' : 'i';
-  process.stdout.write(`  ${color(sym, c.blue)} ${text}\n`);
-}
-
-export function dim(text) {
-  process.stdout.write(`${color(text, c.gray)}\n`);
-}
-
-export function step(current, total, text) {
-  if (!isUnicode) {
-    process.stdout.write(`  [${current}/${total}] ${text}\n`);
-    return;
-  }
-  const dots = [];
-  for (let i = 1; i <= total; i++) {
-    if (i < current) dots.push(color('●', c.green));
-    else if (i === current) dots.push(color('●', c.cyan));
-    else dots.push(color('○', c.gray));
-  }
-  process.stdout.write(`  ${dots.join(' ')}  ${color(`Step ${current} of ${total}`, c.bold)} · ${text}\n`);
-}
-
-export function banner(text) {
-  const pkg = 'DUAL-BRAIN';
-  const inner = `  ${isUnicode ? '🧠' : '**'}  ${pkg}  ${text}   `;
-  const width = inner.length + 2;
-  if (!isUnicode || !hasColor) {
-    process.stdout.write(`\n  +${'='.repeat(width - 2)}+\n  | ${inner} |\n  +${'='.repeat(width - 2)}+\n\n`);
-    return;
-  }
-  const top =    `  ╔${'═'.repeat(width)}╗`;
-  const mid =    `  ║${inner}║`;
-  const bot =    `  ╚${'═'.repeat(width)}╝`;
-  process.stdout.write(`\n${color(top, c.cyan, c.bold)}\n${color(mid, c.cyan, c.bold)}\n${color(bot, c.cyan, c.bold)}\n\n`);
-}
-
-export function box(content, options = {}) {
-  const { color: colorName = 'cyan', padding = 1, title = '' } = options;
-  const ansiColor = c[colorName] || c.cyan;
-  const lines = Array.isArray(content) ? content : content.split('\n');
-  const innerWidth = Math.max(...lines.map(l => stripAnsi(l).length), title ? stripAnsi(title).length : 0) + padding * 2;
-
-  function draw(text, ansi) {
-    if (!hasColor) return text;
-    return ansi + text + c.reset;
-  }
-
-  const titleStr = title ? ` ${title} ` : '';
-  const topFill = '─'.repeat(Math.max(0, innerWidth - stripAnsi(titleStr).length));
-  const top = isUnicode
-    ? draw(`┌${titleStr}${'─'.repeat(Math.floor(topFill.length / 2))}${'─'.repeat(Math.ceil(topFill.length / 2))}┐`, ansiColor)
-    : draw(`+${titleStr}${'-'.repeat(topFill.length)}+`, ansiColor);
-  const bot = isUnicode
-    ? draw(`└${'─'.repeat(innerWidth)}┘`, ansiColor)
-    : draw(`+${'-'.repeat(innerWidth)}+`, ansiColor);
-
-  process.stdout.write(`  ${top}\n`);
-  for (const line of lines) {
-    const pad = ' '.repeat(padding);
-    const visible = stripAnsi(line).length;
-    const right = ' '.repeat(Math.max(0, innerWidth - padding - visible));
-    const border = isUnicode ? draw('│', ansiColor) : draw('|', ansiColor);
-    process.stdout.write(`  ${border}${pad}${line}${right}${border}\n`);
-  }
-  process.stdout.write(`  ${bot}\n`);
-}
-
-function stripAnsi(str) {
-  return str.replace(/\x1b\[[0-9;]*m/g, '');
-}
-
-export function gradient(text, fromColor = 196, toColor = 226) {
-  if (!hasColor) return process.stdout.write(text + '\n');
-  const chars = [...text];
-  const result = chars.map((ch, i) => {
-    const t = chars.length <= 1 ? 0 : i / (chars.length - 1);
-    const colorIdx = Math.round(fromColor + t * (toColor - fromColor));
-    return `\x1b[38;5;${colorIdx}m${ch}`;
-  }).join('') + c.reset;
-  process.stdout.write(result + '\n');
-}
-
-export async function celebrate(text) {
-  const sym = isUnicode ? '✨' : '*';
-  if (!isTTY || getMode() === 'ci' || getMode() === 'plain') {
-    process.stdout.write(`  ${sym} ${text} ${sym}\n`);
-    return;
-  }
-  process.stdout.write(`\r${c.clearLine}  ${color(`${sym} ${text} ${sym}`, c.bgGreen, c.bold)}`);
-  await sleep(100);
-  process.stdout.write(`\r${c.clearLine}  ${color(`${sym} ${text} ${sym}`, c.green, c.bold)}\n`);
-}
-
-export async function loadingSequence(steps) {
-  for (const s of steps) {
-    const sp = spinner(s.text).start();
-    await sleep(s.duration || 800);
-    sp.succeed(s.successText || s.text);
-  }
-}
-
-export async function agentDispatch(model, task) {
-  const mode = getMode();
-  if (mode === 'ci' || mode === 'plain') {
-    process.stdout.write(`Dispatching ${model}...\n`);
-    process.stdout.write(`Agent dispatched: ${task}\n`);
-    return;
-  }
-  const sp = spinner(`Dispatching ${color(model, c.cyan)}...`).start();
-  await sleep(mode === 'subtle' ? 0 : 600);
-  sp.succeed(`Agent dispatched: ${task}`);
-}
-
-export async function thinkRound(round, provider, question) {
-  const mode = getMode();
-  const providerLabel = color(provider, c.magenta);
-  const roundLabel = color(`Round ${round}`, c.bold);
-
-  if (mode === 'ci' || mode === 'plain') {
-    process.stdout.write(`Dual-Brain Think · ${roundLabel} · ${provider} analyzing: ${question}\n`);
-    return;
-  }
-
-  const title = `Dual-Brain Think · ${roundLabel}`;
-  const titleVisible = stripAnsi(title);
-  const width = Math.max(titleVisible.length + 4, question.length + 4, 36);
-  const topFill = '─'.repeat(Math.max(0, width - titleVisible.length - 2));
-
-  if (isUnicode && hasColor) {
-    process.stdout.write(`  ${color(`╭─ ${title} ${'─'.repeat(topFill.length)}╮`, c.cyan)}\n`);
-    process.stdout.write(`  ${color('│', c.cyan)} ${isUnicode ? '🤖' : '>>'} ${providerLabel} analyzing...${' '.repeat(Math.max(0, width - 4 - stripAnsi(provider).length - 13))}${color('│', c.cyan)}\n`);
-    process.stdout.write(`  ${color(`╰${'─'.repeat(width)}╯`, c.cyan)}\n`);
-  } else {
-    process.stdout.write(`  +-- ${title} --+\n`);
-    process.stdout.write(`  | ${provider} analyzing: ${question}\n`);
-    process.stdout.write(`  +${'─'.repeat(width + 2)}+\n`);
-  }
-
-  const sp = spinner(`${provider} thinking on: ${question}`).start();
-  await sleep(mode === 'subtle' ? 0 : 900);
-  sp.succeed(`${provider} analysis complete`);
-}