@indigoai-us/hq-cloud 6.11.10 → 6.11.11

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

@@ -1794,6 +1794,71 @@ describe("personal slot fanout", () => {
             fs.rmSync(tmpHqRoot, { recursive: true, force: true });
         }
     });
+    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) => Promise.resolve({ uid, slug: "acme" }),
+                    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.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