@indigoai-us/hq-cloud 6.18.32 → 6.18.34

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

@@ -20,10 +20,10 @@ import { AUTH_WAIT_INITIAL_RECHECK_MS, AUTH_WAIT_RESUME_MESSAGE, AUTH_WAIT_START
 import { PresignObjectIO, S3SdkObjectIO } from "../object-io.js";
 import { BandwidthGovernor, setBandwidthGovernorForTesting, } from "../bandwidth.js";
 import { POST_SYNC_FLAG_KEYS, } from "./sync-runner-post-sync-flags.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, resolveWatchPollMs, CHORE_STARVATION_CAP_MS, CooperativePassScheduler, REALTIME_ADMISSION_DEADLINE_MS, REALTIME_DRAIN_BURST_MS, REALTIME_WORKER_OCCUPANCY_CAP, RealtimeAdmissionTimeoutError, setRealtimeAdmissionDeadlineMsForTesting, setRealtimeDrainBurstMsForTesting, normalizeCoordinatorPaths, shouldQuarantineWatcherDeleteIntents, shouldUseAreaStorage, WATCHER_REDISCOVERY_RETRY_MS, WATCHER_REDISCOVERY_RETRY_MAX_MS, EVENT_SYNC_STARTUP_SHUTDOWN_WAIT_MS, } from "./sync-runner-watch-loop.js";
+import { FakeClock, TreeWatcher, createWatchPathFilter, } 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, isLargeLocalUpload, localUploadSizeClass, isChoreLocalPush, isSessionLogsPushOnlyPath, isFastReceiverBatch, partitionLocalBatch, journalEntriesForWatcherDelete, resolveEventBatchLimit, resolveFullReconcileMs, resolveWatchPollMs, CHORE_STARVATION_CAP_MS, CooperativePassScheduler, REALTIME_ADMISSION_DEADLINE_MS, REALTIME_DRAIN_BURST_MS, REALTIME_WORKER_OCCUPANCY_CAP, REALTIME_LARGE_UPLOAD_THRESHOLD_BYTES, RealtimeAdmissionTimeoutError, setRealtimeAdmissionDeadlineMsForTesting, setRealtimeDrainBurstMsForTesting, normalizeCoordinatorPaths, shouldQuarantineWatcherDeleteIntents, shouldUseAreaStorage, WATCHER_REDISCOVERY_RETRY_MS, WATCHER_REDISCOVERY_RETRY_MAX_MS, EVENT_SYNC_STARTUP_SHUTDOWN_WAIT_MS, } from "./sync-runner-watch-loop.js";
 import { FullPassCapController, resetFullPassCapLogForTest, } from "../sync/full-pass-caps.js";
-import { AreaLedgerMigration, JournalStore, openJournalStateStoreForMigration, PERSONAL_VAULT_JOURNAL_SLUG, readJournal, readJournalForPass, readJournalScoped, readJournalScopedAsync, writeJournal, } from "../journal.js";
+import { AreaLedgerMigration, JournalStore, getJournalPath, openJournalStateStoreForMigration, PERSONAL_VAULT_JOURNAL_SLUG, readJournal, readJournalForPass, readJournalScoped, readJournalScopedAsync, writeJournal, } from "../journal.js";
 import { AreaLedger } from "../sync/area-ledger.js";
 import { AreaResolver } from "../sync/area-resolver.js";
 import { AREA_LEGACY_MIRROR_LINGER_MS } from "../sync/area-ledger-migration.js";
@@ -3145,11 +3145,12 @@ describe("all-complete aggregate", () => {
             true,
         ]);
         expect(reindex).toHaveBeenCalledTimes(1);
