@indigoai-us/hq-cloud 6.18.49-alpha.7 → 6.18.49

package/dist/bin/sync-runner-watch-loop.js

@@ -1,7 +1,6 @@
 import * as os from "os";
 import * as path from "path";
 import * as fs from "fs";
-import { createHash } from "node:crypto";
 import { MULTIPART_PART_SIZE_BYTES } from "../sync/multipart-uploader.js";
 import * as v8 from "node:v8";
 import { performance } from "node:perf_hooks";
@@ -16,17 +15,13 @@ import { TRANSIENT_NETWORK_EXIT } from "../lib/net-errors.js";
 import { PARTIAL_SYNC_EXIT, UNRESOLVED_COMPANY_EXIT, } from "../lib/exit-codes.js";
 import { getOrCreateMachineIdMetadata } from "../lib/machine-id.js";
 import { localPathForVaultKey } from "../local-path-codec.js";
-import { isEphemeralPath } from "../cli/share.js";
-import { cloudAuthoritativePathClass, isLocallyIneligibleForPush, } from "../lib/cloud-authoritative.js";
-import { inspectLocalSymlinkScope } from "../symlink-target-policy.js";
 import { shouldRecordLocalDeleteIntent } from "../local-replacement.js";
 import { createIgnoreFilter } from "../ignore.js";
-import { wrapFilterWithPersonalVaultDefaults } from "../personal-vault-exclusions.js";
 import { TreeWatcher, resolveEventDebounceConfig, systemClock, } from "../watcher.js";
 import { recoverHqRootLocalState } from "../hq-root-recovery.js";
 import { clearLocalDeleteIntent, getStateDir, markLocalDeleteIntent, PERSONAL_VAULT_JOURNAL_SLUG, openJournalStoreSession, openJournalStoreSessionAsync, listJournalSlugs, isCorruptJournalJson, maintainAreaJournalSlice, disposeScopedJournalStores, releaseScopedJournalStore, releaseCachedAreaJournalMigrations, recoverCachedAreaJournalMirrorIfNeeded, setAreaLedgerRecoveryHqRootForProcess, journalCacheCensusSizes, emitJournalCacheMetric, journalRows, readJournalScoped, readJournalScopedAsync, applyJournalDeltaAsync, } from "../journal.js";
-import { isPersonalVaultDeletionExcluded, readCloudBackedSlugsFromManifest, } from "../personal-vault.js";
-import { NoopPushReceiver, ReceiverDispatchError, RealtimePushYieldError, isReceiverTransportFailure, } from "../sync/push-receiver.js";
+import { isPersonalVaultDeletionExcluded } from "../personal-vault.js";
+import { NoopPushReceiver, ReceiverDispatchError, isReceiverTransportFailure, } from "../sync/push-receiver.js";
 import { CONTENT_HASH_PATTERN } from "../sync/push-event.js";
 import { resolveEventSync, startEventSync as defaultStartEventSync, } from "../sync/event-sync.js";
 import { resolveAreaStorageEnabled, resolveEffectiveParallelSyncRollout, resolveParallelSyncRollout, } from "../sync/feature-flags.js";
@@ -268,35 +263,12 @@ export class CooperativePassScheduler {
     get hasActiveSlowRealtime() {
         return this.active?.workClass === "realtime" && this.active.lane === "slow";
     }
-    get isInCapYield() {
-        return this.capYieldDepth > 0;
-    }
     /** Includes the running slow/fast lanes and hand-off occupants; it never changes their cap. */
     get activeRealtimeWorkerCount() {
         return ((this.active?.workClass === "realtime" ? 1 : 0) +
             (this.activeFastRealtime === null ? 0 : 1) +
             this.realtimeOccupants.size);
     }
-    get diagnosticAdmissionSnapshot() {
-        const active = [
-            this.active,
-            this.activeFastRealtime,
-            ...this.realtimeOccupants,
-            this.detachedChore,
-        ].filter((entry) => entry !== null);
-        const holders = active.map((entry) => ({
-            kind: entry.transferDirection === "pull"
-                ? "pull"
-                : entry.workClass === "chore"
-                    ? "chore"
-                    : "push",
-            scope: entry.label.slice(0, 160),
-        }));
-        return {
-            queueDepth: this.pending.filter((entry) => entry.workClass === "realtime").length,
-            holders: holders.slice(0, 20),
-        };
-    }
     pendingLaneCount(lane) {
         return this.pending.filter((entry) => entry.lane === lane).length;
     }
@@ -1320,53 +1292,6 @@ export function isChoreLocalPush(paths, largeUpload) {
     }
     return count > 0;
 }
-/** Keep warm-up route telemetry useful on large checkouts without unbounded logs. */
-export function watcherWarmupPathsByRoute(relativePaths) {
-    const counts = new Map();
-    for (const relativePath of relativePaths) {
-        const route = routeChangeToTarget(relativePath);
-        const key = route ? routeKey(route) : "unrouted";
-        counts.set(key, (counts.get(key) ?? 0) + 1);
-    }
-    const ranked = [...counts.entries()].sort(([leftKey, leftCount], [rightKey, rightCount]) => rightCount - leftCount || leftKey.localeCompare(rightKey));
-    const result = {};
-    for (const [key, count] of ranked.slice(0, 20))
-        result[key] = count;
-    const other = ranked.slice(20).reduce((sum, [, count]) => sum + count, 0);
-    if (other > 0)
-        result.other = other;
-    return result;
-}
-export function watcherWarmupPrefixesByRoute(relativePaths) {
-    const counts = new Map();
-    for (const relativePath of relativePaths) {
-        const route = routeChangeToTarget(relativePath);
-        const key = route ? routeKey(route) : "unrouted";
-        const routePath = route?.kind === "company"
-            ? relativePath.slice(`companies/${route.slug}/`.length)
-            : relativePath;
-        const prefix = routePath.split("/").slice(0, 2).join("/") || "(root)";
-        const routeCounts = counts.get(key) ?? new Map();
-        routeCounts.set(prefix, (routeCounts.get(prefix) ?? 0) + 1);
-        counts.set(key, routeCounts);
-    }
-    const result = {};
-    for (const [route, routeCounts] of [...counts.entries()].sort(([a], [b]) => a.localeCompare(b)).slice(0, 20)) {
-        const ranked = [...routeCounts.entries()].sort(([leftKey, leftCount], [rightKey, rightCount]) => rightCount - leftCount || leftKey.localeCompare(rightKey));
-        const top = {};
-        for (const [prefix, count] of ranked.slice(0, 5))
-            top[prefix] = count;
-        const other = ranked.slice(5).reduce((sum, [, count]) => sum + count, 0);
-        if (other > 0)
-            top.other = other;
-        result[route] = top;
-    }
-    const otherRoutes = [...counts.entries()].sort(([a], [b]) => a.localeCompare(b)).slice(20);
-    if (otherRoutes.length > 0) {
-        result.other = { other: otherRoutes.reduce((sum, [, routeCounts]) => sum + [...routeCounts.values()].reduce((routeSum, count) => routeSum + count, 0), 0) };
-    }
-    return result;
-}
 /** A receiver event needs a known small upsert size before it can go realtime. */
 export function isFastReceiverBatch(eventCount) {
     return eventCount > 0 && eventCount <= resolveFastLaneLimits().maxFiles;
@@ -1620,9 +1545,14 @@ function unresolvedReceiverMessagesWereRedelivered(events, receiveCountsByPath)
             receiveCounts.every((count) => count !== undefined && Number.isFinite(count) && count >= 2);
     });
 }
