harnery 0.44.0 → 0.45.1

package/src/core/agents/state/stale-sweep.ts

@@ -10,21 +10,12 @@
  * `coord.freshness_seconds` (see `coordFreshnessSeconds`).
  */
 
-import { existsSync, lstatSync, readdirSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
+import { existsSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
 import { coordFreshnessSeconds } from "../../config.ts";
 import { type EventAdapterIdV3, eventAdapterIdV3FromPlatform } from "../../events/v3/adapter-id.ts";
-import { withGenerationCustodyV3 } from "../../events/v3/generation-custody.ts";
-import { liveInstanceIdV3 } from "../../events/v3/live-routing.ts";
 import { writeProducerDiagnosticV3 } from "../../events/v3/producers/intake.ts";
 import { recordLiveSweepObservationV3 } from "../live-lifecycle-v3.ts";
-import {
-  captureFileRevision,
-  type DeleteFileResult,
-  deleteFileIfUnchanged,
-  type FileRecoveryResult,
-  recoverInterruptedFileDeletions,
-} from "./unchanged-file.ts";
 
 /** platform → adapter, for the swept-event envelope (mirrors heartbeat-writer's adapterOf). */
 /**
@@ -41,7 +32,6 @@ function emitSwept(
   instanceId: string,
   adapter: EventAdapterIdV3,
   sessionId: string,
-  expectedGenerationId: `gen_${string}` | null,
   reason: "stale" | "unparseable" | "missing_ts",
   ageSecs?: number,
 ): boolean {
@@ -51,7 +41,6 @@ function emitSwept(
       owner: instanceId,
       nativeSessionId: sessionId,
       adapter,
-      expectedGenerationId,
       observation:
         reason === "stale"
           ? "stale_heartbeat"
@@ -76,73 +65,13 @@ function emitSwept(
   }
 }
 
-/** Any retained or unreadable owner row prevents dependent cache deletion. */
-function retainsHeartbeat(
-  coordRoot: string,
-  activeDir: string,
-  owner: string,
-  uncertainOwners: Set<string>,
-): boolean {
-  if (uncertainOwners.has("*") || uncertainOwners.has(owner)) return true;
-  if (!/^[A-Za-z0-9_-]{1,128}$/.test(owner)) return true;
-  const heartbeat = join(activeDir, `${owner}.json`);
-  try {
-    lstatSync(heartbeat);
-    return true;
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== "ENOENT") return true;
-  }
+/** File mtime in epoch-seconds, or +Infinity if it can't be read (treat as fresh → don't reap). */
+function mtimeSecs(path: string): number {
   try {
-    if (!lstatSync(activeDir).isDirectory()) return true;
-  } catch (error) {
-    return (error as NodeJS.ErrnoException).code !== "ENOENT";
-  }
-  // Callers hold this owner's custody. A sweeper that died after the initial
-  // directory scan may have left its heartbeat hidden under a private pin.
-  for (const recovery of recoverInterruptedFileDeletions(
-    activeDir,
-    (source) => source === heartbeat,
-  )) {
-    if (recovery.sourcePath && recovery.sourcePath !== heartbeat) continue;
-    if (recovery.state !== "restored") {
-      uncertainOwners.add(recovery.sourcePath ? owner : "*");
-      recordCleanupFailure(coordRoot, recovery.sourcePath ?? activeDir, recovery);
-    }
-    return true;
-  }
-  return false;
-}
-
-function recordCleanupFailure(
-  coordRoot: string,
-  sourcePath: string,
-  result: DeleteFileResult | FileRecoveryResult,
-): void {
-  if (
-    result.state !== "error" &&
-    result.state !== "recovery-required" &&
-    result.state !== "retained"
-  ) {
-    return;
+    return Math.floor(statSync(path).mtimeMs / 1000);
+  } catch {
+    return Number.POSITIVE_INFINITY;
   }
-  writeProducerDiagnosticV3(coordRoot, "heartbeat_sweep_unrecorded", {
-    signal: "cache.cleanup",
-    state: "cache_cleanup_pending",
-    reason: `${result.state}:${result.error ?? "file_cleanup_pending"}; source=${sourcePath}; recovery=${result.recoveryPath ?? "unavailable"}`,
-  });
-}
-
-function recordHeartbeatCleanupResult(
-  coordRoot: string,
-  sourcePath: string,
-  owner: string,
-  result: DeleteFileResult,
-  uncertainOwners: Set<string>,
-): void {
-  if (result.state === "recovery-required" || result.state === "error") {
-    uncertainOwners.add(owner);
-  }
-  recordCleanupFailure(coordRoot, sourcePath, result);
 }
 
 export function staleSweep(coordRoot: string): {
@@ -176,171 +105,98 @@ export function staleSweep(coordRoot: string): {
   // lifecycle.sweep_observed; a terminal or unavailable generation gets a
   // heartbeat_sweep_unrecorded producer diagnostic without being resurrected.
   const liveInstanceIds = new Set<string>();
-  const uncertainOwners = new Set<string>();
-  const d = resolve(coordRoot, ".harnery", "active");
-  for (const recovery of existsSync(d)
-    ? recoverInterruptedFileDeletions(
-        d,
-        (source) => dirname(source) === d && /^[A-Za-z0-9_-]{1,128}\.json$/.test(basename(source)),
-      )
-    : []) {
-    if (recovery.state !== "restored") {
-      uncertainOwners.add(recovery.sourcePath ? basename(recovery.sourcePath, ".json") : "*");
-      recordCleanupFailure(coordRoot, recovery.sourcePath ?? d, recovery);
-    }
-  }
+  const d = join(coordRoot, ".harnery", "active");
   if (existsSync(d)) {
     for (const f of readdirSync(d)) {
       if (!f.endsWith(".json")) continue;
       const path = join(d, f);
       const idFromFile = f.replace(/\.json$/, "");
-      if (!/^[A-Za-z0-9_-]{1,128}$/.test(idFromFile)) continue;
+      let parsed: {
+        instance_id?: string;
+        last_heartbeat?: string;
+        platform?: unknown;
+        session_id?: string;
+      } | null = null;
       try {
-        withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(idFromFile)], () => {
-          const revision = captureFileRevision(path);
-          if (!revision) return;
-          const mtimeSecs = Number(revision.mtimeNs / 1_000_000_000n);
-          let parsed: {
-            instance_id?: string;
-            last_heartbeat?: string;
-            platform?: unknown;
-            session_id?: string;
-            v3_generation_id?: unknown;
-          } | null = null;
-          try {
-            const value = JSON.parse(revision.bytes.toString("utf8"));
-            if (value && typeof value === "object" && !Array.isArray(value)) parsed = value;
-          } catch {
-            parsed = null;
-          }
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+      } catch {
+        parsed = null;
+      }
 
-          if (parsed === null) {
-            // Unparseable: only reap if the file itself is mtime-old.
-            if (mtimeSecs < cutoff) {
-              const result = deleteFileIfUnchanged(path, revision, () =>
-                emitSwept(
-                  coordRoot,
-                  idFromFile,
-                  "claude-code",
-                  idFromFile,
-                  null,
-                  "unparseable",
-                  nowSec - mtimeSecs,
-                ),
-              );
-              recordHeartbeatCleanupResult(coordRoot, path, idFromFile, result, uncertainOwners);
-              if (result.state === "deleted") {
-                heartbeatsRemoved.push(f);
-              }
+      if (parsed === null) {
+        // Unparseable: only reap if the file itself is mtime-old.
+        if (mtimeSecs(path) < cutoff) {
+          try {
+            const ageSecs = nowSec - mtimeSecs(path);
+            if (
+              !emitSwept(coordRoot, idFromFile, "claude-code", idFromFile, "unparseable", ageSecs)
+            ) {
+              continue;
             }
-            return;
+            unlinkSync(path);
+            heartbeatsRemoved.push(f);
+          } catch {
+            /* swallow */
           }
+        }
+        continue;
+      }
 
-          // The filename selects the writer's custody scope. A conflicting content
-          // identity cannot authorize an audit or deletion for a different owner.
-          if (parsed.instance_id !== undefined && parsed.instance_id !== idFromFile) return;
-          const instanceId = parsed.instance_id ?? idFromFile;
-          const adapter = eventAdapterIdV3FromPlatform(parsed.platform, { context: "stale-sweep" });
-          const sessionId = parsed.session_id ?? instanceId;
-          const generationId =
-            typeof parsed.v3_generation_id === "string" &&
-            /^gen_[A-Za-z0-9._-]+$/.test(parsed.v3_generation_id)
-              ? (parsed.v3_generation_id as `gen_${string}`)
-              : null;
-          const ts = parsed.last_heartbeat
-            ? Math.floor(Date.parse(parsed.last_heartbeat) / 1000)
-            : Number.NaN;
-
-          if (!parsed.last_heartbeat || !Number.isFinite(ts)) {
-            // No / NaN last_heartbeat: can't trust content; gate on mtime.
-            if (mtimeSecs < cutoff) {
-              const result = deleteFileIfUnchanged(path, revision, () =>
-                emitSwept(
-                  coordRoot,
-                  instanceId,
-                  adapter,
-                  sessionId,
-                  generationId,
-                  "missing_ts",
-                  nowSec - mtimeSecs,
-                ),
-              );
-              recordHeartbeatCleanupResult(coordRoot, path, idFromFile, result, uncertainOwners);
-              if (result.state === "deleted") {
-                heartbeatsRemoved.push(f);
-              }
-            } else if (parsed.instance_id) {
-              liveInstanceIds.add(parsed.instance_id);
-            }
-            return;
-          }
+      const instanceId = parsed.instance_id ?? idFromFile;
+      const adapter = eventAdapterIdV3FromPlatform(parsed.platform, { context: "stale-sweep" });
+      const sessionId = parsed.session_id ?? instanceId;
+      const ts = parsed.last_heartbeat
+        ? Math.floor(Date.parse(parsed.last_heartbeat) / 1000)
+        : Number.NaN;
 
-          if (ts < cutoff) {
-            // Legitimate stale prune (valid timestamp, past the freshness cutoff).
-            const result = deleteFileIfUnchanged(path, revision, () =>
-              emitSwept(
-                coordRoot,
-                instanceId,
-                adapter,
-                sessionId,
-                generationId,
-                "stale",
-                nowSec - ts,
-              ),
-            );
-            recordHeartbeatCleanupResult(coordRoot, path, idFromFile, result, uncertainOwners);
-            if (result.state === "deleted") {
-              heartbeatsRemoved.push(f);
-            }
-            return;
+      if (!parsed.last_heartbeat || !Number.isFinite(ts)) {
+        // No / NaN last_heartbeat: can't trust content; gate on mtime.
+        if (mtimeSecs(path) < cutoff) {
+          if (
+            !emitSwept(
+              coordRoot,
+              instanceId,
+              adapter,
+              sessionId,
+              "missing_ts",
+              nowSec - mtimeSecs(path),
+            )
+          ) {
+            continue;
           }
+          unlinkSync(path);
+          heartbeatsRemoved.push(f);
+        } else if (parsed.instance_id) {
+          liveInstanceIds.add(parsed.instance_id);
+        }
+        continue;
+      }
 
-          if (parsed.instance_id) liveInstanceIds.add(parsed.instance_id);
-        });
-      } catch {
-        // Busy or unknown custody retains the cache and its dependent files.
-        uncertainOwners.add(idFromFile);
+      if (ts < cutoff) {
+        // Legitimate stale prune (valid timestamp, past the freshness cutoff).
+        if (!emitSwept(coordRoot, instanceId, adapter, sessionId, "stale", nowSec - ts)) {
+          continue;
+        }
+        unlinkSync(path);
+        heartbeatsRemoved.push(f);
+        continue;
       }
+
+      if (parsed.instance_id) liveInstanceIds.add(parsed.instance_id);
     }
   }
 
   // 2. Prune pid-map entries whose instance has no live heartbeat.
-  const pidmapDir = resolve(coordRoot, ".harnery", "pid-map");
-  for (const recovery of existsSync(pidmapDir)
-    ? recoverInterruptedFileDeletions(
-        pidmapDir,
-        (source) => dirname(source) === pidmapDir && /^\d+$/.test(basename(source)),
-      )
-    : [])
-    recordCleanupFailure(coordRoot, recovery.sourcePath ?? pidmapDir, recovery);
+  const pidmapDir = join(coordRoot, ".harnery", "pid-map");
   if (existsSync(pidmapDir)) {
     for (const f of readdirSync(pidmapDir)) {
-      if (f.startsWith(".harnery-delete-")) continue;
       const path = join(pidmapDir, f);
       try {
-        const revision = captureFileRevision(path);
-        if (!revision) continue;
-        const row = revision.bytes.toString("utf8").trim();
+        const row = readFileSync(path, "utf8").trim();
         const ownerId = row.split("\t")[0]?.trim() ?? "";
-        const prune = () => {
-          if (
-            !ownerId ||
-            (!liveInstanceIds.has(ownerId) &&
-              !retainsHeartbeat(coordRoot, d, ownerId, uncertainOwners))
-          ) {
-            const result = deleteFileIfUnchanged(
-              path,
-              revision,
-              () => !ownerId || !retainsHeartbeat(coordRoot, d, ownerId, uncertainOwners),
-            );
-            recordCleanupFailure(coordRoot, path, result);
-            if (result.state === "deleted") pidmapsRemoved += 1;
-          }
-        };
-        if (/^[A-Za-z0-9_-]{1,128}$/.test(ownerId)) {
-          withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(ownerId)], prune);
-        } else if (!ownerId) {
-          prune();
+        if (!ownerId || !liveInstanceIds.has(ownerId)) {
+          unlinkSync(path);
+          pidmapsRemoved += 1;
         }
       } catch {
         /* swallow */
@@ -350,16 +206,7 @@ export function staleSweep(coordRoot: string): {
 
   // 3. Prune prompt hashes for dead owners. Resource hashes retain their own
   // count so existing peer-hash telemetry keeps its original meaning.
-  const agentsDir = resolve(coordRoot, ".harnery");
-  for (const recovery of existsSync(agentsDir)
-    ? recoverInterruptedFileDeletions(
-        agentsDir,
-        (source) =>
-          dirname(source) === agentsDir &&
-          /^\.last-(?:resource|peer)-hash\.[A-Za-z0-9_-]{1,128}$/.test(basename(source)),
-      )
-    : [])
-    recordCleanupFailure(coordRoot, recovery.sourcePath ?? agentsDir, recovery);
+  const agentsDir = join(coordRoot, ".harnery");
   if (existsSync(agentsDir)) {
     for (const f of readdirSync(agentsDir)) {
       const resourceHash = f.startsWith(".last-resource-hash.");
@@ -370,25 +217,13 @@ export function staleSweep(coordRoot: string): {
         // Ignore atomic-write temporary files and preserve hashes when a
         // retained heartbeat's liveness could not be determined safely.
         if (!/^[A-Za-z0-9_-]{1,128}$/.test(owner)) continue;
+        if (existsSync(join(d, `${owner}.json`))) continue;
       }
-      if (!liveInstanceIds.has(owner) && /^[A-Za-z0-9_-]{1,128}$/.test(owner)) {
+      if (!liveInstanceIds.has(owner)) {
         try {
-          withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(owner)], () => {
-            if (retainsHeartbeat(coordRoot, d, owner, uncertainOwners)) return;
-            const path = join(agentsDir, f);
-            const revision = captureFileRevision(path);
-            if (!revision) return;
-            const result = deleteFileIfUnchanged(
-              path,
-              revision,
-              () => !retainsHeartbeat(coordRoot, d, owner, uncertainOwners),
-            );
-            recordCleanupFailure(coordRoot, path, result);
-            if (result.state === "deleted") {
-              if (resourceHash) resourceHashesRemoved += 1;
-              else peerHashesRemoved += 1;
-            }
-          });
+          unlinkSync(join(agentsDir, f));
+          if (resourceHash) resourceHashesRemoved += 1;
+          else peerHashesRemoved += 1;
         } catch {
           /* swallow */
         }

package/src/core/artifacts/activity.ts

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { lstatSync, readdirSync } from "node:fs";
+import { lstatSync, readdirSync, type Stats } from "node:fs";
 import { join } from "node:path";
 import { ARTIFACT_MANIFEST } from "./constants.ts";
 
@@ -36,11 +36,14 @@ export function artifactRootEntries(path: string): string {
  * Keep the prior root activity while its payload entries match the checkpoint.
  * A root deletion or rename changes that fingerprint; nested changes retain
  * their ordinary filesystem timestamps. Symlinks are inspected, never followed.
+ * `visit` sees every entry's lstat exactly once, including a root manifest the
+ * activity rules skip, so a caller can size the tree in the same walk.
  */
 export function readArtifactActivity(
   path: string,
   now: Date,
   previous?: ArtifactActivity,
+  visit?: (entry: string, stat: Stats) => void,
 ): ArtifactActivity {
   const entries = artifactRootEntries(path);
   const nowMs = now.getTime();
@@ -50,6 +53,7 @@ export function readArtifactActivity(
       : 0;
   const walk = (entry: string, root = false): number => {
     const stat = lstatSync(entry);
+    visit?.(entry, stat);
     let latest =
       root && previous?.root_entries_sha256 === entries
         ? accept(Date.parse(previous.last_changed_at))
@@ -58,7 +62,10 @@ export function readArtifactActivity(
       for (const name of readdirSync(entry)) {
         // Only this unit's own control manifest is metadata. Nested artifact
         // manifests are payload from the containing workspace's point of view.
-        if (root && previous && name === ARTIFACT_MANIFEST) continue;
+        if (root && previous && name === ARTIFACT_MANIFEST) {
+          if (visit) visit(join(entry, name), lstatSync(join(entry, name)));
+          continue;
+        }
         latest = Math.max(latest, walk(join(entry, name)));
       }
     }

package/src/core/artifacts/index.ts

@@ -794,11 +794,13 @@ function cleanArtifactsUnlocked(
     timeBudgetMs?: number;
   },
 ): ArtifactInventoryEntry[] {
-  const started = performance.now();
   const now = opts.now ?? new Date();
   const freshnessSeconds = opts.freshnessSeconds ?? 600;
   const rows = inventoryArtifacts(repoRoot, { now, freshnessSeconds });
   if (!opts.yes) return rows;
+  // The budget bounds deletion work. Inventory cost scales with the store, so
+  // counting it here would leave room for only the one guaranteed deletion.
+  const started = performance.now();
 
   let attempted = 0;
   return rows.map((entry) => {
@@ -1276,7 +1278,13 @@ function autoCleanArtifactsUnlocked(
       failures,
       ...(status === "completed"
         ? { last_completed_at: now.toISOString() }
-        : { retry_after: new Date(now.getTime() + 60_000).toISOString() }),
+        : {
+            // A slice that deleted something continues soon. One that made no
+            // progress would only repeat the same walk, so it waits a full interval.
+            retry_after: new Date(
+              now.getTime() + (deleted > 0 ? 60_000 : intervalMs),
+            ).toISOString(),
+          }),
     });
     return { ran: true, reason: status === "completed" ? "swept" : status, deleted, bytes };
   } catch (error) {
@@ -1340,8 +1348,7 @@ function classifyArtifactPath(
     return rowFor(path, name, repoRoot, classification, parsed.reason);
   }
   const manifest = parsed.manifest;
-  const usage = safeTreeUsage(path);
-  const lastModifiedMs = safeTreeLastModified(path, now, manifest.activity);
+  const { usage, lastModifiedMs } = scanManagedTree(path, now, manifest.activity);
   const retentionAnchorMs = Date.parse(manifest.retention.renewed_at ?? manifest.created_at);
   const retentionWindowMs = Date.parse(manifest.retention.expires_at) - retentionAnchorMs;
   const effectiveLastModifiedMs = Math.max(retentionAnchorMs, lastModifiedMs ?? 0);
@@ -2033,23 +2040,49 @@ function safeTreeUsage(path: string, seen = new Set<string>()): TreeUsage | null
   }
 }
 
-function safeTreeSize(path: string): number | null {
-  return safeTreeUsage(path)?.disk ?? null;
+function addEntryUsage(total: TreeUsage, st: Stats, seen: Set<string>): void {
+  if (st.isDirectory()) {
+    total.disk += allocatedBytes(st);
+    total.apparent += st.size;
+    return;
+  }
+  if (!st.isFile() && !st.isSymbolicLink()) return;
+  const key = `${st.dev}:${st.ino}`;
+  if (st.nlink > 1 && seen.has(key)) {
+    total.apparent += st.size;
+    return;
+  }
+  if (st.nlink > 1) seen.add(key);
+  total.disk += allocatedBytes(st);
+  total.apparent += st.size;
 }
 
 /**
- * Return the newest filesystem change in a managed tree without following
- * symlinks. A small future tolerance protects a write racing the inventory
- * scan; timestamps farther ahead are ignored as clock-skewed metadata.
+ * Size a managed tree and find its newest change in one walk, so inventory
+ * reads each entry's metadata once instead of once per question. If the
+ * activity scan fails, usage is measured on its own, as before.
  */
-function safeTreeLastModified(path: string, now: Date, activity?: ArtifactActivity): number | null {
+function scanManagedTree(
+  path: string,
+  now: Date,
+  activity?: ArtifactActivity,
+): { usage: TreeUsage | null; lastModifiedMs: number | null } {
+  const usage: TreeUsage = { disk: 0, apparent: 0 };
+  const seen = new Set<string>();
   try {
-    return Date.parse(readArtifactActivity(path, now, activity).last_changed_at);
+    const result = readArtifactActivity(path, now, activity, (_entry, st) =>
+      addEntryUsage(usage, st, seen),
+    );
+    return { usage, lastModifiedMs: Date.parse(result.last_changed_at) };
   } catch {
-    return null;
+    return { usage: safeTreeUsage(path), lastModifiedMs: null };
   }
 }
 
+function safeTreeSize(path: string): number | null {
+  return safeTreeUsage(path)?.disk ?? null;
+}
+
 function rowFor(
   path: string,
   name: string,

package/src/core/events/v3/authority-outbox.ts

@@ -16,7 +16,6 @@ import { fsyncParentDirectory } from "../../workflow/durable-record.ts";
 import { canonicalJsonV3, sha256V3 } from "./canonical.ts";
 import type { EventV3 } from "./contract.ts";
 import { liveGenesisIdV3 } from "./control.ts";
-import { assertCurrentGenerationV3, withGenerationCustodyV3 } from "./generation-custody.ts";
 import { assertEventV3 } from "./validate.ts";
 import { ensureEventV3Layout, eventV3Paths, writeEventV3 } from "./writer.ts";
 
@@ -155,32 +154,9 @@ export function publishAuthorityTransactionV3(
   coordRoot: string,
   transaction: AuthorityTransactionV3,
   fence: AuthorityEpochFenceV3 = {},
-): AuthorityTransactionV3 {
-  return withGenerationCustodyV3(
-    coordRoot,
-    [transaction.actor_instance_id, transaction.subject_instance_id],
-    () => publishAuthorityTransactionWithCustodyV3(coordRoot, transaction, fence),
-  );
-}
-
-function publishAuthorityTransactionWithCustodyV3(
-  coordRoot: string,
-  transaction: AuthorityTransactionV3,
-  fence: AuthorityEpochFenceV3,
 ): AuthorityTransactionV3 {
   validateTransaction(transaction);
   const paths = ensureEventV3Layout(coordRoot);
-  const committedPath = authorityCommittedPath(paths.authorityOutbox, transaction.transaction_id);
-  if (existsSync(committedPath)) {
-    if (
-      readAuthorityReceiptV3(committedPath).transaction_digest !==
-      sha256V3(`${canonicalJsonV3(transaction)}\n`)
-    ) {
-      throw new Error("authority committed transaction conflicts with this transaction");
-    }
-    return transaction;
-  }
-  assertTransactionGeneration(coordRoot, transaction);
   if (fence.expectedGenesisId && liveGenesisIdV3(coordRoot) !== fence.expectedGenesisId) {
     throw new Error("authority transaction epoch was replaced before publication");
   }
@@ -209,26 +185,6 @@ export function reconcileAuthorityTransactionV3(
   transactionId: string,
   reconciler: AuthorityReconcilerV3,
   fence: AuthorityEpochFenceV3 = {},
-): AuthorityReceiptV3 {
-  assertTransactionId(transactionId);
-  const paths = ensureEventV3Layout(coordRoot);
-  const committedPath = authorityCommittedPath(paths.authorityOutbox, transactionId);
-  if (existsSync(committedPath)) return readAuthorityReceiptV3(committedPath);
-  const transaction = readAuthorityTransactionV3(
-    authorityReadyPath(paths.authorityOutbox, transactionId),
-  );
-  return withGenerationCustodyV3(
-    coordRoot,
-    [transaction.actor_instance_id, transaction.subject_instance_id],
-    () => reconcileAuthorityTransactionWithCustodyV3(coordRoot, transactionId, reconciler, fence),
-  );
-}
-
-function reconcileAuthorityTransactionWithCustodyV3(
-  coordRoot: string,
-  transactionId: string,
-  reconciler: AuthorityReconcilerV3,
-  fence: AuthorityEpochFenceV3,
 ): AuthorityReceiptV3 {
   assertTransactionId(transactionId);
   const paths = ensureEventV3Layout(coordRoot);
@@ -236,10 +192,8 @@ function reconcileAuthorityTransactionWithCustodyV3(
   if (existsSync(committedPath)) return readAuthorityReceiptV3(committedPath);
   const readyPath = authorityReadyPath(paths.authorityOutbox, transactionId);
   const transaction = readAuthorityTransactionV3(readyPath);
-  assertTransactionGeneration(coordRoot, transaction);
   const current = reconciler.readStateDigest();
   if (current === transaction.expected_prior_state_digest) {
-    assertTransactionGeneration(coordRoot, transaction);
     reconciler.apply(transaction.mutation, transaction.transaction_id);
   } else if (current !== transaction.desired_state_digest) {
     throw new Error("authority transaction prior state conflicts with current state");
@@ -247,7 +201,6 @@ function reconcileAuthorityTransactionWithCustodyV3(
   if (reconciler.readStateDigest() !== transaction.desired_state_digest) {
     throw new Error("authority transaction did not reach its declared desired state");
   }
-  assertTransactionGeneration(coordRoot, transaction);
   const event = JSON.parse(transaction.event_row) as unknown;
   assertEventV3(event);
   const durability = writeEventV3(coordRoot, event, {
@@ -277,15 +230,6 @@ function reconcileAuthorityTransactionWithCustodyV3(
   return receipt;
 }
 
-function assertTransactionGeneration(coordRoot: string, transaction: AuthorityTransactionV3): void {
-  const event = JSON.parse(transaction.event_row) as EventV3;
-  assertCurrentGenerationV3(
-    coordRoot,
-    transaction.actor_instance_id,
-    "generation_id" in event.scope ? event.scope.generation_id : undefined,
-  );
-}
-
 export function listPendingAuthorityTransactionsV3(coordRoot: string): AuthorityTransactionV3[] {
   const outbox = eventV3Paths(coordRoot).authorityOutbox;
   if (!existsSync(outbox)) return [];