mergen-server 1.4.0

package/dist/routes/billing-dashboard.js

@@ -0,0 +1,158 @@
+import { Router } from "express";
+import { getLicenseState, getActivePlanId } from "../intelligence/license.js";
+import { getPlan, PLANS, estimateToolCallOverageCents, estimateSeatOverageCents } from "../intelligence/plans.js";
+import { getUsageSnapshot } from "../intelligence/usage.js";
+import { getToolCallCounts } from "../intelligence/gate-analytics.js";
+import { listMembers } from "../sensor/rbac.js";
+function totalMediatedToolCalls() {
+  let total = 0;
+  for (const count of getToolCallCounts().values()) total += count;
+  return total;
+}
+const DOCS_URL = "https://mergen.app/pricing";
+function nextResetLabel() {
+  const now = /* @__PURE__ */ new Date();
+  const next = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+  const diffDays = Math.ceil((next.getTime() - now.getTime()) / 864e5);
+  return `${next.toISOString().slice(0, 10)} (${diffDays} day${diffDays !== 1 ? "s" : ""})`;
+}
+function usagePercent(used, included) {
+  if (included === null || included === 0) return null;
+  return Math.min(100, Math.round(used / included * 100));
+}
+function createBillingDashboardRouter() {
+  const router = Router();
+  router.get("/billing/dashboard", (_req, res) => {
+    const planId = getActivePlanId();
+    const plan = getPlan(planId);
+    const state = getLicenseState();
+    const usage = getUsageSnapshot();
+    const isPaid = planId !== "free";
+    const isPayg = planId === "pay_as_you_go";
+    const pctUsed = usagePercent(usage.used, usage.included);
+    const nearLimit = pctUsed !== null && pctUsed >= 80 && !isPayg;
+    const atLimit = pctUsed !== null && pctUsed >= 100 && !isPayg;
+    const overageCostCents = usage.estimatedOverageCents;
+    const overageCostDollars = overageCostCents > 0 ? (overageCostCents / 100).toFixed(2) : null;
+    const toolCallsThisMonth = totalMediatedToolCalls();
+    const toolCallOverageCents = estimateToolCallOverageCents(planId, toolCallsThisMonth);
+    const activeSeats = listMembers().length;
+    const seatOverageCents = estimateSeatOverageCents(planId, activeSeats);
+    let upgradeMessage = null;
+    let upgradePlan = null;
+    if (atLimit) {
+      upgradeMessage = `You've reached your ${usage.included} credit limit for ${usage.month}. Upgrade to keep running analyses.`;
+      upgradePlan = plan.ctaUrl != null ? String(plan.ctaUrl) : null;
+    } else if (nearLimit && usage.remaining !== null) {
+      upgradeMessage = `${usage.remaining} credits remaining this month. Consider upgrading to avoid interruption.`;
+      upgradePlan = plan.ctaUrl != null ? String(plan.ctaUrl) : null;
+    } else if (!isPaid) {
+      upgradeMessage = "Upgrade to unlock backend observability, more credits, and autonomous execution.";
+      upgradePlan = DOCS_URL;
+    }
+    res.json({
+      ok: true,
+      plan: {
+        id: plan.id,
+        name: plan.name,
+        tagline: plan.tagline,
+        seats: plan.seats,
+        isPaid,
+        ctaUrl: plan.ctaUrl
+      },
+      license: state ? {
+        email: state.customerEmail ?? null,
+        status: state.status ?? "active",
+        activatedAt: state.validatedAt ?? null
+      } : null,
+      usage: {
+        month: usage.month,
+        used: usage.used,
+        included: usage.included,
+        remaining: usage.remaining,
+        percentUsed: pctUsed,
+        overageCredits: usage.overage,
+        overagePending: usage.overagePendingCredits,
+        estimatedOverageDollars: overageCostDollars,
+        nearLimit,
+        atLimit
+      },
+      // Execution-volume usage — mediated tool-calls (Gate A evaluations), the
+      // primary metering dimension alongside seats (analyze-credits above cover
+      // diagnostic AI checks specifically, a separate, narrower usage type).
+      execution: {
+        toolCallsThisMonth,
+        includedToolCallsPerMonth: plan.includedToolCallsPerMonth === 0 ? null : plan.includedToolCallsPerMonth,
+        estimatedOverageDollars: toolCallOverageCents > 0 ? (toolCallOverageCents / 100).toFixed(2) : null
+      },
+      seats: {
+        active: activeSeats,
+        included: isFinite(plan.seatCap) ? plan.seatCap : null,
+        estimatedOverageDollars: seatOverageCents > 0 ? (seatOverageCents / 100).toFixed(2) : null
+      },
+      billing: {
+        nextResetOn: nextResetLabel(),
+        overageCentsPerCredit: plan.overageCentsPerCredit,
+        docsUrl: DOCS_URL
+      },
+      upgrade: upgradeMessage ? { message: upgradeMessage, url: upgradePlan } : null
+    });
+  });
+  router.get("/billing/plans", (_req, res) => {
+    const activePlanId = getActivePlanId();
+    const plans = Object.values(PLANS).map((p) => ({
+      id: p.id,
+      name: p.name,
+      tagline: p.tagline,
+      seats: p.seats,
+      bufferSize: p.bufferSize,
+      backendObservability: p.backendObservability,
+      analyzeCreditsPerMonth: p.analyzeCreditsPerMonth === Infinity ? null : p.analyzeCreditsPerMonth,
+      overageCentsPerCredit: p.overageCentsPerCredit,
+      overagePriceLabel: p.overageCentsPerCredit > 0 ? `$${(p.overageCentsPerCredit / 100).toFixed(2)} / credit over limit` : "No overage \u2014 hard stop at limit",
+      seatCap: isFinite(p.seatCap) ? p.seatCap : null,
+      overageCentsPerSeat: p.overageCentsPerSeat,
+      seatOveragePriceLabel: p.overageCentsPerSeat > 0 ? `$${(p.overageCentsPerSeat / 100).toFixed(2)} / mo per additional seat` : null,
+      includedToolCallsPerMonth: p.includedToolCallsPerMonth === 0 ? null : p.includedToolCallsPerMonth,
+      overageCentsPerThousandToolCalls: p.overageCentsPerThousandToolCalls,
+      toolCallOveragePriceLabel: p.overageCentsPerThousandToolCalls > 0 ? `$${(p.overageCentsPerThousandToolCalls / 100).toFixed(2)} / 1,000 tool-calls over limit` : null,
+      ctaUrl: p.ctaUrl,
+      active: p.id === activePlanId
+    }));
+    res.json({ ok: true, plans, activePlanId });
+  });
+  router.get("/billing/usage", (_req, res) => {
+    const planId = getActivePlanId();
+    const plan = getPlan(planId);
+    const usage = getUsageSnapshot();
+    const pctUsed = usagePercent(usage.used, usage.included);
+    const status = !pctUsed ? "ok" : pctUsed >= 100 ? "at_limit" : pctUsed >= 80 ? "near_limit" : "ok";
+    res.json({
+      ok: true,
+      current: {
+        month: usage.month,
+        used: usage.used,
+        included: usage.included,
+        remaining: usage.remaining,
+        percentUsed: pctUsed,
+        overage: usage.overage,
+        overagePendingCredits: usage.overagePendingCredits,
+        overageConfirmedCredits: usage.overageConfirmedCredits,
+        estimatedOverageCents: usage.estimatedOverageCents,
+        estimatedOverageDollars: usage.estimatedOverageCents > 0 ? (usage.estimatedOverageCents / 100).toFixed(2) : null,
+        status
+      },
+      plan: {
+        id: plan.id,
+        name: plan.name,
+        overageCentsPerCredit: plan.overageCentsPerCredit,
+        ctaUrl: plan.ctaUrl
+      },
+      guidance: status === "at_limit" ? { message: `Monthly limit reached. Upgrade or wait for reset on ${nextResetLabel()}.`, url: plan.ctaUrl } : status === "near_limit" ? { message: `Approaching limit (${pctUsed}% used). Consider upgrading.`, url: plan.ctaUrl } : null
+    });
+  });
+  return router;
+}
+export {
+  createBillingDashboardRouter
+};