-function targetedReceiverDispatchError(outcome, accepted, authRequiredExitCode) {
+export function targetedReceiverDispatchError(outcome, accepted, authRequiredExitCode) {
     const exitCode = passExitCode(outcome);
     const result = typeof outcome === "number" ? undefined : outcome.result;
+    const httpStatus = [
+        ...(result?.errors ?? []),
+        ...(result?.transient ?? []),
+        ...(result?.companyFailures ?? []),
+    ].find((failure) => failure.httpStatus !== undefined)?.httpStatus;
     const diagnostics = [
         ...(result?.errors ?? []).map(({ company, message }) => `${company}: ${message}`),
         ...(result?.transient ?? []).map(({ company, message }) => `${company}: ${message}`),
@@ -1630,11 +1560,15 @@ function targetedReceiverDispatchError(outcome, accepted, authRequiredExitCode)
     ];
     const failureReason = `targeted pull failed with exit code ${exitCode}, accepted=${accepted}` +
         (diagnostics.length === 0 ? "" : `: ${[...new Set(diagnostics)].join("; ")}`);
-    const isTransportFailure = exitCode === authRequiredExitCode ||
-        exitCode === TRANSIENT_NETWORK_EXIT ||
-        (result?.transient?.length ?? 0) > 0 ||
-        isReceiverTransportFailure(failureReason);
-    return new ReceiverDispatchError(isTransportFailure ? "transport" : "path-specific", failureReason);
+    const exitKind = exitCode === authRequiredExitCode
+        ? "auth_required"
+        : exitCode === TRANSIENT_NETWORK_EXIT || (result?.transient?.length ?? 0) > 0
+            ? "transient_network"
+            : undefined;
+    const errorCode = ["ENOSPC", "EDQUOT", "EACCES", "EPERM"].find((code) => diagnostics.some((diagnostic) => new RegExp(`\\b${code}\\b`).test(diagnostic)));
+    const transportTextMatch = exitKind === undefined && isReceiverTransportFailure(failureReason);
+    const isTransportFailure = exitKind !== undefined || transportTextMatch;
+    return new ReceiverDispatchError(isTransportFailure ? "transport" : "path-specific", failureReason, { exitCode, errorCode, exitKind, transportTextMatch, httpStatus, rawExit: typeof outcome === "number" });
 }
 /**
  * Exit code for one scoped/catch-up route. A 404 company route returns
@@ -1829,10 +1763,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
     let recycleRequested = null;
     const pendingAppliedUpserts = new Map();
     const pendingAppliedDeletes = new Set();
-    const uploadedAwaitingPublish = new Set();
-    const UPLOADED_AWAITING_PUBLISH_BATCH_SIZE = 1_000;
-    const UPLOADED_AWAITING_PUBLISH_CAP = 10_000;
-    let uploadedAwaitingPublishDropLogged = false;
     const rememberAppliedUpsert = (relativePath, contentHash) => {
         pendingAppliedDeletes.delete(relativePath);
         if (eventSyncLive && eventSync) {
@@ -1863,23 +1793,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             pendingAppliedDeletes.delete(oldest);
         }
     };
-    const flushPendingUploadEvents = () => {
-        if (!eventSyncLive || !eventSync || uploadedAwaitingPublish.size === 0)
-            return;
-        while (uploadedAwaitingPublish.size > 0) {
-            const uploadedPaths = [...uploadedAwaitingPublish].slice(0, UPLOADED_AWAITING_PUBLISH_BATCH_SIZE);
-            const paths = new Map(uploadedPaths.map((relativePath) => [
-                localPathForVaultKey(hqRoot, relativePath),
-                relativePath,
-            ]));
-            const expanded = expandDirectoryPublishPaths(paths, uploadedPaths);
-            if (expanded.size > 0)
-                eventSync.publishBatch({ paths: expanded });
-            for (const relativePath of uploadedPaths) {
-                uploadedAwaitingPublish.delete(relativePath);
-            }
-        }
-    };
     const flushPendingAppliedUpserts = () => {
         if (!eventSyncLive || !eventSync)
             return;
@@ -1891,7 +1804,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             eventSync.markContentDeleted?.(relativePath);
         }
         pendingAppliedDeletes.clear();
-        flushPendingUploadEvents();
     };
     // `activeSlowPass` is assigned before its task has necessarily acquired the
     // cross-process lock (it may be waiting behind a rescue or a second runner).
@@ -1942,7 +1854,7 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
         refresh.unref?.();
     }
     const passScheduler = new CooperativePassScheduler(monotonicNow, CHORE_STARVATION_CAP_MS, { caps: fullPassCaps });
-    const runPassWithLock = async (passArgvForRun, prepare, lane = "slow", workClass = "chore", checkpoint, telemetry, pullSignal, receiverSignal, watcherPushStage) => {
+    const runPassWithLock = async (passArgvForRun, prepare, lane = "slow", workClass = "chore", checkpoint, telemetry, pullSignal, receiverSignal) => {
         const passCheckpoint = pullSignal || receiverSignal
             ? Object.assign(async () => checkpoint?.(), {
                 shouldYieldToRealtime: checkpoint?.shouldYieldToRealtime,
@@ -1972,43 +1884,20 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             }
         };
         const invokePass = () => {
-            watcherPushStage?.("pass invocation");
-            activePassCount += 1;
-            emitSyncWorkState(true);
-            const trackPass = (pass) => {
-                const complete = () => {
-                    watcherPushStage?.("pass return");
-                    activePassCount = Math.max(0, activePassCount - 1);
-                    emitSyncWorkState(true);
-                };
-                // Observe settlement without returning a chained promise to the pass
-                // scheduler. The scheduler's synchronous test seam and watcher wake
-                // ordering depend on the original pass promise's completion turn.
-                void pass.then(complete, complete);
-                return pass;
-            };
-            try {
-                if (!runPassSupportsCooperativeCheckpoint) {
-                    if (!runPassSupportsQmdLifecycle)
-                        return trackPass(runPass(passArgvForRun));
-                    return trackPass(runPass(passArgvForRun, undefined, undefined, undefined, undefined, qmdShutdownController.signal, writeMaintenanceProgress, idleHeartbeatIntervalMs));
-                }
-                // This callback is emitted by the production runner after journal
-                // repair/seed and before fanout. It starts ingress early, but never
-                // admits a second durable writer: queued realtime still waits for the
-                // existing scheduler's cooperative hand-off checkpoint.
-                const onJournalsReady = () => activateEventPushSurfaces();
-                if (!runPassSupportsQmdLifecycle) {
-                    return trackPass(runPass(passArgvForRun, passCheckpoint, onJournalsReady, recordDurableAppliedUpserts, workClass));
-                }
-                return trackPass(runPass(passArgvForRun, passCheckpoint, onJournalsReady, recordDurableAppliedUpserts, workClass, qmdShutdownController.signal, writeMaintenanceProgress, idleHeartbeatIntervalMs, recordDurableAppliedDeletes));
+            if (!runPassSupportsCooperativeCheckpoint) {
+                if (!runPassSupportsQmdLifecycle)
+                    return runPass(passArgvForRun);
+                return runPass(passArgvForRun, undefined, undefined, undefined, undefined, qmdShutdownController.signal, writeMaintenanceProgress, idleHeartbeatIntervalMs);
             }
-            catch (error) {
-                watcherPushStage?.("pass return");
-                activePassCount = Math.max(0, activePassCount - 1);
-                emitSyncWorkState(true);
-                throw error;
+            // This callback is emitted by the production runner after journal
+            // repair/seed and before fanout. It starts ingress early, but never
+            // admits a second durable writer: queued realtime still waits for the
+            // existing scheduler's cooperative hand-off checkpoint.
+            const onJournalsReady = () => activateEventPushSurfaces();
+            if (!runPassSupportsQmdLifecycle) {
+                return runPass(passArgvForRun, passCheckpoint, onJournalsReady, recordDurableAppliedUpserts, workClass);
             }
+            return runPass(passArgvForRun, passCheckpoint, onJournalsReady, recordDurableAppliedUpserts, workClass, qmdShutdownController.signal, writeMaintenanceProgress, idleHeartbeatIntervalMs, recordDurableAppliedDeletes);
         };
         // Observe the heap at pass boundaries — a gated checkpoint immediately before
         // admitting a pass and immediately after it returns. A pass that runs a long
@@ -2023,11 +1912,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                 return;
             recordDurableAppliedUpserts(outcome.result?.appliedUpserts ?? []);
             recordDurableAppliedDeletes(outcome.result?.appliedDeletes ?? []);
-            rememberUploadedPaths(outcome);
-            if (typeof outcome !== "number") {
-                acknowledgeDurableWatcherUploads(outcome.result?.uploadedPaths ?? []);
-            }
-            flushPendingUploadEvents();
         };
         // Pre-admit boundary observation.
         heapCheckpoint?.();
@@ -2278,25 +2162,15 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
         // watcher fast path explicitly opts into its established scoped exception.
         return passScheduler.submit(task, workClass, lane, allowFastRealtimeOvertake, signal, resourceCap, allowFlaggedRealtimeHandoff, transferDirection, transferSizeClass, holderLabel);
     };
-    const runGuarded = (passArgvForRun, prepare, lane = "slow", workClass = "chore", allowFastRealtimeOvertake = false, signal, resourceCap = false, telemetry, allowConcurrentHandoff = false, receiverSignal, holderLabel = workClass === "chore" && resourceCap ? "full-reconcile" : workClass, watcherPushStage) => {
-        if (watcherPushStage) {
-            watcherPushStage("guarded scheduler admission requested");
-            const admission = passScheduler.diagnosticAdmissionSnapshot;
-            if (passScheduler.isInCapYield)
-                watcherPushStage("CPU/heap cap wait");
-            else if (admission.holders.some((holder) => holder.kind === "pull")) {
-                watcherPushStage("pull-yield wait");
-            }
-        }
+    const runGuarded = (passArgvForRun, prepare, lane = "slow", workClass = "chore", allowFastRealtimeOvertake = false, signal, resourceCap = false, telemetry, allowConcurrentHandoff = false, receiverSignal, holderLabel = workClass === "chore" && resourceCap ? "full-reconcile" : workClass) => {
         telemetry?.mark("operationGate");
         const admissionSignal = signal && receiverSignal
             ? AbortSignal.any([signal, receiverSignal])
             : signal ?? receiverSignal;
         return runGuardedTask((context) => {
-            watcherPushStage?.("guarded scheduler admission granted");
             telemetry?.mark("appendLock");
             telemetry?.setOccupancy(passScheduler.activeRealtimeWorkerCount);
-            return runPassWithLock(passArgvForRun, prepare, lane, workClass, workClass === "chore" ? context.checkpoint : undefined, telemetry, context.signal, receiverSignal, watcherPushStage);
+            return runPassWithLock(passArgvForRun, prepare, lane, workClass, workClass === "chore" ? context.checkpoint : undefined, telemetry, context.signal, receiverSignal);
         }, lane, workClass, allowFastRealtimeOvertake, admissionSignal, resourceCap, allowConcurrentHandoff, telemetry?.direction, telemetry?.sizeClass, holderLabel);
     };
     /*
@@ -2418,7 +2292,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             return {
                 result: execution.result ?? (allRefused ? 0 : 1),
                 accepted,
-                yieldedToPush: outcome.paths.some((path) => path.reason === "yielded to queued watcher push"),
                 coordinatorRefusedPaths: normalizeCoordinatorPaths(outcome.paths
                     .filter((path) => path.status === "refused")
                     .map((path) => path.path)),
@@ -2616,172 +2489,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
     /** Vanished never-journaled file deletes removed from batches at drain time. */
     let drainedUntrackedDeletes = 0;
     const pendingWatcherPaths = new Map();
-    const durableWatcherPaths = new Map();
-    const durableWatcherPathLimit = 10_000;
-    let durableWatcherOverflowed = false;
-    let durableWatcherPersistTimer;
-    let durableWatcherPersistQueue = Promise.resolve();
-    let durableWatcherPersistGeneration = 0;
-    let durableWatcherPersistedGeneration = 0;
-    const watcherPushStatePath = path.join(getStateDir(), "sync-runner", `watcher-push-${createHash("sha256").update(hqRoot).digest("hex").slice(0, 20)}.json`);
-    const persistDurableWatcherPaths = () => {
-        const generation = durableWatcherPersistGeneration;
-        if (generation === durableWatcherPersistedGeneration)
-            return durableWatcherPersistQueue;
-        const snapshot = durableWatcherOverflowed
-            ? { format: 1, hqRoot, overflowed: true }
-            : { format: 1, hqRoot, paths: [...durableWatcherPaths.values()] };
-        durableWatcherPersistQueue = durableWatcherPersistQueue.then(async () => {
-            try {
-                if (!durableWatcherOverflowed && durableWatcherPaths.size === 0) {
-                    await fs.promises.rm(watcherPushStatePath, { force: true });
-                    durableWatcherPersistedGeneration = Math.max(durableWatcherPersistedGeneration, generation);
-                    return;
-                }
-                await fs.promises.mkdir(path.dirname(watcherPushStatePath), { recursive: true, mode: 0o700 });
-                const tempPath = `${watcherPushStatePath}.${process.pid}.tmp`;
-                await fs.promises.writeFile(tempPath, JSON.stringify(snapshot), { mode: 0o600 });
-                await fs.promises.rename(tempPath, watcherPushStatePath);
-                durableWatcherPersistedGeneration = Math.max(durableWatcherPersistedGeneration, generation);
-            }
-            catch (err) {
-                process.stderr.write(`hq-sync-runner: watcher push state persistence failed: ${describeError(err)}\n`);
-            }
-        }).catch((err) => {
-            process.stderr.write(`hq-sync-runner: watcher push state persistence failed: ${describeError(err)}\n`);
-        });
-        return durableWatcherPersistQueue;
-    };
-    const scheduleDurableWatcherPersist = () => {
-        durableWatcherPersistGeneration += 1;
-        if (durableWatcherPersistTimer !== undefined)
-            clearTimeout(durableWatcherPersistTimer);
-        durableWatcherPersistTimer = setTimeout(() => {
-            durableWatcherPersistTimer = undefined;
-            void persistDurableWatcherPaths();
-        }, 1_000);
-        durableWatcherPersistTimer.unref?.();
-    };
-    const addDurableWatcherPath = (absolutePath, relativePath) => {
-        if (durableWatcherOverflowed)
-            return;
-        if (!durableWatcherPaths.has(absolutePath) && durableWatcherPaths.size >= durableWatcherPathLimit) {
-            durableWatcherPaths.clear();
-            durableWatcherOverflowed = true;
-        }
-        else if (!durableWatcherOverflowed) {
-            durableWatcherPaths.set(absolutePath, relativePath);
-        }
-        scheduleDurableWatcherPersist();
-    };
-    const clearDurableWatcherOverflow = () => {
-        if (!durableWatcherOverflowed)
-            return;
-        durableWatcherOverflowed = false;
-        durableWatcherPaths.clear();
-        for (const [absolutePath, relativePath] of pendingWatcherPaths) {
-            addDurableWatcherPath(absolutePath, relativePath);
-        }
-        scheduleDurableWatcherPersist();
-    };
-    const acknowledgeDurableWatcherUploads = (relativePaths) => {
-        let changed = false;
-        const uploaded = new Set(relativePaths);
-        for (const [absolutePath, relativePath] of durableWatcherPaths) {
-            if (!uploaded.has(relativePath))
-                continue;
-            durableWatcherPaths.delete(absolutePath);
-            changed = true;
-        }
-        if (changed)
-            scheduleDurableWatcherPersist();
-    };
-    const acknowledgeDurableWatcherPathsCoveredByFullPass = (relativePaths) => {
-        const stillPending = new Set(pendingWatcherPaths.values());
-        acknowledgeDurableWatcherUploads(relativePaths.filter((relativePath) => !stillPending.has(relativePath)));
-    };
-    let activePassCount = 0;
-    let inFlightWatcherPushes = 0;
-    const watcherPushStages = new Map();
-    let nextWatcherPushGroupId = 0;
-    const setWatcherPushStage = (groupId, stage) => {
-        const record = watcherPushStages.get(groupId);
-        if (!record || record.stage === stage)
-            return;
-        record.stage = stage;
-        record.stageEnteredAt = Date.now();
-        process.stderr.write(`${JSON.stringify({
-            type: "watcher-push-group-stage",
-            diagnostic: true,
-            groupId: record.groupId,
-            route: record.route,
-            paths: record.paths,
-            stage: record.stage,
-            stageEnteredAt: new Date(record.stageEnteredAt).toISOString(),
-        })}\n`);
-    };
-    const startWatcherPushStageTracking = (route, paths) => {
-        const groupId = `watcher-push-${++nextWatcherPushGroupId}`;
-        watcherPushStages.set(groupId, {
-            groupId,
-            route,
-            paths,
-            stage: "",
-            stageEnteredAt: Date.now(),
-        });
-        return { groupId, setStage: (stage) => setWatcherPushStage(groupId, stage) };
-    };
-    const emitWatcherPushInflightStages = () => {
-        if (inFlightWatcherPushes <= 0)
-            return;
-        const now = Date.now();
-        const entries = [...watcherPushStages.values()];
-        const admission = passScheduler.diagnosticAdmissionSnapshot;
-        process.stderr.write(`${JSON.stringify({
-            type: "watcher-push-inflight-stages",
-            diagnostic: true,
-            groups: entries.slice(0, 20).map((record) => ({
-                route: record.route,
-                paths: record.paths,
-                stage: record.stage,
-                ageMs: Math.max(0, now - record.stageEnteredAt),
-            })),
-            other: Math.max(0, entries.length - 20),
-            realtimeAdmissionQueueDepth: admission.queueDepth,
-            holders: admission.holders,
-        })}\n`);
-    };
-    const watcherPushStagesTimer = setInterval(emitWatcherPushInflightStages, Math.max(1, deps.watcherPushDiagnosticsIntervalMs ?? 60_000));
-    watcherPushStagesTimer.unref?.();
-    let pendingReceivers = 0;
-    let lastSyncWorkStateEmitAt = 0;
-    let syncWorkStateTimer;
-    const emitSyncWorkState = (force = false) => {
-        const now = Date.now();
-        const elapsed = now - lastSyncWorkStateEmitAt;
-        if (force || elapsed >= 250) {
-            if (syncWorkStateTimer !== undefined)
-                clearTimeout(syncWorkStateTimer);
-            syncWorkStateTimer = undefined;
-            lastSyncWorkStateEmitAt = now;
-            const snapshot = {
-                passActive: activePassCount > 0,
-                queuedWatcherPushes: pendingWatcherPaths.size,
-                inFlightWatcherPushes,
-                pendingReceivers,
-            };
-            deps.onSyncWorkStateSnapshot?.(snapshot);
-            stdout.write(`${JSON.stringify({ type: "sync-work-state", ...snapshot })}\n`);
-            return;
-        }
-        if (syncWorkStateTimer !== undefined)
-            return;
-        syncWorkStateTimer = setTimeout(() => {
-            syncWorkStateTimer = undefined;
-            emitSyncWorkState(true);
-        }, Math.max(1, 250 - elapsed));
-        syncWorkStateTimer.unref?.();
-    };
     const droppedUnresolvedWatcherSlugs = new Set();
     const logDroppedUnresolvedWatcherRoute = (slug) => {
         if (droppedUnresolvedWatcherSlugs.has(slug))
@@ -2849,11 +2556,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             }
         }
         if (batch) {
-            if (batch.overflowed || batch.paths.size > durableWatcherPathLimit) {
-                durableWatcherPaths.clear();
-                durableWatcherOverflowed = true;
-                scheduleDurableWatcherPersist();
-            }
             const entries = [...batch.paths.entries()].filter(([absolutePath]) => {
                 const previousSequence = pendingWatcherChangeSequences.get(absolutePath);
                 return previousSequence === undefined ||
@@ -2862,7 +2564,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             });
             if (entries.length === 0)
                 return false;
-            const queueWasEmpty = pendingWatcherPaths.size === 0;
             pendingWatcherBatchGeneration ??= ++nextWatcherBatchGeneration;
             pendingWatcherOriginalBatch =
                 pendingWatcherPaths.size === 0 &&
@@ -2874,13 +2575,11 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                     : null;
             for (const [absolutePath, relativePath] of entries) {
                 pendingWatcherPaths.set(absolutePath, relativePath);
-                addDurableWatcherPath(absolutePath, relativePath);
                 const change = batch.changes?.get(absolutePath);
                 if (change)
                     pendingWatcherChanges.set(absolutePath, change);
                 pendingWatcherChangeSequences.set(absolutePath, ++nextPendingWatcherChangeSequence);
             }
-            emitSyncWorkState(queueWasEmpty);
             if (batch.overflowed) {
                 pendingWatcherOverflowed = true;
                 pendingWatcherDroppedPaths += batch.droppedPaths ?? 0;
@@ -2904,20 +2603,16 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             // counterpart must be re-derived through the codec — a raw join would
             // point at the impossible colon path on Windows.
             const absolutePath = localPathForVaultKey(hqRoot, changedRelPath);
-            const queueWasEmpty = pendingWatcherPaths.size === 0;
             pendingWatcherPaths.set(absolutePath, changedRelPath);
-            addDurableWatcherPath(absolutePath, changedRelPath);
             pendingWatcherChangeSequences.set(absolutePath, ++nextPendingWatcherChangeSequence);
             // A bare path signal carries no delete intent; drop any change record
             // a prior batch left for this path so the stale intent cannot leak
             // into the coalesced batch (#227).
             pendingWatcherChanges.delete(absolutePath);
-            emitSyncWorkState(queueWasEmpty);
             return true;
         }
         pendingWatcherOriginalBatch = null;
         pendingWatcherBareChange = true;
-        emitSyncWorkState();
         return true;
     };
     const takePendingWatcherChange = () => {
@@ -2962,7 +2657,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
         pendingWatcherDroppedRouteHints.clear();
         pendingWatcherDroppedRoutesUnknown = false;
         pendingWatcherBatchGeneration = null;
-        emitSyncWorkState();
         return { batch, bare, warmupCatchup, warmupCatchupFailed, generation };
     };
     const restorePendingWatcherPaths = (paths, generation, changes) => {
@@ -2976,54 +2670,12 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             if (pendingWatcherChangeSequences.has(absolutePath))
                 continue;
             pendingWatcherPaths.set(absolutePath, relativePath);
-            addDurableWatcherPath(absolutePath, relativePath);
             pendingWatcherChangeSequences.set(absolutePath, ++nextPendingWatcherChangeSequence);
             const change = changes?.get(absolutePath);
             if (change)
                 pendingWatcherChanges.set(absolutePath, change);
         }
