dual-brain 0.2.30 → 0.3.0

package/src/signal.mjs

@@ -1,115 +0,0 @@
-// signal.mjs — Compound outcome signal scoring
-// Combines multiple weak signals into one reliable reward score.
-
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { execSync } from 'node:child_process';
-
-export const EXPECTED_DURATION_MS = { search: 15000, execute: 45000, think: 30000, review: 40000 };
-
-export function scoreDurationRatio(durationMs, tier) {
-  try {
-    if (durationMs <= 0) return null;
-    const expectedMs = EXPECTED_DURATION_MS[tier] || EXPECTED_DURATION_MS.execute;
-    const ratio = durationMs / expectedMs;
-    if (ratio >= 0.5 && ratio <= 1.5) return 1.0;
-    if (ratio < 0.2) return 0.5;
-    if (ratio > 3.0) return 0.3;
-    if (ratio < 0.5) return 0.5 + ((ratio - 0.2) / (0.5 - 0.2)) * 0.5;
-    // ratio 1.5–3.0
-    return 1.0 - ((ratio - 1.5) / (3.0 - 1.5)) * 0.7;
-  } catch {
-    return null;
-  }
-}
-
-export function measureFileSurvival(outcome, cwd) {
-  try {
-    const files = Array.isArray(outcome.filesChanged)
-      ? outcome.filesChanged
-      : [];
-    if (files.length === 0) return 1.0;
-
-    let changed;
-    try {
-      changed = new Set(
-        execSync('git diff --name-only', { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] })
-          .split('\n')
-          .map(f => f.trim())
-          .filter(Boolean)
-      );
-    } catch {
-      changed = new Set();
-    }
-
-    const survived = files.filter(f => {
-      const abs = join(cwd, f);
-      return existsSync(abs) && !changed.has(f);
-    });
-    return survived.length / files.length;
-  } catch {
-    return null;
-  }
-}
-
-export function scoreOutcome(outcome, context = {}) {
-  try {
-    const tier = outcome.tier ?? 'execute';
-    const signals = [];
-
-    // Signal 1: exit success (weight 0.3)
-    let exitVal;
-    if (outcome.success === true) exitVal = 1.0;
-    else if (outcome.status === 'partial') exitVal = 0.4;
-    else exitVal = 0.0;
-    signals.push({ name: 'exitSuccess', value: exitVal, weight: 0.3 });
-
-    // Signal 2: duration ratio (weight 0.25)
-    const durationMs = outcome.durationMs ?? 0;
-    const durVal = durationMs > 0 ? scoreDurationRatio(durationMs, tier) : null;
-    signals.push({ name: 'durationRatio', value: durVal, weight: 0.25 });
-
-    // Signal 3: token efficiency (weight 0.25)
-    let effVal = null;
-    const filesChanged = outcome.filesChanged ?? 0;
-    const fileCount = Array.isArray(filesChanged) ? filesChanged.length : (typeof filesChanged === 'number' ? filesChanged : 0);
-    if (!(fileCount === 0 && tier === 'think')) {
-      const tokensUsed =
-        outcome.tokensUsed?.output ??
-        (durationMs > 0 ? Math.round(durationMs / 100) : null);
-      if (tokensUsed !== null) {
-        const efficiency = fileCount / Math.max(1, tokensUsed / 1000);
-        if (efficiency > 2) effVal = 1.0;
-        else if (efficiency >= 0.5) effVal = 0.5 + ((efficiency - 0.5) / 1.5) * 0.5;
-        else if (efficiency < 0.1) effVal = 0.2;
-        else effVal = 0.2 + ((efficiency - 0.1) / 0.4) * 0.3;
-      }
-    }
-    signals.push({ name: 'tokenEfficiency', value: effVal, weight: 0.25 });
-
-    // Signal 4: file survival (weight 0.2) — delayed, may be null
-    const survivalVal = context.fileSurvival ?? null;
-    signals.push({ name: 'fileSurvival', value: survivalVal, weight: 0.2 });
-
-    // Compound score with weight redistribution
-    const active = signals.filter(s => s.value !== null);
-    const totalWeight = active.reduce((sum, s) => sum + s.weight, 0);
-    const reward = totalWeight > 0
-      ? active.reduce((sum, s) => sum + (s.value * s.weight / totalWeight), 0)
-      : 0;
-    const confidence = totalWeight;
-
-    return {
-      reward: Math.min(1, Math.max(0, reward)),
-      confidence: Math.min(1, confidence),
-      signals: {
-        exitSuccess: exitVal,
-        durationRatio: durVal,
-        tokenEfficiency: effVal,
-        fileSurvival: survivalVal,
-      },
-    };
-  } catch {
-    return { reward: 0, confidence: 0, signals: { exitSuccess: false, durationRatio: null, tokenEfficiency: null, fileSurvival: null } };
-  }
-}

