opencode-swarm 7.143.6 → 7.144.1

package/dist/cli/{index-6vmazy9f.js → index-4fda8kkw.js}

@@ -20,20 +20,225 @@ import {
 // src/background/pending-delegations.ts
 init_zod();
 import { createHash } from "crypto";
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 import { isDeepStrictEqual } from "util";
 init_logger();
+
+// src/background/delegation-health.ts
+init_zod();
+import * as fs from "fs";
+import * as path from "path";
+var BACKGROUND_DELEGATIONS_HEALTH_FILE = "background-delegations-health.json";
+var MAX_RECOVERY_LEDGER_BYTES = 4 * 1024 * 1024;
+var DelegationCheckpointAuditSchema = exports_external.object({
+  dispatchCount: exports_external.number().int().nonnegative(),
+  terminalsByStatus: exports_external.object({
+    completed: exports_external.number().int().nonnegative(),
+    error: exports_external.number().int().nonnegative(),
+    cancelled: exports_external.number().int().nonnegative(),
+    stale: exports_external.number().int().nonnegative()
+  }).strict(),
+  settledCount: exports_external.number().int().nonnegative(),
+  preservedCount: exports_external.number().int().nonnegative(),
+  lateTerminalCount: exports_external.number().int().nonnegative(),
+  compactedTransitionCount: exports_external.number().int().nonnegative(),
+  compactedRecordCount: exports_external.number().int().nonnegative(),
+  firstDispatchAt: exports_external.number().int().nonnegative().nullable(),
+  lastTerminalAt: exports_external.number().int().nonnegative().nullable(),
+  lastCompactionAt: exports_external.number().int().nonnegative()
+}).strict();
+var CheckpointSectionSchema = exports_external.object({
+  sequence: exports_external.number().int().positive(),
+  createdAt: exports_external.number().int().nonnegative(),
+  liveRecords: exports_external.number().int().nonnegative(),
+  closedSummaries: exports_external.number().int().nonnegative(),
+  bytes: exports_external.number().int().nonnegative(),
+  audit: DelegationCheckpointAuditSchema
+}).strict();
+var RecoverySectionSchema = exports_external.object({
+  source: exports_external.enum([
+    "checkpoint+tail",
+    "checkpoint+ledger-suffix",
+    "legacy-ledger",
+    "unknown"
+  ]),
+  at: exports_external.number().int().nonnegative(),
+  ok: exports_external.boolean(),
+  reason: exports_external.string().min(1).max(2000).optional(),
+  repairHint: exports_external.string().min(1).max(2000).optional()
+}).strict();
+var UncertaintySectionSchema = exports_external.object({
+  reason: exports_external.string().min(1).max(2000),
+  at: exports_external.number().int().nonnegative(),
+  source: exports_external.string().min(1).max(256),
+  repairHint: exports_external.string().min(1).max(2000).optional()
+}).strict();
+var DelegationLedgerHealthSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1),
+  updatedAt: exports_external.number().int().nonnegative(),
+  ledger: exports_external.object({
+    bytes: exports_external.number().int().nonnegative(),
+    limitBytes: exports_external.number().int().positive(),
+    pressurePct: exports_external.number().min(0).max(100),
+    band: exports_external.enum(["ok", "nominal", "compact-overdue", "fail-closed"])
+  }).strict(),
+  checkpoint: CheckpointSectionSchema.nullable(),
+  recovery: RecoverySectionSchema.nullable(),
+  lastUncertainty: UncertaintySectionSchema.nullable(),
+  counts: exports_external.object({
+    activeOwners: exports_external.number().int().nonnegative(),
+    pendingAdvisories: exports_external.number().int().nonnegative(),
+    lateTerminals: exports_external.number().int().nonnegative(),
+    orphanWorktreeOwners: exports_external.number().int().nonnegative()
+  }).strict()
+}).strict();
+function sleepSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+    const start = Date.now();
+    while (Date.now() - start < ms) {}
+  }
+}
+var _healthInternals = {
+  renameOnce: (from, to) => {
+    fs.renameSync(from, to);
+  }
+};
+function healthArtifactPath(directory) {
+  return validateSwarmPath(directory, BACKGROUND_DELEGATIONS_HEALTH_FILE);
+}
+function readDelegationHealthArtifact(directory) {
+  let raw;
+  try {
+    raw = fs.readFileSync(healthArtifactPath(directory), "utf-8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = DelegationLedgerHealthSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+function writeDelegationHealthArtifact(directory, update) {
+  const existing = readDelegationHealthArtifact(directory);
+  const base = existing ?? {
+    schemaVersion: 1,
+    updatedAt: 0,
+    ledger: {
+      bytes: 0,
+      limitBytes: MAX_RECOVERY_LEDGER_BYTES,
+      pressurePct: 0,
+      band: "ok"
+    },
+    checkpoint: null,
+    recovery: null,
+    lastUncertainty: null,
+    counts: {
+      activeOwners: 0,
+      pendingAdvisories: 0,
+      lateTerminals: 0,
+      orphanWorktreeOwners: 0
+    }
+  };
+  const next = {
+    schemaVersion: 1,
+    updatedAt: Date.now(),
+    ledger: update.ledger ?? base.ledger,
+    checkpoint: update.checkpoint === undefined ? base.checkpoint : update.checkpoint,
+    recovery: update.recovery === undefined ? base.recovery : update.recovery,
+    lastUncertainty: update.lastUncertainty ?? base.lastUncertainty,
+    counts: update.counts ?? base.counts
+  };
+  if (update.uncertainty) {
+    next.lastUncertainty = update.uncertainty;
+  }
+  const parsed = DelegationLedgerHealthSchema.safeParse(next);
+  if (!parsed.success)
+    return null;
+  try {
+    fs.mkdirSync(path.resolve(directory, ".swarm"), { recursive: true });
+    const target = healthArtifactPath(directory);
+    const tmp = `${target}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+    fs.writeFileSync(tmp, `${JSON.stringify(parsed.data)}
+`, "utf-8");
+    let lastError;
+    for (let attempt = 0;attempt < 5; attempt++) {
+      try {
+        _healthInternals.renameOnce(tmp, target);
+        lastError = undefined;
+        break;
+      } catch (err) {
+        lastError = err;
+        const code = err.code;
+        if (code !== "EEXIST" && code !== "EBUSY" && code !== "EPERM") {
+          break;
+        }
+        if (attempt < 4)
+          sleepSync(15);
+      }
+    }
+    if (lastError !== undefined) {
+      try {
+        fs.rmSync(tmp, { force: true });
+      } catch {}
+      return null;
+    }
+    return parsed.data;
+  } catch {
+    return null;
+  }
+}
+function collectDelegationLedgerHealth(directory, options) {
+  const artifact = readDelegationHealthArtifact(directory);
+  let ledgerBytes = 0;
+  let ledgerExists = false;
+  try {
+    ledgerBytes = fs.statSync(validateSwarmPath(directory, "background-delegations.jsonl")).size;
+    ledgerExists = true;
+  } catch {
+    ledgerExists = false;
+  }
+  if (!artifact && !ledgerExists)
+    return null;
+  const limitBytes = options.ledgerLimitBytes;
+  const pressurePct = Math.min(100, Math.round(ledgerBytes / limitBytes * 1000) / 10);
+  const band = ledgerBytes > limitBytes ? "fail-closed" : ledgerBytes > options.highWaterBytes ? "compact-overdue" : ledgerBytes > options.lowWaterBytes ? "nominal" : "ok";
+  return {
+    schemaVersion: 1,
+    updatedAt: artifact?.updatedAt ?? 0,
+    ledger: { bytes: ledgerBytes, limitBytes, pressurePct, band },
+    checkpoint: artifact?.checkpoint ?? null,
+    recovery: artifact?.recovery ?? null,
+    lastUncertainty: artifact?.lastUncertainty ?? null,
+    counts: artifact?.counts ?? {
+      activeOwners: 0,
+      pendingAdvisories: 0,
+      lateTerminals: 0,
+      orphanWorktreeOwners: 0
+    }
+  };
+}
+// src/background/pending-delegations.ts
 var BACKGROUND_DELEGATIONS_FILE = "background-delegations.jsonl";
 var BACKGROUND_DELEGATION_FALLBACK_DIR = "background-delegation-fallback";
 var BACKGROUND_CODER_RESERVATIONS_FILE = "background-coder-reservations.json";
+var BACKGROUND_DELEGATIONS_CHECKPOINT_FILE = "background-delegations.checkpoint.json";
+var BACKGROUND_DELEGATIONS_MANIFEST_FILE = "background-delegations.manifest.json";
 var MAX_LIVE_BACKGROUND_FALLBACKS = 256;
 var MAX_LIVE_BACKGROUND_CODER_RESERVATIONS = 256;
 var MAX_BACKGROUND_OBSERVED_FILES = 5000;
 var MAX_BACKGROUND_ADVISORY_CHARS = 4000;
 var MAX_BACKGROUND_DELEGATION_GENERATION = 1e6;
-var MAX_RECOVERY_LEDGER_BYTES = 4 * 1024 * 1024;
 var MAX_RECOVERY_FALLBACK_BYTES = 1024 * 1024;
+var DELEGATION_COMPACTION_LOW_WATER_BYTES = 256 * 1024;
+var DELEGATION_COMPACTION_HIGH_WATER_BYTES = 1024 * 1024;
+var MAX_CHECKPOINT_BYTES = 2 * 1024 * 1024;
+var MAX_CHECKPOINT_RECORDS = 2048;
+var TOMBSTONE_MIN_AGE_MS = 72 * 60 * 60 * 1000;
 var STORE_LOCK_AGENT = "background";
 var STORE_LOCK_TASK = "background-delegations";
 var FALLBACK_LOCK_TASK = "background-delegation-fallback";
@@ -291,43 +496,359 @@ var FallbackArtifactSchema = exports_external.object({
 function storePath(directory) {
   return validateSwarmPath(directory, BACKGROUND_DELEGATIONS_FILE);
 }
-function ensureSwarmDir(directory) {
-  fs.mkdirSync(path.resolve(directory, ".swarm"), { recursive: true });
+function checkpointPath(directory) {
+  return validateSwarmPath(directory, BACKGROUND_DELEGATIONS_CHECKPOINT_FILE);
 }
-function readDelegations(directory) {
+function manifestPath(directory) {
+  return validateSwarmPath(directory, BACKGROUND_DELEGATIONS_MANIFEST_FILE);
+}
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+var CheckpointSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1),
+  sequence: exports_external.number().int().positive(),
+  writerId: exports_external.string().min(1).max(128),
+  rootPath: exports_external.string().min(1).max(4096),
+  createdAt: exports_external.number().int().nonnegative(),
+  cutLedgerBytes: exports_external.number().int().nonnegative(),
+  cutLedgerDigest: exports_external.string().regex(SHA256_HEX),
+  records: exports_external.array(RecordSchema).max(MAX_CHECKPOINT_RECORDS),
+  closed: exports_external.array(RecordSchema),
+  audit: DelegationCheckpointAuditSchema,
+  payloadChecksum: exports_external.string().regex(SHA256_HEX)
+}).strict();
+var ManifestSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1),
+  sequence: exports_external.number().int().positive(),
+  checkpointChecksum: exports_external.string().regex(SHA256_HEX),
+  writerId: exports_external.string().min(1).max(128),
+  rootPath: exports_external.string().min(1).max(4096),
+  updatedAt: exports_external.number().int().nonnegative()
+}).strict();
+var WRITER_ID = `w-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+var _checkpointInternals = {
+  renameWithRetry: (from, to) => {
+    let lastError;
+    for (let attempt = 0;attempt < 5; attempt++) {
+      try {
+        _checkpointInternals.renameOnce(from, to);
+        return;
+      } catch (err) {
+        lastError = err;
+        const code = err.code;
+        if (code !== "EEXIST" && code !== "EBUSY" && code !== "EPERM") {
+          throw err;
+        }
+        _checkpointInternals.syncSleep(15);
+      }
+    }
+    throw lastError;
+  },
+  renameOnce: (from, to) => {
+    fs2.renameSync(from, to);
+  },
+  syncSleep: (ms) => {
+    try {
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    } catch {
+      const start = Date.now();
+      while (Date.now() - start < ms) {}
+    }
+  }
+};
+function writeDurableFileSync(target, contents) {
+  const tmp = `${target}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+  try {
+    const fd = fs2.openSync(tmp, "w");
+    try {
+      if (typeof contents === "string") {
+        fs2.writeSync(fd, contents);
+      } else {
+        fs2.writeSync(fd, contents, 0, contents.length);
+      }
+      fs2.fsyncSync(fd);
+    } finally {
+      fs2.closeSync(fd);
+    }
+    _checkpointInternals.renameWithRetry(tmp, target);
+  } catch (err) {
+    try {
+      fs2.rmSync(tmp, { force: true });
+    } catch {}
+    throw err;
+  }
+  try {
+    const dfd = fs2.openSync(path2.dirname(target), "r");
+    try {
+      fs2.fsyncSync(dfd);
+    } finally {
+      fs2.closeSync(dfd);
+    }
+  } catch {}
+}
+function readJsonFileWithRetry(target) {
   let raw;
   try {
-    raw = fs.readFileSync(storePath(directory), "utf-8");
+    raw = fs2.readFileSync(target, "utf-8");
   } catch (err) {
-    if (err.code === "ENOENT")
-      return [];
-    warn(`[background] readDelegations failed: ${err instanceof Error ? err.message : String(err)}`);
-    return [];
+    const code = err.code;
+    if (code === "ENOENT")
+      return { status: "absent" };
+    return {
+      status: "invalid",
+      reason: `unreadable (${code ?? "unknown error"})`
+    };
+  }
+  try {
+    return { status: "ok", value: JSON.parse(raw) };
+  } catch (err) {
+    return {
+      status: "invalid",
+      reason: `malformed JSON (${err instanceof Error ? err.message : String(err)})`
+    };
+  }
+}
+function readDelegationManifest(directory) {
+  const read = readJsonFileWithRetry(manifestPath(directory));
+  if (read.status === "absent")
+    return { kind: "absent" };
+  if (read.status === "invalid")
+    return { kind: "invalid", reason: read.reason };
+  const parsed = ManifestSchema.safeParse(read.value);
+  if (!parsed.success) {
+    return { kind: "invalid", reason: "manifest fails schema validation" };
+  }
+  return { kind: "ok", manifest: parsed.data };
+}
+function readDelegationCheckpoint(directory) {
+  let bytes = 0;
+  try {
+    bytes = fs2.statSync(checkpointPath(directory)).size;
+  } catch {}
+  if (bytes > MAX_CHECKPOINT_BYTES) {
+    return {
+      kind: "invalid",
+      reason: `checkpoint exceeds the ${MAX_CHECKPOINT_BYTES}-byte bound`
+    };
+  }
+  const read = readJsonFileWithRetry(checkpointPath(directory));
+  if (read.status === "absent")
+    return { kind: "absent" };
+  if (read.status === "invalid")
+    return { kind: "invalid", reason: read.reason };
+  const parsed = CheckpointSchema.safeParse(read.value);
+  if (!parsed.success) {
+    return { kind: "invalid", reason: "checkpoint fails schema validation" };
+  }
+  return { kind: "ok", checkpoint: parsed.data, bytes };
+}
+function sha256Hex(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function checkpointPayloadChecksum(checkpoint) {
+  return sha256Hex(JSON.stringify([
+    checkpoint.schemaVersion,
+    checkpoint.sequence,
+    checkpoint.writerId,
+    checkpoint.rootPath,
+    checkpoint.createdAt,
+    checkpoint.cutLedgerBytes,
+    checkpoint.cutLedgerDigest,
+    checkpoint.records,
+    checkpoint.closed,
+    checkpoint.audit
+  ]));
+}
+var CHECKPOINT_REBIND_HINT = "remove .swarm/background-delegations.manifest.json (manifest only) after verifying no in-flight background delegations; recovery then falls back to the full-ledger read. Only if you also want to discard pre-cut closed summaries and audit history \u2014 which for a compacted (rolled) ledger exist ONLY in .swarm/background-delegations.checkpoint.json \u2014 remove the checkpoint too or use the full reset below";
+var CHECKPOINT_RESET_HINT = "the rolled tail no longer carries pre-checkpoint state: stop swarm processes, verify no in-flight background delegations, and remove .swarm/background-delegations.manifest.json, .swarm/background-delegations.checkpoint.json, and .swarm/background-delegations.jsonl to reset the store (or restore them from backup)";
+function loadFoldedState(directory, options) {
+  const manifestRead = readDelegationManifest(directory);
+  if (manifestRead.kind === "invalid") {
+    return {
+      status: "uncertain",
+      reason: `background delegation manifest is invalid: ${manifestRead.reason}`,
+      repairHint: CHECKPOINT_RESET_HINT
+    };
+  }
+  if (manifestRead.kind === "absent") {
+    return loadLegacyLedger(directory, options.strict);
+  }
+  const manifest = manifestRead.manifest;
+  if (manifest.rootPath !== path2.resolve(directory)) {
+    return {
+      status: "uncertain",
+      reason: "background delegation checkpoint is bound to a different project root",
+      repairHint: CHECKPOINT_REBIND_HINT
+    };
+  }
+  const checkpointRead = readDelegationCheckpoint(directory);
+  if (checkpointRead.kind === "invalid" || checkpointRead.kind === "absent") {
+    const detail = checkpointRead.kind === "invalid" ? `: ${checkpointRead.reason}` : " (file missing)";
+    return {
+      status: "uncertain",
+      reason: `background delegation checkpoint is invalid${detail} while a manifest is published`,
+      repairHint: CHECKPOINT_RESET_HINT
+    };
+  }
+  const checkpoint = checkpointRead.checkpoint;
+  if (checkpoint.sequence !== manifest.sequence && checkpoint.sequence !== manifest.sequence + 1) {
+    return {
+      status: "uncertain",
+      reason: `background delegation checkpoint/manifest sequence mismatch (checkpoint ${checkpoint.sequence}, manifest ${manifest.sequence})`,
+      repairHint: CHECKPOINT_RESET_HINT
+    };
+  }
+  if (checkpoint.sequence === manifest.sequence && manifest.checkpointChecksum !== checkpoint.payloadChecksum) {
+    return {
+      status: "uncertain",
+      reason: "background delegation manifest checksum does not match its checkpoint",
+      repairHint: CHECKPOINT_RESET_HINT
+    };
+  }
+  if (checkpointPayloadChecksum(checkpoint) !== checkpoint.payloadChecksum) {
+    return {
+      status: "uncertain",
+      reason: "background delegation checkpoint payload checksum mismatch",
+      repairHint: CHECKPOINT_RESET_HINT
+    };
+  }
+  let stat;
+  try {
+    stat = fs2.statSync(storePath(directory));
+  } catch (error) {
+    return {
+      status: "uncertain",
+      reason: `background delegation ledger metadata is unreadable: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  let tail;
+  let mode;
+  if (stat.size >= checkpoint.cutLedgerBytes && checkpoint.cutLedgerBytes > 0) {
+    const prefix = readLedgerRegion(directory, 0, checkpoint.cutLedgerBytes);
+    if (sha256Hex(prefix) === checkpoint.cutLedgerDigest) {
+      const suffixBytes = stat.size - checkpoint.cutLedgerBytes;
+      if (suffixBytes > MAX_RECOVERY_LEDGER_BYTES) {
+        return {
+          status: "uncertain",
+          reason: `background delegation ledger changed beyond the ${MAX_RECOVERY_LEDGER_BYTES}-byte recovery bound`
+        };
+      }
+      tail = suffixBytes === 0 ? Buffer.alloc(0) : readLedgerRegion(directory, checkpoint.cutLedgerBytes, suffixBytes);
+      mode = "checkpoint+ledger-suffix";
+    } else {
+      tail = readBoundedRecentLedgerWindow(directory, stat.size);
+      mode = "checkpoint+tail";
+    }
+  } else {
+    tail = readBoundedRecentLedgerWindow(directory, stat.size);
+    mode = "checkpoint+tail";
+  }
+  const records = new Map;
+  for (const record of checkpoint.records) {
+    records.set(record.correlationId, record);
+  }
+  for (const summary of checkpoint.closed) {
+    records.set(summary.correlationId, summary);
+  }
+  const foldError = foldLedgerTail(records, tail, options.strict, checkpoint);
+  if (foldError)
+    return { status: "uncertain", reason: foldError };
+  return {
+    status: "ok",
+    mode,
+    records,
+    manifest,
+    checkpoint
+  };
+}
+function readLedgerRegion(directory, offset, length) {
+  const fd = fs2.openSync(storePath(directory), "r");
+  try {
+    const buffer = Buffer.alloc(length);
+    let read = 0;
+    while (read < length) {
+      const n = fs2.readSync(fd, buffer, read, length - read, offset + read);
+      if (n <= 0)
+        break;
+      read += n;
+    }
+    return read === length ? buffer : buffer.subarray(0, read);
+  } finally {
+    fs2.closeSync(fd);
+  }
+}
+function readBoundedRecentLedgerWindow(directory, size) {
+  if (size === 0)
+    return Buffer.alloc(0);
+  if (size <= MAX_RECOVERY_LEDGER_BYTES) {
+    return readLedgerRegion(directory, 0, size);
   }
-  const folded = new Map;
-  for (const line of raw.split(`
+  const window = readLedgerRegion(directory, size - MAX_RECOVERY_LEDGER_BYTES, MAX_RECOVERY_LEDGER_BYTES);
+  const firstNewline = window.indexOf(10);
+  return firstNewline === -1 ? Buffer.alloc(0) : window.subarray(firstNewline + 1);
+}
+function foldLedgerTail(records, tail, strict, checkpoint) {
+  let lineNumber = 0;
+  for (const line of tail.toString("utf-8").split(`
 `)) {
+    lineNumber += 1;
     const trimmed = line.trim();
-    if (trimmed.length === 0)
+    if (!trimmed)
       continue;
     let parsedJson;
     try {
       parsedJson = JSON.parse(trimmed);
     } catch {
+      if (strict) {
+        return `background delegation ledger has malformed JSON at line ${lineNumber}`;
+      }
+      continue;
+    }
+    const parsed = RecordSchema.safeParse(parsedJson);
+    if (!parsed.success) {
+      if (strict) {
+        return `background delegation ledger has an invalid record at line ${lineNumber}`;
+      }
       continue;
     }
-    const result = RecordSchema.safeParse(parsedJson);
-    if (!result.success)
+    const existing = checkpoint ? records.get(parsed.data.correlationId) : undefined;
+    if (checkpoint && existing && !(parsed.data.updatedAt > existing.updatedAt) && !(parsed.data.updatedAt === existing.updatedAt && parsed.data.updatedAt > checkpoint.createdAt)) {
       continue;
-    folded.set(result.data.correlationId, result.data);
+    }
+    records.set(parsed.data.correlationId, parsed.data);
   }
-  return [...folded.values()];
+  return null;
 }
-function scanDelegationsForRecovery(directory) {
+function loadLegacyLedger(directory, strict) {
+  if (!strict) {
+    let raw2;
+    try {
+      raw2 = fs2.readFileSync(storePath(directory), "utf-8");
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        warn(`[background] readDelegations failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      return {
+        status: "ok",
+        mode: "legacy",
+        records: new Map,
+        manifest: null,
+        checkpoint: null
+      };
+    }
+    const records2 = new Map;
+    const foldError2 = foldLedgerTail(records2, Buffer.from(raw2, "utf-8"), false);
+    return {
+      status: "ok",
+      mode: "legacy",
+      records: records2,
+      manifest: null,
+      checkpoint: null
+    };
+  }
   let absolutePath;
   try {
     absolutePath = storePath(directory);
-    const stat = fs.statSync(absolutePath);
+    const stat = fs2.statSync(absolutePath);
     if (stat.size > MAX_RECOVERY_LEDGER_BYTES) {
       return {
         status: "uncertain",
@@ -336,7 +857,13 @@ function scanDelegationsForRecovery(directory) {
     }
   } catch (error) {
     if (error.code === "ENOENT") {
-      return { status: "ok", owners: [] };
+      return {
+        status: "ok",
+        mode: "legacy",
+        records: new Map,
+        manifest: null,
+        checkpoint: null
+      };
     }
     return {
       status: "uncertain",
@@ -345,7 +872,7 @@ function scanDelegationsForRecovery(directory) {
   }
   let raw;
   try {
-    raw = fs.readFileSync(absolutePath, "utf-8");
+    raw = fs2.readFileSync(absolutePath, "utf-8");
   } catch (error) {
     return {
       status: "uncertain",
@@ -358,33 +885,392 @@ function scanDelegationsForRecovery(directory) {
       reason: `background delegation ledger changed beyond the ${MAX_RECOVERY_LEDGER_BYTES}-byte recovery bound`
     };
   }
-  const folded = new Map;
-  let lineNumber = 0;
-  for (const line of raw.split(`
-`)) {
-    lineNumber += 1;
-    const trimmed = line.trim();
-    if (!trimmed)
+  const records = new Map;
+  const foldError = foldLedgerTail(records, Buffer.from(raw, "utf-8"), true);
+  if (foldError)
+    return { status: "uncertain", reason: foldError };
+  return {
+    status: "ok",
+    mode: "legacy",
+    records,
+    manifest: null,
+    checkpoint: null
+  };
+}
+function loadRecordsForWrite(directory) {
+  const load = loadFoldedState(directory, { strict: false });
+  if (load.status === "uncertain") {
+    recordLedgerUncertainty(directory, load.reason, "mutation", load.repairHint);
+    return null;
+  }
+  return [...load.records.values()];
+}
+function findRecordForWrite(records, correlationId) {
+  if (!records)
+    return null;
+  for (const record of records) {
+    if (record.correlationId === correlationId)
+      return record;
+  }
+  return null;
+}
+function recordLedgerUncertainty(directory, reason, source, repairHint) {
+  try {
+    writeDelegationHealthArtifact(directory, {
+      uncertainty: {
+        reason,
+        at: Date.now(),
+        source,
+        ...repairHint ? { repairHint } : {}
+      }
+    });
+  } catch {}
+}
+function isUnsettledWorktreeOwner(record) {
+  return Boolean(record.worktree) && !(record.coderSettlement?.state === "settled" && record.coderSettlement.outcome?.kind === "standard-worktree" && (record.coderSettlement.outcome.result === "merged" || record.coderSettlement.outcome.result === "unchanged"));
+}
+function isCheckpointLiveRecord(record) {
+  if (!isTerminal(record.status))
+    return true;
+  if (record.advisoryInbox?.state === "pending")
+    return true;
+  const settlement = record.coderSettlement;
+  if (settlement && settlement.state !== "settled")
+    return true;
+  if (settlement?.state === "settled" && isUnsettledWorktreeOwner(record)) {
+    return true;
+  }
+  if (isActiveCoderOwner(record))
+    return true;
+  return false;
+}
+function buildClosedSummary(record) {
+  const summary = { ...record };
+  delete summary.prompt;
+  delete summary.taskChangeContext;
+  if (summary.result) {
+    summary.result = stripResultBody(summary.result);
+  }
+  if (summary.terminalResult) {
+    summary.terminalResult = {
+      ...summary.terminalResult,
+      result: stripResultBody(summary.terminalResult.result)
+    };
+  }
+  const parsed = RecordSchema.safeParse(summary);
+  return parsed.success ? parsed.data : null;
+}
+function stripResultBody(result) {
+  const { text: _text, error: _error, ...rest } = result;
+  return rest;
+}
+function emptyAudit() {
+  return {
+    dispatchCount: 0,
+    terminalsByStatus: { completed: 0, error: 0, cancelled: 0, stale: 0 },
+    settledCount: 0,
+    preservedCount: 0,
+    lateTerminalCount: 0,
+    compactedTransitionCount: 0,
+    compactedRecordCount: 0,
+    firstDispatchAt: null,
+    lastTerminalAt: null,
+    lastCompactionAt: 0
+  };
+}
+function terminalEventStatusOf(record) {
+  if (record.terminalResult) {
+    return record.terminalResult.status;
+  }
+  if (record.status === "completed" || record.status === "error" || record.status === "cancelled" || record.status === "stale") {
+    return record.status;
+  }
+  return null;
+}
+function mergeCheckpointAudit(previous, previousCheckpoint, folded, healthLateTerminals, retiredLineCount, newlySummarizedCount, now) {
+  const prev = previous ?? emptyAudit();
+  const prevById = new Map;
+  if (previousCheckpoint) {
+    for (const record of previousCheckpoint.records) {
+      prevById.set(record.correlationId, record);
+    }
+    for (const summary of previousCheckpoint.closed) {
+      prevById.set(summary.correlationId, summary);
+    }
+  }
+  const audit = {
+    dispatchCount: prev.dispatchCount,
+    terminalsByStatus: { ...prev.terminalsByStatus },
+    settledCount: prev.settledCount,
+    preservedCount: prev.preservedCount,
+    lateTerminalCount: Math.max(prev.lateTerminalCount, healthLateTerminals),
+    compactedTransitionCount: capCounter(prev.compactedTransitionCount, retiredLineCount),
+    compactedRecordCount: capCounter(prev.compactedRecordCount, newlySummarizedCount),
+    firstDispatchAt: prev.firstDispatchAt,
+    lastTerminalAt: prev.lastTerminalAt,
+    lastCompactionAt: now
+  };
+  let minCreated = Number.POSITIVE_INFINITY;
+  let maxTerminal = 0;
+  for (const record of folded) {
+    const prevRecord = prevById.get(record.correlationId);
+    if (!prevRecord) {
+      audit.dispatchCount += 1;
+    }
+    const terminalStatus = terminalEventStatusOf(record);
+    if (terminalStatus) {
+      const prevStatus = prevRecord ? terminalEventStatusOf(prevRecord) : null;
+      if (prevStatus !== terminalStatus) {
+        audit.terminalsByStatus[terminalStatus] += 1;
+      }
+      maxTerminal = Math.max(maxTerminal, record.terminalResult?.recordedAt ?? record.completedAt ?? 0);
+    }
+    if (record.coderSettlement?.state === "settled" && prevRecord?.coderSettlement?.state !== "settled") {
+      audit.settledCount += 1;
+    }
+    if (record.coderSettlement?.state === "preserved" && prevRecord?.coderSettlement?.state !== "preserved") {
+      audit.preservedCount += 1;
+    }
+    minCreated = Math.min(minCreated, record.createdAt);
+  }
+  audit.firstDispatchAt = Number.isFinite(minCreated) ? Math.min(prev.firstDispatchAt ?? Number.POSITIVE_INFINITY, minCreated) : prev.firstDispatchAt;
+  audit.lastTerminalAt = Math.max(prev.lastTerminalAt ?? 0, maxTerminal) || null;
+  return audit;
+}
+function capCounter(previous, delta) {
+  return Number.isSafeInteger(previous + delta) ? previous + delta : Number.MAX_SAFE_INTEGER;
+}
+async function compactBackgroundDelegations(directory, options = {}) {
+  try {
+    let outcome = {
+      status: "skipped",
+      reason: "not attempted"
+    };
+    await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      outcome = compactDelegationsLocked(directory, options);
+    });
+    return outcome;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warn(`[background] compactBackgroundDelegations failed: ${message}`);
+    return { status: "uncertain", reason: message };
+  }
+}
+function compactDelegationsLocked(directory, options) {
+  const load = loadFoldedState(directory, { strict: false });
+  if (load.status === "uncertain") {
+    recordLedgerUncertainty(directory, load.reason, "compaction", load.repairHint);
+    return { status: "uncertain", reason: load.reason };
+  }
+  let ledgerBytes;
+  try {
+    ledgerBytes = fs2.readFileSync(storePath(directory));
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { status: "skipped", reason: "no ledger to compact" };
+    }
+    return {
+      status: "uncertain",
+      reason: err instanceof Error ? err.message : String(err)
+    };
+  }
+  if (ledgerBytes.length <= DELEGATION_COMPACTION_HIGH_WATER_BYTES && !options.force) {
+    return {
+      status: "skipped",
+      reason: "ledger below the compaction high-water mark"
+    };
+  }
+  const cutLedgerBytes = ledgerBytes.length;
+  const retiredLineCount = countCompleteLines(ledgerBytes);
+  const now = Date.now();
+  const folded = [...load.records.values()];
+  const live = [];
+  const closedCandidates = [];
+  for (const record of folded) {
+    if (isCheckpointLiveRecord(record)) {
+      live.push(record);
+    } else {
+      closedCandidates.push(buildClosedSummary(record) ?? record);
+    }
+  }
+  if (live.length > MAX_CHECKPOINT_RECORDS) {
+    recordLedgerUncertainty(directory, `checkpoint live-record budget exceeded (${live.length} > ${MAX_CHECKPOINT_RECORDS}); compaction skipped`, "compaction");
+    return {
+      status: "skipped",
+      reason: `live record count ${live.length} exceeds the checkpoint budget ${MAX_CHECKPOINT_RECORDS}`
+    };
+  }
+  closedCandidates.sort((a, b) => b.updatedAt - a.updatedAt);
+  const baseOverhead = Buffer.byteLength(JSON.stringify({
+    schemaVersion: 1,
+    sequence: 1,
+    writerId: WRITER_ID,
+    rootPath: path2.resolve(directory),
+    createdAt: now,
+    cutLedgerBytes,
+    cutLedgerDigest: sha256Hex(ledgerBytes),
+    records: live,
+    closed: [],
+    audit: emptyAudit(),
+    payloadChecksum: "0".repeat(64)
+  }), "utf-8");
+  let used = baseOverhead;
+  const keptClosed = [];
+  let evicted = 0;
+  for (const entry of closedCandidates) {
+    const cost = Buffer.byteLength(JSON.stringify(entry), "utf-8") + 1;
+    if (used + cost > MAX_CHECKPOINT_BYTES) {
+      if (now - entry.updatedAt < TOMBSTONE_MIN_AGE_MS) {
+        recordLedgerUncertainty(directory, "checkpoint byte budget would evict a young closed summary; compaction skipped", "compaction");
+        return {
+          status: "skipped",
+          reason: "checkpoint byte budget would evict a young closed summary"
+        };
+      }
+      evicted += 1;
       continue;
-    let parsedJson;
-    try {
-      parsedJson = JSON.parse(trimmed);
-    } catch {
-      return {
-        status: "uncertain",
-        reason: `background delegation ledger has malformed JSON at line ${lineNumber}`
-      };
     }
-    const parsed = RecordSchema.safeParse(parsedJson);
-    if (!parsed.success) {
-      return {
-        status: "uncertain",
-        reason: `background delegation ledger has an invalid record at line ${lineNumber}`
-      };
+    used += cost;
+    keptClosed.push(entry);
+  }
+  const sequence = Math.max(load.manifest?.sequence ?? 0, load.checkpoint?.sequence ?? 0, 0) + 1;
+  let healthLateTerminals = 0;
+  try {
+    const artifact = readDelegationHealthArtifact(directory);
+    healthLateTerminals = artifact?.counts.lateTerminals ?? 0;
+  } catch {
+    healthLateTerminals = 0;
+  }
+  const previousClosedIds = new Set((load.checkpoint?.closed ?? []).map((entry) => entry.correlationId));
+  const newlySummarized = keptClosed.filter((entry) => !previousClosedIds.has(entry.correlationId)).length;
+  const audit = mergeCheckpointAudit(load.checkpoint?.audit ?? null, load.checkpoint, folded, healthLateTerminals, retiredLineCount, newlySummarized + evicted, now);
+  const checkpoint = {
+    schemaVersion: 1,
+    sequence,
+    writerId: WRITER_ID,
+    rootPath: path2.resolve(directory),
+    createdAt: now,
+    cutLedgerBytes,
+    cutLedgerDigest: sha256Hex(ledgerBytes),
+    records: live,
+    closed: keptClosed,
+    audit,
+    payloadChecksum: ""
+  };
+  checkpoint.payloadChecksum = checkpointPayloadChecksum(checkpoint);
+  const checkpointJson = `${JSON.stringify(checkpoint)}
+`;
+  if (Buffer.byteLength(checkpointJson, "utf-8") > MAX_CHECKPOINT_BYTES) {
+    recordLedgerUncertainty(directory, "serialized checkpoint exceeds the byte budget; compaction skipped", "compaction");
+    return {
+      status: "skipped",
+      reason: "serialized checkpoint exceeds the byte budget"
+    };
+  }
+  writeDurableFileSync(checkpointPath(directory), checkpointJson);
+  writeDurableFileSync(manifestPath(directory), `${JSON.stringify({
+    schemaVersion: 1,
+    sequence,
+    checkpointChecksum: checkpoint.payloadChecksum,
+    writerId: WRITER_ID,
+    rootPath: checkpoint.rootPath,
+    updatedAt: now
+  })}
+`);
+  let currentSize;
+  try {
+    currentSize = fs2.statSync(storePath(directory)).size;
+  } catch (err) {
+    return {
+      status: "uncertain",
+      reason: `ledger vanished during compaction: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (currentSize < cutLedgerBytes) {
+    return {
+      status: "skipped",
+      reason: "ledger shrank during compaction; checkpoint published unrolled"
+    };
+  }
+  const tailContent = currentSize > cutLedgerBytes ? readLedgerRegion(directory, cutLedgerBytes, currentSize - cutLedgerBytes) : Buffer.alloc(0);
+  writeDurableFileSync(storePath(directory), tailContent);
+  try {
+    const pressurePct = Math.min(100, Math.round(tailContent.length / MAX_RECOVERY_LEDGER_BYTES * 1000) / 10);
+    writeDelegationHealthArtifact(directory, {
+      ledger: {
+        bytes: tailContent.length,
+        limitBytes: MAX_RECOVERY_LEDGER_BYTES,
+        pressurePct,
+        band: tailContent.length > DELEGATION_COMPACTION_HIGH_WATER_BYTES ? "compact-overdue" : tailContent.length > DELEGATION_COMPACTION_LOW_WATER_BYTES ? "nominal" : "ok"
+      },
+      checkpoint: {
+        sequence,
+        createdAt: now,
+        liveRecords: live.length,
+        closedSummaries: keptClosed.length,
+        bytes: Buffer.byteLength(checkpointJson, "utf-8"),
+        audit
+      },
+      counts: {
+        activeOwners: folded.filter((record) => isActiveCoderOwner(record)).length,
+        pendingAdvisories: folded.filter((record) => record.advisoryInbox?.state === "pending").length,
+        lateTerminals: audit.lateTerminalCount,
+        orphanWorktreeOwners: folded.filter(isUnsettledWorktreeOwner).length
+      }
+    });
+  } catch {}
+  return {
+    status: "compacted",
+    sequence,
+    tailBytes: tailContent.length,
+    checkpointBytes: Buffer.byteLength(checkpointJson, "utf-8")
+  };
+}
+function countCompleteLines(buffer) {
+  let count = 0;
+  for (const byte of buffer) {
+    if (byte === 10)
+      count += 1;
+  }
+  return count;
+}
+function maybeCompactDelegationsLocked(directory) {
+  try {
+    const stat = fs2.statSync(storePath(directory));
+    if (stat.size <= DELEGATION_COMPACTION_HIGH_WATER_BYTES)
+      return;
+    const outcome = compactDelegationsLocked(directory, {});
+    if (outcome.status === "uncertain") {
+      warn(`[background] post-append compaction skipped: ${outcome.reason}`);
     }
-    folded.set(parsed.data.correlationId, parsed.data);
+  } catch (err) {
+    warn(`[background] post-append compaction check failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function ensureSwarmDir(directory) {
+  fs2.mkdirSync(path2.resolve(directory, ".swarm"), { recursive: true });
+}
+function readDelegations(directory) {
+  const load = loadFoldedState(directory, { strict: false });
+  if (load.status === "uncertain") {
+    warn(`[background] readDelegations: authoritative state uncertain (${load.reason}); returning empty`);
+    return [];
+  }
+  return [...load.records.values()];
+}
+function scanDelegationsForRecovery(directory) {
+  const load = loadFoldedState(directory, { strict: true });
+  if (load.status === "uncertain") {
+    const manifestKind = readDelegationManifest(directory).kind;
+    return {
+      status: "uncertain",
+      reason: load.reason,
+      source: manifestKind === "absent" ? "legacy-ledger" : "unknown",
+      ...load.repairHint ? { repairHint: load.repairHint } : {}
+    };
   }
-  return { status: "ok", owners: [...folded.values()] };
+  const source = load.mode === "legacy" ? "legacy-ledger" : load.mode;
+  return { status: "ok", owners: [...load.records.values()], source };
 }
 function findByCorrelationId(directory, correlationId) {
   if (!correlationId)
@@ -397,7 +1283,7 @@ function findByCorrelationId(directory, correlationId) {
 }
 function appendRecord(directory, record) {
   ensureSwarmDir(directory);
-  fs.appendFileSync(storePath(directory), `${JSON.stringify(record)}
+  fs2.appendFileSync(storePath(directory), `${JSON.stringify(record)}
 `, "utf-8");
 }
 function buildPendingRecord(input, now) {
@@ -430,7 +1316,7 @@ function buildPendingRecord(input, now) {
     ...input.generation !== undefined ? { generation: input.generation } : {}
   };
 }
-function pendingLaunchIdentity(record) {
+function pendingLaunchIdentity(record, summaryAware) {
   return {
     correlationId: record.correlationId,
     jobId: record.jobId,
@@ -448,16 +1334,19 @@ function pendingLaunchIdentity(record) {
     ownedWorkflowLanes: record.ownedWorkflowLanes,
     promptHash: record.promptHash,
     workspace: record.workspace,
-    taskChangeContext: record.taskChangeContext,
-    workflowGeneration: record.workflowGeneration,
-    worktree: record.worktree,
-    coderReservationId: record.coderReservationId,
-    prompt: record.prompt,
-    generation: record.generation ?? 1
+    ...summaryAware ? {} : {
+      taskChangeContext: record.taskChangeContext,
+      workflowGeneration: record.workflowGeneration,
+      worktree: record.worktree,
+      coderReservationId: record.coderReservationId,
+      prompt: record.prompt,
+      generation: record.generation ?? 1
+    }
   };
 }
 function samePendingLaunchIdentity(left, right) {
-  return isDeepStrictEqual(pendingLaunchIdentity(left), pendingLaunchIdentity(right));
+  const summaryAware = isTerminal(left.status) && left.prompt === undefined && left.taskChangeContext === undefined;
+  return isDeepStrictEqual(pendingLaunchIdentity(left, summaryAware), pendingLaunchIdentity(right, summaryAware));
 }
 async function recordPendingDelegationDetailed(directory, input, options = {}) {
   const now = Date.now();
@@ -476,7 +1365,10 @@ async function recordPendingDelegationDetailed(directory, input, options = {}) {
       if (options.staleTimeoutMs && options.staleTimeoutMs > 0) {
         sweepStaleLocked(directory, options.staleTimeoutMs, now);
       }
-      const existing = findByCorrelationId(directory, parsedRecord.data.correlationId);
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
+      const existing = findRecordForWrite(records, parsedRecord.data.correlationId);
       if (existing) {
         outcome = {
           status: samePendingLaunchIdentity(existing, parsedRecord.data) ? "duplicate" : "conflict",
@@ -485,6 +1377,7 @@ async function recordPendingDelegationDetailed(directory, input, options = {}) {
         return;
       }
       appendRecord(directory, parsedRecord.data);
+      maybeCompactDelegationsLocked(directory);
       outcome = { status: "recorded", record: parsedRecord.data };
     });
     return outcome;
@@ -513,7 +1406,10 @@ async function appendDelegationTransition(directory, correlationId, transition)
   try {
     let next = null;
     await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
-      const current = findByCorrelationId(directory, correlationId);
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
+      const current = findRecordForWrite(records, correlationId);
       if (!current)
         return;
       if (isTerminal(current.status) && transition.status !== "consumed" && transition.status !== "ingestion_error" && !(current.status === "completed" && transition.status === "stale")) {
@@ -529,6 +1425,7 @@ async function appendDelegationTransition(directory, correlationId, transition)
         ...transition.result ? { result: transition.result } : {}
       };
       appendRecord(directory, next);
+      maybeCompactDelegationsLocked(directory);
     });
     return next;
   } catch (err) {
@@ -549,7 +1446,10 @@ function sameJson(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
 function sameTerminalEvent(left, right) {
-  return left.eventId === right.eventId && left.status === right.status && sameJson(left.result, right.result);
+  return left.eventId === right.eventId && left.status === right.status && sameRetainedResult(left.result, right.result);
+}
+function sameRetainedResult(left, right) {
+  return left.chars === right.chars && left.truncated === right.truncated && left.digest === right.digest && left.outputRef === right.outputRef && left.outputPreviewChars === right.outputPreviewChars && left.outputDegraded === right.outputDegraded && left.outputArtifactError === right.outputArtifactError && left.transcriptIncomplete === right.transcriptIncomplete && left.messageCount === right.messageCount && sameJson(left.salvagedWorkflowLanes, right.salvagedWorkflowLanes);
 }
 function settlementProvenanceFor(record) {
   const baseline = record.taskChangeContext?.baseline;
@@ -582,12 +1482,16 @@ async function claimTerminalResult(directory, correlationId, terminalResult) {
   let claim = null;
   try {
     await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
-      const current = findByCorrelationId(directory, correlationId);
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
+      const current = findRecordForWrite(records, correlationId);
       if (!current)
         return;
       if (current.terminalResult) {
         if (!sameTerminalEvent(current.terminalResult, parsedTerminal.data)) {
           warn(`[background] claimTerminalResult: different terminal event for ` + `correlationId=${correlationId}; ` + `existing={status: ${current.terminalResult.status}, eventId: ${current.terminalResult.eventId}} ` + `incoming={status: ${parsedTerminal.data.status}, eventId: ${parsedTerminal.data.eventId}}; ` + `rejected`);
+          incrementLateTerminalCount(directory);
           return;
         }
         claim = {
@@ -611,6 +1515,7 @@ async function claimTerminalResult(directory, correlationId, terminalResult) {
           };
         }
       }
+      const foldUpdatedAt = Math.max(parsedTerminal.data.recordedAt, current.updatedAt);
       const next = {
         ...current,
         schemaVersion: 3,
@@ -618,12 +1523,13 @@ async function claimTerminalResult(directory, correlationId, terminalResult) {
         terminalResult: parsedTerminal.data,
         result: parsedTerminal.data.result,
         completedAt: parsedTerminal.data.recordedAt,
-        updatedAt: parsedTerminal.data.recordedAt,
+        updatedAt: foldUpdatedAt,
         ...coderSettlement ? { coderSettlement } : {}
       };
       if (!RecordSchema.safeParse(next).success)
         return;
       appendRecord(directory, next);
+      maybeCompactDelegationsLocked(directory);
       claim = { disposition: "claimed", record: next };
     });
     return claim;
@@ -632,13 +1538,30 @@ async function claimTerminalResult(directory, correlationId, terminalResult) {
     return null;
   }
 }
+function incrementLateTerminalCount(directory) {
+  try {
+    const artifact = readDelegationHealthArtifact(directory);
+    const current = artifact?.counts.lateTerminals ?? 0;
+    writeDelegationHealthArtifact(directory, {
+      counts: {
+        activeOwners: artifact?.counts.activeOwners ?? 0,
+        pendingAdvisories: artifact?.counts.pendingAdvisories ?? 0,
+        lateTerminals: current + 1,
+        orphanWorktreeOwners: artifact?.counts.orphanWorktreeOwners ?? 0
+      }
+    });
+  } catch {}
+}
 async function claimCoderSettlement(directory, correlationId, operationId, input = {}) {
   if (!correlationId || !operationId || operationId.length > 256)
     return null;
   let claim = null;
   try {
     await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
-      const current = findByCorrelationId(directory, correlationId);
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
+      const current = findRecordForWrite(records, correlationId);
       if (!current || current.normalizedAgent !== "coder" || current.terminalResult?.status !== "completed") {
         return;
       }
@@ -684,6 +1607,7 @@ async function claimCoderSettlement(directory, correlationId, operationId, input
       if (!RecordSchema.safeParse(next).success)
         return;
       appendRecord(directory, next);
+      maybeCompactDelegationsLocked(directory);
       claim = {
         disposition: existing.state === "settling" ? "resume" : "claimed",
         record: next
@@ -699,10 +1623,10 @@ function normalizeObservedFile(value) {
   if (typeof value !== "string")
     return null;
   const trimmed = value.trim().replace(/\\/g, "/");
-  if (trimmed.length === 0 || trimmed.length > 4096 || trimmed.includes("\x00") || path.posix.isAbsolute(trimmed) || /^[A-Za-z]:\//.test(trimmed)) {
+  if (trimmed.length === 0 || trimmed.length > 4096 || trimmed.includes("\x00") || path2.posix.isAbsolute(trimmed) || /^[A-Za-z]:\//.test(trimmed)) {
     return null;
   }
-  const normalized = path.posix.normalize(trimmed).replace(/^\.\//, "");
+  const normalized = path2.posix.normalize(trimmed).replace(/^\.\//, "");
   if (normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.endsWith("/")) {
     return null;
   }
@@ -727,7 +1651,10 @@ async function updateCoderSettlement(directory, correlationId, input) {
   let result = null;
   try {
     await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
-      const current = findByCorrelationId(directory, correlationId);
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
+      const current = findRecordForWrite(records, correlationId);
       const existing = current?.coderSettlement;
       if (!current || !existing)
         return;
@@ -788,6 +1715,7 @@ async function updateCoderSettlement(directory, correlationId, input) {
       if (!RecordSchema.safeParse(next).success)
         return;
       appendRecord(directory, next);
+      maybeCompactDelegationsLocked(directory);
       result = next;
     });
     return result;
@@ -804,7 +1732,10 @@ async function claimDelegationIngestion(directory, correlationId, options) {
   let claim = null;
   try {
     await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
-      const current = findByCorrelationId(directory, correlationId);
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
+      const current = findRecordForWrite(records, correlationId);
       if (!current?.terminalResult)
         return;
       if (current.status === "consumed") {
@@ -843,6 +1774,7 @@ async function claimDelegationIngestion(directory, correlationId, options) {
         updatedAt: now
       };
       appendRecord(directory, next);
+      maybeCompactDelegationsLocked(directory);
       claim = { disposition, record: next };
     });
     return claim;
@@ -857,7 +1789,10 @@ async function recordDelegationIngestionResult(directory, correlationId, claimTo
   let result = null;
   try {
     await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
-      const current = findByCorrelationId(directory, correlationId);
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
+      const current = findRecordForWrite(records, correlationId);
       if (!current)
         return;
       if (success && current.status === "consumed" && current.ingestion?.state === "consumed" && current.ingestion.claimToken === claimToken || !success && current.status === "ingestion_error" && current.ingestion?.state === "retryable" && current.ingestion.claimToken === claimToken) {
@@ -880,6 +1815,7 @@ async function recordDelegationIngestionResult(directory, correlationId, claimTo
         updatedAt
       };
       appendRecord(directory, next);
+      maybeCompactDelegationsLocked(directory);
       result = next;
     });
     return result;
@@ -902,7 +1838,10 @@ async function putPendingBackgroundAdvisory(directory, correlationId, input) {
   let result = null;
   try {
     await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
-      const current = findByCorrelationId(directory, correlationId);
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
+      const current = findRecordForWrite(records, correlationId);
       if (!current?.terminalResult || current.terminalResult.eventId !== parsed.data.eventId || current.parentSessionId !== parsed.data.parentSessionId) {
         return;
       }
@@ -919,6 +1858,7 @@ async function putPendingBackgroundAdvisory(directory, correlationId, input) {
         updatedAt: createdAt
       };
       appendRecord(directory, next);
+      maybeCompactDelegationsLocked(directory);
       result = parsed.data;
     });
     return result;
@@ -935,7 +1875,10 @@ async function preparePendingBackgroundAdvisories(directory, parentSessionId, op
   const prepared = [];
   try {
     await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
-      for (const current of readDelegations(directory)) {
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
+      for (const current of records) {
         if (prepared.length >= 1)
           break;
         const advisory = current.advisoryInbox;
@@ -960,6 +1903,7 @@ async function preparePendingBackgroundAdvisories(directory, parentSessionId, op
           updatedAt: now
         };
         appendRecord(directory, next);
+        maybeCompactDelegationsLocked(directory);
         prepared.push(nextAdvisory);
       }
     });
@@ -976,8 +1920,11 @@ async function releaseBackgroundAdvisoryPreparation(directory, parentSessionId,
   }
   try {
     return await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return false;
       const byEvent = new Map;
-      for (const current of readDelegations(directory)) {
+      for (const current of records) {
         const advisory = current.advisoryInbox;
         if (advisory?.parentSessionId === parentSessionId && uniqueEventIds.includes(advisory.eventId)) {
           byEvent.set(advisory.eventId, current);
@@ -1005,6 +1952,7 @@ async function releaseBackgroundAdvisoryPreparation(directory, parentSessionId,
         };
         appendRecord(directory, next);
       }
+      maybeCompactDelegationsLocked(directory);
       return true;
     });
   } catch (err) {
@@ -1018,8 +1966,11 @@ async function acknowledgeObservedBackgroundAdvisories(directory, parentSessionI
   let acknowledged = 0;
   try {
     await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
       const now = Date.now();
-      for (const current of readDelegations(directory)) {
+      for (const current of records) {
         const advisory = current.advisoryInbox;
         if (!advisory || advisory.parentSessionId !== parentSessionId || advisory.state !== "pending" || !observedTexts.some((text) => {
           const advisoryBlock = text.match(/\[ADVISORIES\]([\s\S]*?)\[\/ADVISORIES\]/);
@@ -1046,6 +1997,8 @@ async function acknowledgeObservedBackgroundAdvisories(directory, parentSessionI
         appendRecord(directory, next);
         acknowledged += 1;
       }
+      if (acknowledged > 0)
+        maybeCompactDelegationsLocked(directory);
     });
     return acknowledged;
   } catch (err) {
@@ -1069,7 +2022,10 @@ function isTerminal(status) {
 }
 function sweepStaleLocked(directory, timeoutMs, now, statuses = DEFAULT_SWEEPABLE_DELEGATION_STATUSES) {
   let swept = 0;
-  for (const record of readDelegations(directory)) {
+  const records = loadRecordsForWrite(directory);
+  if (records === null)
+    return 0;
+  for (const record of records) {
     if (!statuses.has(record.status))
       continue;
     if (now - record.updatedAt <= timeoutMs)
@@ -1081,6 +2037,8 @@ function sweepStaleLocked(directory, timeoutMs, now, statuses = DEFAULT_SWEEPABL
     });
     swept += 1;
   }
+  if (swept > 0)
+    maybeCompactDelegationsLocked(directory);
   return swept;
 }
 async function sweepStaleDelegations(directory, timeoutMs, options = {}) {
@@ -1096,18 +2054,18 @@ async function sweepStaleDelegations(directory, timeoutMs, options = {}) {
 }
 function fallbackRelativePath(correlationId) {
   const digest = createHash("sha256").update(correlationId).digest("hex");
-  return path.join(BACKGROUND_DELEGATION_FALLBACK_DIR, `${digest}.json`);
+  return path2.join(BACKGROUND_DELEGATION_FALLBACK_DIR, `${digest}.json`);
 }
 function fallbackPath(directory, correlationId) {
   return validateSwarmPath(directory, fallbackRelativePath(correlationId));
 }
 function fallbackDirectoryPath(directory) {
-  return path.dirname(validateSwarmPath(directory, path.join(BACKGROUND_DELEGATION_FALLBACK_DIR, ".containment-anchor")));
+  return path2.dirname(validateSwarmPath(directory, path2.join(BACKGROUND_DELEGATION_FALLBACK_DIR, ".containment-anchor")));
 }
 async function readFallbackFile(directory, correlationId) {
   for (let attempt = 0;attempt < 5; attempt++) {
     try {
-      const raw = await fs.promises.readFile(fallbackPath(directory, correlationId), "utf-8");
+      const raw = await fs2.promises.readFile(fallbackPath(directory, correlationId), "utf-8");
       const parsedJson = JSON.parse(raw);
       const parsed = FallbackArtifactSchema.safeParse(parsedJson);
       if (!parsed.success || parsed.data.correlationId !== correlationId) {
@@ -1117,7 +2075,7 @@ async function readFallbackFile(directory, correlationId) {
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT" && attempt < 4) {
-        await new Promise((resolve2) => setTimeout(resolve2, 10));
+        await new Promise((resolve3) => setTimeout(resolve3, 10));
         continue;
       }
       return null;
@@ -1133,7 +2091,7 @@ async function readDelegationFallback(directory, correlationId) {
 async function listDelegationFallbacks(directory) {
   let entries;
   try {
-    entries = fs.readdirSync(fallbackDirectoryPath(directory), {
+    entries = fs2.readdirSync(fallbackDirectoryPath(directory), {
       withFileTypes: true
     }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).slice(0, MAX_LIVE_BACKGROUND_FALLBACKS);
   } catch {
@@ -1142,7 +2100,7 @@ async function listDelegationFallbacks(directory) {
   const artifacts = [];
   for (const entry of entries) {
     try {
-      const raw = await fs.promises.readFile(path.join(fallbackDirectoryPath(directory), entry.name), "utf-8");
+      const raw = await fs2.promises.readFile(path2.join(fallbackDirectoryPath(directory), entry.name), "utf-8");
       const parsed = FallbackArtifactSchema.safeParse(JSON.parse(raw));
       if (parsed.success)
         artifacts.push(parsed.data);
@@ -1155,7 +2113,7 @@ async function scanDelegationFallbacksForRecovery(directory) {
   let entries;
   try {
     fallbackDir = fallbackDirectoryPath(directory);
-    entries = fs.readdirSync(fallbackDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json"));
+    entries = fs2.readdirSync(fallbackDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json"));
   } catch (error) {
     if (error.code === "ENOENT") {
       return { status: "ok", owners: [] };
@@ -1173,17 +2131,17 @@ async function scanDelegationFallbacksForRecovery(directory) {
   }
   const artifacts = [];
   for (const entry of entries) {
-    const artifactPath = path.join(fallbackDir, entry.name);
+    const artifactPath = path2.join(fallbackDir, entry.name);
     let raw;
     try {
-      const stat = fs.statSync(artifactPath);
+      const stat = fs2.statSync(artifactPath);
       if (stat.size > MAX_RECOVERY_FALLBACK_BYTES) {
         return {
           status: "uncertain",
           reason: `background fallback artifact "${entry.name}" exceeds the recovery size bound`
         };
       }
-      raw = await fs.promises.readFile(artifactPath, "utf-8");
+      raw = await fs2.promises.readFile(artifactPath, "utf-8");
     } catch (error) {
       return {
         status: "uncertain",
@@ -1218,7 +2176,7 @@ async function scanDelegationFallbacksForRecovery(directory) {
 }
 function countFallbackFiles(directory) {
   try {
-    return fs.readdirSync(fallbackDirectoryPath(directory), {
+    return fs2.readdirSync(fallbackDirectoryPath(directory), {
       withFileTypes: true
     }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).length;
   } catch (err) {
@@ -1253,7 +2211,7 @@ async function writeDelegationFallback(directory, input, options = {}) {
       if (countFallbackFiles(directory) >= maxLive)
         return null;
       const absPath = fallbackPath(directory, input.correlationId);
-      fs.mkdirSync(path.dirname(absPath), { recursive: true });
+      fs2.mkdirSync(path2.dirname(absPath), { recursive: true });
       await bunWrite(absPath, `${JSON.stringify(parsed.data)}
 `);
       return parsed.data;
@@ -1269,7 +2227,7 @@ async function removeDelegationFallback(directory, correlationId) {
   try {
     return await withEvidenceLock(directory, BACKGROUND_DELEGATION_FALLBACK_DIR, STORE_LOCK_AGENT, FALLBACK_LOCK_TASK, async () => {
       try {
-        await fs.promises.unlink(fallbackPath(directory, correlationId));
+        await fs2.promises.unlink(fallbackPath(directory, correlationId));
         return true;
       } catch (err) {
         return err.code === "ENOENT";
@@ -1317,7 +2275,10 @@ async function promoteDelegationFallback(directory, correlationId) {
       }
       let promoted = null;
       await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
-        const current = findByCorrelationId(directory, correlationId);
+        const records = loadRecordsForWrite(directory);
+        if (records === null)
+          return;
+        const current = findRecordForWrite(records, correlationId);
         if (current) {
           if (samePromotionIdentity(current, fallback.record)) {
             promoted = current;
@@ -1325,12 +2286,13 @@ async function promoteDelegationFallback(directory, correlationId) {
           return;
         }
         appendRecord(directory, fallback.record);
+        maybeCompactDelegationsLocked(directory);
         promoted = fallback.record;
       });
       if (!promoted)
         return null;
       try {
-        await fs.promises.unlink(fallbackPath(directory, correlationId));
+        await fs2.promises.unlink(fallbackPath(directory, correlationId));
       } catch (err) {
         if (err.code !== "ENOENT") {
           return null;
@@ -1356,14 +2318,14 @@ function scanBackgroundCoderReservationsForAdmission(directory) {
   let raw;
   try {
     absolutePath = reservationStorePath(directory);
-    const stat = fs.statSync(absolutePath);
+    const stat = fs2.statSync(absolutePath);
     if (stat.size > MAX_BACKGROUND_CODER_RESERVATION_STORE_BYTES) {
       return {
         status: "uncertain",
         reason: `background coder reservation store exceeds the ${MAX_BACKGROUND_CODER_RESERVATION_STORE_BYTES}-byte safety bound`
       };
     }
-    raw = fs.readFileSync(absolutePath, "utf-8");
+    raw = fs2.readFileSync(absolutePath, "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return { status: "ok", reservations: [] };
@@ -1677,4 +2639,4 @@ async function releaseBackgroundCoderReservation(directory, input) {
   }
 }
 
-export { BACKGROUND_DELEGATIONS_FILE, BACKGROUND_DELEGATION_FALLBACK_DIR, BACKGROUND_CODER_RESERVATIONS_FILE, MAX_LIVE_BACKGROUND_FALLBACKS, MAX_LIVE_BACKGROUND_CODER_RESERVATIONS, MAX_BACKGROUND_OBSERVED_FILES, MAX_BACKGROUND_ADVISORY_CHARS, BACKGROUND_INGESTION_LEASE_MS, DEFAULT_STALE_DELEGATION_TIMEOUT_MS, DEFAULT_SWEEPABLE_DELEGATION_STATUSES, readDelegations, scanDelegationsForRecovery, findByCorrelationId, recordPendingDelegationDetailed, recordPendingDelegation, buildPromptSnapshot, appendDelegationTransition, buildBackgroundCompletionEventId, claimTerminalResult, claimCoderSettlement, normalizeBackgroundObservedFiles, updateCoderSettlement, claimDelegationIngestion, recordDelegationIngestionResult, putPendingBackgroundAdvisory, preparePendingBackgroundAdvisories, acknowledgeObservedBackgroundAdvisories, releasePreparedBackgroundAdvisories, findByBatchId, findOpenAsyncLaneBatches, sweepStaleDelegations, readDelegationFallback, listDelegationFallbacks, scanDelegationFallbacksForRecovery, writeDelegationFallback, removeDelegationFallback, findDelegationForCompletion, promoteDelegationFallback, buildBackgroundCoderReservationId, scanBackgroundCoderReservationsForAdmission, reserveBackgroundCoderSlot, bindBackgroundCoderReservation, releaseBackgroundCoderReservation };
+export { MAX_RECOVERY_LEDGER_BYTES, collectDelegationLedgerHealth, BACKGROUND_DELEGATIONS_FILE, BACKGROUND_DELEGATION_FALLBACK_DIR, BACKGROUND_CODER_RESERVATIONS_FILE, BACKGROUND_DELEGATIONS_CHECKPOINT_FILE, BACKGROUND_DELEGATIONS_MANIFEST_FILE, MAX_LIVE_BACKGROUND_FALLBACKS, MAX_LIVE_BACKGROUND_CODER_RESERVATIONS, MAX_BACKGROUND_OBSERVED_FILES, MAX_BACKGROUND_ADVISORY_CHARS, DELEGATION_COMPACTION_LOW_WATER_BYTES, DELEGATION_COMPACTION_HIGH_WATER_BYTES, MAX_CHECKPOINT_BYTES, MAX_CHECKPOINT_RECORDS, TOMBSTONE_MIN_AGE_MS, BACKGROUND_INGESTION_LEASE_MS, DEFAULT_STALE_DELEGATION_TIMEOUT_MS, DEFAULT_SWEEPABLE_DELEGATION_STATUSES, _checkpointInternals, isUnsettledWorktreeOwner, compactBackgroundDelegations, readDelegations, scanDelegationsForRecovery, findByCorrelationId, recordPendingDelegationDetailed, recordPendingDelegation, buildPromptSnapshot, appendDelegationTransition, buildBackgroundCompletionEventId, claimTerminalResult, claimCoderSettlement, normalizeBackgroundObservedFiles, updateCoderSettlement, claimDelegationIngestion, recordDelegationIngestionResult, putPendingBackgroundAdvisory, preparePendingBackgroundAdvisories, acknowledgeObservedBackgroundAdvisories, releasePreparedBackgroundAdvisories, findByBatchId, findOpenAsyncLaneBatches, sweepStaleDelegations, readDelegationFallback, listDelegationFallbacks, scanDelegationFallbacksForRecovery, writeDelegationFallback, removeDelegationFallback, findDelegationForCompletion, promoteDelegationFallback, buildBackgroundCoderReservationId, scanBackgroundCoderReservationsForAdmission, reserveBackgroundCoderSlot, bindBackgroundCoderReservation, releaseBackgroundCoderReservation };