@indigoai-us/hq-cloud 6.15.42 → 6.15.44

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

@@ -149,6 +149,7 @@ function makeDeps(overrides = {}) {
         // and adds ambient diagnostic events to otherwise-hermetic assertions.
         getIdTokenClaims: vi.fn().mockReturnValue(null),
         createVaultClient: vi.fn().mockImplementation(() => makeVaultStub()),
+        fetchFileTombstones: vi.fn().mockResolvedValue(new Map()),
         sync: vi.fn().mockResolvedValue(defaultSyncResult()),
         reindex: vi.fn(() => ({ status: 0 })),
         qmdReindex: vi.fn(() => ({
@@ -1172,7 +1173,9 @@ describe("fanout-plan", () => {
             }),
         });
         expect(await runRunner(["--companies"], deps)).toBe(0);
-        expect(order).toEqual(["company", "personal", "reconcile"]);
+        expect(order).toHaveLength(3);
+        expect(order.slice(0, 2).sort()).toEqual(["company", "personal"]);
+        expect(order[2]).toBe("reconcile");
     });
     it("includes entity.name on plan entries when available", async () => {
         const deps = makeDeps({
@@ -1323,7 +1326,10 @@ describe("automatic journal maintenance", () => {
             `repair:${PERSONAL_VAULT_JOURNAL_SLUG}`,
             "repair:personal",
         ]);
-        expect(order[3]).toBe("sync:indigo");
+        expect(order.slice(3).sort()).toEqual([
+            `sync:${PERSONAL_VAULT_JOURNAL_SLUG}`,
+            "sync:indigo",
+        ]);
         expect(deps.stdout.events().filter((event) => event.type === "maintenance-progress")).toEqual([
             {
                 type: "maintenance-progress",
@@ -1504,6 +1510,27 @@ describe("per-company fanout", () => {
         expect(all).toBeDefined();
         expect(all?.partial).toBe(true);
     });
+    it("fails the affected pass loudly when deletion authority cannot be fetched", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({
+                memberships: [{ companyUid: "cmp_a" }],
+                entityGet: (uid) => Promise.resolve({ uid, slug: "acme" }),
+            }),
+            fetchFileTombstones: vi
+                .fn()
+                .mockRejectedValue(new Error("FILE_TOMBSTONE fetch failed after retries; refusing to sync without delete suppression")),
+        });
+        expect(await runRunner(["--companies", "--direction", "both"], deps)).toBe(PARTIAL_SYNC_EXIT);
+        expect(deps.stderr.events()).toContainEqual(expect.objectContaining({
+            type: "error",
+            company: "acme",
+            path: "(company)",
+            message: expect.stringContaining("refusing to sync without delete suppression"),
+        }));
+        const complete = deps.stdout.events().find((event) => event.type === "all-complete");
+        expect(complete).toMatchObject({ partial: true });
+        expect(complete?.companies).toContainEqual(expect.objectContaining({ company: "acme", status: "errored" }));
+    });
     it("emits complete event per company with the SyncResult spread", async () => {
         const result = defaultSyncResult({
             filesDownloaded: 3,
@@ -3944,6 +3971,73 @@ describe("runRunnerWithLoop — event-push wiring", () => {
             stderrWrite.mockRestore();
         }
     });
+    it("emits a WARN with the reason code when the watcher stands down", async () => {
+        const watcher = makeWatcherStub();
+        const stderrWrite = vi
+            .spyOn(process.stderr, "write")
+            .mockImplementation(() => true);
+        let triggerShutdown = () => { };
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass: vi.fn().mockResolvedValue(completedPassOutcome()),
+            createWatcher: (options) => {
+                watcher.start = () => {
+                    watcher.started = true;
+                    options.onDegraded?.({
+                        reason: "inotify_enospc",
+                        watchedPaths: 17349,
+                        maxWatchedPaths: 500000,
+                        action: "stopped",
+                    });
+                };
+                return watcher;
+            },
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks();
+            expect(stderrWrite.mock.calls.map(([chunk]) => String(chunk)).join("")).toContain("event-push watcher degraded; stopped; continuing cadence-only: inotify_enospc (watched-paths=17349/500000)");
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            stderrWrite.mockRestore();
+        }
+    });
+    it("reports current watcher liveness after startup", async () => {
+        vi.useFakeTimers();
+        const watcher = makeWatcherStub();
+        watcher.isWatching = () => true;
+        watcher.watchedPathCount = () => 17349;
+        watcher.watchMode = () => "chokidar";
+        const stderrWrite = vi
+            .spyOn(process.stderr, "write")
+            .mockImplementation(() => true);
+        let triggerShutdown = () => { };
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass: vi.fn().mockResolvedValue(completedPassOutcome()),
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks();
+            await vi.advanceTimersByTimeAsync(30_000);
+            expect(stderrWrite.mock.calls.map(([chunk]) => String(chunk)).join("")).toContain("event-push watcher liveness (state=active, mode=chokidar, watched-paths=17349)");
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            stderrWrite.mockRestore();
+            vi.useRealTimers();
+        }
+    });
     it("warns once and continues poll-only when watcher startup fails", async () => {
         const stderrWrite = vi
             .spyOn(process.stderr, "write")