package/src/simmer.mjs

@@ -1,241 +0,0 @@
-// simmer.mjs — Ideas that aren't tasks yet. They sit, gather heat, and crystallize.
-//
-// The "song" insight: users drop ideas casually. HEAD tends to acknowledge them
-// verbally then move on. The simmer buffer catches these — every idea gets stored
-// with a heat score. Heat rises when: the idea recurs, evidence supports it,
-// adjacent work makes it more relevant, or time passes and it keeps nagging.
-// When heat crosses a threshold, the idea crystallizes into an actionable item
-// and surfaces to HEAD during deliberation.
-
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-const STATE_DIR = join(process.cwd(), '.dualbrain');
-const SIMMER_FILE = join(STATE_DIR, 'simmer.json');
-
-const CRYSTALLIZE_THRESHOLD = 5;
-const MAX_ITEMS = 30;
-const HEAT_DECAY_PER_HOUR = 0.3;
-
-/**
- * @typedef {object} SimmerItem
- * @property {string} id
- * @property {string} idea - The raw idea in prose
- * @property {string} origin - Where it came from (user quote, observation, debrief finding)
- * @property {number} heat - Current heat score
- * @property {number} createdAt
- * @property {number} lastHeated - Last time heat was added
- * @property {string[]} signals - Evidence trail (why heat was added)
- * @property {boolean} crystallized - Whether it's crossed the threshold
- * @property {string|null} crystallizedAs - What it became (task description, architecture decision, etc)
- */
-
-/**
- * Add a new idea to the simmer buffer.
- * If a similar idea already exists (fuzzy match), heat it instead of duplicating.
- *
- * @param {string} idea - The idea in natural language
- * @param {object} opts
- * @param {string} opts.origin - Where this came from
- * @param {number} opts.initialHeat - Starting heat (default 1)
- * @returns {SimmerItem} The created or heated item
- */
-export function add(idea, { origin = 'observation', initialHeat = 1 } = {}) {
-  const items = _load();
-
-  // Check for similar existing idea
-  const existing = _findSimilar(items, idea);
-  if (existing) {
-    return heat(existing.id, initialHeat, `Recurrence: "${idea.slice(0, 60)}"`);
-  }
-
-  const item = {
-    id: Date.now().toString(36) + Math.random().toString(36).slice(2, 5),
-    idea,
-    origin,
-    heat: initialHeat,
-    createdAt: Date.now(),
-    lastHeated: Date.now(),
-    signals: [`Created from: ${origin}`],
-    crystallized: false,
-    crystallizedAs: null,
-  };
-
-  items.push(item);
-  _save(items);
-  return item;
-}
-
-/**
- * Add heat to an existing item. If it crosses the threshold, mark as crystallized.
- *
- * @param {string} id
- * @param {number} amount - Heat to add (default 1)
- * @param {string} signal - Why heat is being added
- * @returns {SimmerItem|null}
- */
-export function heat(id, amount = 1, signal = '') {
-  const items = _load();
-  const item = items.find(i => i.id === id);
-  if (!item) return null;
-
-  item.heat += amount;
-  item.lastHeated = Date.now();
-  if (signal) item.signals.push(signal);
-
-  // Cap signals array
-  if (item.signals.length > 10) {
-    item.signals = item.signals.slice(-10);
-  }
-
-  // Check crystallization
-  if (!item.crystallized && item.heat >= CRYSTALLIZE_THRESHOLD) {
-    item.crystallized = true;
-  }
-
-  _save(items);
-  return item;
-}
-
-/**
- * Get all items that have crystallized but haven't been surfaced yet.
- * These should be presented to HEAD during deliberation.
- *
- * @returns {SimmerItem[]}
- */
-export function harvest() {
-  const items = _load();
-  return items.filter(i => i.crystallized && !i.crystallizedAs);
-}
-
-/**
- * Mark a crystallized item as actioned — record what it became.
- *
- * @param {string} id
- * @param {string} became - Description of what action was taken
- */
-export function resolve(id, became) {
-  const items = _load();
-  const item = items.find(i => i.id === id);
-  if (!item) return;
-  item.crystallizedAs = became;
-  _save(items);
-}
-
-/**
- * Get all active (non-resolved) simmering items, sorted by heat descending.
- * Used by the narrative to include "what's brewing" context.
- *
- * @returns {SimmerItem[]}
- */
-export function active() {
-  const items = _load();
-  _applyDecay(items);
-  return items
-    .filter(i => !i.crystallizedAs)
-    .sort((a, b) => b.heat - a.heat);
-}
-
-/**
- * Check if an idea already exists in the buffer (for deduplication).
- * @param {string} idea
- * @returns {SimmerItem|null}
- */
-export function find(idea) {
-  const items = _load();
-  return _findSimilar(items, idea);
-}
-
-/**
- * Generate a brief for HEAD showing what's simmering.
- * Included in the narrative context so HEAD is aware of brewing ideas.
- *
- * @returns {string} Prose summary of active simmer items, or empty string
- */
-export function brief() {
-  const items = active();
-  if (items.length === 0) return '';
-
-  const crystallized = items.filter(i => i.crystallized);
-  const hot = items.filter(i => !i.crystallized && i.heat >= 3);
-  const warm = items.filter(i => !i.crystallized && i.heat >= 1.5 && i.heat < 3);
-
-  const parts = [];
-
-  if (crystallized.length > 0) {
-    parts.push(`Crystallized (ready to act): ${crystallized.map(i => i.idea.slice(0, 80)).join('; ')}`);
-  }
-  if (hot.length > 0) {
-    parts.push(`Hot (building momentum): ${hot.map(i => `${i.idea.slice(0, 60)} [heat:${i.heat.toFixed(1)}]`).join('; ')}`);
-  }
-  if (warm.length > 0 && parts.length < 2) {
-    parts.push(`Warm: ${warm.slice(0, 3).map(i => i.idea.slice(0, 50)).join('; ')}`);
-  }
-
-  return parts.join('\n');
-}
-
-/**
- * Prune resolved and cold-dead items.
- */
-export function prune() {
-  let items = _load();
-  _applyDecay(items);
-  // Remove: resolved items older than 1h, or items with heat <= 0
-  const cutoff = Date.now() - 60 * 60 * 1000;
-  items = items.filter(i => {
-    if (i.crystallizedAs && i.lastHeated < cutoff) return false;
-    if (i.heat <= 0) return false;
-    return true;
-  });
-  _save(items);
-}
-
-// ── Internal ──────────────────────────────────────────────────────────────────
-
-function _load() {
-  try {
-    if (existsSync(SIMMER_FILE)) {
-      return JSON.parse(readFileSync(SIMMER_FILE, 'utf8'));
-    }
-  } catch {}
-  return [];
-}
-
-function _save(items) {
-  // Cap total items
-  if (items.length > MAX_ITEMS) {
-    items.sort((a, b) => b.heat - a.heat);
-    items = items.slice(0, MAX_ITEMS);
-  }
-  mkdirSync(STATE_DIR, { recursive: true });
-  writeFileSync(SIMMER_FILE, JSON.stringify(items, null, 2));
-}
-
-function _applyDecay(items) {
-  const now = Date.now();
-  for (const item of items) {
-    if (item.crystallized) continue; // Crystallized items don't decay
-    const hoursSinceHeat = (now - item.lastHeated) / (60 * 60 * 1000);
-    if (hoursSinceHeat > 1) {
-      item.heat -= HEAT_DECAY_PER_HOUR * hoursSinceHeat;
-      if (item.heat < 0) item.heat = 0;
-    }
-  }
-}
-
-function _findSimilar(items, idea) {
-  const normalized = idea.toLowerCase().replace(/[^a-z0-9\s]/g, '');
-  const words = normalized.split(/\s+/).filter(w => w.length > 4);
-  if (words.length === 0) return null;
-
-  for (const item of items) {
-    if (item.crystallizedAs) continue; // Skip resolved
-    const itemNorm = item.idea.toLowerCase().replace(/[^a-z0-9\s]/g, '');
-    const matchCount = words.filter(w => itemNorm.includes(w)).length;
-    if (matchCount >= Math.ceil(words.length * 0.5)) {
-      return item;
-    }
-  }
-  return null;
-}

