mergen-server 1.4.0

package/dist/sensor/docker-monitor.js

@@ -0,0 +1,122 @@
+import { spawn } from "child_process";
+import fs from "fs";
+import { store } from "./buffer.js";
+import logger from "./logger.js";
+const HEAP_CHECK_INTERVAL_MS = 3e4;
+const HEAP_WARN_MARGIN_BYTES = 40 * 1024 * 1024;
+function readCgroupMemoryLimit() {
+  try {
+    const v2 = fs.readFileSync("/sys/fs/cgroup/memory.max", "utf8").trim();
+    if (v2 !== "max") return parseInt(v2, 10);
+  } catch {
+  }
+  try {
+    const v1 = fs.readFileSync("/sys/fs/cgroup/memory/memory.limit_in_bytes", "utf8").trim();
+    const limit = parseInt(v1, 10);
+    if (limit > 0 && limit < 9e18) return limit;
+  } catch {
+  }
+  return null;
+}
+let _heapTimer = null;
+let _lastHeapWarnAt = 0;
+function startHeapMonitor() {
+  if (_heapTimer) return;
+  const limit = readCgroupMemoryLimit();
+  if (!limit) return;
+  const limitMb = Math.round(limit / 1024 / 1024);
+  logger.info({ limitMb }, "container memory limit detected \u2014 starting heap monitor");
+  _heapTimer = setInterval(() => {
+    const { rss } = process.memoryUsage();
+    const headroom = limit - rss;
+    if (headroom < HEAP_WARN_MARGIN_BYTES) {
+      const now = Date.now();
+      if (now - _lastHeapWarnAt < 5 * 6e4) return;
+      _lastHeapWarnAt = now;
+      const rssMb = Math.round(rss / 1024 / 1024);
+      const headroomMb = Math.round(headroom / 1024 / 1024);
+      logger.warn({ rssMb, limitMb, headroomMb }, "heap approaching container memory limit \u2014 OOM risk");
+      const event = {
+        type: "process_exit",
+        process: "current-process",
+        exitCode: -1,
+        reason: "oom",
+        memoryLimitBytes: limit,
+        timestamp: now
+      };
+      store.push(event);
+    }
+  }, HEAP_CHECK_INTERVAL_MS);
+  if (typeof _heapTimer.unref === "function") _heapTimer.unref();
+}
+function stopHeapMonitor() {
+  if (_heapTimer) {
+    clearInterval(_heapTimer);
+    _heapTimer = null;
+  }
+}
+let _dockerProc = null;
+function startDockerMonitor() {
+  if (_dockerProc) return;
+  try {
+    _dockerProc = spawn(
+      "docker",
+      ["events", "--filter", "event=oom", "--filter", "event=die", "--format", "{{json .}}"],
+      { stdio: ["ignore", "pipe", "ignore"] }
+    );
+  } catch {
+    return;
+  }
+  if (!_dockerProc.stdout) return;
+  let buffer = "";
+  _dockerProc.stdout.on("data", (chunk) => {
+    buffer += chunk.toString();
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const ev = JSON.parse(trimmed);
+        if (ev.Action === "oom" || ev.Action === "die" && ev.Actor?.Attributes?.exitCode === "137") {
+          const containerName = ev.Actor?.Attributes?.name ?? ev.Actor?.ID?.slice(0, 12) ?? "unknown";
+          logger.warn({ containerName, action: ev.Action }, "Docker OOM kill detected");
+          const event = {
+            type: "process_exit",
+            process: containerName,
+            exitCode: 137,
+            reason: "oom",
+            signal: "SIGKILL",
+            timestamp: (ev.time ?? Date.now() / 1e3) * 1e3
+          };
+          store.push(event);
+        }
+      } catch {
+      }
+    }
+  });
+  _dockerProc.on("error", () => {
+    _dockerProc = null;
+  });
+  _dockerProc.on("exit", (code) => {
+    if (code !== 0 && code !== null) {
+      logger.debug({ code }, "docker events process exited");
+    }
+    _dockerProc = null;
+  });
+  logger.info("Docker OOM monitor started");
+}
+function stopDockerMonitor() {
+  if (_dockerProc) {
+    _dockerProc.stdout?.destroy();
+    _dockerProc.kill();
+    _dockerProc = null;
+  }
+  stopHeapMonitor();
+}
+export {
+  startDockerMonitor,
+  startHeapMonitor,
+  stopDockerMonitor,
+  stopHeapMonitor
+};

