@indigoai-us/hq-cloud 6.16.58-alpha.3 → 6.16.59

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

@@ -27,9 +27,10 @@ vi.mock("../s3.js", async (importOriginal) => {
     };
 });
 import { executeCompanyFanout } from "./sync-runner-company.js";
+import { clearContextCache, resolveEntityContext, setEntityFetchSleepForTest, } from "../context.js";
 import { CognitoAuthError, CognitoRefreshError } from "../cognito-auth.js";
 import { _testing as shareTesting, share, parseRegisteredCompanySkillUid, } from "../cli/share.js";
-import { readJournal } from "../journal.js";
+import { PERSONAL_VAULT_JOURNAL_SLUG, readJournal } from "../journal.js";
 import { VaultConflictError } from "../vault-client.js";
 import { headRemoteFile, uploadFile } from "../s3.js";
 import { setBandwidthGovernorForTesting } from "../bandwidth.js";
@@ -68,61 +69,6 @@ describe("executeCompanyFanout realtime inventory gate", () => {
         expect(emit).toHaveBeenCalledWith(expect.objectContaining({ type: "error", company: "personal", path: "(scope)" }));
     });
 });
-describe("executeCompanyFanout cooperative checkpoints", () => {
-    it("hands off only after each target leg has settled and retains the remaining plan", async () => {
-        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-fanout-checkpoint-"));
-        const order = [];
-        const shareResult = {
-            filesUploaded: 0,
-            bytesUploaded: 0,
-            filesSkipped: 0,
-            filesDeleted: 0,
-            filesTombstoned: 0,
-            filesRefusedStale: 0,
-            filesRefusedStalePaths: [],
-            filesSuppressedByTombstone: 0,
-            filesExcludedByPolicy: 0,
-            filesExcludedByScope: 0,
-            filesExcludedByIgnore: 0,
-            unreachablePaths: [],
-            linkedSubtreesNotShipped: [],
-            conflictPaths: [],
-            aborted: false,
-        };
-        try {
-            await executeCompanyFanout({
-                plan: [
-                    { uid: "prs_1", slug: "personal", personalMode: true },
-                    { uid: "prs_2", slug: "personal-next", personalMode: true },
-                ],
-                direction: "push",
-                hqRoot,
-                onConflict: "abort",
-                client: {},
-                vaultConfig: { apiUrl: "https://api.example", authToken: "access-token" },
-                syncFn: vi.fn(),
-                shareFn: vi.fn(async (options) => {
-                    order.push(`target:${options.company}`);
-                    return shareResult;
-                }),
-                resolveDeletePolicy: () => "all",
-                emit: vi.fn(),
-                ensureCompanyDir: vi.fn(),
-                cooperativeCheckpoint: async () => { order.push("checkpoint"); },
-                telemetryClient: null,
-            });
-            expect(order).toEqual([
-                "target:prs_1",
-                "checkpoint",
-                "target:prs_2",
-                "checkpoint",
-            ]);
-        }
-        finally {
-            fs.rmSync(hqRoot, { recursive: true, force: true });
-        }
-    });
-});
 describe("executeCompanyFanout — not-shipped event forwarding", () => {
     it("preserves a company skill validation message", async () => {
         const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-fanout-skill-validation-"));
@@ -609,6 +555,71 @@ describe("executeCompanyFanout — archived session-log skip", () => {
         }
     });
 });
+describe("executeCompanyFanout — diagnostic tombstone HEAD deferral", () => {
+    it("does not error the company when the only events are diagnostic tombstone deferrals", async () => {
+        // A vault 100/hr throttle during planned-deletion HEAD verify is
+        // emitted as `{ type: "error", diagnostic: true }`. The fanout must
+        // forward that marker and leave errors[] empty so the company
+        // settles `complete` and the runner keeps exit 0 (never 2).
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-fanout-tombstone-"));
+        try {
+            const events = [];
+            const pullResult = {
+                filesDownloaded: 0,
+                bytesDownloaded: 0,
+                filesSkipped: 0,
+                conflicts: 0,
+                conflictPaths: [],
+                aborted: false,
+                newFiles: [],
+                newFilesCount: 0,
+                filesExcludedByPolicy: 0,
+                filesTombstoned: 0,
+                filesOutOfScope: 0,
+                scopeOrphansRemoved: 0,
+                scopeOrphansBlocked: 0,
+            };
+            const syncFn = vi.fn(async (opts) => {
+                opts.onEvent?.({
+                    type: "error",
+                    diagnostic: true,
+                    path: "skills/wbr-finalize/SKILL.md",
+                    message: "tombstone HEAD verify failed (deferring): RateLimited rate limited (100/hr) — get skills/wbr-finalize/SKILL.md deferred to next sync",
+                });
+                return pullResult;
+            });
+            const result = await executeCompanyFanout({
+                plan: [{ uid: "prs_1", slug: "personal", personalMode: true }],
+                direction: "pull",
+                hqRoot,
+                onConflict: "keep",
+                client: {},
+                vaultConfig: { apiUrl: "https://api.example", authToken: "access-token" },
+                syncFn,
+                shareFn: vi.fn(),
+                resolveDeletePolicy: () => "all",
+                emit: (e) => events.push(e),
+                ensureCompanyDir: vi.fn(),
+                telemetryClient: null,
+            });
+            expect(events).toContainEqual({
+                type: "error",
+                diagnostic: true,
+                company: "personal",
+                path: "skills/wbr-finalize/SKILL.md",
+                message: "tombstone HEAD verify failed (deferring): RateLimited rate limited (100/hr) — get skills/wbr-finalize/SKILL.md deferred to next sync",
+            });
+            expect(result.errors).toEqual([]);
+            expect(result.companyFailures).toEqual([]);
+            expect(result.transientCompanies).toEqual([]);
+            expect(events.some((e) => e.type === "error" && e.diagnostic !== true)).toBe(false);
+            expect(result.stateByCompany.get("personal")?.status).toBe("complete");
+        }
+        finally {
+            fs.rmSync(hqRoot, { recursive: true, force: true });
+        }
+    });
+});
 describe("executeCompanyFanout — Windows rename-blocked skip (HQ-DESKTOP-54, second path)", () => {
     it("re-emits the skip with the company label, never errors the company, and keeps it complete", async () => {
         // A transient Windows rename refusal surfaces from the pull leg as the
@@ -1163,6 +1174,104 @@ describe("executeCompanyFanout — scoped push walk roots", () => {
         }
     });
 });
+describe("executeCompanyFanout — entity-fetch 429 (2026-09-18 Odin)", () => {
+    const vaultConfig = {
+        apiUrl: "https://vault-api.test",
+        authToken: "access-token",
+    };
+    const entity = {
+        uid: "cmp_01KQ2RYAHXHDPCTY9GPQPTH3DG",
+        slug: "indigo",
+        bucketName: "hq-vault-indigo",
+        status: "active",
+    };
+    const vend = {
+        credentials: {
+            accessKeyId: "ASIA_TEST",
+            secretAccessKey: "secret",
+            sessionToken: "session",
+            expiration: new Date(Date.now() + 15 * 60 * 1000).toISOString(),
+        },
+        expiresAt: new Date(Date.now() + 15 * 60 * 1000).toISOString(),
+    };
+    const runIndigoPull = async (syncFn) => {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-fanout-429-"));
+        const events = [];
+        try {
+            const result = await executeCompanyFanout({
+                plan: [{ uid: entity.uid, slug: "indigo" }],
+                direction: "pull",
+                hqRoot,
+                onConflict: "keep",
+                client: {},
+                vaultConfig,
+                syncFn,
+                shareFn: vi.fn(),
+                resolveDeletePolicy: () => "all",
+                emit: (e) => events.push(e),
+                ensureCompanyDir: vi.fn(),
+                telemetryClient: null,
+            });
+            return { result, events };
+        }
+        finally {
+            fs.rmSync(hqRoot, { recursive: true, force: true });
+        }
+    };
+    beforeEach(() => {
+        clearContextCache();
+        setEntityFetchSleepForTest(async () => undefined);
+    });
+    afterEach(() => {
+        setEntityFetchSleepForTest(undefined);
+        vi.unstubAllGlobals();
+    });
+    it("a 429 then success on retry yields a complete company sync", async () => {
+        let entityCalls = 0;
+        vi.stubGlobal("fetch", vi.fn(async (url) => {
+            const u = String(url);
+            if (u.includes(`/entity/${entity.uid}`)) {
+                entityCalls += 1;
+                if (entityCalls === 1) {
+                    return new Response(JSON.stringify({ message: "Too Many Requests" }), {
+                        status: 429,
+                    });
+                }
+                return new Response(JSON.stringify({ entity }), { status: 200 });
+            }
+            if (u.includes("/sts/vend")) {
+                return new Response(JSON.stringify(vend), { status: 200 });
+            }
+            return new Response("Not found", { status: 404 });
+        }));
+        const emptyPull = {
+            filesDownloaded: 0,
+            bytesDownloaded: 0,
+            filesSkipped: 0,
+            conflicts: 0,
+            conflictPaths: [],
+            aborted: false,
+            newFiles: [],
+            newFilesCount: 0,
+            filesExcludedByPolicy: 0,
+            filesTombstoned: 0,
+            filesOutOfScope: 0,
+            scopeOrphansRemoved: 0,
+            scopeOrphansBlocked: 0,
+            changedPaths: [],
+        };
+        const { result, events } = await runIndigoPull(async (opts) => {
+            await resolveEntityContext(opts.company ?? entity.uid, opts.vaultConfig);
+            return emptyPull;
+        });
+        expect(entityCalls).toBe(2);
+        expect(result.errors).toEqual([]);
+        expect(result.transientCompanies).toEqual([]);
+        expect(result.stateByCompany.get("indigo")?.status).toBe("complete");
+        expect(events.some((e) => e.type === "error")).toBe(false);
+        expect(events.some((e) => e.type === "transient-network")).toBe(false);
+    });
+});
 describe("executeCompanyFanout — mid-pass identity refusal (HQ-DESKTOP-5S)", () => {
     // A mid-pass Cognito refusal surfaces from the leg (share.ts/sync.ts now
     // rethrow it instead of recording a per-file error). personalMode avoids the
@@ -1361,4 +1470,152 @@ describe("executeCompanyFanout — a company-skill 409 never aborts the leg (HQ-
         expect(parseRegisteredCompanySkillUid(fs.readFileSync(skillFile, "utf8"))).toBe("skl_SOURCE1");
     });
 });
+describe("executeCompanyFanout — personal vault skips journaled company dirs", () => {
+    const shareResult = {
+        filesUploaded: 0,
+        bytesUploaded: 0,
+        filesSkipped: 0,
+        filesDeleted: 0,
+        filesTombstoned: 0,
+        filesRefusedStale: 0,
+        filesRefusedStalePaths: [],
+        filesSuppressedByTombstone: 0,
+        filesExcludedByPolicy: 0,
+        filesExcludedByScope: 0,
+        filesExcludedByIgnore: 0,
+        unreachablePaths: [],
+        linkedSubtreesNotShipped: [],
+        conflictPaths: [],
+        aborted: false,
+    };
+    const syncResult = {
+        filesDownloaded: 0,
+        bytesDownloaded: 0,
+        filesSkipped: 0,
+        conflicts: 0,
+        conflictPaths: [],
+        aborted: false,
+        newFiles: [],
+        newFilesCount: 0,
+        filesExcludedByPolicy: 0,
+        filesTombstoned: 0,
+        filesOutOfScope: 0,
+        scopeOrphansRemoved: 0,
+        scopeOrphansBlocked: 0,
+        changedPaths: [],
+    };
+    let hqRoot;
+    let stateDir;
+    let previousStateDir;
+    beforeEach(() => {
+        hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-fanout-journal-slugs-"));
+        stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-fanout-journal-state-"));
+        previousStateDir = process.env.HQ_STATE_DIR;
+        process.env.HQ_STATE_DIR = stateDir;
+        fs.mkdirSync(path.join(hqRoot, "personal"), { recursive: true });
+    });
+    afterEach(() => {
+        fs.rmSync(hqRoot, { recursive: true, force: true });
+        fs.rmSync(stateDir, { recursive: true, force: true });
+        if (previousStateDir === undefined)
+            delete process.env.HQ_STATE_DIR;
+        else
+            process.env.HQ_STATE_DIR = previousStateDir;
+    });
+    function writeCompanyDir(slug) {
+        fs.mkdirSync(path.join(hqRoot, "companies", slug), { recursive: true });
+    }
+    function writeJournalLocator(slug) {
+        fs.writeFileSync(path.join(stateDir, `sync-journal.${slug}.json`), JSON.stringify({ schema: "hq-sync-journal-locator@1" }));
+    }
+    function relSharePaths(shareFn) {
+        const call = shareFn.mock.calls[0];
+        expect(call).toBeDefined();
+        return call[0].paths.map((p) => path.relative(hqRoot, p)).sort();
+    }
+    async function runPersonalBoth(shareFn = vi.fn(async (_options) => shareResult), syncFn = vi.fn(async (_options) => syncResult)) {
+        const events = [];
+        await executeCompanyFanout({
+            plan: [{ uid: "prs_1", slug: "personal", personalMode: true }],
+            direction: "both",
+            hqRoot,
+            onConflict: "abort",
+            client: {},
+            vaultConfig: { apiUrl: "https://api.example", authToken: "access-token" },
+            fetchFileTombstones: async () => new Map(),
+            syncFn,
+            shareFn,
+            resolveDeletePolicy: () => "all",
+            emit: (event) => events.push(event),
+            ensureCompanyDir: vi.fn(),
+            telemetryClient: null,
+        });
+        return { events, shareFn, syncFn };
+    }
+    it("excludes companies/dandy from the personal push when its sync journal exists and there is no manifest", async () => {
+        writeCompanyDir("dandy");
+        writeJournalLocator("dandy");
+        const { events, shareFn, syncFn } = await runPersonalBoth();
+        const rel = relSharePaths(shareFn);
+        expect(rel).not.toContain(path.join("companies", "dandy"));
+        expect(rel).toContain("personal");
+        const shareArgs = shareFn.mock.calls[0][0];
+        expect(shareArgs.decommissionPrefixes).toEqual(["companies/dandy"]);
+        const pullArgs = syncFn.mock.calls[0][0];
+        expect(Array.from(pullArgs.teamSyncedSlugs ?? [])).toEqual(["dandy"]);
+        expect(events).toContainEqual({
+            type: "error",
+            diagnostic: true,
+            company: "personal",
+            path: "(personal-vault)",
+            message: "excluding journaled companies from personal vault: dandy",
+        });
+        expect(events.some((e) => e.type === "error" && e.diagnostic !== true)).toBe(false);
+    });
+    it("still includes a local-only company that has no journal when there is no manifest", async () => {
+        writeCompanyDir("local-only");
+        const { events, shareFn, syncFn } = await runPersonalBoth();
+        const rel = relSharePaths(shareFn);
+        expect(rel).toContain(path.join("companies", "local-only"));
+        expect(shareFn.mock.calls[0][0]).not.toHaveProperty("decommissionPrefixes");
+        expect(Array.from(syncFn.mock.calls[0][0].teamSyncedSlugs ?? [])).toEqual([]);
+        expect(events.some((e) => e.type === "error")).toBe(false);
+    });
+    it("does not treat the personal-vault sentinel journal as a company slug", async () => {
+        writeCompanyDir("local-only");
+        writeJournalLocator(PERSONAL_VAULT_JOURNAL_SLUG);
+        const { events, shareFn, syncFn } = await runPersonalBoth();
+        const rel = relSharePaths(shareFn);
+        expect(rel).toContain(path.join("companies", "local-only"));
+        expect(shareFn.mock.calls[0][0]).not.toHaveProperty("decommissionPrefixes");
+        expect(Array.from(syncFn.mock.calls[0][0].teamSyncedSlugs ?? [])).toEqual([]);
+        expect(events.some((e) => e.type === "error")).toBe(false);
+    });
+    it("does not pass journal-derived teamSyncedSlugs to a company target", async () => {
+        writeCompanyDir("dandy");
+        writeJournalLocator("dandy");
+        const shareFn = vi.fn(async (_options) => shareResult);
+        const syncFn = vi.fn(async (_options) => syncResult);
+        await executeCompanyFanout({
+            plan: [{ uid: "cmp_dandy", slug: "dandy" }],
+            direction: "both",
+            hqRoot,
+            onConflict: "abort",
+            client: {},
+            vaultConfig: { apiUrl: "https://api.example", authToken: "access-token" },
+            fetchFileTombstones: async () => new Map(),
+            syncFn,
+            shareFn,
+            resolveDeletePolicy: () => "all",
+            emit: vi.fn(),
+            ensureCompanyDir: vi.fn(),
+            telemetryClient: null,
+        });
+        expect(shareFn.mock.calls[0][0].paths).toEqual([
+            path.join(hqRoot, "companies", "dandy"),
+        ]);
+        expect(shareFn.mock.calls[0][0]).not.toHaveProperty("decommissionPrefixes");
+        expect(Object.keys(syncFn.mock.calls[0][0])).not.toContain("teamSyncedSlugs");
+    });
+});
 //# sourceMappingURL=sync-runner-company.test.js.map