@indigoai-us/hq-cloud 6.15.82 → 6.15.84

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

@@ -4067,6 +4067,238 @@ describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", (
     });
 });
 describe("runRunnerWithLoop — event-push wiring", () => {
+    it("parallel coordinator activates every event surface after a partial completed full reconcile", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        const previousEventSync = process.env.HQ_SYNC_EVENT_SYNC;
+        const previousFullReconcileMs = process.env.HQ_SYNC_FULL_RECONCILE_MS;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        process.env.HQ_SYNC_EVENT_SYNC = "1";
+        process.env.HQ_SYNC_FULL_RECONCILE_MS = "60000";
+        const watcher = makeWatcherStub();
+        const receiver = {
+            connected: false,
+            start: vi.fn().mockResolvedValue(undefined),
+            dispose: vi.fn().mockResolvedValue(undefined),
+        };
+        const scheduler = {
+            signal: vi.fn(),
+            checkHighWater: vi.fn().mockResolvedValue(undefined),
+            dispose: vi.fn().mockResolvedValue(undefined),
+        };
+        const sleep = makeSteppableSleep();
+        let now = 0;
+        let triggerShutdown = () => { };
+        const createWatcher = vi.fn(() => watcher);
+        const createReceiver = vi.fn(() => receiver);
+        const startRealtimeScheduler = vi.fn().mockResolvedValue(scheduler);
+        const startEventSync = vi.fn().mockResolvedValue(null);
+        const runPass = vi.fn().mockResolvedValue(completedPassOutcome(PARTIAL_SYNC_EXIT));
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            createWatcher,
+            createReceiver,
+            startRealtimeScheduler,
+            startEventSync,
+            getIdTokenClaims: () => null,
+            getAccessToken: async () => "jwt-test",
+            monotonicNow: () => now,
+            sleep: sleep.sleep,
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            expect(createWatcher).toHaveBeenCalledTimes(1);
+            expect(createReceiver).toHaveBeenCalledTimes(1);
+            expect(receiver.start).toHaveBeenCalledTimes(1);
+            expect(startRealtimeScheduler).toHaveBeenCalledTimes(1);
+            expect(startEventSync).toHaveBeenCalledTimes(1);
+            // A partial RunnerPassOutcome is a completed legacy-equivalent pass, so
+            // its completion must restart the configured full-reconcile cadence.
+            now = 1;
+            sleep.tick();
+            await flushLoopMicrotasks();
+            expect(runPass).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+            if (previousEventSync === undefined)
+                delete process.env.HQ_SYNC_EVENT_SYNC;
+            else
+                process.env.HQ_SYNC_EVENT_SYNC = previousEventSync;
+            if (previousFullReconcileMs === undefined)
+                delete process.env.HQ_SYNC_FULL_RECONCILE_MS;
+            else
+                process.env.HQ_SYNC_FULL_RECONCILE_MS = previousFullReconcileMs;
+        }
+    });
+    it("parallel coordinator activates event surfaces and advances cadence after a numeric-zero full reconcile", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        const previousEventSync = process.env.HQ_SYNC_EVENT_SYNC;
+        const previousFullReconcileMs = process.env.HQ_SYNC_FULL_RECONCILE_MS;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        process.env.HQ_SYNC_EVENT_SYNC = "1";
+        process.env.HQ_SYNC_FULL_RECONCILE_MS = "60000";
+        const watcher = makeWatcherStub();
+        const receiver = {
+            connected: false,
+            start: vi.fn().mockResolvedValue(undefined),
+            dispose: vi.fn().mockResolvedValue(undefined),
+        };
+        const scheduler = {
+            signal: vi.fn(),
+            checkHighWater: vi.fn().mockResolvedValue(undefined),
+            dispose: vi.fn().mockResolvedValue(undefined),
+        };
+        const sleep = makeSteppableSleep();
+        let now = 0;
+        let triggerShutdown = () => { };
+        const createWatcher = vi.fn(() => watcher);
+        const createReceiver = vi.fn(() => receiver);
+        const startRealtimeScheduler = vi.fn().mockResolvedValue(scheduler);
+        const startEventSync = vi.fn().mockResolvedValue(null);
+        const runPass = vi.fn().mockResolvedValue(0);
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            createWatcher,
+            createReceiver,
+            startRealtimeScheduler,
+            startEventSync,
+            getIdTokenClaims: () => null,
+            getAccessToken: async () => "jwt-test",
+            monotonicNow: () => now,
+            sleep: sleep.sleep,
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            expect(createWatcher).toHaveBeenCalledTimes(1);
+            expect(createReceiver).toHaveBeenCalledTimes(1);
+            expect(receiver.start).toHaveBeenCalledTimes(1);
+            expect(startRealtimeScheduler).toHaveBeenCalledTimes(1);
+            expect(startEventSync).toHaveBeenCalledTimes(1);
+            // The accepted numeric success seam must advance cadence, preventing an
+            // immediate second full reconcile before the configured interval.
+            now = 1;
+            sleep.tick();
+            await flushLoopMicrotasks();
+            expect(runPass).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+            if (previousEventSync === undefined)
+                delete process.env.HQ_SYNC_EVENT_SYNC;
+            else
+                process.env.HQ_SYNC_EVENT_SYNC = previousEventSync;
+            if (previousFullReconcileMs === undefined)
+                delete process.env.HQ_SYNC_FULL_RECONCILE_MS;
+            else
+                process.env.HQ_SYNC_FULL_RECONCILE_MS = previousFullReconcileMs;
+        }
+    });
+    it("parallel coordinator keeps event surfaces off for an auth-required full reconcile", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        const previousEventSync = process.env.HQ_SYNC_EVENT_SYNC;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        process.env.HQ_SYNC_EVENT_SYNC = "1";
+        const watcher = makeWatcherStub();
+        const createWatcher = vi.fn(() => watcher);
+        const createReceiver = vi.fn();
+        const startRealtimeScheduler = vi.fn();
+        const startEventSync = vi.fn();
+        let triggerShutdown = () => { };
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass: vi.fn().mockResolvedValue(AUTH_REQUIRED_PASS_EXIT),
+            createWatcher,
+            createReceiver,
+            startRealtimeScheduler,
+            startEventSync,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            expect(createWatcher).not.toHaveBeenCalled();
+            expect(createReceiver).not.toHaveBeenCalled();
+            expect(startRealtimeScheduler).not.toHaveBeenCalled();
+            expect(startEventSync).not.toHaveBeenCalled();
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+            if (previousEventSync === undefined)
+                delete process.env.HQ_SYNC_EVENT_SYNC;
+            else
+                process.env.HQ_SYNC_EVENT_SYNC = previousEventSync;
+        }
+    });
+    it("parallel coordinator keeps event surfaces off when no RunnerPassOutcome completed", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        const previousEventSync = process.env.HQ_SYNC_EVENT_SYNC;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        process.env.HQ_SYNC_EVENT_SYNC = "1";
+        const watcher = makeWatcherStub();
+        const createWatcher = vi.fn(() => watcher);
+        const createReceiver = vi.fn();
+        const startRealtimeScheduler = vi.fn();
+        const startEventSync = vi.fn();
+        let triggerShutdown = () => { };
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            // A bare nonzero status represents a chore that did not produce the
+            // post-repair runner outcome needed to prove completion.
+            runPass: vi.fn().mockResolvedValue(PARTIAL_SYNC_EXIT),
+            createWatcher,
+            createReceiver,
+            startRealtimeScheduler,
+            startEventSync,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            expect(createWatcher).not.toHaveBeenCalled();
+            expect(createReceiver).not.toHaveBeenCalled();
+            expect(startRealtimeScheduler).not.toHaveBeenCalled();
+            expect(startEventSync).not.toHaveBeenCalled();
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+            if (previousEventSync === undefined)
+                delete process.env.HQ_SYNC_EVENT_SYNC;
+            else
+                process.env.HQ_SYNC_EVENT_SYNC = previousEventSync;
+        }
+    });
     it("keeps a healthy watcher through repeated poll cycles and the periodic full reconcile", async () => {
         const sleep = makeSteppableSleep();
         const watchers = [];
@@ -4610,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();
@@ -8588,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({