@indigoai-us/hq-cloud 6.15.4 → 6.15.6

package/dist/cli/share.test.js

@@ -2032,6 +2032,7 @@ describe("share", () => {
                 if (e.type === "plan" ||
                     e.type === "new-files" ||
                     e.type === "personal-vault-out-of-policy" ||
+                    e.type === "personal-vault-journal-pruned" ||
                     e.type === "scope-excluded" ||
                     e.type === "scope-materialization-gap" ||
                     e.type === "ignore-excluded" ||
@@ -3935,6 +3936,87 @@ describe("share", () => {
             delete process.env.HQ_STATE_DIR;
         }
     });
+    it("stale-journal convergence: a personal push purges out-of-scope baseline rows and emits a summary", async () => {
+        // The never-completing personal-vault sync: a journal written by an engine
+        // that predated an exclusion rule keeps carrying rows for `.claude/
+        // worktrees/`, `workspace/`, `.hq-conflicts/`, and `.conflict-*` — nothing
+        // removed them, so they were re-diffed on every push forever. The push now
+        // purges them (option a: drop the row; the pull leg refuses the keys, so
+        // any remote object is an inert orphan) and persists the trimmed journal.
+        const stateDirPersonal = fs.mkdtempSync(path.join(os.tmpdir(), "hq-state-prs-purge-"));
+        process.env.HQ_STATE_DIR = stateDirPersonal;
+        try {
+            const journalPath = path.join(stateDirPersonal, "sync-journal.__hq_personal_vault__.json");
+            const entry = () => ({
+                hash: "h", size: 1, syncedAt: new Date().toISOString(),
+                direction: "up",
+            });
+            fs.writeFileSync(journalPath, JSON.stringify({
+                version: "1",
+                lastSync: new Date().toISOString(),
+                files: {
+                    // Legit row — must survive.
+                    "personal/keep.md": entry(),
+                    // Stale excluded rows with no other owner — must be purged.
+                    ".claude/worktrees/wt/a.ts": entry(),
+                    "personal/node_modules/pkg/index.js": entry(),
+                    ".hq-conflicts/mirror.md": entry(),
+                    "workspace/scratch/tmp.md": entry(),
+                    // Litter row — owned by the vault-litter drain (remote delete), NOT
+                    // the purge. Left absent on disk so the drain removes it remotely.
+                    "CLAUDE.md.conflict-2026-05-13T19-40-40Z-e5797a.md": entry(),
+                },
+            }));
+            fs.writeFileSync(path.join(tmpDir, "personal-keep-seed"), "x");
+            fs.mkdirSync(path.join(tmpDir, "personal"), { recursive: true });
+            fs.writeFileSync(path.join(tmpDir, "personal", "keep.md"), "x");
+            const personalCtx = makeEntityContext({
+                uid: "prs_01HASSAANTESTUSER",
+                slug: "__hq_personal_vault__",
+                bucketName: "hq-vault-prs-01HASSAANTESTUSER",
+            });
+            const events = [];
+            const pruned = [];
+            await share({
+                paths: [tmpDir],
+                entityContext: personalCtx,
+                hqRoot: tmpDir,
+                personalMode: true,
+                skipUnchanged: true,
+                propagateDeletes: true,
+                onEvent: (e) => {
+                    events.push(e.type);
+                    if (e.type === "personal-vault-journal-pruned") {
+                        pruned.push({ count: e.count, byReason: e.byReason });
+                    }
+                },
+            });
+            // Summary event fired exactly once with the right breakdown. The
+            // `.conflict-*` litter is NOT counted here — it is drained by the
+            // vault-litter delete path, not the purge.
+            expect(pruned).toHaveLength(1);
+            expect(pruned[0].count).toBe(4);
+            expect(pruned[0].byReason["ignore-filtered"]).toBe(3);
+            expect(pruned[0].byReason["excluded-top-level"]).toBe(1);
+            // The persisted journal converged: excluded rows gone, legit row kept.
+            const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
+            expect(Object.keys(journal.files)).toContain("personal/keep.md");
+            expect(journal.files[".claude/worktrees/wt/a.ts"]).toBeUndefined();
+            expect(journal.files["personal/node_modules/pkg/index.js"]).toBeUndefined();
+            expect(journal.files[".hq-conflicts/mirror.md"]).toBeUndefined();
+            expect(journal.files["workspace/scratch/tmp.md"]).toBeUndefined();
+            // The litter row was drained by the litter path (remote delete), so it is
+            // also gone from the journal — but via DeleteObject, not a silent purge.
+            expect(journal.files["CLAUDE.md.conflict-2026-05-13T19-40-40Z-e5797a.md"]).toBeUndefined();
+            expect(deleteRemoteFile).toHaveBeenCalledWith(expect.anything(), "CLAUDE.md.conflict-2026-05-13T19-40-40Z-e5797a.md");
+            // Purged rows are DROPPED, not delete-propagated to the remote.
+            expect(deleteRemoteFile).not.toHaveBeenCalledWith(expect.anything(), ".claude/worktrees/wt/a.ts");
+        }
+        finally {
+            fs.rmSync(stateDirPersonal, { recursive: true, force: true });
+            delete process.env.HQ_STATE_DIR;
+        }
+    });
     // ── personalMode ───────────────────────────────────────────────────────────
     //
     // The personal vault (slug "personal" in the runner's fanout plan) shares