mergen-server 1.4.0

package/dist/intelligence/override-corpus.js

@@ -0,0 +1,597 @@
+import fs from "fs";
+import { lockAndExecute } from "../sensor/file-lock.js";
+import path from "path";
+import { randomUUID } from "crypto";
+import { OVERRIDE_CORPUS_FILE } from "../sensor/paths.js";
+import logger from "../sensor/logger.js";
+import { normalizeForMatching } from "./normalize.js";
+const OVERRIDE_REASONS = [
+  "batch-window",
+  "cost-constraint",
+  "on-call-discretion",
+  "compliance-hold",
+  "prefer-read-replica",
+  "maintenance-window",
+  "wrong-diagnosis",
+  "wrong-fix",
+  "other"
+];
+const MAX_EVENTS = 2e3;
+let _events = [];
+let _loaded = false;
+const READ_CACHE_TTL_MS = 2e3;
+let _lastForcedLoadAt = 0;
+let _compactedRules = null;
+let _corpusDirty = true;
+function load(force = false) {
+  if (_loaded && !force) return;
+  if (!fs.existsSync(OVERRIDE_CORPUS_FILE)) {
+    _events = [];
+    _loaded = true;
+    return;
+  }
+  try {
+    const raw = fs.readFileSync(OVERRIDE_CORPUS_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.version === 1 && Array.isArray(parsed.events)) {
+      _events = parsed.events.slice(-MAX_EVENTS);
+    } else {
+      _events = [];
+    }
+    _loaded = true;
+    _lastForcedLoadAt = Date.now();
+  } catch (err) {
+    logger.warn({ err }, "override-corpus: failed to load \u2014 starting fresh");
+    _events = [];
+    _loaded = true;
+  }
+}
+function loadForRead() {
+  if (!_loaded || Date.now() - _lastForcedLoadAt > READ_CACHE_TTL_MS) {
+    load(true);
+  }
+}
+let _tmpCounter = 0;
+function persist() {
+  try {
+    fs.mkdirSync(path.dirname(OVERRIDE_CORPUS_FILE), { recursive: true });
+    const payload = { version: 1, events: _events };
+    _tmpCounter = _tmpCounter + 1 >>> 0;
+    const tmp = `${OVERRIDE_CORPUS_FILE}.tmp.${process.pid}.${Date.now().toString(36)}.${_tmpCounter.toString(36)}`;
+    fs.writeFileSync(tmp, JSON.stringify(payload), "utf8");
+    fs.renameSync(tmp, OVERRIDE_CORPUS_FILE);
+  } catch (err) {
+    logger.warn({ err }, "override-corpus: failed to persist");
+  }
+}
+const DEFAULT_EXPIRY_MS = 90 * 24 * 60 * 60 * 1e3;
+function detectConflicts(input) {
+  loadForRead();
+  const now = Date.now();
+  const CONFLICT_PAIRS = [
+    ["batch-window", "wrong-fix"],
+    ["maintenance-window", "wrong-diagnosis"],
+    ["compliance-hold", "on-call-discretion"]
+  ];
+  const conflicts = [];
+  for (const ev of _events) {
+    if (ev.incidentTag !== input.incidentTag) continue;
+    if (ev.service !== input.service) continue;
+    if (ev.expiresAt && ev.expiresAt > 0 && ev.expiresAt < now) continue;
+    const commandOverlap = ev.proposedCommand.slice(0, 50).toLowerCase() === input.proposedCommand.slice(0, 50).toLowerCase();
+    if (commandOverlap) {
+      for (const [a, b] of CONFLICT_PAIRS) {
+        if (ev.overrideReason === a && input.overrideReason === b || ev.overrideReason === b && input.overrideReason === a) {
+          conflicts.push(ev.id);
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+function recordOverride(input) {
+  const now = /* @__PURE__ */ new Date();
+  const conflicts = detectConflicts({
+    incidentTag: input.incidentTag,
+    service: input.service,
+    overrideReason: input.overrideReason,
+    proposedCommand: input.proposedCommand
+  });
+  const expiresAt = input.expiresAt === 0 ? 0 : input.expiresAt ?? now.getTime() + DEFAULT_EXPIRY_MS;
+  const event = {
+    ...input,
+    id: randomUUID(),
+    proposedCommand: input.proposedCommand.slice(0, 500),
+    note: input.note?.slice(0, 200),
+    rationale: input.rationale?.slice(0, 300),
+    manualAction: input.manualAction?.slice(0, 500),
+    dayOfWeek: now.getUTCDay(),
+    hourOfDay: now.getUTCHours(),
+    recordedAt: now.getTime(),
+    expiresAt
+  };
+  return lockAndExecute(`${OVERRIDE_CORPUS_FILE}.lock`, () => {
+    load(true);
+    _events.push(event);
+    if (_events.length > MAX_EVENTS) _events = _events.slice(-MAX_EVENTS);
+    _corpusDirty = true;
+    persist();
+    if (conflicts.length > 0) {
+      logger.warn({ id: event.id, tag: event.incidentTag, conflicts }, "override-corpus: conflict detected with existing entries");
+    }
+    logger.info({ id: event.id, tag: event.incidentTag, reason: event.overrideReason, service: event.service, expiresAt }, "override-corpus: override recorded");
+    return { ...event, conflictsWith: conflicts.length > 0 ? conflicts : void 0 };
+  });
+}
+function getExpiringSoon(windowDays = 14) {
+  loadForRead();
+  const now = Date.now();
+  const cutoffMs = now + windowDays * 24 * 60 * 60 * 1e3;
+  return _events.filter((e) => {
+    if (!e.expiresAt || e.expiresAt === 0) return false;
+    return e.expiresAt > now && e.expiresAt < cutoffMs;
+  });
+}
+function overridePackKey(e) {
+  return `${e.incidentTag}:${e.overrideReason}:${e.dayOfWeek}:${e.hourOfDay}:${e.service}`;
+}
+function buildOverridePack(events, opts = {}) {
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const e of events) {
+    if (e.source === "community" && !opts.includeCommunity) continue;
+    const key = overridePackKey(e);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    entries.push({
+      incidentTag: e.incidentTag,
+      proposedCommand: e.proposedCommand,
+      overrideReason: e.overrideReason,
+      ...e.note ? { note: e.note } : {},
+      ...e.rationale ? { rationale: e.rationale } : {},
+      service: e.service,
+      environment: e.environment,
+      dayOfWeek: e.dayOfWeek,
+      hourOfDay: e.hourOfDay,
+      ...e.manualAction ? { manualAction: e.manualAction } : {},
+      ...e.outcome ? { outcome: e.outcome } : {}
+    });
+  }
+  return {
+    format: "mergen-pack",
+    version: 1,
+    ...opts.name ? { name: opts.name } : {},
+    exportedAt: Date.now(),
+    entryCount: entries.length,
+    entries
+  };
+}
+function importOverrides(entries, opts = {}) {
+  const source = opts.source ?? "community";
+  const actor = opts.actor ?? source;
+  return lockAndExecute(`${OVERRIDE_CORPUS_FILE}.lock`, () => {
+    load(true);
+    const existingKeys = new Set(_events.map(overridePackKey));
+    const now = Date.now();
+    let imported = 0;
+    let skipped = 0;
+    for (const entry of entries) {
+      const dayOfWeek = Math.min(6, Math.max(0, Math.trunc(entry.dayOfWeek)));
+      const hourOfDay = Math.min(23, Math.max(0, Math.trunc(entry.hourOfDay)));
+      const key = overridePackKey({ ...entry, dayOfWeek, hourOfDay });
+      if (existingKeys.has(key)) {
+        skipped++;
+        continue;
+      }
+      existingKeys.add(key);
+      _events.push({
+        id: randomUUID(),
+        incidentTag: entry.incidentTag,
+        proposedCommand: entry.proposedCommand.slice(0, 500),
+        overrideReason: entry.overrideReason,
+        note: entry.note?.slice(0, 200),
+        rationale: entry.rationale?.slice(0, 300),
+        service: entry.service,
+        environment: entry.environment,
+        dayOfWeek,
+        hourOfDay,
+        manualAction: entry.manualAction?.slice(0, 500),
+        outcome: entry.outcome,
+        recordedAt: now,
+        actor,
+        source,
+        expiresAt: entry.expiresInDays ? now + entry.expiresInDays * 24 * 60 * 60 * 1e3 : 0
+      });
+      imported++;
+    }
+    if (imported > 0) {
+      if (_events.length > MAX_EVENTS) _events = _events.slice(-MAX_EVENTS);
+      _corpusDirty = true;
+      persist();
+      logger.info({ imported, skipped, source }, "override-corpus: pack imported");
+    }
+    return { imported, skipped };
+  });
+}
+function updateOutcome(id, outcome) {
+  return lockAndExecute(`${OVERRIDE_CORPUS_FILE}.lock`, () => {
+    load(true);
+    const ev = _events.find((e) => e.id === id);
+    if (!ev) return false;
+    ev.outcome = outcome;
+    _corpusDirty = true;
+    persist();
+    return true;
+  });
+}
+function hasRecentOverride(incidentTag, service, dayOfWeek, hourOfDay) {
+  loadForRead();
+  const now = Date.now();
+  const cutoff = now - 90 * 24 * 60 * 60 * 1e3;
+  return _events.some((e) => {
+    if (e.incidentTag !== incidentTag) return false;
+    if (e.service !== service) return false;
+    if (e.recordedAt < cutoff) return false;
+    if (e.expiresAt && e.expiresAt > 0 && e.expiresAt < now) return false;
+    if (e.dayOfWeek !== dayOfWeek) return false;
+    const hourDiff = Math.abs(e.hourOfDay - hourOfDay);
+    return hourDiff <= 1 || hourDiff >= 23;
+  });
+}
+function dominantOverrideReason(incidentTag, service) {
+  loadForRead();
+  const counts = /* @__PURE__ */ new Map();
+  for (const e of _events) {
+    if (e.incidentTag !== incidentTag || e.service !== service) continue;
+    counts.set(e.overrideReason, (counts.get(e.overrideReason) ?? 0) + 1);
+  }
+  if (counts.size === 0) return null;
+  let best = null;
+  let bestCount = 0;
+  for (const [reason, count] of counts) {
+    if (count > bestCount) {
+      best = reason;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+function getOverridesForTag(tag) {
+  loadForRead();
+  return _events.filter((e) => e.incidentTag === tag);
+}
+function getOverrideById(id) {
+  loadForRead();
+  return _events.find((e) => e.id === id) ?? null;
+}
+function getAllOverrides() {
+  loadForRead();
+  return _events;
+}
+const DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+const SIGNATURE_TOKEN_COUNT = 3;
+const MAX_COMMAND_SIGNATURES = 5;
+function commandSignature(proposedCommand) {
+  const normalized = normalizeForMatching(proposedCommand).trim();
+  return normalized.split(" ").slice(0, SIGNATURE_TOKEN_COUNT).join(" ");
+}
+function dominantCommandSignatures(events) {
+  const sigCounts = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const sig = commandSignature(e.proposedCommand);
+    if (sig) sigCounts.set(sig, (sigCounts.get(sig) ?? 0) + 1);
+  }
+  return [...sigCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, MAX_COMMAND_SIGNATURES).map(([sig]) => sig);
+}
+function compactCorpus() {
+  load();
+  if (!_corpusDirty && _compactedRules !== null) return _compactedRules;
+  const buckets = /* @__PURE__ */ new Map();
+  for (const e of _events) {
+    const key = `${e.incidentTag}\0${e.service}\0${e.overrideReason}`;
+    const list = buckets.get(key) ?? [];
+    list.push(e);
+    buckets.set(key, list);
+  }
+  const rules = [];
+  for (const events of buckets.values()) {
+    if (events.length === 0) continue;
+    const first = events[0];
+    const dayCounts = /* @__PURE__ */ new Map();
+    for (const e of events) dayCounts.set(e.dayOfWeek, (dayCounts.get(e.dayOfWeek) ?? 0) + 1);
+    let dominantDay = null;
+    let dominantDayCount = 0;
+    for (const [day, count] of dayCounts) {
+      if (count > dominantDayCount) {
+        dominantDay = day;
+        dominantDayCount = count;
+      }
+    }
+    if (dominantDay !== null && dominantDayCount / events.length < 0.4) dominantDay = null;
+    let hourWindow = null;
+    const hoursToWindow = dominantDay !== null ? events.filter((e) => e.dayOfWeek === dominantDay).map((e) => e.hourOfDay) : events.map((e) => e.hourOfDay);
+    if (hoursToWindow.length > 0) {
+      const minH = Math.min(...hoursToWindow);
+      const maxH = Math.max(...hoursToWindow);
+      if (maxH - minH < 20) hourWindow = [minH, maxH + 1];
+    }
+    const commandSignatures = dominantCommandSignatures(events);
+    rules.push({
+      incidentTag: first.incidentTag,
+      service: first.service,
+      overrideReason: first.overrideReason,
+      dayOfWeek: dominantDay,
+      hourWindow,
+      occurrences: events.length,
+      commandSignatures,
+      compactedAt: Date.now()
+    });
+  }
+  rules.sort((a, b) => b.occurrences - a.occurrences);
+  _compactedRules = rules;
+  _corpusDirty = false;
+  return rules;
+}
+function getRulesForTag(incidentTag, service) {
+  return compactCorpus().filter(
+    (r) => r.incidentTag === incidentTag && r.service === service
+  );
+}
+function describeTopRule(incidentTag, service) {
+  const rules = getRulesForTag(incidentTag, service);
+  if (rules.length === 0) return null;
+  const r = rules[0];
+  const timePart = r.dayOfWeek !== null ? ` (${DAY_NAMES[r.dayOfWeek]}${r.hourWindow ? ` ${r.hourWindow[0]}\u2013${r.hourWindow[1] - 1} UTC` : ""}, ${r.occurrences} overrides)` : ` (${r.occurrences} overrides)`;
+  return `${r.incidentTag} for ${r.service} \u2014 ${r.overrideReason}${timePart}`;
+}
+function getOverrideSummary() {
+  loadForRead();
+  const byTag = /* @__PURE__ */ new Map();
+  for (const e of _events) {
+    const list = byTag.get(e.incidentTag) ?? [];
+    list.push(e);
+    byTag.set(e.incidentTag, list);
+  }
+  const DAY_NAMES2 = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+  const out = [];
+  for (const [tag, events] of byTag) {
+    const reasonCounts = /* @__PURE__ */ new Map();
+    const services = /* @__PURE__ */ new Set();
+    const dayCounts = /* @__PURE__ */ new Map();
+    const outcomes = { resolved: 0, escalated: 0, unresolved: 0, unknown: 0 };
+    for (const e of events) {
+      reasonCounts.set(e.overrideReason, (reasonCounts.get(e.overrideReason) ?? 0) + 1);
+      services.add(e.service);
+      dayCounts.set(e.dayOfWeek, (dayCounts.get(e.dayOfWeek) ?? 0) + 1);
+      if (e.outcome) outcomes[e.outcome]++;
+      else outcomes.unknown++;
+    }
+    let dominant = null;
+    let bestCount = 0;
+    for (const [r, c] of reasonCounts) {
+      if (c > bestCount) {
+        dominant = r;
+        bestCount = c;
+      }
+    }
+    let dominantDay = null;
+    let dominantDayCount = 0;
+    for (const [day, count] of dayCounts) {
+      if (count > dominantDayCount) {
+        dominantDay = day;
+        dominantDayCount = count;
+      }
+    }
+    let timePattern = null;
+    if (dominantDay !== null && dominantDayCount / events.length >= 0.4) {
+      const hoursOnDay = events.filter((e) => e.dayOfWeek === dominantDay).map((e) => e.hourOfDay);
+      const minHour = Math.min(...hoursOnDay);
+      const maxHour = Math.max(...hoursOnDay);
+      timePattern = maxHour > minHour ? `${DAY_NAMES2[dominantDay]} ${minHour}\u2013${maxHour} UTC` : `${DAY_NAMES2[dominantDay]} ${minHour} UTC`;
+    }
+    out.push({
+      tag,
+      total: events.length,
+      dominantReason: dominant,
+      services: [...services],
+      timePattern,
+      outcomes
+    });
+  }
+  out.sort((a, b) => b.total - a.total);
+  return out;
+}
+const _TAG_HINTS = [
+  [/\bpool\b|connection.?limit|max.?conn/i, "infra_db_connection_pool"],
+  [/\boom\b|out.of.memory|heap|memory.?leak/i, "infra_oom_kill"],
+  [/rate.?limit|throttl/i, "infra_rate_limit_cascade"],
+  [/\bauth\b|\btoken\b|session|oauth|\bjwt\b/i, "auth_token_not_persisted"],
+  [/\bcache\b|\bredis\b|memcach/i, "cache_invalidation"],
+  [/\bdeploy\b|rollout|release/i, "deploy_config_drift"],
+  [/\bcert\b|\btls\b|\bssl\b/i, "infra_certificate_expiry"],
+  [/\bdisk\b|storage|volume|\bspace\b/i, "infra_disk_pressure"],
+  [/migrat|schema|alter.?table/i, "db_migration_lock"],
+  [/friday|settlement|batch|weekend|end.of.day/i, "batch_window_conflict"],
+  [/\bscale\b|replica|pod.?count|instance/i, "infra_scaling"],
+  [/slow.?query|high.?latency|\bp99\b|\bp95\b/i, "infra_slow_query"]
+];
+const _REASON_HINTS = [
+  [/\b(friday|saturday|sunday|settlement|batch.window|end.of.day|after.hours|market.hours|trading.hours)\b/i, "batch-window"],
+  [/\b(cost|budget|billing|too.expensive|over.budget|cost.ceiling)\b/i, "cost-constraint"],
+  [/\b(cab|change.?control|change.?freeze|compliance|requires.approval|approval.required)\b/i, "compliance-hold"],
+  [/\b(read.?replica|replica.?routing|prefer.replica|read.only.replica)\b/i, "prefer-read-replica"],
+  [/\b(maintenance.?window|scheduled.downtime|downtime.window)\b/i, "maintenance-window"],
+  [/\b(wrong.?diag|misidentif|incorrect.root.cause|false.?positive|misdiagnos)\b/i, "wrong-diagnosis"],
+  [/\b(wrong.?fix|bad.command|revert|made.it.worse|incorrect.fix|undo)\b/i, "wrong-fix"]
+];
+function _inferTag(text) {
+  for (const [re, tag] of _TAG_HINTS) {
+    if (re.test(text)) return tag;
+  }
+  return "operational_constraint";
+}
+function _inferReason(text) {
+  for (const [re, reason] of _REASON_HINTS) {
+    if (re.test(text)) return reason;
+  }
+  return "on-call-discretion";
+}
+const _CLI_START_RE = /^(kubectl|oc|docker|docker-compose|podman|terraform|tofu|pulumi|ansible(?:-playbook)?|helm|kubeadm|nomad|vault|consul|systemctl|service|supervisorctl|pm2|npm|yarn|pnpm|npx|make|rake|rails|flyway|liquibase|alembic|psql|mysql|mongosh|mongo|redis-cli|aws|gcloud|az|git|pg_dump|pg_restore|createdb|dropdb|nginx|apachectl|kill|pkill|rm|chmod|chown|scp|rsync|bash|sh)\b/i;
+const _ACTION_RE = /\b(restart|kill|delete|drop|destroy|scale|resize|run|migrate|execute|deploy|push|apply|rollback|terminate|truncate|alter|reboot|flush|drain|update|patch)\b/i;
+const _NEG_RE = /\b(don'?t|do\s+not|avoid|never|should\s+not|shouldn'?t|must\s+not|mustn'?t|cannot|can'?t|won'?t|will\s+not|decided\s+(?:not|against)(?:\s+to)?|refrain\s+from|hold\s+off\s+on|no\s+(?:more\s+)?)\b/i;
+const _CONSTRAINT_SIGNAL_RE = /\b(constraint:|policy:|rule:|adr:|decided:|going\s+forward[,:]?|lesson(?:\s+learned)?[s:]?|we\s+learned|action\s+item[s:]?|takeaway[s:]?|we\s+(?:shouldn'?t|should\s+not|decided\s+not|won'?t|will\s+not))\b/i;
+const _TEMPORAL_RE = /\b(until|freeze|freeze\s+all|hold\s+off\s+until|not\s+until|embargo|blackout|lock\s+down|halt.*until|pause.*until|suspend.*until|stop.*until|don'?t.*until|this\s+(?:weekend|week|friday|monday|evening|night|morning)|end\s+of\s+(?:day|week|month|sprint|quarter))\b/i;
+function _parseTemporalExpiry(sentence) {
+  const lc = sentence.toLowerCase();
+  if (/this\s+(weekend|saturday|sunday)/.test(lc)) {
+    const now = /* @__PURE__ */ new Date();
+    const daysUntilMon = (8 - now.getUTCDay()) % 7 || 7;
+    const expiry = new Date(now);
+    expiry.setUTCDate(now.getUTCDate() + daysUntilMon);
+    expiry.setUTCHours(6, 0, 0, 0);
+    return expiry.getTime();
+  }
+  if (/end\s+of\s+day|tonight|this\s+evening/.test(lc)) {
+    const expiry = /* @__PURE__ */ new Date();
+    expiry.setUTCHours(23, 59, 0, 0);
+    if (expiry.getTime() < Date.now()) expiry.setUTCDate(expiry.getUTCDate() + 1);
+    return expiry.getTime();
+  }
+  if (/this\s+week|end\s+of\s+week/.test(lc)) {
+    return Date.now() + 7 * 24 * 60 * 60 * 1e3;
+  }
+  if (/end\s+of\s+month/.test(lc)) {
+    return Date.now() + 30 * 24 * 60 * 60 * 1e3;
+  }
+  if (/end\s+of\s+(sprint|quarter)/.test(lc)) {
+    return Date.now() + 14 * 24 * 60 * 60 * 1e3;
+  }
+  return void 0;
+}
+function _extractCandidates(thread) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  function _add(command, note, isNegative, manualAction, expiresAt) {
+    const key = command.toLowerCase().slice(0, 50);
+    if (!seen.has(key)) {
+      seen.add(key);
+      candidates.push({ command: command.slice(0, 500), note: note.slice(0, 300), isNegative, manualAction, expiresAt });
+    }
+  }
+  const backtickCmds = [...thread.matchAll(/`([^`]{4,300})`/g)].map((m) => m[1].trim());
+  if (backtickCmds.length > 0) {
+    const proposed = backtickCmds[0];
+    const manual = backtickCmds[1];
+    _add(proposed, proposed, false, manual);
+    if (manual) seen.add(manual.toLowerCase().slice(0, 50));
+    for (const cmd of backtickCmds.slice(2)) _add(cmd, cmd, false);
+  }
+  for (const line of thread.split("\n")) {
+    const t = line.trim();
+    if (_CLI_START_RE.test(t)) _add(t, t, false);
+  }
+  for (const sentence of thread.split(/[.!?\n]+/).map((s) => s.trim()).filter((s) => s.length > 15 && s.length < 350)) {
+    if (!_NEG_RE.test(sentence)) continue;
+    if (!_ACTION_RE.test(sentence)) continue;
+    const lc = sentence.toLowerCase();
+    if ([...seen].some((k) => k.length > 10 && lc.includes(k))) continue;
+    const actionMatch = sentence.match(_ACTION_RE);
+    const verb = actionMatch ? actionMatch[0] : "operation";
+    _add(`${verb} (blocked): ${sentence.slice(0, 120)}`, sentence, true);
+  }
+  for (const sentence of thread.split(/[.!?\n]+/).map((s) => s.trim()).filter((s) => s.length > 10 && s.length < 400)) {
+    if (!_CONSTRAINT_SIGNAL_RE.test(sentence)) continue;
+    const lc = sentence.toLowerCase();
+    if ([...seen].some((k) => k.length > 10 && lc.includes(k))) continue;
+    _add(sentence.slice(0, 200), sentence, false);
+  }
+  for (const sentence of thread.split(/[.!?\n]+/).map((s) => s.trim()).filter((s) => s.length > 10 && s.length < 400)) {
+    if (!_TEMPORAL_RE.test(sentence)) continue;
+    const lc = sentence.toLowerCase();
+    if ([...seen].some((k) => k.length > 10 && lc.includes(k))) continue;
+    const expiresAt = _parseTemporalExpiry(sentence);
+    const label = expiresAt ? `temporal-hold (expires ${new Date(expiresAt).toISOString().slice(0, 16)}Z): ${sentence.slice(0, 120)}` : `temporal-hold: ${sentence.slice(0, 120)}`;
+    _add(label, sentence, true, void 0, expiresAt);
+  }
+  return candidates;
+}
+function compileOverridesFromSlackThread(slackThread, service = "unknown") {
+  if (!slackThread) return [];
+  const candidates = _extractCandidates(slackThread);
+  if (candidates.length === 0) return [];
+  const threadTag = _inferTag(slackThread);
+  const threadReason = _inferReason(slackThread);
+  const events = [];
+  for (const cand of candidates) {
+    const localTag = _inferTag(cand.note) !== "operational_constraint" ? _inferTag(cand.note) : threadTag;
+    const localReason = _inferReason(cand.note) !== "on-call-discretion" ? _inferReason(cand.note) : threadReason;
+    try {
+      const event = recordOverride({
+        incidentTag: localTag,
+        proposedCommand: cand.command,
+        overrideReason: localReason,
+        note: cand.note,
+        rationale: cand.isNegative ? "Auto-extracted: negative decision pattern from postmortem thread" : "Auto-extracted: constraint declaration from postmortem thread",
+        service,
+        environment: "production",
+        manualAction: cand.manualAction,
+        actor: "slack-nlp-parser",
+        // Temporal constraints carry an auto-computed expiry
+        expiresAt: cand.expiresAt
+      });
+      events.push(event);
+    } catch {
+    }
+    if (events.length >= 10) break;
+  }
+  return events;
+}
+function getStaleOverrides(daysThreshold = 60) {
+  loadForRead();
+  const cutoff = Date.now() - daysThreshold * 24 * 60 * 60 * 1e3;
+  return _events.filter((e) => {
+    const lastReviewed = e.reviewedAt ?? e.recordedAt;
+    return lastReviewed < cutoff;
+  });
+}
+function markOverrideReviewed(id) {
+  return lockAndExecute(`${OVERRIDE_CORPUS_FILE}.lock`, () => {
+    load(true);
+    const ev = _events.find((e) => e.id === id);
+    if (!ev) return false;
+    ev.reviewedAt = Date.now();
+    _corpusDirty = true;
+    persist();
+    logger.info({ id }, "override-corpus: entry marked reviewed");
+    return true;
+  });
+}
+function compileOverrideFromSlackThread(slackThread, service = "unknown") {
+  return compileOverridesFromSlackThread(slackThread, service)[0] ?? null;
+}
+export {
+  MAX_COMMAND_SIGNATURES,
+  OVERRIDE_REASONS,
+  buildOverridePack,
+  commandSignature,
+  compactCorpus,
+  compileOverrideFromSlackThread,
+  compileOverridesFromSlackThread,
+  describeTopRule,
+  detectConflicts,
+  dominantCommandSignatures,
+  dominantOverrideReason,
+  getAllOverrides,
+  getExpiringSoon,
+  getOverrideById,
+  getOverrideSummary,
+  getOverridesForTag,
+  getRulesForTag,
+  getStaleOverrides,
+  hasRecentOverride,
+  importOverrides,
+  markOverrideReviewed,
+  overridePackKey,
+  recordOverride,
+  updateOutcome
+};

package/dist/intelligence/planning-gate.js

@@ -0,0 +1,84 @@
+import { calibrationClassifier } from "./calibration-classifier.js";
+import { getStatsForTag } from "./calibration.js";
+import { serviceGraph } from "../sensor/service-graph.js";
+import { postmortemStore } from "./postmortem-store.js";
+import { DEFAULT_EXECUTION_THRESHOLD } from "./threshold-optimizer.js";
+import logger from "../sensor/logger.js";
+const BLAST_RISK_THRESHOLD_DELTA = {
+  low: 0,
+  medium: 0.05,
+  high: 0.1
+};
+function planningGate(hyp, service, executionThreshold = DEFAULT_EXECUTION_THRESHOLD) {
+  const confidence = hyp.confidenceScore ?? 0;
+  const tagStats = getStatsForTag(hyp.tag);
+  const classifierScore = calibrationClassifier.predict(
+    confidence,
+    tagStats?.accuracy ?? 0.5,
+    tagStats?.verdicts ?? 0,
+    tagStats?.trusted ?? false
+  );
+  const blastRisk = serviceGraph.getBlastRisk(service);
+  const upstreamImpact = serviceGraph.getUpstreamImpact(service).length;
+  const serviceUnobserved = upstreamImpact === 0 && blastRisk === "low";
+  if (serviceUnobserved) {
+    logger.warn({ service }, "planning-gate: service has no observed spans \u2014 applying +10pp threshold as precaution");
+  }
+  const histSuccessRate = tagStats?.trusted ? tagStats.accuracy : null;
+  const recentPms = postmortemStore.getByTag(hyp.tag, 10).filter((pm) => pm.service === service).slice(0, 5);
+  const recentServiceSuccessRate = recentPms.length >= 3 ? recentPms.filter((pm) => pm.causallyCorrect).length / recentPms.length : null;
+  const recentServiceSamples = recentPms.length;
+  const blended = confidence * 0.6 + classifierScore * 0.4;
+  const adjustedConfidence = Math.round(blended * 1e3) / 1e3;
+  const unobservedDelta = serviceUnobserved ? 0.1 : 0;
+  const effectiveThreshold = executionThreshold + BLAST_RISK_THRESHOLD_DELTA[blastRisk] + unobservedDelta;
+  const signals = {
+    classifierScore: Math.round(classifierScore * 1e3) / 1e3,
+    upstreamImpact,
+    blastRisk,
+    histSuccessRate: histSuccessRate !== null ? Math.round(histSuccessRate * 1e3) / 1e3 : null,
+    recentServiceSuccessRate: recentServiceSuccessRate !== null ? Math.round(recentServiceSuccessRate * 1e3) / 1e3 : null,
+    recentServiceSamples
+  };
+  if (classifierScore < 0.5) {
+    return {
+      execute: false,
+      reason: `classifier gate: P(correct)=${(classifierScore * 100).toFixed(0)}% < 50% \u2014 hypothesis pattern does not match historical correct fixes`,
+      adjustedConfidence,
+      signals
+    };
+  }
+  if (adjustedConfidence < effectiveThreshold) {
+    return {
+      execute: false,
+      reason: `adjusted confidence ${(adjustedConfidence * 100).toFixed(0)}% < ${(effectiveThreshold * 100).toFixed(0)}% threshold (blast risk: ${blastRisk}, classifier: ${(classifierScore * 100).toFixed(0)}%)`,
+      adjustedConfidence,
+      signals
+    };
+  }
+  if (blastRisk === "high" && (histSuccessRate !== null && histSuccessRate < 0.6)) {
+    return {
+      execute: false,
+      reason: `high blast risk (${upstreamImpact} upstream services) + low historical success rate (${(histSuccessRate * 100).toFixed(0)}%) \u2014 requires manual approval`,
+      adjustedConfidence,
+      signals
+    };
+  }
+  if (recentServiceSuccessRate !== null && recentServiceSuccessRate < 0.3) {
+    return {
+      execute: false,
+      reason: `service-specific failure: last ${recentServiceSamples} (${hyp.tag}, ${service}) incidents resolved correctly only ${Math.round(recentServiceSuccessRate * 100)}% of the time \u2014 requires manual review`,
+      adjustedConfidence,
+      signals
+    };
+  }
+  return {
+    execute: true,
+    reason: `planning gate approved: adjusted confidence ${(adjustedConfidence * 100).toFixed(0)}%, classifier ${(classifierScore * 100).toFixed(0)}%, blast risk ${blastRisk}${recentServiceSuccessRate !== null ? `, service success ${Math.round(recentServiceSuccessRate * 100)}%` : ""}`,
+    adjustedConfidence,
+    signals
+  };
+}
+export {
+  planningGate
+};