opencode-swarm 7.148.5 → 7.149.1

package/dist/cli/index-exn0ztsv.js

@@ -0,0 +1,881 @@
+// @bun
+import {
+  telemetry
+} from "./index-xggpmtfx.js";
+import {
+  init_logger,
+  warn
+} from "./index-zgwm4ryv.js";
+
+// src/events/core-events.ts
+import * as fs from "fs";
+import * as path from "path";
+init_logger();
+var CORE_EVENT_LIMITS = {
+  activeMaxBytes: 2 * 1024 * 1024,
+  activeMaxEntries: 20000,
+  ageMaxMs: 7 * 24 * 60 * 60 * 1000,
+  compactMaxBytes: 512 * 1024,
+  readMaxBytes: 3 * 1024 * 1024,
+  checkInterval: 25,
+  warnCooldownMs: 60000,
+  headerMaxBytes: 64 * 1024,
+  authorityIndexMaxEntries: 20000,
+  maxLineBytes: 256 * 1024
+};
+var AUTHORITY_RETRY = "coder_retry_circuit_breaker";
+var AUTHORITY_REPAIR = "task_workflow_repaired";
+var AUTHORITY_DRIFT_ACK = "spec_drift_acknowledged";
+var AUTHORITY_DRIFT_REPAIR = "spec_drift_repaired";
+var RETRY_ACTIONS = new Set([
+  "sounding_board_consultation",
+  "simplification",
+  "user_escalation"
+]);
+function authorityKeyFor(event) {
+  switch (event.type) {
+    case AUTHORITY_RETRY: {
+      if (typeof event.taskId === "string" && typeof event.retryEpoch === "number" && Number.isFinite(event.retryEpoch) && typeof event.action === "string" && RETRY_ACTIONS.has(event.action)) {
+        return `retry|${event.taskId}|${event.retryEpoch}|${event.action}`;
+      }
+      return null;
+    }
+    case AUTHORITY_REPAIR: {
+      if (typeof event.taskId === "string" && typeof event.transitionId === "string") {
+        return `repair|${event.taskId}|${event.transitionId}`;
+      }
+      return null;
+    }
+    case AUTHORITY_DRIFT_ACK:
+    case AUTHORITY_DRIFT_REPAIR: {
+      if (typeof event.transitionId === "string") {
+        return `drift|${String(event.type)}|${event.transitionId}`;
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+var MANIFEST_TYPE = "swarm-events-manifest";
+var MANIFEST_SCHEMA = 1;
+var BY_TYPE_MAX_KEYS = 64;
+var BY_TYPE_OTHER = "__other__";
+function emptyFolded() {
+  return {
+    totalEvents: 0,
+    byType: {},
+    corrupt: 0,
+    dropped: 0,
+    oldestTimestamp: null,
+    newestTimestamp: null
+  };
+}
+function emptyManifest() {
+  return {
+    v: 1,
+    type: MANIFEST_TYPE,
+    schemaVersion: MANIFEST_SCHEMA,
+    folded: emptyFolded(),
+    updatedAt: new Date().toISOString()
+  };
+}
+function parseManifestLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed)
+    return null;
+  try {
+    const obj = JSON.parse(trimmed);
+    if (typeof obj !== "object" || obj === null)
+      return null;
+    const rec = obj;
+    if (rec.type !== MANIFEST_TYPE || rec.v !== 1 || rec.schemaVersion !== MANIFEST_SCHEMA || typeof rec.folded !== "object" || rec.folded === null) {
+      return null;
+    }
+    const f = rec.folded;
+    const manifest = emptyManifest();
+    const num = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
+    manifest.folded.totalEvents = num(f.totalEvents);
+    manifest.folded.corrupt = num(f.corrupt);
+    manifest.folded.dropped = num(f.dropped);
+    if (typeof f.byType === "object" && f.byType !== null) {
+      for (const [k, v] of Object.entries(f.byType)) {
+        if (typeof v === "number" && Number.isFinite(v) && v >= 0) {
+          manifest.folded.byType[k] = v;
+        }
+      }
+    }
+    if (typeof f.oldestTimestamp === "string") {
+      manifest.folded.oldestTimestamp = f.oldestTimestamp;
+    }
+    if (typeof f.newestTimestamp === "string") {
+      manifest.folded.newestTimestamp = f.newestTimestamp;
+    }
+    manifest.updatedAt = typeof rec.updatedAt === "string" ? rec.updatedAt : new Date().toISOString();
+    return manifest;
+  } catch {
+    return null;
+  }
+}
+var _internals = {
+  appendFileSync: fs.appendFileSync,
+  readFileSync: fs.readFileSync,
+  existsSync: fs.existsSync,
+  mkdirSync: fs.mkdirSync,
+  statSync: fs.statSync,
+  renameSync: fs.renameSync,
+  writeFileSync: fs.writeFileSync,
+  unlinkSync: fs.unlinkSync,
+  openSync: fs.openSync,
+  closeSync: fs.closeSync,
+  readSync: fs.readSync,
+  now: () => Date.now(),
+  limits: CORE_EVENT_LIMITS,
+  emitHealth: emitCoreEventsHealth
+};
+function eventsFilePath(directory) {
+  return path.join(directory, ".swarm", "events.jsonl");
+}
+function lockFilePath(directory) {
+  return path.join(directory, ".swarm", "events.lock");
+}
+function authorityIndexPath(directory) {
+  return path.join(directory, ".swarm", "events-authority-index.json");
+}
+function tmpPathFor(finalPath) {
+  return `${finalPath}.${process.pid}.tmp`;
+}
+function readBoundedChunk(filePath, maxBytes, offset = 0) {
+  try {
+    if (!_internals.existsSync(filePath)) {
+      return { text: "", truncated: false };
+    }
+    const fd = _internals.openSync(filePath, "r");
+    try {
+      const size = _internals.statSync(filePath).size;
+      const readable = Math.max(0, size - offset);
+      const truncated = readable > maxBytes;
+      const len = Math.min(readable, maxBytes);
+      const buf = Buffer.alloc(len);
+      let read = 0;
+      while (read < len) {
+        const n = _internals.readSync(fd, buf, read, len - read, offset + read);
+        if (n <= 0)
+          break;
+        read += n;
+      }
+      return { text: buf.toString("utf-8", 0, read), truncated };
+    } finally {
+      _internals.closeSync(fd);
+    }
+  } catch {
+    warnThrottled("bounded read failed (transient I/O)");
+    return { text: "", truncated: false };
+  }
+}
+function fileSizeOrZero(filePath) {
+  try {
+    if (!_internals.existsSync(filePath))
+      return 0;
+    return _internals.statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+function fileEndsWithNewline(filePath) {
+  try {
+    if (!_internals.existsSync(filePath))
+      return true;
+    const size = _internals.statSync(filePath).size;
+    if (size === 0)
+      return true;
+    const fd = _internals.openSync(filePath, "r");
+    try {
+      const buf = Buffer.alloc(1);
+      const n = _internals.readSync(fd, buf, 0, 1, size - 1);
+      return n <= 0 || buf[0] === 10;
+    } finally {
+      _internals.closeSync(fd);
+    }
+  } catch {
+    return true;
+  }
+}
+function eventDiscriminator(event) {
+  if (typeof event.type === "string" && event.type.length > 0) {
+    return event.type.slice(0, 64);
+  }
+  if (typeof event.event === "string" && event.event.length > 0) {
+    return event.event.slice(0, 64);
+  }
+  return "__untyped__";
+}
+function eventTimestamp(event) {
+  if (typeof event.timestamp !== "string")
+    return null;
+  const ts = Date.parse(event.timestamp);
+  return Number.isNaN(ts) ? null : event.timestamp;
+}
+function foldLineInto(folded, event) {
+  folded.totalEvents += 1;
+  const key = eventDiscriminator(event);
+  const keys = Object.keys(folded.byType);
+  if (folded.byType[key] !== undefined || keys.length < BY_TYPE_MAX_KEYS) {
+    folded.byType[key] = (folded.byType[key] ?? 0) + 1;
+  } else {
+    folded.byType[BY_TYPE_OTHER] = (folded.byType[BY_TYPE_OTHER] ?? 0) + 1;
+  }
+  const ts = eventTimestamp(event);
+  if (ts !== null) {
+    if (folded.oldestTimestamp === null || ts < folded.oldestTimestamp) {
+      folded.oldestTimestamp = ts;
+    }
+    if (folded.newestTimestamp === null || ts > folded.newestTimestamp) {
+      folded.newestTimestamp = ts;
+    }
+  }
+}
+function cloneFolded(folded) {
+  return {
+    totalEvents: folded.totalEvents,
+    byType: { ...folded.byType },
+    corrupt: folded.corrupt,
+    dropped: folded.dropped,
+    oldestTimestamp: folded.oldestTimestamp,
+    newestTimestamp: folded.newestTimestamp
+  };
+}
+function emptyAuthorityIndex() {
+  return { version: 1, entries: {}, evicted: 0 };
+}
+function loadAuthorityIndex(directory) {
+  const indexPath = authorityIndexPath(directory);
+  try {
+    if (!_internals.existsSync(indexPath))
+      return { kind: "absent" };
+    const raw = _internals.readFileSync(indexPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || parsed.version !== 1 || typeof parsed.entries !== "object" || parsed.entries === null) {
+      return { kind: "corrupt" };
+    }
+    const entries = {};
+    for (const [k, v] of Object.entries(parsed.entries)) {
+      if (typeof v === "string")
+        entries[k] = v;
+    }
+    const evictedRaw = parsed.evicted;
+    return {
+      kind: "ok",
+      index: {
+        version: 1,
+        entries,
+        evicted: typeof evictedRaw === "number" && Number.isFinite(evictedRaw) && evictedRaw >= 0 ? evictedRaw : 0
+      }
+    };
+  } catch {
+    return { kind: "corrupt" };
+  }
+}
+function mergeAuthorityKeys(directory, state, keys) {
+  if (keys.length === 0)
+    return;
+  const base = state.kind === "ok" ? {
+    version: 1,
+    entries: { ...state.index.entries },
+    evicted: state.index.evicted
+  } : emptyAuthorityIndex();
+  const now = new Date().toISOString();
+  for (const key of keys)
+    base.entries[key] = now;
+  const limit = _internals.limits.authorityIndexMaxEntries;
+  const allKeys = Object.keys(base.entries);
+  if (allKeys.length > limit) {
+    allKeys.sort((a, b) => base.entries[a] <= base.entries[b] ? -1 : 1);
+    const excess = allKeys.length - limit;
+    for (let i = 0;i < excess; i += 1) {
+      delete base.entries[allKeys[i]];
+    }
+    base.evicted += excess;
+  }
+  authorityIndexAtomicReplace(directory, base);
+}
+function authorityIndexAtomicReplace(directory, index) {
+  const finalPath = authorityIndexPath(directory);
+  const tmpPath = tmpPathFor(finalPath);
+  try {
+    if (_internals.existsSync(tmpPath)) {
+      try {
+        _internals.unlinkSync(tmpPath);
+      } catch {}
+    }
+    _internals.writeFileSync(tmpPath, `${JSON.stringify(index)}
+`, "utf-8");
+    renameSyncWithRetry(tmpPath, finalPath);
+  } catch {
+    try {
+      if (_internals.existsSync(tmpPath)) {
+        _internals.unlinkSync(tmpPath);
+      }
+    } catch {}
+    throw new Error("core-events authority index atomic replace failed");
+  }
+}
+function atomicReplace(directory, content) {
+  const lines = content.split(`
+`);
+  if (lines.length < 2 || lines[lines.length - 1] !== "") {
+    throw new Error("core-events atomic replace failed (framing)");
+  }
+  if (parseManifestLine(lines[0] ?? "") === null) {
+    throw new Error("core-events atomic replace failed (manifest)");
+  }
+  for (let i = 1;i < lines.length - 1; i += 1) {
+    const line = lines[i];
+    if (line.trim() === "")
+      continue;
+    JSON.parse(line);
+  }
+  const finalPath = eventsFilePath(directory);
+  const tmpPath = tmpPathFor(finalPath);
+  try {
+    if (_internals.existsSync(tmpPath)) {
+      try {
+        _internals.unlinkSync(tmpPath);
+      } catch {}
+    }
+    _internals.writeFileSync(tmpPath, content, "utf-8");
+    if (_internals.readFileSync(tmpPath, "utf-8") !== content) {
+      throw new Error("tmp verify mismatch");
+    }
+    renameSyncWithRetry(tmpPath, finalPath);
+  } catch {
+    try {
+      if (_internals.existsSync(tmpPath)) {
+        _internals.unlinkSync(tmpPath);
+      }
+    } catch {}
+    throw new Error("core-events atomic replace failed");
+  }
+}
+var LOCK_RETRY_ATTEMPTS = 20;
+var LOCK_RETRY_DELAY_MS = 5;
+var LOCK_STALE_MS = 5 * 60000;
+var sleepScratch = new Int32Array(new SharedArrayBuffer(4));
+function syncSleep(ms) {
+  try {
+    Atomics.wait(sleepScratch, 0, 0, ms);
+  } catch {
+    const start = _internals.now();
+    while (_internals.now() - start < ms) {}
+  }
+}
+var RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200];
+var RETRYABLE_RENAME_CODES = new Set(["EPERM", "EBUSY", "EACCES", "EEXIST"]);
+function renameSyncWithRetry(fromPath, toPath) {
+  let lastError;
+  for (let attempt = 0;attempt <= RENAME_RETRY_DELAYS_MS.length; attempt += 1) {
+    try {
+      _internals.renameSync(fromPath, toPath);
+      return;
+    } catch (err) {
+      lastError = err;
+      const code = err?.code;
+      if (!code || !RETRYABLE_RENAME_CODES.has(code))
+        throw err;
+      if (attempt < RENAME_RETRY_DELAYS_MS.length) {
+        syncSleep(RENAME_RETRY_DELAYS_MS[attempt]);
+      }
+    }
+  }
+  throw lastError;
+}
+function tryLockOnce(directory) {
+  const lockPath = lockFilePath(directory);
+  try {
+    _internals.mkdirSync(path.dirname(lockPath), { recursive: true });
+    const fd = _internals.openSync(lockPath, "wx");
+    _internals.closeSync(fd);
+    return true;
+  } catch {
+    try {
+      const age = _internals.now() - _internals.statSync(lockPath).mtimeMs;
+      if (age > LOCK_STALE_MS) {
+        try {
+          _internals.unlinkSync(lockPath);
+        } catch {}
+        try {
+          const fd = _internals.openSync(lockPath, "wx");
+          _internals.closeSync(fd);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    } catch {}
+    return false;
+  }
+}
+function withCoreEventStoreLock(directory, fn) {
+  for (let attempt = 0;attempt < LOCK_RETRY_ATTEMPTS; attempt += 1) {
+    if (tryLockOnce(directory)) {
+      try {
+        return fn();
+      } finally {
+        try {
+          _internals.unlinkSync(lockFilePath(directory));
+        } catch {}
+      }
+    }
+    if (attempt < LOCK_RETRY_ATTEMPTS - 1) {
+      syncSleep(LOCK_RETRY_DELAY_MS);
+    }
+  }
+  return null;
+}
+var _appendCount = 0;
+var _lastWarnAt = 0;
+function shouldRunMaintenance(linesAppended = 1) {
+  _appendCount += linesAppended;
+  if (_appendCount >= _internals.limits.checkInterval) {
+    _appendCount = 0;
+    return true;
+  }
+  return false;
+}
+function warnThrottled(message) {
+  const now = _internals.now();
+  if (now - _lastWarnAt < _internals.limits.warnCooldownMs)
+    return;
+  _lastWarnAt = now;
+  warn(`core-events: ${message}`);
+}
+function readStoreFull(directory) {
+  const filePath = eventsFilePath(directory);
+  if (!_internals.existsSync(filePath)) {
+    return { manifest: null, lines: [], corruptLines: 0 };
+  }
+  let text;
+  try {
+    text = _internals.readFileSync(filePath, "utf-8");
+  } catch {
+    return { manifest: null, lines: [], corruptLines: 0 };
+  }
+  const rawLines = text.split(`
+`);
+  const lines = [];
+  let corruptLines = 0;
+  let manifest = null;
+  for (let i = 0;i < rawLines.length; i += 1) {
+    const line = rawLines[i];
+    if (line.trim() === "")
+      continue;
+    if (i === 0) {
+      manifest = parseManifestLine(line);
+      if (manifest)
+        continue;
+    }
+    try {
+      const parsed = JSON.parse(line);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        lines.push({ line, event: parsed });
+      } else {
+        corruptLines += 1;
+      }
+    } catch {
+      corruptLines += 1;
+    }
+  }
+  return { manifest, lines, corruptLines };
+}
+function coverageFor(fileExists, lineCount, truncated) {
+  if (!fileExists || lineCount === 0)
+    return "empty";
+  return truncated ? "truncated" : "complete";
+}
+function readCoreEvents(directory) {
+  const filePath = eventsFilePath(directory);
+  if (!_internals.existsSync(filePath)) {
+    return { text: "", truncated: false, coverage: "empty" };
+  }
+  const size = fileSizeOrZero(filePath);
+  const truncated = size > _internals.limits.readMaxBytes;
+  const offset = truncated ? Math.max(0, size - _internals.limits.readMaxBytes) : 0;
+  let text = readBoundedChunk(filePath, _internals.limits.readMaxBytes, offset).text;
+  if (truncated) {
+    const firstNewline = text.indexOf(`
+`);
+    text = firstNewline === -1 ? "" : text.slice(firstNewline + 1);
+  }
+  const lines = text.split(`
+`);
+  const start = parseManifestLine(lines[0] ?? "") !== null ? 1 : 0;
+  if (start === 1) {
+    text = lines.slice(1).join(`
+`);
+  }
+  const eventLineCount = text.split(`
+`).filter((l) => l.trim() !== "").length;
+  const coverage = start === 1 ? truncated ? "truncated" : "complete" : coverageFor(true, eventLineCount, truncated);
+  return { text, truncated, coverage };
+}
+function getCoreEventCoverage(directory) {
+  const filePath = eventsFilePath(directory);
+  if (!_internals.existsSync(filePath))
+    return "empty";
+  const size = fileSizeOrZero(filePath);
+  if (size === 0)
+    return "empty";
+  return size > _internals.limits.readMaxBytes ? "truncated" : "complete";
+}
+var CORE_EVENT_LOCKED = "CORE_EVENT_STORE_LOCKED";
+var CORE_EVENT_LINE_TOO_LARGE = "CORE_EVENT_LINE_TOO_LARGE";
+var CORE_EVENT_NO_STORE = "CORE_EVENT_NO_STORE";
+function appendCoreEventSync(directory, event, options) {
+  const line = `${JSON.stringify(event)}
+`;
+  const lineBytes = Buffer.byteLength(line);
+  if (lineBytes - 1 > _internals.limits.maxLineBytes) {
+    throw new Error(CORE_EVENT_LINE_TOO_LARGE);
+  }
+  const filePath = eventsFilePath(directory);
+  const swarmDir = path.join(directory, ".swarm");
+  if (options?.ensureSwarmDir === false) {
+    if (!_internals.existsSync(swarmDir)) {
+      throw new Error(CORE_EVENT_NO_STORE);
+    }
+  } else {
+    _internals.mkdirSync(swarmDir, { recursive: true });
+  }
+  const authorityKey = authorityKeyFor(event);
+  const wrote = withCoreEventStoreLock(directory, () => {
+    if (authorityKey && options?.dedupeOnAuthorityKey) {
+      if (authorityKeyPresent(directory, authorityKey, event)) {
+        return "skipped";
+      }
+    }
+    if (!_internals.existsSync(filePath)) {
+      const manifest = emptyManifest();
+      atomicReplace(directory, `${JSON.stringify(manifest)}
+${line}`);
+    } else {
+      const prefix = fileEndsWithNewline(filePath) ? "" : `
+`;
+      _internals.appendFileSync(filePath, `${prefix}${line}`, "utf-8");
+    }
+    if (authorityKey) {
+      const state = loadAuthorityIndex(directory);
+      mergeAuthorityKeys(directory, state, [authorityKey]);
+    }
+    return "appended";
+  });
+  if (wrote === null) {
+    throw new Error(CORE_EVENT_LOCKED);
+  }
+  if (shouldRunMaintenance()) {
+    runMaintenance(directory);
+  }
+}
+function authorityKeyPresent(directory, key, event) {
+  const state = loadAuthorityIndex(directory);
+  if (state.kind === "ok" && state.index.entries[key] !== undefined) {
+    return true;
+  }
+  for (const candidate of scanWindowFor(directory, (e) => authorityKeyFor(e) === key)) {
+    return true;
+  }
+  return false;
+}
+function appendCoreEventsSync(directory, events, options) {
+  if (events.length === 0)
+    return;
+  const lines = events.map((event) => `${JSON.stringify(event)}
+`);
+  for (const line of lines) {
+    if (Buffer.byteLength(line) - 1 > _internals.limits.maxLineBytes) {
+      throw new Error(CORE_EVENT_LINE_TOO_LARGE);
+    }
+  }
+  const filePath = eventsFilePath(directory);
+  const swarmDir = path.join(directory, ".swarm");
+  if (options?.ensureSwarmDir === false) {
+    if (!_internals.existsSync(swarmDir)) {
+      throw new Error(CORE_EVENT_NO_STORE);
+    }
+  } else {
+    _internals.mkdirSync(swarmDir, { recursive: true });
+  }
+  const wrote = withCoreEventStoreLock(directory, () => {
+    let appended = 0;
+    let framingChecked = false;
+    for (let i = 0;i < events.length; i += 1) {
+      const event = events[i];
+      const authorityKey = authorityKeyFor(event);
+      if (authorityKey && options?.dedupeOnAuthorityKey) {
+        if (authorityKeyPresent(directory, authorityKey, event)) {
+          continue;
+        }
+      }
+      if (appended === 0 && !_internals.existsSync(filePath)) {
+        const manifest = emptyManifest();
+        atomicReplace(directory, `${JSON.stringify(manifest)}
+${lines[i]}`);
+        framingChecked = true;
+      } else {
+        const prefix = !framingChecked && !fileEndsWithNewline(filePath) ? `
+` : "";
+        _internals.appendFileSync(filePath, `${prefix}${lines[i]}`, "utf-8");
+        framingChecked = true;
+      }
+      if (authorityKey) {
+        const state = loadAuthorityIndex(directory);
+        mergeAuthorityKeys(directory, state, [authorityKey]);
+      }
+      appended += 1;
+    }
+    return appended;
+  });
+  if (wrote === null) {
+    throw new Error(CORE_EVENT_LOCKED);
+  }
+  if (shouldRunMaintenance(events.length)) {
+    runMaintenance(directory);
+  }
+}
+function scanWindowFor(directory, predicate) {
+  const window = readCoreEvents(directory);
+  const matches = [];
+  for (const line of window.text.split(`
+`)) {
+    if (line.trim() === "")
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && predicate(parsed)) {
+        matches.push(parsed);
+      }
+    } catch {}
+  }
+  return matches;
+}
+function selfHealAuthorityKeys(directory, keys) {
+  try {
+    const state = loadAuthorityIndex(directory);
+    if (state.kind === "corrupt")
+      return;
+    mergeAuthorityKeys(directory, state, keys);
+  } catch {}
+}
+function hasAuthorityEvent(directory, key, predicate) {
+  const state = loadAuthorityIndex(directory);
+  if (state.kind === "corrupt") {
+    throw new Error("CORE_EVENT_AUTHORITY_INDEX_UNREADABLE");
+  }
+  if (state.kind === "ok" && state.index.entries[key] !== undefined) {
+    return true;
+  }
+  const found = scanWindowFor(directory, predicate);
+  if (found.length > 0) {
+    selfHealAuthorityKeys(directory, [key]);
+    return true;
+  }
+  return false;
+}
+function hasSpecDriftAuditEvent(directory, kind, transitionId) {
+  return hasAuthorityEvent(directory, `drift|${kind}|${transitionId}`, (e) => e.type === kind && e.transitionId === transitionId);
+}
+function hasTaskRepairAuditEvent(directory, taskId, transitionId) {
+  return hasAuthorityEvent(directory, `repair|${taskId}|${transitionId}`, (e) => e.type === AUTHORITY_REPAIR && e.taskId === taskId && e.transitionId === transitionId);
+}
+function foldPass(directory, trigger, forceFull, preloadedAuthorityState) {
+  const filePath = eventsFilePath(directory);
+  if (!_internals.existsSync(filePath))
+    return;
+  const view = readStoreFull(directory);
+  if (view.manifest === null && view.lines.length === 0)
+    return;
+  const folded = view.manifest ? cloneFolded(view.manifest.folded) : emptyFolded();
+  const now = _internals.now();
+  const agePruned = [];
+  const kept = [];
+  for (const entry of view.lines) {
+    if (entry.event === null) {
+      agePruned.push(entry);
+      continue;
+    }
+    if (authorityKeyFor(entry.event) !== null) {
+      kept.push(entry);
+      continue;
+    }
+    const ts = eventTimestamp(entry.event);
+    if (ts !== null && now - Date.parse(ts) > _internals.limits.ageMaxMs) {
+      agePruned.push(entry);
+    } else {
+      kept.push(entry);
+    }
+  }
+  const retained = [];
+  let bytes = Buffer.byteLength(JSON.stringify(view.manifest ?? emptyManifest()));
+  for (let i = kept.length - 1;i >= 0; i -= 1) {
+    const entry = kept[i];
+    const lineBytes = Buffer.byteLength(entry.line) + 1;
+    if (retained.length >= _internals.limits.activeMaxEntries || bytes + lineBytes > _internals.limits.activeMaxBytes) {
+      break;
+    }
+    retained.push(entry);
+    bytes += lineBytes;
+  }
+  retained.reverse();
+  const retainedSet = new Set(retained);
+  const candidates = [];
+  for (const entry of view.lines) {
+    if (entry.event === null) {
+      candidates.push(entry);
+    } else if (!retainedSet.has(entry)) {
+      candidates.push(entry);
+    }
+  }
+  const toFold = new Set;
+  let foldedBytes = 0;
+  for (const cand of candidates) {
+    const cb = Buffer.byteLength(cand.line) + 1;
+    if (!forceFull && foldedBytes + cb > _internals.limits.compactMaxBytes && toFold.size > 0) {
+      break;
+    }
+    toFold.add(cand);
+    foldedBytes += cb;
+  }
+  const indexKeys = [];
+  for (const cand of toFold) {
+    if (cand.event !== null) {
+      const key = authorityKeyFor(cand.event);
+      if (key)
+        indexKeys.push(key);
+    }
+  }
+  if (indexKeys.length > 0) {
+    mergeAuthorityKeys(directory, loadAuthorityIndex(directory), indexKeys);
+  }
+  const agePrunedSet = new Set(agePruned);
+  let dropped = 0;
+  for (const cand of toFold) {
+    if (cand.event === null) {
+      folded.corrupt += 1;
+    } else {
+      foldLineInto(folded, cand.event);
+      if (agePrunedSet.has(cand))
+        dropped += 1;
+    }
+  }
+  folded.dropped += dropped;
+  folded.corrupt += view.corruptLines;
+  const finalRetained = [];
+  for (const entry of view.lines) {
+    if (!toFold.has(entry))
+      finalRetained.push(entry);
+  }
+  const manifest = {
+    ...emptyManifest(),
+    folded,
+    updatedAt: new Date().toISOString()
+  };
+  const outLines = [`${JSON.stringify(manifest)}`];
+  for (const entry of finalRetained)
+    outLines.push(entry.line);
+  atomicReplace(directory, outLines.length > 1 ? `${outLines.join(`
+`)}
+` : `${outLines[0]}
+`);
+  emitHealth(directory, {
+    trigger,
+    accepted: folded.totalEvents + finalRetained.length,
+    compacted: toFold.size - dropped,
+    retained: finalRetained.length,
+    dropped,
+    corrupt: folded.corrupt,
+    oldest: folded.oldestTimestamp,
+    newest: folded.newestTimestamp,
+    bytes: fileSizeOrZero(filePath),
+    limitBytes: _internals.limits.activeMaxBytes
+  }, preloadedAuthorityState);
+}
+function runMaintenance(directory) {
+  try {
+    const filePath = eventsFilePath(directory);
+    if (!_internals.existsSync(filePath))
+      return;
+    const drainThreshold = _internals.limits.activeMaxBytes + _internals.limits.headerMaxBytes + 2048;
+    withCoreEventStoreLock(directory, () => {
+      const authorityState = loadAuthorityIndex(directory);
+      foldPass(directory, "compaction", false, authorityState);
+      let prevSize = Number.POSITIVE_INFINITY;
+      for (let pass = 0;pass < 64; pass += 1) {
+        const size = fileSizeOrZero(filePath);
+        if (size <= drainThreshold)
+          break;
+        if (size >= prevSize)
+          break;
+        prevSize = size;
+        foldPass(directory, "compaction", false, authorityState);
+      }
+      return true;
+    });
+  } catch {
+    warnThrottled("maintenance pass failed");
+  }
+}
+function finalizeCoreEventsForClose(directory) {
+  try {
+    const filePath = eventsFilePath(directory);
+    if (!_internals.existsSync(filePath))
+      return;
+    withCoreEventStoreLock(directory, () => {
+      const authorityState = loadAuthorityIndex(directory);
+      let prev = Number.POSITIVE_INFINITY;
+      for (let pass = 0;pass < 1e4; pass += 1) {
+        const view = readStoreFull(directory);
+        if (view.manifest !== null)
+          break;
+        if (view.lines.length === 0)
+          break;
+        if (view.lines.length >= prev)
+          break;
+        prev = view.lines.length;
+        foldPass(directory, "close", false, authorityState);
+      }
+      foldPass(directory, "close", true, authorityState);
+      return true;
+    });
+  } catch {
+    warnThrottled("finalize failed");
+  }
+}
+function emitCoreEventsHealth(directory, payload, preloadedAuthorityState) {
+  let authorityCount = 0;
+  let authorityEvicted = 0;
+  const state = preloadedAuthorityState ?? loadAuthorityIndex(directory);
+  if (state.kind === "ok") {
+    authorityCount = Object.keys(state.index.entries).length;
+    authorityEvicted = state.index.evicted;
+  }
+  try {
+    telemetry.coreEventsHealth({
+      trigger: payload.trigger,
+      accepted_count: payload.accepted,
+      compacted_count: payload.compacted,
+      retained_count: payload.retained,
+      dropped_count: payload.dropped,
+      corrupt_count: payload.corrupt,
+      authority_index_count: authorityCount,
+      authority_evicted_count: authorityEvicted,
+      oldest_timestamp: payload.oldest,
+      newest_timestamp: payload.newest,
+      bytes: payload.bytes,
+      limit_bytes: payload.limitBytes
+    });
+  } catch {}
+}
+function emitHealth(directory, payload, preloadedAuthorityState) {
+  _internals.emitHealth(directory, payload, preloadedAuthorityState);
+}
+
+export { readCoreEvents, getCoreEventCoverage, CORE_EVENT_LOCKED, appendCoreEventSync, appendCoreEventsSync, hasSpecDriftAuditEvent, hasTaskRepairAuditEvent, finalizeCoreEventsForClose };