-        emitSyncWorkState();
     };
-    if (eventPush) {
-        try {
-            const stored = JSON.parse(fs.readFileSync(watcherPushStatePath, "utf8"));
-            if (stored.format !== 1 || stored.hqRoot !== hqRoot ||
-                (!Array.isArray(stored.paths) && stored.overflowed !== true)) {
-                throw new Error("stored watcher push state has an unsupported shape or root");
-            }
-            if (stored.overflowed === true) {
-                durableWatcherOverflowed = true;
-                pendingWatcherOverflowed = true;
-                pendingWatcherWarmupCatchup = true;
-                pendingWatcherDroppedRoutesUnknown = true;
-                pendingWatcherBatchGeneration = ++nextWatcherBatchGeneration;
-                emitSyncWorkState(true);
-                process.stderr.write("hq-sync-runner: restored overflowed watcher push state; scheduling full warm-up catch-up\n");
-            }
-            for (const relativePath of Array.isArray(stored.paths) ? stored.paths : []) {
-                if (typeof relativePath !== "string" || relativePath.length === 0)
-                    continue;
-                const route = routeChangeToTarget(relativePath);
-                if (!route || !isWatchRouteSelected(route, watchRouteSelection))
-                    continue;
-                const absolutePath = localPathForVaultKey(hqRoot, relativePath);
-                addDurableWatcherPath(absolutePath, relativePath);
-                pendingWatcherPaths.set(absolutePath, relativePath);
-                pendingWatcherChangeSequences.set(absolutePath, ++nextPendingWatcherChangeSequence);
-            }
-            if (pendingWatcherPaths.size > 0) {
-                pendingWatcherBatchGeneration = ++nextWatcherBatchGeneration;
-                pendingWatcherWarmupCatchup = true;
-                emitSyncWorkState(true);
-                process.stderr.write(`hq-sync-runner: restored ${pendingWatcherPaths.size} watcher push path(s) from prior shutdown\n`);
-            }
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.code === "ENOENT")) {
-                process.stderr.write(`hq-sync-runner: watcher push state recovery failed: ${describeError(err)}\n`);
-            }
-        }
-    }
     const routePushFailureBackoff = new RoutePushFailureBackoff();
     const pushRetryScheduler = deps.pushRetryScheduler ?? systemPushRetryScheduler;
     const routePushRetryTimerHandles = new Map();
