@indigoai-us/hq-cloud 6.14.17 → 6.14.18

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

@@ -22,6 +22,8 @@ import { PARTIAL_SYNC_EXIT } from "../lib/exit-codes.js";
 import { isCoveredByAny } from "../prefix-coalesce.js";
 import { VaultAuthError, VaultNotFoundError } from "../vault-client.js";
 import { CognitoRefreshError } from "../cognito-auth.js";
+import { reconcileCompanyManifest, } from "../manifest-reconcile.js";
+import yaml from "js-yaml";
 // ---------------------------------------------------------------------------
 // Hermetic journal state — the runner now calls migratePersonalVaultJournal()
 // on every --companies fanout (one-time seed of the reserved vault journal
@@ -153,7 +155,9 @@ function makeDeps(overrides = {}) {
             embedded: false,
             pendingDirty: false,
         })),
-        reconcileManifest: vi.fn().mockResolvedValue(undefined),
+        reconcileManifest: vi
+            .fn()
+            .mockResolvedValue({ written: false, added: [], updated: [], skipped: [] }),
         ...overrides,
         stdout,
         stderr,
@@ -196,7 +200,9 @@ describe("argv parsing", () => {
         const code = await runRunner(["--companies", "--json"], deps);
         expect(code).toBe(0);
         // Empty memberships → setup-needed, not a parse error
-        expect(deps.stdout.events()).toEqual([{ type: "setup-needed" }]);
+        expect(deps.stdout.events()).toEqual([
+            { type: "setup-needed", reason: "no-memberships" },
+        ]);
     });
 });
 // ---------------------------------------------------------------------------
@@ -499,7 +505,67 @@ describe("claim-dance", () => {
         expect(ensureSpy).not.toHaveBeenCalled();
         expect(claimSpy).not.toHaveBeenCalled();
         // No memberships, no invites — truly empty → setup-needed is correct here.
-        expect(deps.stdout.events()).toEqual([{ type: "setup-needed" }]);
+        expect(deps.stdout.events()).toEqual([
+            { type: "setup-needed", reason: "no-memberships" },
+        ]);
+    });
+    // The michelle@boringecom.com shape: an invite exists, the claim attempt does
+    // not convert it into a membership, and the user is told they are solo. The
+    // count is what turns "you have no team" into "you have an invite to accept".
+    it("US-004: carries pendingInviteCount when invites did not become memberships", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({
+                pendingInvites: [{ uid: "inv_1" }, { uid: "inv_2" }],
+                ensurePerson: vi
+                    .fn()
+                    .mockResolvedValue({ uid: "ent_person" }),
+                claim: vi
+                    .fn()
+                    .mockResolvedValue(undefined),
+            }),
+            getIdTokenClaims: () => claims,
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        expect(deps.stdout.events()).toEqual([
+            { type: "setup-needed", reason: "no-memberships", pendingInviteCount: 2 },
+        ]);
+    });
+    it("US-004: omits pendingInviteCount entirely when there were no invites", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({ pendingInvites: [] }),
+            getIdTokenClaims: () => claims,
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        const [event] = deps.stdout.events();
+        expect(event).toEqual({ type: "setup-needed", reason: "no-memberships" });
+        expect("pendingInviteCount" in event).toBe(false);
+    });
+    it("US-004: reports claim-dance skipped as a diagnostic, not a bare stderr line", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({
+                pendingInvites: [{ uid: "inv_1" }],
+                ensurePerson: vi
+                    .fn()
+                    .mockRejectedValue(new Error("BatchWriteItem denied")),
+            }),
+            getIdTokenClaims: () => claims,
+        });
+        // Non-throwing by contract: the failure never changes the exit code...
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        // ...but it is no longer invisible.
+        expect(deps.stderr.raw()).toContain("runner.claim_dance.skipped");
+    });
+    it("US-004: a claim-dance that cannot identify the caller still reports the pending invites", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({ pendingInvites: [{ uid: "inv_1" }] }),
+            // No sub/name — the claim cannot proceed, but the invites are still real.
+            getIdTokenClaims: () => ({}),
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        expect(deps.stdout.events()).toEqual([
+            { type: "setup-needed", reason: "no-memberships", pendingInviteCount: 1 },
+        ]);
+        expect(deps.stderr.raw()).toContain("runner.claim_dance.skipped");
     });
     it("skips claim-dance entirely when no idToken claims are available", async () => {
         const pendingSpy = vi.fn().mockResolvedValue([]);
@@ -569,7 +635,9 @@ describe("target resolution", () => {
         const deps = makeDeps();
         const code = await runRunner(["--companies"], deps);
         expect(code).toBe(0);
-        expect(deps.stdout.events()).toEqual([{ type: "setup-needed" }]);
+        expect(deps.stdout.events()).toEqual([
+            { type: "setup-needed", reason: "no-memberships" },
+        ]);
         // sync should NOT have been called — no targets
         expect(deps.sync).not.toHaveBeenCalled();
     });
@@ -856,7 +924,11 @@ describe("fanout-plan", () => {
         const plan = deps.stdout
             .events()
             .find((e) => e.type === "fanout-plan");
-        expect(plan.companies).toEqual([{ uid: "cmp_live", slug: "live" }]);
+        // The surviving target now also carries the plan-time entity snapshot the
+        // manifest reconciler reads instead of re-fetching (US-002).
+        expect(plan.companies).toEqual([
+            { uid: "cmp_live", slug: "live", entityType: "company", entityStatus: "active" },
+        ]);
     });
     it("reconciles after the personal leg completes", async () => {
         const order = [];
@@ -887,6 +959,7 @@ describe("fanout-plan", () => {
             }),
             reconcileManifest: vi.fn().mockImplementation(async () => {
                 order.push("reconcile");
+                return { written: false, added: [], updated: [], skipped: [] };
             }),
         });
         expect(await runRunner(["--companies"], deps)).toBe(0);
@@ -5342,4 +5415,283 @@ describe("US-004 — --personal for an AGENT machine identity (HARD GATE)", () =
         expect(cmp(HQ_CLOUD_VERSION, FLOOR)).toBeGreaterThanOrEqual(0);
     });
 });