package/dist/routes/billing-outcome.js

@@ -0,0 +1,77 @@
+import { Router } from "express";
+import { getStores } from "../storage/store-registry.js";
+import { postmortemStore } from "../intelligence/postmortem-store.js";
+import { getIncidentCount } from "../intelligence/usage.js";
+const DEFAULT_REVENUE_PER_MINUTE_USD = 100;
+const AUTONOMOUS_MTTR_FALLBACK_MS = 2 * 60 * 1e3;
+function getMedianAutonomousMttrMs(resolved) {
+  const samples = resolved.filter((i) => i.resolvedAutonomously && i.resolvedAt != null).map((i) => i.resolvedAt - i.createdAt).filter((ms) => ms > 0).sort((a, b) => a - b);
+  if (samples.length < 3) return null;
+  const mid = Math.floor(samples.length / 2);
+  return samples.length % 2 === 0 ? (samples[mid - 1] + samples[mid]) / 2 : samples[mid];
+}
+function fmtMs(ms) {
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  const min = Math.floor(ms / 6e4);
+  const sec = Math.round(ms % 6e4 / 1e3);
+  return sec > 0 ? `${min}m ${sec}s` : `${min}m`;
+}
+function createBillingOutcomeRouter() {
+  const router = Router();
+  router.get("/billing/outcome-report", async (req, res) => {
+    const revenuePerMinute = parseFloat(process.env.MERGEN_REVENUE_PER_MINUTE_USD ?? "") || DEFAULT_REVENUE_PER_MINUTE_USD;
+    const all = await getStores().incidents.list(void 0, 1e3, req.tenantId);
+    const resolved = all.filter((i) => i.status === "resolved" && i.resolvedAt && i.createdAt);
+    const manualMttrSamples = resolved.filter((i) => !i.resolvedAutonomously).map((i) => i.resolvedAt - i.createdAt);
+    const avgManualMttrMs = manualMttrSamples.length > 0 ? manualMttrSamples.reduce((a, b) => a + b, 0) / manualMttrSamples.length : null;
+    const autonomousCount = resolved.filter((i) => i.resolvedAutonomously).length;
+    const totalResolved = resolved.length;
+    const empiricalAutonomousMttrMs = getMedianAutonomousMttrMs(resolved);
+    const autonomousMttrMs = empiricalAutonomousMttrMs ?? AUTONOMOUS_MTTR_FALLBACK_MS;
+    const autonomousMttrSource = empiricalAutonomousMttrMs != null ? `empirical median (n=${resolved.filter((i) => i.resolvedAutonomously && i.resolvedAt).length})` : "conservative prior \u2014 updates after 3+ autonomous resolutions";
+    const baselineMttrMs = avgManualMttrMs ?? 30 * 60 * 1e3;
+    const mttrSavedPerIncidentMs = Math.max(0, baselineMttrMs - autonomousMttrMs);
+    const totalTimeSavedMs = mttrSavedPerIncidentMs * autonomousCount;
+    const totalTimeSavedMin = totalTimeSavedMs / 6e4;
+    const estimatedRevenuePreservedUsd = totalTimeSavedMin * revenuePerMinute;
+    const corpusTotal = postmortemStore.count();
+    const tagStats = postmortemStore.tagStats();
+    const serviceSet = new Set(all.map((i) => i.service ?? "unknown").filter((s) => s !== "unknown"));
+    const incidentsThisMonth = getIncidentCount();
+    const report = {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      // Core SRE metrics
+      totalResolved,
+      autonomousResolutions: autonomousCount,
+      autonomousRate: totalResolved > 0 ? Math.round(autonomousCount / totalResolved * 100) : 0,
+      avgManualMttrMs,
+      avgManualMttrLabel: avgManualMttrMs != null ? fmtMs(avgManualMttrMs) : null,
+      estimatedAutonomousMttrMs: autonomousMttrMs,
+      autonomousMttrSource,
+      // Time savings
+      mttrSavedPerIncidentMs: avgManualMttrMs != null ? mttrSavedPerIncidentMs : null,
+      totalTimeSavedMs: avgManualMttrMs != null ? totalTimeSavedMs : null,
+      totalTimeSavedLabel: avgManualMttrMs != null ? fmtMs(totalTimeSavedMs) : null,
+      // Revenue preservation (Y5 outcome billing)
+      revenuePerMinuteUsd: revenuePerMinute,
+      estimatedRevenuePreservedUsd: avgManualMttrMs != null ? Math.round(estimatedRevenuePreservedUsd) : null,
+      revenuePreservedNote: avgManualMttrMs == null ? "Insufficient data: need at least one manually-resolved incident for MTTR baseline." : `Based on ${fmtMs(baselineMttrMs)} avg manual MTTR vs ${fmtMs(autonomousMttrMs)} autonomous (${autonomousMttrSource}). Configure MERGEN_REVENUE_PER_MINUTE_USD for your revenue rate.`,
+      // Corpus health (corpus moat metrics)
+      corpusPostmortems: corpusTotal,
+      topFailureModes: tagStats.slice(0, 5).map((s) => ({
+        tag: s.tag.replace(/^infra_/, ""),
+        incidents: s.count,
+        avgMttrLabel: s.avgMttrMs != null ? fmtMs(s.avgMttrMs) : null
+      })),
+      // Expansion signals (NRR growth)
+      servicesConnected: serviceSet.size,
+      services: [...serviceSet],
+      incidentsThisMonth
+    };
+    res.json({ ok: true, report });
+  });
+  return router;
+}
+export {
+  createBillingOutcomeRouter
+};

