@indigoai-us/hq-cloud 6.14.49 → 6.15.0

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

@@ -13,7 +13,7 @@ import * as path from "path";
 import { runRunner, runRunnerWithLoop, resolveDeletePolicy, resolveSkipPersonal, resolveSkipCompanies, selectObjectIOFactory, routeChangeToTarget, buildTargetedPushArgv, resolvePullScope, readPinnedPrefixes, SESSIONS_SCOPE_PREFIX, defaultCollectTelemetry, AUTH_REQUIRED_PASS_EXIT, } from "./sync-runner.js";
 import { PresignObjectIO, S3SdkObjectIO } from "../object-io.js";
 import { FakeClock, } from "../watcher.js";
-import { adaptivePollMs, journalEntriesForWatcherDelete, shouldQuarantineWatcherDeleteIntents, } from "./sync-runner-watch-loop.js";
+import { adaptivePollMs, advanceMonotonicDeadline, journalEntriesForWatcherDelete, shouldQuarantineWatcherDeleteIntents, } 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";
@@ -3383,6 +3383,21 @@ describe("adaptivePollMs (whole-box CPU backoff)", () => {
         expect(adaptivePollMs(4, 4, 30_000, 300_000)).toBe(300_000);
     });
 });
+describe("advanceMonotonicDeadline", () => {
+    it("runs one immediate catch-up after missed slots, then resumes at the first future slot", () => {
+        // A pass due at t=0 took through t=1,800 with a 600 ms cadence. It does
+        // not replay the three missed slots; exactly one catch-up is immediate and
+        // the following regular deadline is t=2,400.
+        expect(advanceMonotonicDeadline(0, 1_800, 600)).toEqual({
+            nextDueAt: 2_400,
+            delayMs: 0,
+        });
+        expect(advanceMonotonicDeadline(2_400, 1_800, 600)).toEqual({
+            nextDueAt: 3_000,
+            delayMs: 1_200,
+        });
+    });
+});
 describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", () => {
     // Capture the ms handed to sleep on the FIRST poll, then hang so the loop
     // parks until shutdown (mirrors the never-resolving sleep the other loop
@@ -3397,55 +3412,78 @@ describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", (
             },
         };
     }
