@indigoai-us/hq-cloud 6.15.65 → 6.15.67

package/dist/bin/sync-runner-watch-loop.d.ts

@@ -1,4 +1,4 @@
-import { type TreeChange } from "../watcher.js";
+import { type TreeChange, type TreeChangeBatch } from "../watcher.js";
 import { readJournal } from "../journal.js";
 import type { TelemetryClaims } from "../telemetry-events.js";
 import type { Direction, RunnerLoopDeps, RunnerPassOutcome } from "./sync-runner.js";
@@ -21,15 +21,37 @@ export declare const EVENT_BATCH_LIMIT_ENV = "HQ_SYNC_EVENT_BATCH_LIMIT";
  */
 export declare const FAST_LANE_MAX_FILES_ENV = "HQ_SYNC_FAST_LANE_MAX_FILES";
 export declare const FAST_LANE_MAX_BYTES_ENV = "HQ_SYNC_FAST_LANE_MAX_BYTES";
+export declare const FAST_LANE_MAX_FILE_BYTES_ENV = "HQ_SYNC_FAST_LANE_MAX_FILE_BYTES";
 export declare const DEFAULT_FAST_LANE_MAX_FILES = 32;
 export declare const DEFAULT_FAST_LANE_MAX_BYTES: number;
+/**
+ * A per-file ceiling keeps a single medium-sized transfer from consuming the
+ * realtime lane even when the batch aggregate is otherwise below its cap.
+ * 256 KiB comfortably covers ordinary notes and control-plane artifacts while
+ * leaving session logs and other transfer-heavy files in the slow lane.
+ */
+export declare const DEFAULT_FAST_LANE_MAX_FILE_BYTES: number;
 export declare function resolveFastLaneLimits(): {
     maxFiles: number;
     maxBytes: number;
+    maxFileBytes: number;
+};
+/** One latest-per-path work item selected into the realtime or bulk lane. */
+export interface LanePartition<T> {
+    fast: T[];
+    slow: T[];
+}
+/**
+ * Partition one selected watcher batch. The returned batches retain the same
+ * route/filter metadata, but no latest path can appear in both lane maps.
+ */
+export declare function partitionLocalBatch(batch: TreeChangeBatch): {
+    fast: TreeChangeBatch | null;
+    slow: TreeChangeBatch | null;
 };
 /** A missing/stat-failed path is never allowed to bypass the slow lane. */
 export declare function isFastLocalBatch(paths: Iterable<string>, changes?: ReadonlyMap<string, Pick<TreeChange, "kind">>): boolean;
-/** Receiver events carry no content length, so only bounded event batches qualify. */
+/** A receiver event needs a known small upsert size before it can go realtime. */
 export declare function isFastReceiverBatch(eventCount: number): boolean;
 export declare function resolveEventBatchLimit(env?: Record<string, string | undefined>): number;
 /**
@@ -54,6 +76,12 @@ export declare const WATCHER_REDISCOVERY_RETRY_MAX_MS: number;
  * can be unit-tested without a real host or a 10-minute wait.
  */
 export declare function adaptivePollMs(load1: number, cpuCount: number, floorMs?: number, ceilMs?: number): number;
