@indigoai-us/hq-cloud 6.16.58 → 6.16.59

package/dist/cli/sync.test.js

@@ -138,7 +138,7 @@ import { readJournal, writeJournal, getEntry, listJournals, } from "../journal.j
 import { SqsPushReceiver } from "../sync/push-receiver.js";
 import { buildTargetedPullArgv } from "../bin/sync-runner-watch-routes.js";
 import { ReconcileCursorStore } from "../sync/reconcile-cursor.js";
-import { setObjectIOFactory } from "../object-io.js";
+import { RateLimitedError, setObjectIOFactory } from "../object-io.js";
 /**
  * Read a journal the way production does.
  *
@@ -4117,6 +4117,129 @@ describe("sync", () => {
         const journal = journalAt(journalPath);
         expect(journal.files["docs/out-of-scope.md"]).toBeDefined();
     });
+    it("defers a tombstone as a diagnostic error when HEAD throws RateLimitedError", async () => {
+        // Production (2026-09-18): vault 100/hr throttle during HEAD verify
+        // was emitted as a hard type:"error", so the company landed in
+        // errors[] and hq-sync-runner exited 2 even though the tombstone
+        // was already dropped from this pass. Rate-limit deferrals reuse
+        // the diagnostic marker; the file stays, the journal stays, and
+        // no hard error is emitted.
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        const skillDir = path.join(companyRoot, "skills", "wbr-finalize");
+        fs.mkdirSync(skillDir, { recursive: true });
+        const skillPath = path.join(skillDir, "SKILL.md");
+        const body = "skill body";
+        fs.writeFileSync(skillPath, body);
+        const crypto = await import("node:crypto");
+        const baselineHash = crypto.createHash("sha256").update(body).digest("hex");
+        fs.writeFileSync(journalPath, JSON.stringify({
+            version: "1",
+            lastSync: new Date(Date.now() - 60_000).toISOString(),
+            files: {
+                "skills/wbr-finalize/SKILL.md": {
+                    hash: baselineHash,
+                    size: body.length,
+                    syncedAt: new Date(Date.now() - 60_000).toISOString(),
+                    direction: "down",
+                    remoteEtag: "e-skill",
+                },
+            },
+        }));
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([]);
+        // Drop sibling Once/implementation leftovers so verify HEAD is this throw.
+        vi.mocked(s3Module.headRemoteFile).mockReset();
+        let headVerified = false;
+        vi.mocked(s3Module.headRemoteFile).mockImplementationOnce(async (_ctx, key) => {
+            expect(key).toBe("skills/wbr-finalize/SKILL.md");
+            headVerified = true;
+            throw new RateLimitedError("skills/wbr-finalize/SKILL.md", "get");
+        });
+        try {
+            const events = [];
+            const result = await sync({
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onEvent: (e) => events.push(e),
+            });
+            expect(headVerified).toBe(true);
+            expect(s3Module.headRemoteFile).toHaveBeenCalledTimes(1);
+            expect(s3Module.headRemoteFile).toHaveBeenCalledWith(expect.anything(), "skills/wbr-finalize/SKILL.md");
+            expect(fs.existsSync(skillPath)).toBe(true);
+            expect(result.filesTombstoned).toBe(0);
+            expect(journalAt(journalPath).files["skills/wbr-finalize/SKILL.md"]).toBeDefined();
+            const errorEvents = events.filter((e) => e.type === "error");
+            expect(errorEvents).toHaveLength(1);
+            expect(errorEvents[0]).toMatchObject({
+                type: "error",
+                diagnostic: true,
+                path: "skills/wbr-finalize/SKILL.md",
+                message: expect.stringMatching(/tombstone HEAD verify failed \(deferring\):.*RateLimited/),
+            });
+            expect(events.some((e) => e.type === "error" && e.diagnostic !== true)).toBe(false);
+        }
+        finally {
+            vi.mocked(s3Module.headRemoteFile).mockReset();
+            vi.mocked(s3Module.headRemoteFile).mockResolvedValue(null);
+        }
+    });
+    it("still emits a hard error when tombstone HEAD throws a generic Error", async () => {
+        const companyRoot = path.join(tmpDir, "companies", "acme");
+        fs.mkdirSync(path.join(companyRoot, "docs"), { recursive: true });
+        const localPath = path.join(companyRoot, "docs", "peer-deleted.md");
+        const body = "still here";
+        fs.writeFileSync(localPath, body);
+        const crypto = await import("node:crypto");
+        const baselineHash = crypto.createHash("sha256").update(body).digest("hex");
+        fs.writeFileSync(journalPath, JSON.stringify({
+            version: "1",
+            lastSync: new Date(Date.now() - 60_000).toISOString(),
+            files: {
+                "docs/peer-deleted.md": {
+                    hash: baselineHash,
+                    size: body.length,
+                    syncedAt: new Date(Date.now() - 60_000).toISOString(),
+                    direction: "down",
+                    remoteEtag: "e-del",
+                },
+            },
+        }));
+        vi.mocked(s3Module.listRemoteFiles).mockResolvedValueOnce([]);
+        vi.mocked(s3Module.headRemoteFile).mockReset();
+        let headVerified = false;
+        vi.mocked(s3Module.headRemoteFile).mockImplementationOnce(async (_ctx, key) => {
+            expect(key).toBe("docs/peer-deleted.md");
+            headVerified = true;
+            throw new Error("S3 boom");
+        });
+        try {
+            const events = [];
+            const result = await sync({
+                company: "acme",
+                vaultConfig: mockConfig,
+                hqRoot: tmpDir,
+                onEvent: (e) => events.push(e),
+            });
+            expect(headVerified).toBe(true);
+            expect(s3Module.headRemoteFile).toHaveBeenCalledTimes(1);
+            expect(s3Module.headRemoteFile).toHaveBeenCalledWith(expect.anything(), "docs/peer-deleted.md");
+            expect(fs.existsSync(localPath)).toBe(true);
+            expect(result.filesTombstoned).toBe(0);
+            expect(journalAt(journalPath).files["docs/peer-deleted.md"]).toBeDefined();
+            const errorEvents = events.filter((e) => e.type === "error");
+            expect(errorEvents).toHaveLength(1);
+            expect(errorEvents[0]).toMatchObject({
+                type: "error",
+                path: "docs/peer-deleted.md",
+                message: expect.stringContaining("tombstone HEAD verify failed (deferring):"),
+            });
+            expect(errorEvents[0]).not.toHaveProperty("diagnostic");
+        }
+        finally {
+            vi.mocked(s3Module.headRemoteFile).mockReset();
+            vi.mocked(s3Module.headRemoteFile).mockResolvedValue(null);
+        }
+    });
     it("retains the journal entry when tombstone unlink fails with EACCES (Codex P1 — Bug #9 follow-up)", async () => {
         // Codex review on PR #24 caught this: pre-fix the tombstone branch
         // dropped the journal entry unconditionally even when the local