+// ---------------------------------------------------------------------------
+// US-002 — post-fanout manifest reconciliation wiring
+//
+// The reconciler itself is unit-tested in manifest-reconcile.test.ts. These
+// tests own the SEAM: which run modes reach it, which targets cross it, and
+// what the runner does with the result it hands back.
+// ---------------------------------------------------------------------------
+describe("US-002 — manifest reconciliation wiring", () => {
+    const PERSON_ENTITY = {
+        uid: "prs_me",
+        slug: "me",
+        type: "person",
+        status: "active",
+        bucketName: "hq-vault-prs-me",
+        createdAt: "2026-01-01T00:00:00Z",
+    };
+    function noopReconcileResult() {
+        return { written: false, added: [], updated: [], skipped: [] };
+    }
+    /** A vault stub whose companies all resolve to `cmp_x` → slug `x`. */
+    function companiesClient(companyUids) {
+        return makeVaultStub({
+            memberships: companyUids.map((companyUid) => ({ companyUid })),
+            entityGet: (uid) => Promise.resolve({
+                uid,
+                slug: uid.replace(/^cmp_/, ""),
+                name: `${uid} Inc`,
+                type: "company",
+                status: "active",
+                bucketName: `bucket-${uid}`,
+                createdAt: "2026-01-01T00:00:00Z",
+            }),
+            listPersons: () => Promise.resolve([PERSON_ENTITY]),
+        });
+    }
+    function reconcileArgs(reconcile) {
+        return reconcile.mock.calls[0][0];
+    }
+    /** Diagnostics ride stderr as ndjson; pick out the manifest ones. */
+    function manifestDiagnostics(stderr) {
+        return stderr
+            .lines()
+            .flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        })
+            .filter((entry) => entry.component === "manifest-reconcile");
+    }
+    it("AC2: an errored company is not eligible — only the completing company is", async () => {
+        const reconcile = vi.fn().mockResolvedValue(noopReconcileResult());
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_ok", "cmp_bad"]),
+            sync: vi.fn().mockImplementation(async (options) => {
+                if (options.company === "cmp_bad")
+                    throw new Error("pull leg exploded");
+                return defaultSyncResult();
+            }),
+            reconcileManifest: reconcile,
+        });
+        await runRunner(["--companies"], deps);
+        expect(reconcile).toHaveBeenCalledTimes(1);
+        const args = reconcileArgs(reconcile);
+        // The completion filter is `completedCompanySlugs`; assert the EFFECTIVE
+        // eligible set, which is what actually reaches the manifest.
+        const eligible = args.targets.filter((target) => args.completedCompanySlugs.has(target.slug));
+        expect(eligible.map((target) => target.slug)).toEqual(["ok"]);
+        expect(args.completedCompanySlugs.has("bad")).toBe(false);
+    });
+    it("AC3: the personal target is never passed to the reconciler", async () => {
+        const reconcile = vi.fn().mockResolvedValue(noopReconcileResult());
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            reconcileManifest: reconcile,
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        const args = reconcileArgs(reconcile);
+        // The personal leg definitely ran — otherwise this assertion is vacuous.
+        const plan = deps.stdout
+            .events()
+            .find((e) => e.type === "fanout-plan");
+        expect(plan.companies.map((t) => t.slug)).toContain("personal");
+        expect(args.targets.map((target) => target.slug)).toEqual(["acme"]);
+        expect(args.targets.some((target) => target.personalMode === true)).toBe(false);
+        expect(args.targets.some((target) => target.slug === "personal")).toBe(false);
+    });
+    it("AC4: --personal mode does not reconcile", async () => {
+        const reconcile = vi.fn().mockResolvedValue(noopReconcileResult());
+        const deps = makeDeps({
+            createVaultClient: () => makeVaultStub({ listPersons: () => Promise.resolve([PERSON_ENTITY]) }),
+            reconcileManifest: reconcile,
+        });
+        expect(await runRunner(["--personal"], deps)).toBe(0);
+        expect(reconcile).not.toHaveBeenCalled();
+    });
+    it("AC4: single-company mode (--company <slug>) does not reconcile", async () => {
+        const reconcile = vi.fn().mockResolvedValue(noopReconcileResult());
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            reconcileManifest: reconcile,
+        });
+        expect(await runRunner(["--company", "cmp_acme"], deps)).toBe(0);
+        expect(reconcile).not.toHaveBeenCalled();
+    });
+    it("AC5: company targets carry the plan-resolved bucketName, so no getEntity is passed", async () => {
+        const reconcile = vi.fn().mockResolvedValue(noopReconcileResult());
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            reconcileManifest: reconcile,
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        const args = reconcileArgs(reconcile);
+        expect(args.targets[0]).toMatchObject({
+            uid: "cmp_acme",
+            slug: "acme",
+            name: "cmp_acme Inc",
+            bucketName: "bucket-cmp_acme",
+            // Liveness evidence travels with the target. Dropping the round trip
+            // must not drop the guarantee it used to provide.
+            entityType: "company",
+            entityStatus: "active",
+        });
+        // Zero extra API calls: the runner hands over no entity resolver at all.
+        expect(args.getEntity).toBeUndefined();
+    });
+    it("END-TO-END: a suspended company completes its sync leg but never reaches the manifest", async () => {
+        // Exercises the REAL reconciler through the runner — no stub — because the
+        // defect this guards was invisible to every stubbed assertion.
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), "hq-runner-manifest-"));
+        try {
+            fs.mkdirSync(path.join(root, "companies", "live"), { recursive: true });
+            fs.mkdirSync(path.join(root, "companies", "susp"), { recursive: true });
+            const manifestPath = path.join(root, "companies", "manifest.yaml");
+            fs.writeFileSync(manifestPath, "companies: {}\n");
+            const deps = makeDeps({
+                createVaultClient: () => makeVaultStub({
+                    memberships: [{ companyUid: "cmp_live" }, { companyUid: "cmp_susp" }],
+                    entityGet: (uid) => Promise.resolve({
+                        uid,
+                        slug: uid === "cmp_live" ? "live" : "susp",
+                        type: "company",
+                        // The suspended company is still a perfectly syncable target.
+                        status: uid === "cmp_live" ? "active" : "suspended",
+                        bucketName: `bucket-${uid}`,
+                        createdAt: "2026-01-01T00:00:00Z",
+                    }),
+                    listPersons: () => Promise.resolve([PERSON_ENTITY]),
+                }),
+                // The REAL reconciler, not the makeDeps stub — that stub is exactly
+                // what let this defect hide from every other assertion here.
+                reconcileManifest: reconcileCompanyManifest,
+            });
+            expect(await runRunner(["--companies", "--hq-root", root], deps)).toBe(0);
+            // Both companies synced (the guard must not have leaked into sync).
+            const syncedCompanies = deps.sync.mock.calls
+                .map((call) => call[0].company)
+                .filter(Boolean);
+            expect(syncedCompanies).toContain("cmp_live");
+            expect(syncedCompanies).toContain("cmp_susp");
+            // ...but only the active one earned a manifest entry.
+            const written = yaml.load(fs.readFileSync(manifestPath, "utf8"));
+            expect(Object.keys(written.companies ?? {})).toEqual(["live"]);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("US-003: seeds activeCompany from the completed company set", async () => {
+        const seed = vi.fn().mockReturnValue({ written: true, activeCompany: "acme" });
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            seedActiveCompany: seed,
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        expect(seed).toHaveBeenCalledTimes(1);
+        expect(seed.mock.calls[0][0]).toMatchObject({ companySlugs: ["acme"] });
+        expect(deps.stderr.raw()).toContain("active-company-seeded");
+    });
+    it("US-003: the personal target is never offered as an activeCompany candidate", async () => {
+        const seed = vi.fn().mockReturnValue({ written: false, skippedReason: "already-set" });
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            seedActiveCompany: seed,
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        expect(seed.mock.calls[0][0].companySlugs).not.toContain("personal");
+    });
+    // The two writes are independent repairs. A joiner whose manifest write fails
+    // should still get routed, and vice versa.
+    it("US-003: a failing manifest reconcile does not prevent activeCompany seeding", async () => {
+        const seed = vi.fn().mockReturnValue({ written: true, activeCompany: "acme" });
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            reconcileManifest: vi.fn().mockRejectedValue(new Error("manifest write blew up")),
+            seedActiveCompany: seed,
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        expect(deps.stderr.raw()).toContain("runner.manifest_reconcile.failed");
+        expect(seed).toHaveBeenCalledTimes(1);
+    });
+    it("US-003: a throwing seeder still emits all-complete and exits 0", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            seedActiveCompany: vi.fn().mockImplementation(() => {
+                throw new Error("config write blew up");
+            }),
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        expect(deps.stdout.events().some((e) => e.type === "all-complete")).toBe(true);
+        expect(deps.stderr.raw()).toContain("runner.active_company.failed");
+    });
+    it("US-003: a no-op seeding is silent", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            seedActiveCompany: vi
+                .fn()
+                .mockReturnValue({ written: false, skippedReason: "already-set" }),
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        expect(deps.stderr.raw()).not.toContain("active-company-seeded");
+    });
+    it("US-003: single-company mode does not seed activeCompany", async () => {
+        const seed = vi.fn();
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            seedActiveCompany: seed,
+        });
+        await runRunner(["--company", "acme"], deps);
+        expect(seed).not.toHaveBeenCalled();
+    });
+    it("AC6: a throwing reconciler still emits all-complete and exits 0", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            reconcileManifest: vi
+                .fn()
+                .mockRejectedValue(new Error("manifest write blew up")),
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        expect(deps.stdout.events().some((e) => e.type === "all-complete")).toBe(true);
+        expect(deps.stderr.raw()).toContain("runner.manifest_reconcile.failed");
+    });
+    it("AC7: a write emits a manifest-reconciled diagnostic naming the slugs", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            reconcileManifest: vi.fn().mockResolvedValue({
+                written: true,
+                added: ["acme"],
+                updated: ["beta"],
+                skipped: [],
+            }),
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        const diagnostics = manifestDiagnostics(deps.stderr);
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatchObject({
+            component: "manifest-reconcile",
+            event: "manifest-reconciled",
+            added: ["acme"],
+            updated: ["beta"],
+        });
+    });
+    it("AC7: a no-op reconciliation is completely silent (steady-state sync)", async () => {
+        const deps = makeDeps({
+            createVaultClient: () => companiesClient(["cmp_acme"]),
+            reconcileManifest: vi.fn().mockResolvedValue({
+                written: false,
+                added: [],
+                updated: [],
+                skipped: ["weird-slug"],
+            }),
+        });
+        expect(await runRunner(["--companies"], deps)).toBe(0);
+        expect(manifestDiagnostics(deps.stderr)).toEqual([]);
+        expect(deps.stderr.raw()).not.toContain("manifest-reconciled");
+    });
+});
 //# sourceMappingURL=sync-runner.test.js.map