vibecheck-ai 2.0.2 → 5.0.0

package/bin/runners/lib/json-output.js

@@ -0,0 +1,76 @@
+/**
+ * JSON Output Utilities
+ * 
+ * Provides versioned JSON output schema helpers for CLI commands
+ */
+
+const VERSION = "1.0.0";
+const SCHEMA_BASE = "vibecheck-cli-tool/v1";
+
+/**
+ * Create a versioned JSON output envelope
+ * @param {Object} data - The actual output data
+ * @param {string} schemaType - Schema type (e.g., "scan", "gate", "ship")
+ * @returns {Object} Versioned output object
+ */
+function createVersionedOutput(data, schemaType = "generic") {
+  return {
+    version: VERSION,
+    schema: `${SCHEMA_BASE}/${schemaType}`,
+    timestamp: new Date().toISOString(),
+    ...data,
+  };
+}
+
+/**
+ * Create a versioned error output
+ * @param {string|Error} error - Error message or Error object
+ * @param {Object} metadata - Additional error metadata
+ * @returns {Object} Versioned error output
+ */
+function createErrorOutput(error, metadata = {}) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  const errorOutput = {
+    version: VERSION,
+    schema: `${SCHEMA_BASE}/error`,
+    timestamp: new Date().toISOString(),
+    success: false,
+    error: errorMessage,
+  };
+
+  if (metadata.receipt) {
+    errorOutput.receipt = metadata.receipt;
+  }
+  if (metadata.code) {
+    errorOutput.code = metadata.code;
+  }
+  if (metadata.exitCode) {
+    errorOutput.exitCode = metadata.exitCode;
+  }
+  if (metadata.verifyCommand) {
+    errorOutput.verifyCommand = metadata.verifyCommand;
+  }
+
+  return errorOutput;
+}
+
+/**
+ * Create a versioned success output
+ * @param {Object} data - Success data
+ * @param {string} schemaType - Schema type
+ * @returns {Object} Versioned success output
+ */
+function createSuccessOutput(data, schemaType = "generic") {
+  return createVersionedOutput({
+    success: true,
+    ...data,
+  }, schemaType);
+}
+
+module.exports = {
+  VERSION,
+  SCHEMA_BASE,
+  createVersionedOutput,
+  createErrorOutput,
+  createSuccessOutput,
+};

package/bin/runners/lib/llm.js