@@ -3874,6 +3526,8 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
     // a file and still be refused as stale (a download changed the directory
     // mid-pass); the retry then finds the file already in the cloud and uploads
     // nothing, so without this the file is never announced to peers.
+    const uploadedAwaitingPublish = new Set();
+    const UPLOADED_AWAITING_PUBLISH_CAP = 1_000;
     const rememberUploadedPaths = (result) => {
         if (result === undefined || typeof result === "number")
             return;
@@ -3886,14 +3540,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                 const oldest = uploadedAwaitingPublish.values().next().value;
                 if (oldest !== undefined)
                     uploadedAwaitingPublish.delete(oldest);
-                if (!uploadedAwaitingPublishDropLogged) {
-                    uploadedAwaitingPublishDropLogged = true;
-                    process.stderr.write(`${JSON.stringify({
-                        type: "event-sync-upload-buffer-overflow",
-                        cap: UPLOADED_AWAITING_PUBLISH_CAP,
-                        action: "drop-oldest",
-                    })}\n`);
-                }
             }
         }
     };
@@ -4009,39 +3655,18 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                         : "small";
                     const largeUpload = sizeClass !== "small";
                     const chorePush = isChoreLocalPush(group.relPaths, largeUpload);
-                    const { groupId, setStage: watcherPushStage } = startWatcherPushStageTracking(routeId, group.relPaths.length);
-                    watcherPushStage("coordinator submit");
-                    inFlightWatcherPushes += group.relPaths.length;
-                    emitSyncWorkState(true);
-                    emitWatcherPushInflightStages();
-                    let execution;
-                    try {
-                        execution = await (parallelCoordinatorEnabled && !chorePush
-                            ? runRealtimePass("watcher", "push", group.relPaths, lane, async (slice, telemetry, coordinatorFenced) => {
-                                watcherPushStage("worker entry");
-                                const admittedPaths = slice.paths.map((path) => path.canonicalPath);
-                                const admittedChanges = changesForAdmittedPaths(group, admittedPaths);
-                                const scopedArgv = buildScopedPushArgv(group.route, admittedPaths, passArgv, group.deleteScopeRoots);
-                                return runGuarded(scopedArgv, admittedChanges.size > 0
-                                    ? () => prepareWatcherChanges(admittedChanges)
-                                    : undefined, lane, "realtime", allowFastRealtimeOvertake, slice.signal, false, telemetry, coordinatorFenced, undefined, routeId, watcherPushStage);
-                            }, sizeClass)
-                            : (() => {
-                                watcherPushStage("worker entry");
-                                return runGuarded(buildScopedPushArgv(group.route, group.relPaths, passArgv, group.deleteScopeRoots), group.changes.size > 0
-                                    ? () => prepareWatcherChanges(group.changes)
-                                    : undefined, lane, chorePush ? "chore" : "realtime", allowFastRealtimeOvertake, undefined, false, undefined, false, undefined, routeId, watcherPushStage).then((result) => ({
-                                    result,
-                                    accepted: true,
-                                    coordinatorRefusedPaths: [],
-                                }));
-                            })());
-                    }
-                    finally {
-                        watcherPushStages.delete(groupId);
-                        inFlightWatcherPushes = Math.max(0, inFlightWatcherPushes - group.relPaths.length);
-                        emitSyncWorkState(true);
-                    }
+                    const execution = parallelCoordinatorEnabled && !chorePush
+                        ? await runRealtimePass("watcher", "push", group.relPaths, lane, async (slice, telemetry, coordinatorFenced) => {
+                            const admittedPaths = slice.paths.map((path) => path.canonicalPath);
+                            const admittedChanges = changesForAdmittedPaths(group, admittedPaths);
+                            const scopedArgv = buildScopedPushArgv(group.route, admittedPaths, passArgv, group.deleteScopeRoots);
+                            return runGuarded(scopedArgv, admittedChanges.size > 0
+                                ? () => prepareWatcherChanges(admittedChanges)
+                                : undefined, lane, "realtime", allowFastRealtimeOvertake, slice.signal, false, telemetry, coordinatorFenced);
+                        }, sizeClass)
+                        : { result: await runGuarded(buildScopedPushArgv(group.route, group.relPaths, passArgv, group.deleteScopeRoots), group.changes.size > 0
+                                ? () => prepareWatcherChanges(group.changes)
+                                : undefined, lane, chorePush ? "chore" : "realtime", allowFastRealtimeOvertake), accepted: true, coordinatorRefusedPaths: [] };
                     const result = execution.result;
                     rememberUploadedPaths(result);
                     const pushExit = passExitCode(result);
