mergen-server 1.4.0

package/dist/intelligence/session-threat-tracker.js

@@ -0,0 +1,231 @@
+import logger from "../sensor/logger.js";
+const SESSION_RING_SIZE = 20;
+const SESSION_EXPIRY_MS = 30 * 60 * 1e3;
+const _sessions = /* @__PURE__ */ new Map();
+function _getOrCreate(sessionId) {
+  let s = _sessions.get(sessionId);
+  if (!s) {
+    s = { calls: [], contaminatedCallsRemaining: 0, contaminationSource: "", lastActivity: Date.now() };
+    _sessions.set(sessionId, s);
+    void _hydrateContamination(sessionId);
+  }
+  s.lastActivity = Date.now();
+  return s;
+}
+const _pruneHandle = setInterval(() => {
+  const cutoff = Date.now() - SESSION_EXPIRY_MS;
+  for (const [id, s] of _sessions) {
+    if (s.lastActivity < cutoff) _sessions.delete(id);
+  }
+}, 60 * 60 * 1e3);
+_pruneHandle.unref();
+const THREAT_SEQUENCES = [
+  {
+    steps: [/env|printenv|cat\s+\.env/i, /curl\b|wget\b|nc\b|netcat\b/i],
+    label: "credential_exfil_chain"
+  },
+  {
+    steps: [/rm.*log|delete.*log|clear.*log/i, /rm\s+-rf/i],
+    label: "cover_tracks_chain"
+  },
+  {
+    steps: [/select.*from|describe\s+table|show\s+tables/i, /drop\s+table|truncate\s+table/i],
+    label: "db_recon_destroy_chain"
+  },
+  {
+    steps: [/kubectl\s+get|kubectl\s+describe/i, /kubectl\s+delete|terraform\s+destroy/i],
+    label: "infra_recon_destroy_chain"
+  },
+  // git history read → exfil: agent dumps commit history or secrets then ships them out
+  {
+    steps: [/git\s+log|git\s+show|git\s+diff\b/i, /curl\b|wget\b|nc\b|netcat\b/i],
+    label: "git_history_exfil_chain"
+  },
+  // AWS identity probe → privilege escalation via role assumption or IAM mutation
+  {
+    steps: [/aws\s+sts\s+get-caller-identity|aws\s+iam\s+list/i, /aws\s+sts\s+assume-role|aws\s+iam\s+attach|aws\s+iam\s+put/i],
+    label: "aws_priv_esc_chain"
+  },
+  // /etc/passwd or /etc/shadow read → exfil of system credentials
+  {
+    steps: [/cat\s+\/etc\/passwd|cat\s+\/etc\/shadow|\/etc\/shadow/i, /curl\b|wget\b|nc\b|netcat\b/i],
+    label: "system_cred_exfil_chain"
+  },
+  // setuid/world-writable chmod → execute as privileged user
+  {
+    steps: [/chmod\s+(777|[0-9]*[47][0-9]*s|[ugo]\+s)/i, /\.\/|\bbash\b|\bsh\b|\bexec\b/i],
+    label: "suid_escalation_chain"
+  }
+];
+function recordSessionCall(sessionId, toolName, commandArg, verdict) {
+  const s = _getOrCreate(sessionId);
+  s.calls.push({ toolName, commandArg, verdict, ts: Date.now() });
+  if (s.calls.length > SESSION_RING_SIZE) s.calls.shift();
+  if (s.contaminatedCallsRemaining > 0) s.contaminatedCallsRemaining--;
+}
+function detectSequenceThreat(sessionId, currentCommandArg) {
+  const s = _sessions.get(sessionId);
+  if (!s || s.calls.length === 0) return { threat: false, label: null };
+  const history = s.calls.map((c) => c.commandArg);
+  for (const seq of THREAT_SEQUENCES) {
+    if (seq.steps.length < 2) continue;
+    const lastStep = seq.steps[seq.steps.length - 1];
+    if (!lastStep.test(currentCommandArg)) continue;
+    let stepIdx = seq.steps.length - 2;
+    for (let i = history.length - 1; i >= 0 && stepIdx >= 0; i--) {
+      if (seq.steps[stepIdx].test(history[i])) stepIdx--;
+    }
+    if (stepIdx < 0) {
+      logger.warn({ sessionId, label: seq.label }, "session-threat-tracker: multi-turn threat sequence detected");
+      return { threat: true, label: seq.label };
+    }
+  }
+  return { threat: false, label: null };
+}
+function markContaminated(sessionId, source, callCount) {
+  const s = _getOrCreate(sessionId);
+  s.contaminatedCallsRemaining = callCount;
+  s.contaminationSource = source;
+  logger.info({ sessionId, source, callCount }, "session-threat-tracker: session marked contaminated");
+  void _persistContamination(sessionId, source, callCount);
+}
+async function _persistContamination(sessionId, source, remaining) {
+  try {
+    const { agentContextStore } = await import("../sensor/agent-context-store.js");
+    const expiresAt = Date.now() + SESSION_EXPIRY_MS;
+    agentContextStore.store(
+      sessionId,
+      "contamination_v1",
+      JSON.stringify({ source, remaining, expiresAt }),
+      SESSION_EXPIRY_MS
+    );
+  } catch {
+  }
+}
+async function _hydrateContamination(sessionId) {
+  try {
+    const { agentContextStore } = await import("../sensor/agent-context-store.js");
+    const entries = agentContextStore.recall(sessionId, "contamination_v1", 1);
+    if (entries.length === 0) return;
+    const { source, remaining, expiresAt } = JSON.parse(entries[0].value);
+    if (Date.now() > expiresAt || remaining <= 0) return;
+    const s = _getOrCreate(sessionId);
+    s.contaminatedCallsRemaining = remaining;
+    s.contaminationSource = source;
+    logger.info({ sessionId, remaining }, "session-threat-tracker: contamination state restored from store");
+  } catch {
+  }
+}
+function isSessionContaminated(sessionId) {
+  const s = _sessions.get(sessionId);
+  return s ? s.contaminatedCallsRemaining > 0 : false;
+}
+function getContaminationSource(sessionId) {
+  const s = _sessions.get(sessionId);
+  return s && s.contaminatedCallsRemaining > 0 ? s.contaminationSource || null : null;
+}
+const _reputations = /* @__PURE__ */ new Map();
+const DAY_MS = 24 * 60 * 60 * 1e3;
+const GENERIC_AGENT_ID = "agent";
+function _defaultReputation() {
+  return { blockCount24h: 0, injectionAttempts: 0, sequenceThreats: 0, scrutinyTier: "normal", windowStart: Date.now() };
+}
+function _loadReputation(agentId) {
+  if (!_reputations.has(agentId)) _reputations.set(agentId, _defaultReputation());
+  return _reputations.get(agentId);
+}
+function _computeTier(rep) {
+  if (rep.injectionAttempts >= 2 || rep.sequenceThreats >= 1) return "high";
+  if (rep.blockCount24h >= 3) return "elevated";
+  return "normal";
+}
+function updateAgentReputation(agentId, eventType) {
+  if (!agentId || agentId === GENERIC_AGENT_ID) return;
+  const rep = _loadReputation(agentId);
+  const now = Date.now();
+  if (now - rep.windowStart > DAY_MS) {
+    rep.blockCount24h = 0;
+    rep.windowStart = now;
+  }
+  if (eventType === "block") rep.blockCount24h++;
+  if (eventType === "injection") rep.injectionAttempts++;
+  if (eventType === "sequence") rep.sequenceThreats++;
+  rep.scrutinyTier = _computeTier(rep);
+  void _persistReputation(agentId, rep);
+}
+function getAgentScrutinyTier(agentId) {
+  if (!agentId || agentId === GENERIC_AGENT_ID) return "normal";
+  return _loadReputation(agentId).scrutinyTier;
+}
+async function _persistReputation(agentId, rep) {
+  try {
+    const { agentContextStore } = await import("../sensor/agent-context-store.js");
+    agentContextStore.store(agentId, "reputation_v1", JSON.stringify(rep), 0);
+  } catch {
+  }
+}
+async function hydrateReputation(agentId) {
+  if (!agentId || agentId === GENERIC_AGENT_ID || _reputations.has(agentId)) return;
+  try {
+    const { agentContextStore } = await import("../sensor/agent-context-store.js");
+    const entries = agentContextStore.recall(agentId, "reputation_v1", 1);
+    if (entries.length > 0) {
+      const rep = JSON.parse(entries[0].value);
+      _reputations.set(agentId, rep);
+    }
+  } catch {
+  }
+}
+const READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
+  "analyze_runtime",
+  "get_recent_logs",
+  "get_network_activity",
+  "get_unified_timeline",
+  "validate_fix",
+  "clear_buffer"
+]);
+function _resetSessionsForTesting() {
+  _sessions.clear();
+  _reputations.clear();
+}
+function getSessionCallRing(sessionId) {
+  return _sessions.get(sessionId)?.calls ?? [];
+}
+function getSessionContaminationState(sessionId) {
+  const s = _sessions.get(sessionId);
+  return {
+    contaminated: (s?.contaminatedCallsRemaining ?? 0) > 0,
+    source: s?.contaminationSource ?? "",
+    callsRemaining: s?.contaminatedCallsRemaining ?? 0
+  };
+}
+function getDetectedSequences(sessionId) {
+  const s = _sessions.get(sessionId);
+  if (!s || s.calls.length < 2) return [];
+  const detected = [];
+  const history = s.calls.map((c) => c.commandArg);
+  for (const seq of THREAT_SEQUENCES) {
+    if (seq.steps.length < 2) continue;
+    let stepIdx = seq.steps.length - 1;
+    for (let i = history.length - 1; i >= 0 && stepIdx >= 0; i--) {
+      if (seq.steps[stepIdx].test(history[i])) stepIdx--;
+    }
+    if (stepIdx < 0) detected.push(seq.label);
+  }
+  return detected;
+}
+export {
+  READ_ONLY_TOOLS,
+  _resetSessionsForTesting,
+  detectSequenceThreat,
+  getAgentScrutinyTier,
+  getContaminationSource,
+  getDetectedSequences,
+  getSessionCallRing,
+  getSessionContaminationState,
+  hydrateReputation,
+  isSessionContaminated,
+  markContaminated,
+  recordSessionCall,
+  updateAgentReputation
+};