package/dist/sensor/extended-buffer.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+const ComponentTreeNodeSchema = z.object({
+  name: z.string(),
+  type: z.string(),
+  // 'React' | 'Vue' | 'Vue3'
+  props: z.record(z.unknown()).optional(),
+  state: z.record(z.unknown()).optional(),
+  children: z.array(z.lazy(() => ComponentTreeNodeSchema)).optional()
+});
+const StateDiffSchema = z.object({
+  framework: z.string(),
+  // 'Redux' | 'Zustand' | 'Jotai' | 'MobX'
+  before: z.unknown().optional(),
+  after: z.unknown().optional(),
+  field: z.string().optional(),
+  timestamp: z.number()
+});
+const PerformanceTraceSchema = z.object({
+  entryType: z.string(),
+  // 'long-task' | 'layout-shift' | 'paint' | 'navigation'
+  name: z.string(),
+  startTime: z.number(),
+  duration: z.number(),
+  metadata: z.record(z.unknown()).optional()
+});
+const ExtendedContextSnapshotSchema = z.object({
+  type: z.literal("context"),
+  trigger: z.enum(["error", "warn", "pageload", "hmr", "baseline", "manual"]),
+  timestamp: z.number(),
+  url: z.string(),
+  title: z.string(),
+  activeElement: z.string().optional(),
+  component: z.string().optional(),
+  localStorage: z.record(z.string()).default({}),
+  sessionStorage: z.record(z.string()).default({}),
+  // Layer 1 extensions
+  componentTree: ComponentTreeNodeSchema.optional(),
+  stateDiff: StateDiffSchema.optional(),
+  performanceTrace: z.array(PerformanceTraceSchema).optional()
+});
+export {
+  ComponentTreeNodeSchema,
+  ExtendedContextSnapshotSchema,
+  PerformanceTraceSchema,
+  StateDiffSchema
+};

package/dist/sensor/feedback-token.js

@@ -0,0 +1,41 @@
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { DATA_DIR } from "./paths.js";
+const TOKEN_FILE = path.join(DATA_DIR, "feedback-secret");
+const TOKEN_LEN = 32;
+let _secret = "";
+function getSecret() {
+  if (_secret) return _secret;
+  try {
+    const s = fs.readFileSync(TOKEN_FILE, "utf8").trim();
+    if (s.length >= 64) {
+      _secret = s;
+      return _secret;
+    }
+  } catch {
+  }
+  _secret = crypto.randomBytes(32).toString("hex");
+  try {
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+    fs.writeFileSync(TOKEN_FILE, _secret, { mode: 384 });
+  } catch {
+  }
+  return _secret;
+}
+function generateFeedbackToken(id, correct) {
+  return crypto.createHmac("sha256", getSecret()).update(`${id}:${correct}`).digest("hex").slice(0, TOKEN_LEN);
+}
+function verifyFeedbackToken(id, correct, token) {
+  if (!token || token.length !== TOKEN_LEN) return false;
+  const expected = generateFeedbackToken(id, correct);
+  try {
+    return crypto.timingSafeEqual(Buffer.from(token, "hex"), Buffer.from(expected, "hex"));
+  } catch {
+    return false;
+  }
+}
+export {
+  generateFeedbackToken,
+  verifyFeedbackToken
+};

package/dist/sensor/file-lock.js

@@ -0,0 +1,6 @@
+function lockAndExecute(_lockFilePath, fn) {
+  return fn();
+}
+export {
+  lockAndExecute
+};

package/dist/sensor/fs-watcher.js