+/**
+ * A receiver that has observed messages owns a bounded drain, even if its
+ * slow lane is currently waiting for the operation lock.  Do not stretch the
+ * cadence from that observed work to the CPU-derived backoff ceiling.
+ */
+export declare function resolveWatchPollMs(explicitPollMs: number | undefined, receiverHasQueuedWork: boolean, loadAvg: number, cpuCount: number): number;
 /**
  * Advance the cadence from its previous monotonic deadline while the runner is
  * on time. When a pass overruns its slot, give the host one complete interval

package/dist/bin/sync-runner-watch-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync-runner-watch-loop.d.ts","sourceRoot":"","sources":["../../src/bin/sync-runner-watch-loop.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sync-runner-watch-loop.d.ts","sourceRoot":"","sources":["../../src/bin/sync-runner-watch-loop.ts"],"names":[],"mappings":"AAkBA,OAAO,EAKL,KAAK,UAAU,EACf,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAOL,WAAW,EAEZ,MAAM,eAAe,CAAC;AAWvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAY9D,OAAO,KAAK,EACV,SAAS,EAET,cAAc,EACd,iBAAiB,EAElB,MAAM,kBAAkB,CAAC;AAsD1B;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAChD,eAAO,MAAM,qBAAqB,8BAA8B,CAAC;AAEjE;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,gCAAgC,CAAC;AACrE,eAAO,MAAM,uBAAuB,gCAAgC,CAAC;AACrE,eAAO,MAAM,4BAA4B,qCAAqC,CAAC;AAC/E,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAC9C,eAAO,MAAM,2BAA2B,QAAkB,CAAC;AAC3D;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,QAAa,CAAC;AAO3D,wBAAgB,qBAAqB,IAAI;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB,CASA;AAED,6EAA6E;AAC7E,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,IAAI,EAAE,CAAC,EAAE,CAAC;CACX;AAiDD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,eAAe,GAAG;IAC3D,IAAI,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7B,IAAI,EAAE,eAAe,GAAG,IAAI,CAAC;CAC9B,CAgBA;AAED,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvB,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,GACtD,OAAO,CAyBT;AAED,kFAAkF;AAClF,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED,wBAAgB,sBAAsB,CACpC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,MAAM,CAMR;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,8BAA8B,CAAC;AACjE,eAAO,MAAM,yBAAyB,EAAE,MAAM,GAAG,SAAqB,CAAC;AAEvE,wBAAgB,sBAAsB,CACpC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,MAAM,GAAG,SAAS,CAOpB;AAiBD,iFAAiF;AACjF,eAAO,MAAM,4BAA4B,QAAa,CAAC;AACvD,kFAAkF;AAClF,eAAO,MAAM,gCAAgC,QAAc,CAAC;AAE5D;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,MAA+B,EACxC,MAAM,GAAE,MAA8B,GACrC,MAAM,CAKR;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,qBAAqB,EAAE,OAAO,EAC9B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,MAAM,CAKR;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,GACjB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAUxC;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kFAAkF;IAClF,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,mCAAmC,EAAE,CACnC,QAAQ,EAAE,MAAM,EAAE,KACf,OAAO,CAAC,MAAM,GAAG,iBAAiB,CAAC,CAAC;IACzC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,uBAAuB,EAAE,MAAM,CAAC;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,eAAe,CAAC,GAAG,IAAI,CAAC;IAC7E,qBAAqB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,KAAK,YAAY,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC;AAE5D;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,QAAQ,GAAG,WAAW,GAC3B,KAAK,CAAC,CAAC,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CASvC;AAWD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oCAAoC,CAClD,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,OAAO,CAIT;AAuBD,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,MAAM,CAAC,CAgBjB;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,MAAM,CAAC,CAw1DjB"}

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

@@ -12,7 +12,7 @@ import { PARTIAL_SYNC_EXIT } from "../lib/exit-codes.js";
 import { getOrCreateMachineId } from "../lib/machine-id.js";
 import { localPathForVaultKey } from "../local-path-codec.js";
 import { TreeWatcher, resolveEventDebounceConfig, systemClock, } from "../watcher.js";
-import { clearLocalDeleteIntent, markLocalDeleteIntent, PERSONAL_VAULT_JOURNAL_SLUG, openJournalStoreSession, listJournals, readJournal, writeJournal, } from "../journal.js";
+import { clearLocalDeleteIntent, getStateDir, markLocalDeleteIntent, PERSONAL_VAULT_JOURNAL_SLUG, openJournalStoreSession, listJournals, readJournal, writeJournal, } from "../journal.js";
 import { NoopPushReceiver, } from "../sync/push-receiver.js";
 import { resolveEventSync, startEventSync as defaultStartEventSync, } from "../sync/event-sync.js";
 import { buildRoutePullArgv, buildScopedPushArgv, buildScopedDrainPullArgv, buildTargetedPullArgv, isWatchRouteSelected, routeChangeToTarget, routeKey, } from "./sync-runner-watch-routes.js";
@@ -52,8 +52,16 @@ export const EVENT_BATCH_LIMIT_ENV = "HQ_SYNC_EVENT_BATCH_LIMIT";
  */
 export const FAST_LANE_MAX_FILES_ENV = "HQ_SYNC_FAST_LANE_MAX_FILES";
 export const FAST_LANE_MAX_BYTES_ENV = "HQ_SYNC_FAST_LANE_MAX_BYTES";
