ai-control-center 1.15.2

package/lib/utils/cron-scheduler.js

@@ -0,0 +1,53 @@
+/**
+ * Cron Scheduler — runs recurring QA on assigned projects.
+ *
+ * Supports: daily (6 AM), hourly, or manual (no cron).
+ * Sets scheduledQA flag in status.json — the autonomous loop picks it up.
+ */
+
+import cron from 'node-cron';
+import { getConfig } from '../config.js';
+import { getStatus, updateStatus } from '../utils/pipeline.js';
+import { logActivity } from '../utils/activity-log.js';
+
+let cronJob = null;
+
+export function startQACron() {
+  const config = getConfig();
+  const schedule = config.browserQA?.schedule;
+
+  if (!schedule || schedule === 'manual' || schedule === 'on_deploy') {
+    return; // No cron needed
+  }
+
+  if (schedule === 'daily') {
+    // Run QA daily at 6:00 AM
+    cronJob = cron.schedule('0 6 * * *', () => {
+      logActivity('CRON', 'Scheduled daily QA triggered', 'info');
+      const status = getStatus();
+      if (status.stage === 'idle') {
+        updateStatus({ scheduledQA: true });
+      }
+    });
+    logActivity('CRON', 'Daily QA cron scheduled (6:00 AM)', 'info');
+  }
+
+  if (schedule === 'hourly') {
+    cronJob = cron.schedule('0 * * * *', () => {
+      logActivity('CRON', 'Scheduled hourly QA triggered', 'info');
+      const status = getStatus();
+      if (status.stage === 'idle') {
+        updateStatus({ scheduledQA: true });
+      }
+    });
+    logActivity('CRON', 'Hourly QA cron scheduled', 'info');
+  }
+}
+
+export function stopQACron() {
+  if (cronJob) {
+    cronJob.stop();
+    cronJob = null;
+    logActivity('CRON', 'QA cron stopped', 'info');
+  }
+}

package/lib/utils/db-adapter.js