-        // Session logs are recopied at most every 10 minutes from the runner.
+        // Session logs are captured only after ten minutes without source changes.
         expect(reindex).toHaveBeenCalledWith({
             repoRoot: "/tmp/fake-hq",
             skipLock: true,
-            sessionLogMinIntervalMs: 600_000,
+            sessionLogQuietForMs: 600_000,
+            sessionLogMaxStalenessMs: 3_600_000,
         });
     });
     it("gates qmd to indexable knowledge and project changes and propagates hq-relative paths", async () => {
@@ -6360,6 +6361,8 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         writeJournal("personal", legacy);
         const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-warmup-rows-"));
         fs.mkdirSync(path.join(hqRoot, "companies", "indigo", "repos", "x"), { recursive: true });
+        fs.mkdirSync(path.join(hqRoot, "companies", "bad-json"), { recursive: true });
+        fs.writeFileSync(getJournalPath("bad-json"), "{corrupt legacy journal");
         fs.writeFileSync(path.join(hqRoot, "companies", "indigo", "repos", "x", "a.md"), "keep local repository checkout");
         const watcher = makeBatchWatcherStub();
         let markReady = () => { };
@@ -6735,7 +6738,7 @@ describe("runRunnerWithLoop — event-push wiring", () => {
             });
             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":3,"source":"receiver","direction":"pull","outcome":"refused"');
+            expect(stderr.mock.calls.map(([chunk]) => String(chunk)).join("")).toContain('"event":"sync.realtime.timing","schemaVersion":5,"source":"receiver","direction":"pull","sizeClass":"unknown","outcome":"refused"');
             releaseHeld();
             await heldReceiverWork;
             await replacement;
@@ -9073,6 +9076,7 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         fs.rmSync(hqRoot, { recursive: true, force: true });
     });
     it("U07: drains the first watcher event after activation without guarded overlap", async () => {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-watch-first-event-"));
         const watcher = makeWatcherStub();
         let triggerShutdown = () => { };
         let releaseFirstPass = () => { };
@@ -9097,7 +9101,7 @@ describe("runRunnerWithLoop — event-push wiring", () => {
             "--poll-remote-ms",
             "600000",
             "--hq-root",
-            "/tmp/hq",
+            hqRoot,
         ], {
             runPass,
             createWatcher: () => watcher,
@@ -9114,13 +9118,17 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         expect(watcher.started).toBe(true);
         // Activation happens synchronously after the maintenance-bearing pass,
         // before the next wait is registered. Its first event must still drain.
+        const eventPath = path.join(hqRoot, "companies/indigo/pre-registration.md");
+        fs.mkdirSync(path.dirname(eventPath), { recursive: true });
+        fs.writeFileSync(eventPath, "small watcher edit");
         watcher.emit("companies/indigo/pre-registration.md");
-        await flushLoopMicrotasks();
+        await flushLoopMicrotasks(32);
         expect(spans).toHaveLength(3);
         expect(spans[1].enteredAt >= spans[0].exitedAt).toBe(true);
         expect(spans[2].enteredAt >= spans[1].exitedAt).toBe(true);
         triggerShutdown();
         await loop;
+        fs.rmSync(hqRoot, { recursive: true, force: true });
     });
     it("F05: guard-held watcher changes stay accumulated, then drain immediately after the guarded pass", async () => {
         const watcher = makeWatcherStub();
@@ -9343,7 +9351,7 @@ describe("runRunnerWithLoop — event-push wiring", () => {
                 return () => { };
             },
         });
-        await flushLoopMicrotasks();
+        await waitForPollSleep(sleep);
         sleep.tick();
         await flushLoopMicrotasks();
         // The transient pass did NOT end the loop — it ran again, and neither
@@ -9385,6 +9393,7 @@ describe("runRunnerWithLoop — event-push wiring", () => {
             },
         });
         await flushLoopMicrotasks();
+        await waitForPollSleep(sleep);
         sleep.tick();
         await flushLoopMicrotasks();
         expect(routedArgv).toEqual([
@@ -9924,6 +9933,152 @@ describe("runRunnerWithLoop — U58 realtime scheduler guard", () => {
     });
 });
 describe("CooperativePassScheduler", () => {
+    it("identifies session-log backups for the chore-only route", () => {
+        const transcript = "workspace/.session-logs/codex/2026/10/01/live.jsonl";
+        expect(isSessionLogsPushOnlyPath(transcript)).toBe(true);
+        expect(isSessionLogsPushOnlyPath("workspace/notes.md")).toBe(false);
+        expect(isChoreLocalPush([transcript], false)).toBe(true);
+        expect(isChoreLocalPush(["workspace/notes.md"], false)).toBe(false);
+        expect(isChoreLocalPush(["workspace/notes.md"], true)).toBe(true);
+    });
+    it("reserves a realtime occupant for each transfer direction", async () => {
+        const scheduler = new CooperativePassScheduler(() => 0);
+        const started = [];
+        let releasePush1 = () => { };
+        const push1Gate = new Promise((resolve) => { releasePush1 = resolve; });
+        let releasePush2 = () => { };
+        const push2Gate = new Promise((resolve) => { releasePush2 = resolve; });
+        let releaseCheckpoint = () => { };
+        const checkpointReady = new Promise((resolve) => { releaseCheckpoint = resolve; });
+        const chore = scheduler.submit(async ({ checkpoint }) => {
+            await checkpointReady;
+            await checkpoint();
+            return 0;
+        }, "chore");
+        await Promise.resolve();
+        const push1 = scheduler.submit(async () => {
+            started.push("push-1");
+            await push1Gate;
+            return 0;
+        }, "realtime", "slow", false, undefined, false, false, "push");
+        releaseCheckpoint();
+        await new Promise((resolve) => setTimeout(resolve, 2));
+        const push2 = scheduler.submit(async () => {
+            started.push("push-2");
+            await push2Gate;
+            return 0;
+        }, "realtime", "slow", false, undefined, false, true, "push");
+        await new Promise((resolve) => setTimeout(resolve, 2));
+        const pull = scheduler.submit(async () => {
+            started.push("pull");
+            return 0;
+        }, "realtime", "slow", false, undefined, false, true, "pull");
+        try {
+            await new Promise((resolve) => setTimeout(resolve, 2));
+            expect(started).toContain("pull");
+        }
+        finally {
+            releasePush1();
+            releasePush2();
+            await Promise.all([chore, push1, push2, pull]);
+        }
+    });
+    it("classifies uploads at the multipart part-size boundary", () => {
+        const directory = fs.mkdtempSync(path.join(os.tmpdir(), "hq-large-upload-class-"));
+        try {
+            const small = path.join(directory, "small.txt");
+            const large = path.join(directory, "large.bin");
+            const missing = path.join(directory, "not-created-yet.txt");
+            fs.writeFileSync(small, "small edit");
+            const fd = fs.openSync(large, "w");
+            fs.ftruncateSync(fd, REALTIME_LARGE_UPLOAD_THRESHOLD_BYTES);
+            fs.closeSync(fd);
+            expect(REALTIME_LARGE_UPLOAD_THRESHOLD_BYTES).toBe(8 * 1024 * 1024);
+            expect(isLargeLocalUpload([small])).toBe(false);
+            expect(isLargeLocalUpload([large])).toBe(true);
+            expect(localUploadSizeClass([small])).toBe("small");
+            expect(localUploadSizeClass([large])).toBe("large");
+            expect(localUploadSizeClass([missing])).toBe("unknown");
+            expect(isLargeLocalUpload([missing])).toBe(true);
+        }
+        finally {
+            fs.rmSync(directory, { recursive: true, force: true });
+        }
+    });
+    it("keeps small pulls under 5s during a 60s fake S3 PUT despite excluded path floods", async () => {
+        vi.useFakeTimers();
+        const watchRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-realtime-excluded-flood-"));
+        try {
+            const scheduler = new CooperativePassScheduler(() => Date.now());
+            const shouldWatch = createWatchPathFilter(watchRoot, false);
+            const fakeS3 = new Map();
+            const localFiles = new Map();
+            const mirrorJournal = new Map();
+            const remoteChanges = Array.from({ length: 20 }, (_, index) => [`remote-${index}`, `value-${index}`]);
+            for (const [key, value] of remoteChanges)
+                fakeS3.set(key, value);
+            let markPutStarted = () => { };
+            const putStarted = new Promise((resolve) => { markPutStarted = resolve; });
+            let largePutComplete = false;
+            const upload = scheduler.submit(async ({ checkpoint }) => {
+                const transfer = await checkpoint.runChoreNetworkTransfer(async () => {
+                    markPutStarted();
+                    await new Promise((resolve) => { setTimeout(resolve, 60_000); });
+                    fakeS3.set("large-upload", "large payload");
+                    return "large-upload";
+                });
+                largePutComplete = true;
+                mirrorJournal.set(transfer.value, fakeS3.get(transfer.value) ?? "");
+                transfer.complete();
+                return 0;
+            }, "chore");
+            await putStarted;
+            for (let index = 0; index < 1_000; index += 1) {
+                const excluded = path.join(watchRoot, "workspace", "worktrees", `lane-${index}`, "output.ts");
+                if (shouldWatch(excluded)) {
+                    void scheduler.submit(async () => 0, "realtime", "slow", false, undefined, false, true, "push", "small");
+                }
+            }
+            expect(scheduler.activeRealtimeWorkerCount).toBe(0);
+            expect(scheduler.pendingLaneCount("slow")).toBe(0);
+            let allPullsSettled = false;
+            const pullWaits = remoteChanges.map(([key]) => {
+                const arrivedAt = Date.now();
+                return scheduler.submit(async () => {
+                    const value = fakeS3.get(key);
+                    if (value === undefined)
+                        throw new Error(`fake S3 object missing: ${key}`);
+                    localFiles.set(key, value);
+                    mirrorJournal.set(key, value);
+                    return Date.now() - arrivedAt;
+                }, "realtime", "slow", false, undefined, false, true, "pull", "small");
+            });
+            const allPullWaits = Promise.all(pullWaits).then((waits) => {
+                allPullsSettled = true;
+                return waits;
+            });
+            await vi.advanceTimersByTimeAsync(5_000);
+            const pullsMetWorkerBound = allPullsSettled;
+            if (!pullsMetWorkerBound)
+                await vi.advanceTimersByTimeAsync(55_000);
+            const waits = await allPullWaits;
+            expect(pullsMetWorkerBound).toBe(true);
+            expect(waits.every((waitMs) => waitMs < 5_000)).toBe(true);
+            expect(localFiles.size).toBe(remoteChanges.length);
+            expect(largePutComplete).toBe(false);
+            expect(mirrorJournal.has("large-upload")).toBe(false);
+            if (!largePutComplete)
+                await vi.advanceTimersByTimeAsync(55_000);
+            await upload;
+            expect(largePutComplete).toBe(true);
+            expect(fakeS3.get("large-upload")).toBe("large payload");
+            expect(mirrorJournal.get("large-upload")).toBe("large payload");
+        }
+        finally {
+            vi.useRealTimers();
+            fs.rmSync(watchRoot, { recursive: true, force: true });
+        }
+    });
     it("admits realtime during payload I/O and fences the next chore transfer until the result is committed", async () => {
         const scheduler = new CooperativePassScheduler(() => 0);
         const order = [];
@@ -10581,6 +10736,7 @@ describe("CooperativePassScheduler", () => {
 });
 describe("first-tick realtime yield", () => {
     it("commits a watcher push at the first chore checkpoint without a wall-clock wait", async () => {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-first-tick-realtime-"));
         const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
         const previousInterval = process.env.HQ_SYNC_FULL_RECONCILE_MS;
         process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
@@ -10635,7 +10791,7 @@ describe("first-tick realtime yield", () => {
             "--direction",
             "both",
             "--hq-root",
-            "/tmp/hq",
+            hqRoot,
             "--poll-remote-ms",
             "60000",
         ], {
@@ -10651,9 +10807,12 @@ describe("first-tick realtime yield", () => {
         });
         try {
             await flushLoopMicrotasks(40);
+            const notePath = path.join(hqRoot, "companies/indigo/note.md");
+            fs.mkdirSync(path.dirname(notePath), { recursive: true });
+            fs.writeFileSync(notePath, "small watcher edit");
             watcher.emit("companies/indigo/note.md", {
                 paths: new Map([
-                    ["/tmp/hq/companies/indigo/note.md", "companies/indigo/note.md"],
+                    [notePath, "companies/indigo/note.md"],
                 ]),
             });
             await new Promise((resolve) => setImmediate(resolve));
@@ -10687,6 +10846,7 @@ describe("first-tick realtime yield", () => {
                 delete process.env.HQ_SYNC_FULL_RECONCILE_MS;
             else
                 process.env.HQ_SYNC_FULL_RECONCILE_MS = previousInterval;
+            fs.rmSync(hqRoot, { recursive: true, force: true });
         }
     });
 });
@@ -11844,6 +12004,10 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
         await loop;
     });
     it("push-only scoped ticks run the scoped push and no pull leg", async () => {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-push-only-tick-"));
+        const file = path.join(hqRoot, "companies/indigo/knowledge/a.md");
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, "small watcher edit");
         const runPass = vi.fn().mockResolvedValue(completedPassOutcome());
         const { loop, watcher, tick, shutdown } = startDrainLoopWithArgv(runPass, [
             "--companies",
@@ -11852,15 +12016,15 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
             "--direction",
             "push",
             "--hq-root",
-            "/tmp/hq",
+            hqRoot,
             "--poll-remote-ms",
             "60000",
         ]);
-        await flushLoopMicrotasks();
+        await flushLoopMicrotasks(30);
         runPass.mockClear();
         watcher.emit("companies/indigo/knowledge/a.md");
         tick();
-        await flushLoopMicrotasks();
+        await flushLoopMicrotasks(30);
         expect(runPass.mock.calls.map((call) => call[0])).toEqual([
             [
                 "--company",
@@ -11870,12 +12034,13 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
                 "--scope-path",
                 "knowledge/a.md",
                 "--hq-root",
-                "/tmp/hq",
+                hqRoot,
             ],
         ]);
         shutdown();
         tick();
         await loop;
+        fs.rmSync(hqRoot, { recursive: true, force: true });
     });
     it("overflow and an elapsed hour run a full unscoped reconcile", async () => {
         const clockState = { now: 0 };
@@ -12141,11 +12306,14 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
         }
     });
     it("a 5,000-path batch under the shipped default stays on the targeted path", async () => {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-5000-path-batch-"));
+        const argv = [...watchArgv];
+        argv[argv.indexOf("/tmp/hq")] = hqRoot;
         const watcher = makeBatchWatcherStub();
         const sleep = makeSteppableSleep();
         let triggerShutdown = () => { };
         const runPass = vi.fn().mockResolvedValue(completedPassOutcome());
-        const loop = runRunnerWithLoop(watchArgv, {
+        const loop = runRunnerWithLoop(argv, {
             runPass,
             clock: new FakeClock(),
             createWatcher: () => watcher,
@@ -12158,13 +12326,16 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
         await flushLoopMicrotasks();
         runPass.mockClear();
         watcher.emit("companies/indigo/a.md", {
-            paths: new Map(Array.from({ length: 5_000 }, (_, index) => [
-                `/tmp/hq/companies/indigo/${index}.md`,
-                `companies/indigo/${index}.md`,
-            ])),
+            paths: new Map(Array.from({ length: 5_000 }, (_, index) => {
+                const relativePath = `companies/indigo/${index}.md`;
+                const absolutePath = path.join(hqRoot, relativePath);
+                fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+                fs.writeFileSync(absolutePath, "x");
+                return [absolutePath, relativePath];
+            })),
         });
         sleep.tick();
-        await flushLoopMicrotasks();
+        await waitForCondition("5,000-path batch to split into two scoped passes", () => runPass.mock.calls.length === 2);
         const calls = runPass.mock.calls.map((call) => call[0]);
         expect(calls).not.toContainEqual(fullArgv);
         expect(calls).toHaveLength(2);
@@ -12178,6 +12349,7 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
         expect(calls[1]?.filter((arg) => arg === "--scope-path")).toHaveLength(5_000);
         triggerShutdown();
         await loop;
+        fs.rmSync(hqRoot, { recursive: true, force: true });
     });
     it("a batch above the shipped 10,000-path default stays on chunked targeted passes before the interval", async () => {
         const saved = process.env.HQ_SYNC_FULL_RECONCILE_MS;
@@ -13835,12 +14007,13 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
                 ]]),
         });
         tick();
-        await microtasks();
+        await microtasks(30);
         expect(publishBatch).not.toHaveBeenCalled();
         shutdown();
         await loop;
     });
     it("parallel coordinator publishes only durable watcher paths after a subset is superseded", async () => {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-subset-superseded-"));
         const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
         process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
         const publishBatch = vi.fn();
@@ -13859,36 +14032,42 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
         });
         const { loop, watcher, clock, waitForPoll, shutdown } = runLoop({
             claims: EMAIL_CLAIMS,
+            hqRoot,
             startEventSync,
             runPass,
         });
         const heldPath = "companies/indigo/held.md";
         const supersededPath = "companies/indigo/superseded.md";
         const durablePath = "companies/indigo/durable.md";
+        for (const relativePath of [heldPath, supersededPath, durablePath]) {
+            const absolutePath = path.join(hqRoot, relativePath);
+            fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+            fs.writeFileSync(absolutePath, "small watcher edit");
+        }
         try {
             await waitForPoll();
             await waitForObservable("watcher subscription to become active", () => watcher.started && watcher.listenerCount() > 0);
             runPass.mockClear();
             watcher.emit(heldPath, {
-                paths: new Map([[`/tmp/hq/${heldPath}`, heldPath]]),
-                changes: new Map([[`/tmp/hq/${heldPath}`, { kind: "change" }]]),
+                paths: new Map([[path.join(hqRoot, heldPath), heldPath]]),
+                changes: new Map([[path.join(hqRoot, heldPath), { kind: "change" }]]),
             });
             clock.advance(0);
             await waitForObservable("held watcher push to start", () => runPass.mock.calls.some(([argv]) => argv.includes("held.md")));
             watcher.emit(supersededPath, {
                 paths: new Map([
-                    [`/tmp/hq/${supersededPath}`, supersededPath],
-                    [`/tmp/hq/${durablePath}`, durablePath],
+                    [path.join(hqRoot, supersededPath), supersededPath],
+                    [path.join(hqRoot, durablePath), durablePath],
                 ]),
                 changes: new Map([
-                    [`/tmp/hq/${supersededPath}`, { kind: "change" }],
-                    [`/tmp/hq/${durablePath}`, { kind: "change" }],
+                    [path.join(hqRoot, supersededPath), { kind: "change" }],
+                    [path.join(hqRoot, durablePath), { kind: "change" }],
                 ]),
             });
             clock.advance(0);
             watcher.emit(supersededPath, {
-                paths: new Map([[`/tmp/hq/${supersededPath}`, supersededPath]]),
-                changes: new Map([[`/tmp/hq/${supersededPath}`, { kind: "change" }]]),
+                paths: new Map([[path.join(hqRoot, supersededPath), supersededPath]]),
+                changes: new Map([[path.join(hqRoot, supersededPath), { kind: "change" }]]),
             });
             clock.advance(0);
             releaseHeld();
@@ -13907,9 +14086,11 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
                 delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
             else
                 process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+            fs.rmSync(hqRoot, { recursive: true, force: true });
         }
     });
     it("parallel coordinator publishes nothing for a wholly superseded watcher batch", async () => {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-wholly-superseded-"));
         const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
         process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
         const publishBatch = vi.fn();
@@ -13928,26 +14109,32 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
         });
         const { loop, watcher, clock, shutdown } = runLoop({
             claims: EMAIL_CLAIMS,
+            hqRoot,
             startEventSync,
             runPass,
         });
         const heldPath = "companies/indigo/held.md";
         const supersededPath = "companies/indigo/wholly-superseded.md";
+        const heldAbsolutePath = path.join(hqRoot, heldPath);
+        fs.mkdirSync(path.dirname(heldAbsolutePath), { recursive: true });
+        fs.writeFileSync(heldAbsolutePath, "small watcher edit");
         try {
             await microtasks(30);
             runPass.mockClear();
             watcher.emit(heldPath, {
-                paths: new Map([[`/tmp/hq/${heldPath}`, heldPath]]),
+                paths: new Map([[path.join(hqRoot, heldPath), heldPath]]),
             });
             clock.advance(0);
             await microtasks(30);
             watcher.emit(supersededPath, {
-                paths: new Map([[`/tmp/hq/${supersededPath}`, supersededPath]]),
+                paths: new Map([[path.join(hqRoot, supersededPath), supersededPath]]),
+                changes: new Map([[path.join(hqRoot, supersededPath), { kind: "unlink" }]]),
             });
             clock.advance(0);
             await microtasks(30);
             watcher.emit(supersededPath, {
-                paths: new Map([[`/tmp/hq/${supersededPath}`, supersededPath]]),
+                paths: new Map([[path.join(hqRoot, supersededPath), supersededPath]]),
+                changes: new Map([[path.join(hqRoot, supersededPath), { kind: "unlink" }]]),
             });
             clock.advance(0);
             await microtasks(30);
@@ -13967,7 +14154,9 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
             // overlapping batch is reconciled. It has no accepted delete result,
             // so it must not publish an event.
             expect(supersededPushes).toHaveLength(1);
-            expect(publishBatch).not.toHaveBeenCalled();
+            const publishedPaths = publishBatch.mock.calls.flatMap(([batch]) => [...batch.paths.values()]);
+            expect(publishedPaths).toContain(heldPath);
+            expect(publishedPaths).not.toContain(supersededPath);
             let loopExited = false;
             void loop.then(() => { loopExited = true; });
             await microtasks();
@@ -13982,6 +14171,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
                 delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
             else
                 process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+            fs.rmSync(hqRoot, { recursive: true, force: true });
         }
     });
     it("excludes refused descendants while publishing accepted unlinkDir deletes", async () => {
@@ -14029,7 +14219,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
             changes: new Map([[absolutePath, { kind: "unlinkDir" }]]),
         });
         tick();
-        await microtasks();
+        await microtasks(30);
         expect(publishBatch).toHaveBeenCalledTimes(1);
         expect([...publishBatch.mock.calls[0][0].paths.values()]).toEqual([
             "companies/indigo/archive/accepted.md",
@@ -14078,7 +14268,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
             changes: new Map([[absoluteDirectory, { kind: "unlinkDir" }]]),
         });
         tick();
-        await microtasks();
+        await microtasks(30);
         expect(publishBatch).toHaveBeenCalledTimes(1);
         expect([...publishBatch.mock.calls[0][0].paths.values()]).toEqual([
             "companies/indigo/archive/first.md",