@indigoai-us/hq-cli 5.77.13 → 5.78.0

package/src/commands/dm.test.ts

@@ -1,748 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-  type MockInstance,
-} from "vitest";
-
-// Stub ensureCognitoToken so the action handlers run without keychain/disk I/O.
-vi.mock("../utils/cognito-session.js", async (importOriginal) => {
-  const original = (await importOriginal()) as Record<string, unknown>;
-  return {
-    ...original,
-    ensureCognitoToken: vi.fn(async () => "test-token"),
-  };
-});
-
-import { Command } from "commander";
-import chalk from "chalk";
-import {
-  detectRecipient,
-  parseDuration,
-  parseGroupRecipients,
-  buildDmBody,
-  matchRequest,
-  buildConnectionActionBody,
-  registerDmCommand,
-  channelSlug,
-  parseChannelName,
-  matchChannelsByName,
-  senderLabel,
-  formatRelativeTime,
-  isUnread,
-  unreadEventIds,
-  filterUnread,
-  firstLine,
-  buildThreadQuery,
-  formatInboxEvent,
-  formatThreadMessage,
-  type ConnectionRequest,
-  type ChannelSummary,
-  type DmInboxEvent,
-} from "./dm.js";
-
-describe("parseGroupRecipients", () => {
-  it("returns null with no comma (the 1:1 path)", () => {
-    expect(parseGroupRecipients("a@x.com")).toBeNull();
-    expect(parseGroupRecipients("prs_1")).toBeNull();
-  });
-  it("splits, trims, and de-dupes a comma list", () => {
-    expect(parseGroupRecipients("a@x.com, b@y.com ,a@x.com")).toEqual([
-      "a@x.com",
-      "b@y.com",
-    ]);
-  });
-});
-
-describe("channelSlug", () => {
-  it("mirrors the server: lowercases, hyphenates, trims", () => {
-    expect(channelSlug("vyg-dev")).toBe("vyg-dev");
-    expect(channelSlug("VYG Dev!!")).toBe("vyg-dev");
-    expect(channelSlug("  --Team  Room--  ")).toBe("team-room");
-  });
-});
-
-describe("parseChannelName", () => {
-  it("treats a bare non-email/uid token as a channel name", () => {
-    expect(parseChannelName("vyg-dev")).toBe("vyg-dev");
-    expect(parseChannelName("  design  ")).toBe("design");
-  });
-  it("strips a leading # (hash-channel form)", () => {
-    expect(parseChannelName("#vyg-dev")).toBe("vyg-dev");
-    expect(parseChannelName("#")).toBeNull();
-  });
-  it("returns null for person paths and group lists", () => {
-    expect(parseChannelName("a@b.com")).toBeNull();
-    expect(parseChannelName("prs_01ABC")).toBeNull();
-    expect(parseChannelName("agt_01ABC")).toBeNull();
-    expect(parseChannelName("a@x.com,b@y.com")).toBeNull();
-    expect(parseChannelName("")).toBeNull();
-  });
-});
-
-describe("matchChannelsByName", () => {
-  const channels: ChannelSummary[] = [
-    { channelId: "chn_1", name: "VYG Dev", slug: "vyg-dev", scope: "company" },
-    { channelId: "chn_2", name: "Design", slug: "design", scope: "personal" },
-    { channelId: "chn_grp", scope: "group", memberCount: 2 },
-  ];
-  it("matches a named channel by slug (case/punctuation-insensitive)", () => {
-    expect(matchChannelsByName(channels, "vyg-dev").map((c) => c.channelId)).toEqual([
-      "chn_1",
-    ]);
-    expect(matchChannelsByName(channels, "VYG Dev").map((c) => c.channelId)).toEqual([
-      "chn_1",
-    ]);
-  });
-  it("never matches an unnamed group DM", () => {
-    expect(matchChannelsByName(channels, "chn_grp")).toEqual([]);
-    expect(matchChannelsByName(channels, "")).toEqual([]);
-  });
-  it("returns every match so an ambiguous name can be detected", () => {
-    const dup: ChannelSummary[] = [
-      { channelId: "a", name: "ops", slug: "ops", scope: "personal" },
-      { channelId: "b", name: "Ops", slug: "ops", scope: "company" },
-    ];
-    expect(matchChannelsByName(dup, "ops").map((c) => c.channelId)).toEqual(["a", "b"]);
-  });
-});
-
-describe("detectRecipient", () => {
-  it("classifies an email", () => {
-    expect(detectRecipient("Stefan@Getindigo.ai")).toEqual({
-      toEmail: "stefan@getindigo.ai",
-    });
-  });
-  it("classifies a personUid", () => {
-    expect(detectRecipient("prs_01ABC")).toEqual({ toPersonUid: "prs_01ABC" });
-  });
-  it("classifies an agentUid on the same wire field (server accepts agt_*)", () => {
-    expect(detectRecipient("agt_01KTT1RJJ6KQRHNHHST0K4VRGT")).toEqual({
-      toPersonUid: "agt_01KTT1RJJ6KQRHNHHST0K4VRGT",
-    });
-  });
-  it("rejects anything else", () => {
-    expect(detectRecipient("not-an-email")).toBeNull();
-    expect(detectRecipient("")).toBeNull();
-    expect(detectRecipient("cmp_01ABC")).toBeNull();
-    expect(detectRecipient("agt")).toBeNull();
-  });
-});
-
-describe("parseDuration", () => {
-  it("parses units", () => {
-    expect(parseDuration("30s")).toBe(30_000);
-    expect(parseDuration("10m")).toBe(600_000);
-    expect(parseDuration("2h")).toBe(7_200_000);
-    expect(parseDuration("1d")).toBe(86_400_000);
-    expect(parseDuration(" 5m ")).toBe(300_000);
-  });
-  it("returns null on garbage", () => {
-    expect(parseDuration("soon")).toBeNull();
-    expect(parseDuration("10")).toBeNull();
-    expect(parseDuration("10x")).toBeNull();
-  });
-});
-
-describe("buildDmBody", () => {
-  const now = Date.parse("2026-05-29T00:00:00.000Z");
-
-  it("builds an email DM with body", () => {
-    expect(
-      buildDmBody({ recipient: "a@b.com", message: "  hi  ", now }),
-    ).toEqual({ toEmail: "a@b.com", body: "hi" });
-  });
-
-  it("includes prompt + details when present, omits when blank", () => {
-    expect(
-      buildDmBody({
-        recipient: "prs_x",
-        message: "m",
-        prompt: "do the thing",
-        details: "  ",
-        now,
-      }),
-    ).toEqual({ toPersonUid: "prs_x", body: "m", prompt: "do the thing" });
-  });
-
-  it("builds an agent DM (agt_* rides toPersonUid)", () => {
-    expect(
-      buildDmBody({ recipient: "agt_01ABC", message: "status?", now }),
-    ).toEqual({ toPersonUid: "agt_01ABC", body: "status?" });
-  });
-
-  it("resolves --in to a future deliverAt", () => {
-    const out = buildDmBody({ recipient: "a@b.com", message: "m", inDelay: "10m", now });
-    expect(out.deliverAt).toBe("2026-05-29T00:10:00.000Z");
-  });
-
-  it("resolves --at to a normalized ISO deliverAt", () => {
-    const out = buildDmBody({
-      recipient: "a@b.com",
-      message: "m",
-      at: "2026-06-01T12:00:00Z",
-      now,
-    });
-    expect(out.deliverAt).toBe("2026-06-01T12:00:00.000Z");
-  });
-
-  it("rejects an invalid recipient", () => {
-    expect(() => buildDmBody({ recipient: "nope", message: "m", now })).toThrow(/Invalid recipient/);
-  });
-
-  it("requires a body", () => {
-    expect(() => buildDmBody({ recipient: "a@b.com", message: "   ", now })).toThrow(/body is required/);
-  });
-
-  it("rejects both --at and --in", () => {
-    expect(() =>
-      buildDmBody({ recipient: "a@b.com", message: "m", at: "2026-06-01T12:00:00Z", inDelay: "10m", now }),
-    ).toThrow(/only one of --at or --in/);
-  });
-
-  it("rejects an invalid --at and --in", () => {
-    expect(() => buildDmBody({ recipient: "a@b.com", message: "m", at: "nope", now })).toThrow(/Invalid --at/);
-    expect(() => buildDmBody({ recipient: "a@b.com", message: "m", inDelay: "soon", now })).toThrow(/Invalid --in/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// matchRequest (pure)
-// ---------------------------------------------------------------------------
-
-const SAMPLE_REQUESTS: ConnectionRequest[] = [
-  {
-    pairKey: "pair_abc",
-    fromPersonUid: "prs_alice",
-    fromDisplayName: "Alice",
-    fromEmail: "alice@example.com",
-    message: "hey, lets connect",
-    createdAt: "2026-06-01T00:00:00.000Z",
-  },
-  {
-    pairKey: "pair_def",
-    fromPersonUid: "prs_bob",
-    fromDisplayName: "Bob",
-    fromEmail: "Bob@Example.com",
-  },
-];
-
-describe("matchRequest", () => {
-  it("matches by email case-insensitively", () => {
-    expect(matchRequest(SAMPLE_REQUESTS, "ALICE@example.com")?.pairKey).toBe("pair_abc");
-    expect(matchRequest(SAMPLE_REQUESTS, "bob@example.com")?.pairKey).toBe("pair_def");
-  });
-  it("matches by personUid", () => {
-    expect(matchRequest(SAMPLE_REQUESTS, "prs_bob")?.pairKey).toBe("pair_def");
-  });
-  it("matches by pairKey", () => {
-    expect(matchRequest(SAMPLE_REQUESTS, "pair_abc")?.fromPersonUid).toBe("prs_alice");
-  });
-  it("returns null when nothing matches", () => {
-    expect(matchRequest(SAMPLE_REQUESTS, "nobody@example.com")).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// buildConnectionActionBody (pure)
-// ---------------------------------------------------------------------------
-
-describe("buildConnectionActionBody", () => {
-  it("prefers the matched request's pairKey", () => {
-    expect(buildConnectionActionBody("alice@example.com", SAMPLE_REQUESTS[0])).toEqual({
-      pairKey: "pair_abc",
-    });
-  });
-  it("falls back to withPersonUid for an unmatched prs_ id", () => {
-    expect(buildConnectionActionBody("prs_zed", null)).toEqual({ withPersonUid: "prs_zed" });
-  });
-  it("falls back to withEmail for an unmatched email", () => {
-    expect(buildConnectionActionBody("Stranger@Example.com", null)).toEqual({
-      withEmail: "stranger@example.com",
-    });
-  });
-  it("throws on an unresolvable identifier", () => {
-    expect(() => buildConnectionActionBody("not-an-id", null)).toThrow(/Could not resolve/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Action handlers (HTTP/auth mocked)
-// ---------------------------------------------------------------------------
-
-describe("senderLabel", () => {
-  it("prefers display name, then email, then uid", () => {
-    expect(
-      senderLabel({ fromDisplayName: "Jonathan", fromEmail: "j@x.com", fromPersonUid: "prs_1" }),
-    ).toBe("Jonathan");
-    expect(senderLabel({ fromEmail: "j@x.com", fromPersonUid: "prs_1" })).toBe("j@x.com");
-    expect(senderLabel({ fromPersonUid: "prs_1" })).toBe("prs_1");
-    expect(senderLabel({})).toBe("unknown");
-  });
-});
-
-describe("formatRelativeTime", () => {
-  const now = Date.parse("2026-07-16T12:00:00.000Z");
-  it("renders sub-minute as 'just now'", () => {
-    expect(formatRelativeTime("2026-07-16T11:59:30.000Z", now)).toBe("just now");
-  });
-  it("renders minutes, hours, and days", () => {
-    expect(formatRelativeTime("2026-07-16T11:57:00.000Z", now)).toBe("3m ago");
-    expect(formatRelativeTime("2026-07-16T10:00:00.000Z", now)).toBe("2h ago");
-    expect(formatRelativeTime("2026-07-11T12:00:00.000Z", now)).toBe("5d ago");
-  });
-  it("falls back to a date for anything older than a week", () => {
-    expect(formatRelativeTime("2026-06-01T09:00:00.000Z", now)).toBe("2026-06-01");
-  });
-  it("echoes an unparseable input", () => {
-    expect(formatRelativeTime("not-a-date", now)).toBe("not-a-date");
-  });
-});
-
-describe("isUnread / unreadEventIds / filterUnread", () => {
-  const events: DmInboxEvent[] = [
-    { eventId: "a", body: "x", createdAt: "2026-07-16T11:00:00.000Z" },
-    {
-      eventId: "b",
-      body: "y",
-      createdAt: "2026-07-16T11:30:00.000Z",
-      acknowledgedAt: "2026-07-16T11:31:00.000Z",
-    },
-  ];
-  it("treats a message with no acknowledgedAt as unread", () => {
-    expect(isUnread(events[0])).toBe(true);
-    expect(isUnread(events[1])).toBe(false);
-  });
-  it("collects unread event ids", () => {
-    expect(unreadEventIds(events)).toEqual(["a"]);
-  });
-  it("filters to unread only", () => {
-    expect(filterUnread(events).map((e) => e.eventId)).toEqual(["a"]);
-  });
-});
-
-describe("firstLine", () => {
-  it("collapses whitespace to a single trimmed line", () => {
-    expect(firstLine("  hello\n  world  \t there ")).toBe("hello world there");
-  });
-  it("truncates with an ellipsis past the cap", () => {
-    const out = firstLine("abcdefghij", 5);
-    expect(out).toBe("abcd…");
-    expect(out.length).toBe(5);
-  });
-});
-
-describe("buildThreadQuery", () => {
-  it("routes an email through withEmail (lowercased)", () => {
-    expect(buildThreadQuery("Jonathan@GetIndigo.ai")).toEqual({
-      withEmail: "jonathan@getindigo.ai",
-    });
-  });
-  it("routes a personUid / agentUid through withPersonUid", () => {
-    expect(buildThreadQuery("prs_123")).toEqual({ withPersonUid: "prs_123" });
-    expect(buildThreadQuery("agt_123")).toEqual({ withPersonUid: "agt_123" });
-  });
-  it("rejects a bare name", () => {
-    expect(() => buildThreadQuery("Jonathan")).toThrow(/Resolve a name first/);
-  });
-});
-
-describe("format helpers (rendering)", () => {
-  beforeEach(() => {
-    chalk.level = 0; // plain text so assertions read the rendered content
-  });
-  const now = Date.parse("2026-07-16T12:00:00.000Z");
-  it("marks an unread inbox row with a bullet and shows the sender + body", () => {
-    const row = formatInboxEvent(
-      {
-        eventId: "e1",
-        fromDisplayName: "Jonathan Bach",
-        fromEmail: "jonathan@getindigo.ai",
-        body: "grp_jb_agent is created",
-        createdAt: "2026-07-16T11:57:00.000Z",
-      },
-      now,
-    );
-    expect(row).toContain("●");
-    expect(row).toContain("Jonathan Bach");
-    expect(row).toContain("<jonathan@getindigo.ai>");
-    expect(row).toContain("3m ago");
-    expect(row).toContain("grp_jb_agent is created");
-  });
-  it("tags thread direction: outgoing as 'you', incoming by sender", () => {
-    const out = formatThreadMessage(
-      { eventId: "o", body: "hey", createdAt: "2026-07-16T11:00:00.000Z", direction: "out" },
-      now,
-    );
-    expect(out).toContain("→");
-    expect(out).toContain("you");
-    const inbound = formatThreadMessage(
-      {
-        eventId: "i",
-        fromDisplayName: "Jonathan",
-        body: "thanks",
-        createdAt: "2026-07-16T11:30:00.000Z",
-        direction: "in",
-      },
-      now,
-    );
-    expect(inbound).toContain("←");
-    expect(inbound).toContain("Jonathan");
-  });
-});
-
-function jsonResponse(status: number, body: unknown): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}
-
-describe("dm command actions", () => {
-  let fetchSpy: MockInstance<typeof fetch>;
-  let exitSpy: MockInstance<typeof process.exit>;
-  let logSpy: MockInstance<typeof console.log>;
-  let errSpy: MockInstance<typeof console.error>;
-  let program: Command;
-
-  beforeEach(() => {
-    fetchSpy = vi.spyOn(globalThis, "fetch");
-    exitSpy = vi.spyOn(process, "exit").mockImplementation(((code?: number) => {
-      throw new Error(`__EXIT__:${code ?? 0}`);
-    }) as never);
-    logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
-    errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
-    program = new Command();
-    registerDmCommand(program);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  function logged(): string {
-    return logSpy.mock.calls.map((c) => String(c[0])).join("\n");
-  }
-
-  it("send: prints delivered on 200", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(200, { eventId: "evt_1" }));
-    await program.parseAsync(["dm", "alice@example.com", "hi there"], { from: "user" });
-    const url = String(fetchSpy.mock.calls[0][0]);
-    expect(url).toContain("/v1/notify/dm");
-    expect(logged()).toMatch(/DM sent to alice@example.com/);
-    expect(errSpy).not.toHaveBeenCalled();
-  });
-
-  it("group send: a comma recipient creates a group then posts the message", async () => {
-    fetchSpy
-      .mockResolvedValueOnce(
-        jsonResponse(200, { channel: { channelId: "chn_grp1" }, created: true }),
-      )
-      .mockResolvedValueOnce(jsonResponse(200, { eventId: "evt_g" }));
-    await program.parseAsync(
-      ["dm", "alice@example.com,bob@example.com", "hey team"],
-      { from: "user" },
-    );
-    // 1st call creates the group channel...
-    const createCall = fetchSpy.mock.calls[0];
-    expect(String(createCall[0])).toContain("/v1/notify/channels");
-    const createBody = JSON.parse((createCall[1]?.body as string) ?? "{}");
-    expect(createBody.scope).toBe("group");
-    expect(createBody.participants).toEqual(["alice@example.com", "bob@example.com"]);
-    // ...2nd posts the message into it.
-    const sendCall = fetchSpy.mock.calls[1];
-    expect(String(sendCall[0])).toContain("/v1/notify/channels/chn_grp1/messages");
-    expect(JSON.parse((sendCall[1]?.body as string) ?? "{}").body).toBe("hey team");
-    expect(logged()).toMatch(/Group DM sent to 2 people \(new group\)\./);
-    expect(errSpy).not.toHaveBeenCalled();
-  });
-
-  it("group send: a single recipient still uses the 1:1 dm path", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(200, { eventId: "evt_1" }));
-    await program.parseAsync(["dm", "alice@example.com", "hi"], { from: "user" });
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/notify/dm");
-  });
-
-  const channelsPayload = {
-    channels: [
-      { channelId: "chn_v", name: "VYG Dev", slug: "vyg-dev", scope: "company" },
-      { channelId: "chn_grp", scope: "group", memberCount: 2 },
-    ],
-  };
-
-  it("channel send (bare name): resolves the channel then posts the message", async () => {
-    fetchSpy
-      .mockResolvedValueOnce(jsonResponse(200, channelsPayload)) // GET channels
-      .mockResolvedValueOnce(jsonResponse(200, { eventId: "evt_c" })); // POST message
-    await program.parseAsync(["dm", "vyg-dev", "hello channel"], { from: "user" });
-    // 1st call lists the caller's channels...
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/notify/channels");
-    // ...2nd posts into the resolved channel id.
-    const sendCall = fetchSpy.mock.calls[1];
-    expect(String(sendCall[0])).toContain("/v1/notify/channels/chn_v/messages");
-    expect(JSON.parse((sendCall[1]?.body as string) ?? "{}").body).toBe("hello channel");
-    expect(logged()).toMatch(/Message posted to #VYG Dev\./);
-    expect(errSpy).not.toHaveBeenCalled();
-  });
-
-  it("channel send (#hash form) resolves the same channel", async () => {
-    fetchSpy
-      .mockResolvedValueOnce(jsonResponse(200, channelsPayload))
-      .mockResolvedValueOnce(jsonResponse(200, { eventId: "evt_c" }));
-    await program.parseAsync(["dm", "#vyg-dev", "yo"], { from: "user" });
-    expect(String(fetchSpy.mock.calls[1][0])).toContain("/v1/notify/channels/chn_v/messages");
-    expect(errSpy).not.toHaveBeenCalled();
-  });
-
-  it("channel send (--channel flag) takes the message from the positional", async () => {
-    fetchSpy
-      .mockResolvedValueOnce(jsonResponse(200, channelsPayload))
-      .mockResolvedValueOnce(jsonResponse(200, { eventId: "evt_c" }));
-    await program.parseAsync(["dm", "--channel", "vyg-dev", "flagged hello"], {
-      from: "user",
-    });
-    const sendCall = fetchSpy.mock.calls[1];
-    expect(String(sendCall[0])).toContain("/v1/notify/channels/chn_v/messages");
-    expect(JSON.parse((sendCall[1]?.body as string) ?? "{}").body).toBe("flagged hello");
-    expect(errSpy).not.toHaveBeenCalled();
-  });
-
-  it("channel send: unknown name errors and never posts", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(200, channelsPayload));
-    await program
-      .parseAsync(["dm", "nope-channel", "hi"], { from: "user" })
-      .catch(() => undefined); // process.exit is mocked to throw
-    expect(errSpy.mock.calls.map((c) => String(c[1] ?? c[0])).join("\n")).toMatch(
-      /No channel named 'nope-channel'/,
-    );
-    // Only the GET happened — no message POST.
-    expect(fetchSpy.mock.calls).toHaveLength(1);
-  });
-
-  it("channel send: an ambiguous name errors and never posts", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, {
-        channels: [
-          { channelId: "a", name: "ops", slug: "ops", scope: "personal" },
-          { channelId: "b", name: "Ops", slug: "ops", scope: "company" },
-        ],
-      }),
-    );
-    await program
-      .parseAsync(["dm", "ops", "hi"], { from: "user" })
-      .catch(() => undefined);
-    expect(errSpy.mock.calls.map((c) => String(c[0])).join("\n")).toMatch(/ambiguous/);
-    expect(fetchSpy.mock.calls).toHaveLength(1);
-  });
-
-  it("send: prints pending request on 202 connection_requested (not an error)", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(202, { state: "connection_requested" }),
-    );
-    await program.parseAsync(["dm", "stranger@example.com", "hello"], { from: "user" });
-    expect(logged()).toMatch(/Request sent — pending stranger@example\.com's acceptance\./);
-    // 202 is a success, not an error path.
-    expect(exitSpy).not.toHaveBeenCalled();
-    expect(errSpy).not.toHaveBeenCalled();
-  });
-
-  it("requests: lists pending incoming requests with identifiers", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, { requests: SAMPLE_REQUESTS }),
-    );
-    await program.parseAsync(["dm", "requests"], { from: "user" });
-    const url = String(fetchSpy.mock.calls[0][0]);
-    expect(url).toContain("/v1/notify/connections/requests");
-    const out = logged();
-    expect(out).toMatch(/2 pending connection requests/);
-    expect(out).toContain("Alice");
-    expect(out).toContain("alice@example.com");
-    expect(out).toContain('"hey, lets connect"');
-  });
-
-  it("requests: handles an empty list quietly", async () => {
-    fetchSpy.mockResolvedValueOnce(jsonResponse(200, { requests: [] }));
-    await program.parseAsync(["dm", "requests"], { from: "user" });
-    expect(logged()).toMatch(/No pending connection requests/);
-  });
-
-  it("accept: resolves email to pairKey and hits the accept endpoint", async () => {
-    // 1st call: fetch requests; 2nd call: accept.
-    fetchSpy
-      .mockResolvedValueOnce(jsonResponse(200, { requests: SAMPLE_REQUESTS }))
-      .mockResolvedValueOnce(jsonResponse(200, { state: "active" }));
-    await program.parseAsync(["dm", "accept", "alice@example.com"], { from: "user" });
-    const acceptCall = fetchSpy.mock.calls.find((c) =>
-      String(c[0]).includes("/v1/notify/connections/accept"),
-    );
-    expect(acceptCall).toBeTruthy();
-    const body = JSON.parse((acceptCall![1]?.body as string) ?? "{}");
-    expect(body).toEqual({ pairKey: "pair_abc" });
-    expect(logged()).toMatch(/Connection accepted — Alice\./);
-  });
-
-  it("decline: hits the decline endpoint", async () => {
-    fetchSpy
-      .mockResolvedValueOnce(jsonResponse(200, { requests: SAMPLE_REQUESTS }))
-      .mockResolvedValueOnce(jsonResponse(200, { state: "declined" }));
-    await program.parseAsync(["dm", "decline", "prs_bob"], { from: "user" });
-    const call = fetchSpy.mock.calls.find((c) =>
-      String(c[0]).includes("/v1/notify/connections/decline"),
-    );
-    expect(call).toBeTruthy();
-    const body = JSON.parse((call![1]?.body as string) ?? "{}");
-    expect(body).toEqual({ pairKey: "pair_def" });
-    expect(logged()).toMatch(/Request declined — Bob\./);
-  });
-
-  it("block: hits the block endpoint, falling back to withEmail for a stranger", async () => {
-    // No matching request → falls back to withEmail.
-    fetchSpy
-      .mockResolvedValueOnce(jsonResponse(200, { requests: [] }))
-      .mockResolvedValueOnce(jsonResponse(200, { state: "blocked" }));
-    await program.parseAsync(["dm", "block", "spammer@example.com"], { from: "user" });
-    const call = fetchSpy.mock.calls.find((c) =>
-      String(c[0]).includes("/v1/notify/connections/block"),
-    );
-    expect(call).toBeTruthy();
-    const body = JSON.parse((call![1]?.body as string) ?? "{}");
-    expect(body).toEqual({ withEmail: "spammer@example.com" });
-    expect(logged()).toMatch(/Blocked — spammer@example\.com\./);
-  });
-
-  // ---- receive side: inbox / thread / channel ----
-
-  it("inbox: lists incoming messages from GET /v1/notify/inbox", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, {
-        events: [
-          {
-            eventId: "e1",
-            fromDisplayName: "Jonathan Bach",
-            fromEmail: "jonathan@getindigo.ai",
-            body: "grp_jb_agent is created",
-            createdAt: "2026-07-16T11:57:00.000Z",
-          },
-        ],
-      }),
-    );
-    await program.parseAsync(["dm", "inbox"], { from: "user" });
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/notify/inbox");
-    expect(logged()).toContain("Jonathan Bach");
-    expect(logged()).toContain("grp_jb_agent is created");
-    expect(errSpy).not.toHaveBeenCalled();
-  });
-
-  it("inbox --unread --mark-read: acks only the unread ids", async () => {
-    fetchSpy
-      .mockResolvedValueOnce(
-        jsonResponse(200, {
-          events: [
-            { eventId: "u1", body: "new", createdAt: "2026-07-16T11:00:00.000Z" },
-            {
-              eventId: "r1",
-              body: "old",
-              createdAt: "2026-07-16T10:00:00.000Z",
-              acknowledgedAt: "2026-07-16T10:01:00.000Z",
-            },
-          ],
-        }),
-      )
-      .mockResolvedValueOnce(jsonResponse(200, { acknowledged: 1 }));
-    await program.parseAsync(["dm", "inbox", "--unread", "--mark-read"], {
-      from: "user",
-    });
-    const ackCall = fetchSpy.mock.calls.find((c) =>
-      String(c[0]).includes("/v1/notify/inbox/ack"),
-    );
-    expect(ackCall).toBeTruthy();
-    expect(JSON.parse((ackCall![1]?.body as string) ?? "{}")).toEqual({
-      eventIds: ["u1"],
-    });
-  });
-
-  it("thread <email>: reads via withEmail and acks incoming messages", async () => {
-    fetchSpy
-      .mockResolvedValueOnce(
-        jsonResponse(200, {
-          messages: [
-            {
-              eventId: "in1",
-              fromDisplayName: "Jonathan",
-              body: "thanks!",
-              createdAt: "2026-07-16T11:30:00.000Z",
-              direction: "in",
-            },
-            {
-              eventId: "out1",
-              body: "done",
-              createdAt: "2026-07-16T11:00:00.000Z",
-              direction: "out",
-            },
-          ],
-        }),
-      )
-      .mockResolvedValueOnce(jsonResponse(200, { acknowledged: 1 }));
-    await program.parseAsync(["dm", "thread", "jonathan@getindigo.ai"], {
-      from: "user",
-    });
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/notify/thread");
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("withEmail=");
-    const ackCall = fetchSpy.mock.calls.find((c) =>
-      String(c[0]).includes("/v1/notify/inbox/ack"),
-    );
-    expect(ackCall).toBeTruthy();
-    expect(JSON.parse((ackCall![1]?.body as string) ?? "{}")).toEqual({
-      eventIds: ["in1"],
-    });
-    expect(logged()).toContain("thanks!");
-  });
-
-  it("thread --no-ack: reads without marking anything read", async () => {
-    fetchSpy.mockResolvedValueOnce(
-      jsonResponse(200, {
-        messages: [
-          {
-            eventId: "in1",
-            body: "hi",
-            createdAt: "2026-07-16T11:30:00.000Z",
-            direction: "in",
-          },
-        ],
-      }),
-    );
-    await program.parseAsync(["dm", "thread", "prs_x", "--no-ack"], {
-      from: "user",
-    });
-    expect(
-      fetchSpy.mock.calls.some((c) => String(c[0]).includes("/inbox/ack")),
-    ).toBe(false);
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("withPersonUid=prs_x");
-  });
-
-  it("channel <name>: resolves the channel then reads its messages", async () => {
-    fetchSpy
-      .mockResolvedValueOnce(jsonResponse(200, channelsPayload))
-      .mockResolvedValueOnce(
-        jsonResponse(200, {
-          messages: [
-            {
-              eventId: "m1",
-              fromDisplayName: "Stefan",
-              body: "ship it",
-              createdAt: "2026-07-16T11:00:00.000Z",
-            },
-          ],
-        }),
-      );
-    await program.parseAsync(["dm", "channel", "vyg-dev"], { from: "user" });
-    expect(String(fetchSpy.mock.calls[0][0])).toContain("/v1/notify/channels");
-    expect(String(fetchSpy.mock.calls[1][0])).toContain(
-      "/v1/notify/channels/chn_v/messages",
-    );
-    expect(logged()).toContain("ship it");
-  });
-});