dual-brain 0.2.29 → 0.3.0

package/src/context.mjs

@@ -1,389 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { execSync } from 'node:child_process';
-import { join, resolve, dirname, extname, relative } from 'node:path';
-
-import { detectTask } from './detect.mjs';
-
-// ─── Language detection ───────────────────────────────────────────────────────
-
-const EXT_LANG = {
-  '.mjs': 'javascript', '.js': 'javascript', '.cjs': 'javascript',
-  '.ts': 'typescript', '.tsx': 'typescript', '.mts': 'typescript',
-  '.py': 'python', '.pyx': 'python', '.pyi': 'python',
-  '.rs': 'rust',
-  '.go': 'go',
-  '.rb': 'ruby',
-  '.java': 'java',
-  '.kt': 'kotlin', '.kts': 'kotlin',
-  '.swift': 'swift',
-  '.c': 'c', '.h': 'c',
-  '.cpp': 'cpp', '.cc': 'cpp', '.cxx': 'cpp', '.hpp': 'cpp',
-  '.cs': 'csharp',
-  '.php': 'php',
-  '.sh': 'shell', '.bash': 'shell', '.zsh': 'shell',
-  '.html': 'html', '.htm': 'html',
-  '.css': 'css', '.scss': 'scss', '.sass': 'sass', '.less': 'less',
-  '.json': 'json', '.jsonl': 'json',
-  '.yaml': 'yaml', '.yml': 'yaml',
-  '.toml': 'toml',
-  '.md': 'markdown', '.mdx': 'markdown',
-  '.sql': 'sql',
-  '.graphql': 'graphql', '.gql': 'graphql',
-  '.dockerfile': 'dockerfile',
-};
-
-function detectLanguage(filePath) {
-  const ext = extname(filePath).toLowerCase();
-  if (!ext && filePath.toLowerCase().endsWith('dockerfile')) return 'dockerfile';
-  return EXT_LANG[ext] || 'unknown';
-}
-
-// ─── Git helpers ──────────────────────────────────────────────────────────────
-
-function git(cmd, cwd) {
-  return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-}
-
-function safeGit(cmd, cwd, fallback = '') {
-  try { return git(cmd, cwd); } catch { return fallback; }
-}
-
-function getGitChangedFiles(cwd) {
-  const raw = safeGit('git status --porcelain', cwd, '');
-  if (!raw) return { files: [], statusMap: {} };
-
-  const statusMap = {};
-  const files = [];
-
-  for (const line of raw.split('\n')) {
-    if (!line.trim()) continue;
-    const code = line.slice(0, 2).trim() || '?';
-    const filePath = line.slice(3).trim().replace(/^"(.*)"$/, '$1');
-    if (filePath) {
-      statusMap[filePath] = code;
-      files.push(filePath);
-    }
-  }
-
-  return { files, statusMap };
-}
-
-function getRepoState(cwd) {
-  const branch = safeGit('git branch --show-current', cwd, 'unknown');
-
-  const statusRaw = safeGit('git status --porcelain', cwd, '');
-  const uncommittedCount = statusRaw
-    ? statusRaw.split('\n').filter(l => l.trim()).length
-    : 0;
-
-  const lastCommitMessage = safeGit('git log -1 --pretty=format:%s', cwd, '');
-
-  let lastCommitAge = 'unknown';
-  try {
-    const epochStr = git('git log -1 --pretty=format:%ct', cwd);
-    const epoch = parseInt(epochStr, 10);
-    if (!isNaN(epoch)) {
-      lastCommitAge = formatTimeAgo(epoch * 1000);
-    }
-  } catch { /* non-fatal */ }
-
-  return { branch, uncommittedCount, lastCommitMessage, lastCommitAge };
-}
-
-function formatTimeAgo(timestampMs) {
-  const diff = Date.now() - timestampMs;
-  const mins = Math.floor(diff / 60_000);
-  if (mins < 1) return 'just now';
-  if (mins < 60) return `${mins}m ago`;
-  const hours = Math.floor(mins / 60);
-  if (hours < 24) return `${hours}h ago`;
-  const days = Math.floor(hours / 24);
-  return `${days}d ago`;
-}
-
-// ─── Related files (import graph, one hop) ───────────────────────────────────
-
-const IMPORT_RE = /(?:import\s+.*?from\s+|require\s*\(\s*)['"]([^'"]+)['"]/g;
-
-function findRelatedFiles(explicitFiles, cwd) {
-  const related = new Set();
-
-  for (const filePath of explicitFiles) {
-    const absPath = resolve(cwd, filePath);
-    if (!existsSync(absPath)) continue;
-
-    let content;
-    try { content = readFileSync(absPath, 'utf8'); } catch { continue; }
-
-    const fileDir = dirname(absPath);
-    let match;
-    IMPORT_RE.lastIndex = 0;
-
-    while ((match = IMPORT_RE.exec(content)) !== null) {
-      const specifier = match[1];
-      if (!specifier.startsWith('.')) continue; // skip node_modules / bare specifiers
-
-      // Try common extensions in order
-      const candidates = [
-        specifier,
-        specifier + '.mjs', specifier + '.js', specifier + '.ts',
-        specifier + '/index.mjs', specifier + '/index.js', specifier + '/index.ts',
-      ];
-
-      for (const candidate of candidates) {
-        const abs = resolve(fileDir, candidate);
-        if (existsSync(abs)) {
-          const rel = relative(cwd, abs);
-          if (!explicitFiles.includes(rel)) related.add(rel);
-          break;
-        }
-      }
-    }
-  }
-
-  return [...related];
-}
-
-// ─── File summaries ───────────────────────────────────────────────────────────
-
-function buildFileSummary(filePath, cwd, statusMap = {}) {
-  const absPath = resolve(cwd, filePath);
-  const language = detectLanguage(filePath);
-
-  let lines = 0;
-  try {
-    const content = readFileSync(absPath, 'utf8');
-    lines = content.split('\n').length;
-  } catch { /* file missing or unreadable */ }
-
-  const rawStatus = statusMap[filePath] || statusMap[filePath.replace(/\\/g, '/')];
-  const gitStatus = rawStatus || 'clean';
-
-  return { path: filePath, language, lines, gitStatus };
-}
-
-// ─── Constraints from CLAUDE.md ───────────────────────────────────────────────
-
-const CONSTRAINT_RE = /\b(must|never|always|require[sd]?|do not|don't)\b/i;
-
-function extractConstraints(cwd) {
-  const candidates = [
-    join(cwd, 'CLAUDE.md'),
-    join(cwd, '.claude', 'CLAUDE.md'),
-  ];
-
-  const constraints = [];
-
-  for (const p of candidates) {
-    if (!existsSync(p)) continue;
-    try {
-      const lines = readFileSync(p, 'utf8').split('\n');
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed && CONSTRAINT_RE.test(trimmed) && trimmed.length < 200) {
-          constraints.push(trimmed.replace(/^[-*#\s]+/, '').trim());
-        }
-      }
-    } catch { /* non-fatal */ }
-  }
-
-  return constraints;
-}
-
-// ─── Prior attempts from .dualbrain/outcomes/ ────────────────────────────────
-
-function loadPriorAttempts(prompt, cwd) {
-  const outcomesDir = join(cwd, '.dualbrain', 'outcomes');
-  if (!existsSync(outcomesDir)) return [];
-
-  const promptWords = new Set(
-    prompt.toLowerCase().split(/\W+/).filter(w => w.length > 3),
-  );
-
-  const attempts = [];
-
-  let entries;
-  try { entries = readdirSync(outcomesDir); } catch { return []; }
-
-  for (const entry of entries) {
-    if (!entry.endsWith('.json')) continue;
-    try {
-      const raw = JSON.parse(readFileSync(join(outcomesDir, entry), 'utf8'));
-      if (!raw.prompt) continue;
-
-      // Simple word-overlap similarity
-      const entryWords = raw.prompt.toLowerCase().split(/\W+/).filter(w => w.length > 3);
-      const overlap = entryWords.filter(w => promptWords.has(w)).length;
-      const similarity = overlap / Math.max(promptWords.size, entryWords.length, 1);
-
-      if (similarity >= 0.3) {
-        attempts.push({
-          timestamp: raw.timestamp || 0,
-          prompt: raw.prompt,
-          success: raw.success ?? false,
-          lesson: raw.lesson || raw.summary || '',
-        });
-      }
-    } catch { /* non-fatal */ }
-  }
-
-  return attempts.sort((a, b) => b.timestamp - a.timestamp).slice(0, 5);
-}
-
-// ─── Related sessions ─────────────────────────────────────────────────────────
-
-async function loadRelatedSessions(prompt, files, cwd) {
-  try {
-    // Dynamic import so missing module doesn't break the whole pack
-    const { findRelatedSessions } = await import('./session.mjs');
-    const raw = findRelatedSessions(prompt, files, cwd);
-    return raw.map(s => ({
-      id: s.sessionId,
-      name: s.smartName || s.sessionId.slice(0, 8),
-      score: s.score,
-    }));
-  } catch {
-    return [];
-  }
-}
-
-// ─── Acceptance criteria ──────────────────────────────────────────────────────
-
-const CRITERIA_PATTERNS = [
-  { re: /\btests?\s+pass\b/i,        label: 'tests pass' },
-  { re: /\bno\s+regression[s]?\b/i,  label: 'no regressions' },
-  { re: /\bbuilds?\s+clean\b/i,      label: 'builds clean' },
-  { re: /\bbuild[s]?\b/i,            label: 'builds clean' },
-  { re: /\blint\s+clean\b/i,         label: 'lint clean' },
-  { re: /\bno\s+error[s]?\b/i,       label: 'no errors' },
-  { re: /\btype.?check\b/i,          label: 'type-check passes' },
-  { re: /\bworks?\s+on\s+\w+/i,      label: (m) => `works on ${m[0].match(/works?\s+on\s+(\w+)/i)?.[1]}` },
-  { re: /\bcompatible\s+with\s+\w+/i, label: (m) => `compatible with ${m[0].match(/compatible\s+with\s+(\w+)/i)?.[1]}` },
-  { re: /\bno\s+breaking\s+change[s]?\b/i, label: 'no breaking changes' },
-  { re: /\bbackward[s]?\s+compat/i,  label: 'backward compatible' },
-  { re: /\ball\s+tests?\s+pass/i,    label: 'all tests pass' },
-  { re: /\bci\s+pass(?:es)?\b/i,     label: 'CI passes' },
-  { re: /\bcoverage\b/i,             label: 'coverage maintained' },
-];
-
-function inferAcceptanceCriteria(prompt) {
-  const found = new Set();
-  for (const { re, label } of CRITERIA_PATTERNS) {
-    const m = prompt.match(re);
-    if (m) {
-      const criterion = typeof label === 'function' ? label([m[0]]) : label;
-      if (criterion) found.add(criterion);
-    }
-  }
-  return [...found];
-}
-
-// ─── Main export ──────────────────────────────────────────────────────────────
-
-/**
- * Build a structured context pack for a task. All fields are best-effort —
- * missing git, missing files, and missing optional modules all degrade gracefully.
- *
- * @param {string}   prompt
- * @param {string[]} files   - Explicitly mentioned file paths (may be relative)
- * @param {string}   cwd     - Working directory (absolute)
- * @param {object}   options
- * @param {number}   [options.priorFailures=0]
- * @returns {Promise<object>}
- */
-export async function buildContextPack(prompt = '', files = [], cwd = process.cwd(), options = {}) {
-  const { priorFailures = 0 } = options;
-
-  // 1. Detection (intent / tier / risk)
-  const detection = detectTask({ prompt, files, priorFailures });
-
-  // 2. Git changed files + status map
-  const { files: gitChanged, statusMap } = getGitChangedFiles(cwd);
-
-  // 3. Related files (import graph, one hop from explicit files)
-  const relatedFiles = findRelatedFiles(files, cwd);
-
-  const filesPack = {
-    explicit: files,
-    gitChanged,
-    related: relatedFiles,
-  };
-
-  // 4. File summaries — explicit + gitChanged, deduped
-  const summaryTargets = [...new Set([...files, ...gitChanged])];
-  const fileSummaries = summaryTargets.map(f => buildFileSummary(f, cwd, statusMap));
-
-  // 5. Repo state
-  const repoState = getRepoState(cwd);
-
-  // 6. Constraints from CLAUDE.md
-  const constraints = extractConstraints(cwd);
-
-  // 7. Prior attempts
-  const priorAttempts = loadPriorAttempts(prompt, cwd);
-
-  // 8. Related sessions (async, may fail silently)
-  const allFiles = [...new Set([...files, ...gitChanged])];
-  const relatedSessions = await loadRelatedSessions(prompt, allFiles, cwd);
-
-  // 9. Acceptance criteria
-  const acceptanceCriteria = inferAcceptanceCriteria(prompt);
-
-  return {
-    intent: detection.intent,
-    prompt,
-    tier: detection.tier,
-    risk: detection.risk,
-    files: filesPack,
-    fileSummaries,
-    repoState,
-    constraints,
-    priorAttempts,
-    relatedSessions,
-    acceptanceCriteria,
-  };
-}
-
-// ─── Summarizer ───────────────────────────────────────────────────────────────
-
-/**
- * Return a human-readable 3-5 line summary of a context pack for logging/display.
- *
- * @param {object} pack - Result of buildContextPack()
- * @returns {string}
- */
-export function summarizeContextPack(pack) {
-  const lines = [];
-
-  lines.push(
-    `Task: ${pack.intent} (${pack.tier} tier, ${pack.risk} risk)`,
-  );
-
-  const explicit = pack.files?.explicit?.length ?? 0;
-  const changed  = pack.files?.gitChanged?.length ?? 0;
-  const related  = pack.files?.related?.length ?? 0;
-  lines.push(`Files: ${explicit} explicit, ${changed} changed, ${related} related`);
-
-  const { branch, uncommittedCount, lastCommitAge } = pack.repoState ?? {};
-  const branchStr = branch ? `${branch} branch` : 'unknown branch';
-  const uncommittedStr = uncommittedCount != null
-    ? `${uncommittedCount} uncommitted file${uncommittedCount === 1 ? '' : 's'}`
-    : 'commit count unknown';
-  const ageStr = lastCommitAge && lastCommitAge !== 'unknown' ? `, last commit ${lastCommitAge}` : '';
-  lines.push(`Repo: ${branchStr}, ${uncommittedStr}${ageStr}`);
-
-  if (pack.priorAttempts?.length > 0) {
-    const failed = pack.priorAttempts.filter(a => !a.success).length;
-    const total = pack.priorAttempts.length;
-    const label = failed > 0
-      ? `${failed} failed attempt${failed === 1 ? '' : 's'} on similar task`
-      : `${total} prior attempt${total === 1 ? '' : 's'} on similar task`;
-    lines.push(`Prior: ${label}`);
-  }
-
-  if (pack.acceptanceCriteria?.length > 0) {
-    lines.push(`Criteria: ${pack.acceptanceCriteria.join(', ')}`);
-  }
-
-  return lines.join('\n');
-}

package/src/continuity.mjs

@@ -1,298 +0,0 @@
-#!/usr/bin/env node
-// continuity.mjs — Session continuity for dual-brain.
-// Generates handoff receipts so the next session can pick up seamlessly
-// when a session hits context limits, crashes, or is manually ended.
-//
-// Exports: generateHandoff, saveHandoff, getLatestHandoff, getHandoffAge,
-//          buildCompactionSurvivalKit, buildResumeBrief, pruneHandoffs,
-//          extractRoutingPatterns
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import { load as loadNarrative } from './narrative.mjs';
-
-// ─── Session chaining ─────────────────────────────────────────────────────────
-
-/**
- * Generate a compact handoff object from current session state.
- * Designed to fit in ~500 tokens when serialized.
- *
- * @param {object} sessionState
- * @param {string}   [sessionState.taskDescription]
- * @param {string[]} [sessionState.filesChanged]
- * @param {string[]} [sessionState.testsRun]
- * @param {object[]} [sessionState.decisions]         Most recent routing decisions
- * @param {string[]} [sessionState.unresolved]        Open questions / blockers
- * @param {object}   [sessionState.routingHistory]
- * @param {string}     [sessionState.routingHistory.lastProvider]
- * @param {string}     [sessionState.routingHistory.lastModel]
- * @param {string[]}   [sessionState.routingHistory.failedProviders]
- * @param {string[]} [sessionState.activePreferences]
- * @param {string}   [sessionState.resumeHint]        e.g. "continue implementing auth refactor"
- * @returns {object}
- */
-export function generateHandoff(sessionState) {
-  return {
-    version: 2,
-    timestamp: new Date().toISOString(),
-    task: sessionState.taskDescription || null,
-    progress: {
-      filesChanged: (sessionState.filesChanged || []).slice(0, 20),
-      testsRun: sessionState.testsRun || [],
-      decisions: (sessionState.decisions || []).slice(0, 5),
-    },
-    unresolved: (sessionState.unresolved || []).slice(0, 5),
-    routing: {
-      lastProvider: sessionState.routingHistory?.lastProvider || null,
-      lastModel: sessionState.routingHistory?.lastModel || null,
-      failedProviders: sessionState.routingHistory?.failedProviders || [],
-    },
-    preferences: sessionState.activePreferences || [],
-    resumeHint: sessionState.resumeHint || null,
-    narrative: sessionState.narrative || loadNarrative() || null,
-  };
-}
-
-// ─── Handoff persistence ──────────────────────────────────────────────────────
-
-/**
- * Persist a handoff object to .dualbrain/handoffs/.
- * @param {object} handoff   Result of generateHandoff()
- * @param {string} [cwd]     Project root (defaults to process.cwd())
- * @returns {string}         Absolute path of the written file
- */
-export function saveHandoff(handoff, cwd) {
-  const dir = join(cwd || process.cwd(), '.dualbrain', 'handoffs');
-  mkdirSync(dir, { recursive: true });
-  const filename = `handoff-${Date.now()}.json`;
-  writeFileSync(join(dir, filename), JSON.stringify(handoff, null, 2));
-  return join(dir, filename);
-}
-
-/**
- * Load the most recent handoff from .dualbrain/handoffs/.
- * Returns null when no handoffs exist or all are unreadable.
- * @param {string} [cwd]
- * @returns {object|null}
- */
-export function getLatestHandoff(cwd) {
-  const dir = join(cwd || process.cwd(), '.dualbrain', 'handoffs');
-  if (!existsSync(dir)) return null;
-  const files = readdirSync(dir)
-    .filter(f => f.startsWith('handoff-') && f.endsWith('.json'))
-    .sort()
-    .reverse();
-  if (files.length === 0) return null;
-  try {
-    return JSON.parse(readFileSync(join(dir, files[0]), 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Return the age of a handoff in hours.
- * Returns Infinity when the handoff has no timestamp.
- * @param {object|null} handoff
- * @returns {number}  Hours since handoff was generated
- */
-export function getHandoffAge(handoff) {
-  if (!handoff?.timestamp) return Infinity;
-  return (Date.now() - Date.parse(handoff.timestamp)) / 3600000;
-}
-
-// ─── Smart compaction ─────────────────────────────────────────────────────────
-
-/**
- * Build a compaction-safe summary string to inject before context compression.
- * The content must survive being summarised by a compression pass, so keep it
- * terse, high-signal, and easy to re-state.
- *
- * @param {object} state
- * @param {string}   [state.activeTask]
- * @param {string[]} [state.routingRules]
- * @param {string[]} [state.criticalDecisions]
- * @param {string[]} [state.filesInProgress]
- * @param {string[]} [state.preferences]
- * @param {string[]} [state.warnings]
- * @returns {string}
- */
-export function buildCompactionSurvivalKit(state) {
-  const lines = [];
-  lines.push('[DUAL-BRAIN CONTINUITY]');
-
-  if (state.activeTask) {
-    lines.push(`TASK: ${state.activeTask}`);
-  }
-  if (state.routingRules?.length) {
-    lines.push(`ROUTING: ${state.routingRules.join('; ')}`);
-  }
-  if (state.criticalDecisions?.length) {
-    lines.push(`DECISIONS: ${state.criticalDecisions.join('; ')}`);
-  }
-  if (state.filesInProgress?.length) {
-    lines.push(`FILES: ${state.filesInProgress.join(', ')}`);
-  }
-  if (state.preferences?.length) {
-    lines.push(`PREFS: ${state.preferences.join('; ')}`);
-  }
-  if (state.warnings?.length) {
-    lines.push(`WARNINGS: ${state.warnings.join('; ')}`);
-  }
-
-  lines.push('[/DUAL-BRAIN CONTINUITY]');
-  return lines.join('\n');
-}
-
-// ─── Resume brief builder ─────────────────────────────────────────────────────
-
-/**
- * Check for a recent handoff and build a resume context string for a new session.
- * Returns null when no usable handoff exists (missing, too stale, or unreadable).
- *
- * @param {string} [cwd]
- * @returns {string|null}
- */
-export function buildResumeBrief(cwd) {
-  const handoff = getLatestHandoff(cwd);
-  if (!handoff) return null;
-
-  const ageHours = getHandoffAge(handoff);
-  if (ageHours > 48) return null; // too stale to be useful
-
-  const lines = [];
-  const ageLabel =
-    ageHours < 1
-      ? 'just now'
-      : ageHours < 24
-        ? `${Math.round(ageHours)}h ago`
-        : `${Math.round(ageHours / 24)}d ago`;
-
-  lines.push(`Resuming from previous session (${ageLabel}):`);
-
-  // Narrative first — most valuable context for immersion
-  if (handoff.narrative) {
-    lines.push(`  Context: ${handoff.narrative.slice(0, 300)}`);
-  }
-
-  if (handoff.task) lines.push(`  Task: ${handoff.task}`);
-  if (handoff.resumeHint) lines.push(`  Next: ${handoff.resumeHint}`);
-  if (handoff.progress?.filesChanged?.length) {
-    const shown = handoff.progress.filesChanged.slice(0, 5);
-    const extra = handoff.progress.filesChanged.length > 5
-      ? ` (+${handoff.progress.filesChanged.length - 5} more)`
-      : '';
-    lines.push(`  Changed: ${shown.join(', ')}${extra}`);
-  }
-  if (handoff.unresolved?.length) {
-    lines.push(`  Unresolved: ${handoff.unresolved.join('; ')}`);
-  }
-  if (handoff.routing?.failedProviders?.length) {
-    lines.push(`  Note: ${handoff.routing.failedProviders.join(', ')} failed last session`);
-  }
-
-  return lines.join('\n');
-}
-
-// ─── Handoff cleanup ──────────────────────────────────────────────────────────
-
-/**
- * Remove old handoff files, keeping only the most recent `keep` entries.
- * @param {string} [cwd]
- * @param {number} [keep=10]
- * @returns {number}  Count of files pruned
- */
-export function pruneHandoffs(cwd, keep = 10) {
-  const dir = join(cwd || process.cwd(), '.dualbrain', 'handoffs');
-  if (!existsSync(dir)) return 0;
-  const files = readdirSync(dir)
-    .filter(f => f.startsWith('handoff-') && f.endsWith('.json'))
-    .sort()
-    .reverse();
-  let pruned = 0;
-  for (const f of files.slice(keep)) {
-    try {
-      unlinkSync(join(dir, f));
-      pruned++;
-    } catch {
-      // Skip files that can't be removed — best-effort
-    }
-  }
-  return pruned;
-}
-
-// ─── Cross-session learning ───────────────────────────────────────────────────
-
-/**
- * Extract routing patterns from handoff history to inform provider/model selection.
- *
- * @param {string} [cwd]
- * @returns {{
- *   patterns: Array<{ type: string, value: string, count: number }>,
- *   confidence: number,
- *   sampleSize: number
- * }}
- */
-export function extractRoutingPatterns(cwd) {
-  const dir = join(cwd || process.cwd(), '.dualbrain', 'handoffs');
-  if (!existsSync(dir)) return { patterns: [], confidence: 0, sampleSize: 0 };
-
-  const files = readdirSync(dir)
-    .filter(f => f.startsWith('handoff-') && f.endsWith('.json'))
-    .sort()
-    .reverse()
-    .slice(0, 20);
-
-  const handoffs = files
-    .map(f => {
-      try {
-        return JSON.parse(readFileSync(join(dir, f), 'utf8'));
-      } catch {
-        return null;
-      }
-    })
-    .filter(Boolean);
-
-  // Count provider/model usage patterns
-  const providerCounts = {};
-  const modelCounts = {};
-  const failureCounts = {};
-
-  for (const h of handoffs) {
-    if (h.routing?.lastProvider) {
-      providerCounts[h.routing.lastProvider] = (providerCounts[h.routing.lastProvider] || 0) + 1;
-    }
-    if (h.routing?.lastModel) {
-      modelCounts[h.routing.lastModel] = (modelCounts[h.routing.lastModel] || 0) + 1;
-    }
-    for (const fp of (h.routing?.failedProviders || [])) {
-      failureCounts[fp] = (failureCounts[fp] || 0) + 1;
-    }
-  }
-
-  const patterns = [];
-
-  // Most used provider
-  const topProvider = Object.entries(providerCounts).sort((a, b) => b[1] - a[1])[0];
-  if (topProvider) {
-    patterns.push({ type: 'preferred_provider', value: topProvider[0], count: topProvider[1] });
-  }
-
-  // Most used model
-  const topModel = Object.entries(modelCounts).sort((a, b) => b[1] - a[1])[0];
-  if (topModel) {
-    patterns.push({ type: 'preferred_model', value: topModel[0], count: topModel[1] });
-  }
-
-  // Frequently failing provider (threshold: 3+ failures)
-  const topFailure = Object.entries(failureCounts).sort((a, b) => b[1] - a[1])[0];
-  if (topFailure && topFailure[1] >= 3) {
-    patterns.push({ type: 'unreliable_provider', value: topFailure[0], count: topFailure[1] });
-  }
-
-  return {
-    patterns,
-    confidence: Math.min(1, handoffs.length / 10),
-    sampleSize: handoffs.length,
-  };
-}