opencode-swarm 7.164.11 → 7.164.12

package/dist/cli/{index-zfs3zqeq.js → index-d3mpxsmy.js}

@@ -1,10 +1,21 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-zjg4chy2.js";
+} from "./index-qqq04n70.js";
+import {
+  deleteCoordinationState,
+  importCoordinationOnce,
+  listCoordinationStates,
+  transitionCoordinationState,
+  withCoordinationTransaction
+} from "./index-c45662wc.js";
+import {
+  getProjectDb,
+  projectDbExists
+} from "./index-es64amqt.js";
 import {
   observeStoreHealth
-} from "./index-dsg9dw3b.js";
+} from "./index-eed0gkv6.js";
 import {
   canonicalRootKey,
   canonicalRootKeyFresh,
@@ -12,13 +23,13 @@ import {
 } from "./index-7qefgq4j.js";
 import {
   withEvidenceLock
-} from "./index-2bgr671r.js";
+} from "./index-2bhz5k91.js";
 import {
   atomicWriteSwarmFileSync
-} from "./index-9gxbjkts.js";
+} from "./index-ewv8qa8q.js";
 import {
   telemetry
-} from "./index-ww6zm5hr.js";
+} from "./index-r2p0pgst.js";
 import {
   exports_external,
   init_zod
@@ -29,6 +40,7 @@ import {
 
 // src/background/pr-subscriptions.ts
 init_zod();
+import { createHash } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 var PR_SUBSCRIPTIONS_FILE = "pr-monitor/subscriptions.jsonl";
@@ -38,6 +50,7 @@ var LEGACY_ARCHIVE_FILE = "pr-monitor/subscriptions.legacy.jsonl";
 var FOREIGN_CHECKPOINT_FILE = "pr-monitor/subscriptions.checkpoint.foreign.json";
 var CORRUPT_CHECKPOINT_FILE = "pr-monitor/subscriptions.checkpoint.corrupt.json";
 var FOREIGN_LEGACY_FILE = "pr-monitor/subscriptions.legacy.foreign.jsonl";
+var PR_SUBSCRIPTION_COORDINATION_NAMESPACE = "background.pr-subscription";
 var STORE_LOCK_AGENT = "pr-monitor";
 var STORE_LOCK_TASK = "pr-subscriptions";
 var PR_SUBSCRIPTION_LIMITS = {
@@ -154,12 +167,482 @@ function fileExistsStrict(filePath) {
     throw err;
   }
 }
+function importedShadowPath(filePath) {
+  return `${filePath}.imported`;
+}
+function projectionMarkerPath(filePath) {
+  return `${filePath}.sqlite-projection`;
+}
 function foreignSlotPath(directory) {
   return validateSwarmPath(directory, FOREIGN_CHECKPOINT_FILE);
 }
 function corruptSlotPath(directory) {
   return validateSwarmPath(directory, CORRUPT_CHECKPOINT_FILE);
 }
+function readCoordinationSubscriptions(directory) {
+  if (!projectDbExists(directory))
+    return null;
+  try {
+    return Object.fromEntries(listCoordinationStates(directory, PR_SUBSCRIPTION_COORDINATION_NAMESPACE).map((row) => {
+      const parsed = RecordSchema.safeParse(JSON.parse(row.payload));
+      if (!parsed.success || parsed.data.correlationId !== row.entityKey || row.generation !== 1 || parsed.data.status !== row.status) {
+        throw new Error(`PR subscription coordination row failed schema or authority binding validation for ${row.entityKey}`);
+      }
+      return [row.entityKey, parsed.data];
+    }));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    log(`[pr-monitor] coordination read failed closed: ${detail}`);
+    throw new Error(`PR subscription coordination authority is unreadable: ${detail}`);
+  }
+}
+function projectionSequence(directory) {
+  const read = readCheckpoint(directory);
+  return read.kind === "ok" ? read.value.sequence : 0;
+}
+function writeCoordinationProjection(directory, view, baseCheckpoint) {
+  ensureSwarmDir(directory);
+  const prepared = prepareCoordinationPersistence(directory, view, baseCheckpoint);
+  assertCoordinationProjectionCapacity(directory, prepared.view, prepared.checkpoint);
+  const sequence = projectionSequence(directory) + 1;
+  const checkpoint = prepared.checkpoint;
+  checkpoint.sequence = sequence;
+  checkpoint.updatedAt = Date.now();
+  _internals.writeCheckpointFile(directory, checkpoint);
+  fs.writeFileSync(projectionMarkerPath(checkpointPath(directory)), "", "utf-8");
+  const legacyPath = storePath(directory);
+  if (fs.existsSync(legacyPath)) {
+    const legacyPayload = Object.values(checkpoint.records).map((entry) => JSON.stringify(entry)).join(`
+`) + (Object.keys(checkpoint.records).length > 0 ? `
+` : "");
+    writeLegacyStoreFile(legacyPath, legacyPayload);
+    fs.writeFileSync(projectionMarkerPath(legacyPath), "", "utf-8");
+    if (checkpoint.migration?.done === true) {
+      try {
+        const legacyStat = fs.statSync(legacyPath);
+        checkpoint.migration.sourceBytes = legacyStat.size;
+        checkpoint.migration.scannedBytes = legacyStat.size;
+        checkpoint.migration.sourceMtimeMs = legacyStat.mtimeMs;
+        _internals.writeCheckpointFile(directory, checkpoint);
+      } catch {}
+    }
+  }
+}
+function writeLegacyStoreFile(targetPath, content) {
+  atomicWriteSwarmFileSync(targetPath, content);
+}
+function hasLegacyReconciliationArtifacts(directory) {
+  return [
+    legacyArchiveNextPath(directory),
+    legacyArchivePreviousPath(directory)
+  ].some((filePath) => fileExistsStrict(filePath));
+}
+function loadLegacyPrSubscriptionViewStrict(directory) {
+  const checkpoint = readCheckpoint(directory);
+  if (checkpoint.kind === "invalid") {
+    throw new Error("legacy checkpoint is invalid");
+  }
+  if (checkpoint.kind === "ok") {
+    if (!sameProjectRoot(checkpoint.value.rootPath, directory)) {
+      throw new Error("legacy checkpoint belongs to a different project root");
+    }
+    const overlaid = overlayLegacy(directory, checkpoint.value);
+    if (overlaid.overLimit) {
+      throw new Error("legacy subscription source exceeds migration ceiling");
+    }
+    if (overlaid.aborted) {
+      throw new Error("legacy subscription source is unreadable");
+    }
+    return overlaid.view;
+  }
+  const legacy = storePath(directory);
+  const stat = fileSizeOrNull(legacy);
+  if (stat === null)
+    return {};
+  if (stat > PR_SUBSCRIPTION_LIMITS.legacySourceMaxBytes) {
+    throw new Error("legacy subscription source exceeds migration ceiling");
+  }
+  const fold = foldLegacyRegion(legacy, 0, Number.MAX_SAFE_INTEGER);
+  if (fold.ioError || fold.aborted) {
+    throw new Error("PR subscription legacy migration read failed (I/O error)");
+  }
+  const view = {};
+  mergeFoldedRecords(view, fold.folded);
+  return view;
+}
+function buildCoordinationProjectionCheckpoint(directory, view, baseCheckpoint) {
+  const records = { ...view };
+  const terminals = Object.values(records).filter((entry) => entry.status !== "active");
+  const current = readCheckpoint(directory);
+  const checkpoint = baseCheckpoint ? cloneCheckpoint(baseCheckpoint) : current.kind === "ok" && sameProjectRoot(current.value.rootPath, directory) ? cloneCheckpoint(current.value) : freshCheckpoint(directory);
+  const priorSummary = { ...checkpoint.terminalSummary };
+  checkpoint.records = records;
+  checkpoint.terminalSummary = {
+    removed: priorSummary.removed,
+    expired: priorSummary.expired,
+    lastTerminalAt: terminals.length ? Math.max(priorSummary.lastTerminalAt ?? 0, ...terminals.map((entry) => entry.updatedAt)) : priorSummary.lastTerminalAt
+  };
+  checkpoint.rootPath = path.resolve(directory);
+  return checkpoint;
+}
+function assertCoordinationProjectionCapacity(directory, view, baseCheckpoint) {
+  const checkpoint = buildCoordinationProjectionCheckpoint(directory, view, baseCheckpoint);
+  const recordCount = Object.keys(checkpoint.records).length;
+  if (recordCount > PR_SUBSCRIPTION_LIMITS.maxCheckpointRecords) {
+    throw new Error(`PR subscription store over checkpoint capacity: ${recordCount} records > ${PR_SUBSCRIPTION_LIMITS.maxCheckpointRecords}. The folded state exceeds the bounded checkpoint \u2014 archive or split .swarm/pr-monitor/subscriptions.jsonl (subscriptions can be re-created with /swarm pr subscribe), then remove it.`);
+  }
+  const contentBytes = Buffer.byteLength(`${JSON.stringify(checkpoint)}
+`, "utf-8");
+  if (contentBytes > PR_SUBSCRIPTION_LIMITS.checkpointHardReadBytes) {
+    throw new Error(`PR subscription store over checkpoint capacity: ${contentBytes} bytes > ${PR_SUBSCRIPTION_LIMITS.checkpointHardReadBytes}. The folded state exceeds the bounded checkpoint \u2014 archive or split .swarm/pr-monitor/subscriptions.jsonl (subscriptions can be re-created with /swarm pr subscribe), then remove it.`);
+  }
+}
+function prepareCoordinationPersistence(directory, view, baseCheckpoint) {
+  const preparedView = { ...view };
+  const checkpoint = buildCoordinationProjectionCheckpoint(directory, preparedView, baseCheckpoint);
+  const compacted = compactTerminalRecords(preparedView, checkpoint) !== null;
+  checkpoint.records = { ...preparedView };
+  return { view: preparedView, checkpoint, compacted };
+}
+function coordinationShadowDigest(directory) {
+  const hash = createHash("sha256");
+  for (const filePath of [
+    storePath(directory),
+    checkpointPath(directory),
+    auditPath(directory)
+  ]) {
+    if (!fileExistsStrict(filePath))
+      continue;
+    hash.update(path.basename(filePath));
+    hash.update(fs.readFileSync(filePath));
+  }
+  return hash.digest("hex");
+}
+function isDeepStrictEqualByJson(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function coordinationProjectionMatches(directory, view) {
+  try {
+    const legacyPath = storePath(directory);
+    if (!fileExistsStrict(legacyPath)) {
+      const checkpointRead = readCheckpoint(directory);
+      if (checkpointRead.kind !== "ok")
+        return false;
+      const prepared = prepareCoordinationPersistence(directory, view, checkpointRead.value).checkpoint;
+      return isDeepStrictEqualByJson(checkpointRead.value.records, prepared.records) && isDeepStrictEqualByJson(checkpointRead.value.terminalSummary, prepared.terminalSummary);
+    }
+    return isDeepStrictEqualByJson(loadLegacyPrSubscriptionViewStrict(directory), view);
+  } catch {
+    return false;
+  }
+}
+function coordinationImportShadowState(directory) {
+  if (!projectDbExists(directory))
+    return "absent";
+  const statement = getProjectDb(directory).prepare("SELECT source_digest FROM coordination_import WHERE source = ?");
+  try {
+    const row = statement.get(PR_SUBSCRIPTIONS_CHECKPOINT_FILE);
+    if (!row)
+      return "absent";
+    return row.source_digest === coordinationShadowDigest(directory) ? "matches" : "mismatch";
+  } finally {
+    statement.finalize();
+  }
+}
+function legacyProjectionFingerprintMatches(directory, checkpoint) {
+  const migration = checkpoint.migration;
+  const legacyPath = storePath(directory);
+  if (!fileExistsStrict(legacyPath))
+    return true;
+  if (!fileExistsStrict(projectionMarkerPath(legacyPath)) || !migration?.done) {
+    return false;
+  }
+  try {
+    const stat = fs.statSync(legacyPath);
+    return stat.size === migration.sourceBytes && stat.mtimeMs === migration.sourceMtimeMs;
+  } catch {
+    return false;
+  }
+}
+function archiveShadowFileBestEffort(filePath) {
+  if (!fileExistsStrict(filePath))
+    return;
+  const importedPath = importedShadowPath(filePath);
+  if (fileExistsStrict(importedPath))
+    return;
+  try {
+    renameWithRetry(filePath, importedPath);
+  } catch (error) {
+    log(`[pr-monitor] shadow archive failed for ${path.basename(filePath)}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function retireAuthoritativeLegacyShadow(directory) {
+  const legacyPath = storePath(directory);
+  if (!fileExistsStrict(legacyPath))
+    return true;
+  if (fileExistsStrict(projectionMarkerPath(legacyPath)))
+    return true;
+  const importedPath = importedShadowPath(legacyPath);
+  try {
+    if (!fileExistsStrict(importedPath)) {
+      _internals.renameWithRetry(legacyPath, importedPath);
+    } else {
+      fs.unlinkSync(legacyPath);
+    }
+    return !fileExistsStrict(legacyPath);
+  } catch (error) {
+    log(`[pr-monitor] authoritative legacy shadow retirement failed: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
+}
+function ensurePrSubscriptionCoordinationImported(directory, createIfNeeded) {
+  if (!createIfNeeded && !projectDbExists(directory))
+    return false;
+  const coordinationView = readCoordinationSubscriptions(directory);
+  if (coordinationView !== null && Object.keys(coordinationView).length > 0) {
+    const checkpointRead2 = readCheckpoint(directory);
+    const migrationPending = checkpointRead2.kind === "ok" && sameProjectRoot(checkpointRead2.value.rootPath, directory) && checkpointRead2.value.migration?.done === false;
+    if (migrationPending)
+      return false;
+    const legacyPath = storePath(directory);
+    if (fileExistsStrict(legacyPath) && !fileExistsStrict(projectionMarkerPath(legacyPath))) {
+      let legacyStat2 = null;
+      try {
+        legacyStat2 = _internals.statSync(legacyPath);
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw new Error(`PR subscription legacy migration read failed (I/O error); refusing mutation: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      if (legacyStat2 && legacyStat2.size > PR_SUBSCRIPTION_LIMITS.migrationMaxBytesPerOperation && (checkpointRead2.kind !== "ok" || checkpointRead2.value.migration === null || checkpointRead2.value.migration.done === false)) {
+        return false;
+      }
+    }
+    if (fileExistsStrict(legacyPath)) {
+      let legacyStat2 = null;
+      try {
+        legacyStat2 = _internals.statSync(legacyPath);
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw new Error(`PR subscription legacy migration read failed (I/O error); refusing mutation: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      if (legacyStat2 && legacyStat2.size > PR_SUBSCRIPTION_LIMITS.migrationMaxBytesPerOperation && (checkpointRead2.kind !== "ok" || checkpointRead2.value.migration === null || checkpointRead2.value.migration.done === false)) {
+        return false;
+      }
+    }
+    const projectionNeedsRepair = !fileExistsStrict(projectionMarkerPath(checkpointPath(directory))) || fileExistsStrict(legacyPath) && !fileExistsStrict(projectionMarkerPath(legacyPath)) || !coordinationProjectionMatches(directory, coordinationView);
+    if (projectionNeedsRepair) {
+      const checkpointProjectionPublished = fileExistsStrict(projectionMarkerPath(checkpointPath(directory)));
+      const settledProjection = checkpointProjectionPublished && checkpointRead2.kind === "ok" && (checkpointRead2.value.migration === null || checkpointRead2.value.migration.archived === true);
+      const importShadowState = coordinationImportShadowState(directory);
+      if (importShadowState === "mismatch" && !settledProjection || !checkpointProjectionPublished && importShadowState !== "matches" || hasLegacyReconciliationArtifacts(directory)) {
+        return false;
+      }
+      for (const filePath of [
+        storePath(directory),
+        checkpointPath(directory),
+        auditPath(directory)
+      ]) {
+        archiveShadowFileBestEffort(filePath);
+      }
+      writeCoordinationProjection(directory, coordinationView);
+    }
+    return true;
+  }
+  const hasLegacyArtifacts = [
+    storePath(directory),
+    checkpointPath(directory),
+    auditPath(directory),
+    legacyArchivePath(directory)
+  ].some((filePath) => fileExistsStrict(filePath));
+  if (!hasLegacyArtifacts)
+    return createIfNeeded || projectDbExists(directory);
+  const checkpointRead = readCheckpoint(directory);
+  const baseCheckpoint = checkpointRead.kind === "ok" && sameProjectRoot(checkpointRead.value.rootPath, directory) ? cloneCheckpoint(checkpointRead.value) : undefined;
+  if (checkpointRead.kind === "invalid" || checkpointRead.kind === "ok" && !sameProjectRoot(checkpointRead.value.rootPath, directory)) {
+    return false;
+  }
+  let legacyStat = null;
+  try {
+    legacyStat = _internals.statSync(storePath(directory));
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw new Error(`PR subscription legacy migration read failed (I/O error); refusing mutation: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (legacyStat !== null && legacyStat.size > PR_SUBSCRIPTION_LIMITS.migrationMaxBytesPerOperation && (checkpointRead.kind !== "ok" || checkpointRead.value.migration === null || checkpointRead.value.migration.done === false)) {
+    return false;
+  }
+  const legacyView = loadLegacyPrSubscriptionViewStrict(directory);
+  const preparedImport = prepareCoordinationPersistence(directory, legacyView, baseCheckpoint);
+  if (legacyStat) {
+    preparedImport.checkpoint.migration = {
+      scannedBytes: legacyStat.size,
+      sourceBytes: legacyStat.size,
+      sourceMtimeMs: legacyStat.mtimeMs,
+      corruptLines: preparedImport.checkpoint.maintenance.corruptLegacyRecords,
+      discardingOversizeLine: false,
+      baselineRecords: {},
+      baselineTerminalSummary: {
+        removed: 0,
+        expired: 0,
+        lastTerminalAt: null
+      },
+      done: true,
+      archived: false,
+      startedAt: Date.now()
+    };
+  }
+  assertCoordinationProjectionCapacity(directory, preparedImport.view, preparedImport.checkpoint);
+  const outcome = importCoordinationOnce(directory, {
+    source: PR_SUBSCRIPTIONS_CHECKPOINT_FILE,
+    sourceDigest: coordinationShadowDigest(directory),
+    rowCount: Object.keys(preparedImport.view).length,
+    emptyNamespace: PR_SUBSCRIPTION_COORDINATION_NAMESPACE
+  }, () => {
+    for (const record of Object.values(preparedImport.view)) {
+      const payload = JSON.stringify(record);
+      const result = transitionCoordinationState(directory, {
+        namespace: PR_SUBSCRIPTION_COORDINATION_NAMESPACE,
+        entityKey: record.correlationId,
+        expectedRevision: null,
+        generation: 1,
+        status: record.status,
+        payload
+      });
+      if (result.outcome !== "applied") {
+        throw new Error(`subscription import failed for ${record.correlationId}: ${result.outcome}`);
+      }
+    }
+  });
+  const importedView = readCoordinationSubscriptions(directory) ?? preparedImport.view;
+  if (outcome !== "state_exists") {
+    for (const filePath of [
+      storePath(directory),
+      checkpointPath(directory),
+      auditPath(directory),
+      legacyArchivePath(directory)
+    ]) {
+      archiveShadowFileBestEffort(filePath);
+    }
+    const importedLegacy = importedShadowPath(storePath(directory));
+    if (legacyStat) {
+      if (!fileExistsStrict(storePath(directory)) && fileExistsStrict(importedLegacy)) {
+        fs.copyFileSync(importedLegacy, storePath(directory));
+      } else if (fileExistsStrict(storePath(directory)) && !fileExistsStrict(importedLegacy)) {
+        fs.copyFileSync(storePath(directory), importedLegacy);
+      }
+    }
+  }
+  writeCoordinationProjection(directory, importedView, preparedImport.checkpoint);
+  if (outcome !== "state_exists" && preparedImport.checkpoint.migration) {
+    if (fileExistsStrict(storePath(directory))) {
+      const projected = _internals.statSync(storePath(directory));
+      legacyStat = projected;
+      preparedImport.checkpoint.migration.sourceBytes = projected.size;
+      preparedImport.checkpoint.migration.scannedBytes = projected.size;
+      preparedImport.checkpoint.migration.sourceMtimeMs = projected.mtimeMs;
+    }
+    const archiveEvent = maybeArchiveLegacy(directory, preparedImport.checkpoint);
+    if (archiveEvent) {
+      preparedImport.checkpoint.sequence += 1;
+      preparedImport.checkpoint.updatedAt = Date.now();
+      _internals.writeCheckpointFile(directory, preparedImport.checkpoint);
+      flushAuditEvents(directory, [{ kind: "migrate-complete" }, archiveEvent], preparedImport.checkpoint.sequence, preparedImport.checkpoint.maintenance);
+      emitHealthTelemetry(directory, "migrate-complete", preparedImport.checkpoint);
+      emitHealthTelemetry(directory, "archive", preparedImport.checkpoint);
+    } else {
+      if (legacyStat) {
+        try {
+          const currentLegacyStat = _internals.statSync(storePath(directory));
+          if (currentLegacyStat.size !== legacyStat.size || currentLegacyStat.mtimeMs !== legacyStat.mtimeMs) {
+            try {
+              fs.unlinkSync(projectionMarkerPath(storePath(directory)));
+            } catch (error) {
+              if (error.code !== "ENOENT") {
+                return false;
+              }
+            }
+            return false;
+          }
+        } catch {
+          return false;
+        }
+      }
+      flushAuditEvents(directory, [{ kind: "migrate-complete" }], preparedImport.checkpoint.sequence, preparedImport.checkpoint.maintenance);
+      emitHealthTelemetry(directory, "migrate-complete", preparedImport.checkpoint);
+    }
+  }
+  return true;
+}
+function canUseCoordinationWritePath(directory) {
+  if (hasLegacyReconciliationArtifacts(directory))
+    return false;
+  const checkpoint = readCheckpoint(directory);
+  if (checkpoint.kind === "ok" && checkpoint.value.migration?.done === false) {
+    return false;
+  }
+  const ensured = ensurePrSubscriptionCoordinationImported(directory, true);
+  return ensured;
+}
+function persistCoordinationSubscriptions(directory, view, writeProjection = true, events = []) {
+  const prepared = prepareCoordinationPersistence(directory, view);
+  if (writeProjection) {
+    writeCoordinationProjection(directory, prepared.view, prepared.checkpoint);
+  }
+  withCoordinationTransaction(directory, () => {
+    const current = new Map(listCoordinationStates(directory, PR_SUBSCRIPTION_COORDINATION_NAMESPACE).map((row) => [row.entityKey, row]));
+    const nextIds = new Set(Object.keys(prepared.view));
+    for (const [entityKey, row] of current) {
+      if (nextIds.has(entityKey))
+        continue;
+      const deleted = deleteCoordinationState(directory, PR_SUBSCRIPTION_COORDINATION_NAMESPACE, entityKey, row.revision);
+      if (!deleted) {
+        throw new Error(`subscription delete conflict for ${entityKey}`);
+      }
+    }
+    for (const record of Object.values(prepared.view)) {
+      const row = current.get(record.correlationId);
+      const payload = JSON.stringify(record);
+      const result = transitionCoordinationState(directory, {
+        namespace: PR_SUBSCRIPTION_COORDINATION_NAMESPACE,
+        entityKey: record.correlationId,
+        expectedRevision: row?.revision ?? null,
+        generation: 1,
+        status: record.status,
+        payload,
+        event: {
+          streamId: record.correlationId,
+          idempotencyKey: createHash("sha256").update(payload).digest("hex"),
+          eventType: record.status,
+          payload
+        }
+      });
+      if (result.outcome !== "applied" && result.outcome !== "duplicate") {
+        throw new Error(`subscription write failed for ${record.correlationId}: ${result.outcome}`);
+      }
+    }
+  });
+  if (events.length === 0)
+    return;
+  const checkpoint = readCheckpoint(directory);
+  if (checkpoint.kind !== "ok")
+    return;
+  const auditCompaction = prepareAuditCompaction(directory);
+  if (applyAuditCompaction(directory, auditCompaction) && auditCompaction) {
+    checkpoint.value.maintenance.droppedAuditTransitions += auditCompaction.dropped;
+    try {
+      _internals.writeCheckpointFile(directory, checkpoint.value);
+    } catch (error) {
+      log(`[pr-monitor] audit accounting write deferred: ${storageErrorCode(error)}`);
+    }
+  }
+  flushAuditEvents(directory, events, checkpoint.value.sequence, checkpoint.value.maintenance);
+  if (prepared.compacted) {
+    emitHealthTelemetry(directory, "compact", prepared.checkpoint);
+  }
+}
 function foreignLegacySlotPath(directory) {
   return validateSwarmPath(directory, FOREIGN_LEGACY_FILE);
 }
@@ -508,6 +991,25 @@ function validateRecord(record) {
     throw new Error(`Invalid subscription record: ${result.error.message}`);
   }
 }
+function snapshotUpdateHasChanges(match, updates) {
+  const immutableKeys = new Set([
+    "correlationId",
+    "sessionID",
+    "prNumber",
+    "repoFullName",
+    "prUrl",
+    "createdAt",
+    "updatedAt"
+  ]);
+  for (const [key, value] of Object.entries(updates)) {
+    if (immutableKeys.has(key))
+      continue;
+    if (!Object.is(match[key], value)) {
+      return true;
+    }
+  }
+  return false;
+}
 function writeCheckpointFile(directory, checkpoint) {
   const recordCount = Object.keys(checkpoint.records).length;
   if (recordCount > PR_SUBSCRIPTION_LIMITS.maxCheckpointRecords) {
@@ -837,8 +1339,7 @@ function reconcileLegacyArchiveStaging(directory, migration) {
     archiveExists = true;
     previousExists = false;
     if (nextExists) {
-      _internals.renameWithRetry(next, legacy);
-      migration.archived = false;
+      fs.unlinkSync(next);
       legacyExists = true;
       nextExists = false;
     }
@@ -995,11 +1496,66 @@ function overlayLegacy(directory, checkpoint) {
   };
 }
 async function loadViewForRead(directory) {
+  if (ensurePrSubscriptionCoordinationImported(directory, false)) {
+    const coordinationView = readCoordinationSubscriptions(directory) ?? {};
+    const checkpointRead = readCheckpoint(directory);
+    if (checkpointRead.kind === "ok" && sameProjectRoot(checkpointRead.value.rootPath, directory) && checkpointRead.value.migration?.done === false) {
+      const pendingCheckpoint = cloneCheckpoint(checkpointRead.value);
+      pendingCheckpoint.records = {
+        ...pendingCheckpoint.records,
+        ...coordinationView
+      };
+      const overlaid = overlayLegacy(directory, pendingCheckpoint);
+      return {
+        view: overlaid.view,
+        recoverySource: overlaid.usedLegacy ? "checkpoint+legacy" : "checkpoint"
+      };
+    }
+    return {
+      view: coordinationView,
+      recoverySource: "checkpoint"
+    };
+  }
   const read = readCheckpoint(directory);
+  const pendingCoordination = readCoordinationSubscriptions(directory);
+  if (read.kind === "ok" && sameProjectRoot(read.value.rootPath, directory) && read.value.migration?.done === false && pendingCoordination !== null && Object.keys(pendingCoordination).length > 0) {
+    const pendingCheckpoint = cloneCheckpoint(read.value);
+    pendingCheckpoint.records = {
+      ...pendingCheckpoint.records,
+      ...pendingCoordination
+    };
+    const overlaid = overlayLegacy(directory, pendingCheckpoint);
+    return {
+      view: overlaid.view,
+      recoverySource: overlaid.usedLegacy ? "checkpoint+legacy" : "checkpoint"
+    };
+  }
   if (read.kind === "ok") {
     if (!sameProjectRoot(read.value.rootPath, directory)) {
       return { view: {}, recoverySource: "foreign" };
     }
+    if (read.value.migration?.done === true) {
+      if (!legacyProjectionFingerprintMatches(directory, read.value)) {
+        if (fileExistsStrict(legacyArchivePath(directory))) {
+          retireAuthoritativeLegacyShadow(directory);
+          return {
+            view: { ...read.value.records },
+            recoverySource: "checkpoint"
+          };
+        }
+        const overlaid2 = overlayLegacy(directory, read.value);
+        if (overlaid2.usedLegacy && !overlaid2.aborted) {
+          return {
+            view: overlaid2.view,
+            recoverySource: "checkpoint+legacy"
+          };
+        }
+      }
+      return {
+        view: { ...read.value.records },
+        recoverySource: "checkpoint"
+      };
+    }
     const overlaid = overlayLegacy(directory, read.value);
     return {
       view: overlaid.view,
@@ -1123,6 +1679,7 @@ function loadViewForWrite(directory) {
   let reboundForeign = false;
   let checkpoint;
   const read = readCheckpoint(directory);
+  let archiveDeferredForExternalRewrite = false;
   if (read.kind === "ok" && sameProjectRoot(read.value.rootPath, directory)) {
     checkpoint = cloneCheckpoint(read.value);
   } else if (read.kind === "ok") {
@@ -1188,7 +1745,9 @@ function loadViewForWrite(directory) {
     legacyStat = null;
   if (legacyStat === null) {
     view = { ...checkpoint.records };
-    if (checkpoint.migration?.done && !checkpoint.migration.archived) {
+    const importedShadowExists = fileExistsStrict(importedShadowPath(legacy));
+    const archiveExists = fileExistsStrict(legacyArchivePath(directory));
+    if (checkpoint.migration?.done && !checkpoint.migration.archived && (archiveExists || !importedShadowExists)) {
       checkpoint.migration.archived = true;
       dirty = true;
     }
@@ -1198,6 +1757,21 @@ function loadViewForWrite(directory) {
     warnLegacyOverLimit(directory, legacyStat.size);
     throw new Error(`PR subscription legacy store exceeds the ${PR_SUBSCRIPTION_LIMITS.legacySourceMaxBytes}-byte migration ceiling; refusing mutation until the file is archived or split`);
   }
+  if (checkpoint.migration?.done === true && checkpoint.migration.archived && legacyProjectionFingerprintMatches(directory, checkpoint)) {
+    checkpoint.migration.archived = false;
+    dirty = true;
+  }
+  if (checkpoint.migration?.done === true && !legacyProjectionFingerprintMatches(directory, checkpoint)) {
+    try {
+      fs.unlinkSync(projectionMarkerPath(legacy));
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+    checkpoint.migration = null;
+    dirty = true;
+    archiveDeferredForExternalRewrite = true;
+  }
   const legacySize = legacyStat.size;
   const legacyMtime = legacyStat.mtimeMs;
   const migration = checkpoint.migration;
@@ -1265,7 +1839,8 @@ function loadViewForWrite(directory) {
         warnMigrationCapacity(directory, Object.keys(view).length);
         break;
       }
-      if (!fold.eof) {
+      const deferLargeInitialGeneration = !sameGeneration && legacySize > PR_SUBSCRIPTION_LIMITS.migrationMaxBytesPerOperation && foldedThisOperation >= PR_SUBSCRIPTION_LIMITS.migrationMaxBytesPerOperation;
+      if (!fold.eof || deferLargeInitialGeneration) {
         const progress = cloneCheckpoint(checkpoint);
         progress.records = { ...view };
         progress.migration = {
@@ -1303,7 +1878,7 @@ function loadViewForWrite(directory) {
           lastTerminalAt: null
         },
         done: true,
-        archived: false,
+        archived: archiveDeferredForExternalRewrite,
         startedAt
       };
       audit.push({ kind: "migrate-complete" });
@@ -1315,17 +1890,15 @@ function loadViewForWrite(directory) {
     }
     return { checkpoint, view, audit, dirty };
   }
-  const overlaid = overlayLegacy(directory, checkpoint);
-  view = overlaid.view;
-  if (overlaid.usedLegacy && !overlaid.aborted) {
-    migration.sourceBytes = legacySize;
-    migration.sourceMtimeMs = legacyMtime;
-    migration.scannedBytes = legacySize;
-    migration.archived = false;
-    checkpoint.maintenance.corruptLegacyRecords += overlaid.corruptLines;
-    dirty = true;
+  if (!legacyProjectionFingerprintMatches(directory, checkpoint)) {
+    const legacyPath = storePath(directory);
+    if (fileExistsStrict(projectionMarkerPath(legacyPath))) {
+      const overlaid = overlayLegacy(directory, checkpoint);
+      return { checkpoint, view: overlaid.view, audit, dirty };
+    }
+    retireAuthoritativeLegacyShadow(directory);
   }
-  return { checkpoint, view, audit, dirty };
+  return { checkpoint, view: { ...checkpoint.records }, audit, dirty };
 }
 function finalizeWrite(directory, loaded, opAudit) {
   const { checkpoint } = loaded;
@@ -1352,6 +1925,23 @@ function finalizeWrite(directory, loaded, opAudit) {
   checkpoint.sequence += 1;
   const auditCompaction = prepareAuditCompaction(directory);
   persistCheckpointWithAuditCompaction(directory, checkpoint, auditCompaction);
+  if (checkpoint.migration?.done === true) {
+    const legacyPath = storePath(directory);
+    try {
+      let legacyStat = fs.statSync(legacyPath);
+      if (legacyStat.size !== checkpoint.migration.sourceBytes || legacyStat.mtimeMs !== checkpoint.migration.sourceMtimeMs) {
+        const legacyPayload = Object.values(checkpoint.records).map((entry) => JSON.stringify(entry)).join(`
+`) + (Object.keys(checkpoint.records).length > 0 ? `
+` : "");
+        writeLegacyStoreFile(legacyPath, legacyPayload);
+        fs.writeFileSync(projectionMarkerPath(legacyPath), "", "utf-8");
+        legacyStat = fs.statSync(legacyPath);
+      }
+      checkpoint.migration.sourceBytes = legacyStat.size;
+      checkpoint.migration.scannedBytes = legacyStat.size;
+      checkpoint.migration.sourceMtimeMs = legacyStat.mtimeMs;
+    } catch {}
+  }
   flushAuditEvents(directory, events, checkpoint.sequence, checkpoint.maintenance);
   const archiveEvent = maybeArchiveLegacy(directory, checkpoint);
   if (archiveEvent) {
@@ -1361,6 +1951,10 @@ function finalizeWrite(directory, loaded, opAudit) {
     flushAuditEvents(directory, [archiveEvent], checkpoint.sequence, checkpoint.maintenance);
   }
   cleanupStaleLegacyArchive(directory);
+  const coordinationView = readCoordinationSubscriptions(directory);
+  if (coordinationView !== null && !isDeepStrictEqualByJson(coordinationView, loaded.view)) {
+    persistCoordinationSubscriptions(directory, { ...loaded.view });
+  }
   for (const kind of [
     "compact",
     "migrate-complete",
@@ -1392,6 +1986,42 @@ async function subscribe(directory, input) {
   const correlationId = buildCorrelationId(input.sessionID, input.repoFullName, input.prNumber);
   const now = Date.now();
   return withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+    if (canUseCoordinationWritePath(directory)) {
+      const view = readCoordinationSubscriptions(directory) ?? {};
+      const match2 = Object.values(view).find((r) => r.correlationId === correlationId && r.status === "active");
+      if (match2) {
+        onSubscriptionCreated?.(directory, match2);
+        return match2;
+      }
+      if (input.maxSubscriptions === undefined || input.maxSubscriptions > 0) {
+        const limit = input.maxSubscriptions !== undefined ? input.maxSubscriptions : PR_SUBSCRIPTION_LIMITS.defaultMaxActiveSubscriptions;
+        const activeCount = Object.values(view).filter((r) => r.status === "active").length;
+        if (activeCount >= limit) {
+          throw new Error(`PR subscription limit reached: ${activeCount}/${limit}`);
+        }
+      }
+      const record2 = {
+        correlationId,
+        sessionID: input.sessionID,
+        prNumber: input.prNumber,
+        repoFullName: input.repoFullName,
+        prUrl: input.prUrl,
+        lastCheckedAt: now,
+        isWatching: true,
+        hasUnaddressedEvents: false,
+        status: "active",
+        createdAt: now,
+        updatedAt: now,
+        errorCount: 0
+      };
+      validateRecord(record2);
+      view[correlationId] = record2;
+      persistCoordinationSubscriptions(directory, view, true, [
+        { kind: "subscribe", correlationId }
+      ]);
+      onSubscriptionCreated?.(directory, record2);
+      return record2;
+    }
     const loaded = loadViewForWrite(directory);
     const match = Object.values(loaded.view).find((r) => r.correlationId === correlationId && r.status === "active");
     if (match) {
@@ -1432,6 +2062,24 @@ async function unsubscribe(directory, correlationId) {
   if (!correlationId)
     return null;
   return withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+    if (canUseCoordinationWritePath(directory)) {
+      const view = readCoordinationSubscriptions(directory) ?? {};
+      const match2 = Object.values(view).find((r) => r.correlationId === correlationId && r.status === "active");
+      if (!match2) {
+        return null;
+      }
+      const removed2 = {
+        ...match2,
+        status: "removed",
+        isWatching: false,
+        updatedAt: Date.now()
+      };
+      view[correlationId] = removed2;
+      persistCoordinationSubscriptions(directory, view, true, [
+        { kind: "unsubscribe", correlationId }
+      ]);
+      return removed2;
+    }
     const loaded = loadViewForWrite(directory);
     const match = Object.values(loaded.view).find((r) => r.correlationId === correlationId && r.status === "active");
     if (!match) {
@@ -1470,12 +2118,65 @@ async function updateSnapshot(directory, correlationId, updates) {
   if (!correlationId)
     return null;
   return withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+    const existingCoordination = readCoordinationSubscriptions(directory);
+    if (existingCoordination !== null && !fileExistsStrict(storePath(directory)) && !hasLegacyReconciliationArtifacts(directory)) {
+      const match2 = Object.values(existingCoordination).find((r) => r.correlationId === correlationId && r.status === "active");
+      if (!match2)
+        return null;
+      if (!snapshotUpdateHasChanges(match2, updates)) {
+        return match2;
+      }
+      const updated2 = {
+        ...match2,
+        ...updates,
+        correlationId,
+        sessionID: match2.sessionID,
+        repoFullName: match2.repoFullName,
+        prNumber: match2.prNumber,
+        prUrl: match2.prUrl,
+        createdAt: match2.createdAt,
+        updatedAt: Date.now()
+      };
+      validateRecord(updated2);
+      existingCoordination[correlationId] = updated2;
+      persistCoordinationSubscriptions(directory, existingCoordination);
+      return updated2;
+    }
+    if (canUseCoordinationWritePath(directory)) {
+      const view = readCoordinationSubscriptions(directory) ?? {};
+      const match2 = Object.values(view).find((r) => r.correlationId === correlationId && r.status === "active");
+      if (!match2) {
+        return null;
+      }
+      if (!snapshotUpdateHasChanges(match2, updates)) {
+        return match2;
+      }
+      const updated2 = {
+        ...match2,
+        ...updates,
+        correlationId,
+        sessionID: match2.sessionID,
+        repoFullName: match2.repoFullName,
+        prNumber: match2.prNumber,
+        prUrl: match2.prUrl,
+        createdAt: match2.createdAt,
+        updatedAt: Date.now()
+      };
+      validateRecord(updated2);
+      view[correlationId] = updated2;
+      persistCoordinationSubscriptions(directory, view);
+      return updated2;
+    }
     const loaded = loadViewForWrite(directory);
     const match = Object.values(loaded.view).find((r) => r.correlationId === correlationId && r.status === "active");
     if (!match) {
       finalizeWrite(directory, loaded, []);
       return null;
     }
+    if (!snapshotUpdateHasChanges(match, updates)) {
+      finalizeWrite(directory, loaded, []);
+      return match;
+    }
     const updated = {
       ...match,
       ...updates,
@@ -1501,6 +2202,36 @@ async function sweepStale(directory, ttlDays, mergedPrs) {
   const now = Date.now();
   try {
     return await withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      if (canUseCoordinationWritePath(directory)) {
+        const view = readCoordinationSubscriptions(directory) ?? {};
+        let swept2 = 0;
+        const expiredCorrelationIds = [];
+        const now2 = Date.now();
+        for (const record of Object.values(view)) {
+          if (record.status !== "active")
+            continue;
+          const prKey = `${record.repoFullName}::${record.prNumber}`;
+          const isMerged = mergedPrs?.has(prKey) ?? false;
+          const isStale = now2 - record.updatedAt > ttlMs;
+          if (isMerged || isStale && !record.hasUnaddressedEvents) {
+            view[record.correlationId] = {
+              ...record,
+              status: "expired",
+              isWatching: false,
+              updatedAt: now2
+            };
+            expiredCorrelationIds.push(record.correlationId);
+            swept2 += 1;
+          }
+        }
+        if (swept2 > 0) {
+          persistCoordinationSubscriptions(directory, view, true, expiredCorrelationIds.map((correlationId) => ({
+            kind: "expired",
+            correlationId
+          })));
+        }
+        return swept2;
+      }
       const loaded = loadViewForWrite(directory);
       const opAudit = [];
       let swept = 0;
@@ -1552,7 +2283,18 @@ async function sweepStale(directory, ttlDays, mergedPrs) {
 }
 async function getPrSubscriptionHealth(directory) {
   try {
+    const coordinationView = readCoordinationSubscriptions(directory);
     const read = readCheckpoint(directory);
+    const migrationPending = read.kind === "ok" && sameProjectRoot(read.value.rootPath, directory) && read.value.migration?.done === false;
+    if (coordinationView !== null && Object.keys(coordinationView).length > 0 && !migrationPending) {
+      const audit2 = auditStats(directory);
+      const archiveBytes2 = fileSizeOrNull(legacyArchivePath(directory)) ?? 0;
+      const checkpointBytes2 = fileSizeOrNull(checkpointPath(directory)) ?? 0;
+      const health2 = healthFromView(coordinationView, buildCoordinationProjectionCheckpoint(directory, coordinationView));
+      health2.recoverySource = "checkpoint";
+      applyFileStats(health2, checkpointBytes2, audit2, archiveBytes2);
+      return health2;
+    }
     const audit = auditStats(directory);
     const archiveBytes = fileSizeOrNull(legacyArchivePath(directory)) ?? 0;
     const checkpointBytes = fileSizeOrNull(checkpointPath(directory)) ?? 0;
@@ -1587,7 +2329,15 @@ async function getPrSubscriptionHealth(directory) {
       }
       health.recoverySource = legacySize === null ? "empty" : "legacy-log";
     } else {
-      const overlaid = overlayLegacy(directory, read.value);
+      const pendingCheckpoint = migrationPending && coordinationView !== null ? (() => {
+        const merged = cloneCheckpoint(read.value);
+        merged.records = {
+          ...merged.records,
+          ...coordinationView
+        };
+        return merged;
+      })() : read.value;
+      const overlaid = overlayLegacy(directory, pendingCheckpoint);
       health = healthFromView(overlaid.view, read.value);
       health.recoverySource = overlaid.usedLegacy ? "checkpoint+legacy" : "checkpoint";
     }