@indigoai-us/hq-cloud 6.14.49 → 6.15.0

package/src/bin/sync-runner.test.ts

@@ -42,6 +42,7 @@ import {
 } from "../watcher.js";
 import {
   adaptivePollMs,
+  advanceMonotonicDeadline,
   journalEntriesForWatcherDelete,
   shouldQuarantineWatcherDeleteIntents,
 } from "./sync-runner-watch-loop.js";
@@ -4205,6 +4206,22 @@ describe("adaptivePollMs (whole-box CPU backoff)", () => {
   });
 });
 
+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
@@ -4220,8 +4237,14 @@ 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<() => number>()
+      .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"],
@@ -4229,6 +4252,7 @@ describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", (
         runPass: vi.fn().mockResolvedValue(0),
         sleep,
         sampleLoadAvg: () => 0,
+        monotonicNow,
         onShutdownSignal: (handler) => {
           triggerShutdown = handler;
           return () => {};
@@ -4236,13 +4260,19 @@ describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", (
       },
     );
     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<() => number>()
+      .mockReturnValueOnce(1_000)
+      .mockReturnValueOnce(1_075);
     let triggerShutdown = () => {};
     const loop = runRunnerWithLoop(
       ["--companies", "--watch", "--hq-root", "/tmp/hq"],
@@ -4250,6 +4280,7 @@ describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", (
         runPass: vi.fn().mockResolvedValue(0),
         sleep,
         sampleLoadAvg: () => 1_000, // far above any core count → clamps to ceil
+        monotonicNow,
         onShutdownSignal: (handler) => {
           triggerShutdown = handler;
           return () => {};
@@ -4257,14 +4288,20 @@ describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", (
       },
     );
     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<() => number>()