+export const FAST_LANE_MAX_FILE_BYTES_ENV = "HQ_SYNC_FAST_LANE_MAX_FILE_BYTES";
 export const DEFAULT_FAST_LANE_MAX_FILES = 32;
 export const DEFAULT_FAST_LANE_MAX_BYTES = 4 * 1024 * 1024;
+/**
+ * A per-file ceiling keeps a single medium-sized transfer from consuming the
+ * realtime lane even when the batch aggregate is otherwise below its cap.
+ * 256 KiB comfortably covers ordinary notes and control-plane artifacts while
+ * leaving session logs and other transfer-heavy files in the slow lane.
+ */
+export const DEFAULT_FAST_LANE_MAX_FILE_BYTES = 256 * 1024;
 function positiveEnvInt(name, fallback) {
     const value = Number.parseInt(process.env[name] ?? "", 10);
     return Number.isFinite(value) && value > 0 ? value : fallback;
@@ -62,7 +70,68 @@ export function resolveFastLaneLimits() {
     return {
         maxFiles: positiveEnvInt(FAST_LANE_MAX_FILES_ENV, DEFAULT_FAST_LANE_MAX_FILES),
         maxBytes: positiveEnvInt(FAST_LANE_MAX_BYTES_ENV, DEFAULT_FAST_LANE_MAX_BYTES),
+        maxFileBytes: positiveEnvInt(FAST_LANE_MAX_FILE_BYTES_ENV, DEFAULT_FAST_LANE_MAX_FILE_BYTES),
+    };
+}
+/**
+ * Select a bounded realtime prefix from already coalesced work. A path appears
+ * exactly once in this input, so a later change to the same path has already
+ * replaced its earlier revision and cannot straddle lanes.
+ */
+function partitionByKnownSizes(items, sizeOf) {
+    const { maxFiles, maxBytes, maxFileBytes } = resolveFastLaneLimits();
+    const fast = [];
+    const slow = [];
+    let bytes = 0;
+    for (const item of items) {
+        const size = sizeOf(item);
+        if (size === null ||
+            size > maxFileBytes ||
+            fast.length >= maxFiles ||
+            bytes + size > maxBytes) {
+            slow.push(item);
+            continue;
+        }
+        fast.push(item);
+        bytes += size;
+    }
+    return { fast, slow };
+}
+function localPathSize(absolutePath, changes) {
+    // `unlinkDir` has an unbounded journal expansion; never guess its payload.
+    if (changes?.get(absolutePath)?.kind === "unlinkDir")
+        return null;
+    try {
+        const stat = fs.lstatSync(absolutePath);
+        if (stat.isDirectory())
+            return null;
+        return stat.isFile() ? stat.size : 0;
+    }
+    catch (err) {
+        // A missing file is an exact delete and has no content transfer. Any other
+        // stat error leaves its payload unknown and therefore slow.
+        return err.code === "ENOENT" ? 0 : null;
+    }
+}
+/**
+ * Partition one selected watcher batch. The returned batches retain the same
+ * route/filter metadata, but no latest path can appear in both lane maps.
+ */
+export function partitionLocalBatch(batch) {
+    const partition = partitionByKnownSizes([...batch.paths.entries()], ([absolutePath]) => localPathSize(absolutePath, batch.changes));
+    const makeBatch = (entries) => {
+        if (entries.length === 0)
+            return null;
+        const paths = new Map(entries);
+        const changes = new Map();
+        for (const [absolutePath] of entries) {
+            const change = batch.changes?.get(absolutePath);
+            if (change)
+                changes.set(absolutePath, change);
+        }
+        return { ...batch, paths, ...(changes.size > 0 ? { changes } : {}) };
     };
+    return { fast: makeBatch(partition.fast), slow: makeBatch(partition.slow) };
 }
 /** A missing/stat-failed path is never allowed to bypass the slow lane. */
 export function isFastLocalBatch(paths, changes) {
@@ -97,7 +166,7 @@ export function isFastLocalBatch(paths, changes) {
     }
     return files > 0;
 }
-/** Receiver events carry no content length, so only bounded event batches qualify. */
+/** A receiver event needs a known small upsert size before it can go realtime. */
 export function isFastReceiverBatch(eventCount) {
     return eventCount > 0 && eventCount <= resolveFastLaneLimits().maxFiles;
 }
@@ -161,6 +230,18 @@ export function adaptivePollMs(load1, cpuCount, floorMs = ADAPTIVE_POLL_FLOOR_MS
     const ratio = Math.max(0, Math.min(1, saturation));
     return Math.round(floorMs + ratio * (ceilMs - floorMs));
 }
+/**
+ * A receiver that has observed messages owns a bounded drain, even if its
+ * slow lane is currently waiting for the operation lock.  Do not stretch the
+ * cadence from that observed work to the CPU-derived backoff ceiling.
+ */
+export function resolveWatchPollMs(explicitPollMs, receiverHasQueuedWork, loadAvg, cpuCount) {
+    if (explicitPollMs !== undefined)
+        return explicitPollMs;
+    return receiverHasQueuedWork
+        ? 60_000
+        : adaptivePollMs(loadAvg, cpuCount);
+}
 /**
  * Advance the cadence from its previous monotonic deadline while the runner is
  * on time. When a pass overruns its slot, give the host one complete interval
@@ -557,6 +638,19 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             resolveStoppedQueue();
             return;
         }
+        // A queued slow pass is the bulk-drain progress boundary. Admit it before
+        // refilling the realtime queue; otherwise a steady stream of fast work
+        // perpetually leapfrogs a receiver's bulk batch and its SQS poll loop
+        // cannot issue another receive.
+        if (activeSlowPass === null &&
+            activeFastPass === null &&
+            pendingSlowPasses.length > 0) {
+            const slow = pendingSlowPasses.shift();
+            if (slow) {
+                const current = startGuardedTask(slow.task, "slow");
+                void current.then(slow.resolve, slow.reject);
+            }
+        }
         if (activeFastPass === null) {
             const fast = pendingFastPasses.shift();
             if (fast) {
@@ -905,6 +999,22 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                 : relativePath.slice(prefix.length + 1),
         };
     };
+    /**
+     * A receiver event is eligible only when its upsert bytes are known small.
+     * Current publishers do not require a size field, so a locally journaled
+     * version is the backwards-compatible HEAD-size source. An event with no
+     * declared or journal-known size is bulk: guessing would let a large legacy
+     * transfer consume the realtime lane.
+     */
+    const receiverEventSize = (event) => {
+        if (event.kind !== "upsert")
+            return null;
+        const coordinates = journalCoordinates(event.relativePath);
+        if (!coordinates)
+            return null;
+        const size = readJournal(coordinates.slug).files[coordinates.key]?.size;
+        return Number.isSafeInteger(size) && size >= 0 ? size : null;
+    };
     const captureLocalDeleteSnapshots = (relativePath, kind) => {
         const coordinates = journalCoordinates(relativePath);
         const route = routeChangeToTarget(relativePath);
@@ -1030,6 +1140,27 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
         }
         return paths;
     };
