@indigoai-us/hq-cloud 6.15.83 → 6.15.85

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

@@ -4842,6 +4842,237 @@ describe("runRunnerWithLoop — event-push wiring", () => {
             await loop;
         }
     });
+    it("keeps the parallel watch loop alive after an all-refused warm-up catch-up", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        const watcher = makeBatchWatcherStub();
+        let markReady = () => { };
+        let shutdown = () => { };
+        let settled;
+        watcher.onReady = (listener) => {
+            markReady = listener;
+            return () => { };
+        };
+        watcher.collectWarmupCatchup = vi.fn(() => ({
+            batch: {
+                paths: new Map([[
+                        "/tmp/hq/companies/indigo/warmup-superseded.md",
+                        "companies/indigo/warmup-superseded.md",
+                    ]]),
+            },
+            scannedPaths: 1,
+        }));
+        let receiverSync;
+        let releaseHeld = () => { };
+        const held = new Promise((resolve) => { releaseHeld = resolve; });
+        const runPass = vi.fn(async (argv) => {
+            if (argv.includes("held.md"))
+                await held;
+            return completedPassOutcome();
+        });
+        const loop = runRunnerWithLoop([
+            "--company", "indigo", "--watch", "--event-push", "--direction", "pull",
+            "--hq-root", "/tmp/hq", "--poll-remote-ms", "60000",
+        ], {
+            runPass,
+            createWatcher: () => watcher,
+            createReceiver: ({ syncBatchFn }) => {
+                receiverSync = syncBatchFn;
+                return { connected: true, start: async () => { }, dispose: async () => { } };
+            },
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                shutdown = handler;
+                return () => { };
+            },
+        });
+        void loop.then((exitCode) => { settled = exitCode; });
+        try {
+            await flushLoopMicrotasks(30);
+            runPass.mockClear();
+            const heldReceiverWork = receiverSync({
+                events: [{
+                        kind: "upsert",
+                        relativePath: "companies/indigo/held.md",
+                        contentHash: "sha256:remote",
+                        mtime: "2026-08-28T01:22:30.000Z",
+                        originDeviceId: "peer-device",
+                        originTenantId: "tenant-indigo",
+                        sequenceNumber: 1,
+                        eventTimestamp: "2026-08-28T01:22:30.000Z",
+                    }],
+                signal: new AbortController().signal,
+            });
+            await flushLoopMicrotasks();
+            markReady();
+            await flushLoopMicrotasks(30); // queues the warm-up push behind held work
+            const firstReplacement = receiverSync({
+                events: [{
+                        kind: "upsert",
+                        relativePath: "companies/indigo/warmup-superseded.md",
+                        contentHash: "sha256:remote",
+                        mtime: "2026-08-28T01:22:31.000Z",
+                        originDeviceId: "peer-device",
+                        originTenantId: "tenant-indigo",
+                        sequenceNumber: 2,
+                        eventTimestamp: "2026-08-28T01:22:31.000Z",
+                    }],
+                signal: new AbortController().signal,
+            });
+            await flushLoopMicrotasks(30); // queues the warm-up pull behind held work
+            const secondReplacement = receiverSync({
+                events: [{
+                        kind: "upsert",
+                        relativePath: "companies/indigo/warmup-superseded.md",
+                        contentHash: "sha256:remote",
+                        mtime: "2026-08-28T01:22:32.000Z",
+                        originDeviceId: "peer-device",
+                        originTenantId: "tenant-indigo",
+                        sequenceNumber: 3,
+                        eventTimestamp: "2026-08-28T01:22:32.000Z",
+                    }],
+                signal: new AbortController().signal,
+            });
+            await firstReplacement;
+            await flushLoopMicrotasks(30);
+            // Both warm-up passes were superseded while queued behind held realtime
+            // work, so the coordinator never dispatched their executor. They remain
+            // terminal no-ops rather than fabricated exit-1 runner failures.
+            expect(runPass.mock.calls.filter(([argv]) => argv.includes("warmup-superseded.md"))).toHaveLength(0);
+            expect(settled).toBeUndefined();
+            await Promise.resolve();
+            expect(settled).toBeUndefined();
+            releaseHeld();
+            await heldReceiverWork;
+            await secondReplacement;
+        }
+        finally {
+            releaseHeld();
+            shutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+        }
+    });
+    it("acknowledges superseded receiver work and records refused telemetry", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        const watcher = makeBatchWatcherStub();
+        let receiverSync;
+        let shutdown = () => { };
+        let releaseHeld = () => { };
+        const held = new Promise((resolve) => { releaseHeld = resolve; });
+        const runPass = vi.fn(async (argv) => {
+            if (argv.includes("held.md"))
+                await held;
+            return completedPassOutcome();
+        });
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            createWatcher: () => watcher,
+            createReceiver: ({ syncBatchFn }) => {
+                receiverSync = syncBatchFn;
+                return { connected: true, start: async () => { }, dispose: async () => { } };
+            },
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                shutdown = handler;
+                return () => { };
+            },
+        });
+        const stderr = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+        const event = (relativePath) => ({
+            kind: "upsert",
+            relativePath,
+            contentHash: "sha256:remote",
+            mtime: "2026-08-28T01:22:30.000Z",
+            originDeviceId: "peer-device",
+            originTenantId: "tenant-indigo",
+            sequenceNumber: 1,
+            eventTimestamp: "2026-08-28T01:22:30.000Z",
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            runPass.mockClear();
+            const heldReceiverWork = receiverSync({
+                events: [event("companies/indigo/held.md")],
+                signal: new AbortController().signal,
+            });
+            await flushLoopMicrotasks();
+            const superseded = receiverSync({
+                events: [event("companies/indigo/superseded.md")],
+                signal: new AbortController().signal,
+            });
+            await flushLoopMicrotasks();
+            const replacement = receiverSync({
+                events: [event("companies/indigo/superseded.md")],
+                signal: new AbortController().signal,
+            });
+            await expect(superseded).resolves.toBeUndefined();
+            expect(runPass.mock.calls.filter(([argv]) => argv.includes("superseded.md"))).toHaveLength(0);
+            expect(stderr.mock.calls.map(([chunk]) => String(chunk)).join("")).toContain('"event":"sync.realtime.timing","schemaVersion":1,"source":"receiver","direction":"pull","outcome":"refused"');
+            releaseHeld();
+            await heldReceiverWork;
+            await replacement;
+        }
+        finally {
+            releaseHeld();
+            shutdown();
+            await loop;
+            stderr.mockRestore();
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+        }
+    });
+    it("still rejects retryable coordinator receiver outcomes", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        const watcher = makeBatchWatcherStub();
+        let receiverSync;
+        let shutdown = () => { };
+        const runPass = vi.fn(async (argv) => argv.includes("retryable.md") ? 1 : completedPassOutcome());
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            createWatcher: () => watcher,
+            createReceiver: ({ syncBatchFn }) => {
+                receiverSync = syncBatchFn;
+                return { connected: true, start: async () => { }, dispose: async () => { } };
+            },
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                shutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            await expect(receiverSync({
+                events: [{
+                        kind: "upsert",
+                        relativePath: "companies/indigo/retryable.md",
+                        contentHash: "sha256:remote",
+                        mtime: "2026-08-28T01:22:30.000Z",
+                        originDeviceId: "peer-device",
+                        originTenantId: "tenant-indigo",
+                        sequenceNumber: 1,
+                        eventTimestamp: "2026-08-28T01:22:30.000Z",
+                    }],
+                signal: new AbortController().signal,
+            })).rejects.toThrow("targeted pull failed with exit code 1");
+        }
+        finally {
+            shutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+        }
+    });
     it("keeps every event surface off until a result proves maintenance completed", async () => {
         const watcher = makeWatcherStub();
         const sleep = makeSteppableSleep();
@@ -8820,6 +9051,129 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
         shutdown();
         await loop;
     });