@@ -0,0 +1,293 @@
+import { createRequire } from 'module';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { getConfig } from '../config.js';
+import { getStatus, updateStatus } from './pipeline.js';
+import { getCostEntries, trackUsage } from './cost-tracker.js';
+
+let _Database = undefined; // undefined = not tried yet, null = not available
+
+function getDatabase() {
+  if (_Database === undefined) {
+    try {
+      const require = createRequire(import.meta.url);
+      _Database = require('better-sqlite3');
+    } catch {
+      _Database = null;
+    }
+  }
+  return _Database;
+}
+
+const WORKFLOW_DIR = '.ai-workflow';
+const DB_PATH = join(WORKFLOW_DIR, 'aicc.db');
+
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS pipeline_status (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    feature_id TEXT,
+    phase TEXT,
+    stage TEXT,
+    status TEXT,
+    data TEXT,
+    updated_at TEXT DEFAULT (datetime('now'))
+  );
+  CREATE TABLE IF NOT EXISTS cost_entries (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts TEXT,
+    provider TEXT,
+    model TEXT,
+    stage TEXT,
+    feature_id TEXT,
+    input_tokens INTEGER,
+    output_tokens INTEGER,
+    estimated_cost REAL,
+    duration_ms INTEGER,
+    data TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  );
+  CREATE TABLE IF NOT EXISTS audit_log (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts TEXT,
+    action TEXT,
+    user_id TEXT,
+    details TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  );
+  CREATE TABLE IF NOT EXISTS checkpoints (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    feature_id TEXT,
+    stage TEXT,
+    sub_step TEXT,
+    content TEXT,
+    hash TEXT,
+    created_at TEXT DEFAULT (datetime('now')),
+    UNIQUE(feature_id, stage, sub_step)
+  );
+  CREATE INDEX IF NOT EXISTS idx_cost_feature ON cost_entries(feature_id);
+  CREATE INDEX IF NOT EXISTS idx_cost_provider ON cost_entries(provider);
+  CREATE INDEX IF NOT EXISTS idx_audit_action ON audit_log(action);
+  CREATE INDEX IF NOT EXISTS idx_checkpoint_feature ON checkpoints(feature_id);
+`;
+
+let _storageType = null;
+
+export function getStorageType() {
+  if (_storageType) return _storageType;
+  try {
+    const cfg = getConfig();
+    _storageType = cfg.storage?.type === 'sqlite' ? 'sqlite' : 'file';
+  } catch {
+    _storageType = 'file';
+  }
+  return _storageType;
+}
+
+export class StorageAdapter {
+  constructor(type = 'file') {
+    this.type = type;
+    this.db = null;
+    if (type === 'sqlite') {
+      this._initSQLite();
+    }
+  }
+
+  _initSQLite() {
+    const Database = getDatabase();
+    if (!Database) {
+      console.warn('[StorageAdapter] better-sqlite3 not installed. Falling back to file storage.');
+      console.warn('  Install with: npm install better-sqlite3');
+      this.type = 'file';
+      return;
+    }
+    try {
+      if (!existsSync(WORKFLOW_DIR)) mkdirSync(WORKFLOW_DIR, { recursive: true });
+      this.db = new Database(DB_PATH);
+      this.db.pragma('journal_mode = WAL');
+      this.db.pragma('foreign_keys = ON');
+      this.db.exec(SCHEMA);
+    } catch (e) {
+      console.warn(`[StorageAdapter] SQLite init failed: ${e.message}. Falling back to file storage.`);
+      this.type = 'file';
+      this.db = null;
+    }
+  }
+
+  // --- Pipeline Status ---
+  readStatus() {
+    if (this.type === 'sqlite' && this.db) {
+      const row = this.db.prepare('SELECT * FROM pipeline_status ORDER BY updated_at DESC LIMIT 1').get();
+      if (!row) return {};
+      return { ...JSON.parse(row.data || '{}'), feature_id: row.feature_id, phase: row.phase, stage: row.stage, status: row.status };
+    }
+    return getStatus();
+  }
+
+  writeStatus(data) {
+    if (this.type === 'sqlite' && this.db) {
+      const stmt = this.db.prepare(
+        'INSERT INTO pipeline_status (feature_id, phase, stage, status, data) VALUES (?, ?, ?, ?, ?)'
+      );
+      stmt.run(data.featureId || '', data.phase || '', data.stage || '', data.status || '', JSON.stringify(data));
+      return;
+    }
+    return updateStatus(data);
+  }
+
+  // --- Cost Tracking ---
+  readCosts(filters = {}) {
+    if (this.type === 'sqlite' && this.db) {
+      let query = 'SELECT * FROM cost_entries WHERE 1=1';
+      const params = [];
+      if (filters.featureId) { query += ' AND feature_id = ?'; params.push(filters.featureId); }
+      if (filters.provider) { query += ' AND provider = ?'; params.push(filters.provider); }
+      if (filters.stage) { query += ' AND stage = ?'; params.push(filters.stage); }
+      if (filters.since) { query += ' AND ts >= ?'; params.push(filters.since); }
+      query += ' ORDER BY created_at DESC';
+      if (filters.limit) { query += ' LIMIT ?'; params.push(filters.limit); }
+      return this.db.prepare(query).all(...params).map(row => ({
+        ...JSON.parse(row.data || '{}'),
+        ts: row.ts, provider: row.provider, model: row.model,
+        stage: row.stage, featureId: row.feature_id,
+        inputTokens: row.input_tokens, outputTokens: row.output_tokens,
+        estimatedCost: row.estimated_cost, durationMs: row.duration_ms,
+      }));
+    }
+    return getCostEntries(filters);
+  }
+
+  writeCost(entry) {
+    if (this.type === 'sqlite' && this.db) {
+      const stmt = this.db.prepare(
+        'INSERT INTO cost_entries (ts, provider, model, stage, feature_id, input_tokens, output_tokens, estimated_cost, duration_ms, data) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'
+      );
+      stmt.run(
+        entry.ts || new Date().toISOString(), entry.provider || '', entry.model || '',
+        entry.stage || '', entry.featureId || '',
+        entry.inputTokens || 0, entry.outputTokens || 0,
+        entry.estimatedCost || 0, entry.durationMs || 0,
+        JSON.stringify(entry)
+      );
+      return;
+    }
+    return trackUsage(entry);
+  }
+
+  // --- Audit Log ---
+  readAuditLog(filters = {}) {
+    if (this.type === 'sqlite' && this.db) {
+      let query = 'SELECT * FROM audit_log WHERE 1=1';
+      const params = [];
+      if (filters.action) { query += ' AND action = ?'; params.push(filters.action); }
+      if (filters.userId) { query += ' AND user_id = ?'; params.push(filters.userId); }
+      if (filters.since) { query += ' AND ts >= ?'; params.push(filters.since); }
+      query += ' ORDER BY created_at DESC';
+      if (filters.limit) { query += ' LIMIT ?'; params.push(filters.limit); }
+      return this.db.prepare(query).all(...params).map(row => ({
+        ts: row.ts, action: row.action, userId: row.user_id,
+        ...JSON.parse(row.details || '{}'),
+      }));
+    }
+    // File-based fallback: read from audit.jsonl if it exists
+    const auditFile = join(WORKFLOW_DIR, 'audit.jsonl');
+    if (!existsSync(auditFile)) return [];
+    return readFileSync(auditFile, 'utf8').split('\n').filter(Boolean).map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  }
+
+  writeAuditEntry(entry) {
+    if (this.type === 'sqlite' && this.db) {
+      const stmt = this.db.prepare(
+        'INSERT INTO audit_log (ts, action, user_id, details) VALUES (?, ?, ?, ?)'
+      );
+      stmt.run(entry.ts || new Date().toISOString(), entry.action || '', entry.userId || '', JSON.stringify(entry));
+      return;
+    }
+    // File-based fallback
+    const auditFile = join(WORKFLOW_DIR, 'audit.jsonl');
+    if (!existsSync(WORKFLOW_DIR)) mkdirSync(WORKFLOW_DIR, { recursive: true });
+    const line = JSON.stringify({ ts: new Date().toISOString(), ...entry }) + '\n';
+    writeFileSync(auditFile, existsSync(auditFile) ? readFileSync(auditFile, 'utf8') + line : line);
+  }
+
+  // --- Checkpoints ---
+  readCheckpoint(featureId, stage, subStep) {
+    if (this.type === 'sqlite' && this.db) {
+      const row = this.db.prepare(
+        'SELECT * FROM checkpoints WHERE feature_id = ? AND stage = ? AND sub_step = ? ORDER BY created_at DESC LIMIT 1'
+      ).get(featureId, stage, subStep);
+      if (!row) return null;
+      return { content: row.content, hash: row.hash, createdAt: row.created_at };
+    }
+    return null; // File-based checkpoints handled by pipeline.js
+  }
+
+  writeCheckpoint(featureId, stage, subStep, content, hash) {
+    if (this.type === 'sqlite' && this.db) {
+      const stmt = this.db.prepare(
+        'INSERT OR REPLACE INTO checkpoints (feature_id, stage, sub_step, content, hash) VALUES (?, ?, ?, ?, ?)'
+      );
+      stmt.run(featureId, stage, subStep, content, hash);
+      return;
+    }
+    // File-based checkpoints handled by pipeline.js
+  }
+
+  // --- Migration ---
+  async migrate() {
+    if (!this.db) {
+      this._initSQLite();
+      if (!this.db) throw new Error('Cannot initialize SQLite. Install better-sqlite3: npm install better-sqlite3');
+    }
+
+    let migrated = { costs: 0, audit: 0 };
+
+    // Migrate costs.jsonl
+    const costsFile = join(WORKFLOW_DIR, 'costs.jsonl');
+    if (existsSync(costsFile)) {
+      const entries = readFileSync(costsFile, 'utf8').split('\n').filter(Boolean);
+      const stmt = this.db.prepare(
+        'INSERT OR IGNORE INTO cost_entries (ts, provider, model, stage, feature_id, input_tokens, output_tokens, estimated_cost, duration_ms, data) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'
+      );
+      const insertMany = this.db.transaction((lines) => {
+        for (const line of lines) {
+          try {
+            const e = JSON.parse(line);
+            stmt.run(e.ts || '', e.provider || '', e.model || '', e.stage || '', e.featureId || '',
+              e.inputTokens || 0, e.outputTokens || 0, e.estimatedCost || 0, e.durationMs || 0, line);
+            migrated.costs++;
+          } catch { /* skip malformed */ }
+        }
+      });
+      insertMany(entries);
+    }
+
+    // Migrate audit.jsonl
+    const auditFile = join(WORKFLOW_DIR, 'audit.jsonl');
+    if (existsSync(auditFile)) {
+      const entries = readFileSync(auditFile, 'utf8').split('\n').filter(Boolean);
+      const stmt = this.db.prepare(
+        'INSERT OR IGNORE INTO audit_log (ts, action, user_id, details) VALUES (?, ?, ?, ?)'
+      );
+      const insertMany = this.db.transaction((lines) => {
+        for (const line of lines) {
+          try {
+            const e = JSON.parse(line);
+            stmt.run(e.ts || '', e.action || '', e.userId || '', line);
+            migrated.audit++;
+          } catch { /* skip malformed */ }
+        }
+      });
+      insertMany(entries);
+    }
+
+    return migrated;
+  }
+
+  close() {
+    if (this.db) { this.db.close(); this.db = null; }
+  }
+}
+
+export const storage = new StorageAdapter(getStorageType());

package/lib/utils/display.js

@@ -0,0 +1,272 @@
+import chalk from 'chalk';
+import { getConfig } from '../config.js';
+import { getStatus } from './pipeline.js';
+import { statusBar } from './status-bar.js';
+
+// ─── Stage registry ────────────────────────────────────────────────────────────
+
+const STAGE_META = {
+  idle:                    { label: 'Idle',                          color: 'gray' },
+  inbox:                   { label: 'Feature Submitted',             color: 'yellow' },
+  spec_complete:           { label: 'PM Spec Ready',                 color: 'cyan' },
+  arch_complete:           { label: 'Architecture Ready',            color: 'blue' },
+  implementation_complete: { label: 'Copilot Done  ·  Needs Review', color: 'magenta' },
+  review_complete:         { label: 'Review Ready  ·  Approve?',     color: 'green' },
+  approved:                { label: 'Approved  ·  Ready to Deploy',  color: 'green' },
+  rejected:                { label: 'Rejected  ·  Needs Fixes',      color: 'red' },
+};
+
+// ─── Internal helpers ──────────────────────────────────────────────────────────
+
+function cols() {
+  // Always read current terminal width — works correctly after resize too.
+  return process.stdout.columns || 80;
+}
+
+function divider(c = '─') {
+  // Full-width line — no alignment needed, always correct.
+  return chalk.dim(c.repeat(cols()));
+}
+
+// ─── Header ────────────────────────────────────────────────────────────────────
+//
+// Design: Completely flat — no box borders that require exact width math.
+// Looks great at any terminal width.  Inspired by Claude Code / Gemini CLI.
+//
+//   ◆  ProjectName  ·  AI Control Center                              v1.0
+//      ● Architecture Ready
+//      Feature  FEATURE-20260223-230241
+//   ──────────────────────────────────────────────────────────────────────────────
+
+export function printHeader() {
+  const status    = getStatus();
+  const stageMeta = STAGE_META[status.stage] || { label: status.stage || 'Unknown', color: 'white' };
+  const VER       = 'v1.0';
+
+  // Feature — truncate to fit terminal
+  const featureRaw = status.current_feature || 'no active feature';
+  const maxFeat    = Math.max(20, cols() - 16);
+  const feature    = featureRaw.length > maxFeat ? featureRaw.slice(0, maxFeat - 1) + '…' : featureRaw;
+
+  // Pipeline mode badge — only when a feature is active
+  const modeStr = status.current_feature
+    ? `  ${chalk.dim('·')}  ${status.pipeline_mode === 'auto' ? chalk.cyan('auto') : chalk.dim('manual')}`
+    : '';
+
+  console.clear();
+  console.log('');
+
+  // ── Row 1: ◆  ProjectName  ·  AI Control Center              v1.0 ──────
+  const projectName = (() => { try { return getConfig().name; } catch { return 'AI Control Center'; } })();
+  const titleFixed  = `  ◆  ${projectName}  ·  AI Control Center  `;
+  const versionPad  = Math.max(1, cols() - titleFixed.length - VER.length);
+  console.log(
+    `  ${chalk.cyan.bold('◆')}  ${chalk.bold.white(projectName)}  ${chalk.dim('·')}  ${chalk.white('AI Control Center')}` +
+    ' '.repeat(versionPad) +
+    chalk.dim(VER)
+  );
+
+  // ── Row 2: ● Stage  ·  feature-id  ·  mode ────────────────────────────
+  console.log(
+    `     ${chalk[stageMeta.color](`● ${stageMeta.label}`)}  ${chalk.dim('·')}  ${chalk.dim(feature)}${modeStr}`
+  );
+
+  console.log('');
+  console.log(divider());
+  console.log('');
+
+  statusBar.reinstall();
+}
+
+// ─── Status / feedback ─────────────────────────────────────────────────────────
+
+export function printDivider() {
+  console.log(divider());
+}
+
+export function printSuccess(msg) {
+  console.log(chalk.green(`\n  ✓  ${msg}`));
+}
+
+export function printError(msg) {
+  console.log(chalk.red(`\n  ✗  ${msg}`));
+}
+
+export function printWarning(msg) {
+  console.log(chalk.yellow(`\n  ~  ${msg}`));
+}
+
+export function printInfo(msg) {
+  console.log(chalk.cyan(`\n  →  ${msg}`));
+}
+
+// ─── Content boxes ─────────────────────────────────────────────────────────────
+// Uses indented text blocks — no drawn borders that need width math.
+
+export function printBox(title, lines) {
+  console.log('');
+  console.log(chalk.bold.white(`  ${title}`));
+  console.log(chalk.dim(`  ${'─'.repeat(Math.min(50, cols() - 4))}`));
+  lines.forEach(line => console.log(`  ${chalk.white(line || '')}`));
+  console.log('');
+}
+
+// ─── AI handoff prompts ────────────────────────────────────────────────────────
+//
+// Each uses a simple left-rule bar — no right border that needs width matching.
+//
+//   ┃  CLAUDE CODE
+//   ┃  [prompt text here]
+//   ┃
+
+function sectionBlock(headerColor, headerText, lines) {
+  console.log('');
+  console.log(chalk[headerColor].bold(`  ┃  ${headerText}`));
+  lines.forEach(l => console.log(chalk.dim('  ┃  ') + chalk.white(l || '')));
+  console.log(chalk.dim('  ┃'));
+  console.log('');
+}
+
+export function printClaudePrompt(prompt) {
+  sectionBlock('magenta', 'CLAUDE CODE — paste this prompt:', prompt.split('\n'));
+}
+
+export function printCopilotPrompt(tasksFile) {
+  const archFile = tasksFile.replace('tasks/TASKS', 'architecture/ARCH');
+  sectionBlock('blue', 'COPILOT CHAT — paste this prompt:', [
+    `Read ${tasksFile}`,
+    'and implement all tasks. Follow the architecture in',
+    archFile,
+  ]);
+}
+
+/**
+ * Show a structured verdict panel after Gemini review completes.
+ *
+ * verdict = {
+ *   decision:  'APPROVED' | 'REJECTED' | 'UNKNOWN',
+ *   blockers:  string[],
+ *   warnings:  string[],
+ *   approved:  string[],
+ *   actionItems: string[],
+ * }
+ */
+export function printVerdictPanel(verdict, reviewFilePath) {
+  const isApproved = verdict.decision === 'APPROVED';
+  const color  = isApproved ? 'green'  : verdict.decision === 'UNKNOWN' ? 'yellow' : 'red';
+  const symbol = isApproved ? '✓' : '✗';
+  const bar    = chalk.dim('  ┃  ');
+
+  console.log('');
+  console.log(chalk[color].bold(`  ┃  REVIEW VERDICT`));
+  console.log(chalk.dim('  ┃'));
+
+  // Decision line
+  const decLabel = chalk[color].bold(`${symbol}  ${verdict.decision}`);
+  const counts   = [
+    verdict.blockers.length  ? chalk.red(`${verdict.blockers.length} blocker${verdict.blockers.length !== 1 ? 's' : ''}`)   : null,
+    verdict.warnings.length  ? chalk.yellow(`${verdict.warnings.length} warning${verdict.warnings.length !== 1 ? 's' : ''}`) : null,
+    verdict.approved.length  ? chalk.green(`${verdict.approved.length} approved`)  : null,
+  ].filter(Boolean).join(chalk.dim('  ·  '));
+
+  console.log(`${bar}${decLabel}  ${chalk.dim('·')}  ${counts || chalk.dim('no issues')}`);
+  console.log(chalk.dim('  ┃'));
+
+  // Blockers
+  if (verdict.blockers.length) {
+    console.log(`${bar}${chalk.red.bold(`Blockers  (must fix before merge)`)}`);
+    verdict.blockers.forEach((b, i) => {
+      console.log(`${bar}  ${chalk.red(`${i + 1}.`)}  ${chalk.white(b)}`);
+    });
+    console.log(chalk.dim('  ┃'));
+  }
+
+  // Warnings
+  if (verdict.warnings.length) {
+    console.log(`${bar}${chalk.yellow.bold('Warnings  (non-blocking)')}`);
+    verdict.warnings.forEach((w, i) => {
+      console.log(`${bar}  ${chalk.yellow(`${i + 1}.`)}  ${chalk.white(w)}`);
+    });
+    console.log(chalk.dim('  ┃'));
+  }
+
+  // Action items
+  if (verdict.actionItems.length) {
+    console.log(`${bar}${chalk.cyan.bold('Action Items for Copilot')}`);
+    verdict.actionItems.forEach((a, i) => {
+      console.log(`${bar}  ${chalk.cyan(`${i + 1}.`)}  ${chalk.white(a)}`);
+    });
+    console.log(chalk.dim('  ┃'));
+  }
+
+  // File path
+  console.log(`${bar}${chalk.dim('Review file')}  ${chalk.white(reviewFilePath)}`);
+  console.log(chalk.dim('  ┃'));
+
+  // Next step hint
+  if (isApproved) {
+    console.log(`${bar}${chalk.dim('Next')}  ${chalk.green('Select  ✓ Approve Feature  in the menu')}`);
+  } else {
+    console.log(`${bar}${chalk.dim('Next')}  ${chalk.yellow('Select  ✗ Reject / Request Fixes  to dispatch to Copilot')}`);
+  }
+  console.log('');
+}
+
+/**
+ * Show a structured deploy error panel.
+ * componentErrors: [{ fileName, lineNumber, problem }]
+ * testFailures:    [{ name, methodName, message }]
+ */
+export function printDeployErrorPanel(componentErrors, testFailures, attempt, maxAttempts, rawErrors = '') {
+  const total = componentErrors.length + testFailures.length;
+  const bar   = chalk.dim('  ┃  ');
+
+  console.log('');
+  console.log(chalk.red.bold('  ┃  DEPLOY FAILED') + chalk.dim(`  ·  attempt ${attempt} of ${maxAttempts}`));
+  console.log(chalk.dim('  ┃'));
+  console.log(`${bar}${chalk.red(`${total} error${total !== 1 ? 's' : ''} total`)}  ${chalk.dim('·')}  ${chalk.red(`${componentErrors.length} compile`)}  ${chalk.dim('·')}  ${chalk.red(`${testFailures.length} test`)}`);
+  console.log(chalk.dim('  ┃'));
+
+  if (componentErrors.length) {
+    console.log(`${bar}${chalk.red.bold('Compile Errors')}`);
+    componentErrors.forEach((e, i) => {
+      const loc = e.lineNumber ? chalk.dim(`:${e.lineNumber}`) : '';
+      console.log(`${bar}  ${chalk.dim(`${i + 1}.`)}  ${chalk.yellow(e.fileName || e.fullName)}${loc}`);
+      console.log(`${bar}      ${chalk.white(e.problem)}`);
+    });
+    console.log(chalk.dim('  ┃'));
+  }
+
+  if (testFailures.length) {
+    console.log(`${bar}${chalk.red.bold('Test Failures')}`);
+    testFailures.forEach((f, i) => {
+      console.log(`${bar}  ${chalk.dim(`${i + 1}.`)}  ${chalk.yellow(`${f.name}.${f.methodName}`)}`);
+      console.log(`${bar}      ${chalk.white((f.message || '').slice(0, 200))}`);
+    });
+    console.log(chalk.dim('  ┃'));
+  }
+
+  // Show raw output when SF CLI didn't return structured errors
+  if (total === 0 && rawErrors) {
+    console.log(`${bar}${chalk.yellow.bold('Raw Deploy Output  (structured errors unavailable)')}`);
+    rawErrors.split('\n').slice(0, 20).forEach(line => {
+      console.log(`${bar}  ${chalk.white(line)}`);
+    });
+    console.log(chalk.dim('  ┃'));
+  }
+
+  console.log('');
+}
+
+export function printCopilotFixPrompt(reviewFile, actionItems) {
+  const lines = [
+    `Read ${reviewFile}`,
+    'Fix all ✗ Blockers and ~ Warnings listed in the review.',
+  ];
+  if (actionItems.length) {
+    lines.push('');
+    lines.push('Action Items:');
+    actionItems.forEach((item, i) => lines.push(`  ${i + 1}.  ${item}`));
+  }
+  sectionBlock('blue', 'COPILOT CHAT — paste this prompt:', lines);
+}