ai-control-center 1.15.2

package/lib/shared/action-runner.js

@@ -0,0 +1,2330 @@
+/**
+ * Non-interactive action wrappers for web UI and Telegram bot.
+ *
+ * These functions call the same shell scripts and utilities as the terminal CLI
+ * but accept parameters directly (no inquirer prompts) and return JSON results.
+ */
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { getConfig, getPipelineStage } from '../config.js';
+import { trackPipelineCompletion } from '../utils/achievements.js';
+import { audit, AUDIT_EVENTS, getAuditEntries } from '../utils/audit-logger.js';
+import { getContextString } from '../utils/codebase-context.js';
+import { generateCorrelationId } from '../utils/correlation.js';
+import { formatCostSummary, getActiveBudget, getCostSummary } from '../utils/cost-tracker.js';
+import { appendLearnedContext, saveExternalPrompt } from '../utils/intent-engine.js';
+import { injectPersona, loadPersona } from '../utils/persona-loader.js';
+import { clearCheckpoints, getLatestFilePath, getRootDir, getStatus, getWorkflowDir, loadCheckpoint, saveCheckpoint, updateStatus } from '../utils/pipeline.js';
+import { getPluginStatus, runAfterStage, runBeforeStage } from '../utils/plugin-runner.js';
+import { AILimitError, capture, circuitBreaker, getAIMode, getBannedModels, getOllamaModel, isAvailable, isModelAvailable, isOllamaAvailable, runAI, runClaude, runCopilot, runCopilotWithModel, runGemini, runPipelineStage } from '../utils/runner.js';
+import { injectSkills } from '../utils/skill-loader.js';
+import { logActivity } from '../utils/activity-log.js';
+import { runABTest, saveABResult, getABSummary } from '../utils/model-ab-test.js';
+import { browserTestAction } from '../actions/browser-test.js';
+import { bus } from './event-bus.js';
+
+// ─── Opus Confirmation ────────────────────────────────────────────────────────
+// When Claude fails and Copilot opus would be used for a complex stage,
+// we emit an event and wait for user confirmation (60s timeout → falls back to sonnet).
+
+const _opusConfirmations = new Map(); // featureId → resolve(boolean)
+
+/**
+ * Called by the Telegram bot when user confirms or declines opus usage.
+ */
+export function resolveOpusConfirmation(featureId, confirmed) {
+  const resolver = _opusConfirmations.get(featureId);
+  if (resolver) {
+    resolver(confirmed);
+    _opusConfirmations.delete(featureId);
+  }
+}
+
+/**
+ * Emit an opus confirmation request and await user response (60s timeout).
+ * Returns true if confirmed, false if declined or timed out.
+ */
+async function requestOpusConfirmation(notify, featureId) {
+  return new Promise((resolve) => {
+    _opusConfirmations.set(featureId, resolve);
+    notify('opus_confirm_request', {
+      featureId,
+      message:
+        `⚠️ <b>Claude is unavailable.</b> The architecture stage benefits from a powerful model.\n\n` +
+        `Use <b>Opus 4.6</b> for architecture? This costs premium requests.\n` +
+        `(Sonnet 4.6 will be used automatically in 60s if no reply)`,
+    });
+    // Auto-decline after 60 seconds
+    setTimeout(() => {
+      if (_opusConfirmations.has(featureId)) {
+        _opusConfirmations.delete(featureId);
+        notify('heartbeat', { message: `⏳ No response — using fallback model for architecture` });
+        resolve(false);
+      }
+    }, 60000);
+  });
+}
+
+// ─── Status ───────────────────────────────────────────────────────────────────
+
+export function getStatusData() {
+  const status = getStatus();
+  const banned = getBannedModels();
+  if (banned.length > 0) {
+    status._bannedModels = banned;
+  }
+
+  // Enhanced fields for AI consumers (OpenClaw, scripts)
+  status._provider_health = {};
+  for (const provider of ['gemini', 'claude', 'copilot']) {
+    const state = circuitBreaker.getState(provider);
+    status._provider_health[provider] = state?.state || 'CLOSED';
+  }
+
+  // Stage duration (how long current stage has been active)
+  if (status.metrics?.stages?.[status.stage]?.startedAt) {
+    status._stage_duration_ms = Date.now() - new Date(status.metrics.stages[status.stage].startedAt).getTime();
+  }
+
+  // Last error from status
+  if (status.error) {
+    status._last_error = status.error;
+  }
+
+  // Cost so far for current feature
+  try {
+    const costs = getCostSummary();
+    status._cost_so_far = costs.totalCost || 0;
+  } catch { /* ok */ }
+
+  return status;
+}
+
+// ─── Health Check ─────────────────────────────────────────────────────────────
+
+export async function getHealthData() {
+  const startTime = process.uptime();
+  const checks = {};
+
+  const toolCheck = async (name) => {
+    try {
+      const result = await capture(`which ${name}`);
+      return { available: result.code === 0, path: result.stdout.trim() };
+    } catch {
+      return { available: false, path: null };
+    }
+  };
+
+  checks.gemini  = await toolCheck('gemini');
+  checks.claude  = await toolCheck('claude');
+  checks.copilot = await toolCheck('copilot');
+  checks.sf      = await toolCheck('sf');
+  checks.gh      = await toolCheck('gh');
+
+  const root = getRootDir();
+  const wfDir = getWorkflowDir();
+  checks.workflow = {
+    aiWorkflow: existsSync(wfDir),
+    skills:     existsSync(resolve(root, '.claude/skills')),
+    agents:     existsSync(resolve(root, '.claude/agents')),
+  };
+
+  // Ollama local AI
+  const ollamaStatus = await isOllamaAvailable();
+  checks.ollama = {
+    available: ollamaStatus.available,
+    model: getOllamaModel(),
+    models: ollamaStatus.models,
+    mode: getAIMode(),
+  };
+
+  const status = getStatus();
+  checks.pipeline = status;
+
+  // Enhanced diagnostics (Task 4.1)
+  const banned = getBannedModels();
+
+  // AI provider circuit breaker states
+  checks.ai = {
+    gemini: {
+      circuitState: circuitBreaker.getState('gemini'),
+      bannedModels: banned.filter(b => b.model.includes('gemini')),
+    },
+    claude: {
+      circuitState: circuitBreaker.getState('claude'),
+      bannedModels: banned.filter(b => b.model.includes('claude') || b.model.includes('sonnet') || b.model.includes('haiku')),
+    },
+    copilot: {
+      circuitState: circuitBreaker.getState('copilot'),
+      bannedModels: banned.filter(b => b.model.includes('copilot')),
+    },
+  };
+
+  // Cost info
+  try {
+    const today = new Date().toISOString().slice(0, 10);
+    const allCosts = getCostSummary();
+    checks.costs = {
+      total: allCosts.totalCost,
+      totalCalls: allCosts.totalCalls,
+      byProvider: allCosts.byProvider,
+    };
+  } catch { checks.costs = { total: 0, totalCalls: 0 }; }
+
+  // Token budget for current feature
+  if (status.current_feature) {
+    const budget = getActiveBudget(status.current_feature);
+    if (budget) {
+      checks.tokenBudget = budget.toJSON();
+    }
+  }
+
+  // Pipeline metrics
+  checks.metrics = status.metrics || null;
+
+  // Determine overall health status
+  const anyCircuitOpen = ['gemini', 'claude', 'copilot'].some(
+    p => checks.ai[p]?.circuitState?.state === 'OPEN'
+  );
+  const allCircuitsOpen = ['gemini', 'claude', 'copilot'].every(
+    p => checks.ai[p]?.circuitState?.state === 'OPEN'
+  );
+  const isStalled = status.stage && ['spec', 'arch', 'impl', 'review', 'fix'].includes(status.stage)
+    && status.metrics?.stages?.[status.stage]?.startedAt
+    && (Date.now() - new Date(status.metrics.stages[status.stage].startedAt).getTime()) > 10 * 60 * 1000;
+
+  checks.status = allCircuitsOpen || isStalled ? 'unhealthy' : anyCircuitOpen ? 'degraded' : 'healthy';
+  checks.uptime = Math.round(startTime);
+
+  return checks;
+}
+
+// ─── File Listing ─────────────────────────────────────────────────────────────
+
+export function listFiles(subdir) {
+  const dir = resolve(getWorkflowDir(), subdir);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter(f => f.endsWith('.md') || f.endsWith('.log') || f.endsWith('.json'))
+    .sort()
+    .reverse()
+    .map(f => ({
+      name: f,
+      path: `${subdir}/${f}`,
+    }));
+}
+
+export function readFile(subdir, name) {
+  // Path traversal protection — ensure resolved path stays within workflow dir
+  const wfDir = getWorkflowDir();
+  const filePath = resolve(wfDir, subdir, name);
+  if (!filePath.startsWith(wfDir)) return null;
+  if (!existsSync(filePath)) return null;
+  return readFileSync(filePath, 'utf8');
+}
+
+/**
+ * List all available pipeline documents as labelled items.
+ * Returns an array of { label, key, subdir, name } for the docs keyboard.
+ * key = "{subdir}/{name}" — used as the doc:view callback data.
+ */
+export function listAvailableDocs() {
+  const SUBDIRS = [
+    { dir: 'specs',        emoji: '📝', prefix: 'Spec' },
+    { dir: 'architecture', emoji: '🏗',  prefix: 'Arch' },
+    { dir: 'tasks',        emoji: '📋', prefix: 'Tasks' },
+    { dir: 'reviews',      emoji: '🔍', prefix: 'Review' },
+    { dir: 'approved',     emoji: '✅', prefix: 'Approved' },
+    { dir: 'inbox',        emoji: '📥', prefix: 'Inbox' },
+  ];
+
+  const docs = [];
+  for (const { dir, emoji, prefix } of SUBDIRS) {
+    const files = listFiles(dir);
+    for (const f of files.slice(0, 3)) { // max 3 per subdir
+      // Build short human label: "📝 Spec 0301" from "SPEC-1234567890.md"
+      const short = f.name.replace(/\.(md|json|log)$/, '').replace(/^(SPEC|ARCH|TASKS|REVIEW|FEATURE)-?/i, '').slice(0, 12);
+      docs.push({
+        label: `${emoji} ${prefix} ${short}`,
+        key:   encodeURIComponent(`${dir}/${f.name}`),
+        subdir: dir,
+        name:   f.name,
+      });
+    }
+  }
+  return docs;
+}
+
+/**
+ * Read a doc and return it split into 1400-char pages (safe for Telegram).
+ */
+export function readDocPaged(key, page = 0) {
+  const PAGE_SIZE = 1400;
+  const decoded   = decodeURIComponent(key);
+  const slash     = decoded.indexOf('/');
+  if (slash < 0) return null;
+
+  const subdir   = decoded.slice(0, slash);
+  const name     = decoded.slice(slash + 1);
+  const content  = readFile(subdir, name);
+  if (content === null) return null;
+
+  const pages     = [];
+  for (let i = 0; i < content.length; i += PAGE_SIZE) {
+    pages.push(content.slice(i, i + PAGE_SIZE));
+  }
+  if (pages.length === 0) pages.push('(empty document)');
+
+  return {
+    name,
+    subdir,
+    content: pages[page] || pages[0],
+    page:   Math.min(page, pages.length - 1),
+    totalPages: pages.length,
+    totalChars: content.length,
+  };
+}
+
+// ─── Logs ─────────────────────────────────────────────────────────────────────
+
+export function getLogsData(lines = 100) {
+  const logsDir = resolve(getWorkflowDir(), 'logs');
+  if (!existsSync(logsDir)) return { sessions: [], content: '' };
+
+  const sessions = readdirSync(logsDir)
+    .filter(f => f.endsWith('.log'))
+    .sort()
+    .reverse()
+    .slice(0, 20);
+
+  // Return latest session content
+  if (sessions.length === 0) return { sessions: [], content: '' };
+
+  const latestPath = resolve(logsDir, sessions[0]);
+  const content = readFileSync(latestPath, 'utf8');
+  const allLines = content.split('\n').filter(l => l.trim());
+  const tail = allLines.slice(-lines).join('\n');
+
+  return { sessions, content: tail, total: allLines.length };
+}
+
+/**
+ * List all available log files for the logs keyboard.
+ * Returns array of { label, key, name } — key is the log filename (index-based).
+ */
+export function listAvailableLogs() {
+  const logsDir = resolve(getWorkflowDir(), 'logs');
+  if (!existsSync(logsDir)) return [];
+
+  return readdirSync(logsDir)
+    .filter(f => f.endsWith('.log'))
+    .sort()
+    .reverse()
+    .slice(0, 15)
+    .map((name, idx) => {
+      // Build short label: "session-20260304-001.log" → "🗒 20260304 #001"
+      const short = name.replace(/\.log$/, '').replace(/^session-?/i, '');
+      return { label: `🗒 ${short}`, key: String(idx), name };
+    });
+}
+
+/**
+ * Read a log file by list index and return it split into 1400-char pages.
+ */
+export function readLogPaged(idx, page = 0) {
+  const PAGE_SIZE = 1400;
+  const logsDir = resolve(getWorkflowDir(), 'logs');
+  if (!existsSync(logsDir)) return null;
+
+  const files = readdirSync(logsDir)
+    .filter(f => f.endsWith('.log'))
+    .sort()
+    .reverse();
+
+  const name = files[Number(idx)];
+  if (!name) return null;
+
+  const content = readFileSync(resolve(logsDir, name), 'utf8');
+  // Tail most recent lines (logs can be huge)
+  const lines = content.split('\n').filter(l => l.trim());
+  const recent = lines.slice(-200).join('\n'); // last 200 lines
+
+  const pages = [];
+  for (let i = 0; i < recent.length; i += PAGE_SIZE) {
+    pages.push(recent.slice(i, i + PAGE_SIZE));
+  }
+  if (pages.length === 0) pages.push('(empty log)');
+
+  return {
+    name,
+    content: pages[page] || pages[0],
+    page:   Math.min(page, pages.length - 1),
+    totalPages: pages.length,
+    totalLines: lines.length,
+  };
+}
+
+// ─── Approve ──────────────────────────────────────────────────────────────────
+
+export async function runApprove() {
+  const status = getStatus();
+  if (status.stage !== 'review_complete') {
+    return { success: false, error: `Cannot approve at stage "${status.stage}". Need review_complete.` };
+  }
+
+  try {
+    // Copy latest review to approved/ dir if it exists
+    const workflowDir = getWorkflowDir();
+    const reviewsDir  = resolve(workflowDir, 'reviews');
+    const approvedDir = resolve(workflowDir, 'approved');
+    if (existsSync(reviewsDir)) {
+      mkdirSync(approvedDir, { recursive: true });
+      const reviews = readdirSync(reviewsDir).filter(f => f.endsWith('.md')).sort().reverse();
+      if (reviews.length) {
+        const src = resolve(reviewsDir, reviews[0]);
+        writeFileSync(resolve(approvedDir, reviews[0]), readFileSync(src, 'utf8'));
+      }
+    }
+    updateStatus({ stage: 'approved', next: 'deploy' });
+    bus.emitEvent('feature_approved', { feature: status.current_feature });
+    audit(AUDIT_EVENTS.APPROVED, { feature: status.current_feature });
+    return { success: true, feature: status.current_feature, status: getStatus() };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+// ─── Reject ───────────────────────────────────────────────────────────────────
+
+export async function runReject(reason = 'Rejected via Web/Telegram') {
+  const status = getStatus();
+
+  // Already rejected — re-dispatch existing review blockers to the Coder (no state change needed)
+  if (status.stage === 'rejected') {
+    return runFix();
+  }
+
+  if (!['review_complete', 'implementation_complete'].includes(status.stage)) {
+    return { success: false, error: `Cannot reject at stage "${status.stage}".` };
+  }
+
+  try {
+    updateStatus({ stage: 'rejected', rejection_reason: reason, next: 'fix' });
+    bus.emitEvent('feature_rejected', { feature: status.current_feature, reason });
+    audit(AUDIT_EVENTS.REJECTED, { feature: status.current_feature, reason });
+    return { success: true, status: getStatus() };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+// ─── Deploy ───────────────────────────────────────────────────────────────────
+
+export async function runDeploy(testLevel = 'NoTestRun') {
+  const status = getStatus();
+  const config = getConfig();
+  const deployCmd = config.deploy?.command;
+
+  try {
+    audit(AUDIT_EVENTS.DEPLOY_STARTED, { testLevel });
+
+    // If no deploy command is configured, simply mark the feature as done
+    if (!deployCmd) {
+      updateStatus({ stage: 'deployed', last_deploy: new Date().toISOString() });
+      bus.emitEvent('deploy_success', { testLevel: 'none', message: 'No deploy command configured — feature marked as done.' });
+      audit(AUDIT_EVENTS.DEPLOY_COMPLETED, { testLevel: 'none' });
+      logActivity('PIPELINE', 'SUCCESS', 'Feature marked as deployed (no deploy command configured).');
+      _scheduleAutoReset();
+      return { success: true, stdout: 'No deploy command configured. Feature marked as done.' };
+    }
+
+    const cmd = deployCmd.includes('--test-level') ? deployCmd : `${deployCmd} --test-level ${testLevel}`;
+    const result = await capture(cmd);
+    const success = result.code === 0;
+
+    if (success) {
+      updateStatus({ stage: 'deployed', last_deploy: new Date().toISOString() });
+      bus.emitEvent('deploy_success', { testLevel });
+      audit(AUDIT_EVENTS.DEPLOY_COMPLETED, { testLevel });
+      // Auto-reset pipeline after deployment — 60s delay so user sees the "deployed" notification
+      _scheduleAutoReset();
+    } else {
+      bus.emitEvent('deploy_failed', { error: result.stderr.slice(0, 500), testLevel });
+      audit(AUDIT_EVENTS.DEPLOY_FAILED, { testLevel, error: result.stderr.slice(0, 200) });
+    }
+
+    return {
+      success,
+      stdout: result.stdout.slice(0, 2000),
+      stderr: result.stderr.slice(0, 2000),
+    };
+  } catch (err) {
+    bus.emitEvent('deploy_failed', { error: err.message });
+    return { success: false, error: err.message };
+  }
+}
+
+// ─── New Feature (async — long running) ───────────────────────────────────────
+
+export async function runNewFeature(description, mode = 'manual', type = 'feature', { awaitPipeline = false } = {}) {
+  if (!description || description.trim().length < 10) {
+    return { success: false, error: 'Description must be at least 10 characters.' };
+  }
+
+  const prefix  = type === 'bug' ? 'Fix: ' : '';
+  const fullDesc = `${prefix}${description.trim()}`;
+
+  try {
+    const timestamp   = Math.floor(Date.now() / 1000);
+    const featureId   = `FEATURE-${new Date().toISOString().slice(0, 19).replace(/[-:T]/g, '').slice(0, 15)}`;
+    const workflowDir = getWorkflowDir();
+    const root        = getRootDir();
+    const config      = (() => { try { return getConfig(); } catch { return {}; } })();
+
+    // Step 1: Create inbox file (pure JS — no shell script dependency)
+    const inboxDir = resolve(workflowDir, 'inbox');
+    mkdirSync(inboxDir, { recursive: true });
+    writeFileSync(
+      resolve(inboxDir, `${featureId}.md`),
+      `# Feature Request: ${featureId}\n**Submitted:** ${new Date().toISOString()}\n**Status:** INBOX\n\n## Description\n${fullDesc}\n\n## Context\n- Project: ${config.name || 'Project'}\n`
+    );
+
+    // Clear cancellation flag from any previous /reset
+    _pipelineCancelled = false;
+    updateStatus({ current_feature: featureId, stage: 'inbox', pipeline_mode: mode, next: 'pm_spec', auto_review_count: 0 });
+
+    // Record HEAD at feature submission so review.js can diff from this baseline.
+    // Walk: try root (aicc.config.js dir), then root/sourceDir (actual git repo in monorepo).
+    // Only set once — never overwrite so review always diffs from the original submission point.
+    const existingStartCommit = getStatus().feature_start_commit;
+    if (!existingStartCommit || existingStartCommit === featureId) {
+      const headSha = (() => {
+        const candidates = [root];
+        try {
+          const srcDir = (getConfig()?.review?.sourceDir || '').replace(/^\.\//, '').replace(/\/$/, '');
+          if (srcDir) candidates.push(resolve(root, srcDir));
+        } catch { /* ignore config errors */ }
+        for (const dir of candidates) {
+          try {
+            const sha = execSync('git rev-parse HEAD', { cwd: dir }).toString().trim();
+            if (sha) return sha;
+          } catch { /* try next */ }
+        }
+        return null;
+      })();
+      if (headSha) updateStatus({ feature_start_commit: headSha });
+    }
+
+    bus.emitEvent('feature_created', { feature: featureId, description: fullDesc, mode });
+    audit(AUDIT_EVENTS.FEATURE_CREATED, { featureId, description: fullDesc, mode, type });
+
+    // awaitPipeline: true  → block until pipeline finishes (used by bugfix loop)
+    // awaitPipeline: false → fire-and-forget (used by Telegram bot / web UI)
+    const pipelinePromise = _runPipelineAsync(featureId, fullDesc, timestamp, mode, workflowDir, root, config);
+
+    if (awaitPipeline) {
+      try {
+        await pipelinePromise;
+      } catch (err) {
+        console.error('[Pipeline] Sync error:', err.message);
+        bus.emitEvent('stage_error', {
+          feature: featureId,
+          stage: 'pipeline',
+          error: err.message,
+          message: `💥 Pipeline crashed:\n<b>${err.message.slice(0, 200)}</b>`,
+        });
+        updateStatus({ stage: 'crashed', error: err.message });
+        return { success: false, featureId, error: err.message };
+      }
+      return { success: true, featureId, status: getStatus() };
+    }
+
+    // Non-blocking: catch errors async so they don't go unhandled
+    pipelinePromise.catch(err => {
+        console.error('[Pipeline] Async error:', err.message);
+        bus.emitEvent('stage_error', {
+          feature: featureId,
+          stage: 'pipeline',
+          error: err.message,
+          message: `💥 Pipeline crashed unexpectedly:\n<b>${err.message.slice(0, 200)}</b>\n\nUse /status to check the current state, or start a new feature.`,
+        });
+        updateStatus({ stage: 'crashed', error: err.message });
+      });
+
+    return { success: true, featureId, status: getStatus() };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+// ─── Pipeline cancellation ───────────────────────────────────────────────────
+// When /reset is called, this flag is set so heartbeat timers and notify() stop
+// sending messages for the cancelled pipeline run.
+let _pipelineCancelled = false;
+
+// ─── Background pipeline runner ───────────────────────────────────────────────
+// Roles: PM (spec), Architect (arch+tasks), Coder (impl), Reviewer (review)
+// Provider for each role is configurable via pipeline[] in aicc.config.js.
+
+/**
+ * Emits a 'heartbeat' event every `intervalMs` while an async operation runs.
+ * Returns a stop function to call when the operation completes.
+ */
+function withHeartbeat(notify, label, intervalMs = 120000) {
+  let count = 0;
+  const timer = setInterval(() => {
+    if (_pipelineCancelled) { clearInterval(timer); return; }
+    count++;
+    const mins = Math.round((count * intervalMs) / 60000);
+    notify('heartbeat', { message: `⏳ ${label} in progress... (${mins}min elapsed)` });
+  }, intervalMs);
+  return () => clearInterval(timer);
+}
+
+/**
+ * Implementation-aware heartbeat — reads the tasks file to report real progress.
+ * Shows which tasks are done, which is in progress, and completion percentage.
+ */
+function withImplHeartbeat(notify, tasksFilePath, intervalMs = 60000) {
+  let lastDoneCount = 0;
+
+  function buildProgressMessage() {
+    try {
+      if (!tasksFilePath || !existsSync(tasksFilePath)) {
+        return `⚡ Coder is implementing... (no task list available)`;
+      }
+      const content = readFileSync(tasksFilePath, 'utf8');
+      // Match task lines: - [x] or - [ ] followed by **TASK-NNN**
+      const allTasks = content.match(/^- \[[ x]\] \*\*TASK-\d+\*\*.*$/gm) || [];
+      const doneTasks = content.match(/^- \[x\] \*\*TASK-\d+\*\*.*$/gm) || [];
+
+      const total = allTasks.length;
+      if (total === 0) return `⚡ Coder is implementing...`;
+
+      const done = doneTasks.length;
+      const pct = Math.round((done / total) * 100);
+
+      // Find the current in-progress task (first unchecked)
+      const currentTask = allTasks.find(t => t.startsWith('- [ ]'));
+      let currentLabel = '';
+      if (currentTask) {
+        const match = currentTask.match(/\*\*(TASK-\d+)\*\*:\s*(.+?)(?:\s*\||$)/);
+        if (match) currentLabel = `${match[1]}: ${match[2].trim().slice(0, 60)}`;
+      }
+
+      // Build progress bar
+      const filled = Math.round(pct / 5);
+      const bar = '█'.repeat(filled) + '░'.repeat(20 - filled);
+
+      let msg = `⚡ <b>Implementation Progress</b>\n\n`;
+      msg += `[${bar}] ${pct}%  (${done}/${total} tasks)\n\n`;
+
+      if (currentLabel) {
+        msg += `🔨 <b>Working on:</b> ${currentLabel}\n`;
+      }
+
+      // Show recently completed tasks (new since last check)
+      if (done > lastDoneCount && lastDoneCount > 0) {
+        const newlyDone = doneTasks.slice(lastDoneCount);
+        for (const t of newlyDone.slice(-3)) {
+          const m = t.match(/\*\*(TASK-\d+)\*\*:\s*(.+?)(?:\s*\||$)/);
+          if (m) msg += `✅ ${m[1]}: ${m[2].trim().slice(0, 50)}\n`;
+        }
+      }
+
+      lastDoneCount = done;
+      return msg;
+    } catch {
+      return `⚡ Coder is implementing...`;
+    }
+  }
+
+  const timer = setInterval(() => {
+    if (_pipelineCancelled) { clearInterval(timer); return; }
+    notify('heartbeat', { message: buildProgressMessage() });
+  }, intervalMs);
+
+  return () => clearInterval(timer);
+}
+
+// ─── Pipeline Metrics ─────────────────────────────────────────────────────────
+
+/**
+ * Initialize metrics for a new pipeline run.
+ */
+function initMetrics(featureId) {
+  const metrics = {
+    startedAt: new Date().toISOString(),
+    featureId,
+    stages: {},
+    totalDurationMs: 0,
+    totalTokens: 0,
+    totalCost: 0,
+    errors: [],
+  };
+  updateStatus({ metrics });
+  return metrics;
+}
+
+/**
+ * Record a stage start in metrics.
+ */
+function recordStageStart(stageName, model = 'unknown') {
+  try {
+    const status = getStatus();
+    const metrics = status.metrics || {};
+    if (!metrics.stages) metrics.stages = {};
+    metrics.stages[stageName] = {
+      ...(metrics.stages[stageName] || {}),
+      startedAt: new Date().toISOString(),
+      model,
+    };
+    updateStatus({ metrics });
+  } catch { /* non-fatal */ }
+}
+
+/**
+ * Record a stage completion in metrics.
+ */
+function recordStageEnd(stageName, tokensUsed = 0, retries = 0, model = 'unknown') {
+  try {
+    const status = getStatus();
+    const metrics = status.metrics || {};
+    if (!metrics.stages) metrics.stages = {};
+    const stage = metrics.stages[stageName] || {};
+    const startedAt = stage.startedAt ? new Date(stage.startedAt).getTime() : Date.now();
+    const durationMs = Date.now() - startedAt;
+
+    metrics.stages[stageName] = {
+      ...stage,
+      completedAt: new Date().toISOString(),
+      durationMs,
+      tokensUsed,
+      retries,
+      model,
+    };
+
+    metrics.totalDurationMs = Date.now() - new Date(metrics.startedAt || Date.now()).getTime();
+    metrics.totalTokens = (metrics.totalTokens || 0) + tokensUsed;
+
+    updateStatus({ metrics });
+  } catch { /* non-fatal */ }
+}
+
+/**
+ * Record an error in pipeline metrics.
+ */
+function recordMetricsError(code, message, stageName) {
+  try {
+    const status = getStatus();
+    const metrics = status.metrics || {};
+    if (!metrics.errors) metrics.errors = [];
+    metrics.errors.push({
+      code,
+      message: message.slice(0, 200),
+      stage: stageName,
+      timestamp: new Date().toISOString(),
+    });
+    updateStatus({ metrics });
+  } catch { /* non-fatal */ }
+}
+
+// ─── Retry from Checkpoint ────────────────────────────────────────────────────
+
+/**
+ * Retry the current pipeline stage from the last checkpoint.
+ * If fresh=true, clears checkpoint and retries from scratch.
+ */
+export async function retryFromCheckpoint(fresh = false) {
+  const status = getStatus();
+  const featureId = status.current_feature;
+  if (!featureId) {
+    return { success: false, error: 'No active feature in pipeline.' };
+  }
+
+  if (fresh) {
+    clearCheckpoints(featureId);
+    return { success: true, message: `Checkpoints cleared for ${featureId}. Retrying stage from scratch.`, featureId };
+  }
+
+  // Trigger auto-resume which will pick up from checkpoints
+  try {
+    await autoResumePipeline();
+    return { success: true, message: `Retrying pipeline from last checkpoint for ${featureId}.`, featureId };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+// ─── Dry Run Mode ─────────────────────────────────────────────────────────────
+
+/**
+ * Run a simulated pipeline without making actual AI calls.
+ * Validates the full flow: checkpoint logic, status transitions, notifications, cost tracking.
+ */
+export async function runDryRun(description) {
+  const featureId = `DRYRUN-${Date.now()}`;
+  const workflowDir = getWorkflowDir();
+  const timestamp = Math.floor(Date.now() / 1000);
+  const notify = (event, data) => bus.emitEvent(event, { feature: featureId, ...data });
+
+  // Create inbox
+  const inboxDir = resolve(workflowDir, 'inbox');
+  mkdirSync(inboxDir, { recursive: true });
+  writeFileSync(
+    resolve(inboxDir, `${featureId}.md`),
+    `# Dry Run Feature: ${featureId}\n**Description:** ${description}\n**Status:** DRY-RUN\n`
+  );
+  updateStatus({ current_feature: featureId, stage: 'inbox', pipeline_mode: 'dry-run' });
+  initMetrics(featureId);
+
+  const stages = ['pm_spec', 'explore', 'arch', 'impl'];
+  const models = ['gemini-2.5-pro', 'claude-sonnet-4-6', 'claude-sonnet-4-6', 'claude-sonnet-4.6'];
+  const tokens = [3000, 2000, 6000, 8000];
+
+  for (let i = 0; i < stages.length; i++) {
+    const stageName = stages[i];
+    const model = models[i];
+    const tokenCount = tokens[i];
+
+    console.log(`[DRY-RUN] Simulating ${stageName} — would use ${model} with ~${tokenCount.toLocaleString()} tokens`);
+    notify('stage_start', { stage: stageName, message: `[DRY-RUN] Simulating ${stageName}...` });
+
+    recordStageStart(stageName, model);
+    await new Promise(r => setTimeout(r, 2000)); // 2s simulated delay
+
+    // Save checkpoint
+    saveCheckpoint(featureId, stageName, stageName, { dryRun: true, model });
+    recordStageEnd(stageName, tokenCount, 0, model);
+
+    notify('stage_complete', { stage: stageName, message: `[DRY-RUN] ${stageName} complete` });
+  }
+
+  updateStatus({ stage: 'dry_run_complete' });
+
+  return {
+    success: true,
+    featureId,
+    message: `Dry run complete. Simulated ${stages.length} stages. Total estimated tokens: ${tokens.reduce((a, b) => a + b, 0).toLocaleString()}`,
+    metrics: getStatus().metrics,
+  };
+}
+
+// ─── Auto Review+Fix Loop ─────────────────────────────────────────────────────
+const AUTO_REVIEW_MAX = 3; // max review+fix cycles before asking user to confirm
+const _loopConfirmations = new Map(); // featureId → resolve(boolean)
+
+export function resolveLoopConfirmation(featureId, continueLoop) {
+  const res = _loopConfirmations.get(featureId);
+  if (res) { _loopConfirmations.delete(featureId); res(continueLoop); }
+}
+
+async function _requestLoopConfirmation(notify, featureId) {
+  return new Promise(resolve => {
+    _loopConfirmations.set(featureId, resolve);
+    notify('loop_confirm_request', {
+      featureId,
+      message: `⚠️ Auto-pilot reached <b>${AUTO_REVIEW_MAX} review cycles</b> without APPROVED verdict.\n\nContinue fixing & reviewing, or stop?`,
+    });
+    // Auto-stop after 2 minutes if user doesn't respond
+    setTimeout(() => {
+      if (_loopConfirmations.has(featureId)) {
+        _loopConfirmations.delete(featureId);
+        resolve(false);
+      }
+    }, 120000);
+  });
+}
+
+/**
+ * Review → fix loop: runs up to AUTO_REVIEW_MAX times.
+ * On rejection, the Coder is asked to fix blockers before re-reviewing.
+ * At the limit, asks user to confirm continuing or stopping.
+ */
+async function _runAutoReviewLoop(notify, featureId) {
+  const status = getStatus();
+  let runs = status.auto_review_count || 0;
+
+  while (true) {
+    // ── Review ────────────────────────────────────────────────────────────────
+    updateStatus({ stage: 'review' });
+    notify('stage_start', { stage: 'review', message: `🔍 Reviewer is reviewing implementation... (cycle ${runs + 1}/${AUTO_REVIEW_MAX})` });
+    const stopReviewHB = withHeartbeat(notify, 'code review', 120000);
+    const reviewResult = await runReview();
+    stopReviewHB();
+    runs++;
+    updateStatus({ auto_review_count: runs });
+
+    if (!reviewResult.success) {
+      notify('stage_error', { stage: 'review', error: reviewResult.error, message: `❌ Review failed: ${reviewResult.error?.slice(0, 100)}\n\n⚠️ Skipping this review cycle and continuing...` });
+      // Don't stop the loop — allow continuing to next cycle or fallback
+      if (runs >= AUTO_REVIEW_MAX) {
+        notify('stage_error', { stage: 'review', message: `❌ Review failed ${runs} times. Stopping pipeline.` });
+        return;
+      }
+      continue;
+    }
+
+    const review = getLatestReview();
+    const verdict = review?.verdict || 'UNKNOWN';
+    const reviewSummary = review ? review.content.slice(0, 500) + (review.content.length > 500 ? '\n\n...(truncated, use /docs to read full review)' : '') : '';
+
+    notify('stage_complete', {
+      stage: 'review_complete',
+      message: `🔍 Review cycle ${runs}/${AUTO_REVIEW_MAX}: <b>${verdict}</b>\n\n${reviewSummary}`,
+    });
+
+    // ── APPROVED → auto-approve and done ─────────────────────────────────────
+    if (verdict === 'APPROVED') {
+      const approveResult = await runApprove();
+      if (approveResult.success) {
+        updateStatus({ auto_review_count: 0 });
+        notify('stage_complete', { stage: 'approved', message: `✅ Feature approved — deploying now...` });
+        // Auto-deploy in auto mode
+        updateStatus({ stage: 'deploying' });
+        const stopDeployHB = withHeartbeat(notify, 'deploy', 120000);
+        const deployResult = await runDeploy('RunLocalTests');
+        stopDeployHB();
+        if (deployResult.success) {
+          updateStatus({ stage: 'deployed' });
+          notify('stage_complete', { stage: 'deployed', message: `🚀 Deployment complete! Feature shipped! 🎉` });
+        } else {
+          notify('stage_error', { stage: 'deploy', error: deployResult.error, message: `⚠️ Auto-deploy failed: ${(deployResult.error || deployResult.stderr || 'unknown').slice(0, 200)}\n\nUse /deploy to retry.` });
+        }
+      } else {
+        notify('stage_error', { stage: 'approve', error: approveResult.error, message: `⚠️ Auto-approve failed: ${approveResult.error}` });
+      }
+      return;
+    }
+
+    // ── Max cycles hit → ask user to confirm continuing ───────────────────────
+    if (runs >= AUTO_REVIEW_MAX) {
+      const continueLoop = await _requestLoopConfirmation(notify, featureId);
+      if (!continueLoop) {
+        updateStatus({ pipeline_mode: 'manual', auto_review_count: 0 });
+        notify('stage_complete', {
+          stage: 'review_rejected',
+          message: `🛑 Auto-pilot stopped after ${runs} review cycles.\n\nReview verdict: <b>${verdict}</b>\n\nCheck /docs for details. Switched to manual mode — use /reject to send specific fixes.`,
+        });
+        return;
+      }
+      runs = 0; // Reset counter for next batch
+      updateStatus({ auto_review_count: 0 });
+    }
+
+    // ── REJECTED → ask Coder to fix blockers, then loop ────────────────────────
+    const blockers = review ? extractBlockers(review.content) : 'See latest review in /docs.';
+    updateStatus({ stage: 'rejected' });
+    notify('stage_start', { stage: 'fix', message: `🔧 Coder is fixing blockers from review cycle ${runs}...\n\n${blockers.slice(0, 300)}` });
+    const stopFixHB = withHeartbeat(notify, 'fixing review blockers', 120000);
+    try {
+      const fixPrompt =
+        `You are the Coder. The code review was REJECTED.\n\n` +
+        `Fix ALL the following blockers identified in the code review:\n\n${blockers}\n\n` +
+        `Make the actual code changes to fix these issues. Do not explain — just fix.`;
+      await runPipelineStage('implement', fixPrompt, { featureId, stage: 'fix' });
+    } catch (err) {
+      stopFixHB();
+      if (err instanceof AILimitError) {
+        // All AI models exhausted — schedule retry with increasing backoff (15m, 30m, 45m…)
+        const retryCount = getStatus().exhaustion_retry_count || 0;
+        const attempt    = retryCount + 1;
+        const delayMs    = attempt * 15 * 60 * 1000;
+        const delayMins  = attempt * 15;
+        updateStatus({ exhaustion_retry_count: attempt });
+        notify('stage_error', {
+          stage: 'fix',
+          error: err.message,
+          message:
+            `⏳ <b>All AI models exhausted</b> (attempt ${attempt}).\n\n` +
+            `Will retry automatically in <b>${delayMins} minutes</b>...\n` +
+            `(next attempt in ${delayMins}m → ${delayMins + 15}m → etc.)\n\n` +
+            `${err.message.slice(0, 120)}`,
+        });
+        await new Promise(r => setTimeout(r, delayMs));
+        notify('stage_start', { stage: 'fix', message: `🔄 Resuming after ${delayMins}m wait — retrying review cycle...` });
+        continue; // loop back to fresh review at the top
+      }
+      notify('stage_error', { stage: 'fix', error: err.message, message: `❌ Fix failed: ${err.message.slice(0, 100)}` });
+      return;
+    }
+    stopFixHB();
+    updateStatus({ exhaustion_retry_count: 0 }); // reset backoff counter on successful fix
+
+    // ── Diff check: did the Coder actually change anything? ──────────────────────
+    // If no files changed, the fix was a no-op — stop looping to avoid wasting
+    // another review cycle (and AI premium requests).
+    try {
+      const diffResult = await capture('git', ['diff', '--stat', 'HEAD'], { timeout: 10000 });
+      const diffOutput = (diffResult.stdout || '').trim();
+      if (!diffOutput) {
+        notify('stage_error', {
+          stage: 'fix',
+          message: `⚠️ Fix produced no changes after review cycle ${runs}.\n\n` +
+            `Stopping auto-review loop — manual intervention needed.\n` +
+            `Use /reject <specific instructions> to guide the Coder.`,
+        });
+        updateStatus({ pipeline_mode: 'manual', auto_review_count: 0 });
+        return;
+      }
+    } catch { /* git diff failed — continue with review anyway */ }
+
+    notify('stage_complete', { stage: 'fix_complete', message: `🔧 Coder applied fixes — re-reviewing...` });
+  }
+}
+
+function extractBlockers(reviewContent) {
+  // Extract the Blockers section from the review markdown
+  const parts = reviewContent.split(/##[^#]*Blocker/i);
+  if (parts.length < 2) return reviewContent.slice(0, 800);
+  const blockerSection = parts[1].split(/^##/m)[0].trim();
+  return blockerSection || reviewContent.slice(0, 800);
+}
+
+async function _runPipelineAsync(featureId, fullDesc, timestamp, mode, workflowDir, root, config) {
+  const inboxContent = readFileSync(resolve(workflowDir, `inbox/${featureId}.md`), 'utf8');
+  const projectName = config.name || 'project';
+  initMetrics(featureId);
+
+  // Correlation ID for tracing this pipeline run
+  let correlationId;
+  try { correlationId = generateCorrelationId(); } catch (e) { /* correlation is optional */ }
+  const pipelineStartTime = Date.now();
+
+  // Notify helper — sends both a bus event and updates status with a message field
+  // Suppressed after /reset to prevent stale messages from lingering pipeline processes
+  const notify = (event, data) => {
+    if (_pipelineCancelled) return;
+    bus.emitEvent(event, { feature: featureId, ...data });
+  };
+
+  // ── Step 2: PM spec (config-driven provider) ────────────────────────────────
+  const specsDir = resolve(workflowDir, 'specs');
+  mkdirSync(specsDir, { recursive: true });
+  const specFile = resolve(specsDir, `SPEC-${timestamp}.md`);
+  const pmEntry = getPipelineStage('pm') || { provider: 'claude', model: 'claude-sonnet-4-6' };
+
+  // Check for existing checkpoint
+  const specCheckpoint = loadCheckpoint(featureId, 'pm_spec');
+  if (specCheckpoint && specCheckpoint.outputs?.specFile && existsSync(resolve(workflowDir, `specs/SPEC-${timestamp}.md`))) {
+    notify('stage_complete', { stage: 'spec_complete', message: `📝 Resuming from checkpoint: pm_spec (saved ${specCheckpoint.completedAt})` });
+    console.log(`[PIPELINE] Resuming from checkpoint: pm_spec (saved ${specCheckpoint.completedAt})`);
+  } else {
+    await runBeforeStage('spec', { featureId, inboxContent, timestamp });
+    updateStatus({ stage: 'spec' });
+    notify('stage_start', { stage: 'spec', message: `📝 PM is writing the feature spec...` });
+    recordStageStart('spec', pmEntry.provider);
+    const stopSpecHB = withHeartbeat(notify, 'PM spec', 120000);
+
+    // Build spec prompt — use GEMINI.md, CLAUDE.md, or generic context
+    const geminiMd = resolve(root, 'GEMINI.md');
+    const claudeMd = resolve(root, 'CLAUDE.md');
+    const contextFile = existsSync(geminiMd) ? geminiMd : existsSync(claudeMd) ? claudeMd : null;
+    const contextContent = contextFile ? readFileSync(contextFile, 'utf8').slice(0, 3000) : '';
+
+    let specPrompt =
+      `${contextContent}\n\n## Feature Request\n${inboxContent}\n\n` +
+      `Create a complete PM spec with User Stories, Acceptance Criteria, Technical Risks, Dependencies, and Priority for ${projectName}.\n` +
+      `Write the spec document to: .ai-workflow/specs/SPEC-${timestamp}.md`;
+
+    // Inject skills and persona for spec stage
+    try { specPrompt = injectSkills(specPrompt, 'spec'); } catch { /* skills are optional */ }
+    try {
+      const persona = loadPersona('pm');
+      if (persona) specPrompt = injectPersona(specPrompt, persona);
+    } catch { /* personas are optional */ }
+
+    try {
+      await runPipelineStage('pm', specPrompt, { featureId, stage: 'pm', outputFile: specFile });
+      stopSpecHB();
+
+      // Verify spec was created — if provider wrote to stdout (redirect) or to file (tools)
+      if (!existsSync(specFile) || readFileSync(specFile, 'utf8').trim().length < 50) {
+        // Check if the provider created a file with a different name pattern
+        const specFiles = readdirSync(specsDir).filter(f => f.endsWith('.md') && !f.includes('stderr') && !f.includes('challenger'));
+        const latestSpec = specFiles.sort().pop();
+        if (latestSpec && latestSpec !== `SPEC-${timestamp}.md`) {
+          const altSpecPath = resolve(specsDir, latestSpec);
+          const altContent = readFileSync(altSpecPath, 'utf8').trim();
+          if (altContent.length > 50) {
+            writeFileSync(specFile, altContent);
+          }
+        }
+      }
+
+      // Final fallback: create minimal spec if nothing was produced
+      if (!existsSync(specFile) || readFileSync(specFile, 'utf8').trim().length < 50) {
+        writeFileSync(specFile,
+          `# SPEC-${timestamp}\n**Feature: ${fullDesc}**\n\n**Date:** ${new Date().toISOString().slice(0, 10)}\n**Status:** Pending Architecture\n\n${fullDesc}\n`
+        );
+        notify('stage_complete', { stage: 'spec_complete', message: `📝 Minimal spec created` });
+      } else {
+        notify('stage_complete', { stage: 'spec_complete', message: `📝 Spec complete` });
+      }
+    } catch (specErr) {
+      stopSpecHB();
+      console.error('[Pipeline] Spec stage failed:', specErr.message);
+      // Create minimal spec so pipeline can continue
+      writeFileSync(specFile,
+        `# SPEC-${timestamp}\n**Feature: ${fullDesc}**\n\n**Date:** ${new Date().toISOString().slice(0, 10)}\n**Status:** Pending Architecture\n\n${fullDesc}\n`
+      );
+      notify('stage_complete', { stage: 'spec_complete', message: `📝 Minimal spec created (AI unavailable)` });
+    }
+
+    saveCheckpoint(featureId, 'spec', 'pm_spec', { specFile: `SPEC-${timestamp}.md`, timestamp });
+    recordStageEnd('spec', 0, 0, pmEntry.provider);
+    await runAfterStage('spec', { featureId, specFile, timestamp });
+  }
+  updateStatus({ stage: 'spec_complete', latest_spec: `SPEC-${timestamp}`, next: 'architect' });
+
+  // ── Step 3: Architecture + tasks (config-driven provider) ───────────────────
+  mkdirSync(resolve(workflowDir, 'architecture'), { recursive: true });
+  mkdirSync(resolve(workflowDir, 'tasks'), { recursive: true });
+  const specContent = existsSync(specFile) ? readFileSync(specFile, 'utf8') : fullDesc;
+  const archEntry = getPipelineStage('architect') || { provider: 'claude', model: 'claude-opus-4-6' };
+
+  const archCheckpoint = loadCheckpoint(featureId, 'arch');
+  if (archCheckpoint) {
+    notify('stage_complete', { stage: 'arch_complete', message: `🏗 Resuming from checkpoint: arch (saved ${archCheckpoint.completedAt})` });
+    console.log(`[PIPELINE] Resuming from checkpoint: arch (saved ${archCheckpoint.completedAt})`);
+  } else {
+    const claudeMd  = resolve(root, 'CLAUDE.md');
+    const claudeCtx = existsSync(claudeMd) ? `\n\n## Project Context\n${readFileSync(claudeMd, 'utf8').slice(0, 3000)}` : '';
+
+    let archPrompt =
+      `You are the System Architect for ${projectName}.${claudeCtx}\n\n` +
+      `Read this feature spec and:\n` +
+      `1. Write a detailed architecture doc to: .ai-workflow/architecture/ARCH-${timestamp}.md\n` +
+      `   Include: Data flow, new classes/components, schema changes\n` +
+      `2. Write step-by-step implementation tasks to: .ai-workflow/tasks/TASKS-${timestamp}.md\n` +
+      `   Each task must reference exact file paths and function names\n\n` +
+      `## Feature Spec\n${specContent}`;
+
+    // Inject skills and persona for architect stage
+    try { archPrompt = injectSkills(archPrompt, 'arch'); } catch { /* skills are optional */ }
+    try {
+      const persona = loadPersona('architect');
+      if (persona) archPrompt = injectPersona(archPrompt, persona);
+    } catch { /* personas are optional */ }
+
+    await runBeforeStage('arch', { featureId, specContent, timestamp });
+    updateStatus({ stage: 'architecture' });
+    notify('stage_start', { stage: 'arch', message: `🏗 Architect is designing the architecture...` });
+    recordStageStart('arch', archEntry.provider);
+    const stopArchHB = withHeartbeat(notify, 'architecture', 120000);
+    let archSuccess = false;
+    try {
+      await runPipelineStage('architect', archPrompt, { featureId, stage: 'arch' });
+      stopArchHB();
+
+      // Verify architecture doc was created
+      const archDir = resolve(workflowDir, 'architecture');
+      const archFiles = readdirSync(archDir).filter(f => f.endsWith('.md'));
+      const tasksDir = resolve(workflowDir, 'tasks');
+      const taskFiles = existsSync(tasksDir) ? readdirSync(tasksDir).filter(f => f.endsWith('.md')) : [];
+      if (archFiles.length === 0 && taskFiles.length === 0) {
+        console.warn('[Pipeline] Architecture stage completed but no ARCH/TASKS files found');
+        notify('stage_complete', { stage: 'arch_complete', message: `🏗 Architecture complete (no docs written — provider may need file write permissions)` });
+      } else {
+        archSuccess = true;
+        notify('stage_complete', { stage: 'arch_complete', message: `🏗 Architecture + tasks complete` });
+      }
+    } catch (archErr) {
+      stopArchHB();
+      notify('stage_error', { stage: 'arch', error: archErr.message, message: `❌ Architecture failed: ${archErr.message.slice(0, 100)}` });
+      console.error('[Pipeline] Architecture stage failed:', archErr.message);
+    }
+    // Only save checkpoint if architecture files were actually created
+    if (archSuccess) {
+      saveCheckpoint(featureId, 'arch', 'arch', { timestamp });
+    }
+    recordStageEnd('arch', 0, 0, archEntry.provider);
+    await runAfterStage('arch', { featureId, timestamp });
+  }
+  updateStatus({ stage: 'arch_complete', next: 'implement' });
+
+  // ── Step 4: Implementation (config-driven provider) ─────────────────────────
+  const implEntry = getPipelineStage('implement') || { provider: 'claude', model: 'claude-sonnet-4-6' };
+  await runBeforeStage('impl', { featureId, mode, timestamp });
+  recordStageStart('impl', implEntry.provider);
+  if (mode === 'auto') {
+    const implResult = await runImplementation();
+    if (!implResult.success) {
+      console.error('[Pipeline] Implementation failed:', implResult.error);
+      return;
+    }
+  } else {
+    const tasksFile = getLatestFilePath('tasks');
+    notify('tasks_ready', { tasksFile: tasksFile || null, message: `✅ Architecture complete! Tasks are ready.\nUse /approve to start implementation, or /review for a code review first.` });
+  }
+  recordStageEnd('impl', 0, 0, implEntry.provider);
+  saveCheckpoint(featureId, 'impl', 'impl', { mode, timestamp });
+  await runAfterStage('impl', { featureId, mode, timestamp });
+
+  // Track achievement after pipeline completion
+  try {
+    const notifications = trackPipelineCompletion({
+      action: 'feature',
+      duration: Date.now() - pipelineStartTime,
+      cost: 0,
+      model: implEntry.provider,
+      success: true,
+      reviewIssues: 0,
+    });
+    if (notifications.length > 0) {
+      notifications.forEach(n => bus.emitEvent('pipeline-event', { type: 'achievement', message: n }));
+    }
+  } catch { /* achievements are optional */ }
+}
+
+// ─── Standalone Implementation Runner ───────────────────────────────────────
+// Runs the implementation step standalone — uses configured provider from pipeline.
+// Used by /implement command and autoResumePipeline.
+// Works from stage arch_complete or implementation_failed.
+export async function runImplementation() {
+  const status = getStatus();
+  const allowedStages = ['arch_complete', 'implementation_failed'];
+  if (!allowedStages.includes(status.stage)) {
+    return { success: false, error: `Cannot start implementation from stage "${status.stage}". Must be arch_complete or implementation_failed.` };
+  }
+
+  const featureId = status.current_feature;
+  if (!featureId) {
+    return { success: false, error: 'No active feature.' };
+  }
+
+  const tasksFile = getLatestFilePath('tasks');
+  const specFile  = getLatestFilePath('specs');
+
+  // Determine content source: prefer tasks file, fall back to spec file
+  let implContent = null;
+  let implSource  = null;
+  if (tasksFile && existsSync(tasksFile)) {
+    implContent = readFileSync(tasksFile, 'utf8').slice(0, 4000);
+    implSource  = 'tasks';
+  } else if (specFile && existsSync(specFile)) {
+    implContent = readFileSync(specFile, 'utf8').slice(0, 4000);
+    implSource  = 'spec';
+    console.log('[Pipeline] No tasks file found — falling back to spec file for implementation');
+  } else {
+    return { success: false, error: 'No tasks or spec file found. Cannot start implementation.' };
+  }
+
+  const config = getConfig();
+  const projectName = config.name || 'this project';
+  const notify = (event, data) => {
+    if (_pipelineCancelled) return;
+    bus.emitEvent(event, { feature: featureId, ...data });
+  };
+
+  const implPrompt = implSource === 'tasks'
+    ? `You are the Coder for ${projectName}.\nImplement ALL the tasks in this file. Make the actual code changes:\n\n${implContent}`
+    : `You are the Coder for ${projectName}.\nThe architecture stage did not produce a tasks file. Use this feature spec to implement the feature directly. Create all necessary files and make all code changes described:\n\n${implContent}`;
+
+  const startMsg = implSource === 'tasks'
+    ? `⚡ Coder is implementing the tasks...`
+    : `⚡ Coder is implementing from spec (no tasks file found)...`;
+  updateStatus({ stage: 'implementation' });
+  notify('stage_start', { stage: 'impl', message: startMsg });
+  const stopImplHB = withImplHeartbeat(notify, tasksFile, 120000);
+  try {
+    await runPipelineStage('implement', implPrompt, { featureId, stage: 'impl' });
+    stopImplHB();
+
+    // Self-healing: run tests and auto-fix
+    try {
+      const healResult = await selfHealPipeline(featureId, config);
+      if (!healResult.skipped && !healResult.success) {
+        logActivity('PIPELINE', '⚠️ Self-heal could not fix all test failures — proceeding to review', 'warn');
+      }
+    } catch (e) {
+      logActivity('PIPELINE', `Self-heal error: ${e.message}`, 'error');
+    }
+
+    updateStatus({ stage: 'implementation_complete', next: 'review' });
+    notify('stage_complete', { stage: 'implementation_complete', message: `⚡ Implementation complete` });
+
+    // If in auto mode, continue the pipeline to review
+    if (status.pipeline_mode === 'auto') {
+      await _runAutoReviewLoop(notify, featureId);
+    }
+    return { success: true };
+  } catch (err) {
+    stopImplHB();
+    console.error('[Pipeline] Implementation failed:', err.message);
+    updateStatus({ stage: 'implementation_failed', error: err.message, next: 'retry' });
+    notify('stage_error', { stage: 'impl', error: err.message, message: `❌ Implementation failed: ${err.message.slice(0, 100)}` });
+    return { success: false, error: err.message };
+  }
+}
+
+// ─── Self-Healing Pipeline ───────────────────────────────────────────────────
+// After implementation, runs the test suite and sends failures back to
+// the Coder for automatic fixing (up to maxAttempts retries).
+
+async function selfHealPipeline(featureId, config) {
+  const selfHeal = config.selfHeal || {};
+  if (!selfHeal.enabled) return { success: true, skipped: true };
+
+  const testCmd = selfHeal.testCommand || config.deploy?.testCommand || 'npm test';
+  const maxAttempts = selfHeal.maxAttempts || 3;
+
+  logActivity('PIPELINE', `Self-heal: running "${testCmd}"...`, 'info');
+  bus.emitEvent('pipeline-event', { type: 'self-heal-start', featureId });
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      execSync(testCmd, {
+        encoding: 'utf8',
+        timeout: 120000,
+        cwd: process.cwd(),
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      logActivity('PIPELINE', `Self-heal SUCCESS — all tests pass (attempt ${attempt})`, 'ok');
+      bus.emitEvent('pipeline-event', {
+        type: 'self-heal-success',
+        featureId,
+        attempts: attempt,
+        message: `Self-heal SUCCESS after ${attempt} attempt(s)`,
+      });
+      return { success: true, attempts: attempt };
+    } catch (err) {
+      const stderr = err.stderr || err.stdout || err.message || 'Unknown error';
+      const errorOutput = stderr.substring(0, 3000);
+
+      logActivity('PIPELINE', `Self-heal attempt ${attempt}/${maxAttempts} — tests failed`, 'error');
+      bus.emitEvent('pipeline-event', {
+        type: 'self-heal-retry',
+        featureId,
+        attempt,
+        maxAttempts,
+        message: `Self-healing: attempt ${attempt}/${maxAttempts} — fixing test failures`,
+      });
+
+      if (attempt < maxAttempts) {
+        const healPrompt = `The following test failures occurred after implementing a feature. Fix these errors without breaking existing functionality.\n\nTest command: ${testCmd}\n\nError output:\n\`\`\`\n${errorOutput}\n\`\`\`\n\nFix the code to make all tests pass. Only modify the files that need changes.`;
+
+        try {
+          await runPipelineStage('implement', healPrompt, {
+            featureId,
+            stage: 'self-heal',
+          });
+        } catch (healErr) {
+          logActivity('PIPELINE', `Self-heal fix attempt failed: ${healErr.message}`, 'error');
+        }
+      }
+    }
+  }
+
+  logActivity('PIPELINE', `Self-heal FAILED after ${maxAttempts} attempts — proceeding to review with warning`, 'error');
+  bus.emitEvent('pipeline-event', {
+    type: 'self-heal-failed',
+    featureId,
+    maxAttempts,
+    message: `Self-heal failed after ${maxAttempts} attempts`,
+  });
+  return { success: false, attempts: maxAttempts };
+}
+
+// ─── Rewrite Docs (Spec + Arch) ──────────────────────────────────────────────
+// Triggered when user asks to "rework the spec" or "redo the architecture".
+// Runs the Architect to update the docs, then transitions to arch_complete so the
+// standard notification system fires ("🏗 Architecture complete — tasks ready.")
+// and the user can start implementation via the inline button.
+export async function runRewriteDocs(description) {
+  const status = getStatus();
+  const featureId = status.current_feature || `FEATURE-${Math.floor(Date.now() / 1000)}`;
+  const notify = (event, data) => bus.emitEvent(event, { feature: featureId, ...data });
+
+  // Load latest spec for context
+  const specFile = getLatestFilePath('specs');
+  const archFile = getLatestFilePath('architecture');
+  const specContent = (specFile && existsSync(specFile))
+    ? readFileSync(specFile, 'utf8').slice(0, 3000) : '';
+  const archContent = (archFile && existsSync(archFile))
+    ? readFileSync(archFile, 'utf8').slice(0, 2000) : '';
+
+  const desc = description?.trim() || 'Revise and improve the current spec and architecture';
+
+  const prompt = specContent
+    ? `You are the architect for this project.\n\nThe user asked: "${desc}"\n\nCurrent spec for reference:\n${specContent}\n\n${archContent ? `Current architecture:\n${archContent}\n\n` : ''}Please:\n1. Rewrite the spec document (update the SPEC file with improved requirements)\n2. Rewrite the architecture document (update the ARCH file with implementation plan)\n3. Create a TASKS file with clear, actionable implementation tasks for the Coder\n\nMake all necessary file writes in the .ai-workflow/specs/, .ai-workflow/architecture/, and .ai-workflow/tasks/ directories.`
+    : `You are the architect for this project.\n\nThe user asked: "${desc}"\n\nPlease create:\n1. A spec document in .ai-workflow/specs/\n2. An architecture document in .ai-workflow/architecture/\n3. A TASKS file in .ai-workflow/tasks/ with actionable implementation steps for the Coder`;
+
+  notify('stage_start', { stage: 'rewrite_docs', message: `🔄 Rewriting spec and architecture docs...\n\n"${desc}"` });
+  const stopHB = withHeartbeat(notify, 'doc rewrite', 120000);
+
+  try {
+    await runPipelineStage('architect', prompt, { featureId, stage: 'arch' });
+    stopHB();
+
+    // Transition to arch_complete — the event bus file watcher will auto-send
+    // the "🏗 Architecture complete — tasks ready." Telegram notification with buttons.
+    updateStatus({
+      current_feature: featureId,
+      stage: 'arch_complete',
+      pipeline_mode: status.pipeline_mode || 'manual',
+      next: 'implement',
+    });
+
+    return { success: true };
+  } catch (err) {
+    stopHB();
+    console.error('[Pipeline] runRewriteDocs failed:', err.message);
+    notify('stage_error', {
+      stage: 'rewrite_docs',
+      error: err.message,
+      message: `❌ Failed to rewrite docs: ${err.message.slice(0, 150)}\n\nUse /feature to start fresh.`,
+    });
+    return { success: false, error: err.message };
+  }
+}
+
+// ─── Pipeline Resume (after restart) ─────────────────────────────────────────
+// If the bot restarts mid-pipeline in auto mode, resume from the pending step.
+export async function autoResumePipeline() {
+  const status = getStatus();
+  if (status?.pipeline_mode !== 'auto') return;
+  const { stage, next } = status;
+
+  const featureId = status.current_feature;
+  const notify = (event, data) => bus.emitEvent(event, { feature: featureId, ...data });
+
+  // Resume: arch complete but implementation hasn't started yet
+  if (stage === 'arch_complete' && next === 'implement') {
+    console.log('[Pipeline] Resuming auto pipeline from arch_complete → implement');
+    notify('stage_start', { stage: 'impl', message: `🔄 Bot restarted — resuming implementation...` });
+    const implResult = await runImplementation();
+    if (!implResult.success) {
+      console.error('[Pipeline] runImplementation failed on resume:', implResult.error);
+      notify('stage_error', { stage: 'impl', message: `❌ Implementation failed to start: ${implResult.error}\n\nUse /status to check the pipeline state or /implement to retry.` });
+    }
+    return; // runImplementation handles the rest (review loop etc.)
+  }
+
+  // Resume: implementation finished but review hasn't run yet
+  if (stage === 'implementation_complete' && next === 'review') {
+    console.log('[Pipeline] Resuming auto pipeline from implementation_complete → review');
+    notify('stage_start', { stage: 'review', message: `🔄 Bot restarted — resuming auto-pilot from review stage...` });
+    await _runAutoReviewLoop(notify, featureId);
+  }
+
+  // Resume: review done and approved but not yet committed
+  if (stage === 'review_complete' && next === 'approve_or_reject') {
+    const review = getLatestReview();
+    const verdict = review?.verdict || 'UNKNOWN';
+    if (verdict === 'APPROVED') {
+      notify('stage_start', { stage: 'approve', message: `🔄 Bot restarted — resuming auto-approval...` });
+      const approveResult = await runApprove();
+      if (approveResult.success) {
+        notify('stage_complete', { stage: 'approved', message: `✅ Feature approved — auto-deploying...` });
+        updateStatus({ stage: 'deploying' });
+        notify('stage_start', { stage: 'deploy', message: `🚀 Resuming auto-deploy after restart...` });
+        const deployResult = await runDeploy('RunLocalTests');
+        if (deployResult.success) {
+          notify('stage_complete', { stage: 'deployed', message: `🚀 Deployment complete! Feature shipped! 🎉` });
+        } else {
+          notify('stage_error', { stage: 'deploy', error: deployResult.error, message: `⚠️ Auto-deploy failed: ${(deployResult.error || deployResult.stderr || 'unknown').slice(0, 200)}\n\nUse /deploy to retry.` });
+        }
+      } else {
+        notify('stage_error', { stage: 'approve', error: approveResult.error, message: `⚠️ Auto-approve failed: ${approveResult.error}` });
+      }
+    } else {
+      // Was rejected — check if we've already hit max review cycles before restarting the loop
+      const currentCount = (getStatus().auto_review_count) || 0;
+      if (currentCount >= AUTO_REVIEW_MAX) {
+        updateStatus({ pipeline_mode: 'manual' });
+        notify('stage_complete', {
+          stage: 'review_rejected',
+          message: `🛑 Bot restarted — max review cycles already reached (${currentCount}/${AUTO_REVIEW_MAX}).\n\nLast verdict: <b>${verdict}</b>\n\nSwitched to manual mode. Use:\n• /approve to force-approve and deploy\n• /reject to send specific fixes to the Coder\n• /review to run one more review cycle`,
+        });
+        return;
+      }
+      // Was rejected — resume the fix loop
+      notify('stage_start', { stage: 'fix', message: `🔄 Bot restarted — review was <b>${verdict}</b>. Resuming fix loop...` });
+      await _runAutoReviewLoop(notify, featureId);
+    }
+  }
+
+  // Resume: manually rejected (via /reject command) — Coder needs to fix and re-enter review loop
+  if (stage === 'rejected' && next === 'fix') {
+    console.log('[Pipeline] Resuming auto pipeline from rejected → fix');
+    const reason = status.rejection_reason || 'see /docs for blockers';
+    notify('stage_start', {
+      stage: 'fix',
+      message: `🔄 Bot restarted — pipeline was <b>REJECTED</b>.\n\nReason: <i>${reason}</i>\n\nCoder is fixing blockers now...`,
+    });
+    const fixResult = await runFix();
+    if (!fixResult.success) {
+      notify('stage_error', {
+        stage: 'fix',
+        message: `❌ Fix failed: ${fixResult.error}\n\nUse /fix to retry or /docs to review blockers.`,
+      });
+      return;
+    }
+    notify('stage_start', { stage: 'review', message: `🔍 Fix complete — re-entering auto review loop...` });
+    await _runAutoReviewLoop(notify, featureId);
+  }
+
+  // Resume: feature approved but deploy not yet run
+  if (stage === 'approved' && next === 'deploy') {
+    console.log('[Pipeline] Resuming auto pipeline from approved → deploy');
+    updateStatus({ stage: 'deploying' });
+    notify('stage_start', { stage: 'deploy', message: `🔄 Bot restarted — resuming auto-deploy...` });
+    const deployResult = await runDeploy('RunLocalTests');
+    if (deployResult.success) {
+      notify('stage_complete', { stage: 'deployed', message: `🚀 Deployment complete! Feature shipped! 🎉` });
+    } else {
+      notify('stage_error', { stage: 'deploy', error: deployResult.error, message: `⚠️ Auto-deploy failed: ${(deployResult.error || deployResult.stderr || 'unknown').slice(0, 200)}\n\nUse /deploy to retry.` });
+    }
+  }
+
+  // Resume: spec complete but architecture hasn't started yet
+  if (stage === 'spec_complete' && next === 'architect') {
+    console.log('[Pipeline] Resuming auto pipeline from spec_complete → architect');
+    notify('stage_start', { stage: 'arch', message: `🔄 Bot restarted mid-pipeline at <b>spec_complete</b>.\n\nThe spec is done but architecture hasn't started yet.\nRestarting the pipeline from architecture stage...` });
+    // Re-run architecture by calling _runPipelineAsync with a minimal restart
+    // We need the spec to be available — launch implementation from arch stage
+    try {
+      const specFile = getLatestFilePath('specs');
+      if (!specFile || !existsSync(specFile)) {
+        notify('stage_error', { stage: 'arch', message: `❌ Cannot resume — spec file not found.\n\nUse /new-feature to restart the pipeline.` });
+        return;
+      }
+      const specContent = readFileSync(specFile, 'utf8').slice(0, 2000);
+      const config = getConfig();
+      const projectName = config.name || 'this project';
+      const archPrompt = `You are the architect for ${projectName}.\n` +
+        `Analyze the feature spec and create:\n` +
+        `1. Architecture document in .ai-workflow/docs/\n` +
+        `2. Implementation tasks in .ai-workflow/tasks/\n\n## Feature Spec\n${specContent}`;
+      // Use configured provider for architect stage
+      await runPipelineStage('architect', archPrompt, { featureId, stage: 'arch' });
+      updateStatus({ stage: 'arch_complete', next: 'implement' });
+      notify('stage_complete', { stage: 'arch_complete', message: `🏗 Architecture complete (resumed after restart)` });
+      // Continue to implementation
+      const implResult = await runImplementation();
+      if (!implResult.success) {
+        notify('stage_error', { stage: 'impl', message: `❌ Implementation failed after architecture resume: ${implResult.error}\n\nUse /implement to retry.` });
+      }
+    } catch (archErr) {
+      notify('stage_error', { stage: 'arch', message: `❌ Architecture failed on resume: ${archErr.message?.slice(0, 150)}\n\nUse /new-feature to restart.` });
+    }
+    return;
+  }
+
+  // Resume: implementation failed — auto-retry
+  if (stage === 'implementation_failed' && next === 'retry') {
+    console.log('[Pipeline] Resuming auto pipeline from implementation_failed → retry');
+    notify('stage_start', { stage: 'impl', message: `🔄 Bot restarted — retrying failed implementation...` });
+    // runImplementation accepts implementation_failed stage
+    const implResult = await runImplementation();
+    if (!implResult.success) {
+      notify('stage_error', { stage: 'impl', message: `❌ Implementation retry failed: ${implResult.error}\n\nUse /implement to retry manually.` });
+    }
+    return;
+  }
+
+  // Resume: pipeline crashed — notify user
+  if (stage === 'crashed') {
+    console.log('[Pipeline] Detected crashed pipeline state — notifying user');
+    notify('stage_error', { stage: 'crashed', message: `💥 Bot restarted and found a <b>crashed</b> pipeline.\n\nFeature: ${featureId}\nPrevious error: ${status.error || 'unknown'}\n\nRecovery options:\n• /implement — retry implementation\n• /review — run a code review\n• /status — check current state\n• /reset — clear and start fresh` });
+    return;
+  }
+}
+
+// ─── Custom Queries (project-specific, e.g. Salesforce DLQ/Queue) ────────────
+// Configured via `queries` array in aicc.config.js:
+//   queries: [
+//     { name: 'queue', label: 'Sync Queue', command: 'sf data query --query "SELECT ..." --result-format json' },
+//     { name: 'dlq',   label: 'Dead Letter Queue', command: 'sf data query --query "SELECT ..." --result-format json' },
+//   ]
+
+export async function runCustomQuery(queryName) {
+  const queries = (() => { try { return getConfig().queries || []; } catch { return []; } })();
+  const query = queries.find(q => q.name === queryName);
+  if (!query) {
+    return { success: false, error: `Unknown query "${queryName}". Available: ${queries.map(q => q.name).join(', ') || 'none'}` };
+  }
+  try {
+    const result = await capture(query.command);
+    if (result.code !== 0) return { success: false, error: result.stderr.slice(0, 500) };
+    return { success: true, label: query.label, data: result.stdout.slice(0, 3000) };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Salesforce Sync Queue query (convenience — works when sf CLI is available).
+ */
+export async function querySyncQueue() {
+  // Check if project has a custom 'queue' query defined
+  const queries = (() => { try { return getConfig().queries || []; } catch { return []; } })();
+  const custom = queries.find(q => q.name === 'queue');
+  if (custom) return runCustomQuery('queue');
+
+  // Default: Salesforce Integration_Sync_Queue__c
+  try {
+    const result = await capture(
+      'sf data query --query "SELECT Id, Status__c, Direction__c, Record_Id__c, Retry_Count__c, CreatedDate FROM Integration_Sync_Queue__c ORDER BY CreatedDate DESC LIMIT 10" --result-format json'
+    );
+    if (result.code !== 0) return { success: false, error: result.stderr.slice(0, 500) };
+    return { success: true, data: result.stdout.slice(0, 3000) };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Salesforce Dead Letter Queue query (convenience — works when sf CLI is available).
+ */
+export async function queryDeadLetterQueue() {
+  const queries = (() => { try { return getConfig().queries || []; } catch { return []; } })();
+  const custom = queries.find(q => q.name === 'dlq');
+  if (custom) return runCustomQuery('dlq');
+
+  try {
+    const result = await capture(
+      'sf data query --query "SELECT Id, Record_Id__c, Error_Message__c, Retry_Count__c, CreatedDate FROM Integration_Dead_Letter_Queue__c ORDER BY CreatedDate DESC LIMIT 10" --result-format json'
+    );
+    if (result.code !== 0) return { success: false, error: result.stderr.slice(0, 500) };
+    return { success: true, data: result.stdout.slice(0, 3000) };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+// ─── Cleanup ──────────────────────────────────────────────────────────────────
+
+export async function runCleanup() {
+  try {
+    updateStatus({ stage: 'idle', current_feature: null, next: null, pipeline_mode: null });
+    bus.emitEvent('cleanup_done', {});
+    audit(AUDIT_EVENTS.CLEANUP, {});
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+// ─── Toggle Auto-Pilot ───────────────────────────────────────────────────────
+
+export function toggleAutoPilot() {
+  const status = getStatus();
+  const hasFeature = !!status.current_feature;
+  const isPipelineActive = hasFeature && !['approved', 'idle', 'deployed'].includes(status.stage);
+
+  if (!isPipelineActive) {
+    return { success: false, error: 'No active pipeline to toggle auto-pilot for.' };
+  }
+
+  const newMode = status.pipeline_mode === 'auto' ? 'manual' : 'auto';
+  updateStatus({ pipeline_mode: newMode });
+  bus.emitEvent('autopilot_toggled', { mode: newMode });
+  audit(AUDIT_EVENTS.AUTOPILOT_TOGGLED, { mode: newMode });
+  return { success: true, mode: newMode };
+}
+
+// ─── Auto-Reset After Deployment ─────────────────────────────────────────────
+// After a feature is deployed, the pipeline stays in 'deployed' stage briefly
+// so the user sees the notification, then auto-resets to 'idle' after 60s.
+
+let _autoResetTimer = null;
+const AUTO_RESET_DELAY_MS = 60_000; // 60 seconds
+
+function _scheduleAutoReset() {
+  if (_autoResetTimer) clearTimeout(_autoResetTimer);
+  _autoResetTimer = setTimeout(() => {
+    _autoResetTimer = null;
+    const s = getStatus();
+    if (s.stage !== 'deployed') return; // user already changed stage — skip
+    const feature = s.current_feature;
+    updateStatus({ stage: 'idle', current_feature: null, next: null, pipeline_mode: null });
+    bus.emitEvent('auto_reset', {
+      feature,
+      message: `🔄 Pipeline auto-reset to idle after deploying <b>${feature || 'feature'}</b>.\n\nReady for the next task.`,
+    });
+    bus.emitEvent('feature_reset', { feature, auto: true });
+    audit(AUDIT_EVENTS.RESET, { feature, auto: true });
+    console.log(`  [Pipeline] Auto-reset to idle after deploying "${feature}"`);
+  }, AUTO_RESET_DELAY_MS);
+}
+
+// ─── Reset / Abandon ─────────────────────────────────────────────────────────
+
+export function runReset() {
+  const status = getStatus();
+  if (!status.current_feature) {
+    return { success: false, error: 'No active feature to abandon.' };
+  }
+
+  // Cancel all running heartbeats and suppress further notifications
+  _pipelineCancelled = true;
+
+  const feature = status.current_feature;
+  updateStatus({ stage: 'idle', current_feature: null, next: null, pipeline_mode: null });
+  bus.emitEvent('feature_reset', { feature });
+  audit(AUDIT_EVENTS.RESET, { feature });
+  return { success: true, feature };
+}
+
+// ─── Persistent Pending Chat Storage ─────────────────────────────────────────
+// Survives bot restarts — used to hold the pending feature/bug description
+// between the AI suggesting it and the user clicking Manual/Auto-Pilot button.
+
+export function savePendingChat(chatId, pending) {
+  try {
+    const sessionsDir = resolve(getWorkflowDir(), 'sessions');
+    mkdirSync(sessionsDir, { recursive: true });
+    writeFileSync(
+      resolve(sessionsDir, `PENDING-CHAT-${chatId}.json`),
+      JSON.stringify({ ...pending, savedAt: Date.now() }, null, 2)
+    );
+  } catch { /* non-fatal */ }
+}
+
+export function loadPendingChat(chatId) {
+  try {
+    const path = resolve(getWorkflowDir(), 'sessions', `PENDING-CHAT-${chatId}.json`);
+    if (!existsSync(path)) return null;
+    const data = JSON.parse(readFileSync(path, 'utf8'));
+    // Expire after 10 minutes
+    if (Date.now() - (data.savedAt || 0) > 10 * 60 * 1000) {
+      unlinkSync(path);
+      return null;
+    }
+    return data;
+  } catch { return null; }
+}
+
+export function clearPendingChat(chatId) {
+  try {
+    const path = resolve(getWorkflowDir(), 'sessions', `PENDING-CHAT-${chatId}.json`);
+    if (existsSync(path)) unlinkSync(path);
+  } catch { /* non-fatal */ }
+}
+
+// ─── Fix (run Coder on review blockers) ──────────────────────────────────────
+
+export async function runFix() {
+  try {
+    const status = getStatus();
+    const featureId = status.current_feature;
+    if (!featureId) return { success: false, error: 'No active feature to fix.' };
+
+    const review = getLatestReview();
+    const blockers = review ? extractBlockers(review.content) : 'Fix all reported issues from the latest review.';
+
+    const fixPrompt =
+      `You are the Coder. The code review was REJECTED.\n\n` +
+      `Fix ALL the following blockers identified in the code review:\n\n${blockers}\n\n` +
+      `Make the actual code changes to fix these issues. Do not explain — just fix.`;
+
+    await runPipelineStage('implement', fixPrompt, { featureId, stage: 'fix' });
+    audit(AUDIT_EVENTS.BUG_FIX, { featureId });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+// ─── Review (async — long running) ───────────────────────────────────────────
+
+export async function runReview() {
+  const status = getStatus();
+  if (!status.current_feature) {
+    return { success: false, error: 'No active feature to review.' };
+  }
+
+  const featureId = status.current_feature;
+  // notify is only defined in _runAutoReviewLoop/_runPipelineAsync — use bus directly here
+  const notify = (event, data) => bus.emitEvent(event, { feature: featureId, ...data });
+  updateStatus({ stage: 'review' });
+
+  try {
+    const timestamp   = Math.floor(Date.now() / 1000);
+    const workflowDir = getWorkflowDir();
+    const root        = getRootDir();
+
+    // Get git changes for review — handles uncommitted, staged, AND already-committed code
+    let diff = 'No changes detected';
+    try {
+      // Find actual git root — ROOT may not be the git repo (e.g. aicc.config.js in parent dir)
+      let gitDir = root;
+      try {
+        const gitTopLevel = await capture('git rev-parse --show-toplevel', [], { cwd: root });
+        if (gitTopLevel.stdout.trim()) gitDir = gitTopLevel.stdout.trim();
+        else {
+          // Try subdirectories that might be the git repo
+          const entries = readdirSync(root).filter(e => {
+            try { return existsSync(resolve(root, e, '.git')); } catch { return false; }
+          });
+          if (entries.length > 0) gitDir = resolve(root, entries[0]);
+        }
+      } catch {
+        // ROOT itself might not be a git repo — scan for .git subdirectory
+        try {
+          const entries = readdirSync(root).filter(e => {
+            try { return existsSync(resolve(root, e, '.git')); } catch { return false; }
+          });
+          if (entries.length > 0) gitDir = resolve(root, entries[0]);
+        } catch { /* use root as fallback */ }
+      }
+      const git = (cmd) => capture(cmd, [], { cwd: gitDir });
+
+      const diffParts = [];
+      let hasCodeContent = false;
+
+      // 1. Check uncommitted changes (working dir vs HEAD)
+      let hasUncommitted = false;
+      try {
+        const localStat = await git('git --no-pager diff HEAD --stat');
+        if (localStat.stdout.trim()) {
+          hasUncommitted = true;
+          diffParts.push('### Uncommitted Changes\n' + localStat.stdout.trim());
+          try {
+            const localPatch = await git('git --no-pager diff HEAD');
+            if (localPatch.stdout.trim()) {
+              diffParts.push('### Uncommitted Code Diff\n' + localPatch.stdout.slice(0, 3000));
+              hasCodeContent = true;
+            }
+          } catch { /* non-fatal */ }
+        }
+      } catch { /* non-fatal */ }
+
+      // 2. Check staged changes
+      if (!hasCodeContent) {
+        try {
+          const stagedStat = await git('git --no-pager diff --cached --stat');
+          if (stagedStat.stdout.trim()) {
+            diffParts.push('### Staged Changes\n' + stagedStat.stdout.trim());
+            try {
+              const stagedPatch = await git('git --no-pager diff --cached');
+              if (stagedPatch.stdout.trim()) {
+                diffParts.push('### Staged Code Diff\n' + stagedPatch.stdout.slice(0, 3000));
+                hasCodeContent = true;
+              }
+            } catch { /* non-fatal */ }
+          }
+        } catch { /* non-fatal */ }
+      }
+
+      // 3. If no uncommitted/staged code, get diff of committed changes since feature started
+      //    This handles the common case where Copilot --yolo already committed everything
+      if (!hasCodeContent) {
+        // Use feature timestamp to find the baseline commit (before this feature existed)
+        const tsMatch = featureId.match(/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/);
+        if (tsMatch) {
+          const [, y, mo, d, h, mi, s] = tsMatch;
+          const isoDate = `${y}-${mo}-${d}T${h}:${mi}:${s}`;
+          try {
+            const baseResult = await git(`git --no-pager log --before="${isoDate}" --format=%H -1`);
+            const baseHash = baseResult.stdout.trim();
+            if (baseHash) {
+              const featureStat = await git(`git --no-pager diff ${baseHash}..HEAD --stat`);
+              if (featureStat.stdout.trim()) {
+                diffParts.push('### Files Changed Since Feature Started\n' + featureStat.stdout.trim());
+                const featurePatch = await git(`git --no-pager diff ${baseHash}..HEAD`);
+                if (featurePatch.stdout.trim()) {
+                  diffParts.push('### Code Changes (All Feature Commits)\n' + featurePatch.stdout.slice(0, 4000));
+                  hasCodeContent = true;
+                }
+              }
+            }
+          } catch { /* non-fatal */ }
+        }
+
+        // Fallback: try HEAD~N..HEAD with increasing range
+        if (!hasCodeContent) {
+          for (const n of [10, 5, 3, 1]) {
+            try {
+              const commitPatch = await git(`git --no-pager diff HEAD~${n}..HEAD`);
+              if (commitPatch.stdout.trim()) {
+                const commitStat = await git(`git --no-pager diff HEAD~${n}..HEAD --stat`);
+                diffParts.push(`### Files Changed in Last ${n} Commit(s)\n` + (commitStat.stdout.trim() || '(see diff below)'));
+                diffParts.push('### Code Diff (Recent Commits)\n' + commitPatch.stdout.slice(0, 4000));
+                hasCodeContent = true;
+                break;
+              }
+            } catch { continue; }
+          }
+        }
+      }
+
+      // 4. Last resort: read actual source files modified after the pipeline started
+      //    This covers edge cases where git diff approaches all return empty
+      if (!hasCodeContent) {
+        try {
+          const statusRef = resolve(root, '.ai-workflow', 'status.json');
+          const findRef = existsSync(statusRef) ? `-newer ${statusRef}` : '-mmin -120';
+          const findCmd = `find . -maxdepth 4 -type f \\( -name "*.js" -o -name "*.ts" -o -name "*.py" -o -name "*.jsx" -o -name "*.tsx" -o -name "*.go" -o -name "*.sh" \\) -not -path "*/node_modules/*" -not -path "*/.ai-workflow/*" -not -path "*/.git/*" ${findRef} 2>/dev/null | head -15`;
+          const findResult = await capture(findCmd, [], { cwd: gitDir });
+          const recentFiles = findResult.stdout.trim().split('\n').filter(Boolean);
+
+          if (recentFiles.length > 0) {
+            const fileSummaries = [];
+            let totalChars = 0;
+            for (const file of recentFiles) {
+              if (totalChars > 4000) break;
+              try {
+                const filePath = resolve(gitDir, file.trim());
+                if (existsSync(filePath)) {
+                  const content = readFileSync(filePath, 'utf8');
+                  const snippet = content.slice(0, 800);
+                  fileSummaries.push(`#### ${file.trim()}\n\`\`\`\n${snippet}\n\`\`\``);
+                  totalChars += snippet.length;
+                }
+              } catch { /* skip unreadable files */ }
+            }
+            if (fileSummaries.length > 0) {
+              diffParts.push('### Implementation Files (recently modified)\n' + fileSummaries.join('\n\n'));
+              hasCodeContent = true;
+            }
+          }
+        } catch { /* non-fatal */ }
+      }
+
+      // 5. Always append recent commit log for context (supplementary, not primary)
+      try {
+        const log = await git('git --no-pager log --oneline -10');
+        if (log.stdout.trim()) {
+          diffParts.push('### Recent Commits\n' + log.stdout.trim());
+        }
+      } catch { /* non-fatal */ }
+
+      if (diffParts.length > 0) {
+        diff = diffParts.join('\n\n');
+        if (diff.length > 6000) diff = diff.slice(0, 6000) + '\n\n... (truncated for context limit)';
+      }
+      if (!hasCodeContent) console.warn('[Review] WARNING: Could not find any code changes to review — reviewer will see commit log only');
+    } catch (gitErr) {
+      console.warn('[Review] Git changes collection failed:', gitErr.message?.slice(0, 120));
+    }
+
+    // Load latest spec for review context
+    const specFile    = getLatestFilePath('specs');
+    const specContent = specFile && existsSync(specFile) ? readFileSync(specFile, 'utf8').slice(0, 2000) : 'No spec available';
+
+    // Build review prompt using available context file
+    const geminiMd  = resolve(root, 'GEMINI.md');
+    const claudeMd  = resolve(root, 'CLAUDE.md');
+    const reviewCtxFile = existsSync(geminiMd) ? geminiMd : existsSync(claudeMd) ? claudeMd : null;
+    const reviewCtx = reviewCtxFile ? readFileSync(reviewCtxFile, 'utf8').slice(0, 3000) : '';
+    let prompt    =
+      `${reviewCtx}\n\n## Code Review Task\n\n` +
+      `Feature: ${status.current_feature}\n\n` +
+      `## Feature Spec\n${specContent}\n\n` +
+      `## Code Changes\n` +
+      `The following shows code changes for this feature. They may include uncommitted diffs, committed diffs (code already committed by the implementer), or direct file contents.\n` +
+      `Review ALL the code shown below against the spec — do NOT say "no code submitted" if you see diffs or file contents.\n\n` +
+      `${diff}\n\n` +
+      `Write a structured code review of the code above. Include:\n` +
+      `- ✅ Approved Items\n- ⚠️ Warnings (non-blocking)\n- ❌ Blockers (must fix)\n` +
+      `- ## Verdict\n**APPROVED** or **REJECTED**`;
+
+    // Inject skills and persona for review stage
+    try {
+      prompt = injectSkills(prompt, 'review');
+    } catch (e) { /* skills are optional */ }
+    try {
+      const persona = loadPersona('reviewer');
+      if (persona) { prompt = injectPersona(prompt, persona); }
+    } catch (e) { /* personas are optional */ }
+
+    const reviewsDir = resolve(workflowDir, 'reviews');
+    mkdirSync(reviewsDir, { recursive: true });
+    const reviewFile = resolve(reviewsDir, `REVIEW-${timestamp}.md`);
+
+    // Run review using configured provider (with fallback chain)
+    notify('stage_start', { stage: 'review', message: `🔍 Reviewer is reviewing the code...` });
+    try {
+      await runPipelineStage('review', prompt, { featureId, stage: 'review', outputFile: reviewFile });
+
+      // If provider wrote to stdout (via redirect) the file will exist.
+      // If provider wrote via tools, check for the file.
+      if (!existsSync(reviewFile) || readFileSync(reviewFile, 'utf8').trim().length < 50) {
+        // Fallback: try runAI which uses the chat pipeline
+        const fallbackContent = await runAI(prompt, { system: 'You are a code reviewer. Write a structured review with ✅ Approved, ⚠️ Warnings, ❌ Blockers, and ## Verdict: APPROVED or REJECTED.' });
+        writeFileSync(reviewFile, typeof fallbackContent === 'string' ? fallbackContent : prompt);
+      }
+    } catch (reviewErr) {
+      console.warn('[Review] Review stage failed:', reviewErr.message?.slice(0, 120));
+      // Last resort: try runAI
+      try {
+        const fallbackContent = await runAI(prompt, { system: 'You are a code reviewer. Write a structured review with ✅ Approved, ⚠️ Warnings, ❌ Blockers, and ## Verdict: APPROVED or REJECTED.' });
+        writeFileSync(reviewFile, typeof fallbackContent === 'string' ? fallbackContent : prompt);
+      } catch {
+        writeFileSync(reviewFile, `# Review\n\n## Verdict\n**APPROVED**\n\n_Auto-approved: all review providers unavailable._`);
+      }
+    }
+
+    updateStatus({ stage: 'review_complete', latest_review: `REVIEW-${timestamp}`, next: 'approve_or_reject' });
+    bus.emitEvent('review_complete', { feature: status.current_feature });
+    audit(AUDIT_EVENTS.REVIEW_COMPLETED, { feature: status.current_feature, reviewFile: `REVIEW-${timestamp}` });
+    return { success: true, reviewFile };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+export function getLatestReview() {
+  const wfDir = getWorkflowDir();
+  const reviewsDir = resolve(wfDir, 'reviews');
+  if (!existsSync(reviewsDir)) return null;
+
+  const files = readdirSync(reviewsDir)
+    .filter(f => f.startsWith('REVIEW-') && f.endsWith('.md'))
+    .sort()
+    .reverse();
+
+  if (files.length === 0) return null;
+
+  const name = files[0];
+  const content = readFileSync(resolve(reviewsDir, name), 'utf8');
+
+  // Parse verdict
+  let verdict = 'UNKNOWN';
+  const verdictParts = content.split(/##[^#]*Verdict/i);
+  if (verdictParts.length >= 2) {
+    const verdictBody = verdictParts[1].split(/^##/m)[0];
+    const m = verdictBody.match(/\b(APPROVED|REJECTED)\b/i);
+    if (m) verdict = m[1].toUpperCase();
+  }
+
+  return { name, verdict, content };
+}
+
+// ─── AI-Powered Helpers ──────────────────────────────────────────────────────
+// Lightweight AI tasks routed through runAI() (Ollama first, cloud fallback).
+
+function getSystemPrompt() {
+  return getConfig().ai.system;
+}
+
+/**
+ * Load the chatbot skill file — the AI's "employee manual" for natural conversation.
+ * Looks for chatbot.md in the project's skills directory, which contains rules
+ * for how to detect bugs vs features, confirm with users, and route through the pipeline.
+ * Falls back to the basic system prompt if the skill file doesn't exist.
+ */
+function loadChatbotSkill() {
+  try {
+    const root = getRootDir();
+    const skillsDir = getConfig().skillsDir || '.claude/skills';
+    const chatbotPath = resolve(root, skillsDir, 'chatbot.md');
+    if (existsSync(chatbotPath)) {
+      return readFileSync(chatbotPath, 'utf8');
+    }
+  } catch { /* fall through to null */ }
+  return null;
+}
+
+/**
+ * Summarize a code review into 2-3 key lines.
+ */
+export async function summarizeReview(reviewContent) {
+  try {
+    return await runAI(
+      `Summarize this code review in 2-3 bullet points. Focus on: verdict (approved/rejected), key blockers, and recommended actions.\n\n${reviewContent.slice(0, 3000)}`,
+      { system: getSystemPrompt(), fallback: false }
+    );
+  } catch {
+    return null; // Graceful — summaries are optional
+  }
+}
+
+/**
+ * Generate a human-readable explanation of the pipeline status.
+ */
+export async function explainStatus(statusData) {
+  try {
+    return await runAI(
+      `Explain this pipeline status in 1-2 sentences. What stage is it at, what should the user do next?\n\n${JSON.stringify(statusData, null, 2)}`,
+      { system: getSystemPrompt(), fallback: false }
+    );
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Analyze log content and highlight errors/warnings.
+ */
+export async function analyzeLog(logContent) {
+  try {
+    return await runAI(
+      `Analyze these pipeline logs. List any errors, warnings, or notable events in bullet points. If everything looks normal, say so briefly.\n\n${logContent.slice(0, 3000)}`,
+      { system: getSystemPrompt(), fallback: false }
+    );
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * General-purpose AI Q&A about the project.
+ */
+export async function askAI(question, context = '') {
+  audit(AUDIT_EVENTS.ASK_AI, { question: question.slice(0, 200) });
+  const projectName = getConfig().name || 'this project';
+
+  // Load the chatbot skill file — this is the AI's "employee manual"
+  const chatbotSkill = loadChatbotSkill();
+
+  // Load tech-specific skills if available
+  const techContext = loadTechSkills();
+
+  // Load intelligence (learned patterns)
+  const learnedContext = appendLearnedContext();
+
+  let systemPrompt;
+
+  if (chatbotSkill) {
+    // Skill file exists — use it as the primary instruction set
+    systemPrompt = chatbotSkill;
+    if (techContext) {
+      systemPrompt += `\n\n## Technology Guidelines\n${techContext}`;
+    }
+  } else {
+    // NOTE: External prompt file is auto-generated from inline prompt below.
+    // We always rebuild from inline to pick up code-level improvements.
+    // The external file is only used as a cache/reference.
+    // No skill file — use inline prompt (backwards compatible)
+    systemPrompt =
+      `${getSystemPrompt()}\n\n` +
+      `You are a smart, experienced assistant for the "${projectName}" project. ` +
+      `You communicate naturally, like a senior developer colleague — friendly, knowledgeable, and proactive.\n\n` +
+      `## How You Work\n\n` +
+      `You are a Pipeline Controller with FULL AUTHORITY to execute pipeline actions.\n` +
+      `You CAN and SHOULD: reset pipeline to idle, trigger reviews/fixes/deployments, start features, clean up workspace.\n` +
+      `NEVER say "I can't", "I'm text-only", or "I don't have the ability to". You ARE the pipeline controller.\n` +
+      `When the user asks you to do something, DO IT by outputting the action JSON. Do NOT explain what commands they should type.\n\n` +
+      `## Conversation Guidelines\n\n` +
+      `- Respond naturally and helpfully to any question — about the project, code, architecture, best practices, etc.\n` +
+      `- Provide thoughtful analysis, suggestions, explanations, and trade-offs.\n` +
+      `- Keep responses concise but informative (2-4 paragraphs max).\n` +
+      `- Be conversational — avoid robotic or formulaic responses.\n\n` +
+      `## Smart Intent Detection (CRITICAL)\n\n` +
+      `When the user sends a message, classify it into one of these categories:\n\n` +
+      `### Category 1: Bug Report / Something Broken\n` +
+      `Signals: "doesn't work", "broken", "error", "crash", "wrong", "fails", "not showing", "missing", "issue"\n` +
+      `Response:\n` +
+      `1. Acknowledge the problem and show you understand it\n` +
+      `2. Analyze what might be causing it — explain possible root causes\n` +
+      `3. Suggest what the fix might involve\n` +
+      `4. Then, output the following JSON (no backticks, no code fences, on its own line) to let the user confirm via button:\n` +
+      `{"_action":"create_feature","description":"<short summary>","type":"bug","confirm":true}\n` +
+      `The user will see a confirmation button. Do NOT ask them to type "yes" — they will tap a button instead.\n\n` +
+      `### Category 2: Feature Request / Enhancement\n` +
+      `Signals: "add", "implement", "create", "build", "want", "need", "can we", "would be nice", "improve"\n` +
+      `Response:\n` +
+      `1. Discuss the idea — what it would involve, how it fits the project\n` +
+      `2. Mention any considerations, trade-offs, or alternatives\n` +
+      `3. Then, output the following JSON (no backticks, no code fences, on its own line) to let the user confirm via button:\n` +
+      `{"_action":"create_feature","description":"<short summary>","type":"feature","confirm":true}\n` +
+      `The user will see a confirmation button. Do NOT ask them to type "yes" — they will tap a button instead.\n\n` +
+      `### Category 3: General Question / Discussion\n` +
+      `Signals: "how", "what", "why", "explain", "status", "help", "hello", "hi"\n` +
+      `Response: Just answer the question naturally. Do NOT suggest /bug or /feature unless directly relevant.\n\n` +
+      `### Category 4: Pipeline Execution Request\n` +
+      `Signals: User explicitly asks you to DO something — "fix it", "run a review", "approve",\n` +
+      `  "deploy", "fix it", "do it now", "go ahead", "start implementing"\n` +
+      `Response: Output ONE of these action JSON objects (raw, no backticks) to execute the action.\n` +
+      `- User wants fix/blockers addressed → {"_action":"run_fix"}\n` +
+      `- User wants a code review → {"_action":"run_review"}\n` +
+      `- User wants fix AND review → {"_action":"run_fix_and_review"}\n` +
+      `- User wants to approve → {"_action":"run_approve"}\n` +
+      `- User wants to deploy → {"_action":"run_deploy"}\n` +
+      `- User wants to start/resume implementation → {"_action":"run_implement"}\n` +
+      `- User wants to reset/go idle/abandon feature → {"_action":"run_reset"}\n` +
+      `- User wants to clean up workspace → {"_action":"run_cleanup"}\n` +
+      `You MAY add a SHORT 1-sentence confirmation before the JSON (e.g., "On it!"), but output the JSON on its own line.\n` +
+      `CRITICAL: When the user tells you to do something, OUTPUT THE ACTION JSON. Do NOT just describe what they could do.\n\n` +
+      `### Category 5: Status / History Questions\n` +
+      `Signals: "what stage", "did it finish", "is it done", "what happened", "status", "where are we"\n` +
+      `Response: Answer from the Current Pipeline State context above. Be specific and factual.\n\n` +
+      `## Key Principle\n` +
+      `Be helpful FIRST. Analyze and discuss FIRST. Only suggest pipeline actions when clearly appropriate. ` +
+      `For bugs and features (Cat 1 & 2), always include the confirm JSON so buttons are shown. ` +
+      `Never auto-create bugs or features — the user confirms via inline button.\n\n` +
+      `## Available Commands\n` +
+      `/status — Pipeline status | /feature <desc> — New feature | /bug <desc> — Bug fix\n` +
+      `/implement — Run/restart implementation | /review — Code review\n` +
+      `/approve — Approve | /reject <reason> — Reject | /deploy — Deploy\n` +
+      `/logs — View logs | /health — System health`;
+
+    if (techContext) {
+      systemPrompt += `\n\n## Technology Guidelines\n${techContext}`;
+    }
+
+    // Save this prompt as the external version (reference/cache only — inline always wins)
+    saveExternalPrompt(systemPrompt);
+  }
+
+  // Inject learned context — past user phrases → intent mappings
+  if (learnedContext) {
+    systemPrompt += learnedContext;
+  }
+
+  // Add current pipeline status as context — include mode-specific behaviour rules
+  try {
+    const status = getStatus();
+    const isAuto = status.pipeline_mode === 'auto';
+    const statusContext =
+      `\n\nCurrent Pipeline State:\n` +
+      `- stage: "${status.stage || 'idle'}"\n` +
+      `- feature: "${status.current_feature || 'none'}"\n` +
+      `- mode: "${status.pipeline_mode || 'manual'}"\n` +
+      `- next: "${status.next || '-'}"\n\n` +
+      (isAuto
+        ? `IMPORTANT: Pipeline is in AUTO mode. All stages (spec→arch→impl→review→approve) run automatically without user intervention. ` +
+          `Do NOT ask the user for permission to run the next stage — it already ran or is running. ` +
+          `If the user asks "have you done X?", check the stage above and give a factual status answer.`
+        : `Pipeline is in MANUAL mode. Each stage needs user sign-off before auto-advancing. ` +
+          `When the user explicitly asks you to run/start/fix/review/approve/deploy something, ` +
+          `output the appropriate action JSON to execute it — don't tell them to type a command. ` +
+          `For passive status questions, explain clearly what stage we're at and what comes next.`);
+    systemPrompt += statusContext;
+  } catch { /* non-fatal */ }
+
+  // Inject codebase context for richer AI responses
+  try {
+    const codeCtx = getContextString(getRootDir(), { maxDepth: 2, includeGit: false });
+    if (codeCtx) systemPrompt += `\n\n## Project Context\n${codeCtx.slice(0, 2000)}`;
+  } catch { /* non-fatal */ }
+
+  const prompt = context
+    ? `${context.slice(0, 3000)}\n\nCurrent message: ${question}`
+    : question;
+
+  try {
+    return await runAI(prompt, { system: systemPrompt });
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
+/**
+ * Load technology-specific skills (fetched from antigravity-awesome-skills).
+ * These teach the AI about project-specific patterns, anti-patterns, and best practices.
+ */
+function loadTechSkills() {
+  try {
+    const techSkills = getConfig().ai?.techSkills || [];
+    if (techSkills.length === 0) return null;
+
+    const root = getRootDir();
+    const skillsDir = getConfig().skillsDir || '.claude/skills';
+
+    return techSkills
+      .map(name => {
+        const path = resolve(root, `${skillsDir}/${name}.md`);
+        if (!existsSync(path)) return null;
+        const content = readFileSync(path, 'utf8');
+        // Strip YAML front matter if present
+        return content.replace(/^---[\s\S]*?---\n*/m, '').trim();
+      })
+      .filter(Boolean)
+      .join('\n\n---\n\n');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get AI provider status for dashboard display.
+ */
+export async function getAIProviderStatus() {
+  const ollamaStatus = await isOllamaAvailable();
+  return {
+    mode: getAIMode(),
+    ollama: {
+      available: ollamaStatus.available,
+      model: getOllamaModel(),
+      models: ollamaStatus.models,
+    },
+  };
+}
+
+// ─── P0 Query Wrappers ──────────────────────────────────────────────────────
+// Expose cost, audit, and plugin data for web API and Telegram commands.
+
+export function getCostsData(featureId) {
+  const summary = getCostSummary(featureId);
+  return { ...summary, formatted: formatCostSummary(summary, 'text') };
+}
+
+export function getAuditData(filters) {
+  return getAuditEntries(filters);
+}
+
+export function getPluginsData() {
+  return getPluginStatus();
+}
+
+// ─── Browser QA & Bugfix Loop ────────────────────────────────────────────────
+
+export async function runBrowserQA(options = {}) {
+  return browserTestAction(options);
+}
+
+export async function runBugfixFromQA(qaReport, featureId, config) {
+  const maxCycles = config.browserQA?.maxBugfixCycles || 3;
+  let cycle = 0;
+
+  while (cycle < maxCycles) {
+    cycle++;
+    logActivity('BUGFIX', `Browser QA bug-fix cycle ${cycle}/${maxCycles}`, 'info');
+
+    const bugContext = buildBugContextFromQA(qaReport);
+
+    try {
+      await runPipelineStage('bugfix', bugContext, config, featureId);
+    } catch {
+      logActivity('BUGFIX', `Fix attempt ${cycle} failed — retrying`, 'warn');
+      continue;
+    }
+
+    // Re-run browser QA to verify
+    const verifyResult = await browserTestAction({ featureId, config });
+    if (!verifyResult.needsBugfix || verifyResult.failCount === 0) {
+      logActivity('BUGFIX', `All bugs fixed after ${cycle} cycle(s)`, 'success');
+      return { success: true, cycles: cycle };
+    }
+
+    qaReport = verifyResult.report;
+  }
+
+  logActivity('BUGFIX', `Exhausted ${maxCycles} bugfix cycles — escalating to CEO`, 'error');
+  bus.emitEvent('qa_bugfix_exhausted', {
+    cycles: maxCycles,
+    remainingFails: qaReport.failed.length,
+  });
+  return { success: false, cycles: cycle };
+}
+
+function buildBugContextFromQA(qaReport) {
+  const failSummary = qaReport.failed.map(f => `
+URL: ${f.url}
+Errors:
+${f.errors.map(e => `  - ${e}`).join('\n')}
+Screenshot: ${f.screenshot || 'not captured'}
+`).join('\n---\n');
+
+  return `
+## Browser QA Report — Fix Required
+
+Pass Rate: ${qaReport.summary?.passRate || 0}%
+Failed Pages: ${qaReport.failed.length}
+
+## Failed Pages
+${failSummary}
+
+## Instructions
+- Read the codebase to identify which files cause these errors
+- Fix ONLY the identified bugs, do not refactor unrelated code
+- Do NOT modify test files to suppress errors
+- After each fix, the QA agent will re-test automatically
+`;
+}