@indigoai-us/hq-cloud 6.15.0 → 6.15.2

package/src/outcome-telemetry.test.ts

@@ -1,498 +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,
-  type OutcomeTelemetryClientSurface,
-} from "./outcome-telemetry.js";
-import type {
-  OutcomeEventsBatch,
-  OutcomeEventsIngestResult,
-  TelemetryOptInResponse,
-} from "./vault-client.js";
-
-// ── Test stubs ────────────────────────────────────────────────────────────────
-
-interface StubClient extends OutcomeTelemetryClientSurface {
-  posts: OutcomeEventsBatch[];
-  optInCalls: number;
-}
-
-function makeClient(
-  opts: {
-    optInResponse?: TelemetryOptInResponse | Error;
-    postResponse?: OutcomeEventsIngestResult | Error;
-  } = {},
-): StubClient {
-  const optInResponse = opts.optInResponse ?? { enabled: true, updatedAt: null };
-  const postResponse = opts.postResponse ?? { ok: true, written: 0, deduped: 0 };
-  const posts: OutcomeEventsBatch[] = [];
-  return {
-    posts,
-    optInCalls: 0,
-    async getTelemetryOptIn() {
-      this.optInCalls++;
-      if (optInResponse instanceof Error) throw optInResponse;
-      return optInResponse;
-    },
-    async postOutcomeEvents(batch: OutcomeEventsBatch) {
-      posts.push(batch);
-      if (postResponse instanceof Error) throw postResponse;
-      return postResponse;
-    },
-  };
-}
-
-// ── HQ-root fixture ─────────────────────────────────────────────────────────
-
-const COMPANY_UID = "cmp_01TESTCOMPANY0000000000000";
-
-async function makeHqRoot(): Promise<string> {
-  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: string,
-  slug: string,
-  project: string,
-  prd: unknown,
-): Promise<string> {
-  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: string, slug: string, board: unknown): Promise<string> {
-  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: string;
-  let cursorPath: string;
-  let menubarPath: string;
-
-  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("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("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: OutcomeTelemetryClientSurface & { posts: OutcomeEventsBatch[] } = {
-      posts: [],
-      async getTelemetryOptIn() {
-        return { enabled: true, updatedAt: null };
-      },
-      async postOutcomeEvents(batch: OutcomeEventsBatch) {
-        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: string[] = [];
-    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);
-  });
-});