@@ -4060,7 +3685,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                         }
                         const isRefusedPath = (relativePath) => [...refusedPaths].some((refusedPath) => relativePath === refusedPath ||
                             relativePath.startsWith(`${refusedPath}/`));
-                        acknowledgeDurableWatcherUploads(group.relPaths.filter((relativePath) => !isRefusedPath(relativePath)));
                         const publishPaths = new Map();
                         for (const [absolutePath, relativePath] of group.paths) {
                             if (isRefusedPath(relativePath))
@@ -4100,11 +3724,9 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                         deferPushAfterAdmissionTimeout(group, routeId);
                     }
                     else if (pushExit === UNRESOLVED_COMPANY_EXIT) {
-                        acknowledgeDurableWatcherUploads(group.relPaths);
                         routePushFailureBackoff.succeeded(routeId);
                         clearRoutePushRetry(routeId);
                         if (group.route.kind === "company") {
-                            deps.watcherCatchupSkipStore?.recordUnresolvedCompany(group.route.slug);
                             logDroppedUnresolvedWatcherRoute(group.route.slug);
                         }
                     }
@@ -4166,7 +3788,7 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                 const execution = parallelCoordinatorEnabled
                     ? await runRealtimePass("watcher", "pull", group.relPaths, lane, (slice, telemetry, coordinatorFenced) => {
                         const slicePaths = slice.paths.map((path) => path.canonicalPath);
-                        return runGuarded(buildTargetedPullArgv(group.route, passArgv, slicePaths, exactFileUpserts.filter((relativePath) => slicePaths.includes(relativePath))), undefined, lane, "realtime", false, slice.signal, false, telemetry, coordinatorFenced, undefined, routeKey(group.route));
+                        return runGuarded(buildTargetedPullArgv(group.route, passArgv, slicePaths, exactFileUpserts.filter((relativePath) => slicePaths.includes(relativePath))), undefined, lane, "realtime", false, slice.signal, false, telemetry, coordinatorFenced);
                     })
                     : await runGuarded(pullArgv, undefined, lane, "realtime").then((result) => ({ result, accepted: true }), (error) => {
                         if (error instanceof RealtimeAdmissionTimeoutError) {
@@ -4218,7 +3840,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             addRoute(hint);
         const skipCompanies = resolveSkipCompanies();
         if (parallelCoordinatorEnabled) {
-            let routesRemaining = [...routes.values()].filter((route) => route.kind !== "company" || !skipCompanies.has(route.slug.toLowerCase())).length;
             for (const route of routes.values()) {
                 if (route.kind === "company" &&
                     skipCompanies.has(route.slug.toLowerCase())) {
@@ -4247,11 +3868,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                         process.stderr.write(`hq-sync-runner: backlog chore for ${routeKey(route)} failed; will retry on cadence\n`);
                         interruptWait();
                     }
-                    else {
-                        routesRemaining -= 1;
-                        if (routesRemaining === 0)
-                            clearDurableWatcherOverflow();
-                    }
                 });
             }
             return 0;
@@ -4488,7 +4104,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                 }
             }
             watcher.start();
