dual-brain 0.2.30 → 0.3.0

package/src/models.mjs

@@ -1,363 +0,0 @@
-/**
- * models.mjs — Static model intelligence registry for the Dual-Brain Orchestrator.
- *
- * Pure in-memory registry of AI model capabilities used by routing modules.
- * No file I/O, no API calls. Updated with each package release.
- */
-
-export const REGISTRY_VERSION = '2026-05-15';
-export const REGISTRY_UPDATED = '2026-05-15';
-
-export const MODEL_REGISTRY = Object.freeze({
-  'claude-opus-4-6': {
-    provider: 'anthropic',
-    name: 'Claude Opus 4.6',
-    tier: 'frontier',
-    contextWindow: 200000,
-    maxOutput: 32000,
-    strengths: ['complex reasoning', 'architecture', 'code review', 'long context', 'multi-step planning'],
-    weaknesses: ['speed', 'cost'],
-    costTier: 'high',
-    bestFor: ['think', 'review', 'architecture', 'complex debugging'],
-    speed: 'slow',
-    reasoning: true,
-    vision: true,
-    tools: true,
-    agentCapable: true,
-  },
-  'claude-sonnet-4-6': {
-    provider: 'anthropic',
-    name: 'Claude Sonnet 4.6',
-    tier: 'workhorse',
-    contextWindow: 200000,
-    maxOutput: 16000,
-    strengths: ['balanced speed/quality', 'code generation', 'editing', 'testing'],
-    weaknesses: ['less depth on architecture decisions'],
-    costTier: 'medium',
-    bestFor: ['execute', 'implement', 'test', 'fix'],
-    speed: 'medium',
-    reasoning: true,
-    vision: true,
-    tools: true,
-    agentCapable: true,
-  },
-  'claude-haiku-4-5-20251001': {
-    provider: 'anthropic',
-    name: 'Claude Haiku 4.5',
-    tier: 'fast',
-    contextWindow: 200000,
-    maxOutput: 8192,
-    strengths: ['speed', 'low cost', 'simple tasks', 'search', 'classification'],
-    weaknesses: ['complex reasoning', 'multi-step tasks'],
-    costTier: 'low',
-    bestFor: ['search', 'classify', 'simple edits', 'grep'],
-    speed: 'fast',
-    reasoning: false,
-    vision: true,
-    tools: true,
-    agentCapable: true,
-  },
-  'gpt-5.5': {
-    provider: 'openai',
-    name: 'GPT-5.5',
-    tier: 'frontier',
-    contextWindow: 1050000,
-    maxOutput: 128000,
-    strengths: ['massive context', 'complex professional work', 'reasoning', 'web search', 'code interpreter'],
-    weaknesses: ['cost', 'latency on complex reasoning'],
-    costTier: 'premium',
-    bestFor: ['think', 'review', 'research', 'long-context analysis'],
-    speed: 'medium',
-    reasoning: true,
-    vision: true,
-    tools: true,
-    agentCapable: true,
-  },
-  'o3': {
-    provider: 'openai',
-    name: 'o3',
-    tier: 'reasoning',
-    contextWindow: 200000,
-    maxOutput: 100000,
-    strengths: ['deep reasoning', 'math', 'code', 'science', 'multi-step logic'],
-    weaknesses: ['speed', 'cost', 'simple tasks overkill'],
-    costTier: 'premium',
-    bestFor: ['think', 'complex debugging', 'algorithm design', 'security analysis'],
-    speed: 'slow',
-    reasoning: true,
-    vision: true,
-    tools: true,
-    agentCapable: true,
-  },
-  'gpt-4o': {
-    provider: 'openai',
-    name: 'GPT-4o',
-    tier: 'workhorse',
-    contextWindow: 128000,
-    maxOutput: 16384,
-    strengths: ['balanced', 'fast', 'multimodal', 'tool use'],
-    weaknesses: ['less depth than frontier models'],
-    costTier: 'medium',
-    bestFor: ['execute', 'implement', 'chat', 'multimodal'],
-    speed: 'fast',
-    reasoning: false,
-    vision: true,
-    tools: true,
-    agentCapable: true,
-  },
-  'gpt-4o-mini': {
-    provider: 'openai',
-    name: 'GPT-4o Mini',
-    tier: 'fast',
-    contextWindow: 128000,
-    maxOutput: 16384,
-    strengths: ['very fast', 'very cheap', 'good enough for simple tasks'],
-    weaknesses: ['complex reasoning', 'nuanced code review'],
-    costTier: 'low',
-    bestFor: ['search', 'classify', 'simple tasks', 'formatting'],
-    speed: 'fast',
-    reasoning: false,
-    vision: true,
-    tools: true,
-    agentCapable: false,
-  },
-});
-
-const COST_TIER_ORDER = ['low', 'medium', 'high', 'premium'];
-const SPEED_ORDER = ['fast', 'medium', 'slow'];
-const TIER_ORDER = ['fast', 'workhorse', 'reasoning', 'frontier'];
-
-const MODEL_QUIRKS = {
-  'claude-opus-4-6': [
-    'Best for architecture decisions',
-    'Use for code review when quality matters',
-    'Expensive — reserve for high-value tasks',
-  ],
-  'claude-sonnet-4-6': [
-    'Best general-purpose worker',
-    'Good balance of speed and quality',
-    'Use Agent(model: "sonnet") for work dispatch',
-  ],
-  'claude-haiku-4-5-20251001': [
-    'Best for fast search and classification',
-    'Not reliable for multi-step edits',
-    'Use for disposable search agents',
-  ],
-  'gpt-5.5': [
-    'Massive 1M+ context window',
-    'Good challenger for dual-brain think',
-    'Web search and code interpreter available',
-  ],
-  'o3': [
-    'Purpose-built for deep reasoning chains',
-    'Strong challenger for security analysis',
-    'Slow — avoid for quick tasks',
-  ],
-  'gpt-4o': [
-    'Fast and multimodal',
-    'Solid fallback for execute-tier GPT work',
-    'Native tool use support',
-  ],
-  'gpt-4o-mini': [
-    'Cheapest GPT option for simple tasks',
-    'Not agent-capable — single-shot only',
-    'Good for classification and formatting',
-  ],
-};
-
-export function getModel(modelId) {
-  return MODEL_REGISTRY[modelId] ?? null;
-}
-
-export function getModelsForTask(taskType, provider = null) {
-  const entries = Object.entries(MODEL_REGISTRY);
-
-  const filtered = entries.filter(([, m]) => {
-    if (provider && m.provider !== provider) return false;
-    return true;
-  });
-
-  filtered.sort(([, a], [, b]) => {
-    const aMatch = a.bestFor.includes(taskType) ? 1 : 0;
-    const bMatch = b.bestFor.includes(taskType) ? 1 : 0;
-    if (bMatch !== aMatch) return bMatch - aMatch;
-
-    const aTier = TIER_ORDER.indexOf(a.tier);
-    const bTier = TIER_ORDER.indexOf(b.tier);
-    if (bTier !== aTier) return bTier - aTier;
-
-    return SPEED_ORDER.indexOf(a.speed) - SPEED_ORDER.indexOf(b.speed);
-  });
-
-  return filtered.map(([id, m]) => ({ id, ...m }));
-}
-
-export function getBestModel(taskType, constraints = {}) {
-  const { provider = null, maxCost = null, preferSpeed = false, requireReasoning = false, minContext = 0 } = constraints;
-
-  let candidates = getModelsForTask(taskType, provider);
-
-  if (requireReasoning) {
-    candidates = candidates.filter(m => m.reasoning);
-  }
-
-  if (minContext > 0) {
-    candidates = candidates.filter(m => m.contextWindow >= minContext);
-  }
-
-  if (maxCost) {
-    const maxIdx = COST_TIER_ORDER.indexOf(maxCost);
-    if (maxIdx !== -1) {
-      candidates = candidates.filter(m => COST_TIER_ORDER.indexOf(m.costTier) <= maxIdx);
-    }
-  }
-
-  if (preferSpeed) {
-    candidates.sort((a, b) => SPEED_ORDER.indexOf(a.speed) - SPEED_ORDER.indexOf(b.speed));
-  }
-
-  return candidates[0] ?? null;
-}
-
-export function compareModels(modelA, modelB) {
-  const a = MODEL_REGISTRY[modelA];
-  const b = MODEL_REGISTRY[modelB];
-
-  if (!a || !b) {
-    return {
-      contextAdvantage: 'tie',
-      speedAdvantage: 'tie',
-      costAdvantage: 'tie',
-      reasoningAdvantage: 'tie',
-      recommendation: 'One or both model IDs are unknown.',
-    };
-  }
-
-  const ctxAdv = a.contextWindow > b.contextWindow ? 'a'
-    : b.contextWindow > a.contextWindow ? 'b'
-    : 'tie';
-
-  const spdA = SPEED_ORDER.indexOf(a.speed);
-  const spdB = SPEED_ORDER.indexOf(b.speed);
-  const spdAdv = spdA < spdB ? 'a' : spdB < spdA ? 'b' : 'tie';
-
-  const costA = COST_TIER_ORDER.indexOf(a.costTier);
-  const costB = COST_TIER_ORDER.indexOf(b.costTier);
-  const costAdv = costA < costB ? 'a' : costB < costA ? 'b' : 'tie';
-
-  const rsnAdv = (a.reasoning && !b.reasoning) ? 'a'
-    : (b.reasoning && !a.reasoning) ? 'b'
-    : 'tie';
-
-  const aAdvantages = [ctxAdv, spdAdv, costAdv, rsnAdv].filter(v => v === 'a').length;
-  const bAdvantages = [ctxAdv, spdAdv, costAdv, rsnAdv].filter(v => v === 'b').length;
-
-  let recommendation;
-  if (aAdvantages > bAdvantages) {
-    recommendation = `Use ${a.name} for ${a.bestFor.slice(0, 2).join('/')}; ${b.name} as a lighter alternative.`;
-  } else if (bAdvantages > aAdvantages) {
-    recommendation = `Use ${b.name} for ${b.bestFor.slice(0, 2).join('/')}; ${a.name} as a lighter alternative.`;
-  } else {
-    recommendation = `${a.name} and ${b.name} are comparable — choose based on provider availability.`;
-  }
-
-  return { contextAdvantage: ctxAdv, speedAdvantage: spdAdv, costAdvantage: costAdv, reasoningAdvantage: rsnAdv, recommendation };
-}
-
-export function getRegistryAge() {
-  const updated = new Date(REGISTRY_UPDATED);
-  const now = new Date();
-  return Math.floor((now - updated) / (1000 * 60 * 60 * 24));
-}
-
-const COST_SYMBOL = { low: '$', medium: '$$', high: '$$$', premium: '$$$$' };
-
-function fmtCtx(n) {
-  if (n >= 1000000) return `${(n / 1000000).toFixed(2)}M ctx`;
-  return `${Math.round(n / 1000)}K ctx`;
-}
-
-export function formatModelTable(provider = null) {
-  const groups = {};
-  for (const [id, m] of Object.entries(MODEL_REGISTRY)) {
-    if (provider && m.provider !== provider) continue;
-    if (!groups[m.provider]) groups[m.provider] = [];
-    groups[m.provider].push({ id, ...m });
-  }
-
-  const lines = [];
-  const providerLabels = { anthropic: 'Claude Models', openai: 'OpenAI Models' };
-  const providerOrder = ['anthropic', 'openai'];
-
-  for (const prov of providerOrder) {
-    if (!groups[prov]) continue;
-    lines.push(`${providerLabels[prov] ?? prov}:`);
-    for (const m of groups[prov]) {
-      const displayName = m.provider === 'anthropic' ? m.name.replace(/^Claude /, '') : m.name;
-      const name = displayName.padEnd(12);
-      const tier = m.tier.padEnd(10);
-      const ctx = fmtCtx(m.contextWindow).padEnd(10);
-      const speed = m.speed.padEnd(8);
-      const cost = (COST_SYMBOL[m.costTier] ?? '?').padEnd(6);
-      const tasks = m.bestFor.slice(0, 2).join('/');
-      lines.push(`  ${name}${tier}${ctx}${speed}${cost}${tasks}`);
-    }
-    lines.push('');
-  }
-
-  return lines.join('\n').trimEnd();
-}
-
-export function getModelQuirks(modelId) {
-  return MODEL_QUIRKS[modelId] ?? [];
-}
-
-export function suggestModel(intent, risk, complexity, availableProviders = ['anthropic', 'openai']) {
-  const intentLower = (intent || '').toLowerCase();
-
-  const TASK_MAP = {
-    think: ['architect', 'design', 'plan', 'review', 'security', 'audit', 'analysis', 'analyze'],
-    execute: ['implement', 'edit', 'fix', 'refactor', 'test', 'build', 'write', 'update', 'create'],
-    search: ['search', 'find', 'grep', 'look', 'explore', 'classify', 'format', 'list'],
-  };
-
-  let taskType = 'execute';
-  for (const [type, keywords] of Object.entries(TASK_MAP)) {
-    if (keywords.some(kw => intentLower.includes(kw))) {
-      taskType = type;
-      break;
-    }
-  }
-
-  if ((risk === 'critical' || risk === 'high') && taskType !== 'think') {
-    taskType = 'think';
-  }
-
-  const requireReasoning = complexity === 'complex' || risk === 'critical';
-  const preferSpeed = risk === 'low' && complexity === 'simple';
-  const maxCost = risk === 'low' && complexity !== 'complex' ? 'medium' : null;
-
-  const candidates = getModelsForTask(taskType)
-    .filter(m => availableProviders.includes(m.provider))
-    .filter(m => !requireReasoning || m.reasoning)
-    .filter(m => !maxCost || COST_TIER_ORDER.indexOf(m.costTier) <= COST_TIER_ORDER.indexOf(maxCost));
-
-  if (preferSpeed) {
-    candidates.sort((a, b) => SPEED_ORDER.indexOf(a.speed) - SPEED_ORDER.indexOf(b.speed));
-  }
-
-  const best = candidates[0] ?? null;
-  if (!best) {
-    return { model: null, reason: 'No suitable model found for the given constraints.', alternatives: [] };
-  }
-
-  const reason = [
-    `Selected ${best.name} for ${taskType}-tier work`,
-    risk !== 'low' ? `(${risk} risk)` : null,
-    requireReasoning ? '— reasoning required' : null,
-  ].filter(Boolean).join(' ');
-
-  const alternatives = candidates.slice(1, 3).map(m => ({ id: m.id, name: m.name }));
-
-  return { model: best.id, reason, alternatives };
-}

