@indigoai-us/hq-cloud 6.15.53 → 6.15.55

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

@@ -5078,6 +5078,27 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
     function startDrainLoop(runPass) {
         return startDrainLoopWithArgv(runPass, watchArgv);
     }
+    function startBatchDrainLoop(runPass) {
+        const watcher = makeBatchWatcherStub();
+        const sleep = makeSteppableSleep();
+        let triggerShutdown = () => { };
+        const loop = runRunnerWithLoop(watchArgv, {
+            runPass,
+            clock: new FakeClock(),
+            createWatcher: () => watcher,
+            sleep: sleep.sleep,
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        return {
+            loop,
+            watcher,
+            tick: sleep.tick,
+            shutdown: () => triggerShutdown(),
+        };
+    }
     function startDrainLoopWithArgv(runPass, argv) {
         const watcher = makeWatcherStub();
         const sleep = makeSteppableSleep();
@@ -5099,6 +5120,293 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
             shutdown: () => triggerShutdown(),
         };
     }
+    function captureFullReconcileDecisions() {
+        const records = [];
+        const spy = vi
+            .spyOn(process.stderr, "write")
+            .mockImplementation((chunk) => {
+            if (typeof chunk === "string" && chunk.startsWith("{")) {
+                const parsed = JSON.parse(String(chunk));
+                if (typeof parsed === "object" &&
+                    parsed !== null &&
+                    parsed.type === "full-reconcile-decision") {
+                    records.push(parsed);
+                }
+            }
+            return true;
+        });
+        return {
+            records,
+            clear: () => records.splice(0),
+            restore: () => spy.mockRestore(),
+        };
+    }
+    const allTriggerFlags = (matched = []) => ({
+        "event-push-surfaces-inactive": matched.includes("event-push-surfaces-inactive"),
+        "first-tick": matched.includes("first-tick"),
+        "bare-wake": matched.includes("bare-wake"),
+        "batch-over-limit": matched.includes("batch-over-limit"),
+        "overflow-routes-unknown": matched.includes("overflow-routes-unknown"),
+        "scheduled-interval": matched.includes("scheduled-interval"),
+    });
+    function expectFullReconcileDecision(record, mode, reasons) {
+        expect(record).toMatchObject({
+            type: "full-reconcile-decision",
+            mode,
+            reasons,
+            triggers: allTriggerFlags(reasons),
+        });
+    }
+    it("logs first-tick as the sole full-reconcile trigger when event push is off", async () => {
+        const capture = captureFullReconcileDecisions();
+        const runPass = vi.fn().mockResolvedValue(completedPassOutcome());
+        const sleep = makeSteppableSleep();
+        let shutdown = () => { };
+        const loop = runRunnerWithLoop([
+            "--companies", "--watch", "--direction", "both", "--hq-root", "/tmp/hq",
+            "--poll-remote-ms", "60000",
+        ], {
+            runPass,
+            sleep: sleep.sleep,
+            onShutdownSignal: (handler) => {
+                shutdown = handler;
+                return () => { };
+            },
+        });
+        await flushLoopMicrotasks();
+        expectFullReconcileDecision(capture.records[0], "full", ["first-tick"]);
+        expect(runPass.mock.calls.map((call) => call[0])).toEqual([fullArgv]);
+        shutdown();
+        sleep.tick();
+        await loop;
+        capture.restore();
+    });
+    it("logs event-push-surfaces-inactive without silently attributing the first tick", async () => {
+        const saved = process.env.HQ_SYNC_FULL_RECONCILE_MS;
+        process.env.HQ_SYNC_FULL_RECONCILE_MS = "10800000";
+        const capture = captureFullReconcileDecisions();
+        try {
+            const sleep = makeSteppableSleep();
+            let shutdown = () => { };
+            const runPass = vi.fn().mockResolvedValue(PARTIAL_SYNC_EXIT);
+            const loop = runRunnerWithLoop(watchArgv, {
+                runPass,
+                monotonicNow: () => 0,
+                sleep: sleep.sleep,
+                onShutdownSignal: (handler) => {
+                    shutdown = handler;
+                    return () => { };
+                },
+            });
+            await flushLoopMicrotasks();
+            capture.clear();
+            runPass.mockClear();
+            sleep.tick();
+            await flushLoopMicrotasks();
+            expectFullReconcileDecision(capture.records[0], "full", [
+                "event-push-surfaces-inactive",
+            ]);
+            expect(runPass.mock.calls.map((call) => call[0])).toEqual([fullArgv]);
+            shutdown();
+            await loop;
+        }
+        finally {
+            capture.restore();
+            if (saved === undefined)
+                delete process.env.HQ_SYNC_FULL_RECONCILE_MS;
+            else
+                process.env.HQ_SYNC_FULL_RECONCILE_MS = saved;
+        }
+    });
+    it("reports every matching trigger instead of short-circuiting at the first", async () => {
+        const capture = captureFullReconcileDecisions();
+        const runPass = vi.fn().mockResolvedValue(completedPassOutcome());
+        const { loop, shutdown } = startDrainLoop(runPass);
+        await flushLoopMicrotasks();
+        expectFullReconcileDecision(capture.records[0], "full", [
+            "event-push-surfaces-inactive",
+            "first-tick",
+        ]);
+        expect(runPass.mock.calls.map((call) => call[0])).toEqual([fullArgv]);
+        shutdown();
+        await loop;
+        capture.restore();
+    });
+    it("logs a bare watcher wake as the sole full-reconcile trigger", async () => {
+        const capture = captureFullReconcileDecisions();
+        const runPass = vi.fn().mockResolvedValue(completedPassOutcome());
+        const { loop, watcher, shutdown } = startDrainLoop(runPass);
+        await flushLoopMicrotasks();
+        capture.clear();
+        runPass.mockClear();
+        watcher.emit();
+        await flushLoopMicrotasks();
+        expectFullReconcileDecision(capture.records[0], "full", ["bare-wake"]);
+        expect(runPass.mock.calls.map((call) => call[0])).toEqual([fullArgv]);
+        shutdown();
+        await loop;
+        capture.restore();
+    });
+    it("logs batch-over-limit as the sole full-reconcile trigger", async () => {
+        const saved = process.env.HQ_SYNC_EVENT_BATCH_LIMIT;
+        process.env.HQ_SYNC_EVENT_BATCH_LIMIT = "2";
+        const capture = captureFullReconcileDecisions();
+        try {
+            const runPass = vi.fn().mockResolvedValue(completedPassOutcome());
+            const { loop, watcher, tick, shutdown } = startBatchDrainLoop(runPass);
+            await flushLoopMicrotasks();
+            capture.clear();
+            runPass.mockClear();
+            watcher.emit("companies/indigo/a.md", {
+                paths: new Map([
+                    ["/tmp/hq/companies/indigo/a.md", "companies/indigo/a.md"],
+                    ["/tmp/hq/companies/indigo/b.md", "companies/indigo/b.md"],
+                    ["/tmp/hq/companies/indigo/c.md", "companies/indigo/c.md"],
+                ]),
+            });
+            tick();
+            await flushLoopMicrotasks();
+            expectFullReconcileDecision(capture.records[0], "full", ["batch-over-limit"]);
+            expect(capture.records[0]?.batchPathCount).toBe(3);
+            expect(runPass.mock.calls.map((call) => call[0])).toEqual([fullArgv]);
+            shutdown();
+            await loop;
+        }
+        finally {
+            capture.restore();
+            if (saved === undefined)
+                delete process.env.HQ_SYNC_EVENT_BATCH_LIMIT;
+            else
+                process.env.HQ_SYNC_EVENT_BATCH_LIMIT = saved;
+        }
+    });
+    it("logs overflow-routes-unknown as the sole full-reconcile trigger", async () => {
+        const capture = captureFullReconcileDecisions();
+        const runPass = vi.fn().mockResolvedValue(completedPassOutcome());
+        const { loop, watcher, tick, shutdown } = startBatchDrainLoop(runPass);
+        await flushLoopMicrotasks();
+        capture.clear();
+        runPass.mockClear();
+        watcher.emit("companies/indigo/a.md", {
+            paths: new Map([["/tmp/hq/companies/indigo/a.md", "companies/indigo/a.md"]]),
+            overflowed: true,
+        });
+        tick();
+        await flushLoopMicrotasks();
+        expectFullReconcileDecision(capture.records[0], "full", [
+            "overflow-routes-unknown",
+        ]);
+        expect(runPass.mock.calls.map((call) => call[0])).toEqual([fullArgv]);
+        shutdown();
+        await loop;
+        capture.restore();
+    });
+    it("logs scheduled-interval as the sole full-reconcile trigger on the legacy cadence", async () => {
+        const saved = process.env.HQ_SYNC_FULL_RECONCILE_MS;
+        delete process.env.HQ_SYNC_FULL_RECONCILE_MS;
+        const capture = captureFullReconcileDecisions();
+        try {
+            const sleep = makeSteppableSleep();
+            let shutdown = () => { };
+            const runPass = vi.fn().mockResolvedValue(completedPassOutcome());
+            const loop = runRunnerWithLoop([
+                "--companies", "--watch", "--direction", "both", "--hq-root", "/tmp/hq",
+                "--poll-remote-ms", "60000",
+            ], {
+                runPass,
+                sleep: sleep.sleep,
+                onShutdownSignal: (handler) => {
+                    shutdown = handler;
+                    return () => { };
+                },
+            });
+            await flushLoopMicrotasks();
+            capture.clear();
+            runPass.mockClear();
+            for (let tick = 0; tick < 8; tick++) {
+                sleep.tick();
+                await flushLoopMicrotasks();
+            }
+            capture.clear();
+            runPass.mockClear();
+            sleep.tick();
+            await flushLoopMicrotasks();
+            expectFullReconcileDecision(capture.records[0], "full", [
+                "scheduled-interval",
+            ]);
+            expect(runPass.mock.calls.map((call) => call[0])).toEqual([fullArgv]);
+            shutdown();
+            await loop;
+        }
+        finally {
+            capture.restore();
+            if (saved === undefined)
+                delete process.env.HQ_SYNC_FULL_RECONCILE_MS;
+            else
+                process.env.HQ_SYNC_FULL_RECONCILE_MS = saved;
+        }
+    });
+    it("logs scoped passes with their batch path count and preserves the scoped route", async () => {
+        const capture = captureFullReconcileDecisions();
+        const runPass = vi.fn().mockResolvedValue(completedPassOutcome());
+        const { loop, watcher, shutdown } = startDrainLoop(runPass);
+        await flushLoopMicrotasks();
+        capture.clear();
+        runPass.mockClear();
+        watcher.emit("companies/indigo/knowledge/a.md");
+        await flushLoopMicrotasks();
+        expectFullReconcileDecision(capture.records[0], "scoped", []);
+        expect(capture.records[0]?.batchPathCount).toBe(1);
+        expect(runPass.mock.calls.map((call) => call[0])).not.toContainEqual(fullArgv);
+        expect(runPass).toHaveBeenCalledTimes(2);
+        shutdown();
+        await loop;
+        capture.restore();
+    });
+    it("reports interval diagnostics while the configured interval has not elapsed", async () => {
+        const saved = process.env.HQ_SYNC_FULL_RECONCILE_MS;
+        process.env.HQ_SYNC_FULL_RECONCILE_MS = "1000";
+        const capture = captureFullReconcileDecisions();
+        try {
+            const clockState = { now: 0 };
+            const sleep = makeSteppableSleep();
+            let shutdown = () => { };
+            const runPass = vi.fn().mockResolvedValue(completedPassOutcome());
+            const loop = runRunnerWithLoop(watchArgv, {
+                runPass,
+                monotonicNow: () => clockState.now,
+                createWatcher: () => makeBatchWatcherStub(),
+                sleep: sleep.sleep,
+                onShutdownSignal: (handler) => {
+                    shutdown = handler;
+                    return () => { };
+                },
+            });
+            await flushLoopMicrotasks();
+            capture.clear();
+            runPass.mockClear();
+            clockState.now = 999;
+            sleep.tick();
+            await flushLoopMicrotasks();
+            expectFullReconcileDecision(capture.records[0], "scoped", []);
+            expect(capture.records[0]).toMatchObject({
+                pollTick: 2,
+                configuredIntervalMs: 1000,
+                elapsedSinceLastCompletedFullReconcileMs: 999,
+                triggers: allTriggerFlags(),
+            });
+            expect(runPass.mock.calls.map((call) => call[0])).toEqual([fullPullArgv]);
+            shutdown();
+            await loop;
+        }
+        finally {
+            capture.restore();
+            if (saved === undefined)
+                delete process.env.HQ_SYNC_FULL_RECONCILE_MS;
+            else
+                process.env.HQ_SYNC_FULL_RECONCILE_MS = saved;
+        }
+    });
     it("startup runs one full reconcile, then watcher edits interrupt the pending wait", async () => {
         const runPass = vi.fn().mockResolvedValue(completedPassOutcome());
         const { loop, watcher, tick, shutdown } = startDrainLoop(runPass);
@@ -5747,6 +6055,7 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
         }
     });
     it("a throwing targeted pass falls back to one full reconcile instead of dropping the change", async () => {
+        const capture = captureFullReconcileDecisions();
         const runPass = vi.fn(async (argv) => {
             if (argv.includes("pull") && argv.includes("--scope-path")) {
                 throw new Error("scoped pull exploded");
@@ -5755,6 +6064,7 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
         });
         const { loop, watcher, tick, shutdown } = startDrainLoop(runPass);
         await flushLoopMicrotasks();
+        capture.clear();
         runPass.mockClear();
         watcher.emit("companies/indigo/knowledge/a.md");
         tick();
@@ -5784,9 +6094,14 @@ describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
             // …and the loop degrades to the full reconcile, never dropping the tick.
             fullArgv,
         ]);
+        expect(capture.records).toHaveLength(1);
+        expectFullReconcileDecision(capture.records[0], "full", [
+            "targeted-pass-failed",
+        ]);
         shutdown();
         tick();
         await loop;
+        capture.restore();
     });
     it("wires the event debounce config (default 15s quiet / 120s max-wait) into the watcher factory", async () => {
         const captured = [];