dual-brain 0.2.30 → 0.3.1

package/src/routing-advisor.mjs

@@ -1,204 +0,0 @@
-// routing-advisor.mjs — EMA + epsilon-greedy routing advisor
-// Learns which model works best for which task type from outcome signals.
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from 'node:fs';
-import { checkFileSurvival } from './outcome.mjs';
-import { join } from 'node:path';
-
-const ALPHA = 0.3;
-const MIN_EPSILON = 0.1;
-const MIN_OBSERVATIONS = 5;
-const PRIOR_WEIGHT = 5;
-
-const STATIC_PRIORS = {
-  'search:haiku': 0.85,  'search:sonnet': 0.70,  'search:opus': 0.50,
-  'execute:haiku': 0.55, 'execute:sonnet': 0.80,  'execute:opus': 0.85,
-  'think:haiku': 0.30,   'think:sonnet': 0.70,    'think:opus': 0.90,
-  'review:haiku': 0.40,  'review:sonnet': 0.75,   'review:opus': 0.85,
-};
-
-const VALID_MODELS = {
-  search:  ['haiku', 'sonnet'],
-  execute: ['haiku', 'sonnet', 'opus'],
-  think:   ['sonnet', 'opus'],
-  review:  ['sonnet', 'opus'],
-};
-
-function stateFile(cwd) { return join(cwd || process.cwd(), '.dualbrain', 'routing-state.json'); }
-
-function loadState(cwd) {
-  try {
-    const p = stateFile(cwd);
-    if (!existsSync(p)) return {};
-    const raw = readFileSync(p, 'utf8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
-    return parsed;
-  } catch { return {}; }
-}
-
-function saveState(state, cwd) {
-  try {
-    const dir = join(cwd || process.cwd(), '.dualbrain');
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    const p = stateFile(cwd), tmp = p + '.tmp';
-    writeFileSync(tmp, JSON.stringify(state, null, 2), 'utf8');
-    renameSync(tmp, p);
-  } catch { /* non-throwing */ }
-}
-
-/** Cross-cell bias: average EMA from same-tier cells that have >= 8 observations. */
-function getCrossCellBias(state, cellKey, model) {
-  const [tier] = cellKey.split(':');
-  let biasSum = 0, biasCount = 0;
-  for (const [key, models] of Object.entries(state)) {
-    if (key.startsWith(tier + ':') && key !== cellKey && models[model]) {
-      const entry = models[model];
-      if ((entry.observations ?? 0) >= 8) { biasSum += entry.ema; biasCount++; }
-    }
-  }
-  return biasCount > 0 ? biasSum / biasCount : null;
-}
-
-const staticPrior = (tier, model) => STATIC_PRIORS[`${tier}:${model}`] ?? 0.5;
-const cellObs = (state, key) => Object.values(state[key] ?? {}).reduce((s, m) => s + (m.observations ?? 0), 0);
-const blended = (ema, n, tier, model) =>
-  (n / (n + PRIOR_WEIGHT)) * ema + (PRIOR_WEIGHT / (n + PRIOR_WEIGHT)) * staticPrior(tier, model);
-
-// taskProfile: { intent, tier, risk, files?, complexity? }
-// Returns: { model, reason, confidence, explored }
-export function adviseModel(taskProfile, cwd) {
-  try {
-    const { tier, intent } = taskProfile ?? {};
-    const validTier = tier && VALID_MODELS[tier] ? tier : 'execute';
-    const cellKey = `${validTier}:${intent ?? 'implement'}`;
-    const models = VALID_MODELS[validTier];
-
-    const state = loadState(cwd);
-    const totalObs = cellObs(state, cellKey);
-    const grandTotal = Object.values(state).reduce((s, cell) =>
-      s + Object.values(cell).reduce((t, e) => t + (e.observations ?? 0), 0), 0);
-
-    if (totalObs < MIN_OBSERVATIONS) {
-      // When enough global data exists, blend cross-cell bias with static prior
-      if (grandTotal > 100) {
-        let bestModel = models[0], bestScore = -Infinity;
-        for (const m of models) {
-          const xbias = getCrossCellBias(state, cellKey, m);
-          const prior = staticPrior(validTier, m);
-          const score = xbias != null ? (xbias + prior) / 2 : prior;
-          if (score > bestScore) { bestScore = score; bestModel = m; }
-        }
-        return { model: bestModel, reason: 'cross-cell bias', confidence: 0.4, explored: false };
-      }
-      const best = models.reduce((a, b) => staticPrior(validTier, a) >= staticPrior(validTier, b) ? a : b);
-      return { model: best, reason: 'insufficient data, using heuristic', confidence: 0.3, explored: false };
-    }
-
-    const epsilon = Math.max(MIN_EPSILON, 0.5 * Math.pow(0.9, totalObs));
-    const explored = Math.random() < epsilon;
-
-    if (explored) {
-      const model = models[Math.floor(Math.random() * models.length)];
-      return { model, reason: 'exploration', confidence: epsilon, explored: true };
-    }
-
-    // Exploitation: pick highest blended score
-    const cell = state[cellKey] ?? {};
-    let bestModel = models[0];
-    let bestScore = -Infinity;
-    for (const m of models) {
-      const entry = cell[m];
-      const ema = entry?.ema ?? staticPrior(validTier, m);
-      const n = entry?.observations ?? 0;
-      const score = blended(ema, n, validTier, m);
-      if (score > bestScore) { bestScore = score; bestModel = m; }
-    }
-
-    return { model: bestModel, reason: 'exploitation', confidence: 1 - epsilon, explored: false };
-  } catch {
-    return { model: 'sonnet', reason: 'error fallback', confidence: 0.1, explored: false };
-  }
-}
-
-// reward: number in [0, 1]
-export function recordReward(cellKey, model, reward, cwd) {
-  try {
-    const state = loadState(cwd);
-    if (!state[cellKey]) state[cellKey] = {};
-    const entry = state[cellKey][model] ?? { ema: reward, observations: 0 };
-    entry.ema = ALPHA * reward + (1 - ALPHA) * entry.ema;
-    entry.observations = (entry.observations ?? 0) + 1;
-    entry.lastUpdated = new Date().toISOString();
-    entry.lastReward = reward;
-    state[cellKey][model] = entry;
-    saveState(state, cwd);
-  } catch {
-    // non-throwing
-  }
-}
-
-export function getRoutingStats(cwd) {
-  try {
-    const state = loadState(cwd);
-    const cells = {}, flat = [];
-    let totalObservations = 0;
-    for (const [cellKey, models] of Object.entries(state)) {
-      cells[cellKey] ??= {};
-      for (const [model, entry] of Object.entries(models)) {
-        const obs = entry.observations ?? 0;
-        cells[cellKey][model] = { ema: entry.ema, observations: obs };
-        totalObservations += obs;
-        flat.push({ cell: cellKey, model, ema: entry.ema, observations: obs });
-      }
-    }
-    flat.sort((a, b) => b.ema - a.ema);
-    return { cells, totalObservations, topPerformers: flat.slice(0, 5), worstPerformers: flat.slice(-5).reverse() };
-  } catch {
-    return { cells: {}, totalObservations: 0, topPerformers: [], worstPerformers: [] };
-  }
-}
-
-/**
- * Loads cross-session routing state. If the state was last updated in a prior session,
- * applies a mild decay (×0.95) to all EMA scores to account for staleness.
- */
-export function loadCrossSessionPriors(cwd) {
-  try {
-    const state = loadState(cwd);
-    const sessionStart = state._sessionStart;
-    if (!sessionStart) return state; // no prior session marker
-    const lastMs = new Date(sessionStart).getTime();
-    if (isNaN(lastMs)) return state;
-    const stale = (Date.now() - lastMs) > 60_000; // more than 1 min old = different session
-    if (!stale) return state;
-    for (const [cellKey, models] of Object.entries(state)) {
-      if (cellKey.startsWith('_')) continue;
-      for (const entry of Object.values(models)) {
-        if (typeof entry.ema === 'number') entry.ema = entry.ema * 0.95;
-      }
-    }
-    return state;
-  } catch { return {}; }
-}
-
-/**
- * Records session start timestamp and triggers file survival checks.
- * Call once at CLI session start.
- */
-export async function markSessionStart(cwd) {
-  try {
-    const state = loadState(cwd);
-    state._sessionStart = new Date().toISOString();
-    saveState(state, cwd);
-    await checkFileSurvival(cwd).catch(() => {});
-  } catch { /* non-throwing */ }
-}
-
-export function resetAdvisor(cwd) {
-  try {
-    saveState({}, cwd);
-  } catch {
-    // non-throwing
-  }
-}

package/src/self-correct.mjs

@@ -1,147 +0,0 @@
-// self-correct.mjs — Failure analysis and retry strategy selection
-
-const MODEL_TIER = { 'haiku': 1, 'sonnet': 2, 'opus': 3 };
-const TIER_MODEL = { 1: 'haiku', 2: 'sonnet', 3: 'opus' };
-const MAX_ATTEMPTS = 3;
-
-function modelTier(model = '') {
-  const m = model.toLowerCase();
-  if (m.includes('haiku')) return 1;
-  if (m.includes('opus')) return 3;
-  return 2; // sonnet default
-}
-
-function matchesAny(text, keywords) {
-  const t = text.toLowerCase();
-  return keywords.some(k => t.includes(k));
-}
-
-// Export 1: classifyFailure(result)
-export function classifyFailure(result) {
-  try {
-    const err = String(result?.error || result?.stderr || '');
-    const out = String(result?.output || result?.stdout || '');
-    const combined = err + ' ' + out;
-    const duration = result?.durationMs ?? 0;
-    const timeoutThreshold = result?.timeoutMs ?? 60_000;
-
-    if (matchesAny(combined, ['rate limit', 'ratelimit', '429', 'quota exceeded', 'capacity'])) {
-      return { type: 'rate-limit', confidence: 0.95, retryable: true };
-    }
-    if (matchesAny(combined, ['timeout', 'timed out']) || duration > timeoutThreshold) {
-      return { type: 'timeout', confidence: 0.9, retryable: true };
-    }
-    if (matchesAny(combined, ['context length', 'token limit', 'too long', 'maximum context', 'context window'])) {
-      return { type: 'context-overflow', confidence: 0.9, retryable: true };
-    }
-    if (matchesAny(combined, ['ambiguous', 'unclear', 'did you mean', 'which one', 'could you clarify', 'please clarify'])) {
-      return { type: 'specification', confidence: 0.85, retryable: false };
-    }
-    if (matchesAny(combined, ['unable to', "i don't know how", 'beyond my', 'cannot complete', 'incomplete'])) {
-      return { type: 'capability', confidence: 0.8, retryable: true };
-    }
-    // Heuristic: low quality output without explicit error signals capability gap
-    const quality = result?.quality ?? result?.score ?? null;
-    if (quality !== null && quality < 0.5) {
-      return { type: 'capability', confidence: 0.7, retryable: true };
-    }
-
-    return { type: 'unknown', confidence: 0.5, retryable: true };
-  } catch {
-    return { type: 'unknown', confidence: 0, retryable: true };
-  }
-}
-
-// Export 2: selectStrategy(failure, originalDecision, attemptNumber)
-export function selectStrategy(failure, originalDecision, attemptNumber) {
-  try {
-    if (!failure.retryable) {
-      return { strategy: 'give-up', reason: `failure type '${failure.type}' requires user input` };
-    }
-    if (attemptNumber >= MAX_ATTEMPTS) {
-      return { strategy: 'give-up', reason: `max attempts (${MAX_ATTEMPTS}) reached` };
-    }
-
-    const tier = modelTier(originalDecision?.model);
-
-    if (attemptNumber === 1) {
-      switch (failure.type) {
-        case 'capability':
-          if (tier >= 3) return { strategy: 'split', newDecision: originalDecision, reason: 'already at max tier; decompose task' };
-          return { strategy: 'escalate', newDecision: originalDecision, reason: 'model lacked capability; escalating tier' };
-        case 'timeout':
-          return { strategy: 'wait-retry', newDecision: originalDecision, reason: 'timed out; retrying with delay' };
-        case 'rate-limit':
-          return { strategy: 'wait-retry', newDecision: originalDecision, reason: 'rate limited; retrying after delay' };
-        case 'context-overflow':
-          return { strategy: 'compress', newDecision: originalDecision, reason: 'context too large; compressing' };
-        case 'specification':
-          return { strategy: 'give-up', reason: 'ambiguous specification; user clarification needed' };
-        default: // unknown
-          if (tier >= 3) return { strategy: 'split', newDecision: originalDecision, reason: 'unknown failure at max tier; decomposing' };
-          return { strategy: 'escalate', newDecision: originalDecision, reason: 'unknown failure; escalating as precaution' };
-      }
-    }
-
-    if (attemptNumber === 2) {
-      if (tier >= 3) {
-        return { strategy: 'split', newDecision: originalDecision, reason: 'max tier reached; splitting task' };
-      }
-      return { strategy: 'escalate', newDecision: originalDecision, reason: 'retry failed; escalating one final tier' };
-    }
-
-    return { strategy: 'give-up', reason: 'exhausted retry budget' };
-  } catch {
-    return { strategy: 'give-up', reason: 'internal error in strategy selection' };
-  }
-}
-
-// Export 3: buildRetryDecision(originalDecision, strategy, failure)
-export function buildRetryDecision(originalDecision, strategy, failure) {
-  try {
-    const base = {
-      ...originalDecision,
-      _retryAttempt: (originalDecision?._retryAttempt ?? 0) + 1,
-      _retryReason: failure.type,
-      _retryStrategy: strategy,
-    };
-
-    switch (strategy) {
-      case 'escalate': {
-        const tier = modelTier(originalDecision?.model);
-        const nextTier = Math.min(tier + 1, 3);
-        return { ...base, model: TIER_MODEL[nextTier] };
-      }
-      case 'compress':
-        return { ...base, _contextBudget: 0.5 };
-      case 'wait-retry':
-        return { ...base, _delayMs: 5000 };
-      case 'rethink':
-        return { ...base, tier: 'think', _retryAsThink: true };
-      case 'split':
-        return { ...base, _shouldDecompose: true };
-      default:
-        return base;
-    }
-  } catch {
-    return { ...originalDecision, _retryAttempt: 1, _retryReason: 'error', _retryStrategy: strategy };
-  }
-}
-
-// Export 4: shouldRetry(result, originalDecision, attemptNumber)
-export function shouldRetry(result, originalDecision, attemptNumber = 1) {
-  try {
-    if (attemptNumber >= MAX_ATTEMPTS) return { retry: false, reason: `max attempts (${MAX_ATTEMPTS}) reached`, strategy: 'give-up' };
-    const failure = classifyFailure(result);
-    const { strategy, newDecision, reason } = selectStrategy(failure, originalDecision, attemptNumber);
-
-    if (strategy === 'give-up') {
-      return { retry: false, reason, strategy };
-    }
-
-    const decision = buildRetryDecision(newDecision ?? originalDecision, strategy, failure);
-    return { retry: true, decision, reason, strategy };
-  } catch {
-    return { retry: false, reason: 'internal error in shouldRetry', strategy: 'give-up' };
-  }
-}

package/src/session-lock.mjs

@@ -1,160 +0,0 @@
-// session-lock.mjs — Ensures one active HEAD session at a time.
-// If two shells/chats open, only one owns the cognitive state.
-// The other gets read-only access (can observe but not dispatch).
-//
-// "One ring rules them all" — no split-brain.
-
-import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-const STATE_DIR = join(process.cwd(), '.dualbrain');
-const LOCK_FILE = join(STATE_DIR, 'session.lock');
-
-const STALE_THRESHOLD_MS = 90_000; // 90 seconds without heartbeat = stale
-const HEARTBEAT_INTERVAL_MS = 30_000;
-
-let _heartbeatTimer = null;
-let _sessionId = null;
-
-/**
- * @typedef {object} LockResult
- * @property {boolean} acquired - Whether this session owns HEAD
- * @property {string} sessionId - This session's ID
- * @property {string|null} existingSession - ID of the session that already holds the lock (if not acquired)
- * @property {string} mode - 'primary' | 'takeover' | 'readonly'
- */
-
-/**
- * Attempt to acquire the session lock.
- * - If no lock exists or lock is stale: acquire as primary
- * - If lock is fresh and held by another: return readonly
- *
- * @param {object} opts
- * @param {boolean} opts.force - Force takeover even if existing session is fresh
- * @returns {LockResult}
- */
-export function acquire({ force = false } = {}) {
-  mkdirSync(STATE_DIR, { recursive: true });
-  _sessionId = _generateSessionId();
-
-  const existing = _readLock();
-
-  if (!existing) {
-    // No lock — claim it
-    _writeLock(_sessionId);
-    _startHeartbeat();
-    return { acquired: true, sessionId: _sessionId, existingSession: null, mode: 'primary' };
-  }
-
-  // Same process (re-entry within same session) — always grant
-  if (existing.pid === process.pid) {
-    _sessionId = existing.sessionId;
-    return { acquired: true, sessionId: _sessionId, existingSession: null, mode: 'primary' };
-  }
-
-  const age = Date.now() - existing.heartbeat;
-
-  if (age > STALE_THRESHOLD_MS || force) {
-    // Stale or forced takeover
-    _writeLock(_sessionId);
-    _startHeartbeat();
-    return { acquired: true, sessionId: _sessionId, existingSession: existing.sessionId, mode: 'takeover' };
-  }
-
-  // Another session is active — go readonly
-  return { acquired: false, sessionId: _sessionId, existingSession: existing.sessionId, mode: 'readonly' };
-}
-
-/**
- * Release the session lock (called at session end).
- */
-export function release() {
-  if (_heartbeatTimer) {
-    clearInterval(_heartbeatTimer);
-    _heartbeatTimer = null;
-  }
-
-  try {
-    const existing = _readLock();
-    if (existing && existing.sessionId === _sessionId) {
-      unlinkSync(LOCK_FILE);
-    }
-  } catch {}
-}
-
-/**
- * Check if this session currently holds the lock.
- * @returns {boolean}
- */
-export function isOwner() {
-  const existing = _readLock();
-  return existing?.sessionId === _sessionId;
-}
-
-/**
- * Get current lock status without modifying it.
- * @returns {{active: boolean, sessionId: string|null, age: number|null}}
- */
-export function status() {
-  const existing = _readLock();
-  if (!existing) return { active: false, sessionId: null, age: null };
-  return {
-    active: (Date.now() - existing.heartbeat) < STALE_THRESHOLD_MS,
-    sessionId: existing.sessionId,
-    age: Date.now() - existing.heartbeat,
-  };
-}
-
-/**
- * Manually heartbeat (useful if the automatic timer isn't running).
- */
-export function heartbeat() {
-  if (!_sessionId) return;
-  const existing = _readLock();
-  if (existing && existing.sessionId === _sessionId) {
-    _writeLock(_sessionId);
-  }
-}
-
-// ── Internal ──────────────────────────────────────────────────────────────────
-
-function _generateSessionId() {
-  return Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 8);
-}
-
-function _readLock() {
-  try {
-    if (!existsSync(LOCK_FILE)) return null;
-    return JSON.parse(readFileSync(LOCK_FILE, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function _writeLock(sessionId) {
-  const lock = {
-    sessionId,
-    heartbeat: Date.now(),
-    pid: process.pid,
-  };
-  writeFileSync(LOCK_FILE, JSON.stringify(lock));
-}
-
-function _startHeartbeat() {
-  if (_heartbeatTimer) clearInterval(_heartbeatTimer);
-  _heartbeatTimer = setInterval(() => {
-    try {
-      const existing = _readLock();
-      if (existing && existing.sessionId === _sessionId) {
-        _writeLock(_sessionId);
-      } else {
-        // Someone else took over — stop heartbeating
-        clearInterval(_heartbeatTimer);
-        _heartbeatTimer = null;
-      }
-    } catch {}
-  }, HEARTBEAT_INTERVAL_MS);
-
-  // Don't keep the process alive just for heartbeats
-  if (_heartbeatTimer.unref) _heartbeatTimer.unref();
-}