Function compact

lib/gstack-decision.ts:274–325

(paths: DecisionPaths)

 * caller re-runs. Atomic rewrite (tmp + rename); refreshes the snapshot.
 */
export function compact(paths: DecisionPaths): CompactResult {
  const lockPath = `${paths.log}.compact.lock`;
  let lockFd: number;
  try {
    lockFd = openSync(lockPath, "wx"); // O_EXCL|O_CREAT — throws EEXIST if a compact holds it
  } catch (err) {
    if ((err as NodeJS.ErrnoException).code === "EEXIST") {
      return { activeCount: computeActive(readEvents(paths)).length, archivedCount: 0, expungedCount: 0, skipped: true };
    }
    throw err;
  }
  try {
    const sizeBefore = existsSync(paths.log) ? statSync(paths.log).size : 0;
    const events = readEvents(paths);
    const active = computeActive(events);
    const activeIds = new Set(active.map((d) => d.id));
    const redactedIds = new Set(
      events.filter((e) => e.kind === "redact" && e.supersedes).map((e) => e.supersedes as string),
    );
    // Superseded = a decide that's neither active nor redacted. Archive these for history.
    const superseded = events.filter(
      (e): e is DecisionEvent => e.kind === "decide" && !activeIds.has(e.id) && !redactedIds.has(e.id),
    );

    // Append-race guard: if the log grew/changed since we read it, an append landed —
    // rewriting now would drop it. Abort untouched; the caller re-runs.
    const sizeNow = existsSync(paths.log) ? statSync(paths.log).size : 0;
    if (sizeNow !== sizeBefore) {
      return { activeCount: active.length, archivedCount: 0, expungedCount: 0, skipped: true };
    }

    // One batched append (not one open/write/close per event) — matches the atomic
    // batched rewrite of the active log below and shrinks the mid-compact crash window.
    if (superseded.length) {
      appendFileSync(paths.archive, superseded.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf-8");
    }

    const tmp = `${paths.log}.tmp.${process.pid}`;
    writeFileSync(tmp, active.map((d) => JSON.stringify(d)).join("\n") + (active.length ? "\n" : ""), "utf-8");
    renameSync(tmp, paths.log);
    writeSnapshot(paths, active);

    return { activeCount: active.length, archivedCount: superseded.length, expungedCount: redactedIds.size };
  } finally {
    closeSync(lockFd);
    try {
      unlinkSync(lockPath);
    } catch {
      // best-effort lock cleanup; a leftover lock only blocks the NEXT compact, which re-runs
    }
  }
}