@indigoai-us/hq-cloud 6.15.66 → 6.15.68

package/dist/bin/sync-runner.test.js

@@ -14,7 +14,7 @@ import { runRunner, runRunnerWithLoop, resolveDeletePolicy, resolveSkipPersonal,
 import { PresignObjectIO, S3SdkObjectIO } from "../object-io.js";
 import { setBandwidthGovernorForTesting } from "../bandwidth.js";
 import { FakeClock, TreeWatcher, } from "../watcher.js";
-import { adaptivePollMs, advanceMonotonicDeadline, DEFAULT_EVENT_BATCH_LIMIT, DEFAULT_FAST_LANE_MAX_BYTES, DEFAULT_FAST_LANE_MAX_FILE_BYTES, DEFAULT_FAST_LANE_MAX_FILES, DEFAULT_FULL_RECONCILE_MS, EVENT_BATCH_LIMIT_ENV, FAST_LANE_MAX_BYTES_ENV, FAST_LANE_MAX_FILES_ENV, FULL_RECONCILE_MS_ENV, isFastLocalBatch, isFastReceiverBatch, partitionLocalBatch, journalEntriesForWatcherDelete, resolveEventBatchLimit, resolveFullReconcileMs, shouldQuarantineWatcherDeleteIntents, WATCHER_REDISCOVERY_RETRY_MS, WATCHER_REDISCOVERY_RETRY_MAX_MS, } from "./sync-runner-watch-loop.js";
+import { adaptivePollMs, advanceMonotonicDeadline, DEFAULT_EVENT_BATCH_LIMIT, DEFAULT_FAST_LANE_MAX_BYTES, DEFAULT_FAST_LANE_MAX_FILE_BYTES, DEFAULT_FAST_LANE_MAX_FILES, DEFAULT_FULL_RECONCILE_MS, EVENT_BATCH_LIMIT_ENV, FAST_LANE_MAX_BYTES_ENV, FAST_LANE_MAX_FILES_ENV, FULL_RECONCILE_MS_ENV, isFastLocalBatch, isFastReceiverBatch, partitionLocalBatch, journalEntriesForWatcherDelete, resolveEventBatchLimit, resolveFullReconcileMs, resolveWatchPollMs, shouldQuarantineWatcherDeleteIntents, WATCHER_REDISCOVERY_RETRY_MS, WATCHER_REDISCOVERY_RETRY_MAX_MS, } from "./sync-runner-watch-loop.js";
 import { PERSONAL_VAULT_JOURNAL_SLUG, readJournal, writeJournal, } from "../journal.js";
 import { HQ_CLOUD_VERSION } from "../version.js";
 import { lockPathFor, OPERATION_LOCKED_EXIT } from "../operation-lock.js";
@@ -3695,6 +3695,17 @@ describe("adaptivePollMs (whole-box CPU backoff)", () => {
         expect(adaptivePollMs(4, 4, 30_000, 300_000)).toBe(300_000);
     });
 });