@@ -0,0 +1,106 @@
+import fs from "fs";
+import { store } from "./buffer.js";
+import { getRecords, recordVerdict } from "../intelligence/calibration.js";
+import logger from "./logger.js";
+const SETTLE_DELAY_MS = 2e3;
+let _state = null;
+function startFileWatch(opts) {
+  if (_state) stopFileWatch();
+  const watchers = [];
+  for (const p of opts.paths) {
+    try {
+      const recursive = p.endsWith("/") || !/\.[^/\\]+$/.test(p);
+      const watcher = fs.watch(p, { recursive }, () => {
+        if (!_state) return;
+        _state.lastChangedAt = Date.now();
+        scheduleValidation();
+      });
+      watcher.on("error", (err) => logger.warn({ path: p, err }, "fs-watcher: watch error"));
+      watchers.push(watcher);
+    } catch (err) {
+      logger.warn({ path: p, err }, "fs-watcher: could not watch path \u2014 skipping");
+    }
+  }
+  _state = {
+    pid: opts.pid,
+    since: opts.since,
+    paths: opts.paths,
+    watchers,
+    lastChangedAt: null,
+    validateTimer: null,
+    lastValidation: null
+  };
+  logger.info({ paths: opts.paths.length, pid: opts.pid }, "fs-watcher: started");
+}
+function scheduleValidation() {
+  if (!_state) return;
+  if (_state.validateTimer) clearTimeout(_state.validateTimer);
+  _state.validateTimer = setTimeout(runValidation, SETTLE_DELAY_MS);
+  if (typeof _state.validateTimer.unref === "function") _state.validateTimer.unref();
+}
+function runValidation() {
+  if (!_state) return;
+  const { pid, since } = _state;
+  const windowStart = since - 6e4;
+  const logsBefore = store.getLogs(200, "error", windowStart).filter((e) => e.timestamp < since);
+  const netBefore = store.getNetwork(200, void 0, windowStart).filter((e) => e.timestamp < since && (e.status >= 400 || !!e.error));
+  const logsAfter = store.getLogs(200, "error", since);
+  const netAfter = store.getNetwork(200, void 0, since).filter((e) => e.status >= 400 || !!e.error);
+  const errsBefore = logsBefore.length + netBefore.length;
+  const errsAfter = logsAfter.length + netAfter.length;
+  let verdict;
+  let status;
+  if (errsAfter === 0) {
+    verdict = "correct";
+    status = errsBefore > 0 ? "RESOLVED" : "CLEAN";
+  } else if (errsBefore > 0 && errsAfter < errsBefore * 0.5) {
+    verdict = "partial";
+    status = "PARTIAL";
+  } else {
+    verdict = "wrong";
+    status = errsAfter > errsBefore ? "REGRESSED" : "UNRESOLVED";
+  }
+  const records = getRecords();
+  const prediction = records.find((r) => r.pid === pid);
+  if (prediction && !prediction.verdict) recordVerdict(pid, verdict);
+  const result = { verdict, errsBefore, errsAfter, status, timestamp: Date.now() };
+  if (_state) _state.lastValidation = result;
+  store.push({
+    type: "terminal",
+    terminalName: "mergen:validate",
+    data: `[fix-validation] verdict=${verdict} before=${errsBefore} after=${errsAfter} pid=${pid}`,
+    timestamp: Date.now()
+  });
+  logger.info({ pid, verdict, errsBefore, errsAfter }, "fs-watcher: validation complete");
+  if (verdict === "correct") {
+    const t = setTimeout(stopFileWatch, 200);
+    if (typeof t.unref === "function") t.unref();
+  }
+}
+function stopFileWatch() {
+  if (!_state) return;
+  if (_state.validateTimer) clearTimeout(_state.validateTimer);
+  for (const w of _state.watchers) {
+    try {
+      w.close();
+    } catch {
+    }
+  }
+  logger.info({ pid: _state.pid }, "fs-watcher: stopped");
+  _state = null;
+}
+function getWatchState() {
+  if (!_state) return null;
+  return {
+    pid: _state.pid,
+    since: _state.since,
+    paths: _state.paths,
+    lastChangedAt: _state.lastChangedAt,
+    lastValidation: _state.lastValidation
+  };
+}
+export {
+  getWatchState,
+  startFileWatch,
+  stopFileWatch
+};

package/dist/sensor/gate-heartbeat.js