package/dist/routes/calibration.js

@@ -0,0 +1,305 @@
+import { Router } from "express";
+import {
+  recordVerdict,
+  getStats,
+  getStatsForTag,
+  getRecords,
+  exportCsv,
+  getPendingFeedback,
+  getGlobalStats,
+  isCorpusSeeded,
+  getRealVerdictCount,
+  CALIBRATION_CONFIG
+} from "../intelligence/calibration.js";
+import { getClusters } from "../intelligence/unclassified-clusters.js";
+import { getSessionMetrics } from "../intelligence/session-metrics.js";
+import { computeRocCurve, getExecutionThreshold } from "../intelligence/threshold-optimizer.js";
+import { computeBlastRadius } from "../intelligence/blast-radius.js";
+import { plattScale, getPlattDiagnostics } from "../intelligence/platt-scaling.js";
+import { getStores } from "../storage/store-registry.js";
+const VALID_VERDICT_DIMENSIONS = /* @__PURE__ */ new Set(["root_cause", "fix_hint", "both"]);
+function createCalibrationRouter() {
+  const router = Router();
+  router.post("/feedback", (req, res) => {
+    const { pid, verdict, note, verdictDimension } = req.body ?? {};
+    if (!pid || typeof pid !== "string") {
+      res.status(400).json({ ok: false, error: "pid (string) is required" });
+      return;
+    }
+    if (verdict !== "correct" && verdict !== "wrong" && verdict !== "partial") {
+      res.status(400).json({ ok: false, error: "verdict must be 'correct' | 'wrong' | 'partial'" });
+      return;
+    }
+    if (verdictDimension !== void 0 && !VALID_VERDICT_DIMENSIONS.has(verdictDimension)) {
+      res.status(400).json({
+        ok: false,
+        error: "verdictDimension must be 'root_cause' | 'fix_hint' | 'both'"
+      });
+      return;
+    }
+    const cleanNote = typeof note === "string" && note.trim() ? note : void 0;
+    const cleanDim = verdictDimension;
+    const result = recordVerdict(pid, verdict, cleanNote, cleanDim);
+    if (!result.found) {
+      res.status(404).json({ ok: false, error: `unknown pid: ${pid}` });
+      return;
+    }
+    if (!result.persisted) {
+      res.status(207).json({
+        ok: true,
+        warning: "verdict recorded in memory but failed to persist to disk",
+        retryable: true,
+        retryAfterMs: 5e3
+      });
+      return;
+    }
+    res.json({ ok: true });
+  });
+  router.get("/calibration", (_req, res) => {
+    const stats = getStats();
+    const trusted = stats.filter((s) => s.trusted);
+    const totalVerdicts = trusted.reduce((sum, s) => sum + s.verdicts, 0);
+    const overall = totalVerdicts > 0 ? trusted.reduce((sum, s) => sum + s.accuracy * s.verdicts, 0) / totalVerdicts : null;
+    const anyInterruptsAllowed = stats.some((s) => s.shouldInterrupt);
+    const corpusSeeded = isCorpusSeeded();
+    const realVerdictCount = getRealVerdictCount();
+    res.json({
+      ok: true,
+      overallAccuracy: overall,
+      trustedDetectors: trusted.length,
+      totalDetectors: stats.length,
+      anyInterruptsAllowed,
+      corpusSeeded,
+      realVerdictCount,
+      warmUpComplete: realVerdictCount >= 10,
+      pendingFeedback: getPendingFeedback(),
+      config: CALIBRATION_CONFIG,
+      perDetector: stats
+    });
+  });
+  router.get("/calibration/precision", (_req, res) => {
+    const stats = getStats();
+    const totalPredictions = stats.reduce((s, d) => s + d.predictions, 0);
+    const totalVerdicts = stats.reduce((s, d) => s + d.verdicts, 0);
+    const coverageRate = totalPredictions > 0 ? Math.round(totalVerdicts / totalPredictions * 100) / 100 : 0;
+    const trusted = stats.filter((d) => d.trusted);
+    const trustedVerdicts = trusted.reduce((s, d) => s + d.verdicts, 0);
+    const globalAccuracy = trustedVerdicts > 0 ? Math.round(trusted.reduce((s, d) => s + d.accuracy * d.verdicts, 0) / trustedVerdicts * 1e3) / 1e3 : null;
+    const detectors = stats.map((d) => ({
+      tag: d.tag,
+      predictions: d.predictions,
+      verdicts: d.verdicts,
+      precision: typeof d.accuracy === "number" ? Math.round(d.accuracy * 1e3) / 1e3 : null,
+      diagnosisPrecision: typeof d.diagnosisAccuracy === "number" ? Math.round(d.diagnosisAccuracy * 1e3) / 1e3 : null,
+      remediationPrecision: typeof d.remediationAccuracy === "number" ? Math.round(d.remediationAccuracy * 1e3) / 1e3 : null,
+      trusted: d.trusted,
+      trend: d.trendDelta !== null ? `${d.trendDelta >= 0 ? "+" : ""}${(d.trendDelta * 100).toFixed(1)}%` : null,
+      topFailureModes: d.commonFailureModes.map((f) => f.note)
+    }));
+    res.json({
+      ok: true,
+      generated: (/* @__PURE__ */ new Date()).toISOString(),
+      note: "Precision = P(correct | verdict given). Recall not measurable without ground-truth negatives.",
+      totalPredictions,
+      totalVerdicts,
+      coverageRate,
+      globalAccuracy,
+      detectors
+    });
+  });
+  router.get("/calibration/export", (_req, res) => {
+    const csv = exportCsv();
+    res.setHeader("Content-Type", "text/csv; charset=utf-8");
+    res.setHeader(
+      "Content-Disposition",
+      `attachment; filename="mergen-calibration-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.csv"`
+    );
+    res.send(csv);
+  });
+  router.get("/calibration/unclassified", (req, res) => {
+    const minCount = Math.max(1, parseInt(String(req.query["minCount"] ?? "3"), 10) || 3);
+    const clusters = getClusters(minCount);
+    res.json({
+      ok: true,
+      total: clusters.length,
+      minCount,
+      clusters
+    });
+  });
+  router.get("/calibration/global", (_req, res) => {
+    res.json({
+      ok: true,
+      stats: getGlobalStats()
+    });
+  });
+  router.get("/calibration/corpus-progress", (_req, res) => {
+    const TARGET = 20;
+    const records = getRecords().filter((r) => !r.isBuiltinSeed);
+    const highCorrect = records.filter(
+      (r) => r.confidence === "HIGH" && (r.verdict === "correct" || r.verdict === "partial")
+    ).length;
+    const corpusSeeded = isCorpusSeeded();
+    const trustedDetectors = corpusSeeded ? 0 : getStats().filter((s) => s.trusted).length;
+    res.json({
+      ok: true,
+      highConfidentCorrect: highCorrect,
+      target: TARGET,
+      targetReached: highCorrect >= TARGET,
+      pct: Math.min(100, Math.round(highCorrect / TARGET * 100)),
+      trustedDetectors,
+      totalVerdicts: records.filter((r) => r.verdict).length,
+      corpusSeeded
+    });
+  });
+  router.get("/session-metrics", (_req, res) => {
+    res.json({ ok: true, ...getSessionMetrics() });
+  });
+  router.get("/calibration/threshold", (_req, res) => {
+    const records = getRecords();
+    const verdicted = records.filter((r) => r.verdict !== void 0);
+    const withNumeric = verdicted.filter((r) => r.numericScore !== void 0);
+    const rocCurve = computeRocCurve();
+    const recommended = getExecutionThreshold();
+    res.json({
+      ok: true,
+      generated: (/* @__PURE__ */ new Date()).toISOString(),
+      note: "Threshold maximizes Youden's J (TPR - FPR). Min 20 verdicts required; uses 0.85 fallback until then.",
+      currentThreshold: 0.85,
+      recommendedThreshold: recommended,
+      usingFallback: rocCurve.length === 0,
+      sampleSize: verdicted.length,
+      sampleSizeWithNumericScore: withNumeric.length,
+      rocCurve
+    });
+  });
+  router.get("/blast-radius", (req, res) => {
+    const command = typeof req.query.command === "string" ? req.query.command.trim() : "";
+    if (!command) {
+      res.status(400).json({ ok: false, error: "command query param is required" });
+      return;
+    }
+    const service = typeof req.query.service === "string" ? req.query.service : void 0;
+    const namespace = typeof req.query.namespace === "string" ? req.query.namespace : void 0;
+    const environment = typeof req.query.environment === "string" ? req.query.environment : void 0;
+    const br = computeBlastRadius(command, { service, namespace, environment });
+    res.json({ ok: true, ...br });
+  });
+  router.get("/trust-score/:pid", async (req, res) => {
+    const { pid } = req.params;
+    const inc = await getStores().incidents.get(pid, req.tenantId);
+    if (!inc) {
+      res.status(404).json({ error: "incident not found", pid });
+      return;
+    }
+    await getStores().incidents.markContextViewed(pid, req.tenantId);
+    const rawScore = inc.confidence;
+    const tag = inc.tag;
+    const result = plattScale(rawScore, tag);
+    const pct = Math.round(result.calibrated * 100);
+    const records = getRecords().filter((r) => r["pid"] === pid);
+    const verdictHistory = records.map((r) => ({
+      verdict: r["verdict"] ?? null,
+      note: r["note"] ?? null,
+      recordedAt: r["recordedAt"] ?? null,
+      dimension: r["verdictDimension"] ?? null
+    }));
+    const tagStats = getStatsForTag(tag);
+    const interpretation = pct >= 85 ? "high \u2014 strong historical basis for automated action" : pct >= 65 ? "medium \u2014 recommend human review before execution" : pct >= 40 ? "low \u2014 diagnosis is a signal, not a conclusion" : "insufficient \u2014 surface as context only";
+    res.json({
+      ok: true,
+      pid,
+      service: inc.service ?? null,
+      tag,
+      rawScore,
+      calibrated: result.calibrated,
+      calibratedPct: pct,
+      calibrationSource: result.source,
+      calibrationSampleSize: result.n,
+      verdictHistory,
+      tagAccuracy: tagStats?.accuracy ?? null,
+      tagSampleSize: tagStats?.n ?? null,
+      interpretation,
+      resolvedAutonomously: inc.resolvedAutonomously,
+      causallyCorrect: inc.causallyCorrect
+    });
+  });
+  router.get("/trust-score", (req, res) => {
+    const tag = typeof req.query.tag === "string" ? req.query.tag : void 0;
+    const rawScore = parseFloat(String(req.query.rawScore ?? req.query.score ?? ""));
+    if (isNaN(rawScore) || rawScore < 0 || rawScore > 1) {
+      res.status(400).json({ error: "rawScore must be a number between 0 and 1" });
+      return;
+    }
+    const result = plattScale(rawScore, tag);
+    const pct = Math.round(result.calibrated * 100);
+    const interpretation = pct >= 85 ? "high \u2014 strong historical basis for automated action" : pct >= 65 ? "medium \u2014 recommend human review before execution" : pct >= 40 ? "low \u2014 diagnosis is a signal, not a conclusion" : "insufficient \u2014 surface as context only";
+    res.json({
+      ok: true,
+      rawScore,
+      tag: tag ?? null,
+      calibrated: result.calibrated,
+      calibratedPct: pct,
+      source: result.source,
+      empiricalBasis: result.n,
+      interpretation,
+      // Diagnostic: show all fitted Platt models (useful for PoC demos)
+      models: tag ? void 0 : getPlattDiagnostics()
+    });
+  });
+  router.get("/confidence-report", async (req, res) => {
+    const windowDays = Math.min(90, Math.max(1, parseInt(String(req.query.days ?? "30"), 10)));
+    const windowStart = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+    const currentThreshold = getExecutionThreshold();
+    const roc = computeRocCurve();
+    const bestRoc = roc.length > 0 ? roc.reduce((best, pt) => pt.youdensJ > best.youdensJ ? pt : best, roc[0]) : null;
+    const records = getRecords();
+    const thresholdSampleSize = records.filter((r) => r.verdict !== null).length;
+    const allIncidents = await getStores().incidents.list(void 0, 1e4, req.tenantId);
+    const windowIncidents = allIncidents.filter(
+      (i) => (i.createdAt ?? 0) >= windowStart
+    );
+    const autonomous = windowIncidents.filter((i) => i.resolvedAutonomously);
+    const successful = autonomous.filter((i) => i.causallyCorrect === true);
+    const falsePositives = autonomous.filter((i) => i.causallyCorrect === false);
+    const recent7d = autonomous.filter((i) => (i.resolvedAt ?? i.createdAt ?? 0) >= sevenDaysAgo);
+    const recent7dSuccess = recent7d.filter((i) => i.causallyCorrect === true);
+    const rollingRate7d = recent7d.length > 0 ? Math.round(recent7dSuccess.length / recent7d.length * 1e3) / 1e3 : null;
+    const stats = getStats();
+    const detectorHealth = stats.map((s) => ({
+      tag: s.tag,
+      accuracy: Math.round(s.accuracy * 1e3) / 1e3,
+      verdicts: s.verdicts,
+      trusted: s.trusted,
+      status: s.accuracy >= 0.8 ? "healthy" : s.accuracy >= 0.6 ? "degraded" : "poor"
+    })).sort((a, b) => b.verdicts - a.verdicts);
+    const successRate = autonomous.length > 0 ? Math.round(successful.length / autonomous.length * 100) : null;
+    const deckSummary = autonomous.length === 0 ? `No autonomous resolutions yet in the last ${windowDays} days. Mergen is in observation mode.` : `Mergen acted autonomously ${autonomous.length} time${autonomous.length !== 1 ? "s" : ""} in ${windowDays} days. Success rate: ${successRate}%. Current confidence threshold: ${Math.round(currentThreshold * 100)}%` + (thresholdSampleSize >= 10 ? ` (calibrated from ${thresholdSampleSize} verdicts).` : " (default prior \u2014 calibrates with use).");
+    res.json({
+      ok: true,
+      report: {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        windowDays,
+        threshold: {
+          current: Math.round(currentThreshold * 1e3) / 1e3,
+          recommendation: bestRoc ? Math.round(bestRoc.threshold * 1e3) / 1e3 : Math.round(currentThreshold * 1e3) / 1e3,
+          basis: thresholdSampleSize >= 10 ? "empirical" : "prior",
+          sampleSize: thresholdSampleSize
+        },
+        autonomousAccuracy: {
+          attempts: autonomous.length,
+          successful: successful.length,
+          falsePositives: falsePositives.length,
+          rollingRate7d,
+          label: successRate !== null ? `${successRate}% of autonomous fixes resolved the incident` : "No autonomous actions yet \u2014 enable MERGEN_AUTOPILOT=true"
+        },
+        detectorHealth,
+        deckSummary
+      }
+    });
+  });
+  return router;
+}
+export {
+  createCalibrationRouter
+};

package/dist/routes/ci-gate-history.js

@@ -0,0 +1,20 @@
+import { Router } from "express";
+import { getStores } from "../storage/store-registry.js";
+function createCIGateHistoryRouter() {
+  const router = Router();
+  router.get("/ci/gate/history", async (req, res) => {
+    const prRaw = req.query.pr;
+    const pr = typeof prRaw === "string" ? parseInt(prRaw, 10) : NaN;
+    if (!Number.isFinite(pr)) {
+      res.status(400).json({ ok: false, error: 'query param "pr" is required and must be numeric' });
+      return;
+    }
+    const repo = typeof req.query.repo === "string" ? req.query.repo : void 0;
+    const entries = await getStores().gateHistory.listForPR(pr, repo, req.tenantId);
+    res.json({ ok: true, pr, entries });
+  });
+  return router;
+}
+export {
+  createCIGateHistoryRouter
+};