+    it("parallel coordinator publishes only durable watcher paths after a subset is superseded", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        const publishBatch = vi.fn();
+        const startEventSync = vi.fn().mockResolvedValue({
+            publishBatch,
+            receiver: { start: async () => { }, dispose: async () => { }, connected: true },
+            ownDeviceId: "dev-test",
+            dispose: vi.fn().mockResolvedValue(undefined),
+        });
+        let releaseHeld = () => { };
+        const held = new Promise((resolve) => { releaseHeld = resolve; });
+        const runPass = vi.fn(async (argv) => {
+            if (argv.includes("held.md"))
+                await held;
+            return completedPassOutcome();
+        });
+        const { loop, watcher, clock, shutdown } = runLoop({
+            claims: EMAIL_CLAIMS,
+            startEventSync,
+            runPass,
+        });
+        const heldPath = "companies/indigo/held.md";
+        const supersededPath = "companies/indigo/superseded.md";
+        const durablePath = "companies/indigo/durable.md";
+        try {
+            await microtasks(30);
+            runPass.mockClear();
+            watcher.emit(heldPath, {
+                paths: new Map([[`/tmp/hq/${heldPath}`, heldPath]]),
+            });
+            clock.advance(0);
+            await microtasks(30);
+            watcher.emit(supersededPath, {
+                paths: new Map([
+                    [`/tmp/hq/${supersededPath}`, supersededPath],
+                    [`/tmp/hq/${durablePath}`, durablePath],
+                ]),
+            });
+            clock.advance(0);
+            await microtasks(30);
+            watcher.emit(supersededPath, {
+                paths: new Map([[`/tmp/hq/${supersededPath}`, supersededPath]]),
+            });
+            clock.advance(0);
+            await microtasks(30);
+            releaseHeld();
+            await microtasks(60);
+            const durableBatch = publishBatch.mock.calls
+                .map(([batch]) => [...batch.paths.values()])
+                .find((paths) => paths.includes(durablePath));
+            expect(durableBatch).toEqual([durablePath]);
+        }
+        finally {
+            releaseHeld();
+            shutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+        }
+    });
+    it("parallel coordinator publishes nothing for a wholly superseded watcher batch", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        const publishBatch = vi.fn();
+        const startEventSync = vi.fn().mockResolvedValue({
+            publishBatch,
+            receiver: { start: async () => { }, dispose: async () => { }, connected: true },
+            ownDeviceId: "dev-test",
+            dispose: vi.fn().mockResolvedValue(undefined),
+        });
+        let releaseHeld = () => { };
+        const held = new Promise((resolve) => { releaseHeld = resolve; });
+        const runPass = vi.fn(async (argv) => {
+            if (argv.includes("held.md"))
+                await held;
+            return completedPassOutcome();
+        });
+        const { loop, watcher, clock, shutdown } = runLoop({
+            claims: EMAIL_CLAIMS,
+            startEventSync,
+            runPass,
+        });
+        const heldPath = "companies/indigo/held.md";
+        const supersededPath = "companies/indigo/wholly-superseded.md";
+        try {
+            await microtasks(30);
+            runPass.mockClear();
+            watcher.emit(heldPath, {
+                paths: new Map([[`/tmp/hq/${heldPath}`, heldPath]]),
+            });
+            clock.advance(0);
+            await microtasks(30);
+            watcher.emit(supersededPath, {
+                paths: new Map([[`/tmp/hq/${supersededPath}`, supersededPath]]),
+            });
+            clock.advance(0);
+            await microtasks(30);
+            watcher.emit(supersededPath, {
+                paths: new Map([[`/tmp/hq/${supersededPath}`, supersededPath]]),
+            });
+            clock.advance(0);
+            await microtasks(30);
+            expect(runPass.mock.calls.filter(([argv]) => argv.includes("wholly-superseded.md"))).toHaveLength(0);
+            expect(publishBatch).not.toHaveBeenCalled();
+            let loopExited = false;
+            void loop.then(() => { loopExited = true; });
+            await microtasks();
+            expect(loopExited).toBe(false);
+        }
+        finally {
+            releaseHeld();
+            await microtasks(30);
+            shutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+        }
+    });
     it("does not publish unlinkDir when a covered descendant delete was refused", async () => {
         const publishBatch = vi.fn();
         const startEventSync = vi.fn().mockResolvedValue({