package/dist/intelligence/shadow-digest-cron.js

@@ -0,0 +1,81 @@
+import { getStores } from "../storage/store-registry.js";
+import logger from "../sensor/logger.js";
+const SYSTEM_TENANT = process.env.MERGEN_SYSTEM_TENANT_ID;
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1e3;
+function msUntilNextMonday0900Utc() {
+  const now = /* @__PURE__ */ new Date();
+  const day = now.getUTCDay();
+  const daysUntilMonday = day === 1 ? 7 : (8 - day) % 7 || 7;
+  const next = new Date(Date.UTC(
+    now.getUTCFullYear(),
+    now.getUTCMonth(),
+    now.getUTCDate() + daysUntilMonday,
+    9,
+    0,
+    0,
+    0
+  ));
+  return Math.max(next.getTime() - Date.now(), 0);
+}
+async function postDigest() {
+  const token = process.env.MERGEN_SLACK_BOT_TOKEN;
+  const channel = process.env.MERGEN_SLACK_DIGEST_CHANNEL ?? process.env.MERGEN_SLACK_CHANNEL;
+  if (!token || !channel) {
+    logger.debug("shadow-digest-cron: no Slack token or channel \u2014 skipping digest");
+    return;
+  }
+  const blocks = await getStores().shadowLog.getShadowSlackDigest(7, SYSTEM_TENANT);
+  try {
+    const res = await fetch("https://slack.com/api/chat.postMessage", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json; charset=utf-8",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({ channel, blocks })
+    });
+    if (!res.ok) {
+      logger.warn({ status: res.status }, "shadow-digest-cron: HTTP error posting to Slack");
+      return;
+    }
+    const json = await res.json();
+    if (!json.ok) {
+      logger.warn({ slackError: json.error }, "shadow-digest-cron: Slack API error");
+      return;
+    }
+    logger.info({ channel }, "shadow-digest-cron: weekly digest posted");
+  } catch (err) {
+    logger.warn({ err }, "shadow-digest-cron: failed to post digest");
+  }
+}
+function startShadowDigestCron() {
+  const isShadowMode = process.env.MERGEN_SHADOW_MODE === "true";
+  const isAutopilot = process.env.MERGEN_AUTOPILOT === "true";
+  const hasSlackToken = !!process.env.MERGEN_SLACK_BOT_TOKEN;
+  const hasChannel = !!(process.env.MERGEN_SLACK_DIGEST_CHANNEL ?? process.env.MERGEN_SLACK_CHANNEL);
+  if (!isShadowMode && !isAutopilot || !hasSlackToken || !hasChannel) {
+    return () => {
+    };
+  }
+  const delay = msUntilNextMonday0900Utc();
+  logger.info(
+    { nextFireInHours: Math.round(delay / 36e5) },
+    "shadow-digest-cron: scheduled (Monday 09:00 UTC)"
+  );
+  let intervalHandle = null;
+  const timeoutHandle = setTimeout(() => {
+    void postDigest();
+    intervalHandle = setInterval(() => {
+      void postDigest();
+    }, SEVEN_DAYS_MS);
+    intervalHandle.unref();
+  }, delay);
+  timeoutHandle.unref();
+  return () => {
+    clearTimeout(timeoutHandle);
+    if (intervalHandle) clearInterval(intervalHandle);
+  };
+}
+export {
+  startShadowDigestCron
+};

