@indigoai-us/hq-cloud 6.11.11 → 6.11.13

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

@@ -42,6 +42,7 @@ import type {
   PendingInviteByEmail,
 } from "../vault-client.js";
 import { VaultAuthError } from "../vault-client.js";
+import type { PushEvent } from "../sync/push-event.js";
 
 // ---------------------------------------------------------------------------
 // Hermetic journal state — the runner now calls migratePersonalVaultJournal()
@@ -1008,7 +1009,7 @@ describe("per-company fanout", () => {
     ]);
   });
 
-  it("tags per-file error events with the company slug", async () => {
+  it("F09: per-file transfer errors make the run partial and non-zero", async () => {
     const deps = makeDeps({
       createVaultClient: () =>
         makeVaultStub({
@@ -1027,7 +1028,7 @@ describe("per-company fanout", () => {
     });
 
     const code = await runRunner(["--companies"], deps);
-    expect(code).toBe(0);
+    expect(code).toBe(2);
     // Per-file errors are routed to stderr (error-class events).
     const errs = deps.stderr
       .events()
@@ -1042,6 +1043,14 @@ describe("per-company fanout", () => {
         message: "access denied",
       },
     ]);
+    const all = deps.stdout
+      .events()
+      .find(
+        (e): e is Extract<RunnerEvent, { type: "all-complete" }> =>
+          e.type === "all-complete",
+      );
+    expect(all).toBeDefined();
+    expect(all?.partial).toBe(true);
   });
 
   it("emits complete event per company with the SyncResult spread", async () => {
@@ -3056,6 +3065,73 @@ describe("runRunnerWithLoop — event-push wiring", () => {
     await loop;
   });
 
+  it("F05: guard-held watcher push is queued after the active poll pass", async () => {
+    const watcher = makeWatcherStub();
+    const clock = new FakeClock();
+    let triggerShutdown = () => {};
+
+    let releasePoll: () => void = () => {};
+    const pollGate = new Promise<void>((resolve) => {
+      releasePoll = resolve;
+    });
+    let active = 0;
+    let maxConcurrent = 0;
+    let calls = 0;
+    const runPass = vi.fn().mockImplementation(async () => {
+      active++;
+      maxConcurrent = Math.max(maxConcurrent, active);
+      calls++;
+      if (calls === 1) await pollGate;
+      active--;
+      return 0;
+    });
+
+    const loop = runRunnerWithLoop(
+      ["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"],
+      {
+        runPass,
+        clock,
+        createWatcher: () => watcher,
+        sleep: () => new Promise<void>(() => {}),
+        onShutdownSignal: (handler) => {
+          triggerShutdown = handler;
+          return () => {};
+        },
+      },
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(active).toBe(1);
+
+    watcher.emit("companies/indigo/queued.md");
+    clock.advance(0);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(maxConcurrent).toBe(1);
+
+    releasePoll();
+    for (let i = 0; i < 8; i++) await Promise.resolve();
+    clock.advance(0);
+    for (let i = 0; i < 8; i++) await Promise.resolve();
+
+    triggerShutdown();
+    await loop;
+
+    expect(maxConcurrent).toBe(1);
+    const targetedCall = runPass.mock.calls.find((c) =>
+      (c[0] as string[]).includes("--company"),
+    );
+    expect(targetedCall?.[0]).toEqual([
+      "--company",
+      "indigo",
+      "--direction",
+      "push",
+      "--hq-root",
+      "/tmp/hq",
+    ]);
+  });
+
   it("poll-still-runs: the poll loop fires passes independent of the watcher", async () => {
     const watcher = makeWatcherStub();
     let triggerShutdown = () => {};
@@ -3813,7 +3889,7 @@ describe("readPinnedPrefixes", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Operation lock — one-shot sync takes it; the watch runner is exempt.
+// Operation lock — sync operations serialize per root.
 // ---------------------------------------------------------------------------
 describe("runRunnerWithLoop — operation lock", () => {
   const HQ = "/tmp/hq-oplock";
@@ -3931,14 +4007,29 @@ describe("runRunnerWithLoop — operation lock", () => {
     expect(out).toContain("reindex");
   }, 20_000);
 
-  it("the watch runner is EXEMPT — runs despite a held lock and never takes it", async () => {
+  it("F03: watch runner refuses when another operation holds the root lock", async () => {
     const lp = writeLiveHolder("sync");
     const watcher = makeWatcherStub();
     let triggerShutdown = () => {};
     const runPass = vi.fn().mockResolvedValue(0);
+    const errs: string[] = [];
+    const spy = vi
+      .spyOn(process.stderr, "write")
+      .mockImplementation((chunk: string | Uint8Array) => {
+        errs.push(String(chunk));
+        return true;
+      });
 
     const loop = runRunnerWithLoop(
-      ["--companies", "--watch", "--event-push", "--hq-root", HQ],
+      [
+        "--companies",
+        "--watch",
+        "--event-push",
+        "--hq-root",
+        HQ,
+        "--lock-timeout",
+        "0",
+      ],
       {
         runPass,
         clock: new FakeClock(),
@@ -3953,14 +4044,18 @@ describe("runRunnerWithLoop — operation lock", () => {
 
     await Promise.resolve();
     await Promise.resolve();
-    // It started and ran a pass even though the lock is held → not blocked.
-    expect(watcher.started).toBe(true);
-    expect(runPass).toHaveBeenCalled();
+    if (watcher.started || runPass.mock.calls.length > 0) {
+      triggerShutdown();
+    }
+    const code = await loop;
+    spy.mockRestore();
 
-    triggerShutdown();
-    await loop;
+    expect(code).toBe(OPERATION_LOCKED_EXIT);
+    expect(watcher.started).toBe(false);
+    expect(runPass).not.toHaveBeenCalled();
+    expect(errs.join("")).toContain("sync");
 
-    // The pre-existing holder lock is untouched → the watcher never took it.
+    // The pre-existing holder lock is untouched.
     const held = JSON.parse(fs.readFileSync(lp, "utf8"));
     expect(held.pid).toBe(1);
     expect(held.command).toBe("sync");
@@ -4147,6 +4242,198 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
     await loop;
   });
 
+  it("F04: mixed-route watcher batches publish only routes that were pushed", async () => {
+    const publishBatch = vi.fn();
+    const startEventSync = vi.fn().mockResolvedValue({
+      publishBatch,
+      receiver: { start: async () => {}, dispose: async () => {}, connected: true },
+      ownDeviceId: "dev-test",
+      dispose: vi.fn().mockResolvedValue(undefined),
+    });
+    const runPass = vi.fn().mockResolvedValue(0);
+    const { loop, watcher, clock, shutdown } = runLoop({
+      claims: ENROLLED_CLAIMS,
+      startEventSync,
+      runPass,
+    });
+    await microtasks();
+    runPass.mockClear();
+
+    watcher.emit("companies/indigo/a.md", {
+      paths: new Map([
+        ["/tmp/hq/companies/indigo/a.md", "companies/indigo/a.md"],
+        ["/tmp/hq/companies/acme/b.md", "companies/acme/b.md"],
+        ["/tmp/hq/notes/personal.md", "notes/personal.md"],
+      ]),
+    });
+    clock.advance(0);
+    await microtasks();
+
+    const pushedRoutes = new Set<string>();
+    let pushedEverything = false;
+    for (const call of runPass.mock.calls) {
+      const passArgv = call[0] as string[];
+      const directionIdx = passArgv.indexOf("--direction");
+      if (passArgv[directionIdx + 1] !== "push") continue;
+      const companyIdx = passArgv.indexOf("--company");
+      if (companyIdx >= 0) {
+        pushedRoutes.add(`company:${passArgv[companyIdx + 1]}`);
+      } else if (passArgv.includes("--companies")) {
+        pushedEverything = true;
+      }
+    }
+    const publishedRelPaths = publishBatch.mock.calls.flatMap((call) => {
+      const batch = call[0] as { paths: Map<string, string> };
+      return [...batch.paths.values()];
+    });
+    const publishedWithoutPush = publishedRelPaths.filter((relPath) => {
+      if (pushedEverything) return false;
+      const route = routeChangeToTarget(relPath);
+      if (!route) return true;
+      if (route.kind === "company") {
+        return !pushedRoutes.has(`company:${route.slug}`);
+      }
+      return !pushedRoutes.has("personal");
+    });
+
+    expect(publishedRelPaths).toContain("companies/indigo/a.md");
+    expect(publishedWithoutPush).toEqual([]);
+
+    shutdown();
+    await loop;
+  });
+
+  it("R-F04F05: preserves queued watcher push targets across overlap", async () => {
+    const publishBatch = vi.fn();
+    const startEventSync = vi.fn().mockResolvedValue({
+      publishBatch,
+      receiver: { start: async () => {}, dispose: async () => {}, connected: true },
+      ownDeviceId: "dev-test",
+      dispose: vi.fn().mockResolvedValue(undefined),
+    });
+    let receiverSync:
+      | ((ctx: {
+          event: PushEvent;
+          signal: AbortSignal;
+        }) => Promise<void>)
+      | null = null;
+    const watcher = makeBatchWatcherStub();
+    const clock = new FakeClock();
+    let triggerShutdown = () => {};
+    let releasePoll: () => void = () => {};
+    const pollGate = new Promise<void>((resolve) => {
+      releasePoll = resolve;
+    });
+    let passCount = 0;
+    const runPass = vi.fn().mockImplementation(async () => {
+      passCount += 1;
+      if (passCount === 1) await pollGate;
+      return 0;
+    });
+
+    const loop = runRunnerWithLoop(
+      ["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"],
+      {
+        runPass,
+        clock,
+        createWatcher: () => watcher,
+        createReceiver: ({ syncFn }) => {
+          receiverSync = syncFn;
+          return {
+            connected: true,
+            start: async () => {},
+            dispose: async () => {},
+          };
+        },
+        sleep: () => new Promise<void>(() => {}),
+        onShutdownSignal: (handler) => {
+          triggerShutdown = handler;
+          return () => {};
+        },
+        getIdTokenClaims: () => ENROLLED_CLAIMS as never,
+        getAccessToken: async () => "jwt-test",
+        startEventSync,
+      },
+    );
+    await microtasks();
+    expect(passCount).toBe(1);
+    expect(receiverSync).toBeTruthy();
+
+    const indigoBatch = {
+      paths: new Map([
+        ["/tmp/hq/companies/indigo/a.md", "companies/indigo/a.md"],
+      ]),
+    };
+    const betaBatch = {
+      paths: new Map([
+        ["/tmp/hq/companies/beta/b.md", "companies/beta/b.md"],
+      ]),
+    };
+    watcher.emit("companies/indigo/a.md", indigoBatch);
+    clock.advance(0);
+    await microtasks();
+    watcher.emit("companies/beta/b.md", betaBatch);
+    clock.advance(0);
+    await microtasks();
+
+    const remotePull = receiverSync!({
+      event: {
+        kind: "upsert",
+        relativePath: "companies/acme/remote.md",
+        contentHash: "sha256:remote",
+        mtime: "2026-06-18T12:00:00.000Z",
+        originDeviceId: "peer-device",
+        originTenantId: "tenant-acme",
+        sequenceNumber: 7,
+        eventTimestamp: "2026-06-18T12:00:00.000Z",
+      },
+      signal: new AbortController().signal,
+    });
+    await microtasks();
+
+    releasePoll();
+    await remotePull;
+    await microtasks();
+    clock.advance(0);
+    await microtasks();
+
+    const passArgvs = runPass.mock.calls.map((call) => call[0] as string[]);
+    expect(passArgvs).toEqual(
+      expect.arrayContaining([
+        ["--company", "indigo", "--direction", "push", "--hq-root", "/tmp/hq"],
+        ["--company", "beta", "--direction", "push", "--hq-root", "/tmp/hq"],
+        ["--company", "acme", "--direction", "pull", "--hq-root", "/tmp/hq"],
+      ]),
+    );
+
+    const pushedRoutes = new Set<string>();
+    for (const passArgv of passArgvs) {
+      const directionIdx = passArgv.indexOf("--direction");
+      if (passArgv[directionIdx + 1] !== "push") continue;
+      const companyIdx = passArgv.indexOf("--company");
+      if (companyIdx >= 0) pushedRoutes.add(`company:${passArgv[companyIdx + 1]}`);
+    }
+    const publishedRelPaths = publishBatch.mock.calls.flatMap((call) => {
+      const batch = call[0] as { paths: Map<string, string> };
+      return [...batch.paths.values()];
+    });
+    const publishedWithoutPush = publishedRelPaths.filter((relPath) => {
+      const route = routeChangeToTarget(relPath);
+      return route?.kind !== "company" || !pushedRoutes.has(`company:${route.slug}`);
+    });
+
+    expect(publishedRelPaths).toEqual(
+      expect.arrayContaining([
+        "companies/indigo/a.md",
+        "companies/beta/b.md",
+      ]),
+    );
+    expect(publishedWithoutPush).toEqual([]);
+
+    triggerShutdown();
+    await loop;
+  });
+
   it("falls back to a synthesized single-path batch when the watcher emits a bare path", async () => {
     const publishBatch = vi.fn();
     const startEventSync = vi.fn().mockResolvedValue({