@indigoai-us/hq-cloud 6.18.44-alpha.48 → 6.18.44-alpha.49

package/dist/outcome-telemetry.test.js

@@ -0,0 +1,663 @@
+/**
+ * Tests for the outcome-event collector (outcome-leaderboard US-004).
+ *
+ * The vault client is stubbed structurally (the production boundary is
+ * `OutcomeTelemetryClientSurface`, not the HTTP layer), and a real temp HQ root
+ * with `companies/manifest.yaml` + prd.json/board.json fixtures drives the scan.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { promises as fsp } from "fs";
+import * as os from "os";
+import * as path from "path";
+import { collectAndSendOutcomeTelemetry, extractStoryTransitions, extractProjectTransitions, toWireRow, isDoneStatus, wireRowRejectReason, MAX_FIELD_CHARS, MAX_EVENT_BYTES, } from "./outcome-telemetry.js";
+function makeClient(opts = {}) {
+    const optInResponse = opts.optInResponse ?? { enabled: true, updatedAt: null };
+    const postResponse = opts.postResponse ?? { ok: true, written: 0, deduped: 0 };
+    const posts = [];
+    return {
+        posts,
+        optInCalls: 0,
+        async getTelemetryOptIn() {
+            this.optInCalls++;
+            if (optInResponse instanceof Error)
+                throw optInResponse;
+            return optInResponse;
+        },
+        async postOutcomeEvents(batch) {
+            posts.push(batch);
+            if (postResponse instanceof Error)
+                throw postResponse;
+            return postResponse;
+        },
+    };
+}
+// ── HQ-root fixture ─────────────────────────────────────────────────────────
+const COMPANY_UID = "cmp_01TESTCOMPANY0000000000000";
+async function makeHqRoot() {
+    const root = await fsp.mkdtemp(path.join(os.tmpdir(), "outcome-hq-"));
+    const companies = path.join(root, "companies");
+    await fsp.mkdir(companies, { recursive: true });
+    await fsp.writeFile(path.join(companies, "manifest.yaml"), [
+        "companies:",
+        "  acme:",
+        "    name: Acme",
+        "    path: companies/acme",
+        "    repos: []",
+        `    cloud_uid: ${COMPANY_UID}`,
+        // A second company with NO cloud_uid — its projects must be skipped.
+        "  local-only:",
+        "    name: Local Only",
+        "    path: companies/local-only",
+        "    repos: []",
+        "",
+    ].join("\n"), "utf-8");
+    return root;
+}
+async function writePrd(root, slug, project, prd) {
+    const dir = path.join(root, "companies", slug, "projects", project);
+    await fsp.mkdir(dir, { recursive: true });
+    const p = path.join(dir, "prd.json");
+    await fsp.writeFile(p, JSON.stringify(prd), "utf-8");
+    return p;
+}
+async function writeBoard(root, slug, board) {
+    const dir = path.join(root, "companies", slug);
+    await fsp.mkdir(dir, { recursive: true });
+    const p = path.join(dir, "board.json");
+    await fsp.writeFile(p, JSON.stringify(board), "utf-8");
+    return p;
+}
+// ── Suite ──────────────────────────────────────────────────────────────────
+describe("isDoneStatus", () => {
+    it("matches done/completed/shipped/complete case-insensitively", () => {
+        for (const s of ["done", "completed", "Shipped", "COMPLETE", " done "]) {
+            expect(isDoneStatus(s)).toBe(true);
+        }
+    });
+    it("rejects non-done statuses and non-strings", () => {
+        for (const s of ["in_progress", "prd_created", "archived", "", undefined, 3, null]) {
+            expect(isDoneStatus(s)).toBe(false);
+        }
+    });
+});
+describe("extractStoryTransitions (false→true detection + allowlist)", () => {
+    it("emits ONLY stories whose passes === true", () => {
+        const prd = {
+            name: "my-project",
+            description: "should not leak",
+            userStories: [
+                { id: "US-001", passes: true, notes: "secret", acceptanceCriteria: ["x"] },
+                { id: "US-002", passes: false },
+                { id: "US-003" }, // no passes → not complete
+                { id: "US-004", passes: "true" }, // string, not boolean → not complete
+            ],
+        };
+        const ts = extractStoryTransitions(prd, COMPANY_UID);
+        expect(ts.map((t) => t.storyId)).toEqual(["US-001"]);
+        expect(ts[0]).toEqual({
+            type: "story-completed",
+            companyUid: COMPANY_UID,
+            projectName: "my-project",
+            storyId: "US-001",
+            dedupeKey: `${COMPANY_UID}#my-project#US-001`,
+        });
+    });
+    it("skips a prd with no project name and one with no userStories", () => {
+        expect(extractStoryTransitions({ userStories: [{ id: "US-1", passes: true }] }, COMPANY_UID)).toEqual([]);
+        expect(extractStoryTransitions({ name: "p" }, COMPANY_UID)).toEqual([]);
+        expect(extractStoryTransitions(null, COMPANY_UID)).toEqual([]);
+    });
+});
+describe("extractProjectTransitions (→done detection)", () => {
+    it("emits only done-status projects, titled by title||id", () => {
+        const board = {
+            projects: [
+                { id: "p1", title: "Alpha", status: "done", description: "leak?" },
+                { id: "p2", title: "Beta", status: "in_progress" },
+                { id: "p3", status: "completed" }, // no title → falls back to id
+            ],
+        };
+        const ts = extractProjectTransitions(board, COMPANY_UID);
+        expect(ts.map((t) => t.projectName)).toEqual(["Alpha", "p3"]);
+        expect(ts[0].dedupeKey).toBe(`${COMPANY_UID}#Alpha`);
+        expect(ts[0].storyId).toBeUndefined();
+    });
+});
+describe("toWireRow (transmits nothing beyond name/id/transition — allowlist proof)", () => {
+    const ctx = { occurredAt: "2026-07-29T00:00:00.000Z", repo: "hq", branch: "main" };
+    it("story-completed carries exactly the allowlisted fields", () => {
+        const row = toWireRow({
+            type: "story-completed",
+            companyUid: COMPANY_UID,
+            projectName: "proj",
+            storyId: "US-9",
+            dedupeKey: `${COMPANY_UID}#proj#US-9`,
+        }, ctx);
+        expect(new Set(Object.keys(row))).toEqual(new Set(["type", "occurredAt", "companyUid", "repo", "branch", "dedupeKey", "projectName", "storyId"]));
+        expect(row).toMatchObject({ type: "story-completed", storyId: "US-9", projectName: "proj" });
+        // Defense-in-depth: never leak a person identifier or any content field.
+        expect(row).not.toHaveProperty("personUid");
+        expect(row).not.toHaveProperty("acceptanceCriteria");
+        expect(row).not.toHaveProperty("notes");
+        expect(row).not.toHaveProperty("description");
+    });
+    it("project-shipped carries NO storyId", () => {
+        const row = toWireRow({ type: "project-shipped", companyUid: COMPANY_UID, projectName: "proj", dedupeKey: `${COMPANY_UID}#proj` }, ctx);
+        expect(new Set(Object.keys(row))).toEqual(new Set(["type", "occurredAt", "companyUid", "repo", "branch", "dedupeKey", "projectName"]));
+        expect(row).not.toHaveProperty("storyId");
+    });
+});
+describe("wireRowRejectReason (local ingest-limit guard — Fix 2)", () => {
+    const base = {
+        type: "story-completed",
+        occurredAt: "2026-07-29T00:00:00.000Z",
+        companyUid: COMPANY_UID,
+        repo: "hq",
+        branch: "main",
+        dedupeKey: `${COMPANY_UID}#p#US-1`,
+        projectName: "p",
+        storyId: "US-1",
+    };
+    it("accepts a normal row", () => {
+        expect(wireRowRejectReason({ ...base })).toBeNull();
+    });
+    it("rejects a row whose string field exceeds the char limit", () => {
+        const reason = wireRowRejectReason({ ...base, projectName: "x".repeat(MAX_FIELD_CHARS + 1) });
+        expect(reason).toContain("projectName");
+        expect(reason).toContain(String(MAX_FIELD_CHARS));
+    });
+    it("rejects a row whose serialized size exceeds the byte limit", () => {
+        // Two just-under-field-limit strings still push the event JSON over 4 KB.
+        const big = "y".repeat(MAX_FIELD_CHARS);
+        const reason = wireRowRejectReason({ ...base, projectName: big, storyId: big });
+        expect(reason).toContain(String(MAX_EVENT_BYTES));
+    });
+});
+describe("collectAndSendOutcomeTelemetry", () => {
+    let root;
+    let cursorPath;
+    let menubarPath;
+    beforeEach(async () => {
+        root = await makeHqRoot();
+        const dot = await fsp.mkdtemp(path.join(os.tmpdir(), "outcome-dot-"));
+        cursorPath = path.join(dot, "outcome-telemetry-cursor.json");
+        menubarPath = path.join(dot, "menubar.json");
+    });
+    afterEach(async () => {
+        await fsp.rm(root, { recursive: true, force: true });
+    });
+    it("opt-in gate: emits nothing when telemetry is disabled", async () => {
+        await writePrd(root, "acme", "p", { name: "p", userStories: [{ id: "US-1", passes: true }] });
+        const client = makeClient({ optInResponse: { enabled: false, updatedAt: null } });
+        const res = await collectAndSendOutcomeTelemetry({ client, hqRoot: root, cursorPath, menubarPath });
+        expect(res.enabled).toBe(false);
+        expect(client.posts).toHaveLength(0);
+        // Cursor is not written when disabled.
+        await expect(fsp.readFile(cursorPath, "utf-8")).rejects.toBeTruthy();
+    });
+    it("forceCollect ships outcomes even when personal opt-in is false", async () => {
+        await writePrd(root, "acme", "p", { name: "p", userStories: [{ id: "US-1", passes: true }] });
+        const client = makeClient({ optInResponse: { enabled: false, updatedAt: null } });
+        const res = await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            forceCollect: true,
+        });
+        expect(client.optInCalls).toBe(0);
+        expect(res.enabled).toBe(true);
+        expect(res.optInSource).toBe("agent-required");
+        expect(res.eventsSent).toBe(1);
+    });
+    it("opt-in gate: falls back to local menubar.json when the server check throws", async () => {
+        await writePrd(root, "acme", "p", { name: "p", userStories: [{ id: "US-1", passes: true }] });
+        await fsp.writeFile(menubarPath, JSON.stringify({ telemetryEnabled: true }), "utf-8");
+        const client = makeClient({ optInResponse: new Error("network") });
+        const res = await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            now: () => "2026-07-29T00:00:00.000Z",
+        });
+        expect(res.optInSource).toBe("menubar-fallback");
+        expect(res.eventsSent).toBe(1);
+    });
+    it("emits a story-completed event for a passing story and a project-shipped event for a done board project", async () => {
+        await writePrd(root, "acme", "outcome-leaderboard", {
+            name: "outcome-leaderboard",
+            userStories: [
+                { id: "US-002", passes: true },
+                { id: "US-003", passes: false },
+            ],
+        });
+        await writeBoard(root, "acme", {
+            projects: [
+                { id: "in-proj-1", title: "Shipped Thing", status: "done" },
+                { id: "in-proj-2", title: "WIP", status: "in_progress" },
+            ],
+        });
+        const client = makeClient();
+        const res = await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            now: () => "2026-07-29T00:00:00.000Z",
+        });
+        expect(res.eventsSent).toBe(2);
+        expect(client.posts).toHaveLength(1);
+        const events = client.posts[0].events;
+        const byType = Object.fromEntries(events.map((e) => [e.type, e]));
+        expect(byType["story-completed"]).toMatchObject({
+            projectName: "outcome-leaderboard",
+            storyId: "US-002",
+            companyUid: COMPANY_UID,
+            dedupeKey: `${COMPANY_UID}#outcome-leaderboard#US-002`,
+        });
+        expect(byType["project-shipped"]).toMatchObject({
+            projectName: "Shipped Thing",
+            companyUid: COMPANY_UID,
+            dedupeKey: `${COMPANY_UID}#Shipped Thing`,
+        });
+    });
+    it("emits done-state stories with their valid non-future update timestamp when the hq-flags gate is on", async () => {
+        await writePrd(root, "acme", "p", {
+            name: "p",
+            userStories: [{ id: "US-DONE", state: "DONE", updated_at: "2026-10-01T08:30:00.000Z" }],
+        });
+        const client = makeClient();
+        const res = await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            now: () => "2026-10-02T12:00:00.000Z",
+            isStoryDoneStateEnabled: async (uid, slug) => uid === COMPANY_UID && slug === "acme",
+        });
+        expect(res.eventsSent).toBe(1);
+        expect(client.posts[0].events[0]).toMatchObject({
+            type: "story-completed",
+            occurredAt: "2026-10-01T08:30:00.000Z",
+            dedupeKey: `${COMPANY_UID}#p#US-DONE`,
+            storyId: "US-DONE",
+        });
+    });
+    it("keeps detection time for passes-based completions when the done-state flag is on", async () => {
+        await writePrd(root, "acme", "p", {
+            name: "p",
+            userStories: [{
+                    id: "US-PASSES-OLD-UPDATE",
+                    passes: true,
+                    state: "in_progress",
+                    updated_at: "2026-09-01T08:30:00.000Z",
+                }],
+        });
+        const client = makeClient();
+        await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            now: () => "2026-10-02T12:00:00.000Z",
+            isStoryDoneStateEnabled: async () => true,
+        });
+        expect(client.posts[0].events[0]).toMatchObject({
+            dedupeKey: `${COMPANY_UID}#p#US-PASSES-OLD-UPDATE`,
+            occurredAt: "2026-10-02T12:00:00.000Z",
+        });
+    });
+    it("posts passes and board outcomes within one shared timeout when many company flag reads never resolve", async () => {
+        const otherUids = [
+            "cmp_02TESTCOMPANY0000000000000",
+            "cmp_03TESTCOMPANY0000000000000",
+            "cmp_04TESTCOMPANY0000000000000",
+        ];
+        await fsp.writeFile(path.join(root, "companies", "manifest.yaml"), [
+            "companies:",
+            "  acme:",
+            "    name: Acme",
+            "    path: companies/acme",
+            "    repos: []",
+            `    cloud_uid: ${COMPANY_UID}`,
+            ...otherUids.flatMap((uid, index) => [
+                `  team-${index}:`,
+                `    name: Team ${index}`,
+                `    path: companies/team-${index}`,
+                "    repos: []",
+                `    cloud_uid: ${uid}`,
+            ]),
+            "  local-only:",
+            "    name: Local Only",
+            "    path: companies/local-only",
+            "    repos: []",
+            "",
+        ].join("\n"), "utf-8");
+        await Promise.all(otherUids.map((_uid, index) => fsp.mkdir(path.join(root, "companies", `team-${index}`), { recursive: true })));
+        await writePrd(root, "acme", "p", {
+            name: "p",
+            userStories: [
+                { id: "US-PASSES", passes: true },
+                { id: "US-DONE", state: "done" },
+            ],
+        });
+        await writeBoard(root, "acme", { projects: [{ id: "shipped", title: "Shipped", status: "done" }] });
+        const client = makeClient();
+        const calls = [];
+        let allStarted;
+        const allCallsStarted = new Promise((resolve) => { allStarted = resolve; });
+        const startedAt = Date.now();
+        const collection = collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            forceCollect: true,
+            now: () => "2026-10-02T12:00:00.000Z",
+            isStoryDoneStateEnabled: async (_uid, slug) => {
+                calls.push(slug);
+                if (calls.length === 4)
+                    allStarted();
+                return new Promise(() => { });
+            },
+        });
+        await allCallsStarted;
+        const res = await collection;
+        expect(Date.now() - startedAt).toBeLessThan(6_000);
+        expect(calls).toHaveLength(4);
+        expect(client.posts).toHaveLength(1);
+        expect(res.eventsSent).toBe(2);
+        expect(client.posts[0].events.map((event) => event.type).sort()).toEqual([
+            "project-shipped",
+            "story-completed",
+        ]);
+        expect(client.posts[0].events.map((event) => event.dedupeKey)).not.toContain(`${COMPANY_UID}#p#US-DONE`);
+    }, 8_000);
+    it("uses detection time when a done story timestamp is invalid or in the future", async () => {
+        await writePrd(root, "acme", "p", {
+            name: "p",
+            userStories: [{
+                    id: "US-FUTURE",
+                    status: "completed",
+                    updated_at: "2026-10-03T08:30:00.000Z",
+                    completed_at: "not-a-date",
+                }],
+        });
+        const client = makeClient();
+        await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            now: () => "2026-10-02T12:00:00.000Z",
+            isStoryDoneStateEnabled: async () => true,
+        });
+        expect(client.posts[0].events[0].occurredAt).toBe("2026-10-02T12:00:00.000Z");
+    });
+    it("reads a legacy stories array when the done-state hq-flags gate is on", async () => {
+        await writePrd(root, "acme", "legacy", {
+            name: "legacy",
+            stories: [{ id: "US-LEGACY", status: "complete" }],
+        });
+        const client = makeClient();
+        const res = await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            now: () => "2026-10-02T12:00:00.000Z",
+            isStoryDoneStateEnabled: async () => true,
+        });
+        expect(res.eventsSent).toBe(1);
+        expect(client.posts[0].events[0]).toMatchObject({
+            type: "story-completed",
+            dedupeKey: `${COMPANY_UID}#legacy#US-LEGACY`,
+        });
+    });
+    it("does not complete dropped or waiting stories through state/status", async () => {
+        await writePrd(root, "acme", "p", {
+            name: "p",
+            userStories: [
+                { id: "US-DROPPED", state: "dropped" },
+                { id: "US-WAITING", status: "Waiting" },
+                { id: "US-REVIEW", state: "review" },
+            ],
+        });
+        const client = makeClient();
+        const res = await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            isStoryDoneStateEnabled: async () => true,
+        });
+        expect(res.eventsSent).toBe(0);
+        expect(client.posts).toHaveLength(0);
+    });
+    it("keeps the existing dedupe key for passes-true stories while the new gate is on", async () => {
+        await writePrd(root, "acme", "p", {
+            name: "p",
+            userStories: [{ id: "US-PASSES", passes: true, state: "done" }],
+        });
+        const client = makeClient();
+        await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            now: () => "2026-10-02T12:00:00.000Z",
+            isStoryDoneStateEnabled: async () => true,
+        });
+        expect(client.posts[0].events[0]).toMatchObject({
+            dedupeKey: `${COMPANY_UID}#p#US-PASSES`,
+            occurredAt: "2026-10-02T12:00:00.000Z",
+        });
+    });
+    it("keeps origin behavior when the done-state hq-flags gate is off", async () => {
+        await writePrd(root, "acme", "p", {
+            name: "p",
+            userStories: [
+                { id: "US-DONE", state: "done" },
+                { id: "US-OLD", passes: true, state: "in_progress" },
+            ],
+            stories: [{ id: "US-LEGACY", passes: true }],
+        });
+        const client = makeClient();
+        const res = await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            now: () => "2026-10-02T12:00:00.000Z",
+            isStoryDoneStateEnabled: async () => false,
+        });
+        expect(res.eventsSent).toBe(1);
+        expect(client.posts[0].events.map((event) => event.dedupeKey)).toEqual([
+            `${COMPANY_UID}#p#US-OLD`,
+        ]);
+        expect(client.posts[0].events[0].occurredAt).toBe("2026-10-02T12:00:00.000Z");
+    });
+    it("applies the done-state flag for forceCollect agent syncs", async () => {
+        await writePrd(root, "acme", "p", {
+            name: "p",
+            userStories: [{ id: "US-AGENT", state: "done" }],
+        });
+        const client = makeClient({ optInResponse: { enabled: false, updatedAt: null } });
+        const res = await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            forceCollect: true,
+            now: () => "2026-10-02T12:00:00.000Z",
+            isStoryDoneStateEnabled: async (uid, slug) => uid === COMPANY_UID && slug === "acme",
+        });
+        expect(client.optInCalls).toBe(0);
+        expect(res.optInSource).toBe("agent-required");
+        expect(res.eventsSent).toBe(1);
+        expect(client.posts[0].events[0].dedupeKey).toBe(`${COMPANY_UID}#p#US-AGENT`);
+    });
+    it("skips projects belonging to a company that is not cloud-backed", async () => {
+        await writePrd(root, "local-only", "p", { name: "p", userStories: [{ id: "US-1", passes: true }] });
+        const client = makeClient();
+        const res = await collectAndSendOutcomeTelemetry({ client, hqRoot: root, cursorPath, menubarPath });
+        expect(res.eventsSent).toBe(0);
+        expect(client.posts).toHaveLength(0);
+    });
+    it("cursor persistence + dedupe: a second sync with no new transition emits nothing", async () => {
+        await writePrd(root, "acme", "p", { name: "p", userStories: [{ id: "US-1", passes: true }] });
+        const c1 = makeClient();
+        const r1 = await collectAndSendOutcomeTelemetry({ client: c1, hqRoot: root, cursorPath, menubarPath });
+        expect(r1.eventsSent).toBe(1);
+        // Cursor was written and records the emitted transition (confirmed, with a
+        // pinned occurredAt and no lingering `pending` flag).
+        const cursor = JSON.parse(await fsp.readFile(cursorPath, "utf-8"));
+        const entry = cursor.emitted[`${COMPANY_UID}#p#US-1`];
+        expect(entry.type).toBe("story-completed");
+        expect(typeof entry.occurredAt).toBe("string");
+        expect(entry.occurredAt.length).toBeGreaterThan(0);
+        expect(entry.pending).toBeUndefined();
+        const c2 = makeClient();
+        const r2 = await collectAndSendOutcomeTelemetry({ client: c2, hqRoot: root, cursorPath, menubarPath });
+        expect(r2.eventsSent).toBe(0);
+        expect(c2.posts).toHaveLength(0);
+    });
+    it("dedupe within a single scan: the same completion in two files emits one event", async () => {
+        // Two prd.json with the SAME project name + story id → identical dedupeKey.
+        await writePrd(root, "acme", "a", { name: "dup", userStories: [{ id: "US-1", passes: true }] });
+        await writePrd(root, "acme", "b", { name: "dup", userStories: [{ id: "US-1", passes: true }] });
+        const client = makeClient();
+        const res = await collectAndSendOutcomeTelemetry({ client, hqRoot: root, cursorPath, menubarPath });
+        expect(res.eventsSent).toBe(1);
+    });
+    it("emits a NEW event only after a false→true transition on the second sync", async () => {
+        const prdPath = await writePrd(root, "acme", "p", {
+            name: "p",
+            userStories: [{ id: "US-1", passes: false }],
+        });
+        const c1 = makeClient();
+        const r1 = await collectAndSendOutcomeTelemetry({ client: c1, hqRoot: root, cursorPath, menubarPath });
+        expect(r1.eventsSent).toBe(0);
+        // Flip the story to passing, then sync again.
+        await fsp.writeFile(prdPath, JSON.stringify({ name: "p", userStories: [{ id: "US-1", passes: true }] }), "utf-8");
+        const c2 = makeClient();
+        const r2 = await collectAndSendOutcomeTelemetry({ client: c2, hqRoot: root, cursorPath, menubarPath });
+        expect(r2.eventsSent).toBe(1);
+        expect(c2.posts[0].events[0]).toMatchObject({ type: "story-completed", storyId: "US-1" });
+    });
+    it("swallows a POST error and leaves the cursor un-advanced so the row re-sends", async () => {
+        await writePrd(root, "acme", "p", { name: "p", userStories: [{ id: "US-1", passes: true }] });
+        const failing = makeClient({ postResponse: new Error("boom") });
+        // Must not throw — telemetry never blocks sync.
+        const res = await collectAndSendOutcomeTelemetry({ client: failing, hqRoot: root, cursorPath, menubarPath });
+        expect(res.eventsSent).toBe(0);
+        // Cursor did not record the failed transition, so a healthy sync re-sends it.
+        const healthy = makeClient();
+        const res2 = await collectAndSendOutcomeTelemetry({ client: healthy, hqRoot: root, cursorPath, menubarPath });
+        expect(res2.eventsSent).toBe(1);
+    });
+    it("stable replay timestamp: a re-sent transition reuses the ORIGINAL occurredAt (Fix 1)", async () => {
+        await writePrd(root, "acme", "p", { name: "p", userStories: [{ id: "US-1", passes: true }] });
+        // Sync 1: POST succeeds server-side but we simulate the cursor CONFIRM being
+        // lost — the post-flush cursor write records the entry as `pending` (as if
+        // the process died between POST-success and the final confirm-flush). We
+        // achieve this by using a client that throws AFTER capturing the batch, so
+        // the transition stays `pending` in the cursor with its pinned occurredAt.
+        let call = 0;
+        const client = {
+            posts: [],
+            async getTelemetryOptIn() {
+                return { enabled: true, updatedAt: null };
+            },
+            async postOutcomeEvents(batch) {
+                this.posts.push(batch);
+                call++;
+                // First call: capture the batch but throw, so the cursor stays pending
+                // with its pinned occurredAt (server may or may not have written it —
+                // the emitter must send the SAME occurredAt on retry either way).
+                if (call === 1)
+                    throw new Error("cursor-confirm-lost");
+                return { ok: true, written: 0, deduped: 1 };
+            },
+        };
+        let clock = 1000;
+        const r1 = await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            now: () => new Date(clock).toISOString(),
+        });
+        expect(r1.eventsSent).toBe(0); // POST threw
+        const firstOccurredAt = client.posts[0].events[0].occurredAt;
+        expect(typeof firstOccurredAt).toBe("string");
+        // The cursor pinned the occurredAt before the POST.
+        const pinned = JSON.parse(await fsp.readFile(cursorPath, "utf-8"));
+        const entry = pinned.emitted[`${COMPANY_UID}#p#US-1`];
+        expect(entry.pending).toBe(true);
+        expect(entry.occurredAt).toBe(firstOccurredAt);
+        // Sync 2: clock has advanced, but the re-send MUST reuse the pinned
+        // occurredAt — otherwise the server stores a duplicate row under a new key.
+        clock = 999999;
+        const r2 = await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            now: () => new Date(clock).toISOString(),
+        });
+        expect(r2.eventsSent).toBe(1);
+        const secondOccurredAt = client.posts[1].events[0].occurredAt;
+        expect(secondOccurredAt).toBe(firstOccurredAt); // SAME timestamp, not the advanced clock
+        // Now confirmed (no longer pending).
+        const confirmed = JSON.parse(await fsp.readFile(cursorPath, "utf-8"));
+        const confEntry = confirmed.emitted[`${COMPANY_UID}#p#US-1`];
+        expect(confEntry.pending).toBeUndefined();
+        expect(confEntry.occurredAt).toBe(firstOccurredAt);
+    });
+    it("oversized field poisons nothing: valid events in the batch still send, over-limit one is skipped (Fix 2)", async () => {
+        const huge = "x".repeat(MAX_FIELD_CHARS + 1);
+        // One prd whose project name is over the field limit (its story is valid but
+        // the projectName is on every wire row → the row is rejected wholesale), and
+        // one perfectly valid prd. The valid one must still send.
+        await writePrd(root, "acme", "bad", {
+            name: huge,
+            userStories: [{ id: "US-1", passes: true }],
+        });
+        await writePrd(root, "acme", "good", {
+            name: "good-project",
+            userStories: [{ id: "US-2", passes: true }],
+        });
+        const skips = [];
+        const client = makeClient();
+        const res = await collectAndSendOutcomeTelemetry({
+            client,
+            hqRoot: root,
+            cursorPath,
+            menubarPath,
+            now: () => "2026-07-29T00:00:00.000Z",
+            log: (m) => skips.push(m),
+        });
+        // Exactly the valid outcome went out; the oversized one was dropped.
+        expect(res.eventsSent).toBe(1);
+        expect(client.posts).toHaveLength(1);
+        const ids = client.posts[0].events.map((e) => e.storyId);
+        expect(ids).toEqual(["US-2"]);
+        // The skip was logged.
+        expect(skips.some((m) => m.includes("skipping") && m.includes("US-1"))).toBe(true);
+        // The skipped transition is NOT confirmed in the cursor (so if the field is
+        // later fixed it can send), and the valid one IS.
+        const cursor = JSON.parse(await fsp.readFile(cursorPath, "utf-8"));
+        expect(cursor.emitted[`${COMPANY_UID}#good-project#US-2`].type).toBe("story-completed");
+        expect(cursor.emitted[`${COMPANY_UID}#${huge}#US-1`]).toBeUndefined();
+    });
+    it("no hqRoot → no scan, no events (but opt-in still resolved)", async () => {
+        const client = makeClient();
+        const res = await collectAndSendOutcomeTelemetry({ client, cursorPath, menubarPath });
+        expect(res.enabled).toBe(true);
+        expect(res.eventsSent).toBe(0);
+        expect(client.posts).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=outcome-telemetry.test.js.map