@@ -0,0 +1,75 @@
+// bin/runners/lib/llm.js
+const https = require("https");
+const http = require("http");
+const { URL } = require("url");
+
+function postJson(urlStr, headers, bodyObj) {
+  const url = new URL(urlStr);
+  const lib = url.protocol === "https:" ? https : http;
+
+  const data = JSON.stringify(bodyObj);
+
+  return new Promise((resolve, reject) => {
+    const req = lib.request(
+      {
+        method: "POST",
+        hostname: url.hostname,
+        port: url.port || (url.protocol === "https:" ? 443 : 80),
+        path: url.pathname,
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(data),
+          ...headers
+        }
+      },
+      (res) => {
+        let buf = "";
+        res.on("data", (d) => (buf += d));
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(buf);
+            resolve({ status: res.statusCode, json, raw: buf });
+          } catch (e) {
+            reject(new Error(`LLM response not JSON (status ${res.statusCode}): ${buf.slice(0, 400)}`));
+          }
+        });
+      }
+    );
+
+    req.on("error", reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+async function generatePatchJson(prompt) {
+  const baseUrl = process.env.VIBECHECK_LLM_BASE_URL;
+  const apiKey = process.env.VIBECHECK_LLM_API_KEY;
+  const model = process.env.VIBECHECK_LLM_MODEL || "gpt-4.1-mini";
+
+  if (!baseUrl || !apiKey) {
+    const err = new Error("LLM not configured: set VIBECHECK_LLM_BASE_URL and VIBECHECK_LLM_API_KEY");
+    err.code = "VIBECHECK_LLM_NOT_CONFIGURED";
+    throw err;
+  }
+
+  const headers = { Authorization: `Bearer ${apiKey}` };
+
+  const body = {
+    model,
+    temperature: 0.1,
+    messages: [
+      { role: "system", content: "Return JSON only." },
+      { role: "user", content: prompt }
+    ]
+  };
+
+  const r = await postJson(baseUrl, headers, body);
+
+  const content = r.json?.choices?.[0]?.message?.content;
+  if (!content) throw new Error("LLM response missing choices[0].message.content");
+
+  return JSON.parse(content);
+}
+
+module.exports = { generatePatchJson };

package/bin/runners/lib/logger.js

@@ -0,0 +1,38 @@
+/**
+ * Simple Logger Stub
+ * 
+ * Provides a minimal logger interface for modules that need it.
+ * Respects VIBECHECK_DEBUG and VIBECHECK_QUIET environment variables.
+ */
+
+"use strict";
+
+const isDebug = process.env.VIBECHECK_DEBUG === "true" || process.env.DEBUG;
+const isQuiet = process.env.VIBECHECK_QUIET === "true";
+
+const logger = {
+  debug: (...args) => {
+    if (isDebug && !isQuiet) {
+      console.debug("[DEBUG]", ...args);
+    }
+  },
+  info: (...args) => {
+    if (!isQuiet) {
+      console.info("[INFO]", ...args);
+    }
+  },
+  warn: (...args) => {
+    console.warn("[WARN]", ...args);
+  },
+  error: (...args) => {
+    console.error("[ERROR]", ...args);
+  },
+  // Alias for compatibility
+  log: (...args) => {
+    if (!isQuiet) {
+      console.log(...args);
+    }
+  },
+};
+
+module.exports = { logger };

package/bin/runners/lib/meter.js

@@ -0,0 +1,61 @@
+// bin/runners/lib/meter.js
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+function monthKey(d = new Date()) {
+  const y = d.getUTCFullYear();
+  const m = String(d.getUTCMonth() + 1).padStart(2, "0");
+  return `${y}-${m}`;
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function readJson(p, fallback) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return fallback; }
+}
+
+function writeJson(p, obj) {
+  fs.writeFileSync(p, JSON.stringify(obj, null, 2));
+}
+
+function defaultStorePath() {
+  return path.join(os.homedir(), ".vibecheck", "usage.json");
+}
+
+/**
+ * Local meter:
+ * - Free tier: 10 ship checks per calendar month
+ * - Paid tiers: unlimited (you can override tier via env while developing)
+ */
+function consumeShipCheckOrThrow({ tier, limitFree = 10 } = {}) {
+  const effectiveTier = (tier || process.env.VIBECHECK_TIER || "free").toLowerCase();
+
+  if (effectiveTier !== "free") {
+    return { ok: true, remaining: Infinity, tier: effectiveTier };
+  }
+
+  const storePath = process.env.VIBECHECK_USAGE_PATH || defaultStorePath();
+  ensureDir(path.dirname(storePath));
+  const store = readJson(storePath, { months: {} });
+
+  const key = monthKey();
+  const used = store.months[key]?.shipChecks || 0;
+
+  if (used >= limitFree) {
+    const err = new Error(`Free tier limit reached: ${limitFree} full ship checks/month. Upgrade to continue.`);
+    err.code = "VIBECHECK_LIMIT_REACHED";
+    err.meta = { used, limitFree, month: key };
+    throw err;
+  }
+
+  store.months[key] = store.months[key] || {};
+  store.months[key].shipChecks = used + 1;
+  writeJson(storePath, store);
+
+  return { ok: true, remaining: limitFree - (used + 1), tier: effectiveTier };
+}
+
+module.exports = { consumeShipCheckOrThrow };

package/bin/runners/lib/missions/briefing.js

