@indigoai-us/hq-cloud 6.18.44-alpha.9 → 6.18.44

package/dist/outcome-telemetry.test.js

@@ -1,663 +0,0 @@
-/**
- * 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