+describe("resolveWatchPollMs", () => {
+    it("holds the floor after a receiver observed messages, then resumes normal backoff only after empty", () => {
+        // Regression (v6.15.66): a bulk receive was waiting behind a never-ending
+        // stream of fast passes while the CPU sampler stretched ticks to 10 min.
+        expect(resolveWatchPollMs(undefined, true, 1_000, 1)).toBe(60_000);
+        expect(resolveWatchPollMs(undefined, false, 1_000, 1)).toBe(600_000);
+    });
+    it("preserves an explicit poll cadence regardless of receiver activity", () => {
+        expect(resolveWatchPollMs(45_000, true, 1_000, 1)).toBe(45_000);
+    });
+});
 describe("advanceMonotonicDeadline", () => {
     it("gives an overrun pass a full cooldown instead of running an immediate catch-up", () => {
         // A pass due at t=0 took through t=1,800 with a 600 ms cadence. The next
@@ -3741,6 +3752,90 @@ describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", (
             },
         };
     }
+    function makeInterruptibleCapturingSleep() {
+        const delays = [];
+        const pending = [];
+        return {
+            delays,
+            sleep: (delay) => new Promise((resolve) => {
+                delays.push(delay);
+                pending.push(resolve);
+            }),
+            resolveLatest() {
+                const resolve = pending.at(-1);
+                if (!resolve)
+                    throw new Error("poll sleep was not pending");
+                resolve();
+            },
+        };
+    }
+    it("resets a long adaptive deadline when a received batch tightens the cadence", async () => {
+        const sleep = makeInterruptibleCapturingSleep();
+        const watcher = makeWatcherStub();
+        const clockState = { now: 0 };
+        let syncBatch;
+        let shutdown = () => { };
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass: vi.fn().mockResolvedValue(0),
+            createWatcher: () => watcher,
+            createReceiver: ({ syncBatchFn }) => {
+                syncBatch = syncBatchFn;
+                return { connected: true, start: async () => { }, dispose: async () => { } };
+            },
+            sleep: sleep.sleep,
+            sampleLoadAvg: () => 1_000,
+            monotonicNow: () => clockState.now,
+            onShutdownSignal: (handler) => {
+                shutdown = handler;
+                return () => { };
+            },
+        });
+        await flushLoopMicrotasks();
+        expect(sleep.delays).toEqual([600_000]);
+        clockState.now = 1_000;
+        await syncBatch({ events: [], signal: new AbortController().signal });
+        await flushLoopMicrotasks();
+        // The receive interrupts a 10-minute wait, so its next poll is one minute
+        // from the current monotonic time, not one minute after the old deadline.
+        expect(sleep.delays).toEqual([600_000, 60_000]);
+        shutdown();
+        await loop;
+    });
+    it("lets an injected receiver clear queued-work cadence state after an empty receive", async () => {
+        const sleep = makeInterruptibleCapturingSleep();
+        const watcher = makeWatcherStub();
+        const clockState = { now: 0 };
+        let reportReceiveActivity;
+        let shutdown = () => { };
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass: vi.fn().mockResolvedValue(0),
+            createWatcher: () => watcher,
+            createReceiver: ({ onReceiveActivity }) => {
+                reportReceiveActivity = onReceiveActivity;
+                return { connected: true, start: async () => { }, dispose: async () => { } };
+            },
+            sleep: sleep.sleep,
+            sampleLoadAvg: () => 1_000,
+            monotonicNow: () => clockState.now,
+            onShutdownSignal: (handler) => {
+                shutdown = handler;
+                return () => { };
+            },
+        });
+        await flushLoopMicrotasks();
+        expect(reportReceiveActivity).toBeTypeOf("function");
+        clockState.now = 1_000;
+        reportReceiveActivity(true);
+        await flushLoopMicrotasks();
+        expect(sleep.delays).toEqual([600_000, 60_000]);
+        reportReceiveActivity(false);
+        clockState.now = 61_000;
+        sleep.resolveLatest();
+        await flushLoopMicrotasks();
+        expect(sleep.delays).toEqual([600_000, 60_000, 600_000]);
+        shutdown();
+        await loop;
+    });
     it("waits only the bounded remainder of the idle cadence slot", async () => {
         const { calls, sleep } = makeCapturingSleep();
         const monotonicNow = vi
@@ -5103,6 +5198,65 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         await loop;
         fs.rmSync(hqRoot, { recursive: true, force: true });
     });
+    it("REGRESSION: a queued bulk receiver drain gets a turn before later fast arrivals", async () => {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-bulk-drain-fairness-"));
+        const watcher = makeWatcherStub();
+        let receiverSync;
+        let triggerShutdown = () => { };
+        let releaseFirstFast = () => { };
+        const firstFast = new Promise((resolve) => { releaseFirstFast = resolve; });
+        const order = [];
+        const journal = readJournal("acme");
+        journal.files["realtime.md"] = {
+            hash: "sha256:x", size: 16, syncedAt: "2026-08-26T00:00:00.000Z", direction: "down",
+        };
+        writeJournal("acme", journal);
+        const runPass = vi.fn().mockImplementation(async (argv) => {
+            const scope = argv[argv.indexOf("--scope-path") + 1];
+            if (scope === "realtime.md") {
+                order.push(`fast-${order.filter((item) => item.startsWith("fast-")).length + 1}`);
+                if (order.length === 1)
+                    await firstFast;
+            }
+            else {
+                order.push("bulk");
+            }
+            return completedPassOutcome();
+        });
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", hqRoot], {
+            runPass,
+            createWatcher: () => watcher,
+            createReceiver: ({ syncBatchFn }) => {
+                receiverSync = syncBatchFn;
+                return { connected: true, start: async () => { }, dispose: async () => { } };
+            },
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        await flushLoopMicrotasks();
+        order.splice(0);
+        const event = (relativePath, sequenceNumber) => ({
+            kind: "upsert", relativePath, contentHash: "sha256:x", mtime: "2026-08-26T00:00:00.000Z",
+            originDeviceId: "peer", originTenantId: "tenant-acme", sequenceNumber,
+            eventTimestamp: "2026-08-26T00:00:00.000Z",
+        });
+        const fastOne = receiverSync({ events: [event("companies/acme/realtime.md", 1)], signal: new AbortController().signal });
+        await flushLoopMicrotasks();
+        const bulk = receiverSync({ events: [event("companies/acme/bulk.log", 2)], signal: new AbortController().signal });
+        const fastTwo = receiverSync({ events: [event("companies/acme/realtime.md", 3)], signal: new AbortController().signal });
+        releaseFirstFast();
+        await flushLoopMicrotasks(30);
+        // origin/main failure: ["fast-1", "fast-2"] — the queued bulk path is
+        // perpetually leapfrogged and the SQS receiver cannot issue its next poll.
+        expect(order.slice(0, 2)).toEqual(["fast-1", "bulk"]);
+        await Promise.all([fastOne, bulk, fastTwo]);
+        triggerShutdown();
+        await loop;
+        fs.rmSync(hqRoot, { recursive: true, force: true });
+    });
     it("fast lane: keeps disjoint journal rows under a 16-path interleave with a bulk pass", async () => {
         const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-fast-lane-journal-"));
         const paths = Array.from({ length: 16 }, (_, index) => {