package/src/strategy.mjs

@@ -1,235 +0,0 @@
-// strategy.mjs — Dispatch strategy library + selection
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-// ─── Strategy definitions ──────────────────────────────────────────────────────
-
-export const STRATEGIES = {
-  direct: {
-    id: 'direct',
-    label: 'Direct dispatch',
-    description: 'Single agent, single task. Best for clear, focused work.',
-    applicability: { maxFiles: 3, maxComplexity: 'moderate', maxRisk: 'medium' },
-    cost: 1.0,
-  },
-  cascade: {
-    id: 'cascade',
-    label: 'Think → Execute cascade',
-    description: 'Cheap thinker refines spec, then worker executes. Best for routine-but-multi-step tasks.',
-    applicability: { minFiles: 1, minComplexity: 'moderate', maxRisk: 'high' },
-    cost: 1.3,
-  },
-  split: {
-    id: 'split',
-    label: 'Decompose → parallel dispatch',
-    description: 'Break into sub-tasks, dispatch each at optimal tier. Best for large multi-file changes.',
-    applicability: { minFiles: 4, minComplexity: 'complex' },
-    cost: 2.0,
-  },
-  'dual-review': {
-    id: 'dual-review',
-    label: 'Execute → adversarial review',
-    description: 'Worker implements, second model reviews. Best for high-risk/security code.',
-    applicability: { minRisk: 'high' },
-    cost: 1.5,
-  },
-  'architect-editor': {
-    id: 'architect-editor',
-    label: 'Architect reasons → editor implements',
-    description: 'Opus/o3 reasons freely, sonnet/haiku formats the edits. Best for complex architecture + implementation.',
-    applicability: { minComplexity: 'complex', minFiles: 3 },
-    cost: 1.8,
-  },
-};
-
-// ─── Helpers ───────────────────────────────────────────────────────────────────
-
-const COMPLEXITY_RANK = { trivial: 0, simple: 1, moderate: 2, complex: 3 };
-const RISK_RANK       = { low: 0, medium: 1, high: 2, critical: 3 };
-
-const COST_CAPS = {
-  frugal:        1.0,
-  'cost-saver':  1.3,
-  balanced:      2.0,
-  'quality-first': 3.0,
-  maximum:       Infinity,
-  aggressive:    Infinity, // maps to maximum behaviour
-  fullpower:     Infinity,
-  fast:          1.3,
-};
-
-const SECURITY_KEYWORDS = /\b(auth|security|billing|payment|credential|secret|token|encrypt|permission|oauth|jwt)\b/i;
-
-function costCap(workStyle) {
-  return COST_CAPS[workStyle] ?? 2.0;
-}
-
-function fileCount(detection) {
-  return detection?.fileCount ?? detection?.files ?? 0;
-}
-
-function complexityRank(detection) {
-  return COMPLEXITY_RANK[detection?.complexity] ?? 1;
-}
-
-function riskRank(detection) {
-  return RISK_RANK[detection?.risk] ?? 0;
-}
-
-function prompt(detection) {
-  return detection?.prompt ?? detection?.description ?? '';
-}
-
-// ─── Scoring ───────────────────────────────────────────────────────────────────
-
-function scoreStrategies(detection, workStyle) {
-  const files  = fileCount(detection);
-  const cRank  = complexityRank(detection);
-  const rRank  = riskRank(detection);
-  const text   = prompt(detection);
-  const frugal = workStyle === 'frugal';
-  const saver  = workStyle === 'cost-saver' || workStyle === 'fast';
-
-  return {
-    direct: 0.5,
-
-    cascade: 0
-      + (cRank >= COMPLEXITY_RANK.moderate ? 0.3 : 0)
-      + (files >= 2 ? 0.2 : 0)
-      - (frugal ? 0.5 : 0),
-
-    split: 0
-      + (files >= 4 ? 0.4 : 0)
-      + (cRank >= COMPLEXITY_RANK.complex ? 0.3 : 0)
-      - (frugal || saver ? 0.5 : 0),
-
-    'dual-review': 0
-      + (rRank >= RISK_RANK.high ? 0.5 : 0)
-      + (SECURITY_KEYWORDS.test(text) ? 0.3 : 0)
-      - (frugal ? 0.3 : 0),
-
-    'architect-editor': 0
-      + (cRank >= COMPLEXITY_RANK.complex && files >= 3 ? 0.4 : 0)
-      - (saver ? 0.3 : 0),
-  };
-}
-
-// ─── Export 1: selectStrategy ─────────────────────────────────────────────────
-
-/**
- * Select the best dispatch strategy for a task.
- * @param {object} detection  — from detect.mjs (detectTask output)
- * @param {object} decision   — from decide.mjs (decideRoute output)
- * @param {object} profile    — user profile (workStyle, etc.)
- * @returns {{ strategy: string, reason: string, alternatives: string[] }}
- */
-export function selectStrategy(detection, decision, profile) {
-  try {
-    const workStyle = profile?.workStyle ?? profile?.bias ?? 'balanced';
-    const cap       = costCap(workStyle);
-    const scores    = scoreStrategies(detection, workStyle);
-
-    // Filter by cost cap, then rank
-    const ranked = Object.entries(scores)
-      .filter(([id]) => STRATEGIES[id].cost <= cap)
-      .sort(([, a], [, b]) => b - a);
-
-    if (!ranked.length) {
-      // Fallback — always allow direct
-      return { strategy: 'direct', reason: 'Cost cap allows only direct dispatch.', alternatives: [] };
-    }
-
-    const [bestId] = ranked[0];
-    const alternatives = ranked.slice(1).map(([id]) => id);
-
-    const reasons = {
-      direct:           'Clear, focused task within single-agent scope.',
-      cascade:          'Multi-step task benefits from spec refinement before execution.',
-      split:            'Large file count warrants decomposition into parallel sub-tasks.',
-      'dual-review':    'High-risk or security-sensitive work requires adversarial review.',
-      'architect-editor': 'Complex architecture + implementation benefits from dual-model reasoning.',
-    };
-
-    return {
-      strategy:     bestId,
-      reason:       reasons[bestId] ?? 'Best match for task profile.',
-      alternatives,
-    };
-  } catch {
-    return { strategy: 'direct', reason: 'Fallback to direct dispatch.', alternatives: [] };
-  }
-}
-
-// ─── Export 2: describeStrategy ───────────────────────────────────────────────
-
-/**
- * Human-readable description of a strategy.
- * @param {string} strategyId
- * @returns {string}
- */
-export function describeStrategy(strategyId) {
-  const s = STRATEGIES[strategyId];
-  if (!s) return `Unknown strategy: ${strategyId}`;
-  return `${s.label} (cost ×${s.cost})\n${s.description}`;
-}
-
-// ─── Export 3: getStrategyForTask ─────────────────────────────────────────────
-
-/**
- * Convenience: load profile + decision context, select strategy, return with execution plan.
- * @param {object} detection  — from detect.mjs
- * @param {string} [cwd]      — working directory (for profile loading)
- * @returns {{ strategy: string, reason: string, alternatives: string[], plan: { steps: object[] } }}
- */
-export function getStrategyForTask(detection, cwd) {
-  const dir = cwd ?? process.cwd();
-  let profile = {};
-  try {
-    const p = join(dir, '.dualbrain', 'config.json');
-    if (existsSync(p)) profile = JSON.parse(readFileSync(p, 'utf8'));
-  } catch { /* non-throwing */ }
-
-  // Minimal decision stub (model resolved from profile if available)
-  const decision = { model: profile?.models?.execute ?? 'sonnet' };
-  const selected = selectStrategy(detection, decision, profile);
-
-  return { ...selected, plan: buildPlan(selected.strategy, decision) };
-}
-
-// ─── Plan builder ─────────────────────────────────────────────────────────────
-
-function buildPlan(strategyId, decision) {
-  const m = decision?.model ?? 'sonnet';
-  const plans = {
-    direct: [
-      { role: 'worker',    model: m,            description: 'Execute task' },
-    ],
-    cascade: [
-      { role: 'thinker',  model: 'sonnet',      description: 'Refine spec' },
-      { role: 'worker',   model: 'from-think',  description: 'Execute refined spec' },
-    ],
-    split: [
-      { role: 'thinker',  model: 'sonnet',      description: 'Decompose into sub-tasks' },
-      { role: 'worker',   model: 'varies',       description: 'Execute each sub-task' },
-    ],
-    'dual-review': [
-      { role: 'worker',   model: m,             description: 'Implement' },
-      { role: 'reviewer', model: 'sonnet',      description: 'Adversarial review' },
-    ],
-    'architect-editor': [
-      { role: 'thinker',  model: 'opus',        description: 'Architect solution' },
-      { role: 'worker',   model: 'haiku',       description: 'Format edits' },
-    ],
-  };
-  return { steps: plans[strategyId] ?? plans.direct };
-}
-
-// ─── Export 4: listStrategies ─────────────────────────────────────────────────
-
-/**
- * List all strategies for display.
- * @returns {{ id: string, label: string, description: string, cost: number }[]}
- */
-export function listStrategies() {
-  return Object.values(STRATEGIES).map(({ id, label, description, cost }) => ({ id, label, description, cost }));
-}