@indigoai-us/hq-cloud 6.14.18 → 6.14.20

package/dist/cli/share.test.js

@@ -1653,6 +1653,11 @@ describe("share", () => {
             propagateDeletePolicy: "owned-only",
         });
         expect(result.filesDeleted).toBe(1);
+        expect(result.pathResults).toContainEqual({
+            path: "knowledge",
+            status: "accepted",
+            operation: "delete",
+        });
         expect(deleteRemoteFile).toHaveBeenCalledWith(expect.anything(), "knowledge");
         const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
         expect(journal.files["knowledge"]).toBeUndefined();
@@ -1794,6 +1799,34 @@ describe("share", () => {
         expect(uploadSymlink).not.toHaveBeenCalled();
         expect(uploadFile).toHaveBeenCalledWith(expect.anything(), path.join(localSkill, "SKILL.md"), ".claude/skills/local-skill/SKILL.md", undefined, expect.anything());
     });
+    it("personalMode excludes generated core mirror symlinks but keeps canonical core files", async () => {
+        const packagePolicy = path.join(tmpDir, "core", "packages", "hq-pack-example", "policies", "generated.md");
+        const generatedMirror = path.join(tmpDir, "core", "policies", "generated.md");
+        const canonicalCoreFile = path.join(tmpDir, "core", "policies", "shipped.md");
+        fs.mkdirSync(path.dirname(packagePolicy), { recursive: true });
+        fs.mkdirSync(path.dirname(generatedMirror), { recursive: true });
+        fs.writeFileSync(packagePolicy, "generated package policy\n");
+        fs.symlinkSync(packagePolicy, generatedMirror);
+        fs.writeFileSync(canonicalCoreFile, "shipped core policy\n");
+        const result = await share({
+            paths: [path.join(tmpDir, "core")],
+            entityContext: makeEntityContext({
+                uid: "prs_01PERSONALTEST",
+                slug: "__hq_personal_vault__",
+                bucketName: "hq-vault-prs-01PERSONALTEST",
+            }),
+            hqRoot: tmpDir,
+            personalMode: true,
+            journalSlug: "personal-generated-core-mirror",
+        });
+        expect(result.filesExcludedByPolicy).toBe(1);
+        expect(result.filesUploaded).toBe(2);
+        expect(vi.mocked(uploadSymlink)).not.toHaveBeenCalled();
+        expect(vi.mocked(uploadFile).mock.calls.map((call) => call[2]).sort()).toEqual([
+            "core/packages/hq-pack-example/policies/generated.md",
+            "core/policies/shipped.md",
+        ]);
+    });
     it("personal-vault override does NOT apply to company vaults: `owned-only` on cmp_ entity still " +
         "refuses to tombstone a direction:'down' entry (multi-user curation intact)", async () => {
         // Sibling guard for the previous test: the override is scoped strictly
@@ -2492,7 +2525,7 @@ describe("share", () => {
             message: expect.stringContaining("tombstone"),
         });
     });