-            let catchupPathStatWarningReported = false;
             const reportWatcherReady = () => {
                 if (stopped || watcher === null)
                     return;
@@ -4529,147 +4144,14 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                             : watcher?.collectWarmupCatchup?.(serviceStartedAt - WATCHER_WARMUP_SAFETY_MARGIN_MS, journalPaths);
                         if (!catchup || catchup.cancelled || stopped || watcher === null)
                             return;
-                        const skipStore = deps.watcherCatchupSkipStore;
-                        const cloudCompanySlugs = readCloudBackedSlugsFromManifest(hqRoot);
-                        const eligiblePaths = new Map();
-                        const eligibleChanges = new Map();
-                        const excludedByReason = {};
-                        const excludedByReasonByRoute = {};
-                        const ignoreFilter = createIgnoreFilter(hqRoot);
-                        const personalFilterExclusions = new Map();
-                        const personalPushFilter = wrapFilterWithPersonalVaultDefaults(ignoreFilter, hqRoot, (relativePath, match) => personalFilterExclusions.set(relativePath, match.id));
-                        const clearedResolvedCompanies = new Set();
-                        const ontologyBackupPaths = { attioCleanup: 0, readModelRollout: 0 };
-                        const backupClass = (relativePath) => {
-                            if (/\/ontology\/_attio-cleanup-backup\//.test(`/${relativePath}`))
-                                return "attioCleanup";
-                            if (/\/ontology\/_read-model-rollout-backup\//.test(`/${relativePath}`))
-                                return "readModelRollout";
-                            return undefined;
-                        };
-                        const exclude = (reason, routeName) => {
-                            excludedByReason[reason] = (excludedByReason[reason] ?? 0) + 1;
-                            const routeReasons = excludedByReasonByRoute[routeName] ??= {};
-                            routeReasons[reason] = (routeReasons[reason] ?? 0) + 1;
-                        };
-                        for (const [absolutePath, relativePath] of catchup.batch.paths) {
-                            const route = routeChangeToTarget(relativePath);
-                            const routeName = route ? routeKey(route) : "unrouted";
-                            const ontologyBackupClass = backupClass(relativePath);
-                            if (ontologyBackupClass) {
-                                exclude("local-rule:ontology-backup", routeName);
-                                ontologyBackupPaths[ontologyBackupClass] += 1;
-                                continue;
-                            }
-                            if (route?.kind === "company") {
-                                const resolvedNow = cloudCompanySlugs.has(route.slug) ||
-                                    skipStore?.hasCurrentGrantCompany(route.slug) ||
-                                    skipStore?.hasCurrentGrantVersion(route.slug) ||
-                                    (companyMode && companySlug?.trim().toLowerCase() === route.slug.trim().toLowerCase());
-                                if (resolvedNow && !clearedResolvedCompanies.has(route.slug)) {
-                                    skipStore?.clearUnresolvedCompany(route.slug);
-                                    clearedResolvedCompanies.add(route.slug);
-                                }
-                                if (!resolvedNow && skipStore?.hasFreshUnresolvedCompany(route.slug)) {
-                                    exclude("unresolved-company", routeName);
-                                    continue;
-                                }
-                            }
-                            if (route?.kind === "company" &&
-                                !cloudCompanySlugs.has(route.slug) &&
-                                !skipStore?.hasCurrentGrantCompany(route.slug) &&
-                                !skipStore?.hasCurrentGrantVersion(route.slug) &&
-                                !(companyMode && companySlug?.trim().toLowerCase() === route.slug.trim().toLowerCase())) {
-                                exclude("local-only-company", routeName);
-                                continue;
-                            }
-                            const company = route?.kind === "company" ? route.slug : "personal";
-                            const routePath = route?.kind === "company"
-                                ? relativePath.slice(`companies/${route.slug}/`.length)
-                                : relativePath;
-                            if (isEphemeralPath(routePath)) {
-                                exclude("push-filter:conflict-mirror", routeName);
-                                continue;
-                            }
-                            const acceptedByPushFilter = route?.kind === "personal"
-                                ? personalPushFilter(absolutePath, false)
-                                : ignoreFilter(absolutePath, false);
-                            if (!acceptedByPushFilter) {
-                                const exclusionId = route?.kind === "personal"
-                                    ? personalFilterExclusions.get(relativePath)
-                                    : undefined;
-                                exclude(exclusionId
-                                    ? `push-filter:personal:${exclusionId}`
-                                    : "push-filter:ignore", routeName);
-                                continue;
-                            }
-                            if (route && isLocallyIneligibleForPush(routePath, {
-                                boardClientOwned: true,
-                                ontologyEntityPush: route.kind === "company" && skipStore?.allowsOntologyEntityPush(company),
-                            })) {
-                                const pathClass = cloudAuthoritativePathClass(routePath) ?? "other";
-                                exclude(`local-rule:${pathClass}`, routeName);
-                                continue;
-                            }
-                            try {
-                                const stat = fs.lstatSync(absolutePath);
-                                if (route && stat.isSymbolicLink()) {
-                                    const scopeRoot = route.kind === "company"
-                                        ? path.join(hqRoot, "companies", route.slug)
-                                        : relativePath.startsWith("personal/")
-                                            ? path.join(hqRoot, "personal")
-                                            : hqRoot;
-                                    const inspection = inspectLocalSymlinkScope({
-                                        absoluteLinkPath: absolutePath,
-                                        linkPath: relativePath,
-                                        scopeRoot,
-                                        scope: route.kind === "company"
-                                            ? { kind: "company", companySlug: route.slug }
-                                            : { kind: "personal" },
-                                    });
-                                    if (inspection.refused) {
-                                        exclude("symlink", routeName);
-                                        continue;
-                                    }
-                                }
-                                if (skipStore?.matches(company, routePath, stat)) {
-                                    exclude("record-match", routeName);
-                                    continue;
-                                }
-                            }
-                            catch (error) {
-                                // Fail open: unreadable state or a filesystem race must not suppress a candidate.
-                                if (!catchupPathStatWarningReported) {
-                                    catchupPathStatWarningReported = true;
-                                    process.stderr.write(`hq-sync-runner: warm-up skip stat failed open: ${describeError(error)}\n`);
-                                }
-                            }
-                            eligiblePaths.set(absolutePath, relativePath);
-                            const change = catchup.batch.changes?.get(absolutePath);
-                            if (change)
-                                eligibleChanges.set(absolutePath, change);
-                        }
-                        const queued = addPendingWatcherChange(undefined, {
-                            paths: eligiblePaths,
-                            changes: eligibleChanges,
-                        }, {
+                        const queued = addPendingWatcherChange(undefined, catchup.batch, {
                             preserveChangesAfter: liveChangeSequenceAtWarmupStart,
                         });
                         pendingWatcherWarmupCatchup ||= queued;
-                        const capEvicted = skipStore?.takeCapEvictedCount() ?? 0;
                         process.stderr.write(JSON.stringify({
                             type: "watcher-warmup-catchup",
                             reason: "watch-set-ready",
-                            pathsFound: eligiblePaths.size,
-                            candidatePathsByRoute: watcherWarmupPathsByRoute(catchup.batch.paths.values()),
-                            pathsByRoute: watcherWarmupPathsByRoute(eligiblePaths.values()),
-                            pathPrefixesByRoute: watcherWarmupPrefixesByRoute(catchup.batch.paths.values()),
-                            excludedByReason: {
-                                ...excludedByReason,
-                                ...(capEvicted > 0 ? { "cap-evicted": capEvicted } : {}),
-                            },
-                            excludedByReasonByRoute,
-                            ontologyBackupPaths,
+                            pathsFound: catchup.batch.paths.size,
                             scannedPaths: catchup.scannedPaths,
                             elapsedMs: Date.now() - startedAt,
                             queued,
@@ -4736,16 +4218,13 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                 const execution = await runRealtimePass("receiver", "pull", events.map((event) => event.relativePath), lane, (slice, telemetry, coordinatorFenced) => {
                     const slicePaths = slice.paths.map((path) => path.canonicalPath);
                     const exactFileUpserts = exactUpsertPathsForCoordinatorSlice(events, slicePaths);
-                    return withScopeContentHashesFile(route, events, slicePaths, (contentHashesFile) => runGuarded(buildTargetedPullArgv(route, passArgv, slicePaths, exactFileUpserts, contentHashesFile), undefined, lane, "realtime", lane === "fast", slice.signal, false, telemetry, coordinatorFenced, receiverSignal, routeKey(route)));
+                    return withScopeContentHashesFile(route, events, slicePaths, (contentHashesFile) => runGuarded(buildTargetedPullArgv(route, passArgv, slicePaths, exactFileUpserts, contentHashesFile), undefined, lane, "realtime", lane === "fast", slice.signal, false, telemetry, coordinatorFenced, receiverSignal));
                 });
                 const pathCount = events.length;
                 // Rethrow the typed refusal so the receiver keeps the lease and
                 // retries the whole batch, instead of bisecting a "failed" pull.
                 if (execution.admissionTimeout)
                     throw execution.admissionTimeout;
-                if (execution.yieldedToPush) {
-                    throw new RealtimePushYieldError();
-                }
                 const exitCode = passExitCode(execution.result);
                 if (shouldAcknowledgeParallelUnresolvedCompany(execution.accepted, exitCode)) {
                     if (!unresolvedReceiverMessagesWereRedelivered(events, receiveCountsByPath)) {
@@ -4767,82 +4246,74 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
         const receiverSyncBatchFn = async ({ events, signal, approximateReceiveCountsByPath, settleEvents, }) => {
             if (stopped)
                 return;
-            try {
-                // The injectable receiver seam and the production SQS receiver both
-                // arrive here only after a successful receive. Keep the cadence tight
-                // until the receiver later reports an empty outer long-poll.
-                onReceiveActivity(true);
-                pendingReceivers += events.length;
-                emitSyncWorkState();
-                // A received wake/high-water signal means there is bounded work now.
-                // It wakes the scheduler but is still funneled through runGuarded below,
-                // so it cannot overlap the pass that may currently own the operation
-                // lock.
-                // Apply the caps once across the whole delivery, then retain the residue
-                // in the normal lane. The receiver already coalesces to one latest event
-                // per path, so the partition cannot split revisions of one path.
-                if (parallelCoordinatorEnabled) {
-                    const lane = receiverLaneByBatch.get(events);
-                    if (lane) {
-                        receiverLaneByBatch.delete(events);
-                        await drainParallelReceiverLane(lane, events, approximateReceiveCountsByPath, settleEvents, signal);
-                        return;
-                    }
-                    // Direct embedders may invoke the engine without first going through
-                    // SqsPushReceiver. Preserve that seam while applying the same
-                    // delivery-wide partition the receiver would expose.
-                    const lanes = partitionByKnownSizes(events, receiverEventSize);
-                    await drainParallelReceiverLane("fast", lanes.fast, approximateReceiveCountsByPath, settleEvents, signal);
-                    await drainParallelReceiverLane("slow", lanes.slow, approximateReceiveCountsByPath, settleEvents, signal);
+            // The injectable receiver seam and the production SQS receiver both
+            // arrive here only after a successful receive. Keep the cadence tight
+            // until the receiver later reports an empty outer long-poll.
+            onReceiveActivity(true);
+            // A received wake/high-water signal means there is bounded work now.
+            // It wakes the scheduler but is still funneled through runGuarded below,
+            // so it cannot overlap the pass that may currently own the operation
+            // lock.
+            // Apply the caps once across the whole delivery, then retain the residue
+            // in the normal lane. The receiver already coalesces to one latest event
+            // per path, so the partition cannot split revisions of one path.
+            if (parallelCoordinatorEnabled) {
+                const lane = receiverLaneByBatch.get(events);
+                if (lane) {
+                    receiverLaneByBatch.delete(events);
+                    await drainParallelReceiverLane(lane, events, approximateReceiveCountsByPath, settleEvents, signal);
                     return;
                 }
+                // Direct embedders may invoke the engine without first going through
+                // SqsPushReceiver. Preserve that seam while applying the same
+                // delivery-wide partition the receiver would expose.
                 const lanes = partitionByKnownSizes(events, receiverEventSize);
-                const drainLane = async (lane, laneEvents, receiveCountsByPath, receiverSignal) => {
-                    const eventsByRoute = new Map();
-                    for (const event of laneEvents) {
-                        const route = routeChangeToTarget(event.relativePath);
-                        // The receiver is an independent ingress from the local watcher.
-                        // Apply the same route-selection boundary before it can enqueue a
-                        // fast pull: a --skip-personal runner must acknowledge, not pull,
-                        // a personal-namespace delivery.
-                        if (!route || !isWatchRouteSelected(route, watchRouteSelection))
-                            continue;
-                        const key = routeKey(route);
-                        const group = eventsByRoute.get(key) ?? { route, events: [], upsertPaths: [] };
-                        group.events.push(event);
-                        if (event.kind === "upsert")
-                            group.upsertPaths.push(event.relativePath);
-                        eventsByRoute.set(key, group);
-                    }
-                    for (const { route, events: routeEvents, upsertPaths } of eventsByRoute.values()) {
-                        const paths = routeEvents.map((event) => event.relativePath);
-                        const result = await withScopeContentHashesFile(route, routeEvents, paths, (contentHashesFile) => runGuarded(buildTargetedPullArgv(route, passArgv, paths, upsertPaths, contentHashesFile), undefined, lane, "realtime", false, receiverSignal));
-                        const exitCode = passExitCode(result);
-                        if (exitCode === UNRESOLVED_COMPANY_EXIT) {
-                            if (!unresolvedReceiverMessagesWereRedelivered(routeEvents, receiveCountsByPath)) {
-                                throw targetedReceiverDispatchError(result, true, runtime.authRequiredPassExit);
-                            }
-                            warnUnresolvedReceiverCompany(route, routeEvents.length);
-                            await settleEvents?.(routeEvents);
-                            continue;
-                        }
-                        if (exitCode !== 0) {
+                await drainParallelReceiverLane("fast", lanes.fast, approximateReceiveCountsByPath, settleEvents, signal);
+                await drainParallelReceiverLane("slow", lanes.slow, approximateReceiveCountsByPath, settleEvents, signal);
+                return;
+            }
+            const lanes = partitionByKnownSizes(events, receiverEventSize);
+            const drainLane = async (lane, laneEvents, receiveCountsByPath, receiverSignal) => {
+                const eventsByRoute = new Map();
+                for (const event of laneEvents) {
+                    const route = routeChangeToTarget(event.relativePath);
+                    // The receiver is an independent ingress from the local watcher.
+                    // Apply the same route-selection boundary before it can enqueue a
+                    // fast pull: a --skip-personal runner must acknowledge, not pull,
+                    // a personal-namespace delivery.
+                    if (!route || !isWatchRouteSelected(route, watchRouteSelection))
+                        continue;
+                    const key = routeKey(route);
+                    const group = eventsByRoute.get(key) ?? { route, events: [], upsertPaths: [] };
+                    group.events.push(event);
+                    if (event.kind === "upsert")
+                        group.upsertPaths.push(event.relativePath);
+                    eventsByRoute.set(key, group);
+                }
+                for (const { route, events: routeEvents, upsertPaths } of eventsByRoute.values()) {
+                    const paths = routeEvents.map((event) => event.relativePath);
+                    const result = await withScopeContentHashesFile(route, routeEvents, paths, (contentHashesFile) => runGuarded(buildTargetedPullArgv(route, passArgv, paths, upsertPaths, contentHashesFile), undefined, lane, "realtime", false, receiverSignal));
+                    const exitCode = passExitCode(result);
+                    if (exitCode === UNRESOLVED_COMPANY_EXIT) {
+                        if (!unresolvedReceiverMessagesWereRedelivered(routeEvents, receiveCountsByPath)) {
                             throw targetedReceiverDispatchError(result, true, runtime.authRequiredPassExit);
                         }
+                        warnUnresolvedReceiverCompany(route, routeEvents.length);
                         await settleEvents?.(routeEvents);
+                        continue;
                     }
-                };
-                // Dispatch realtime work before awaiting its bulk residue. This lets an
-                // established slow pass continue while the small scoped pull uses its
-                // ref-counted lock carve-out; the residue remains serialized and cannot
-                // starve the slow lane.
-                await drainLane("fast", lanes.fast, approximateReceiveCountsByPath, signal);
-                await drainLane("slow", lanes.slow, approximateReceiveCountsByPath, signal);
-            }
-            finally {
-                pendingReceivers = Math.max(0, pendingReceivers - events.length);
-                emitSyncWorkState();
-            }
+                    if (exitCode !== 0) {
+                        throw targetedReceiverDispatchError(result, true, runtime.authRequiredPassExit);
+                    }
+                    await settleEvents?.(routeEvents);
+                }
+            };
+            // Dispatch realtime work before awaiting its bulk residue. This lets an
+            // established slow pass continue while the small scoped pull uses its
+            // ref-counted lock carve-out; the residue remains serialized and cannot
+            // starve the slow lane.
+            await drainLane("fast", lanes.fast, approximateReceiveCountsByPath, signal);
+            await drainLane("slow", lanes.slow, approximateReceiveCountsByPath, signal);
         };
         receiverSyncBatchFn.partition = (events, maxPaths) => {
             const lanes = partitionByKnownSizes(events, receiverEventSize);
@@ -4999,14 +4470,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
         if (stopped)
             return shutdownPromise ?? Promise.resolve();
         stopped = true;
-        clearInterval(watcherPushStagesTimer);
-        if (durableWatcherPersistTimer !== undefined)
-            clearTimeout(durableWatcherPersistTimer);
-        durableWatcherPersistTimer = undefined;
-        if (syncWorkStateTimer !== undefined)
-            clearTimeout(syncWorkStateTimer);
-        syncWorkStateTimer = undefined;
-        emitSyncWorkState(true);
         for (const route of routePushRetryTimerHandles.keys()) {
             clearRoutePushRetry(route);
         }
@@ -5036,7 +4499,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             coordinatorDisposal,
             boundedEventSyncStartup,
             eventSyncDisposal,
-            persistDurableWatcherPaths(),
         ]).then(() => undefined);
         try {
             void receiver?.dispose();
@@ -5454,14 +4916,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                                 lastCompletedFullReconcileWallAt = Date.now();
                                 fullPassJournalHealthy = execution.accepted &&
                                     isFullPassJournalHealthy(exit, typeof execution.result === "number" ? undefined : execution.result.result?.partial);
-                                if (fullPassJournalHealthy && pending.batch?.overflowed === true) {
-                                    clearDurableWatcherOverflow();
-                                }
-                                else if (fullPassJournalHealthy && pending.batch !== null) {
-                                    acknowledgeDurableWatcherPathsCoveredByFullPass([
-                                        ...pending.batch.paths.values(),
-                                    ]);
-                                }
                                 if (fullPassJournalHealthy) {
                                     fullPassContinuity.markFullPassCompleted(lastCompletedFullReconcileAt);
                                 }
@@ -5519,11 +4973,7 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                         const catchupBatch = workingBatch;
                         const catchupGeneration = pending.generation;
                         void runScopedDrain(catchupBatch, catchupGeneration, true).then((exit) => {
-                            if (exit === 0) {
-                                clearDurableWatcherOverflow();
-                                return;
-                            }
-                            if (exit === SCOPED_DRAIN_DEFERRED)
+                            if (exit === 0 || exit === SCOPED_DRAIN_DEFERRED)
                                 return;
                             restorePendingWatcherPaths(catchupBatch.paths, catchupGeneration);
                             interruptWait();
@@ -5631,19 +5081,6 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                 ? exitCode === 0
                 : hasCompletedRunnerPass(result));
             if (completedPostRepairPass) {
-                if (!parallelCoordinatorEnabled &&
-                    pending.batch?.overflowed === true &&
-                    ((ranFullReconcile && fullPassJournalHealthy) || (!watcherWarmupCatchup && exitCode === 0))) {
-                    clearDurableWatcherOverflow();
-                }
-                else if (!parallelCoordinatorEnabled &&
-                    ranFullReconcile &&
-                    fullPassJournalHealthy &&
-                    pending.batch !== null) {
-                    acknowledgeDurableWatcherPathsCoveredByFullPass([
-                        ...pending.batch.paths.values(),
-                    ]);
-                }
                 // The production adapter returns RunnerPassResult only after fanout,
                 // which follows journal repair. Its numeric seam has the same
                 // contract: zero means the injected pass completed. This preserves