@indigoai-us/hq-cloud 6.18.44-alpha.24 → 6.18.44-alpha.26

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

@@ -14749,11 +14749,13 @@ describe("readPinnedPrefixes", () => {
 // ---------------------------------------------------------------------------
 describe("runRunnerWithLoop — operation lock", () => {
     const HQ = "/tmp/hq-oplock";
-    /** Write a live-holder lock (pid 1) for the HQ root into the test state dir. */
+    /** Write a live-holder lock for the HQ root into the test state dir.
+     *  process.pid stays alive for the test on Linux, macOS and Windows.
+     *  pid 1 does not exist on Windows, so the probe treats that lock as stale. */
     function writeLiveHolder(command) {
         const p = lockPathFor(HQ);
         fs.mkdirSync(path.dirname(p), { recursive: true });
-        fs.writeFileSync(p, JSON.stringify({ pid: 1, command, startedAt: new Date(0).toISOString(), hqRoot: HQ }));
+        fs.writeFileSync(p, JSON.stringify({ pid: process.pid, command, startedAt: new Date(0).toISOString(), hqRoot: HQ }));
         return p;
     }
     it("one-shot sync refuses immediately (exit 17) with --lock-timeout 0 when another op holds the root", async () => {
@@ -14782,7 +14784,9 @@ describe("runRunnerWithLoop — operation lock", () => {
         expect(errs.join("")).toContain("rescue"); // names the holder
         // The holder's lock is left intact — we refused, we didn't take it over.
         const held = JSON.parse(fs.readFileSync(lp, "utf8"));
-        expect(held.pid).toBe(1);
+        expect(held.pid).toBe(process.pid);
+        // The test pid is also the runner pid, so the epoch startedAt proves the holder record was not rewritten.
+        expect(held.startedAt).toBe(new Date(0).toISOString());
         expect(held.command).toBe("rescue");
     });
     it("one-shot sync WAITS for a live holder (default), bounded by --lock-timeout, then refuses with exit 17", async () => {
@@ -14814,14 +14818,16 @@ describe("runRunnerWithLoop — operation lock", () => {
         expect(errs.join("")).toContain("Waiting for"); // status line emitted once
         expect(errs.join("")).toContain("rescue"); // names the holder
         const held = JSON.parse(fs.readFileSync(lp, "utf8"));
-        expect(held.pid).toBe(1); // holder untouched
+        expect(held.pid).toBe(process.pid); // holder untouched
+        // The test pid is also the runner pid, so the epoch startedAt proves the holder record was not rewritten.
+        expect(held.startedAt).toBe(new Date(0).toISOString());
     }, 20_000);
     it("DEV-1772: one-shot waits out a SHORT-LIVED holder (reindex) then PROCEEDS to sync", async () => {
         // The exact reported scenario (feedback_28a1833f / DEV-1772): a frequent
         // ~1-min `reindex` briefly holds the lock; the instant-sync one-shot used
         // to exit 17 and silently die. Now it WAITS (default) and proceeds the
         // moment the short holder releases. We model the short holder with a
-        // foreign live pid (1) whose lock file is removed shortly after, and inject
+        // foreign live pid (this process) whose lock file is removed shortly after, and inject
         // runPass so "proceeds → syncs" is observable without the network.
         writeLiveHolder("reindex");
         const errs = [];
@@ -14888,7 +14894,9 @@ describe("runRunnerWithLoop — operation lock", () => {
         expect(errs.join("")).toContain("sync");
         // The pre-existing holder lock is untouched.
         const held = JSON.parse(fs.readFileSync(lp, "utf8"));
-        expect(held.pid).toBe(1);
+        expect(held.pid).toBe(process.pid);
+        // The test pid is also the runner pid, so the epoch startedAt proves the holder record was not rewritten.
+        expect(held.startedAt).toBe(new Date(0).toISOString());
         expect(held.command).toBe("sync");
     });
 });