@@ -0,0 +1,122 @@
+import fs from "fs";
+import { DATA_DIR, zeroRetentionMode } from "./paths.js";
+import logger from "./logger.js";
+const GATE_HEARTBEAT_FILE = `${DATA_DIR}/gate-heartbeat.json`;
+const DEFAULT_INTERVAL_MS = 2e3;
+const DEFAULT_MAX_AGE_MS = 1e4;
+let _lastBeatAt = 0;
+let _startedAt = 0;
+let _handle = null;
+function heartbeatIntervalMs() {
+  const raw = Number(process.env.MERGEN_GATE_HEARTBEAT_INTERVAL_MS);
+  return Number.isFinite(raw) && raw >= 250 ? raw : DEFAULT_INTERVAL_MS;
+}
+function gateHeartbeatMaxAgeMs() {
+  const raw = Number(process.env.MERGEN_GATE_HEARTBEAT_MAX_AGE_MS);
+  return Number.isFinite(raw) && raw >= 1e3 ? raw : DEFAULT_MAX_AGE_MS;
+}
+function requireGateHeartbeat() {
+  return process.env.MERGEN_REQUIRE_GATE_HEARTBEAT === "true";
+}
+function writeBeat(now = Date.now()) {
+  _lastBeatAt = now;
+  if (_startedAt === 0) _startedAt = now;
+  if (zeroRetentionMode()) return;
+  try {
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+    const payload = {
+      version: 1,
+      pid: process.pid,
+      startedAt: _startedAt,
+      lastBeatAt: now
+    };
+    const tmp = `${GATE_HEARTBEAT_FILE}.tmp.${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify(payload), { encoding: "utf8", mode: 384 });
+    fs.renameSync(tmp, GATE_HEARTBEAT_FILE);
+  } catch (err) {
+    logger.warn({ err }, "gate-heartbeat: failed to write heartbeat");
+  }
+}
+function startGateHeartbeat() {
+  if (_handle) return stopGateHeartbeat;
+  writeBeat();
+  _handle = setInterval(() => writeBeat(), heartbeatIntervalMs());
+  _handle.unref();
+  logger.info({ maxAgeMs: gateHeartbeatMaxAgeMs() }, "gate-heartbeat: started");
+  return stopGateHeartbeat;
+}
+function stopGateHeartbeat() {
+  if (_handle) {
+    clearInterval(_handle);
+    _handle = null;
+  }
+}
+function getGateHeartbeatStatus(now = Date.now()) {
+  const maxAgeMs = gateHeartbeatMaxAgeMs();
+  let lastBeatAt = _lastBeatAt;
+  if (!zeroRetentionMode() && fs.existsSync(GATE_HEARTBEAT_FILE)) {
+    try {
+      const raw = JSON.parse(fs.readFileSync(GATE_HEARTBEAT_FILE, "utf8"));
+      if (raw.version === 1 && typeof raw.lastBeatAt === "number") {
+        lastBeatAt = Math.max(lastBeatAt, raw.lastBeatAt);
+      }
+    } catch {
+      return {
+        ok: false,
+        required: requireGateHeartbeat(),
+        lastBeatAt: lastBeatAt || null,
+        ageMs: lastBeatAt ? now - lastBeatAt : null,
+        maxAgeMs,
+        reason: "gate heartbeat file is unreadable"
+      };
+    }
+  }
+  if (!lastBeatAt) {
+    return {
+      ok: false,
+      required: requireGateHeartbeat(),
+      lastBeatAt: null,
+      ageMs: null,
+      maxAgeMs,
+      reason: "gate heartbeat has not started"
+    };
+  }
+  const ageMs = now - lastBeatAt;
+  if (ageMs > maxAgeMs) {
+    return {
+      ok: false,
+      required: requireGateHeartbeat(),
+      lastBeatAt,
+      ageMs,
+      maxAgeMs,
+      reason: `gate heartbeat is stale (${ageMs}ms > ${maxAgeMs}ms)`
+    };
+  }
+  return {
+    ok: true,
+    required: requireGateHeartbeat(),
+    lastBeatAt,
+    ageMs,
+    maxAgeMs
+  };
+}
+function assertGateHeartbeatFresh() {
+  if (!requireGateHeartbeat()) return { ok: true };
+  const status = getGateHeartbeatStatus();
+  return status.ok ? { ok: true } : { ok: false, reason: status.reason ?? "gate heartbeat is not fresh" };
+}
+function _resetGateHeartbeatForTesting(lastBeatAt = 0) {
+  stopGateHeartbeat();
+  _startedAt = lastBeatAt;
+  _lastBeatAt = lastBeatAt;
+}
+export {
+  GATE_HEARTBEAT_FILE,
+  _resetGateHeartbeatForTesting,
+  assertGateHeartbeatFresh,
+  gateHeartbeatMaxAgeMs,
+  getGateHeartbeatStatus,
+  requireGateHeartbeat,
+  startGateHeartbeat,
+  stopGateHeartbeat
+};

package/dist/sensor/git-suspect.js

@@ -0,0 +1,136 @@
+import { execFile } from "child_process";
+import fs from "fs";
+import path from "path";
+import { promisify } from "util";
+const execFileAsync = promisify(execFile);
+const CONVENTIONAL_HIGH = /^(feat|fix|refactor|perf)(\(.*?\))?!?:/;
+const CONVENTIONAL_LOW = /^(chore|style|docs|ci|build|test)(\(.*?\))?!?:/;
+async function findSuspectCommit(filePath, line, cwd) {
+  try {
+    const rel = path.isAbsolute(filePath) ? path.relative(cwd, filePath) : filePath;
+    const { stdout: blameOut } = await execFileAsync(
+      "git",
+      ["blame", `-L${line},${line}`, "--porcelain", rel],
+      { cwd, timeout: 5e3 }
+    );
+    const sha = blameOut.slice(0, 40);
+    if (!sha || sha === "0".repeat(40)) return null;
+    const lines = blameOut.split("\n");
+    const get = (prefix) => lines.find((l) => l.startsWith(prefix))?.slice(prefix.length).trim() ?? "";
+    const author = get("author ");
+    const authorEmail = get("author-mail").replace(/[<>]/g, "");
+    const summary = get("summary");
+    const tsStr = get("author-time");
+    const timestamp = tsStr ? parseInt(tsStr, 10) * 1e3 : 0;
+    let causalWeight = "medium";
+    if (CONVENTIONAL_HIGH.test(summary)) causalWeight = "high";
+    else if (CONVENTIONAL_LOW.test(summary)) causalWeight = "low";
+    let hasLocalDiff = false;
+    let localDiffStat = "";
+    try {
+      const { stdout: diffOut } = await execFileAsync(
+        "git",
+        ["diff", "HEAD", "--stat", "--", rel],
+        { cwd, timeout: 3e3 }
+      );
+      hasLocalDiff = diffOut.trim().length > 0;
+      const statLine = diffOut.trim().split("\n").pop() ?? "";
+      localDiffStat = statLine.replace(/\s+\|\s+.*/, "").trim();
+    } catch {
+    }
+    return {
+      sha,
+      shortSha: sha.slice(0, 8),
+      author,
+      authorEmail,
+      summary,
+      timestamp,
+      causalWeight,
+      hasLocalDiff,
+      localDiffStat
+    };
+  } catch {
+    return null;
+  }
+}
+const _coCache = /* @__PURE__ */ new Map();
+function _loadCodeowners(cwd) {
+  const candidates = [
+    path.join(cwd, ".github", "CODEOWNERS"),
+    path.join(cwd, "CODEOWNERS"),
+    path.join(cwd, "docs", "CODEOWNERS")
+  ];
+  for (const p of candidates) {
+    try {
+      const stat = fs.statSync(p);
+      const cached = _coCache.get(p);
+      if (cached && cached.mtime === stat.mtimeMs) return cached.parsed;
+      const lines = fs.readFileSync(p, "utf8").split("\n");
+      const parsed = [];
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const parts = trimmed.split(/\s+/);
+        if (parts.length < 2) continue;
+        parsed.push({ pattern: parts[0], owners: parts.slice(1) });
+      }
+      parsed.reverse();
+      _coCache.set(p, { parsed, mtime: stat.mtimeMs });
+      return parsed;
+    } catch {
+    }
+  }
+  return null;
+}
+function _matchesPattern(filePath, pattern) {
+  const fp = filePath.replace(/\\/g, "/");
+  const pat = pattern.replace(/\\/g, "/");
+  if (pat.endsWith("/")) return fp.startsWith(pat.slice(1)) || fp.startsWith(pat);
+  if (pat.includes("*")) {
+    const escaped = pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*");
+    return new RegExp(escaped + "$").test(fp) || new RegExp(escaped + "$").test(fp.split("/").pop() ?? "");
+  }
+  return fp === pat || fp === pat.replace(/^\//, "") || fp.endsWith("/" + pat) || fp.startsWith(pat + "/") || fp.startsWith(pat.replace(/^\//, "") + "/");
+}
+function findCodeOwners(filePath, cwd) {
+  try {
+    const rules = _loadCodeowners(cwd);
+    if (!rules) return null;
+    const rel = path.isAbsolute(filePath) ? path.relative(cwd, filePath) : filePath;
+    const normalised = rel.replace(/\\/g, "/");
+    for (const rule of rules) {
+      if (_matchesPattern(normalised, rule.pattern)) {
+        const source = [".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS"].find((f) => {
+          try {
+            fs.statSync(path.join(cwd, f));
+            return true;
+          } catch {
+            return false;
+          }
+        }) ?? "CODEOWNERS";
+        return { owners: rule.owners, pattern: rule.pattern, source };
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function getLocalDiff(filePath, cwd) {
+  try {
+    const rel = path.isAbsolute(filePath) ? path.relative(cwd, filePath) : filePath;
+    const { stdout } = await execFileAsync(
+      "git",
+      ["diff", "HEAD", "--", rel],
+      { cwd, timeout: 5e3 }
+    );
+    return stdout.slice(0, 3e3);
+  } catch {
+    return "";
+  }
+}
+export {
+  findCodeOwners,
+  findSuspectCommit,
+  getLocalDiff
+};

package/dist/sensor/habituation-store.js

@@ -0,0 +1,77 @@
+import fs from "fs";
+import path from "path";
+import { DATA_DIR, zeroRetentionMode } from "./paths.js";
+import logger from "./logger.js";
+const HABITUATION_FILE = path.join(DATA_DIR, "habituation.json");
+const MAX_EVENTS = 1e3;
+let _events = [];
+let _loaded = false;
+function load() {
+  if (_loaded) return;
+  _loaded = true;
+  if (!fs.existsSync(HABITUATION_FILE)) return;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(HABITUATION_FILE, "utf8"));
+    if (parsed?.version === 1 && Array.isArray(parsed.events)) _events = parsed.events;
+  } catch {
+  }
+}
+function persist() {
+  if (zeroRetentionMode()) return;
+  try {
+    fs.mkdirSync(DATA_DIR, { recursive: true, mode: 448 });
+    const tmp = `${HABITUATION_FILE}.tmp.${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify({ version: 1, events: _events }), "utf8");
+    fs.renameSync(tmp, HABITUATION_FILE);
+  } catch (err) {
+    logger.warn({ err }, "habituation-store: persist failed");
+  }
+}
+function isoWeekKey(ts) {
+  const d = new Date(ts);
+  const thursday = new Date(d);
+  thursday.setDate(d.getDate() - (d.getDay() + 6) % 7 + 3);
+  const year = thursday.getFullYear();
+  const jan4 = new Date(year, 0, 4);
+  const week = 1 + Math.round((thursday.getTime() - jan4.getTime()) / (7 * 864e5));
+  return `${year}-W${String(week).padStart(2, "0")}`;
+}
+function recordHabituationEvent(event) {
+  load();
+  _events.push(event);
+  if (_events.length > MAX_EVENTS) _events = _events.slice(-MAX_EVENTS);
+  persist();
+}
+function getHabituationEvents() {
+  load();
+  return [..._events];
+}
+function getWeeklyHabituation(windowWeeks = 8) {
+  load();
+  const cutoff = Date.now() - windowWeeks * 7 * 24 * 60 * 60 * 1e3;
+  const recent = _events.filter((e) => e.recordedAt >= cutoff);
+  const byWeek = /* @__PURE__ */ new Map();
+  for (const e of recent) {
+    const wk = isoWeekKey(e.recordedAt);
+    if (!byWeek.has(wk)) byWeek.set(wk, { commented: /* @__PURE__ */ new Set(), engaged: /* @__PURE__ */ new Set(), count: 0 });
+    const w = byWeek.get(wk);
+    if (e.eventType === "comment_posted") {
+      w.commented.add(e.actor);
+      w.count++;
+    } else {
+      w.engaged.add(e.actor);
+    }
+  }
+  return [...byWeek.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([week, w]) => ({
+    week,
+    engineersWithComments: w.commented.size,
+    engineersEngaged: w.engaged.size,
+    engagementRate: w.commented.size > 0 ? w.engaged.size / w.commented.size : 0,
+    commentsPosted: w.count
+  }));
+}
+export {
+  getHabituationEvents,
+  getWeeklyHabituation,
+  recordHabituationEvent
+};