mergen-server 1.4.0

package/dist/intelligence/postmortem-store.js

@@ -0,0 +1,596 @@
+import initSqlJs from "sql.js";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import { execSync } from "child_process";
+import { DATA_DIR, POSTMORTEMS_DB, zeroRetentionMode } from "../sensor/paths.js";
+import logger from "../sensor/logger.js";
+class PostmortemStore {
+  db = null;
+  /** Whether this sql.js build supports FTS5 — detected at init */
+  ftsAvailable = false;
+  resolveWasmPath() {
+    if (process.env.MERGEN_WASM_PATH) return process.env.MERGEN_WASM_PATH;
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const fromModule = path.resolve(moduleDir, "../../node_modules/sql.js/dist/sql-wasm.wasm");
+    if (fs.existsSync(fromModule)) return fromModule;
+    try {
+      const req = createRequire(import.meta.url);
+      const resolved = path.join(path.dirname(req.resolve("sql.js")), "sql-wasm.wasm");
+      if (fs.existsSync(resolved)) return resolved;
+    } catch {
+    }
+    return fromModule;
+  }
+  async init() {
+    if (zeroRetentionMode()) {
+      logger.info("postmortem store: zero-retention mode \u2014 no disk writes");
+      return;
+    }
+    try {
+      const wasmBinary = fs.readFileSync(this.resolveWasmPath());
+      const SQL = await initSqlJs({ wasmBinary });
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+      let fileBuffer;
+      if (fs.existsSync(POSTMORTEMS_DB)) {
+        try {
+          fileBuffer = fs.readFileSync(POSTMORTEMS_DB);
+        } catch {
+        }
+      }
+      this.db = fileBuffer ? new SQL.Database(fileBuffer) : new SQL.Database();
+      this.db.run(`
+        CREATE TABLE IF NOT EXISTS postmortems (
+          pid                   TEXT PRIMARY KEY,
+          tag                   TEXT NOT NULL DEFAULT '',
+          service               TEXT NOT NULL DEFAULT 'unknown',
+          git_sha               TEXT,
+          git_branch            TEXT,
+          root_cause            TEXT NOT NULL DEFAULT '',
+          fix_command           TEXT,
+          confidence            REAL NOT NULL DEFAULT 0,
+          mttr_ms               INTEGER,
+          resolved_autonomously INTEGER NOT NULL DEFAULT 0,
+          causally_correct      INTEGER NOT NULL DEFAULT 0,
+          generated_at          INTEGER NOT NULL,
+          body                  TEXT NOT NULL DEFAULT ''
+        );
+      `);
+      this.db.run(`CREATE INDEX IF NOT EXISTS pm_tag_idx ON postmortems (tag);`);
+      this.db.run(`CREATE INDEX IF NOT EXISTS pm_gen_idx  ON postmortems (generated_at DESC);`);
+      try {
+        this.db.run(`ALTER TABLE postmortems ADD COLUMN causally_correct INTEGER NOT NULL DEFAULT 0`);
+      } catch {
+      }
+      try {
+        this.db.run(`
+          CREATE VIRTUAL TABLE IF NOT EXISTS postmortems_fts USING fts5(
+            pid UNINDEXED,
+            content,
+            tokenize = 'porter ascii'
+          );
+        `);
+        this.db.run(`
+          INSERT INTO postmortems_fts (pid, content)
+          SELECT pm.pid,
+                 (pm.tag || ' ' || pm.service || ' ' || pm.root_cause ||
+                  ' ' || COALESCE(pm.fix_command, '') || ' ' || pm.body)
+          FROM postmortems pm
+          WHERE pm.pid NOT IN (SELECT pid FROM postmortems_fts);
+        `);
+        this.ftsAvailable = true;
+        logger.debug("FTS5 index initialised");
+      } catch (ftsErr) {
+        logger.warn({ ftsErr }, "FTS5 unavailable in this sql.js build \u2014 falling back to LIKE search");
+      }
+      this._flush();
+      logger.info({ path: POSTMORTEMS_DB }, "postmortem store initialised");
+    } catch (err) {
+      logger.warn({ err }, "postmortem store failed to init \u2014 running without persistence");
+    }
+  }
+  isWriting = false;
+  pendingWrite = false;
+  nextBuffer = null;
+  _flush() {
+    if (!this.db || zeroRetentionMode()) return;
+    try {
+      const data = this.db.export();
+      this.writeBufferAsync(Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+    } catch (err) {
+      logger.warn({ err }, "postmortem store flush failed");
+    }
+  }
+  writeBufferAsync(buf) {
+    if (this.isWriting) {
+      this.pendingWrite = true;
+      this.nextBuffer = buf;
+      return;
+    }
+    this.isWriting = true;
+    const tmp = `${POSTMORTEMS_DB}.tmp.${process.pid}`;
+    fs.writeFile(tmp, buf, (err) => {
+      if (err) {
+        logger.warn({ err }, "postmortem store async write failed");
+        this.isWriting = false;
+        this.processPendingWrite();
+        return;
+      }
+      fs.rename(tmp, POSTMORTEMS_DB, (renameErr) => {
+        if (renameErr) {
+          logger.warn({ err: renameErr }, "postmortem store async rename failed");
+        }
+        this.isWriting = false;
+        this.processPendingWrite();
+      });
+    });
+  }
+  processPendingWrite() {
+    if (this.pendingWrite && this.nextBuffer) {
+      this.pendingWrite = false;
+      const buf = this.nextBuffer;
+      this.nextBuffer = null;
+      this.writeBufferAsync(buf);
+    }
+  }
+  _row(cols, vals) {
+    const row = {};
+    cols.forEach((c, i) => {
+      row[c] = vals[i];
+    });
+    return {
+      pid: String(row.pid ?? ""),
+      tag: String(row.tag ?? ""),
+      service: String(row.service ?? "unknown"),
+      gitSha: row.git_sha ? String(row.git_sha) : null,
+      gitBranch: row.git_branch ? String(row.git_branch) : null,
+      rootCause: String(row.root_cause ?? ""),
+      fixCommand: row.fix_command ? String(row.fix_command) : null,
+      confidence: Number(row.confidence ?? 0),
+      mttrMs: row.mttr_ms != null ? Number(row.mttr_ms) : null,
+      resolvedAutonomously: Boolean(row.resolved_autonomously),
+      causallyCorrect: Boolean(row.causally_correct),
+      generatedAt: Number(row.generated_at ?? 0),
+      body: String(row.body ?? "")
+    };
+  }
+  write(pm) {
+    if (!this.db) return;
+    try {
+      this.db.run(
+        `INSERT OR REPLACE INTO postmortems
+          (pid, tag, service, git_sha, git_branch, root_cause, fix_command,
+           confidence, mttr_ms, resolved_autonomously, causally_correct, generated_at, body)
+         VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+        [
+          pm.pid,
+          pm.tag,
+          pm.service,
+          pm.gitSha,
+          pm.gitBranch,
+          pm.rootCause,
+          pm.fixCommand,
+          pm.confidence,
+          pm.mttrMs ?? null,
+          pm.resolvedAutonomously ? 1 : 0,
+          pm.causallyCorrect ? 1 : 0,
+          pm.generatedAt,
+          pm.body
+        ]
+      );
+      if (this.ftsAvailable) {
+        const content = [pm.tag, pm.service, pm.rootCause, pm.fixCommand ?? "", pm.body].join(" ");
+        this.db.run(
+          `INSERT OR REPLACE INTO postmortems_fts (pid, content) VALUES (?, ?)`,
+          [pm.pid, content]
+        );
+      }
+      this.invalidateTagStatsCache();
+      this._flush();
+      logger.debug({ pid: pm.pid, tag: pm.tag }, "postmortem written");
+    } catch (err) {
+      logger.warn({ err, pid: pm.pid }, "postmortem write failed");
+    }
+  }
+  /**
+   * BM25 keyword search via FTS5. Returns pids ranked by relevance.
+   * Falls back to LIKE search when FTS5 is unavailable.
+   */
+  keywordSearch(query, limit = 20) {
+    if (!this.db) return [];
+    const terms = query.replace(/[^\w\s_-]/g, " ").split(/\s+/).filter((t) => t.length >= 2).slice(0, 12);
+    if (terms.length === 0) return [];
+    if (this.ftsAvailable) {
+      try {
+        const ftsQuery = terms.join(" OR ");
+        const res = this.db.exec(
+          `SELECT pid, bm25(postmortems_fts) AS score
+           FROM postmortems_fts
+           WHERE postmortems_fts MATCH ?
+           ORDER BY score
+           LIMIT ?`,
+          [ftsQuery, limit]
+        );
+        if (!res[0]?.values) return [];
+        return res[0].values.map((v, i) => ({ pid: String(v[0]), rank: i }));
+      } catch (e) {
+        logger.debug({ e, query }, "FTS5 query failed \u2014 falling through to LIKE");
+      }
+    }
+    try {
+      const like = `%${terms[0]}%`;
+      const res = this.db.exec(
+        `SELECT pid FROM postmortems
+         WHERE root_cause LIKE ? OR body LIKE ? OR tag LIKE ?
+         ORDER BY generated_at DESC LIMIT ?`,
+        [like, like, like, limit]
+      );
+      if (!res[0]?.values) return [];
+      return res[0].values.map((v, i) => ({ pid: String(v[0]), rank: i }));
+    } catch {
+      return [];
+    }
+  }
+  getByTag(tag, limit = 20) {
+    if (!this.db) return [];
+    try {
+      const res = this.db.exec(
+        "SELECT * FROM postmortems WHERE tag=? ORDER BY generated_at DESC LIMIT ?",
+        [tag, limit]
+      );
+      if (!res[0]?.values) return [];
+      return res[0].values.map((v) => this._row(res[0].columns, v));
+    } catch {
+      return [];
+    }
+  }
+  list(limit = 50) {
+    if (!this.db) return [];
+    try {
+      const res = this.db.exec(
+        "SELECT * FROM postmortems ORDER BY generated_at DESC LIMIT ?",
+        [limit]
+      );
+      if (!res[0]?.values) return [];
+      return res[0].values.map((v) => this._row(res[0].columns, v));
+    } catch {
+      return [];
+    }
+  }
+  count() {
+    if (!this.db) return 0;
+    try {
+      const res = this.db.exec("SELECT COUNT(*) FROM postmortems");
+      return Number(res[0]?.values?.[0]?.[0] ?? 0);
+    } catch {
+      return 0;
+    }
+  }
+  knownServices(limit = 20) {
+    if (!this.db) return [];
+    try {
+      const res = this.db.exec(
+        `SELECT DISTINCT service FROM postmortems WHERE service != '' ORDER BY service LIMIT ?`,
+        [limit]
+      );
+      return (res[0]?.values ?? []).map((v) => String(v[0] ?? ""));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Returns the closest service name in the corpus via LIKE match.
+   * Used as a fallback when an exact service name lookup returns nothing —
+   * handles "api" vs "api-service" naming drift across teams.
+   * Returns null when no match is found.
+   */
+  fuzzyService(service) {
+    if (!this.db) return null;
+    try {
+      const res = this.db.exec(
+        `SELECT service, COUNT(*) AS cnt
+         FROM postmortems
+         WHERE service LIKE ?
+         GROUP BY service
+         ORDER BY cnt DESC
+         LIMIT 1`,
+        [`%${service}%`]
+      );
+      const val = res[0]?.values?.[0]?.[0];
+      return val ? String(val) : null;
+    } catch {
+      return null;
+    }
+  }
+  // 60-second cache for tagStats — called on every validateHypothesis() inside
+  // the agent pipeline. Without the cache this is a GROUP BY query per incident.
+  _tagStatsCache = null;
+  static TAG_STATS_TTL_MS = 6e4;
+  /** Tag-level stats for runbook and corpus reporting. Results are cached 60 s. */
+  tagStats() {
+    const now = Date.now();
+    if (this._tagStatsCache && now - this._tagStatsCache.cachedAt < PostmortemStore.TAG_STATS_TTL_MS) {
+      return this._tagStatsCache.data;
+    }
+    const data = this._computeTagStats();
+    this._tagStatsCache = { data, cachedAt: now };
+    return data;
+  }
+  invalidateTagStatsCache() {
+    this._tagStatsCache = null;
+  }
+  _computeTagStats() {
+    if (!this.db) return [];
+    try {
+      const res = this.db.exec(`
+        SELECT tag, COUNT(*) as cnt, AVG(mttr_ms) as avg_mttr, MAX(generated_at) as last_at
+        FROM postmortems
+        GROUP BY tag
+        ORDER BY cnt DESC
+      `);
+      if (!res[0]?.values) return [];
+      return res[0].values.map((v) => ({
+        tag: String(v[0] ?? ""),
+        count: Number(v[1] ?? 0),
+        avgMttrMs: v[2] != null ? Number(v[2]) : null,
+        lastAt: Number(v[3] ?? 0)
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Look up the resolution history of a specific fix command (or a LIKE pattern).
+   * Used by check_fix_history to answer: "has this fix worked before, and how often?"
+   *
+   * Groups by (fix_command, service) so callers can see per-service success rates
+   * for commands that span multiple services (e.g. `kubectl rollout restart`).
+   */
+  lookupFixHistory(command, service) {
+    if (!this.db) return [];
+    try {
+      const likePattern = `%${command.replace(/%/g, "\\%").replace(/_/g, "\\_")}%`;
+      const sql = service ? `SELECT fix_command, service,
+                  COUNT(*)                AS times_applied,
+                  SUM(causally_correct)   AS times_resolved,
+                  AVG(mttr_ms)            AS avg_mttr,
+                  MAX(generated_at)       AS last_used
+           FROM postmortems
+           WHERE fix_command LIKE ? AND service = ?
+           GROUP BY fix_command, service
+           ORDER BY times_applied DESC
+           LIMIT 10` : `SELECT fix_command, service,
+                  COUNT(*)                AS times_applied,
+                  SUM(causally_correct)   AS times_resolved,
+                  AVG(mttr_ms)            AS avg_mttr,
+                  MAX(generated_at)       AS last_used
+           FROM postmortems
+           WHERE fix_command LIKE ?
+           GROUP BY fix_command, service
+           ORDER BY times_applied DESC
+           LIMIT 10`;
+      const params = service ? [likePattern, service] : [likePattern];
+      const res = this.db.exec(sql, params);
+      if (!res[0]?.values) return [];
+      return res[0].values.map((v) => ({
+        fixCommand: String(v[0] ?? ""),
+        service: String(v[1] ?? "unknown"),
+        timesApplied: Number(v[2] ?? 0),
+        timesResolved: Number(v[3] ?? 0),
+        avgMttrMs: v[4] != null ? Number(v[4]) : null,
+        lastUsedAt: Number(v[5] ?? 0)
+      }));
+    } catch (err) {
+      logger.warn({ err, command }, "postmortem store lookupFixHistory failed");
+      return [];
+    }
+  }
+  /**
+   * Per-service aggregated profile for the explain_service tool.
+   * All three queries run directly against SQLite — zero LLM latency.
+   */
+  serviceProfile(service) {
+    const empty = { totalIncidents: 0, firstSeenAt: null, lastSeenAt: null, failureModes: [], topFixCommands: [] };
+    if (!this.db) return empty;
+    try {
+      const summaryRes = this.db.exec(
+        `SELECT COUNT(*), MIN(generated_at), MAX(generated_at) FROM postmortems WHERE service=?`,
+        [service]
+      );
+      const sumRow = summaryRes[0]?.values?.[0];
+      const totalIncidents = sumRow ? Number(sumRow[0] ?? 0) : 0;
+      if (totalIncidents === 0) return empty;
+      const modesRes = this.db.exec(
+        `SELECT tag,
+                COUNT(*)                                    AS freq,
+                AVG(mttr_ms)                               AS avg_mttr,
+                MAX(generated_at)                          AS last_seen,
+                SUM(resolved_autonomously)                 AS auto_count,
+                (SELECT fix_command FROM postmortems p2
+                 WHERE p2.service=p1.service AND p2.tag=p1.tag
+                   AND p2.fix_command IS NOT NULL
+                 ORDER BY p2.generated_at DESC LIMIT 1)   AS top_fix
+         FROM postmortems p1
+         WHERE service=?
+         GROUP BY tag
+         ORDER BY freq DESC
+         LIMIT 5`,
+        [service]
+      );
+      const failureModes = (modesRes[0]?.values ?? []).map((v) => ({
+        tag: String(v[0] ?? ""),
+        frequency: Number(v[1] ?? 0),
+        avgMttrMs: v[2] != null ? Number(v[2]) : null,
+        lastSeenAt: Number(v[3] ?? 0),
+        autonomousRate: Number(v[1] ?? 1) > 0 ? Math.round(Number(v[4] ?? 0) / Number(v[1] ?? 1) * 100) : 0,
+        topFixCommand: v[5] ? String(v[5]) : null
+      }));
+      const fixRes = this.db.exec(
+        `SELECT fix_command, COUNT(*) AS times_applied
+         FROM postmortems
+         WHERE service=? AND fix_command IS NOT NULL
+         GROUP BY fix_command
+         ORDER BY times_applied DESC
+         LIMIT 3`,
+        [service]
+      );
+      const topFixCommands = (fixRes[0]?.values ?? []).map((v) => ({
+        command: String(v[0] ?? ""),
+        timesApplied: Number(v[1] ?? 0)
+      }));
+      return {
+        totalIncidents,
+        firstSeenAt: sumRow && sumRow[1] != null ? Number(sumRow[1]) : null,
+        lastSeenAt: sumRow && sumRow[2] != null ? Number(sumRow[2]) : null,
+        failureModes,
+        topFixCommands
+      };
+    } catch (err) {
+      logger.warn({ err, service }, "postmortem store serviceProfile failed");
+      return empty;
+    }
+  }
+  /**
+   * Count of postmortems where autopilot ran (resolved_autonomously=1) but
+   * causal verification is missing (causally_correct=0). This includes:
+   *   - Rows written before the causallyCorrect fix was deployed (DEFAULT 0)
+   *   - Post-fix rows where the error rate did not verifiably drop
+   *
+   * Used only by the startup diagnostic — not surfaced as a metric.
+   * Returns 0 when the DB is not initialized.
+   */
+  countUnverifiedAutonomous() {
+    if (!this.db) return 0;
+    try {
+      const res = this.db.exec(
+        `SELECT COUNT(*) FROM postmortems WHERE resolved_autonomously=1 AND causally_correct=0`
+      );
+      return Number(res[0]?.values?.[0]?.[0] ?? 0);
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Total MTTR saved vs. the baseline average manual MTTR (for outcome billing).
+   * Returns null if there are fewer than 3 samples.
+   */
+  totalMttrSavedMs(autonomousMttrMs = 12e4) {
+    if (!this.db) return null;
+    try {
+      const res = this.db.exec(
+        `SELECT SUM(mttr_ms - ?) FROM postmortems WHERE resolved_autonomously=1 AND mttr_ms > ?`,
+        [autonomousMttrMs, autonomousMttrMs]
+      );
+      const val = res[0]?.values?.[0]?.[0];
+      return val != null ? Number(val) : null;
+    } catch {
+      return null;
+    }
+  }
+  /** Returns true when the SQLite database initialised successfully. */
+  isHealthy() {
+    return this.db !== null;
+  }
+}
+const postmortemStore = new PostmortemStore();
+function detectGitSha() {
+  try {
+    return execSync("git rev-parse HEAD", { stdio: "pipe", timeout: 2e3 }).toString().trim().slice(0, 12);
+  } catch {
+    return null;
+  }
+}
+function detectGitBranch() {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", { stdio: "pipe", timeout: 2e3 }).toString().trim();
+  } catch {
+    return null;
+  }
+}
+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 generatePostmortem(input) {
+  const now = Date.now();
+  const gitSha = detectGitSha();
+  const gitBranch = detectGitBranch();
+  const mttrLabel = input.mttrMs != null ? fmtMs(input.mttrMs) : "unknown";
+  const evidenceSection = input.evidence?.length ? `## Evidence
+
+${input.evidence.map((e) => `- ${e}`).join("\n")}
+
+` : "";
+  const fixSection = input.fixCommand ? `## Fix Applied
+
+\`\`\`
+${input.fixCommand}
+\`\`\`
+
+` : input.fixHint ? `## Fix Applied
+
+${input.fixHint}
+
+` : "";
+  const headerLine = gitBranch ? `**Branch:** ${gitBranch}  |  **SHA:** ${gitSha ?? "unknown"}` : "";
+  const relatedPrior = postmortemStore.getByTag(input.tag, 10).filter((pm2) => pm2.pid !== input.pid && pm2.service === input.service).slice(0, 3);
+  const relatedSection = relatedPrior.length > 0 ? [
+    "## Related Past Incidents (same failure mode, same service)",
+    "",
+    ...relatedPrior.map((pm2) => {
+      const date = new Date(pm2.generatedAt).toISOString().slice(0, 10);
+      const mttr = pm2.mttrMs != null ? fmtMs(pm2.mttrMs) : "unknown";
+      const how = pm2.resolvedAutonomously ? "\u{1F916} autonomous" : "\u{1F464} manual";
+      return `- [${date}] MTTR: ${mttr} \xB7 ${how} \xB7 ${pm2.rootCause.slice(0, 100)}`;
+    }),
+    "",
+    relatedPrior.length > 1 ? `_Recurring pattern detected (${relatedPrior.length + 1} incidents). Consider a systemic fix rather than a one-off patch._` : "",
+    ""
+  ].filter(Boolean).join("\n") : "";
+  const body = [
+    `# Postmortem \u2014 ${input.tag.replace(/^infra_/, "")}`,
+    "",
+    `**Service:** ${input.service}  |  **Date:** ${new Date(now).toISOString().slice(0, 10)}`,
+    `**Confidence:** ${Math.round(input.confidence * 100)}%  |  **MTTR:** ${mttrLabel}`,
+    `**Resolution:** ${input.resolvedAutonomously ? "Autonomous (Mergen)" : "Manual"}`,
+    headerLine,
+    "",
+    "## Root Cause",
+    "",
+    input.rootCause,
+    "",
+    evidenceSection,
+    fixSection,
+    "## Timeline",
+    "",
+    "- Incident detected and triaged by Mergen",
+    input.resolvedAutonomously ? `- Fix executed autonomously \u2014 RESOLVED in ${mttrLabel}` : `- Fix applied manually \u2014 RESOLVED in ${mttrLabel}`,
+    "",
+    relatedSection
+  ].filter((l) => l !== void 0).join("\n");
+  const pm = {
+    pid: input.pid,
+    tag: input.tag,
+    service: input.service,
+    gitSha,
+    gitBranch,
+    rootCause: input.rootCause,
+    fixCommand: input.fixCommand,
+    confidence: input.confidence,
+    mttrMs: input.mttrMs,
+    resolvedAutonomously: input.resolvedAutonomously,
+    causallyCorrect: input.causallyCorrect ?? false,
+    generatedAt: now,
+    body
+  };
+  postmortemStore.write(pm);
+  logger.info({ pid: pm.pid, tag: pm.tag, mttrMs: pm.mttrMs }, "postmortem generated");
+  return pm;
+}
+export {
+  generatePostmortem,
+  postmortemStore
+};

package/dist/intelligence/pr-commenter.js

@@ -0,0 +1,81 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { recordHabituationEvent } from "../sensor/habituation-store.js";
+import logger from "../sensor/logger.js";
+const COMMENT_THRESHOLD = 0.85;
+const _commented = /* @__PURE__ */ new Set();
+function hasMergenComment(repoAndPr) {
+  return _commented.has(repoAndPr);
+}
+function loadGitHubToken() {
+  if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN;
+  try {
+    const cfgPath = path.join(os.homedir(), ".mergen", "config.json");
+    const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+    const gh = cfg.github ?? {};
+    if (typeof gh.token === "string" && gh.token) return gh.token;
+  } catch {
+  }
+  return "";
+}
+async function postGitHubComment(repo, prNumber, body, token) {
+  const res = await fetch(`https://api.github.com/repos/${repo}/issues/${prNumber}/comments`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github+json",
+      "Content-Type": "application/json",
+      "X-GitHub-Api-Version": "2022-11-28"
+    },
+    body: JSON.stringify({ body }),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`GitHub API ${res.status}: ${text.slice(0, 120)}`);
+  }
+}
+async function maybePostPRComment(result) {
+  if (process.env.MERGEN_PR_COMMENTS !== "true") return;
+  if (!result.wouldHaveShown) return;
+  if (result.relevanceScore < COMMENT_THRESHOLD) return;
+  if (!result.wouldHaveComment) return;
+  const key = `${result.repo}#${result.prNumber}`;
+  if (_commented.has(key)) return;
+  const token = loadGitHubToken();
+  if (!token) {
+    logger.warn(
+      { prId: result.prId },
+      "pr-commenter: MERGEN_PR_COMMENTS=true but no GitHub token \u2014 set GITHUB_TOKEN or run: mergen-server connect github"
+    );
+    return;
+  }
+  _commented.add(key);
+  const liveComment = result.wouldHaveComment.replace(
+    /\n_\[Mergen shadow mode — not posted yet\]_\n?/,
+    "\n"
+  );
+  try {
+    await postGitHubComment(result.repo, result.prNumber, liveComment, token);
+    logger.info(
+      { prId: result.prId, score: result.relevanceScore },
+      "pr-commenter: comment posted"
+    );
+    recordHabituationEvent({
+      recordedAt: Date.now(),
+      eventType: "comment_posted",
+      actor: result.author,
+      repo: result.repo,
+      prNumber: result.prNumber,
+      relevanceScore: result.relevanceScore
+    });
+  } catch (err) {
+    _commented.delete(key);
+    logger.warn({ err, prId: result.prId }, "pr-commenter: post failed");
+  }
+}
+export {
+  hasMergenComment,
+  maybePostPRComment
+};