@indigoai-us/hq-cloud 6.11.10 → 6.11.12

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 () => {
@@ -2182,6 +2191,104 @@ describe("personal slot fanout", () => {
     }
   });
 
+  it("E2: personal slot pierces the workspace/ exclusion for the session-continuity pointer + active thread file, while the rest of workspace/ stays local (DEV-1778)", async () => {
+    // Regression guard for the cross-machine session-handoff carve-out. Test
+    // "E" proves `workspace/` is excluded wholesale; this proves the ONE
+    // exception travels through the REAL runner push composition (not just the
+    // pure computeContinuityPointerPaths helper): `/handoff` writes
+    // workspace/threads/handoff.json + the thread file it points to, and both
+    // must reach share() so a session handed off on machine A resumes on
+    // machine B. Everything else under workspace/ (locks, other threads, the
+    // INDEX) must remain machine-local.
+    const shareSpy = vi.fn().mockResolvedValue(defaultShareResult());
+    const tmpHqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-runner-test-"));
+    try {
+      // A normal included top-level dir, so the personal push is non-empty
+      // regardless of the carve-out.
+      fs.mkdirSync(path.join(tmpHqRoot, "knowledge"));
+
+      // The session-continuity carve-out: handoff.json + the active thread it
+      // references via `thread_path` (hq-root-relative, as handoff-finalize.sh
+      // writes it).
+      const threadsDir = path.join(tmpHqRoot, "workspace", "threads");
+      fs.mkdirSync(threadsDir, { recursive: true });
+      const activeThreadRel = "workspace/threads/T-20260619-1200-resume-me.json";
+      fs.writeFileSync(
+        path.join(tmpHqRoot, activeThreadRel),
+        JSON.stringify({ conversation_summary: "pick up here" }),
+      );
+      fs.writeFileSync(
+        path.join(threadsDir, "handoff.json"),
+        JSON.stringify({ thread_path: activeThreadRel }),
+      );
+
+      // The rest of workspace/ that must NOT travel: a lock, an inactive
+      // thread, and the regenerated index.
+      fs.mkdirSync(path.join(tmpHqRoot, "workspace", "locks"), {
+        recursive: true,
+      });
+      fs.writeFileSync(
+        path.join(tmpHqRoot, "workspace", "locks", "sync.lock"),
+        "1",
+      );
+      fs.writeFileSync(
+        path.join(threadsDir, "T-20260101-0000-stale.json"),
+        "{}",
+      );
+      fs.writeFileSync(path.join(threadsDir, "INDEX.md"), "# threads");
+
+      const deps = makeDeps({
+        createVaultClient: () =>
+          makeVaultStub({
+            memberships: [{ companyUid: "cmp_a" }],
+            entityGet: (uid: string) =>
+              Promise.resolve({ uid, slug: "acme" } as unknown as EntityInfo),
+            listPersons: () => Promise.resolve([olderPerson]),
+          }),
+        share: shareSpy,
+      });
+
+      const code = await runRunner(
+        ["--companies", "--direction", "push", "--hq-root", tmpHqRoot],
+        deps,
+      );
+      expect(code).toBe(0);
+
+      const personalCall = (shareSpy.mock.calls as Array<[ShareOptions]>).find(
+        (c) => c[0].company?.startsWith("prs_"),
+      );
+      expect(personalCall).toBeDefined();
+      const personalArgs = personalCall![0];
+
+      // Compare as hq-root-relative, forward-slash paths (the namespace the
+      // continuity carve-out is specified in).
+      const relPaths = personalArgs.paths.map((p) =>
+        path.relative(tmpHqRoot, p).split(path.sep).join("/"),
+      );
+
+      // The two continuity files MUST be in the push set.
+      expect(relPaths).toContain("workspace/threads/handoff.json");
+      expect(relPaths).toContain(activeThreadRel);
+
+      // The rest of workspace/ must NOT leak in — neither as the parent dir
+      // nor as the individual machine-local files.
+      expect(relPaths).not.toContain("workspace");
+      expect(relPaths).not.toContain("workspace/locks");
+      expect(
+        relPaths.some(
+          (p) => p === "workspace/locks" || p.startsWith("workspace/locks/"),
+        ),
+      ).toBe(false);
+      expect(relPaths).not.toContain("workspace/threads/T-20260101-0000-stale.json");
+      expect(relPaths).not.toContain("workspace/threads/INDEX.md");
+      // The bare threads dir is never handed in wholesale — only the two
+      // explicit files (otherwise share()'s walk would sweep stale threads).
+      expect(relPaths).not.toContain("workspace/threads");
+    } finally {
+      fs.rmSync(tmpHqRoot, { recursive: true, force: true });
+    }
+  });
+
   it("G: personal slot includes companies/{slug}/ subdirs when cloud:false marker is set AND HQ_SYNC_LOCAL_COMPANIES_TO_PERSONAL=1, excluding _template + team-synced slugs + missing/cloud:true markers", async () => {
     // Gate the new behavior: without this env var the runner falls back to
     // the legacy "companies/ never enumerated" personal vault. Test H below
@@ -2958,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 = () => {};
@@ -3715,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";
@@ -3833,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(),
@@ -3855,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");
@@ -4049,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({