-    it("sleeps the floor interval when the box is idle", async () => {
+    it("waits only the bounded remainder of the idle cadence slot", async () => {
         const { calls, sleep } = makeCapturingSleep();
+        const monotonicNow = vi
+            .fn()
+            .mockReturnValueOnce(1_000)
+            // A 20 ms pass consumes part of this 60 s slot. The scheduler must
+            // retain the original deadline rather than slewing a new 60 s wait.
+            .mockReturnValueOnce(1_020);
         let triggerShutdown = () => { };
         const loop = runRunnerWithLoop(["--companies", "--watch", "--hq-root", "/tmp/hq"], {
             runPass: vi.fn().mockResolvedValue(0),
             sleep,
             sampleLoadAvg: () => 0,
+            monotonicNow,
             onShutdownSignal: (handler) => {
                 triggerShutdown = handler;
                 return () => { };
             },
         });
         await flushLoopMicrotasks();
-        expect(calls[0]).toBe(60_000);
+        expect(calls[0]).toBe(59_980);
+        expect(calls[0]).toBeGreaterThan(0);
+        expect(calls[0]).toBeLessThanOrEqual(60_000);
         triggerShutdown();
         await loop;
     });
-    it("backs off to the ceiling interval when the box is fully loaded", async () => {
+    it("waits only the bounded remainder of the saturated cadence slot", async () => {
         const { calls, sleep } = makeCapturingSleep();
+        const monotonicNow = vi
+            .fn()
+            .mockReturnValueOnce(1_000)
+            .mockReturnValueOnce(1_075);
         let triggerShutdown = () => { };
         const loop = runRunnerWithLoop(["--companies", "--watch", "--hq-root", "/tmp/hq"], {
             runPass: vi.fn().mockResolvedValue(0),
             sleep,
             sampleLoadAvg: () => 1_000, // far above any core count → clamps to ceil
+            monotonicNow,
             onShutdownSignal: (handler) => {
                 triggerShutdown = handler;
                 return () => { };
             },
         });
         await flushLoopMicrotasks();
-        expect(calls[0]).toBe(600_000);
+        expect(calls[0]).toBe(599_925);
+        expect(calls[0]).toBeGreaterThan(0);
+        expect(calls[0]).toBeLessThanOrEqual(600_000);
         triggerShutdown();
         await loop;
     });
-    it("an explicit --poll-remote-ms pins a fixed interval and ignores load", async () => {
+    it("uses the bounded remainder of an explicit cadence slot and ignores load", async () => {
         const { calls, sleep } = makeCapturingSleep();
         const sampleLoadAvg = vi.fn(() => 1_000);
+        const monotonicNow = vi
+            .fn()
+            .mockReturnValueOnce(1_000)
+            .mockReturnValueOnce(1_123);
         let triggerShutdown = () => { };
         const loop = runRunnerWithLoop(["--companies", "--watch", "--poll-remote-ms", "123456", "--hq-root", "/tmp/hq"], {
             runPass: vi.fn().mockResolvedValue(0),
             sleep,
             sampleLoadAvg,
+            monotonicNow,
             onShutdownSignal: (handler) => {
                 triggerShutdown = handler;
                 return () => { };
             },
         });
         await flushLoopMicrotasks();
-        expect(calls[0]).toBe(123456);
+        expect(calls[0]).toBe(123_333);
+        expect(calls[0]).toBeGreaterThan(0);
+        expect(calls[0]).toBeLessThanOrEqual(123_456);
         expect(sampleLoadAvg).not.toHaveBeenCalled();
         triggerShutdown();
         await loop;
@@ -3476,35 +3514,45 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         expect(runPass).toHaveBeenCalled();
         expect(watcher.disposed).toBe(true);
     });
-    it("trigger-on-change: a changed signal accumulates without an immediate push", async () => {
+    it("U07: watcher interrupts a fake 600 s wait and drains through the guarded scheduler", async () => {
         const watcher = makeWatcherStub();
         const clock = new FakeClock();
         let triggerShutdown = () => { };
         const runPass = vi.fn().mockResolvedValue(0);
-        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+        const sleepCalls = [];
+        const loop = runRunnerWithLoop([
+            "--companies",
+            "--watch",
+            "--event-push",
+            "--poll-remote-ms",
+            "600000",
+            "--hq-root",
+            "/tmp/hq",
+        ], {
             runPass,
             clock,
             createWatcher: () => watcher,
-            sleep: () => new Promise(() => { }),
+            monotonicNow: () => 0,
+            sleep: (ms) => {
+                sleepCalls.push(ms);
+                return new Promise(() => { });
+            },
             onShutdownSignal: (handler) => {
                 triggerShutdown = handler;
                 return () => { };
             },
         });
-        // Drain the initial poll pass.
-        await Promise.resolve();
-        await Promise.resolve();
-        runPass.mockClear();
-        // Fire a change for an indigo file; advance the (zero) driver window.
+        await flushLoopMicrotasks();
+        expect(sleepCalls).toEqual([600_000]);
+        // The fake 600-second timer remains unresolved. The watcher wake must
+        // nonetheless start the next pass immediately through runGuarded.
         watcher.emit("companies/indigo/board.json");
-        clock.advance(0);
-        await Promise.resolve();
-        await Promise.resolve();
-        expect(runPass).not.toHaveBeenCalled();
+        await flushLoopMicrotasks();
+        expect(runPass).toHaveBeenCalledTimes(2);
         triggerShutdown();
         await loop;
     });
-    it("bare signal (no path) accumulates without an immediate push", async () => {
+    it("bare watcher signal interrupts the wait and schedules a full reconcile", async () => {
         const watcher = makeWatcherStub();
         const clock = new FakeClock();
         let triggerShutdown = () => { };
@@ -3524,9 +3572,8 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         runPass.mockClear();
         watcher.emit(); // no path — TreeWatcher's bare signal shape
         clock.advance(0);
-        await Promise.resolve();
-        await Promise.resolve();
-        expect(runPass).not.toHaveBeenCalled();
+        await flushLoopMicrotasks();
+        expect(runPass).toHaveBeenCalledTimes(1);
         triggerShutdown();
         await loop;
     });
@@ -3584,7 +3631,54 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         triggerShutdown();
         await loop;
     });
-    it("F05: guard-held watcher changes stay accumulated until a poll drain", async () => {
+    it("U07: retains a watcher event raised before the next wait registers, without guarded overlap", async () => {
+        const watcher = makeWatcherStub();
+        let triggerShutdown = () => { };
+        let releaseFirstPass = () => { };
+        const firstPassGate = new Promise((resolve) => {
+            releaseFirstPass = resolve;
+        });
+        const spans = [];
+        let passes = 0;
+        const runPass = vi.fn().mockImplementation(async () => {
+            const span = { enteredAt: process.hrtime.bigint(), exitedAt: 0n };
+            spans.push(span);
+            passes += 1;
+            if (passes === 1)
+                await firstPassGate;
+            span.exitedAt = process.hrtime.bigint();
+            return 0;
+        });
+        const loop = runRunnerWithLoop([
+            "--companies",
+            "--watch",
+            "--event-push",
+            "--poll-remote-ms",
+            "600000",
+            "--hq-root",
+            "/tmp/hq",
+        ], {
+            runPass,
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        await flushLoopMicrotasks();
+        expect(spans).toHaveLength(1);
+        // This event arrives while the initial guarded pass owns the scheduler,
+        // before its next sleep/wait has been registered.
+        watcher.emit("companies/indigo/pre-registration.md");
+        releaseFirstPass();
+        await flushLoopMicrotasks();
+        expect(spans).toHaveLength(2);
+        expect(spans[1].enteredAt >= spans[0].exitedAt).toBe(true);
+        triggerShutdown();
+        await loop;
+    });
+    it("F05: guard-held watcher changes stay accumulated, then drain immediately after the guarded pass", async () => {
         const watcher = makeWatcherStub();
         const clock = new FakeClock();
         let triggerShutdown = () => { };
@@ -3665,8 +3759,7 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         expect(passes).toBe(1);
         // Step the poll interval → a second poll pass runs (safety net cadence).
         poll.resolve?.();
-        await Promise.resolve();
-        await Promise.resolve();
+        await flushLoopMicrotasks();
         expect(passes).toBeGreaterThanOrEqual(2);
         triggerShutdown();
         // Release any pending sleep so the loop can observe shutdown and exit.
@@ -3930,7 +4023,7 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
             shutdown: () => triggerShutdown(),
         };
     }
-    it("startup runs one full reconcile, then watcher edits wait for the poll drain", async () => {
+    it("startup runs one full reconcile, then watcher edits interrupt the pending wait", async () => {
         const runPass = vi.fn().mockResolvedValue(0);
         const { loop, watcher, tick, shutdown } = startDrainLoop(runPass);
         await flushLoopMicrotasks();
@@ -3938,9 +4031,6 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
         runPass.mockClear();
         watcher.emit("companies/indigo/knowledge/a.md");
         await flushLoopMicrotasks();
-        expect(runPass).not.toHaveBeenCalled();
-        tick();
-        await flushLoopMicrotasks();
         expect(runPass.mock.calls.map((call) => call[0])).toEqual([
             [
                 "--company",
@@ -3986,6 +4076,24 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
         tick();
         await loop;
     });
+    it("U08: --companies --skip-personal drops a personal watcher edit before it queues work", async () => {
+        const runPass = vi.fn().mockResolvedValue(0);
+        const { loop, watcher, tick, shutdown } = startDrainLoopWithArgv(runPass, [
+            ...watchArgv,
+            "--skip-personal",
+        ]);
+        await flushLoopMicrotasks();
+        runPass.mockClear();
+        watcher.emit("knowledge/private.md");
+        await flushLoopMicrotasks();
+        // The watcher event is rejected before the scheduler is interrupted:
+        // no route-specific pass is queued and therefore no runner/network work
+        // is reachable for a disabled personal scope.
+        expect(runPass).not.toHaveBeenCalled();
+        shutdown();
+        tick();
+        await loop;
+    });
     it("drains an unlink path through the same scoped tombstone push path", async () => {
         const runPass = vi.fn().mockResolvedValue(0);
         const { loop, watcher, tick, shutdown } = startDrainLoop(runPass);
@@ -4989,7 +5097,7 @@ function makeBatchWatcherStub() {
     };
 }
 describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", () => {
-    const ENROLLED_CLAIMS = { email: "hassaan@getindigo.ai" };
+    const EMAIL_CLAIMS = { email: "hassaan@getindigo.ai" };
     const UNENROLLED_CLAIMS = { email: "someone@getindigo.ai" };
     function runLoop(opts) {
         const watcher = opts.watcher ?? makeBatchWatcherStub();
@@ -5036,7 +5144,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
         for (let i = 0; i < n; i++)
             await Promise.resolve();
     }
-    it("gate OFF (unenrolled email): the event-sync seam is never consulted", async () => {
+    it("does not use an unenrolled email as a client-side denial", async () => {
         const startEventSync = vi.fn().mockResolvedValue(null);
         const { loop, shutdown } = runLoop({
             claims: UNENROLLED_CLAIMS,
@@ -5045,20 +5153,20 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
         await microtasks();
         shutdown();
         await loop;
-        expect(startEventSync).not.toHaveBeenCalled();
+        expect(startEventSync).toHaveBeenCalledTimes(1);
     });
-    it("gate OFF (no cached claims): the event-sync seam is never consulted", async () => {
+    it("does not use missing cached claims as a client-side denial", async () => {
         const startEventSync = vi.fn().mockResolvedValue(null);
         const { loop, shutdown } = runLoop({ claims: null, startEventSync });
         await microtasks();
         shutdown();
         await loop;
-        expect(startEventSync).not.toHaveBeenCalled();
+        expect(startEventSync).toHaveBeenCalledTimes(1);
     });
-    it("gate ON (enrolled email): wiring receives root, api url, auth + a sync bridge", async () => {
+    it("asks the server for authority before wiring publish and receive", async () => {
         const startEventSync = vi.fn().mockResolvedValue(null);
         const { loop, shutdown } = runLoop({
-            claims: ENROLLED_CLAIMS,
+            claims: EMAIL_CLAIMS,
             startEventSync,
         });
         await microtasks();
@@ -5081,9 +5189,16 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
             ownDeviceId: "dev-test",
             dispose: vi.fn().mockResolvedValue(undefined),
         });
-        const runPass = vi.fn().mockResolvedValue(0);
-        const { loop, watcher, clock, tick, shutdown } = runLoop({
-            claims: ENROLLED_CLAIMS,
+        let finishTargetedPush = () => { };
+        const targetedPush = new Promise((resolve) => {
+            finishTargetedPush = resolve;
+        });
+        const runPass = vi
+            .fn()
+            .mockResolvedValueOnce(0)
+            .mockImplementation((passArgv) => passArgv.includes("--company") ? targetedPush : Promise.resolve(0));
+        const { loop, watcher, clock, shutdown } = runLoop({
+            claims: EMAIL_CLAIMS,
             startEventSync,
             runPass,
         });
@@ -5095,12 +5210,18 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
         watcher.emit("companies/indigo/a.md", batch);
         clock.advance(0);
         await microtasks();
-        expect(runPass).not.toHaveBeenCalled();
+        // U07 wakes the scheduler immediately. It may start the scoped push, but
+        // it must not announce the batch until that push has succeeded.
+        expect(runPass).toHaveBeenCalledWith(expect.arrayContaining([
+            "--company",
+            "indigo",
+            "--direction",
+            "push",
+        ]));
         expect(publishBatch).not.toHaveBeenCalled();
-        tick();
+        finishTargetedPush(0);
         await microtasks();
         // Scoped push drained and succeeded → batch published.
-        expect(runPass).toHaveBeenCalled();
         expect(publishBatch).toHaveBeenCalledTimes(1);
         expect([...publishBatch.mock.calls[0][0].paths.values()]).toEqual([
             "companies/indigo/a.md",
@@ -5122,7 +5243,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
             .mockResolvedValueOnce(0)
             .mockResolvedValue(1);
         const { loop, watcher, clock, tick, shutdown } = runLoop({
-            claims: ENROLLED_CLAIMS,
+            claims: EMAIL_CLAIMS,
             startEventSync,
             runPass,
         });
@@ -5153,7 +5274,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
             });
             const runPass = vi.fn().mockResolvedValue(0);
             const { loop, watcher, clock, tick, shutdown } = runLoop({
-                claims: ENROLLED_CLAIMS,
+                claims: EMAIL_CLAIMS,
                 startEventSync,
                 runPass,
             });
@@ -5205,7 +5326,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
         })
             .mockResolvedValue(0);
         const { loop, watcher, tick, shutdown } = runLoop({
-            claims: ENROLLED_CLAIMS,
+            claims: EMAIL_CLAIMS,
             startEventSync,
             runPass,
         });
@@ -5246,7 +5367,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
         })
             .mockResolvedValue(0);
         const { loop, watcher, tick, shutdown } = runLoop({
-            claims: ENROLLED_CLAIMS,
+            claims: EMAIL_CLAIMS,
             startEventSync,
             runPass,
         });
@@ -5275,7 +5396,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
         });
         const runPass = vi.fn().mockResolvedValue(0);
         const { loop, watcher, clock, tick, shutdown } = runLoop({
-            claims: ENROLLED_CLAIMS,
+            claims: EMAIL_CLAIMS,
             startEventSync,
             runPass,
         });
@@ -5382,7 +5503,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
                 triggerShutdown = handler;
                 return () => { };
             },
-            getIdTokenClaims: () => ENROLLED_CLAIMS,
+            getIdTokenClaims: () => EMAIL_CLAIMS,
             getAccessToken: async () => "jwt-test",
             startEventSync,
         });
@@ -5482,7 +5603,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
             dispose: vi.fn().mockResolvedValue(undefined),
         });
         const { loop, watcher, clock, tick, shutdown } = runLoop({
-            claims: ENROLLED_CLAIMS,
+            claims: EMAIL_CLAIMS,
             startEventSync,
         });
         await microtasks();
@@ -5506,7 +5627,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
             dispose,
         });
         const { loop, shutdown } = runLoop({
-            claims: ENROLLED_CLAIMS,
+            claims: EMAIL_CLAIMS,
             startEventSync,
         });
         await microtasks();
@@ -5520,7 +5641,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
         try {
             const startEventSync = vi.fn().mockResolvedValue(null);
             const { loop, shutdown } = runLoop({
-                claims: ENROLLED_CLAIMS,
+                claims: EMAIL_CLAIMS,
                 startEventSync,
             });
             await microtasks();