package/dist/intelligence/shadow-log.js

@@ -0,0 +1,284 @@
+import fs from "fs";
+import { lockAndExecute } from "../sensor/file-lock.js";
+import { randomUUID } from "crypto";
+import { SHADOW_LOG_FILE, DATA_DIR } from "../sensor/paths.js";
+import { recordOverride } from "./override-corpus.js";
+import logger from "../sensor/logger.js";
+const MAX_ENTRIES = 500;
+let _entries = [];
+let _loaded = false;
+function load(force = false) {
+  if (_loaded && !force) return;
+  if (!fs.existsSync(SHADOW_LOG_FILE)) {
+    _entries = [];
+    _loaded = true;
+    return;
+  }
+  try {
+    const raw = fs.readFileSync(SHADOW_LOG_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.version === 1 && Array.isArray(parsed.entries)) {
+      _entries = parsed.entries.slice(-MAX_ENTRIES);
+    } else {
+      _entries = [];
+    }
+    _loaded = true;
+  } catch (err) {
+    logger.warn({ err }, "shadow-log: failed to load \u2014 starting fresh");
+    _entries = [];
+    _loaded = true;
+  }
+}
+let _tmpCounter = 0;
+function persist() {
+  try {
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+    const payload = { version: 1, entries: _entries };
+    _tmpCounter = _tmpCounter + 1 >>> 0;
+    const tmp = `${SHADOW_LOG_FILE}.tmp.${process.pid}.${Date.now().toString(36)}.${_tmpCounter.toString(36)}`;
+    fs.writeFileSync(tmp, JSON.stringify(payload), "utf8");
+    fs.renameSync(tmp, SHADOW_LOG_FILE);
+  } catch (err) {
+    logger.warn({ err }, "shadow-log: failed to persist");
+  }
+}
+function recordShadow(input) {
+  const entry = {
+    ...input,
+    id: input.id ?? randomUUID(),
+    recordedAt: Date.now()
+  };
+  return lockAndExecute(`${SHADOW_LOG_FILE}.lock`, () => {
+    load(true);
+    _entries.push(entry);
+    if (_entries.length > MAX_ENTRIES) _entries = _entries.slice(-MAX_ENTRIES);
+    persist();
+    logger.info(
+      { id: entry.id, tag: entry.incidentTag, skip: entry.skipReason, wouldRun: entry.wouldHaveExecuted },
+      "shadow-log: entry recorded"
+    );
+    return entry;
+  });
+}
+function recordShadowVerdict(id, verdict, opts = {}) {
+  return lockAndExecute(`${SHADOW_LOG_FILE}.lock`, () => {
+    load(true);
+    const entry = _entries.find((e) => e.id === id);
+    if (!entry) return { found: false };
+    entry.humanVerdict = verdict;
+    entry.verdictAt = Date.now();
+    if (opts.note) entry.humanNote = opts.note.slice(0, 200);
+    let overrideId;
+    if (verdict === "would-override" && entry.command) {
+      const ov = recordOverride({
+        incidentTag: entry.incidentTag,
+        proposedCommand: entry.command,
+        overrideReason: opts.overrideReason ?? "on-call-discretion",
+        note: opts.note,
+        service: entry.service,
+        environment: "production",
+        manualAction: opts.manualAction,
+        actor: opts.actor ?? "shadow-review"
+      });
+      overrideId = ov.id;
+      entry.overrideId = ov.id;
+    }
+    persist();
+    return { found: true, entry, overrideId };
+  });
+}
+function updateShadowReasonByPid(pid, skipReason) {
+  lockAndExecute(`${SHADOW_LOG_FILE}.lock`, () => {
+    load(true);
+    const entry = _entries.find((e) => e.pid === pid);
+    if (entry) {
+      entry.skipReason = skipReason;
+      persist();
+      logger.info({ pid, skipReason }, "shadow-log: entry updated by pid");
+    }
+  });
+}
+function getShadowLog() {
+  load(true);
+  return _entries;
+}
+function computeShadowReport(entries, windowDays = 30) {
+  const cutoff = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+  const window = entries.filter((e) => e.recordedAt >= cutoff);
+  const wouldHaveExecuted = window.filter((e) => e.wouldHaveExecuted).length;
+  const skippedByLowConfidence = window.filter(
+    (e) => e.skipReason === "confidence-below-threshold" || e.skipReason === "remediation-below-threshold"
+  ).length;
+  const skippedByOverrideCorpus = window.filter((e) => e.skipReason === "override-corpus").length;
+  const skippedNoCommand = window.filter((e) => e.skipReason === "no-command").length;
+  const reviewed = window.filter((e) => e.humanVerdict !== void 0);
+  const approved = reviewed.filter((e) => e.humanVerdict === "would-approve").length;
+  const overrode = reviewed.filter((e) => e.humanVerdict === "would-override").length;
+  const approvalRate = reviewed.length >= 3 ? approved / reviewed.length : null;
+  const interventionRate = reviewed.length >= 3 ? overrode / reviewed.length : null;
+  const annotationCoverage = window.length > 0 ? reviewed.length / window.length : 0;
+  const safetyBlocked = window.filter((e) => e.skipReason === "blocked-by-safety-filter");
+  const annotatedSafetyBlocked = safetyBlocked.filter((e) => e.humanVerdict !== void 0);
+  const safetyBlockedApproved = annotatedSafetyBlocked.filter((e) => e.humanVerdict === "would-approve").length;
+  const gateFalsePositiveRate = annotatedSafetyBlocked.length >= 3 ? safetyBlockedApproved / annotatedSafetyBlocked.length : null;
+  let recommendation;
+  if (window.length === 0) {
+    recommendation = "No shadow entries yet. Enable MERGEN_SHADOW_MODE=true to start collecting recommendations.";
+  } else if (approvalRate === null) {
+    recommendation = `${reviewed.length} of ${window.length} entries reviewed. Review more shadow entries to get a reliable approval rate.`;
+  } else if (approvalRate >= 0.85) {
+    recommendation = `${Math.round(approvalRate * 100)}% approval rate over ${windowDays} days. Consider enabling MERGEN_AUTOPILOT_LEVEL=restarts.`;
+  } else if (approvalRate >= 0.7) {
+    recommendation = `${Math.round(approvalRate * 100)}% approval rate. Review override reasons before enabling autopilot \u2014 some patterns may need corpus entries.`;
+  } else {
+    recommendation = `${Math.round(approvalRate * 100)}% approval rate \u2014 below threshold. Review wrong recommendations and add override corpus entries for recurring patterns.`;
+  }
+  return {
+    windowDays,
+    total: window.length,
+    wouldHaveExecuted,
+    skippedByLowConfidence,
+    skippedByOverrideCorpus,
+    skippedNoCommand,
+    humanReviewed: reviewed.length,
+    humanApproved: approved,
+    humanOverrode: overrode,
+    approvalRate,
+    interventionRate,
+    gateFalsePositiveRate,
+    annotationCoverage,
+    recommendation
+  };
+}
+function getShadowReport(windowDays = 30) {
+  load();
+  return computeShadowReport(_entries, windowDays);
+}
+function computeShadowSlackDigest(entries, windowDays = 7) {
+  const report = computeShadowReport(entries, windowDays);
+  const ratePct = report.approvalRate !== null ? `${Math.round(report.approvalRate * 100)}%` : "n/a";
+  const reviewedNote = report.humanReviewed > 0 ? ` | ${report.humanApproved} approved / ${report.humanOverrode} overrode` : "";
+  const cutoff = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+  const pending = entries.filter((e) => e.recordedAt >= cutoff && e.wouldHaveExecuted && e.humanVerdict === void 0).slice(-5).reverse();
+  const entryBlocks = pending.flatMap((e) => {
+    const diagPct = Math.round(e.diagnosisConfidence * 100);
+    const remPct = Math.round(e.remediationConfidence * 100);
+    const cmd = e.command ? `\`${e.command}\`` : "_no command_";
+    return [
+      { type: "divider" },
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `*${e.service}* \xB7 \`${e.incidentTag}\`
+Diagnosis: ${diagPct}% \xB7 Remediation: ${remPct}%
+Would have run: ${cmd}`
+        }
+      },
+      {
+        type: "actions",
+        elements: [
+          {
+            type: "button",
+            text: { type: "plain_text", text: "\u{1F44D} Would approve", emoji: true },
+            action_id: `digest_approve_${e.id}`,
+            value: JSON.stringify({ id: e.id }),
+            style: "primary"
+          },
+          {
+            type: "button",
+            text: { type: "plain_text", text: "\u270B Would override", emoji: true },
+            action_id: `digest_override_${e.id}`,
+            value: JSON.stringify({ id: e.id }),
+            style: "danger"
+          }
+        ]
+      }
+    ];
+  });
+  return {
+    blocks: [
+      {
+        type: "header",
+        text: { type: "plain_text", text: "\u{1F50D} Mergen Shadow Mode \u2014 Weekly Summary" }
+      },
+      {
+        type: "section",
+        fields: [
+          { type: "mrkdwn", text: `*Recommendations (${windowDays}d)*
+${report.total}` },
+          { type: "mrkdwn", text: `*Would-execute (high confidence)*
+${report.wouldHaveExecuted}` },
+          { type: "mrkdwn", text: `*Human approval rate*
+${ratePct}${reviewedNote}` },
+          { type: "mrkdwn", text: `*Override corpus blocks*
+${report.skippedByOverrideCorpus}` }
+        ]
+      },
+      {
+        type: "section",
+        text: { type: "mrkdwn", text: `*Next step:* ${report.recommendation}` }
+      },
+      ...pending.length > 0 ? [
+        {
+          type: "section",
+          text: { type: "mrkdwn", text: `*${pending.length} pending review${pending.length > 1 ? "s" : ""}* \u2014 click below to calibrate:` }
+        },
+        ...entryBlocks
+      ] : [],
+      {
+        type: "actions",
+        elements: [
+          {
+            type: "button",
+            text: { type: "plain_text", text: "View full shadow report" },
+            url: "http://127.0.0.1:3000/shadow-report"
+          }
+        ]
+      }
+    ]
+  };
+}
+function getShadowSlackDigest(windowDays = 7) {
+  load();
+  return computeShadowSlackDigest(_entries, windowDays);
+}
+function computeShadowCsv(entries) {
+  const header = "id,pid,incidentTag,service,command,diagnosisConfidence,remediationConfidence,wouldHaveExecuted,skipReason,recordedAt,humanVerdict,verdictAt,humanNote";
+  const escape = (v) => {
+    if (/[",\r\n]/.test(v)) return `"${v.replace(/"/g, '""')}"`;
+    return v;
+  };
+  const rows = entries.map((e) => [
+    e.id,
+    e.pid,
+    e.incidentTag,
+    e.service,
+    e.command ?? "",
+    e.diagnosisConfidence,
+    e.remediationConfidence,
+    e.wouldHaveExecuted ? "true" : "false",
+    e.skipReason,
+    new Date(e.recordedAt).toISOString(),
+    e.humanVerdict ?? "",
+    e.verdictAt ? new Date(e.verdictAt).toISOString() : "",
+    e.humanNote ?? ""
+  ].map((c) => escape(String(c))).join(","));
+  return [header, ...rows].join("\n") + (rows.length > 0 ? "\n" : "");
+}
+function exportShadowCsv() {
+  load();
+  return computeShadowCsv(_entries);
+}
+export {
+  computeShadowCsv,
+  computeShadowReport,
+  computeShadowSlackDigest,
+  exportShadowCsv,
+  getShadowLog,
+  getShadowReport,
+  getShadowSlackDigest,
+  recordShadow,
+  recordShadowVerdict,
+  updateShadowReasonByPid
+};