@indigoai-us/hq-cloud 6.14.35 → 6.14.37

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

@@ -92,6 +92,8 @@ function defaultShareResult(overrides = {}) {
         filesExcludedByPolicy: 0,
         filesExcludedByScope: 0,
         filesExcludedByIgnore: 0,
+        unreachablePaths: [],
+        linkedSubtreesNotShipped: [],
         conflictPaths: [],
         aborted: false,
         ...overrides,
@@ -6189,6 +6191,9 @@ describe("watcher delete intents without pre-seeded authorization", () => {
         });
         let initialPullGated = options.gateInitialPull === true;
         const runPass = vi.fn(async (argv) => {
+            // Lets a test hold a pass mid-flight and act while the loop is awaiting
+            // it, which is where producer-side state that outlives a pass is decided.
+            await options.onPass?.(argv);
             const direction = argv[argv.indexOf("--direction") + 1];
             if (direction === "push") {
                 const journal = readJournal("indigo");
@@ -6259,7 +6264,8 @@ describe("watcher delete intents without pre-seeded authorization", () => {
             return 0;
         });
         const loop = runRunnerWithLoop([
-            "--companies", "--watch", "--event-push", "--direction", "both",
+            "--companies", "--watch", "--event-push",
+            "--direction", options.direction ?? "both",
             "--hq-root", hqRoot, "--poll-remote-ms", "60000",
         ], {
             runPass,
@@ -6660,6 +6666,86 @@ describe("watcher delete intents without pre-seeded authorization", () => {
         expect(h.remote.size).toBe(11);
         await stopHarness(h);
     });
+    // A pass is awaited, so a bulk removal observed while one is in flight
+    // registers its quarantine root only after that pass's batch was taken — its
+    // own snapshots ride the NEXT batch. Expiring the whole set once the pass
+    // returns would drop the root before `prepareWatcherChanges` ever sees that
+    // batch, re-stamping the revoked descendant intents and handing the engine
+    // the bulk delete the quarantine refused (remotely deleting the subtree under
+    // HQ_SYNC_DELETE_POLICY=all).
+    it("a bulk removal observed during an in-flight pass keeps its quarantine", async () => {
+        const keys = Array.from({ length: 12 }, (_, i) => `knowledge/moved/f-${i}.md`);
+        let releaseGatedPush = () => { };
+        const gatedPush = new Promise((resolve) => {
+            releaseGatedPush = resolve;
+        });
+        let gateArmed = false;
+        let gateReached = false;
+        // Push-only: a pull would restore the quarantined subtree (the documented
+        // recovery for an intent-less disappearance) before the batch carrying the
+        // episode is prepared, masking whether the refusal itself survived.
+        const h = startDeleteHarness([...keys, "knowledge/other.md"], {
+            direction: "push",
+            onPass: async (_argv) => {
+                if (!gateArmed)
+                    return;
+                gateArmed = false;
+                gateReached = true;
+                await gatedPush;
+            },
+        });
+        await settle();
+        const intentCount = () => Object.values(readJournal("indigo").files).filter((entry) => entry.localDeleteIntent).length;
+        // An unrelated edit drains as a scoped push, which then blocks on the gate
+        // with its batch already taken from the pending buffer.
+        gateArmed = true;
+        const otherPath = path.join(h.companyRoot, "knowledge/other.md");
+        fs.writeFileSync(otherPath, "edited");
+        h.watcher.emit("companies/indigo/knowledge/other.md", {
+            paths: new Map([[otherPath, "companies/indigo/knowledge/other.md"]]),
+        });
+        h.tick();
+        await settle();
+        expect(gateReached).toBe(true);
+        // The whole subtree disappears while that pass is still in flight.
+        const childChanges = new Map();
+        for (const key of keys) {
+            const absolutePath = path.join(h.companyRoot, key);
+            fs.unlinkSync(absolutePath);
+            childChanges.set(absolutePath, {
+                kind: "unlink",
+                deleteSnapshots: h.capture()(`companies/indigo/${key}`, "unlink"),
+            });
+        }
+        const subtree = path.join(h.companyRoot, "knowledge/moved");
+        fs.rmSync(subtree, { recursive: true, force: true });
+        const dirSnapshots = h.capture()("companies/indigo/knowledge/moved", "unlinkDir");
+        expect(dirSnapshots).toHaveLength(0);
+        expect(intentCount()).toBe(0);
+        h.watcher.emit("companies/indigo/knowledge/moved", {
+            paths: new Map([
+                ...keys.map((key) => [
+                    path.join(h.companyRoot, key),
+                    `companies/indigo/${key}`,
+                ]),
+                [subtree, "companies/indigo/knowledge/moved"],
+            ]),
+            changes: new Map([
+                ...childChanges,
+                [subtree, { kind: "unlinkDir", deleteSnapshots: dirSnapshots }],
+            ]),
+        });
+        // Completing the overlapped pass must not expire the refusal recorded
+        // during it: the next drain prepares the batch that carries the episode.
+        releaseGatedPush();
+        await settle();
+        h.tick();
+        await settle();
+        expect(intentCount()).toBe(0);
+        for (const key of keys)
+            expect(h.remote.has(key)).toBe(true);
+        await stopHarness(h);
+    });
     it("HQ_SYNC_DELETE_BULK_OVERRIDE=1 lets a whole-shard unlinkDir propagate", async () => {
         process.env.HQ_SYNC_DELETE_BULK_OVERRIDE = "1";
         try {