mergen-server 1.4.0

package/dist/intelligence/cascade-detector.js

@@ -0,0 +1,58 @@
+import { incidentStore } from "../sensor/incident-store.js";
+import { serviceGraph } from "../sensor/service-graph.js";
+import logger from "../sensor/logger.js";
+const CASCADE_WINDOW_MS = 2 * 60 * 1e3;
+function detectCascade(newService, newPid) {
+  const now = Date.now();
+  const cutoff = now - CASCADE_WINDOW_MS;
+  const openIncidents = incidentStore.list("open", 200).filter(
+    (inc) => inc.createdAt >= cutoff && inc.pid !== newPid
+  );
+  if (openIncidents.length === 0) {
+    return {
+      isCascade: false,
+      rootService: newService,
+      affectedServices: [newService],
+      rootPid: null,
+      summary: ""
+    };
+  }
+  const affectedServices = [
+    .../* @__PURE__ */ new Set([newService, ...openIncidents.map((inc) => inc.service ?? "unknown")])
+  ];
+  if (affectedServices.length < 2) {
+    return {
+      isCascade: false,
+      rootService: newService,
+      affectedServices,
+      rootPid: null,
+      summary: ""
+    };
+  }
+  const graphData = serviceGraph.toJSON();
+  const edges = graphData.edges ?? [];
+  let bestRoot = openIncidents[0]?.service ?? newService;
+  let bestUpstreamScore = -1;
+  for (const candidate of affectedServices) {
+    const downstreamCount = edges.filter(
+      (e) => e.source === candidate && affectedServices.includes(e.target)
+    ).length;
+    if (downstreamCount > bestUpstreamScore) {
+      bestUpstreamScore = downstreamCount;
+      bestRoot = candidate;
+    }
+  }
+  const rootIncident = openIncidents.filter((inc) => inc.service === bestRoot).sort((a, b) => a.createdAt - b.createdAt)[0];
+  const rootPid = rootIncident?.pid ?? null;
+  const summary = `\u{1F30A} *Cascade detected* \u2014 ${affectedServices.length} services affected within ${CASCADE_WINDOW_MS / 6e4} minutes.
+Likely root: \`${bestRoot}\`  \xB7  Affected: ${affectedServices.map((s) => `\`${s}\``).join(", ")}
+Suppressing redundant HITL \u2014 targeting root service for fix.`;
+  logger.info(
+    { rootService: bestRoot, affectedServices, rootPid },
+    "cascade-detector: cascade detected"
+  );
+  return { isCascade: true, rootService: bestRoot, affectedServices, rootPid, summary };
+}
+export {
+  detectCascade
+};

package/dist/intelligence/case-study-generator.js

@@ -0,0 +1,126 @@
+import { createHash } from "crypto";
+import { isNonBlockingBlunderType } from "../sensor/agent-blunder-store.js";
+function anonService(name) {
+  if (!name) return "svc-unknown";
+  const hash = createHash("sha256").update(name).digest("hex").slice(0, 6);
+  return `svc-${hash}`;
+}
+function relativeTime(ts) {
+  const diffMs = Date.now() - ts;
+  const diffMins = Math.floor(diffMs / 6e4);
+  const diffHrs = Math.floor(diffMs / 36e5);
+  const diffDays = Math.floor(diffMs / 864e5);
+  if (diffMins < 60) return `${diffMins} minute${diffMins !== 1 ? "s" : ""} ago`;
+  if (diffHrs < 24) return `${diffHrs} hour${diffHrs !== 1 ? "s" : ""} ago`;
+  if (diffDays < 60) return `${diffDays} day${diffDays !== 1 ? "s" : ""} ago`;
+  return `${Math.floor(diffDays / 30)} month${Math.floor(diffDays / 30) !== 1 ? "s" : ""} ago`;
+}
+const CREDENTIAL_PATTERNS = [
+  /[A-Za-z0-9+/]{32,}={0,2}/,
+  // base64-ish
+  /(?:AKIA|ASIA)[A-Z0-9]{16}/,
+  // AWS access key
+  /(?:password|secret|token|key)\s*[:=]\s*\S+/i,
+  /Bearer\s+[A-Za-z0-9._-]+/i
+];
+function sanitizeCommand(cmd) {
+  if (!cmd) return null;
+  if (CREDENTIAL_PATTERNS.some((re) => re.test(cmd))) {
+    return "[command redacted \u2014 contained potential credential]";
+  }
+  return cmd.replace(/(?:\/[\w.-]+){3,}/g, (match) => {
+    const parts = match.split("/").filter(Boolean);
+    return "/" + parts.slice(0, 2).join("/") + "/\u2026";
+  });
+}
+const BLUNDER_TYPE_LABELS = {
+  allowlist_block: "allowlist policy",
+  injection_attempt: "prompt injection detection",
+  rbac_block: "RBAC role check",
+  override_corpus_block: "override corpus (prior human decision)",
+  pipeline_block: "governance pipeline",
+  planning_gate_block: "planning gate (blast-radius / confidence check)",
+  credential_issued: "ephemeral credential broker",
+  policy_integrity_failure: "policy file integrity check (signature/schema fallback)"
+};
+const ALTERNATIVES = {
+  allowlist_block: "verify the action is on the approved allowlist, or submit an override request",
+  injection_attempt: "rephrase the request without instruction-injection patterns",
+  rbac_block: "request elevated permissions through the access-control workflow",
+  override_corpus_block: "review the prior override decision and open a HITL approval if the context has changed",
+  pipeline_block: "reduce the blast radius of the action or increase diagnostic confidence before retrying",
+  planning_gate_block: "narrow the action scope and resubmit once confidence exceeds the configured threshold",
+  credential_issued: "not applicable \u2014 this is a successful issuance record, not a blocked action",
+  policy_integrity_failure: "restore a validly signed/schema-conformant enterprise-policy.json \u2014 Mergen fell back to the default policy"
+};
+function buildNarrative(anonSvc, cmd, blunderType, blockReason) {
+  const cmdPhrase = cmd ? `attempted \`${cmd}\`` : "attempted an unrecorded action";
+  const policyLabel = BLUNDER_TYPE_LABELS[blunderType] ?? blunderType;
+  const alt = ALTERNATIVES[blunderType] ?? "reformulate the request within policy bounds";
+  return `An AI agent targeting ${anonSvc} ${cmdPhrase}. Mergen intercepted the call at the ${policyLabel} layer in <1ms \u2014 the agent received a structured error explaining why the action was blocked (${blockReason.slice(0, 120)}${blockReason.length > 120 ? "\u2026" : ""}) and was guided to ${alt}.`;
+}
+function generateCaseStudies(blunders) {
+  const seen = /* @__PURE__ */ new Set();
+  const cases = [];
+  let seq = 1;
+  const sorted = blunders.filter((b) => !isNonBlockingBlunderType(b.blunderType)).sort((a, b) => b.recordedAt - a.recordedAt);
+  for (const b of sorted) {
+    const anonSvc = anonService(b.service);
+    const cmd = sanitizeCommand(b.command);
+    const dedupeKey = `${b.blunderType}|${cmd ?? ""}|${anonSvc}`;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    const caseId = `case-${String(seq++).padStart(3, "0")}`;
+    const narrative = buildNarrative(anonSvc, cmd, b.blunderType, b.blockReason);
+    cases.push({
+      caseId,
+      recordedRelative: relativeTime(b.recordedAt),
+      blunderType: b.blunderType,
+      anonymizedService: anonSvc,
+      anonymizedCommand: cmd,
+      narrative,
+      policyTriggered: BLUNDER_TYPE_LABELS[b.blunderType] ?? b.blunderType,
+      alternativeSuggested: ALTERNATIVES[b.blunderType] ?? "reformulate within policy bounds"
+    });
+  }
+  return cases;
+}
+function buildReport(blunders) {
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalBlocks: blunders.filter((b) => !isNonBlockingBlunderType(b.blunderType)).length,
+    cases: generateCaseStudies(blunders)
+  };
+}
+function renderMarkdown(report) {
+  const lines = [
+    "# Mergen \u2014 Agent Action Case Studies",
+    "",
+    `> Generated ${report.generatedAt}  `,
+    `> ${report.totalBlocks} total agent actions blocked \xB7 ${report.cases.length} unique patterns shown`,
+    ""
+  ];
+  for (const c of report.cases) {
+    lines.push(`## ${c.caseId} \u2014 ${c.blunderType.replace(/_/g, " ")}`);
+    lines.push("");
+    lines.push(`**Recorded:** ${c.recordedRelative}  `);
+    lines.push(`**Service:** \`${c.anonymizedService}\`  `);
+    if (c.anonymizedCommand) {
+      lines.push(`**Command attempted:** \`${c.anonymizedCommand}\`  `);
+    }
+    lines.push(`**Policy triggered:** ${c.policyTriggered}  `);
+    lines.push("");
+    lines.push(c.narrative);
+    lines.push("");
+    lines.push(`**Agent was guided to:** ${c.alternativeSuggested}`);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+export {
+  buildReport,
+  generateCaseStudies,
+  renderMarkdown
+};

package/dist/intelligence/causal-graph.js

@@ -0,0 +1,126 @@
+import { createHash } from "crypto";
+function stableId(kind, ts, label) {
+  const h = createHash("sha256").update(`${kind}:${ts}:${label}`).digest("hex").slice(0, 8);
+  return `${kind}:${ts}:${h}`;
+}
+function toNodeKind(kind) {
+  switch (kind) {
+    case "error":
+      return "error";
+    case "warn":
+      return "warn";
+    case "network_fail":
+      return "network_fail";
+    case "network_ok":
+      return "network_ok";
+    case "process_exit":
+      return "process_exit";
+    case "process_log":
+      return "process_log";
+    default:
+      return "state";
+  }
+}
+const NETWORK_CAUSE_TAGS = /* @__PURE__ */ new Set([
+  "auth_token_not_persisted",
+  "token_overwrite_race",
+  "failed_request_caused_crash",
+  "null_storage_key",
+  "empty_network_response"
+]);
+function buildCausalGraph(chain) {
+  const nodes = [];
+  const edges = [];
+  for (const ev of chain.chain) {
+    const kind = toNodeKind(ev.kind);
+    const id = stableId(kind, ev.ts, ev.summary);
+    const meta = {};
+    if (ev.detail) meta.detail = ev.detail;
+    if (ev.source) meta.source = ev.source;
+    if (kind === "error") {
+      const errBlock = chain.errors.find((e) => e.timestamp === ev.ts);
+      if (errBlock?.primaryFrame) meta.primaryFrame = errBlock.primaryFrame;
+      if (errBlock?.resolvedStack) meta.resolvedStack = errBlock.resolvedStack.slice(0, 600);
+    }
+    nodes.push({ id, kind, ts: ev.ts, isoTs: ev.isoTs, label: ev.summary.slice(0, 120), metadata: meta });
+  }
+  if (nodes.length === 0) {
+    return { capturedAt: chain.capturedAt, nodes, edges, rootNodes: [], terminalNodes: [], hypotheses: [] };
+  }
+  for (let i = 1; i < nodes.length; i++) {
+    edges.push({ from: nodes[i - 1].id, to: nodes[i].id, kind: "PRECEDED_BY", confidence: 1 });
+  }
+  const errorNodes = nodes.filter((n) => n.kind === "error");
+  const networkFailNodes = nodes.filter((n) => n.kind === "network_fail");
+  const stateNodes = nodes.filter((n) => n.kind === "state");
+  for (const err of errorNodes) {
+    for (const net of networkFailNodes) {
+      const msBefore = err.ts - net.ts;
+      if (msBefore < 0 || msBefore > 3e4) continue;
+      edges.push({
+        from: net.id,
+        to: err.id,
+        kind: "CORRELATED_WITH",
+        confidence: parseFloat(Math.max(0.3, 1 - msBefore / 3e4).toFixed(2)),
+        metadata: { msBefore }
+      });
+    }
+  }
+  for (const netCall of chain.correlatedNetwork) {
+    if (!netCall.traceId) continue;
+    const urlSlug = netCall.url.slice(0, 70);
+    const matchNode = networkFailNodes.find((n) => n.label.includes(urlSlug));
+    if (!matchNode) continue;
+    for (const err of errorNodes) {
+      const edge = edges.find((e) => e.from === matchNode.id && e.to === err.id && e.kind === "CORRELATED_WITH");
+      if (edge) {
+        edge.kind = "TRACE_JOINED";
+        edge.confidence = 1;
+        edge.metadata = { ...edge.metadata, traceId: netCall.traceId };
+      }
+    }
+  }
+  for (const err of errorNodes) {
+    for (const state of stateNodes) {
+      if (Math.abs(err.ts - state.ts) <= 5e3) {
+        edges.push({ from: state.id, to: err.id, kind: "STATE_AT", confidence: 0.9 });
+      }
+    }
+  }
+  for (const h of chain.hypotheses) {
+    if (!NETWORK_CAUSE_TAGS.has(h.tag)) continue;
+    if (h.confidenceScore < 0.55) continue;
+    const best = edges.filter((e) => e.kind === "CORRELATED_WITH" && nodes.find((n) => n.id === e.from)?.kind === "network_fail").sort((a, b) => b.confidence - a.confidence)[0];
+    if (best) {
+      best.kind = "CAUSED_BY";
+      best.confidence = parseFloat(h.confidenceScore.toFixed(2));
+      best.metadata = { ...best.metadata, hypothesis: h.tag, fixHint: h.fixHint ?? void 0 };
+    }
+  }
+  const hasIncomingCausal = new Set(
+    edges.filter((e) => e.kind !== "PRECEDED_BY").map((e) => e.to)
+  );
+  const rootNodes = nodes.filter((n) => !hasIncomingCausal.has(n.id)).map((n) => n.id);
+  const terminalNodes = nodes.filter((n) => n.kind === "error" || n.kind === "process_exit").map((n) => n.id);
+  return {
+    capturedAt: chain.capturedAt,
+    nodes,
+    edges,
+    rootNodes,
+    terminalNodes,
+    hypotheses: chain.hypotheses.map((h) => ({
+      tag: h.tag,
+      summary: h.summary,
+      confidence: h.confidence,
+      confidenceScore: h.confidenceScore,
+      causalPath: h.causalPath,
+      fixHint: h.fixHint,
+      evidence: h.evidence,
+      pid: h.pid
+    })),
+    errorFingerprint: chain.errorFingerprint
+  };
+}
+export {
+  buildCausalGraph
+};

package/dist/intelligence/causal.js

@@ -0,0 +1 @@
+export * from '../__stubs__/causal.js';

package/dist/intelligence/change-risk.js

@@ -0,0 +1,102 @@
+import path from "path";
+import { buildGraph, getZone } from "./arch-graph.js";
+const CRITICAL_ENTRY_POINTS = /* @__PURE__ */ new Set(["app.ts", "index.ts", "cli.ts"]);
+function scoreChangeRisk(filesModified, srcDir) {
+  const graph = buildGraph(srcDir);
+  const factors = [];
+  let score = 0;
+  const fileCount = filesModified.length;
+  const fileDelta = fileCount * 8;
+  score += fileDelta;
+  factors.push({ label: "Files modified", delta: fileDelta, detail: `${fileCount} file(s) \xD7 8` });
+  const zones = /* @__PURE__ */ new Set();
+  for (const f of filesModified) zones.add(getZone(f));
+  zones.delete("other");
+  const subsystems = [...zones];
+  if (subsystems.length > 1) {
+    const delta = (subsystems.length - 1) * 15;
+    score += delta;
+    factors.push({ label: "Cross-subsystem change", delta, detail: `${subsystems.length} subsystems: ${subsystems.join(", ")}` });
+  }
+  const publicApiFiles = filesModified.filter((f) => getZone(f) === "routes");
+  if (publicApiFiles.length > 0) {
+    const delta = publicApiFiles.length * 20;
+    score += delta;
+    factors.push({ label: "Public API changes", delta, detail: `${publicApiFiles.length} route file(s)` });
+  }
+  const criticalEntryPoints = filesModified.filter((f) => CRITICAL_ENTRY_POINTS.has(path.basename(f)));
+  if (criticalEntryPoints.length > 0) {
+    const delta = criticalEntryPoints.length * 25;
+    score += delta;
+    factors.push({ label: "Critical entry points", delta, detail: criticalEntryPoints.map((f) => path.basename(f)).join(", ") });
+  }
+  const affectedTestFiles = /* @__PURE__ */ new Set();
+  for (const f of filesModified) {
+    const dependents = graph.reverse.get(f) ?? /* @__PURE__ */ new Set();
+    for (const dep of dependents) {
+      if (dep.endsWith(".test.ts")) affectedTestFiles.add(dep);
+    }
+  }
+  const testCount = affectedTestFiles.size;
+  if (testCount > 0) {
+    const delta = testCount * 5;
+    score += delta;
+    factors.push({ label: "Tests affected", delta, detail: `${testCount} test file(s) will need verification` });
+  }
+  const untestedFiles = filesModified.filter((f) => {
+    if (f.endsWith(".test.ts") || f.endsWith(".d.ts")) return false;
+    const importers = graph.reverse.get(f) ?? /* @__PURE__ */ new Set();
+    return ![...importers].some((imp) => imp.endsWith(".test.ts"));
+  });
+  if (untestedFiles.length > 0) {
+    const delta = untestedFiles.length * 10;
+    score += delta;
+    factors.push({ label: "Untested files", delta, detail: `${untestedFiles.length} file(s) have no test coverage` });
+  }
+  const clampedScore = Math.min(100, score);
+  const level = clampedScore >= 70 ? "HIGH" : clampedScore >= 40 ? "MEDIUM" : "LOW";
+  const requiresApproval = clampedScore >= 70;
+  const recommendation = requiresApproval ? "HIGH RISK: Get explicit human sign-off before proceeding. File a confidence report and rollback plan first." : level === "MEDIUM" ? "MEDIUM RISK: File a confidence report (report_confidence) and rollback plan (plan_rollback) before proceeding." : "LOW RISK: Proceed. File a confidence report if confidence < 0.8.";
+  return {
+    score: clampedScore,
+    level,
+    requiresApproval,
+    files: fileCount,
+    subsystems,
+    publicApiFiles,
+    criticalEntryPoints,
+    testsAffected: testCount,
+    untestedFiles,
+    factors,
+    recommendation
+  };
+}
+function formatRiskReport(r) {
+  const badge = r.level === "HIGH" ? "\u{1F534} HIGH" : r.level === "MEDIUM" ? "\u{1F7E1} MEDIUM" : "\u{1F7E2} LOW";
+  const lines = [
+    `## Change Risk Score: ${r.score}/100 \u2014 ${badge}`,
+    "",
+    r.requiresApproval ? "> \u26D4 **Human approval required** before making these changes." : r.level === "MEDIUM" ? "> \u26A0 **Review recommended.** File confidence report and rollback plan first." : "> \u2705 Safe to proceed.",
+    "",
+    `**Files:** ${r.files}  |  **Subsystems:** ${r.subsystems.join(", ") || "none"}  |  **Tests affected:** ${r.testsAffected}`,
+    "",
+    "### Risk factors",
+    ""
+  ];
+  for (const f of r.factors) {
+    lines.push(`| +${f.delta} | **${f.label}** | ${f.detail} |`);
+  }
+  if (r.factors.length === 0) lines.push("*No significant risk factors.*");
+  lines.push("");
+  if (r.untestedFiles.length > 0) {
+    lines.push("### Untested files (add coverage before proceeding)", "");
+    for (const f of r.untestedFiles) lines.push(`  - \`${path.basename(f)}\``);
+    lines.push("");
+  }
+  lines.push(`**Recommendation:** ${r.recommendation}`);
+  return lines.join("\n");
+}
+export {
+  formatRiskReport,
+  scoreChangeRisk
+};

package/dist/intelligence/compliance-report.js

@@ -0,0 +1,134 @@
+import fs from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { loadEnterprisePolicy, IMMUTABLE_RULE_IDS } from "./enterprise-policy-engine.js";
+import { listMembers } from "../sensor/rbac.js";
+import { zeroRetentionMode } from "../sensor/paths.js";
+import { fetchBlunderEntries, fetchHttpAuditEntries, fetchChainVerification } from "../sensor/audit-fetch.js";
+async function buildComplianceReport(from, to) {
+  const [blunders, httpEntries, chainVerification] = await Promise.all([
+    fetchBlunderEntries(from, to),
+    fetchHttpAuditEntries(from, to),
+    fetchChainVerification()
+  ]);
+  const policy = loadEnterprisePolicy();
+  const members = listMembers();
+  const blockedByType = {};
+  for (const b of blunders) {
+    blockedByType[b.blunderType] = (blockedByType[b.blunderType] ?? 0) + 1;
+  }
+  const customPiiConfigPresent = fs.existsSync(join(homedir(), ".mergen", "pii-config.json"));
+  return {
+    generatedAt: Date.now(),
+    windowFrom: from,
+    windowTo: to,
+    security: {
+      policyRulesActive: policy.rules.length,
+      immutableRulesActive: policy.rules.filter((r) => IMMUTABLE_RULE_IDS.has(r.id)).length,
+      policyEnabled: policy.enabled,
+      blockedActionsInWindow: blunders.length,
+      blockedActionsByType: blockedByType,
+      auditChain: {
+        valid: chainVerification.valid,
+        verified: chainVerification.verified ?? 0,
+        truncated: chainVerification.truncated ?? false,
+        tamperEvidenceLevel: chainVerification.tamperEvidenceLevel ?? "unknown",
+        hmacProtected: chainVerification.hmacProtected ?? false
+      },
+      rbac: {
+        totalMembers: members.length,
+        admins: members.filter((m) => m.role === "admin").length,
+        responders: members.filter((m) => m.role === "responder").length,
+        viewers: members.filter((m) => m.role === "viewer").length
+      }
+    },
+    confidentiality: {
+      zeroRetentionMode: zeroRetentionMode(),
+      // Always-on regex PII redaction (email, phone, AWS keys, PEM certs, JWTs,
+      // credit cards) — not configurable off, per this product's own design.
+      piiShieldActive: true,
+      customPiiConfigPresent
+    },
+    availability: {
+      applicable: false,
+      note: "Not applicable \u2014 Mergen runs on customer infrastructure and does not host customer production systems. Uptime/DR controls for the systems Mergen governs are the customer's own responsibility."
+    },
+    httpAuditEntryCount: httpEntries.length
+  };
+}
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderComplianceHtml(report) {
+  const fmt = (ts) => new Date(ts).toISOString();
+  const typeRows = Object.entries(report.security.blockedActionsByType).sort((a, b) => b[1] - a[1]).map(([type, count]) => `<tr><td>${esc(type)}</td><td>${count}</td></tr>`).join("");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Mergen Compliance Report</title>
+<style>
+  :root{--bg:#0f1117;--surface:#1a1d26;--border:#2a2d3a;--text:#e2e8f0;--muted:#64748b;
+    --green:#22c55e;--yellow:#f59e0b;--red:#ef4444;--blue:#3b82f6;}
+  *{box-sizing:border-box}
+  body{background:var(--bg);color:var(--text);font-family:-apple-system,ui-sans-serif,sans-serif;font-size:14px;line-height:1.6;margin:0;padding:32px;max-width:860px;margin:0 auto}
+  h1{font-size:22px;margin:0 0 4px}
+  .sub{color:var(--muted);font-size:13px;margin-bottom:28px}
+  section{background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:20px 24px;margin-bottom:20px}
+  h2{font-size:15px;margin:0 0 12px;letter-spacing:.02em}
+  table{width:100%;border-collapse:collapse;font-size:13px}
+  td{padding:6px 8px;border-bottom:1px solid var(--border)}
+  td:first-child{color:var(--muted)}
+  td:last-child{text-align:right;font-weight:600}
+  .badge{display:inline-block;padding:2px 8px;border-radius:10px;font-size:11px;font-weight:700}
+  .badge.ok{background:rgba(34,197,94,.15);color:var(--green)}
+  .badge.warn{background:rgba(245,158,11,.15);color:var(--yellow)}
+  .badge.bad{background:rgba(239,68,68,.15);color:var(--red)}
+  .na{color:var(--muted);font-style:italic}
+  footer{color:var(--muted);font-size:11px;margin-top:24px}
+  @media print{body{padding:0}}
+</style>
+</head>
+<body>
+<h1>Mergen Compliance Report</h1>
+<div class="sub">Generated ${esc(fmt(report.generatedAt))} \xB7 Window ${esc(fmt(report.windowFrom))} \u2192 ${esc(fmt(report.windowTo))}</div>
+
+<section>
+<h2>Security</h2>
+<table>
+<tr><td>Policy enabled</td><td>${report.security.policyEnabled ? '<span class="badge ok">Yes</span>' : '<span class="badge bad">No</span>'}</td></tr>
+<tr><td>Active policy rules</td><td>${report.security.policyRulesActive} (${report.security.immutableRulesActive} immutable)</td></tr>
+<tr><td>Blocked actions in window</td><td>${report.security.blockedActionsInWindow}</td></tr>
+<tr><td>Audit chain</td><td>${report.security.auditChain.valid ? '<span class="badge ok">Valid</span>' : '<span class="badge bad">INVALID</span>'}</td></tr>
+<tr><td>Tamper-evidence level</td><td>${report.security.auditChain.tamperEvidenceLevel === "hmac-sealed" ? '<span class="badge ok">hmac-sealed</span>' : report.security.auditChain.tamperEvidenceLevel === "hash-chain" ? '<span class="badge warn">hash-chain only</span>' : '<span class="badge bad">none</span>'}</td></tr>
+<tr><td>Chain truncated (ring buffer wrapped)</td><td>${report.security.auditChain.truncated ? "Yes" : "No"}</td></tr>
+<tr><td>RBAC members</td><td>${report.security.rbac.totalMembers} (${report.security.rbac.admins} admin, ${report.security.rbac.responders} responder, ${report.security.rbac.viewers} viewer)</td></tr>
+</table>
+${typeRows ? `<h2 style="margin-top:20px">Blocked actions by type</h2><table>${typeRows}</table>` : ""}
+</section>
+
+<section>
+<h2>Confidentiality</h2>
+<table>
+<tr><td>Zero-retention mode</td><td>${report.confidentiality.zeroRetentionMode ? '<span class="badge ok">Enabled</span>' : "Disabled"}</td></tr>
+<tr><td>PII shield (always-on)</td><td><span class="badge ok">Active</span></td></tr>
+<tr><td>Custom PII patterns configured</td><td>${report.confidentiality.customPiiConfigPresent ? "Yes" : "No (default patterns only)"}</td></tr>
+</table>
+</section>
+
+<section>
+<h2>Availability</h2>
+<p class="na">${esc(report.availability.note)}</p>
+</section>
+
+<footer>
+Control-to-criteria mapping: docs/enterprise-security.md. Raw tamper-evident audit data: GET /audit/export?format=soc2.
+Print this page to PDF for distribution \u2014 no server-side PDF generation is used.
+</footer>
+</body>
+</html>`;
+}
+export {
+  buildComplianceReport,
+  renderComplianceHtml
+};

package/dist/intelligence/confidence-report.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+const ConfidenceReportSchema = z.object({
+  /** Unique ID assigned on creation. */
+  id: z.string().optional(),
+  /** 0.0 (no confidence) to 1.0 (fully certain). */
+  confidence: z.number().min(0).max(1),
+  /** What this report covers — e.g. "Add Stripe webhook handler" */
+  scope: z.string().min(1).max(300),
+  /** Things the agent is treating as true without verifying. */
+  assumptions: z.array(z.string().max(500)).default([]),
+  /** Open questions that could affect correctness. */
+  unknowns: z.array(z.string().max(500)).default([]),
+  /** Source files this change will touch. */
+  filesModified: z.array(z.string().max(500)).default([]),
+  /** Human-readable explanation for the confidence score. */
+  rationale: z.string().max(1e3).default("")
+});
+function confidenceLabel(score) {
+  if (score >= 0.9) return "HIGH";
+  if (score >= 0.75) return "MEDIUM-HIGH";
+  if (score >= 0.6) return "MEDIUM";
+  if (score >= 0.4) return "LOW-MEDIUM";
+  return "LOW";
+}
+class ConfidenceStore {
+  MAX = 100;
+  reports = [];
+  counter = 0;
+  add(input) {
+    this.counter += 1;
+    const report = {
+      ...input,
+      id: `CR-${String(this.counter).padStart(4, "0")}`,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.reports.push(report);
+    if (this.reports.length > this.MAX) this.reports.shift();
+    return report;
+  }
+  list(limit = 20) {
+    return this.reports.slice(-limit).reverse();
+  }
+  get(id) {
+    return this.reports.find((r) => r.id === id);
+  }
+}
+const confidenceStore = new ConfidenceStore();
+function formatConfidenceReport(r) {
+  const label = confidenceLabel(r.confidence);
+  const pct = Math.round(r.confidence * 100);
+  const lines = [
+    `## Confidence Report ${r.id}`,
+    "",
+    `**Scope:** ${r.scope}`,
+    `**Confidence:** ${pct}% (${label})  |  **Filed:** ${r.createdAt}`,
+    ""
+  ];
+  if (r.rationale) {
+    lines.push(`**Rationale:** ${r.rationale}`, "");
+  }
+  if (r.assumptions.length > 0) {
+    lines.push("**Assumptions:**");
+    for (const a of r.assumptions) lines.push(`  - ${a}`);
+    lines.push("");
+  }
+  if (r.unknowns.length > 0) {
+    lines.push("**Unknowns:**");
+    for (const u of r.unknowns) lines.push(`  - ${u}`);
+    lines.push("");
+  }
+  if (r.filesModified.length > 0) {
+    lines.push("**Files to modify:**");
+    for (const f of r.filesModified) lines.push(`  - \`${f}\``);
+    lines.push("");
+  }
+  if (r.confidence < 0.6) {
+    lines.push("> \u26A0 **Low confidence** \u2014 resolve unknowns before proceeding or halt and present an impact report.");
+  }
+  return lines.join("\n");
+}
+export {
+  ConfidenceReportSchema,
+  confidenceStore,
+  formatConfidenceReport
+};