@@ -0,0 +1,427 @@
+// bin/runners/lib/missions/briefing.js
+// ═══════════════════════════════════════════════════════════════════════════════
+// MISSION BRIEFING - Beautiful plan-only mode output
+// Shows what would happen without executing, building trust and transparency
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const { RISK_LEVEL, BLAST_RADIUS } = require('./schema');
+const { runPreFlightGates, formatGateResults } = require('./safety-gates');
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TERMINAL STYLING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  // Colors
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+};
+
+// RGB helper
+const rgb = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
+
+// Premium color palette
+const colors = {
+  accent: rgb(255, 150, 50),
+  muted: rgb(120, 120, 140),
+  success: rgb(0, 255, 150),
+  warning: rgb(255, 200, 0),
+  danger: rgb(255, 80, 80),
+  info: rgb(100, 200, 255),
+  
+  // Risk colors
+  low: rgb(100, 200, 100),
+  medium: rgb(255, 200, 100),
+  high: rgb(255, 150, 100),
+  critical: rgb(255, 80, 80),
+};
+
+const ICONS = {
+  mission: '🎯',
+  file: '📄',
+  check: '✓',
+  cross: '✗',
+  warning: '⚠',
+  info: 'ℹ',
+  arrow: '→',
+  bullet: '•',
+  shield: '🛡️',
+  checkpoint: '💾',
+  rollback: '↩️',
+  lock: '🔒',
+  unlock: '🔓',
+  rocket: '🚀',
+  brain: '🧠',
+  gear: '⚙️',
+};
+
+const BOX = {
+  topLeft: '╭',
+  topRight: '╮',
+  bottomLeft: '╰',
+  bottomRight: '╯',
+  horizontal: '─',
+  vertical: '│',
+  teeRight: '├',
+  teeLeft: '┤',
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FORMATTING UTILITIES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Get color for risk level
+ */
+function getRiskColor(riskLevel) {
+  switch (riskLevel) {
+    case RISK_LEVEL.LOW: return colors.low;
+    case RISK_LEVEL.MEDIUM: return colors.medium;
+    case RISK_LEVEL.HIGH: return colors.high;
+    case RISK_LEVEL.CRITICAL: return colors.critical;
+    default: return colors.muted;
+  }
+}
+
+/**
+ * Get icon for mission type
+ */
+function getMissionIcon(type) {
+  const icons = {
+    'REMOVE_OWNER_MODE': '🔐',
+    'FIX_STRIPE_WEBHOOKS': '💰',
+    'ENFORCE_PAID_SURFACE': '🛡️',
+    'ADD_SERVER_AUTH': '🔒',
+    'FIX_MISSING_ROUTE': '🛤️',
+    'FIX_FAKE_SUCCESS': '👻',
+    'FIX_ENV_CONTRACT': '🌍',
+    'FIX_DEAD_UI': '💀',
+    'FIX_EMPTY_CATCH': '🐛',
+    'FIX_TEST_KEYS': '🔑',
+    'FIX_MOCK_DOMAINS': '🔗',
+    'FIX_PLACEHOLDER_DATA': '📝',
+    'FIX_HARDCODED_SECRETS': '🔐',
+    'FIX_SIMULATED_BILLING': '💳',
+    'FIX_SILENT_FALLBACK': '🔇',
+    'SYNC_CONTRACTS': '📊',
+    'FIX_ROUTE_DRIFT': '🛤️',
+    'FIX_AUTH_DRIFT': '🛡️',
+  };
+  return icons[type] || ICONS.mission;
+}
+
+/**
+ * Truncate string to max length
+ */
+function truncate(str, max) {
+  if (!str) return '';
+  if (str.length <= max) return str;
+  return str.slice(0, max - 3) + '...';
+}
+
+/**
+ * Create a horizontal line
+ */
+function line(width = 60, char = '─') {
+  return c.dim + char.repeat(width) + c.reset;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MISSION BRIEFING FORMATTERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Format a single mission briefing
+ * @param {object} mission - Mission object
+ * @param {object} gateResults - Pre-flight gate results
+ * @param {number} index - Mission index (1-based)
+ * @param {number} total - Total missions
+ * @returns {string} Formatted briefing
+ */
+function formatMissionBriefing(mission, gateResults, index, total) {
+  const lines = [];
+  const w = 60;
+  const icon = getMissionIcon(mission.type);
+  const riskColor = getRiskColor(mission.safety?.riskLevel);
+  
+  // Header box
+  lines.push('');
+  lines.push(`  ${c.dim}${BOX.topLeft}${BOX.horizontal.repeat(w)}${BOX.topRight}${c.reset}`);
+  
+  // Mission type header
+  const header = `${icon} Mission ${index}/${total}: ${mission.type}`;
+  const headerPad = Math.max(0, w - header.length - 2);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset} ${colors.accent}${c.bold}${header}${c.reset}${' '.repeat(headerPad)} ${c.dim}${BOX.vertical}${c.reset}`);
+  
+  // Separator
+  lines.push(`  ${c.dim}${BOX.teeRight}${BOX.horizontal.repeat(w)}${BOX.teeLeft}${c.reset}`);
+  
+  // Objective section
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset} ${c.bold}Objective${c.reset}`);
+  const intent = truncate(mission.template?.intent || mission.objective?.intent || 'Fix issues', w - 4);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${intent}`);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}`);
+  
+  // Files section
+  const files = mission.scope?.allowedFiles || [];
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset} ${c.bold}Files${c.reset} ${c.dim}(${files.length} total)${c.reset}`);
+  for (const file of files.slice(0, 4)) {
+    lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${ICONS.file} ${truncate(file, w - 8)}`);
+  }
+  if (files.length > 4) {
+    lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${c.dim}... and ${files.length - 4} more${c.reset}`);
+  }
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}`);
+  
+  // Risk section
+  const riskLevel = (mission.safety?.riskLevel || 'medium').toUpperCase();
+  const blastRadius = mission.scope?.blastRadius || 'medium';
+  const confidence = Math.round((mission.safety?.confidence || 0.5) * 100);
+  
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset} ${c.bold}Risk Assessment${c.reset}`);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${riskColor}${ICONS.shield} Risk: ${riskLevel}${c.reset}`);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${ICONS.bullet} Blast radius: ${blastRadius} (${files.length} files)`);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${ICONS.bullet} Confidence: ${confidence}%`);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${mission.safety?.reversible !== false ? colors.success + ICONS.check : colors.danger + ICONS.cross}${c.reset} Reversible: ${mission.safety?.reversible !== false ? 'Yes' : 'No'}`);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}`);
+  
+  // Safety gates section
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset} ${c.bold}Safety Gates${c.reset}`);
+  for (const result of gateResults.results) {
+    const gateIcon = result.pass 
+      ? (result.severity === 'warning' ? colors.warning + ICONS.warning : colors.success + ICONS.check)
+      : colors.danger + ICONS.cross;
+    const gateName = result.gate.replace(/_/g, ' ');
+    lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${gateIcon}${c.reset} ${gateName}`);
+  }
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}`);
+  
+  // Success criteria section
+  const criteria = mission.template?.success || mission.objective?.successCriteria || [];
+  if (criteria.length > 0) {
+    lines.push(`  ${c.dim}${BOX.vertical}${c.reset} ${c.bold}Success Criteria${c.reset}`);
+    for (const criterion of criteria.slice(0, 3)) {
+      lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${ICONS.bullet} ${truncate(criterion, w - 8)}`);
+    }
+    lines.push(`  ${c.dim}${BOX.vertical}${c.reset}`);
+  }
+  
+  // Actions section
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset} ${c.bold}Actions (on --apply)${c.reset}`);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${c.dim}1.${c.reset} Create checkpoint ${ICONS.checkpoint}`);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${c.dim}2.${c.reset} Generate LLM prompt with Reality Firewall ${ICONS.brain}`);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${c.dim}3.${c.reset} Validate and apply patch ${ICONS.gear}`);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${c.dim}4.${c.reset} Run ship to verify ${ICONS.rocket}`);
+  lines.push(`  ${c.dim}${BOX.vertical}${c.reset}   ${c.dim}5.${c.reset} Auto-rollback if gates fail ${ICONS.rollback}`);
+  
+  // Footer box
+  lines.push(`  ${c.dim}${BOX.bottomLeft}${BOX.horizontal.repeat(w)}${BOX.bottomRight}${c.reset}`);
+  
+  // Execute hint
+  if (gateResults.ok) {
+    lines.push(`  ${colors.success}${ICONS.check}${c.reset} Ready to execute: ${colors.accent}vibecheck fix --apply --mission ${mission.id}${c.reset}`);
+  } else {
+    lines.push(`  ${colors.danger}${ICONS.cross}${c.reset} Cannot execute: ${gateResults.summary}`);
+    // Show remedies
+    for (const result of gateResults.results.filter(r => !r.pass && r.remedy)) {
+      lines.push(`    ${c.dim}${ICONS.arrow} ${result.remedy}${c.reset}`);
+    }
+  }
+  
+  return lines.join('\n');
+}
+
+/**
+ * Format all mission briefings
+ * @param {string} repoRoot - Repository root
+ * @param {object[]} missions - Array of missions
+ * @param {object} options - Formatting options
+ * @returns {string} Formatted output
+ */
+function formatAllBriefings(repoRoot, missions, options = {}) {
+  const lines = [];
+  
+  // Header
+  lines.push('');
+  lines.push(`  ${colors.accent}${c.bold}MISSION BRIEFINGS${c.reset}`);
+  lines.push(`  ${c.dim}Plan-only mode: No changes will be made${c.reset}`);
+  lines.push('  ' + line(60));
+  
+  // Summary stats
+  const stats = {
+    total: missions.length,
+    findings: missions.reduce((sum, m) => sum + (m.objective?.findingCount || 1), 0),
+    files: new Set(missions.flatMap(m => m.scope?.allowedFiles || [])).size,
+  };
+  
+  lines.push('');
+  lines.push(`  ${ICONS.mission} ${c.bold}${stats.total}${c.reset} missions targeting ${c.bold}${stats.findings}${c.reset} findings in ${c.bold}${stats.files}${c.reset} files`);
+  lines.push('');
+  
+  // Individual briefings
+  let readyCount = 0;
+  let blockedCount = 0;
+  
+  for (let i = 0; i < missions.length; i++) {
+    const mission = missions[i];
+    const gateResults = runPreFlightGates(repoRoot, mission, options);
+    
+    if (gateResults.ok) readyCount++;
+    else blockedCount++;
+    
+    lines.push(formatMissionBriefing(mission, gateResults, i + 1, missions.length));
+  }
+  
+  // Summary footer
+  lines.push('');
+  lines.push('  ' + line(60, '═'));
+  lines.push(`  ${c.bold}SUMMARY${c.reset}`);
+  lines.push(`    ${colors.success}${ICONS.check}${c.reset} Ready: ${readyCount}/${missions.length} missions`);
+  if (blockedCount > 0) {
+    lines.push(`    ${colors.danger}${ICONS.cross}${c.reset} Blocked: ${blockedCount}/${missions.length} missions`);
+  }
+  lines.push('');
+  
+  // Next steps
+  lines.push(`  ${c.bold}Next Steps:${c.reset}`);
+  if (readyCount > 0) {
+    lines.push(`    ${colors.accent}vibecheck fix --apply${c.reset}              ${c.dim}Execute all ready missions${c.reset}`);
+    lines.push(`    ${colors.accent}vibecheck fix --apply --mission M_xxx${c.reset}  ${c.dim}Execute specific mission${c.reset}`);
+  }
+  if (blockedCount > 0) {
+    lines.push(`    ${colors.accent}vibecheck fix --apply --force${c.reset}         ${c.dim}Override safety gates${c.reset}`);
+  }
+  lines.push('');
+  
+  return lines.join('\n');
+}
+
+/**
+ * Format a compact mission summary (for non-plan-only mode)
+ * @param {object[]} missions - Array of missions
+ * @returns {string} Formatted summary
+ */
+function formatMissionSummary(missions) {
+  const lines = [];
+  
+  lines.push('');
+  lines.push(`  ${colors.accent}${ICONS.mission}${c.reset} ${c.bold}MISSION PLAN${c.reset} ${c.dim}(${missions.length} missions)${c.reset}`);
+  lines.push('');
+  
+  for (let i = 0; i < missions.length; i++) {
+    const m = missions[i];
+    const icon = getMissionIcon(m.type);
+    const riskColor = getRiskColor(m.safety?.riskLevel);
+    const fileCount = m.scope?.allowedFiles?.length || 0;
+    const findingCount = m.objective?.findingCount || 1;
+    
+    lines.push(`  ${icon} ${c.bold}${i + 1}.${c.reset} ${m.type.padEnd(24)} ${c.dim}${findingCount} finding(s)${c.reset} ${riskColor}${m.safety?.riskLevel?.toUpperCase() || 'MEDIUM'}${c.reset}`);
+  }
+  
+  lines.push('');
+  
+  return lines.join('\n');
+}
+
+/**
+ * Format mission execution result
+ * @param {object} mission - Mission object
+ * @param {object} result - Execution result
+ * @returns {string} Formatted result
+ */
+function formatMissionResult(mission, result) {
+  const lines = [];
+  const icon = getMissionIcon(mission.type);
+  
+  if (result.success) {
+    lines.push(`  ${colors.success}${ICONS.check}${c.reset} ${icon} ${mission.type} ${c.bold}completed${c.reset}`);
+    if (result.findings) {
+      lines.push(`    ${c.dim}${ICONS.arrow} ${result.findings.before} → ${result.findings.after} findings${c.reset}`);
+    }
+  } else if (result.rolledBack) {
+    lines.push(`  ${colors.warning}${ICONS.rollback}${c.reset} ${icon} ${mission.type} ${c.bold}rolled back${c.reset}`);
+    lines.push(`    ${c.dim}${ICONS.arrow} ${result.reason || 'Post-flight gates failed'}${c.reset}`);
+  } else {
+    lines.push(`  ${colors.danger}${ICONS.cross}${c.reset} ${icon} ${mission.type} ${c.bold}failed${c.reset}`);
+    lines.push(`    ${c.dim}${ICONS.arrow} ${result.reason || 'Unknown error'}${c.reset}`);
+  }
+  
+  return lines.join('\n');
+}
+
+/**
+ * Format final summary after all missions
+ * @param {object} summary - Execution summary
+ * @returns {string} Formatted summary
+ */
+function formatFinalSummary(summary) {
+  const lines = [];
+  
+  lines.push('');
+  lines.push('  ' + line(60, '═'));
+  lines.push(`  ${c.bold}MISSION CONTROL SUMMARY${c.reset}`);
+  lines.push('');
+  
+  // Stats
+  lines.push(`    ${colors.success}${ICONS.check}${c.reset} Completed: ${summary.completed}/${summary.total}`);
+  if (summary.rolledBack > 0) {
+    lines.push(`    ${colors.warning}${ICONS.rollback}${c.reset} Rolled back: ${summary.rolledBack}`);
+  }
+  if (summary.failed > 0) {
+    lines.push(`    ${colors.danger}${ICONS.cross}${c.reset} Failed: ${summary.failed}`);
+  }
+  if (summary.skipped > 0) {
+    lines.push(`    ${c.dim}${ICONS.bullet}${c.reset} Skipped: ${summary.skipped}`);
+  }
+  
+  // Duration
+  if (summary.duration) {
+    const seconds = Math.round(summary.duration / 1000);
+    lines.push(`    ${ICONS.bullet} Duration: ${seconds}s`);
+  }
+  
+  // Verdict
+  lines.push('');
+  if (summary.verdict === 'SHIP') {
+    lines.push(`  ${colors.success}${ICONS.rocket} SHIP${c.reset} ${c.dim}All issues resolved!${c.reset}`);
+  } else if (summary.verdict === 'WARN') {
+    lines.push(`  ${colors.warning}${ICONS.warning} WARN${c.reset} ${c.dim}Some warnings remain${c.reset}`);
+  } else {
+    lines.push(`  ${colors.danger}${ICONS.cross} BLOCK${c.reset} ${c.dim}Blocking issues remain${c.reset}`);
+  }
+  
+  lines.push('');
+  
+  return lines.join('\n');
+}
+
+module.exports = {
+  // Main formatters
+  formatMissionBriefing,
+  formatAllBriefings,
+  formatMissionSummary,
+  formatMissionResult,
+  formatFinalSummary,
+  
+  // Utilities
+  getMissionIcon,
+  getRiskColor,
+  truncate,
+  line,
+  
+  // Colors and icons for external use
+  colors,
+  ICONS,
+  c,
+};