mergen-server 1.4.0

package/dist/commands/incident.js

@@ -0,0 +1,644 @@
+import { existsSync, readFileSync } from "fs";
+import { resolve, join } from "path";
+import { log, success, error, hr, ask, sleep, SERVER_ENTRY } from "./shared.js";
+async function postmortemCommand(args) {
+  let port = 3e3;
+  for (let p = 3e3; p <= 3010; p++) {
+    try {
+      const r = await fetch(`http://127.0.0.1:${p}/health`, { signal: AbortSignal.timeout(600) });
+      if (r.ok) {
+        port = p;
+        break;
+      }
+    } catch {
+    }
+  }
+  const hours = parseFloat(args[1] ?? "1") || 1;
+  const sha = args[2] ?? "";
+  const to = Date.now();
+  const from = to - hours * 60 * 60 * 1e3;
+  const params = new URLSearchParams({ from: String(Math.round(from)), to: String(to), format: "md" });
+  if (sha) params.set("sha", sha);
+  console.log(`Generating postmortem (last ${hours}h)...
+`);
+  try {
+    const r = await fetch(`http://127.0.0.1:${port}/export/incident?${params}`, { signal: AbortSignal.timeout(5e3) });
+    if (!r.ok) {
+      error(`Server returned ${r.status}`);
+      process.exit(1);
+    }
+    const md = await r.text();
+    const { writeFileSync: writeFileSync2 } = await import("fs");
+    const filename = `postmortem-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/:/g, "-")}.md`;
+    writeFileSync2(filename, md, "utf8");
+    process.stdout.write(md + "\n");
+    hr();
+    success(`Saved to: ${filename}`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+async function timelineCommand(args) {
+  const seconds = parseInt(args[1] ?? "300", 10) || 300;
+  let port = 0;
+  for (let p = 3e3; p <= 3010; p++) {
+    try {
+      const r = await fetch(`http://127.0.0.1:${p}/health`, { signal: AbortSignal.timeout(600) });
+      if (r.ok) {
+        port = p;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!port) {
+    error("Server not running. Start with: mergen-server start");
+    process.exit(1);
+  }
+  let data = {};
+  try {
+    const r = await fetch(`http://127.0.0.1:${port}/timeline/unified?seconds=${seconds}&limit=100`, { signal: AbortSignal.timeout(3e3) });
+    data = await r.json();
+  } catch {
+    error("Failed to fetch timeline");
+    process.exit(1);
+  }
+  const rows = data.rows ?? [];
+  const rc = data.rootCause ?? null;
+  const KIND_ICON = {
+    error: "\u{1F534}",
+    warn: "\u{1F7E1}",
+    log: "\u2B1C",
+    request: "\u{1F7E0}",
+    context: "\u2B1C",
+    terminal: "\u{1F4BB}",
+    process_exit: "\u{1F4A5}",
+    ci_failure: "\u274C",
+    ci_success: "\u2705",
+    deployment: "\u{1F680}"
+  };
+  const SRC_LABEL = {
+    browser: "BROWSER",
+    backend: "BACKEND",
+    ci: "CI",
+    deploy: "DEPLOY"
+  };
+  hr();
+  console.log(`\u2B21 Mergen Unified Timeline  (last ${Math.round(seconds / 60)}m \xB7 ${rows.length} events)
+`);
+  if (rc) {
+    const pct = Math.round((rc.confidence ?? 0) * 100);
+    console.log(`\u250C\u2500 Root Cause  ${pct}% confidence`);
+    console.log(`\u2502  ${rc.hypothesis}`);
+    if (rc.fixHint) console.log(`\u2502  \u{1F4A1} ${rc.fixHint}`);
+    console.log("\u2514" + "\u2500".repeat(58));
+    console.log("");
+  }
+  if (rows.length === 0) {
+    log("No significant events in this window.");
+    log("Connect CI: POST /ci/github or POST /ci/generic");
+    log("Stream logs: mergen-server watch npm start");
+  } else {
+    for (const r of rows) {
+      const time = new Date(r.ts).toISOString().slice(11, 19);
+      const icon = KIND_ICON[r.kind] ?? "\u2B1C";
+      const src = r.source ? `  [${SRC_LABEL[r.source] ?? r.source}]` : "";
+      const sha = r.sha ? `  {${r.sha}}` : "";
+      const summary = r.summary.slice(0, 90);
+      console.log(`${time}  ${icon}${src.padEnd(12)}  ${summary}${sha}`);
+    }
+  }
+  hr();
+}
+async function watchCommand(args) {
+  let name = "";
+  let port = 3e3;
+  const rest = [];
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--name" && args[i + 1]) {
+      name = args[++i];
+    } else if (args[i] === "--port" && args[i + 1]) {
+      port = parseInt(args[++i], 10);
+    } else if (args[i] === "--") {
+      rest.push(...args.slice(i + 1));
+      break;
+    } else {
+      rest.push(...args.slice(i));
+      break;
+    }
+  }
+  if (rest.length === 0) {
+    error("Usage: mergen-server watch [--name <name>] [--port <port>] <command> [args...]");
+    console.log("  Example: mergen-server watch npm start");
+    console.log("  Example: mergen-server watch --name api python manage.py runserver");
+    process.exit(1);
+  }
+  const command = rest[0];
+  const cmdArgs = rest.slice(1);
+  const processName = name || command;
+  const mergenHost = process.env.MERGEN_HOST ?? "127.0.0.1";
+  let serverPort = port;
+  let serverFound = false;
+  for (let p = 3e3; p <= 3010; p++) {
+    try {
+      const r = await fetch(`http://${mergenHost}:${p}/health`, { signal: AbortSignal.timeout(500) });
+      if (r.ok) {
+        serverPort = p;
+        serverFound = true;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!serverFound) {
+    const serverPath = SERVER_ENTRY;
+    if (existsSync(serverPath)) {
+      process.stdout.write("\u2139 Starting Mergen server...");
+      const { spawn: spawnSrv } = await import("child_process");
+      const srv = spawnSrv("node", [serverPath], {
+        stdio: "ignore",
+        detached: true,
+        env: { ...process.env, NODE_ENV: "production" }
+      });
+      srv.unref();
+      for (let attempt = 0; attempt < 16 && !serverFound; attempt++) {
+        await sleep(500);
+        for (let p = 3e3; p <= 3010; p++) {
+          try {
+            const r = await fetch(`http://${mergenHost}:${p}/health`, { signal: AbortSignal.timeout(300) });
+            if (r.ok) {
+              serverPort = p;
+              serverFound = true;
+              break;
+            }
+          } catch {
+          }
+        }
+      }
+      console.log(serverFound ? ` \u2713  :${serverPort}` : " \u2717 (proceeding without server)");
+    } else {
+      log("Server not found \u2014 run: mergen-server setup", "\u26A0");
+    }
+  }
+  const ingestUrl = `http://${mergenHost}:${serverPort}/ingest`;
+  log(`Watching: ${[command, ...cmdArgs].join(" ")}`);
+  log(`Streaming to Mergen on ${mergenHost}:${serverPort} as process "${processName}"
+`);
+  const { spawn: spawnChild } = await import("child_process");
+  const child = spawnChild(command, cmdArgs, {
+    stdio: ["inherit", "pipe", "pipe"],
+    env: process.env,
+    shell: process.platform === "win32"
+  });
+  let lineCount = 0;
+  let windowStart = Date.now();
+  let analysisTimer = null;
+  let firstInsightShown = false;
+  function scheduleInlineAnalysis() {
+    if (analysisTimer) clearTimeout(analysisTimer);
+    analysisTimer = setTimeout(async () => {
+      analysisTimer = null;
+      try {
+        const r = await fetch(`http://${mergenHost}:${serverPort}/health`, { signal: AbortSignal.timeout(3e3) });
+        if (!r.ok) return;
+        const h = await r.json();
+        const sigs = h.signals ?? [];
+        if (sigs.length === 0) return;
+        const top = sigs[0];
+        const pct = Math.round(top.confidence * 100);
+        const div = "\u2500".repeat(58);
+        process.stdout.write(`
+${div}
+`);
+        process.stdout.write(`\u2B21 Mergen  ${top.message}  [${pct}%]
+`);
+        process.stdout.write(`  \u2192 ${top.action}
+`);
+        if (!firstInsightShown) {
+          firstInsightShown = true;
+          process.stdout.write(`  \u2726 First insight. Run reconstruct_context in your AI IDE for root cause + fix.
+`);
+          process.stdout.write(`    Or: mergen-server explain < your-error.log
+`);
+        }
+        process.stdout.write(`${div}
+
+`);
+      } catch {
+      }
+    }, 2e3);
+  }
+  const ERROR_LINE_RE = /\berror\b|exception|fatal|panic|segfault|ETIMEDOUT|ECONNREFUSED|ENOSPC|unhandled/i;
+  function postLine(data, isErr) {
+    const now = Date.now();
+    if (now - windowStart > 1e3) {
+      lineCount = 0;
+      windowStart = now;
+    }
+    if (lineCount >= 30) return;
+    lineCount++;
+    if (ERROR_LINE_RE.test(data)) scheduleInlineAnalysis();
+    const payload = JSON.stringify({
+      type: "terminal",
+      terminalName: processName,
+      data: (isErr ? "[stderr] " : "") + data.slice(0, 2e3),
+      timestamp: Date.now()
+    });
+    try {
+      const url = new URL(ingestUrl);
+      const req = require("http").request({
+        hostname: url.hostname,
+        port: parseInt(url.port || "3000"),
+        path: url.pathname,
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) }
+      });
+      req.on("error", () => {
+      });
+      req.write(payload);
+      req.end();
+    } catch {
+    }
+  }
+  function pipeProcStream(stream, isErr, out) {
+    let buf = "";
+    stream.on("data", (chunk) => {
+      const text = chunk.toString("utf8");
+      out.write(text);
+      buf += text;
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const l of lines) if (l.trim()) postLine(l, isErr);
+    });
+  }
+  pipeProcStream(child.stdout, false, process.stdout);
+  pipeProcStream(child.stderr, true, process.stderr);
+  child.on("error", (err) => {
+    error(`Failed to start: ${err.message}`);
+    process.exit(1);
+  });
+  child.on("close", (code, signal) => {
+    const reason = code === 137 ? "oom" : signal ? "signal" : code !== 0 ? "crash" : "normal";
+    const payload = JSON.stringify({
+      type: "process_exit",
+      process: processName,
+      exitCode: code ?? -1,
+      reason,
+      signal: signal ?? void 0,
+      timestamp: Date.now()
+    });
+    try {
+      const url = new URL(ingestUrl);
+      const req = require("http").request({
+        hostname: url.hostname,
+        port: parseInt(url.port || "3000"),
+        path: url.pathname,
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) }
+      });
+      req.on("error", () => {
+      });
+      req.write(payload);
+      req.end();
+    } catch {
+    }
+    process.exit(code ?? 0);
+  });
+  process.on("SIGINT", () => {
+    child.kill("SIGINT");
+  });
+  process.on("SIGTERM", () => {
+    child.kill("SIGTERM");
+  });
+}
+async function explainCommand(args) {
+  const filePath = args[0] && args[0] !== "-" ? args[0] : null;
+  let text = "";
+  if (filePath) {
+    if (!existsSync(filePath)) {
+      error(`File not found: ${filePath}`);
+      process.exit(1);
+    }
+    text = readFileSync(filePath, "utf8");
+  } else {
+    if (process.stdin.isTTY) {
+      error("No input. Usage:");
+      console.log("  cat error.log | mergen-server explain");
+      console.log("  mergen-server explain error.log");
+      process.exit(1);
+    }
+    const chunks = [];
+    process.stdin.resume();
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    text = Buffer.concat(chunks).toString("utf8");
+  }
+  const rawLines = text.split("\n").filter((l) => l.trim());
+  if (rawLines.length === 0) {
+    error("Empty input.");
+    process.exit(1);
+  }
+  const now = Date.now();
+  const logs = rawLines.map((line, i) => ({
+    type: "console",
+    level: /\berror\b|exception|fatal|panic|traceback|segfault|ETIMEDOUT|ECONNREFUSED|ENOSPC/i.test(line) ? "error" : /\bwarn/i.test(line) ? "warn" : "log",
+    args: [line],
+    url: filePath ?? "stdin",
+    timestamp: now - (rawLines.length - i) * 500
+  }));
+  const errorCount = logs.filter((l) => l.level === "error").length;
+  if (errorCount === 0) {
+    log(`${rawLines.length} lines read \u2014 no error-level patterns detected.`);
+    log("Lines matching: error, exception, fatal, panic, ETIMEDOUT, ECONNREFUSED are classified as errors.");
+    process.exit(0);
+  }
+  process.stdout.write(`Analyzing ${rawLines.length} lines (${errorCount} error(s))...`);
+  try {
+    const { buildCausalChain } = await import("../intelligence/causal.js");
+    const causal = await buildCausalChain(logs, [], [], void 0, [], [], [], []);
+    console.log(" \u2713\n");
+    if (causal.hypotheses.length === 0) {
+      log("No hypothesis matched \u2014 patterns did not align with known failure modes.");
+      log("For richer analysis with network context: mergen-server watch <your-command>");
+      process.exit(0);
+    }
+    const top = causal.hypotheses[0];
+    const pct = Math.round((top.confidenceScore ?? 0) * 100);
+    hr();
+    console.log(`Root cause  ${top.confidence} [${pct}%]
+`);
+    console.log(`  ${top.summary}
+`);
+    if (top.causalPath?.length) {
+      console.log("Causal chain:");
+      top.causalPath.forEach((step, i) => console.log(`  ${i + 1}. ${step}`));
+      console.log("");
+    }
+    if (top.fixHint) {
+      console.log(`Fix:  ${top.fixHint.split(".")[0]}.
+`);
+    }
+    hr();
+    if (causal.hypotheses.length > 1) {
+      log(`${causal.hypotheses.length - 1} alternative hypothesis(es) considered.`, "\u2139");
+    }
+    log("For real-time analysis with network context: mergen-server watch <your-command>", "\u2139");
+  } catch (err) {
+    console.log(" \u2717");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+async function statusCommand() {
+  let port = 0;
+  let health = null;
+  for (let p = 3e3; p <= 3010; p++) {
+    try {
+      const r = await fetch(`http://127.0.0.1:${p}/health`, { signal: AbortSignal.timeout(800) });
+      if (r.ok) {
+        health = await r.json();
+        port = p;
+        break;
+      }
+    } catch {
+    }
+  }
+  console.log("\u2B21 Mergen Status\n");
+  hr();
+  if (!health) {
+    error("Server not running  (tried :3000\u2013:3010)");
+    console.log("\n  Start it:  mergen-server start");
+    console.log("  Diagnose:  mergen-server doctor");
+    process.exit(1);
+  }
+  const buffered = health.buffered ?? 0;
+  const maxBuffer = health.maxBuffer ?? 2e3;
+  const errors = health.errors ?? 0;
+  const warns = health.warnings ?? 0;
+  const netErrors = health.networkErrors ?? 0;
+  const lastAt = health.lastEventAt ?? null;
+  const mcpAt = health.lastMcpCallAt ?? null;
+  const version = health.version ?? "?";
+  const signals = health.signals ?? [];
+  const bufPct = maxBuffer > 0 ? Math.round(buffered / maxBuffer * 100) : 0;
+  const lastStr = lastAt ? `${Math.round((Date.now() - lastAt) / 1e3)}s ago` : "none yet";
+  const mcpStr = mcpAt ? `${Math.round((Date.now() - mcpAt) / 1e3)}s ago` : "not yet";
+  const errLabel = [
+    errors > 0 ? `${errors} console` : "",
+    netErrors > 0 ? `${netErrors} network` : ""
+  ].filter(Boolean).join(", ") || "none";
+  console.log(`  Server      http://127.0.0.1:${port}  v${version}`);
+  console.log(`  Buffer      ${buffered} / ${maxBuffer}  (${bufPct}% full)`);
+  console.log(`  Errors      ${errLabel}`);
+  if (warns > 0) console.log(`  Warnings    ${warns}`);
+  console.log(`  Last event  ${lastStr}`);
+  console.log(`  MCP         ${mcpStr}`);
+  if (signals.length > 0) {
+    console.log(`
+  Signals (${signals.length} active):`);
+    for (const s of signals.slice(0, 3)) {
+      console.log(`    [${Math.round(s.confidence * 100)}%] ${s.message}`);
+    }
+  }
+  hr();
+  if (!lastAt) {
+    console.log("  \u26A0 No events yet \u2014 send OpenTelemetry events to the gateway to start");
+    console.log("    Or for Node apps: node --require mergen-server/sdk/node your-app.js");
+  } else if (errors === 0 && netErrors === 0) {
+    success(`Healthy \u2014 server running, events flowing`);
+  } else {
+    console.log(`  \u26A0 ${errors + netErrors} error(s) in buffer`);
+    console.log('    Ask your AI: "quick_check"');
+  }
+}
+async function resolvedCommand(args) {
+  const summaryIdx = args.indexOf("--summary");
+  const summary = summaryIdx !== -1 ? args[summaryIdx + 1] : void 0;
+  const prUrl = args.find((a) => a.startsWith("--pr="))?.slice(5);
+  if (!summary && !prUrl) {
+    error('Usage: mergen-server resolved --summary "rolled back enable-bulk-capture flag"');
+    error('       mergen-server resolved --pr=https://github.com/... --summary "hotfix"');
+    process.exit(1);
+  }
+  let port = 3e3;
+  for (let p = 3e3; p <= 3010; p++) {
+    try {
+      const r = await fetch(`http://127.0.0.1:${p}/health`, { signal: AbortSignal.timeout(600) });
+      if (r.ok) {
+        port = p;
+        break;
+      }
+    } catch {
+    }
+  }
+  const body = { resolvedAt: String(Date.now()) };
+  if (summary) body.fixSummary = summary;
+  if (prUrl) body.fixPrUrl = prUrl;
+  try {
+    const r = await fetch(`http://127.0.0.1:${port}/incidents/resolve-active`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!r.ok) {
+      error(`Server returned ${r.status}`);
+      process.exit(1);
+    }
+    const data = await r.json();
+    success("Incident marked resolved. MTTR recorded.");
+    if (summary) log(`Summary: ${summary}`);
+    if (!prUrl && data.attributionSha && data.attributionConfidence !== void 0) {
+      const pct = Math.round(data.attributionConfidence * 100);
+      const sha8 = data.attributionSha.slice(0, 8);
+      console.log("");
+      console.log(`\u2B21 Mergen attributed this incident to deploy \`${sha8}\` (${pct}% confidence).`);
+      const answer = await ask("  Was that correct? [y/n/skip]: ");
+      const lower = answer.toLowerCase();
+      if (lower === "y" || lower === "yes" || lower === "n" || lower === "no") {
+        const attributionCorrect = lower === "y" || lower === "yes";
+        try {
+          await fetch(`http://127.0.0.1:${port}/incidents/resolve-active/attribution-feedback`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ id: data.id, attributionCorrect }),
+            signal: AbortSignal.timeout(3e3)
+          });
+          success(`Attribution feedback recorded: ${attributionCorrect ? "correct" : "incorrect"}`);
+          if (!attributionCorrect) {
+            log("Feedback stored. Attribution weights will improve as more incidents are validated.");
+          }
+        } catch {
+        }
+      } else {
+        log("Attribution feedback skipped.");
+      }
+    }
+  } catch {
+    error("Server not running or unreachable. Start with: mergen-server start");
+    process.exit(1);
+  }
+}
+async function replayCommand(args) {
+  const dir = args[0];
+  if (!dir) {
+    error("Usage: mergen-server replay <directory>");
+    console.log("\nRun historical incidents through the causal pipeline and score accuracy.");
+    console.log("\nIncident file format (any .json file in the directory):");
+    console.log("  {");
+    console.log('    "name":         "db-pool-exhaustion-2024-01-15",');
+    console.log('    "expected_tag": "infra_db_connection_pool",');
+    console.log('    "log_lines":    ["ERROR: Too many connections to postgres:5432"]');
+    console.log("  }");
+    process.exit(1);
+  }
+  const { readdirSync, readFileSync: readFileSync2, existsSync: existsSync2, statSync } = await import("fs");
+  const { basename } = await import("path");
+  const dirPath = resolve(dir);
+  if (!existsSync2(dirPath) || !statSync(dirPath).isDirectory()) {
+    error(`Not a directory: ${dirPath}`);
+    process.exit(1);
+  }
+  const files = readdirSync(dirPath).filter((f) => f.endsWith(".json")).sort();
+  if (files.length === 0) {
+    error(`No .json incident files found in ${dirPath}`);
+    console.log("\nCreate an incident file like this:");
+    console.log('  { "name": "my-incident", "expected_tag": "infra_db_connection_pool",');
+    console.log('    "log_lines": ["ERROR: Too many connections"] }');
+    process.exit(1);
+  }
+  const { buildCausalChain } = await import("../intelligence/causal.js");
+  console.log(`
+Mergen Production Replay \u2014 ${files.length} incident${files.length !== 1 ? "s" : ""}
+`);
+  const rows = [];
+  let passed = 0, failed = 0, unscored = 0;
+  for (const file of files) {
+    const filePath = join(dirPath, file);
+    let incident;
+    try {
+      incident = JSON.parse(readFileSync2(filePath, "utf8"));
+    } catch {
+      rows.push({ name: file, status: "ERR", actual_tag: null, expected_tag: null, confidence: null, fix_hint: null, err_msg: "invalid JSON" });
+      continue;
+    }
+    const name = typeof incident.name === "string" ? incident.name : basename(file, ".json");
+    const expectedTag = typeof incident.expected_tag === "string" ? incident.expected_tag : null;
+    const firedAt = typeof incident.firedAt === "number" ? incident.firedAt : Date.now();
+    let logs = Array.isArray(incident.logs) ? incident.logs : [];
+    if (Array.isArray(incident.log_lines)) {
+      const lineEvents = incident.log_lines.map((line, i) => ({
+        level: /error|fatal|critical/i.test(line) ? "error" : /warn/i.test(line) ? "warn" : "log",
+        args: [line],
+        timestamp: firedAt - (incident.log_lines.length - i) * 1e3,
+        url: "replay"
+      }));
+      logs = [...logs, ...lineEvents];
+    }
+    const network = Array.isArray(incident.network) ? incident.network : [];
+    const infraEvents = Array.isArray(incident.infra_events) ? incident.infra_events : [];
+    try {
+      const causal = await buildCausalChain(logs, network, [], firedAt, [], [], [], [], infraEvents);
+      const top = causal.hypotheses[0] ?? null;
+      const actual = top?.tag ?? null;
+      const conf = top?.confidenceScore ?? null;
+      const hint = top?.fixHint ?? null;
+      if (!expectedTag) {
+        unscored++;
+        rows.push({ name, status: "INFO", actual_tag: actual, expected_tag: null, confidence: conf, fix_hint: hint });
+      } else if (actual === expectedTag) {
+        passed++;
+        rows.push({ name, status: "PASS", actual_tag: actual, expected_tag: expectedTag, confidence: conf, fix_hint: hint });
+      } else {
+        failed++;
+        rows.push({ name, status: "FAIL", actual_tag: actual, expected_tag: expectedTag, confidence: conf, fix_hint: hint });
+      }
+    } catch (e) {
+      rows.push({ name, status: "ERR", actual_tag: null, expected_tag: expectedTag, confidence: null, fix_hint: null, err_msg: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  const nameW = Math.min(Math.max(...rows.map((r) => r.name.length), 20), 40);
+  for (const r of rows) {
+    const icon = r.status === "PASS" ? "\u2713" : r.status === "FAIL" ? "\u2717" : r.status === "ERR" ? "!" : "\u25CB";
+    const label = r.name.slice(0, nameW).padEnd(nameW);
+    const pct = r.confidence !== null ? `  ${Math.round(r.confidence * 100)}%` : "";
+    const pad = " ".repeat(nameW + 10);
+    if (r.status === "PASS") {
+      console.log(`  ${icon} PASS  ${label}  ${r.actual_tag}${pct}`);
+    } else if (r.status === "FAIL") {
+      console.log(`  ${icon} FAIL  ${label}  expected: ${r.expected_tag}`);
+      console.log(`  ${pad}  got:      ${r.actual_tag ?? "(no diagnosis)"}${pct}`);
+      if (r.fix_hint) console.log(`  ${pad}  hint:     ${r.fix_hint.slice(0, 80)}`);
+    } else if (r.status === "INFO") {
+      console.log(`  ${icon} INFO  ${label}  ${r.actual_tag ?? "(no diagnosis)"}${pct}`);
+    } else {
+      console.log(`  ${icon} ERR   ${label}  ${r.err_msg}`);
+    }
+  }
+  const scored = passed + failed;
+  const accuracyPct = scored > 0 ? Math.round(passed / scored * 100) : null;
+  const hr2 = "\u2500".repeat(60);
+  console.log(`
+${hr2}`);
+  if (scored > 0) {
+    const marker = accuracyPct !== null && accuracyPct >= 90 ? "\u2713" : accuracyPct !== null && accuracyPct >= 70 ? "~" : "\u2717";
+    const unscoredNote = unscored > 0 ? `  |  ${unscored} unscored` : "";
+    console.log(`${marker} Accuracy: ${passed}/${scored} scored (${accuracyPct}%)${unscoredNote}`);
+  } else {
+    console.log(`\u25CB ${unscored} incident${unscored !== 1 ? "s" : ""} \u2014 add "expected_tag" fields to score accuracy`);
+  }
+  if (accuracyPct !== null && accuracyPct < 90 && failed > 0) {
+    console.log("\n  To improve: share failing incidents via mergen-server feedback <id>");
+  }
+  console.log("");
+  process.exit(failed > 0 ? 1 : 0);
+}
+export {
+  explainCommand,
+  postmortemCommand,
+  replayCommand,
+  resolvedCommand,
+  statusCommand,
+  timelineCommand,
+  watchCommand
+};