-    it("currency-gated: refuses delete for legacy journal entry with no recorded remoteEtag", async () => {
+    it("daemon-stopped deletion has no watcher intent and is safely refused", async () => {
         const companyRoot = path.join(tmpDir, "companies", "acme");
         fs.mkdirSync(companyRoot, { recursive: true });
         // Journal entry from before remoteEtag tracking — no etag to compare
@@ -2532,6 +2565,12 @@ describe("share", () => {
             reason: "missing-delete-intent",
         });
         expect(result.filesRefusedStale).toBe(1);
+        expect(result.pathResults).toContainEqual({
+            path: "legacy-no-etag.md",
+            status: "refused",
+            operation: "delete",
+            reason: "missing-delete-intent",
+        });
     });
     it("currency-gated: real-world /update-hq scenario — direction:'down' delete propagates when current", async () => {
         // Regression for the exact bug that motivated the 5.24 default flip:
@@ -2742,6 +2781,44 @@ describe("share", () => {
     // exclusion list itself is enforced by the runner (sync-runner.ts) by only
     // passing in the allowed top-level directories — share() trusts its
     // `paths` input.
+    it("plans an intent-backed personal delete from an explicit missing scope root", async () => {
+        const key = "deleted-top-level.md";
+        const journalSlug = "personal-scoped-delete";
+        const journalPath = path.join(stateDir, `sync-journal.${journalSlug}.json`);
+        fs.writeFileSync(journalPath, JSON.stringify({
+            version: "2",
+            lastSync: new Date().toISOString(),
+            pulls: [],
+            files: {
+                [key]: {
+                    hash: "captured-hash",
+                    size: 8,
+                    syncedAt: new Date().toISOString(),
+                    direction: "up",
+                    remoteEtag: "captured-etag",
+                    kind: "file",
+                    localDeleteIntent: deleteIntent("captured-etag", "captured-hash"),
+                },
+            },
+        }));
+        const result = await share({
+            // computePersonalVaultPaths() has no path to contribute after this
+            // top-level file is gone. The watcher-captured root is the sole scope.
+            paths: [],
+            deleteScopeRoots: [key],
+            company: "acme",
+            vaultConfig: mockConfig,
+            hqRoot: tmpDir,
+            personalMode: true,
+            journalSlug,
+            skipUnchanged: true,
+            propagateDeletes: true,
+            propagateDeletePolicy: "owned-only",
+        });
+        expect(result.filesDeleted).toBe(1);
+        expect(deleteRemoteFile).toHaveBeenCalledWith(expect.anything(), key);
+        expect(JSON.parse(fs.readFileSync(journalPath, "utf8")).files[key]).toBeUndefined();
+    });
     // ── Decommission prefixes ──────────────────────────────────────────────────
     //
     // `decommissionPrefixes` is the "company was promoted to its own team
@@ -3312,7 +3389,7 @@ describe("share", () => {
         // entries as absent locally (the rest get a real file on disk).
         // `direction` default "up" so the owned-only branch accepts every
         // candidate (direction:"down" silently skips and never trips the guard).
-        function setupJournal({ total, missing, direction = "up", }) {
+        function setupJournal({ total, missing, direction = "up", withIntents = true, }) {
             const companyRoot = path.join(tmpDir, "companies", "acme");
             fs.mkdirSync(companyRoot, { recursive: true });
             const files = {};
@@ -3325,7 +3402,9 @@ describe("share", () => {
                     direction,
                     remoteEtag: `etag-${i}`,
                     kind: "file",
-                    localDeleteIntent: deleteIntent(`etag-${i}`, "h"),
+                    ...(withIntents
+                        ? { localDeleteIntent: deleteIntent(`etag-${i}`, "h") }
+                        : {}),
                 };
                 if (i >= missing) {
                     fs.writeFileSync(path.join(companyRoot, key), "hi");
@@ -3343,7 +3422,11 @@ describe("share", () => {
             delete process.env.HQ_SYNC_DELETE_BULK_OVERRIDE;
         });
         it("trips at the 11/100 boundary (11% > 10%, abs >= 10): refuses every delete and emits bulk-asymmetry event", async () => {
-            const { companyRoot, journalPath } = setupJournal({ total: 100, missing: 11 });
+            const { companyRoot, journalPath } = setupJournal({
+                total: 100,
+                missing: 11,
+                withIntents: false,
+            });
             // currency-gated: remote HEAD would match every journal etag — guard
             // must trip BEFORE any HEAD round-trip occurs.
             vi.mocked(headRemoteFile).mockImplementation(async (_ctx, key) => ({
@@ -3392,6 +3475,28 @@ describe("share", () => {
             const perKeyRefusals = events.filter((e) => e.type === "delete-refused-stale-etag" && e.reason === "bulk-asymmetry");
             expect(perKeyRefusals.length).toBe(11);
         });
+        it("intent-backed 11/100 subtree disappearance bypasses the breaker and deletes every covered path", async () => {
+            const { companyRoot } = setupJournal({ total: 100, missing: 11 });
+            vi.mocked(headRemoteFile).mockImplementation(async (_ctx, key) => ({
+                etag: `etag-${parseInt(key.replace(/[^0-9]/g, ""), 10)}`,
+                lastModified: new Date(),
+                size: 5,
+            }));
+            const events = [];
+            const result = await share({
+                paths: [companyRoot],
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                skipUnchanged: true,
+                propagateDeletes: true,
+                propagateDeletePolicy: "currency-gated",
+                onEvent: (e) => events.push(e),
+            });
+            expect(result.filesDeleted).toBe(11);
+            expect(deleteRemoteFile).toHaveBeenCalledTimes(11);
+            expect(events.find((e) => e.type === "delete-refused-bulk-asymmetry")).toBeUndefined();
+        });
         it("does NOT trip at 9/100 (below ratio): all candidates delete normally", async () => {
             const { companyRoot } = setupJournal({ total: 100, missing: 9 });
             vi.mocked(headRemoteFile).mockImplementation(async (_ctx, key) => ({
@@ -3449,7 +3554,11 @@ describe("share", () => {
             expect(deleteRemoteFile).toHaveBeenCalledTimes(11);
         });
         it("fully-empty mirror (100/100) trips the guard — the canonical mass-delete failure mode", async () => {
-            const { companyRoot, journalPath } = setupJournal({ total: 50, missing: 50 });
+            const { companyRoot, journalPath } = setupJournal({
+                total: 50,
+                missing: 50,
+                withIntents: false,
+            });
             vi.mocked(headRemoteFile).mockImplementation(async (_ctx, key) => ({
                 etag: `etag-${parseInt(key.replace(/[^0-9]/g, ""), 10)}`,
                 lastModified: new Date(),
@@ -3497,7 +3606,11 @@ describe("share", () => {
             expect(deleteRemoteFile).toHaveBeenCalledTimes(9);
         });
         it("owned-only policy also goes through the guard: 11/100 missing direction:'up' entries refused", async () => {
-            const { companyRoot, journalPath } = setupJournal({ total: 100, missing: 11 });
+            const { companyRoot, journalPath } = setupJournal({
+                total: 100,
+                missing: 11,
+                withIntents: false,
+            });
             const events = [];
             const result = await share({
                 paths: [companyRoot],