package/src/narrative.mjs

@@ -1,169 +0,0 @@
-// narrative.mjs — HEAD's running narrative: prose it writes to itself between turns.
-// Not structured data. A paragraph or two that captures where we are, what just
-// happened, what's brewing. Loaded at the top of each turn so HEAD is immediately
-// "in the song" without reconstructing from scattered JSON.
-
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-const STATE_DIR = join(process.cwd(), '.dualbrain');
-const NARRATIVE_FILE = join(STATE_DIR, 'narrative.md');
-const NARRATIVE_HISTORY = join(STATE_DIR, 'narrative-history.jsonl');
-
-const MAX_NARRATIVE_LENGTH = 2000;
-const MAX_HISTORY_ENTRIES = 20;
-
-/**
- * Load the current running narrative. Returns empty string if none exists.
- * This is meant to be injected at the top of HEAD's context each turn.
- */
-export function load() {
-  try {
-    if (existsSync(NARRATIVE_FILE)) {
-      return readFileSync(NARRATIVE_FILE, 'utf8').trim();
-    }
-  } catch {}
-  return '';
-}
-
-/**
- * Write a new narrative, replacing the old one.
- * The old narrative is archived to history before overwrite.
- *
- * @param {string} prose - HEAD's current understanding in prose form.
- *   Should answer: Where are we? What just happened? What's brewing?
- *   What did the user care about? What should I not forget?
- */
-export function write(prose) {
-  if (!prose || typeof prose !== 'string') return;
-
-  const trimmed = prose.slice(0, MAX_NARRATIVE_LENGTH).trim();
-  if (!trimmed) return;
-
-  mkdirSync(STATE_DIR, { recursive: true });
-
-  // Archive current before overwriting
-  const current = load();
-  if (current) {
-    _appendHistory(current);
-  }
-
-  writeFileSync(NARRATIVE_FILE, trimmed + '\n');
-}
-
-/**
- * Evolve the narrative — append new observations without replacing everything.
- * Used after dispatches return, after user says something illuminating,
- * or after a wave completes.
- *
- * @param {string} addition - New prose to weave into the narrative.
- * @param {object} opts
- * @param {boolean} opts.replace - If true, replace entirely instead of appending.
- */
-export function evolve(addition, { replace = false } = {}) {
-  if (!addition || typeof addition !== 'string') return;
-
-  if (replace) {
-    write(addition);
-    return;
-  }
-
-  const current = load();
-  const combined = current
-    ? current + '\n\n' + addition.trim()
-    : addition.trim();
-
-  // If too long, keep the newest portion (recency bias for immersion)
-  const final = combined.length > MAX_NARRATIVE_LENGTH
-    ? combined.slice(-MAX_NARRATIVE_LENGTH)
-    : combined;
-
-  mkdirSync(STATE_DIR, { recursive: true });
-  writeFileSync(NARRATIVE_FILE, final.trim() + '\n');
-}
-
-/**
- * Generate a narrative excerpt suitable for a dispatch envelope.
- * Shorter than the full narrative — just enough context for a worker
- * to understand the "why" without the full stream of consciousness.
- *
- * @param {number} maxLength - Max chars for the excerpt (default 500)
- * @returns {string}
- */
-export function excerpt(maxLength = 500) {
-  const full = load();
-  if (!full) return '';
-  if (full.length <= maxLength) return full;
-
-  // Take the last N chars — most recent context is most relevant for workers
-  const trimmed = full.slice(-maxLength);
-  // Find the first sentence boundary to avoid mid-thought cuts
-  const firstPeriod = trimmed.indexOf('. ');
-  if (firstPeriod > 0 && firstPeriod < maxLength * 0.4) {
-    return trimmed.slice(firstPeriod + 2);
-  }
-  return trimmed;
-}
-
-/**
- * Get recent narrative history entries (for warm memory tier).
- * @param {number} n - Number of recent entries to retrieve
- * @returns {Array<{ts: number, text: string}>}
- */
-export function recentHistory(n = 5) {
-  try {
-    if (!existsSync(NARRATIVE_HISTORY)) return [];
-    const lines = readFileSync(NARRATIVE_HISTORY, 'utf8').trim().split('\n').filter(Boolean);
-    return lines.slice(-n).map(line => {
-      try { return JSON.parse(line); } catch { return null; }
-    }).filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Persist the current narrative for precompact survival.
- * Called by the precompact hook before context compression.
- * Returns the narrative that was persisted (for confirmation).
- */
-export function persist() {
-  const current = load();
-  if (!current) return '';
-  // Narrative is already on disk — this just ensures it's fresh
-  // and archives a snapshot with explicit "precompact" marker
-  _appendHistory(current, { reason: 'precompact' });
-  return current;
-}
-
-/**
- * Clear the narrative (used in testing or session reset).
- */
-export function clear() {
-  try {
-    if (existsSync(NARRATIVE_FILE)) {
-      writeFileSync(NARRATIVE_FILE, '');
-    }
-  } catch {}
-}
-
-// ── Internal ──────────────────────────────────────────────────────────────────
-
-function _appendHistory(text, meta = {}) {
-  try {
-    const entry = JSON.stringify({ ts: Date.now(), text: text.slice(0, 800), ...meta });
-    mkdirSync(STATE_DIR, { recursive: true });
-
-    // Cap history file
-    let existing = '';
-    if (existsSync(NARRATIVE_HISTORY)) {
-      existing = readFileSync(NARRATIVE_HISTORY, 'utf8');
-      const lines = existing.trim().split('\n').filter(Boolean);
-      if (lines.length >= MAX_HISTORY_ENTRIES) {
-        existing = lines.slice(-MAX_HISTORY_ENTRIES + 1).join('\n') + '\n';
-      }
-    }
-
-    writeFileSync(NARRATIVE_HISTORY, existing + entry + '\n');
-  } catch {}
-}

package/src/nextstep.mjs

@@ -1,100 +0,0 @@
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
-import { join } from 'path';
-
-const AUTH_PAT = /\b(auth|credential|secret|token|password|encrypt|permission|oauth|jwt|api.?key)\b/i;
-const TEST_PAT = /\b(test|spec|\.test\.|\.spec\.)\b/i;
-
-function gitBranch(cwd) {
-  try { return execSync('git rev-parse --abbrev-ref HEAD', { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim(); }
-  catch { return null; }
-}
-
-function packageVersionChanged(cwd, files) {
-  if (!files.some(f => f.includes('package.json'))) return false;
-  try { return execSync('git diff HEAD~1 HEAD -- package.json', { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString().includes('"version"'); }
-  catch { return false; }
-}
-
-function changelogExists(cwd) {
-  return ['CHANGELOG.md', 'CHANGELOG', 'changelog.md'].some(f => existsSync(join(cwd, f)));
-}
-
-function step(priority, type, message, command, reason) {
-  return { priority, type, message, command, reason };
-}
-
-function dedup(steps) {
-  const seen = new Set();
-  return steps.filter(s => { if (seen.has(s.type)) return false; seen.add(s.type); return true; });
-}
-
-export async function suggestNextSteps(completedTask = {}, outcome = {}, cwd = process.cwd()) {
-  try {
-    const { prompt = '', files = [], trigger } = completedTask;
-    const { success = false, filesChanged = [], error = '' } = outcome;
-    const steps = [];
-    const branch = gitBranch(cwd);
-    const onMain = !branch || branch === 'main' || branch === 'master';
-    const allFiles = [...files, ...filesChanged];
-    const hasAuth = allFiles.some(f => AUTH_PAT.test(f));
-    const hasTests = allFiles.some(f => TEST_PAT.test(f));
-    const n = filesChanged.length;
-    const fs = (count) => `${count} file${count !== 1 ? 's' : ''}`;
-
-    if (trigger === 'auto-commit') {
-      steps.push(!onMain && branch
-        ? step(4, 'pr', `Open a pull request for branch "${branch}"`, `gh pr create --head ${branch}`, `On feature branch — changes need review before merging`)
-        : step(3, 'deploy', 'Deploy or tag a release', null, 'Committed to main — ready to ship or version'));
-      if (packageVersionChanged(cwd, filesChanged))
-        steps.push(step(4, 'publish', 'Publish the new package version to npm', 'npm publish', 'package.json version changed in this commit'));
-      if (changelogExists(cwd) && !filesChanged.some(f => /changelog/i.test(f)))
-        steps.push(step(2, 'changelog', 'Update CHANGELOG with this change', null, 'CHANGELOG exists but was not updated'));
-
-    } else if (trigger === 'review' || trigger === 'think') {
-      const issues = error || /issue|problem|fail|error|warn/i.test(prompt);
-      steps.push(issues
-        ? step(5, 'fix', 'Fix the issues identified in the review', `dual-brain go "fix issues identified in review"`, 'Review found problems that need resolution')
-        : step(3, 'continue', 'Ship it — the review looks good', null, 'Review completed without critical findings'));
-
-    } else if (!success) {
-      steps.push(step(5, 'fix', 'Retry with higher reasoning depth', `dual-brain go --tier think "${prompt}"`, 'Task failed — escalating tier may resolve it'));
-      if (error && /test/i.test(error))
-        steps.push(step(4, 'test', 'Look at test output for clues', null, 'Error references tests — check output to understand the failure'));
-      steps.push(step(3, 'review', 'Try a different approach — dual-brain think', `node .claude/hooks/dual-brain-think.mjs --question "${prompt}"`, 'GPT perspective may surface a different solution'));
-
-    } else if (success && n > 0) {
-      if (!hasTests)
-        steps.push(step(5, 'test', `Run tests to verify the ${fs(n)} changed`, 'npm test', `${fs(n)} changed without test verification`));
-      if (hasAuth)
-        steps.push(step(5, 'review', 'Run a security review on auth/credential changes', `node .claude/hooks/dual-brain-think.mjs --question "Security review: ${prompt}"`, 'Auth or security-sensitive files were modified'));
-      if (n > 3)
-        steps.push(step(4, 'review', `Review the ${n}-file diff before committing`, 'git diff', `${n} files changed — quick diff review before committing`));
-      if (!onMain && branch)
-        steps.push(step(4, 'pr', `Open a pull request for branch "${branch}"`, `gh pr create --head ${branch}`, `Changes are on feature branch "${branch}" — ready for PR`));
-      if (hasTests)
-        steps.push(step(3, 'commit', 'Commit changes', 'git add -p && git commit', 'Tests passed — safe to commit'));
-      steps.push(step(2, 'continue', 'Check for edge cases in the changed code', null, 'Edge cases are often missed during implementation'));
-      if (changelogExists(cwd) && !filesChanged.some(f => /changelog/i.test(f)))
-        steps.push(step(2, 'changelog', 'Update CHANGELOG with this change', null, 'CHANGELOG exists but was not updated in this batch'));
-    }
-
-    const sorted = dedup(steps.sort((a, b) => b.priority - a.priority));
-    return {
-      steps: sorted,
-      topSuggestion: sorted.length > 0 ? `→ ${sorted[0].message}` : '→ Nothing urgent — task complete',
-    };
-  } catch {
-    return { steps: [], topSuggestion: '→ Task complete' };
-  }
-}
-
-export function formatNextSteps(steps, limit = 3) {
-  if (!steps?.length) return '';
-  return `📋 Next steps\n${steps.slice(0, limit).map((s, i) => `  ${i + 1}. ${s.message}`).join('\n')}`;
-}
-
-export function getTopSuggestion(steps) {
-  if (!steps?.length) return '→ Task complete';
-  return `→ ${steps[0].message}`;
-}