+    const publishedContentHashBaseline = () => {
+        const hashes = {};
+        for (const { slug, journal } of listJournals()) {
+            const isPersonal = slug === PERSONAL_VAULT_JOURNAL_SLUG || slug === "personal";
+            const route = isPersonal
+                ? { kind: "personal" }
+                : { kind: "company", slug };
+            if (!isWatchRouteSelected(route, watchRouteSelection))
+                continue;
+            for (const [key, entry] of Object.entries(journal.files)) {
+                // Tombstones and link records have no live regular-file body for the
+                // PushEventEmitter's SHA-256 comparison, so they must not seed it.
+                if (entry.removedAt !== undefined ||
+                    entry.kind === "symlink" ||
+                    entry.localDiverges)
+                    continue;
+                hashes[isPersonal ? key : `companies/${slug}/${key}`] = `sha256:${entry.hash}`;
+            }
+        }
+        return hashes;
+    };
     const prepareWatcherChanges = (changes) => {
         const journals = new Map();
         const dirty = new Set();
@@ -1266,6 +1397,12 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
         return worstExit;
     };
     let receiver = null;
+    let receiverHasQueuedWork = false;
+    const onReceiveActivity = (hasMessages) => {
+        receiverHasQueuedWork = hasMessages;
+        if (hasMessages)
+            interruptWait();
+    };
     let eventSync = null;
     const realtimeState = { scheduler: null, nextHighWaterAt: null };
     function activateEventPushSurfaces(rediscovery = false) {
@@ -1342,29 +1479,34 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
             watcher.onChange((changedRelPath, batch) => {
                 if (stopped)
                     return;
-                // A complete, small watcher batch is dispatched immediately while a
-                // bulk pass is in flight. Leaving it in the next poll iteration would
-                // still make it wait for that pass even though the fast lane exists.
+                // Peel a bounded realtime sub-batch from a mixed watcher batch while a
+                // bulk pass is in flight. The residue enters the ordinary pending drain
+                // immediately; a latest path appears in exactly one of these maps.
                 const selectedBatch = batch ? selectWatchBatch(batch) : null;
-                if (selectedBatch &&
-                    !selectedBatch.overflowed &&
-                    activeSlowPass !== null &&
-                    isFastLocalBatch(selectedBatch.paths.keys(), selectedBatch.changes)) {
+                const lanes = selectedBatch && !selectedBatch.overflowed
+                    ? partitionLocalBatch(selectedBatch)
+                    : null;
+                if (lanes?.fast &&
+                    activeSlowPass !== null) {
                     const generation = ++nextWatcherBatchGeneration;
                     // Fast dispatch bypasses the pending-batch ingress, so preserve both
                     // of its contracts here: only selected routes may run, and V2 sees
                     // the same dirty signal as the compatibility drain.
                     realtimeState.scheduler?.signal("watcher");
-                    void runScopedDrain(selectedBatch, generation, true).then((exit) => {
+                    void runScopedDrain(lanes.fast, generation, true).then((exit) => {
                         if (exit === 0)
                             return;
-                        restorePendingWatcherPaths(selectedBatch.paths, generation);
+                        restorePendingWatcherPaths(lanes.fast.paths, generation);
                         interruptWait();
                     }).catch((err) => {
-                        restorePendingWatcherPaths(selectedBatch.paths, generation);
+                        restorePendingWatcherPaths(lanes.fast.paths, generation);
                         process.stderr.write(`watch fast-lane scoped push failed, will retry next tick: ${describeError(err)}\n`);
                         interruptWait();
                     });
+                    if (lanes.slow && addPendingWatcherChange(undefined, lanes.slow)) {
+                        realtimeState.scheduler?.signal("watcher");
+                        interruptWait();
+                    }
                     return;
                 }
                 if (addPendingWatcherChange(changedRelPath, batch)) {
@@ -1454,40 +1596,54 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
         const receiverSyncBatchFn = async ({ events }) => {
             if (stopped)
                 return;
+            // 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.
-            interruptWait();
-            const pathsByRoute = new Map();
-            let eligibleEventCount = 0;
-            for (const event of events) {
-                const route = routeChangeToTarget(event.relativePath);
-                if (!route)
-                    continue;
-                eligibleEventCount += 1;
-                const key = routeKey(route);
-                const group = pathsByRoute.get(key) ?? { route, paths: [] };
-                group.paths.push(event.relativePath);
-                pathsByRoute.set(key, group);
-            }
-            // One receiver delivery can fan out to many routes. Apply the advertised
-            // cap to its whole eligible payload, not independently to each route.
-            const lane = isFastReceiverBatch(eligibleEventCount)
-                ? "fast"
-                : "slow";
-            for (const { route, paths } of pathsByRoute.values()) {
-                // One guarded targeted pass per affected route, with every coalesced
-                // path for that route expressed through the watcher's existing argv seam.
-                const targetedArgv = buildTargetedPullArgv(route, passArgv, paths);
-                const result = await runGuarded(targetedArgv, undefined, lane);
-                if (passExitCode(result) !== 0) {
-                    throw new Error(`targeted pull failed with exit code ${passExitCode(result)}`);
+            // 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.
+            const lanes = partitionByKnownSizes(events, receiverEventSize);
+            const drainLane = async (lane, laneEvents) => {
+                const pathsByRoute = new Map();
+                for (const event of laneEvents) {
+                    const route = routeChangeToTarget(event.relativePath);
+                    if (!route)
+                        continue;
+                    const key = routeKey(route);
+                    const group = pathsByRoute.get(key) ?? { route, paths: [] };
+                    group.paths.push(event.relativePath);
+                    pathsByRoute.set(key, group);
                 }
-            }
+                for (const { route, paths } of pathsByRoute.values()) {
+                    const targetedArgv = buildTargetedPullArgv(route, passArgv, paths);
+                    const result = await runGuarded(targetedArgv, undefined, lane);
+                    if (passExitCode(result) !== 0) {
+                        throw new Error(`targeted pull failed with exit code ${passExitCode(result)}`);
+                    }
+                }
+            };
+            // 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);
+            await drainLane("slow", lanes.slow);
+        };
+        receiverSyncBatchFn.partition = (events) => {
+            const lanes = partitionByKnownSizes(events, receiverEventSize);
+            return [lanes.fast, lanes.slow].filter((lane) => lane.length > 0);
         };
         const createReceiver = deps.createReceiver ?? (() => new NoopPushReceiver());
-        receiver = createReceiver({ syncBatchFn: receiverSyncBatchFn, hqRoot });
+        receiver = createReceiver({
+            syncBatchFn: receiverSyncBatchFn,
+            hqRoot,
+            onReceiveActivity,
+        });
         void Promise.resolve(receiver.start()).catch(() => undefined);
         if (deps.startRealtimeScheduler) {
             // Bound the very first post-maintenance wait while the async scheduler
@@ -1562,6 +1718,9 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                     log: (m) => process.stderr.write(`${m}\n`),
                     telemetryClient: eventSyncClient,
                     telemetryClaims: claims,
+                    publishedContentHashStateDir: getStateDir(),
+                    initialPublishedContentHashes: publishedContentHashBaseline(),
+                    onReceiveActivity,
                 });
                 if (!handles)
                     return;
@@ -1807,7 +1966,7 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                     process.stderr.write(`hq-sync-runner: backup retention dry-run failed — ${error instanceof Error ? error.message : String(error)}\n`);
                 }
             }
-            const nextPollMs = explicitPollMs ?? adaptivePollMs(sampleLoadAvg(), cpuCount);
+            const nextPollMs = explicitPollMs ?? resolveWatchPollMs(undefined, receiverHasQueuedWork, receiverHasQueuedWork ? 0 : sampleLoadAvg(), cpuCount);
             const activeRealtimeScheduler = realtimeState.scheduler;
             let nextRealtimeHighWaterAt = realtimeState.nextHighWaterAt;
             if (activeRealtimeScheduler !== null && nextRealtimeHighWaterAt !== null && monotonicNow() >= nextRealtimeHighWaterAt) {
@@ -1820,7 +1979,13 @@ export async function runWatchLoop(argv, parsed, deps, runtime) {
                 } while (nextRealtimeHighWaterAt <= monotonicNow());
                 realtimeState.nextHighWaterAt = nextRealtimeHighWaterAt;
             }
-            const schedule = advanceMonotonicDeadline(nextDueAt, monotonicNow(), nextPollMs);
+            const now = monotonicNow();
+            // Queued receiver work shortens an already scheduled adaptive poll from
+            // as long as ten minutes to one minute. Its deadline must start at this
+            // receive-driven cycle rather than extending the old, still-future slot.
+            const schedule = receiverHasQueuedWork && explicitPollMs === undefined
+                ? { nextDueAt: now + nextPollMs, delayMs: nextPollMs }
+                : advanceMonotonicDeadline(nextDueAt, now, nextPollMs);
             nextDueAt = schedule.nextDueAt;
             const untilHighWaterMs = realtimeState.nextHighWaterAt === null
                 ? schedule.delayMs