+      .mockReturnValueOnce(1_000)
+      .mockReturnValueOnce(1_123);
     let triggerShutdown = () => {};
     const loop = runRunnerWithLoop(
       ["--companies", "--watch", "--poll-remote-ms", "123456", "--hq-root", "/tmp/hq"],
@@ -4272,6 +4309,7 @@ describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", (
         runPass: vi.fn().mockResolvedValue(0),
         sleep,
         sampleLoadAvg,
+        monotonicNow,
         onShutdownSignal: (handler) => {
           triggerShutdown = handler;
           return () => {};
@@ -4279,7 +4317,9 @@ describe("runRunnerWithLoop — adaptive poll interval (no --poll-remote-ms)", (
       },
     );
     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;
@@ -4317,19 +4357,32 @@ describe("runRunnerWithLoop — event-push wiring", () => {
     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 sleepCalls: number[] = [];
 
     const loop = runRunnerWithLoop(
-      ["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"],
+      [
+        "--companies",
+        "--watch",
+        "--event-push",
+        "--poll-remote-ms",
+        "600000",
+        "--hq-root",
+        "/tmp/hq",
+      ],
       {
         runPass,
         clock,
         createWatcher: () => watcher,
-        sleep: () => new Promise<void>(() => {}),
+        monotonicNow: () => 0,
+        sleep: (ms) => {
+          sleepCalls.push(ms);
+          return new Promise<void>(() => {});
+        },
         onShutdownSignal: (handler) => {
           triggerShutdown = handler;
           return () => {};
@@ -4337,24 +4390,20 @@ describe("runRunnerWithLoop — event-push wiring", () => {
       },
     );
 
-    // Drain the initial poll pass.
-    await Promise.resolve();
-    await Promise.resolve();
-    runPass.mockClear();
+    await flushLoopMicrotasks();
+    expect(sleepCalls).toEqual([600_000]);
 
-    // Fire a change for an indigo file; advance the (zero) driver window.
+    // 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 = () => {};
@@ -4380,10 +4429,9 @@ describe("runRunnerWithLoop — event-push wiring", () => {
 
     watcher.emit(); // no path — TreeWatcher's bare signal shape
     clock.advance(0);
-    await Promise.resolve();
-    await Promise.resolve();
+    await flushLoopMicrotasks();
 
-    expect(runPass).not.toHaveBeenCalled();
+    expect(runPass).toHaveBeenCalledTimes(1);
 
     triggerShutdown();
     await loop;
@@ -4453,7 +4501,61 @@ describe("runRunnerWithLoop — event-push wiring", () => {
     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: () => void = () => {};
+    const firstPassGate = new Promise<void>((resolve) => {
+      releaseFirstPass = resolve;
+    });
+    const spans: Array<{ enteredAt: bigint; exitedAt: bigint }> = [];
+    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<void>(() => {}),
+        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 = () => {};
@@ -4551,8 +4653,7 @@ describe("runRunnerWithLoop — event-push wiring", () => {
 
     // 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();
@@ -4876,7 +4977,7 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
     };
   }
 
-  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();
@@ -4886,10 +4987,6 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
 
     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([
       [
@@ -4942,6 +5039,28 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
     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);
@@ -6215,7 +6334,7 @@ function makeBatchWatcherStub(): BatchWatcherStub {
 }
 
 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: {
@@ -6271,7 +6390,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,
@@ -6280,22 +6399,22 @@ 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();
@@ -6319,9 +6438,18 @@ 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: (outcome: number) => void = () => {};
+    const targetedPush = new Promise<number>((resolve) => {
+      finishTargetedPush = resolve;
+    });
+    const runPass = vi
+      .fn()
+      .mockResolvedValueOnce(0)
+      .mockImplementation((passArgv: string[]) =>
+        passArgv.includes("--company") ? targetedPush : Promise.resolve(0),
+      );
+    const { loop, watcher, clock, shutdown } = runLoop({
+      claims: EMAIL_CLAIMS,
       startEventSync,
       runPass,
     });
@@ -6334,14 +6462,21 @@ 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",
@@ -6365,7 +6500,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,
     });
@@ -6402,7 +6537,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,
       });
@@ -6459,7 +6594,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,
     });
@@ -6502,7 +6637,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,
     });
@@ -6533,7 +6668,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,
     });
@@ -6646,7 +6781,7 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
           triggerShutdown = handler;
           return () => {};
         },
-        getIdTokenClaims: () => ENROLLED_CLAIMS as never,
+        getIdTokenClaims: () => EMAIL_CLAIMS as never,
         getAccessToken: async () => "jwt-test",
         startEventSync,
       },
@@ -6757,7 +6892,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();
@@ -6787,7 +6922,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();
@@ -6802,7 +6937,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();

package/src/bin/sync-runner.ts

@@ -2010,21 +2010,14 @@ const isDirectInvocation = (() => {
   }
 })();
 
-/**
- * Auto-sync (Beta) watch loop. Re-runs the one-shot runner every
- * `pollRemoteMs` until the process is killed (SIGTERM from the menubar's
- * stop_daemon command) or until a pass returns a non-zero exit code (hard
- * error worth surfacing to the operator). `setup-needed` and `auth-error`
- * exit 0 today and so will retry — acceptable noise for the beta; deal with
- * it via a richer return shape if it shows up in Sentry.
- */
 /**
  * Test/event-driven seam (US-001).
  *
- * `runRunnerWithLoop` performs an unbounded poll loop in production. To make
- * the loop deterministically testable (US-003 wires the event-driven watcher
- * into this same loop), the inter-pass sleep is injectable via `deps.sleep`.
- * The default uses the host timer and preserves exact production behavior.
+ * `runRunnerWithLoop` performs an unbounded, monotonic-cadence loop in
+ * production. The initial pass is immediate; subsequent deadlines advance
+ * from their prior deadline rather than pass completion. Watcher and receiver
+ * signals interrupt the wait but still use the same guarded pass queue. To
+ * test it deterministically, both waiting and monotonic time are injectable.
  *
  * A test (or US-003's wiring) injects a fake sleep that resolves immediately
  * and/or coordinates with the {@link WatchPushDriver} seam in `../watcher.js`,
@@ -2033,6 +2026,12 @@ const isDirectInvocation = (() => {
 export interface RunnerLoopDeps {
   /** Sleep `ms` between passes. Default: host setTimeout. */
   sleep?: (ms: number) => Promise<void>;
+  /**
+   * Monotonic milliseconds source for cadence deadlines. Defaults to
+   * `performance.now()`; tests inject it to prove missed-deadline behavior
+   * without depending on wall-clock time.
+   */
+  monotonicNow?: () => number;
   /**
    * 1-minute whole-box load average source for the adaptive remote-poll
    * backoff (used only when `--poll-remote-ms` is omitted). Defaults to