@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/scripts/daemon/session-outcomes.test.mjs

@@ -1,533 +0,0 @@
-/**
- * session-outcomes.test.mjs — the daemon's OUTCOME DISCIPLINE.
- *
- * hq guarantees a live call's action points become real board rows and sweeps the
- * ones the chair never wrote. These tests assert the daemon's parity:
- *
- *   CAPTURE  the OUTCOMES block is read off the turn's final text, deterministically
- *            and bounded, and ordinary prose can never be mistaken for a commitment
- *   GATE     a landed outcome is ORG-VISIBLE, so only an already-org-visible source
- *            may produce one — fail-closed, unlike the rest of this module
- *   LAND     each commitment goes through the EXISTING org protocol (board.create +
- *            one knowledge.append episode) — no new methods
- *   SWEEP    the post-session hook is DRIVEN, idempotent, fail-open, and OFF unless
- *            DAEMON_SESSION_OUTCOMES=1
- *
- * The org collaborators are injected, so nothing here touches a network or a DB.
- */
-
-import { test, beforeEach } from "node:test";
-import assert from "node:assert/strict";
-
-import * as so from "./session-outcomes.mjs";
-
-const ENABLED_CFG = { org: { cohort: { enabled: true, base: "https://org.example" } } };
-
-/**
- * A public Slack channel message — the ONLY source whose outcomes may land.
- * `channel_type: "channel"` is what establishes that; the `C…` id does NOT
- * (Slack mints `C…` ids for private channels too).
- */
-const PUBLIC_ITEM = {
-  service: "slack",
-  channel: "general",
-  channel_id: "C0GENERAL",
-  channel_type: "channel",
-  subject: "#general",
-};
-
-/** A createItem fake that records its calls and returns a success frame. */
-function fakeCreate(sink, behaviour) {
-  return async (item, opts) => {
-    sink.push({ item, opts });
-    if (typeof behaviour === "function") return behaviour(item);
-    return { ok: true, result: { id: item.itemId } };
-  };
-}
-
-function fakeRemember(sink) {
-  return async (text, opts) => {
-    sink.push({ text, opts });
-    return { ok: true, mode: "append", id: "k1" };
-  };
-}
-
-beforeEach(() => so._resetSessionOutcomes());
-
-// ---------------------------------------------------------------------------
-// CAPTURE
-// ---------------------------------------------------------------------------
-
-test("CAPTURE: reads the OUTCOMES block, with owner and timing", () => {
-  const text = [
-    "Sent Alice the revised terms and flagged the pricing gap.",
-    "",
-    "OUTCOMES:",
-    "- Send the redlined MSA to Alice — owner: Robin — due: Friday",
-    "- Book the pricing review with Finance",
-    "",
-    "Let me know if anything else comes up.",
-  ].join("\n");
-
-  const out = so.parseOutcomes(text);
-  assert.equal(out.length, 2, "two commitments");
-  assert.equal(out[0].title, "Send the redlined MSA to Alice");
-  assert.equal(out[0].owner, "Robin");
-  assert.equal(out[0].due, "Friday");
-  assert.equal(out[1].title, "Book the pricing review with Finance");
-  assert.equal(out[1].owner, undefined, "no owner invented");
-});
-
-test("CAPTURE: tolerates markdown decoration around the literal heading", () => {
-  const text = [
-    "## Outcomes",
-    "",
-    "1. Draft the board update",
-    "2. [ ] Chase the vendor SOC2",
-  ].join("\n");
-  const out = so.parseOutcomes(text);
-  assert.deepEqual(out.map((o) => o.title), ["Draft the board update", "Chase the vendor SOC2"]);
-
-  const bold = so.parseOutcomes(["**OUTCOMES:**", "- Ship the fix"].join("\n"));
-  assert.deepEqual(bold.map((o) => o.title), ["Ship the fix"]);
-});
-
-test("CAPTURE: the capture surface is EXACTLY the contract the prompt establishes", () => {
-  // REGRESSION. These headings used to be accepted, which made the sweep wider
-  // than the contract: a turn that merely wrote a prose "Next steps:" section —
-  // possibly from a prompt that never carried OUTCOME_DISCIPLINE at all, since
-  // the prompt injects it at build time while the sweep re-reads the flag at
-  // close time — silently minted org-visible board rows.
-  const wider = [
-    "## Next steps\n\n1. Draft the board update",
-    "Next steps:\n- Draft the board update",
-    "**Action items:**\n- Ship the fix",
-    "Action points:\n- Ship the fix",
-    "Commitments:\n- Ship the fix",
-  ];
-  for (const text of wider) {
-    assert.deepEqual(
-      so.parseOutcomes(text),
-      [],
-      `only the literal OUTCOMES heading is machine-read: ${JSON.stringify(text)}`
-    );
-  }
-});
-
-test("CAPTURE: an honest empty block stays empty", () => {
-  assert.deepEqual(so.parseOutcomes("Answered inline.\n\nOUTCOMES: none"), []);
-  assert.deepEqual(so.parseOutcomes("OUTCOMES:\n- none\n"), []);
-  assert.deepEqual(so.parseOutcomes(""), []);
-});
-
-test("CAPTURE: prose is never mistaken for a commitment block", () => {
-  // No colon after the keyword ⇒ not a heading. This is the false-positive that
-  // would otherwise put junk on the org board.
-  assert.deepEqual(so.parseOutcomes("Action items are clear from the thread."), []);
-  assert.deepEqual(so.parseOutcomes("The outcomes were disappointing this quarter."), []);
-});
-
-test("CAPTURE: the block terminates at the blank line, not at the end of the reply", () => {
-  const text = ["OUTCOMES:", "- Do the thing", "", "- this is a different list entirely"].join("\n");
-  assert.deepEqual(so.parseOutcomes(text).map((o) => o.title), ["Do the thing"]);
-});
-
-test("CAPTURE: bounded and deduped — a runaway summary cannot flood the board", () => {
-  const lines = ["OUTCOMES:"];
-  for (let i = 0; i < 30; i += 1) lines.push(`- step ${i}`);
-  const out = so.parseOutcomes(lines.join("\n"));
-  assert.equal(out.length, so.MAX_OUTCOMES, `capped at ${so.MAX_OUTCOMES}`);
-
-  const dupes = so.parseOutcomes(["OUTCOMES:", "- Ship it", "- ship IT", "- Ship it"].join("\n"));
-  assert.equal(dupes.length, 1, "case-insensitively deduped");
-
-  const long = so.parseOutcomes(`OUTCOMES:\n- ${"x".repeat(500)}`);
-  assert.ok(long[0].title.length <= 200, "title bounded");
-});
-
-test("CAPTURE: recovers the final text from --output-format json stdout", () => {
-  const stdout = JSON.stringify({ type: "result", result: "OUTCOMES:\n- Email the deck", usage: {} });
-  assert.equal(so.resultTextFromStdout(stdout), "OUTCOMES:\n- Email the deck");
-
-  // A leading banner line before the JSON tail (the tolerant path).
-  assert.equal(
-    so.resultTextFromStdout(`warning: something\n${JSON.stringify({ result: "hi" })}`),
-    "hi"
-  );
-  assert.equal(so.resultTextFromStdout(""), "", "empty stdout ⇒ empty");
-  assert.equal(so.resultTextFromStdout("{"), "{", "unparseable ⇒ treated as plain text, never throws");
-});
-
-// ---------------------------------------------------------------------------
-// GATE — a landed outcome is org-visible, so the source must already be
-// ---------------------------------------------------------------------------
-
-test("GATE: a public Slack channel is the only source that qualifies", () => {
-  assert.deepEqual(so.outcomeSourceShareable(PUBLIC_ITEM), {
-    shareable: true,
-    reason: "public-channel",
-  });
-  assert.equal(
-    so.outcomeSourceShareable({ ...PUBLIC_ITEM, channel_id: "C0ABCDEF" }).shareable,
-    true
-  );
-});
-
-test("GATE: a private DM's commitments NEVER become org-visible artifacts", () => {
-  // The leak this closes: board.create with no workstreamId is channel-less (hq's
-  // board query applies no channel filter to it) and knowledge.append with no
-  // group resolves to `org` — so a DM's commitment text AND its topic line would
-  // be readable by every member of the org.
-  const dms = [
-    { service: "slack", channel: "dm/alice", channel_id: "D01ALICE", subject: "DM from Alice" },
-    { service: "slack", channel: "general", channel_id: "C0GENERAL", is_dm: true },
-    { service: "slack", channel: "dm/alice" },
-    { service: "slack", channel: "general", channel_id: "D01ALICE" },
-  ];
-  for (const item of dms) {
-    const gate = so.outcomeSourceShareable(item);
-    assert.equal(gate.shareable, false, `DM must not land: ${JSON.stringify(item)}`);
-    assert.equal(gate.reason, "dm");
-  }
-});
-
-test("GATE: fail-CLOSED — anything not established as public lands nothing", () => {
-  const cases = [
-    [undefined, "no-source"],
-    [null, "no-source"],
-    ["not an object", "no-source"],
-    [{}, "unknown-source"],
-    [{ service: "slack" }, "unknown-channel"],
-    [{ service: "slack", channel_id: "G01GROUP" }, "private-channel"],
-    [{ service: "slack", channel_id: "C0GENERAL", is_private: true }, "private-channel"],
-    [{ service: "gmail", channel: "email/alice@example.com" }, "private-correspondence"],
-    [{ service: "gmail", subject: "Deck review" }, "non-channel-source"],
-    [{ service: "telegram", channel: "telegram" }, "non-channel-source"],
-    [{ channel: "general", channel_id: "C0GENERAL" }, "unknown-source"],
-    // A type we cannot interpret is not a type we may publish from.
-    [{ service: "slack", channel_id: "C0GENERAL", channel_type: "external_shared" }, "unknown-channel-type"],
-  ];
-  for (const [item, reason] of cases) {
-    const gate = so.outcomeSourceShareable(item);
-    assert.equal(gate.shareable, false, `must not land: ${JSON.stringify(item)}`);
-    assert.equal(gate.reason, reason, `reason for ${JSON.stringify(item)}`);
-  }
-});
-
-test("GATE: a `C…` id is NOT a public signal — the conversation TYPE is", () => {
-  // THE DEFECT THIS CLOSES. The gate used to admit on `/^C/.test(channel_id)`,
-  // but Slack is explicit that the conversation-ID prefix is not a reliable type
-  // indicator: private channels are minted with `C…` ids too (only `D` for a DM
-  // is dependable). Every item below carries a `C…` id and must still be refused
-  // — otherwise a private channel's commitment text AND its topic line become a
-  // channel-less board row plus an `org`-group knowledge episode, readable by
-  // every member of the org.
-  const privateWithPublicLookingId = [
-    // What Socket Mode actually delivers for a private channel.
-    [{ service: "slack", channel: "leadership", channel_id: "C0PRIVATE", channel_type: "group" }, "private-channel"],
-    // A group DM, likewise not necessarily `G…`-prefixed.
-    [{ service: "slack", channel: "C0MPIM01", channel_id: "C0MPIM01", channel_type: "mpim" }, "dm"],
-    [{ service: "slack", channel: "C0IM0001", channel_id: "C0IM0001", channel_type: "im" }, "dm"],
-    // An explicit privacy verdict from conversations.list/info.
-    [{ service: "slack", channel: "leadership", channel_id: "C0PRIVATE", is_private: true }, "private-channel"],
-    // NO signal at all: ingest didn't resolve the type, so nothing is established.
-    [{ service: "slack", channel: "general", channel_id: "C0GENERAL" }, "privacy-unknown"],
-  ];
-  for (const [item, reason] of privateWithPublicLookingId) {
-    const gate = so.outcomeSourceShareable(item);
-    assert.equal(gate.shareable, false, `a C-prefixed id must not admit: ${JSON.stringify(item)}`);
-    assert.equal(gate.reason, reason, `reason for ${JSON.stringify(item)}`);
-  }
-});
-
-test("GATE: admits ONLY on a positive public signal (channel_type or is_private:false)", () => {
-  for (const item of [
-    { service: "slack", channel: "general", channel_id: "C0GENERAL", channel_type: "channel" },
-    { service: "slack", channel: "general", channel_id: "C0GENERAL", is_private: false },
-    // A public channel whose id happens not to start with C is still public.
-    { service: "slack", channel: "general", channel_id: "X0WEIRD01", channel_type: "channel" },
-  ]) {
-    const gate = so.outcomeSourceShareable(item);
-    assert.equal(gate.shareable, true, `must land: ${JSON.stringify(item)}`);
-    assert.equal(gate.reason, "public-channel");
-  }
-  // …and an explicit DM/private verdict still overrides a public-looking type.
-  assert.equal(
-    so.outcomeSourceShareable({ service: "slack", channel_id: "C0GENERAL", channel_type: "channel", is_private: true }).shareable,
-    false,
-    "is_private:true wins outright"
-  );
-  assert.equal(
-    so.outcomeSourceShareable({ service: "slack", channel_id: "C0GENERAL", channel_type: "channel", is_dm: true }).shareable,
-    false,
-    "is_dm:true wins outright"
-  );
-});
-
-test("GATE: the SWEEP refuses a private channel that carries a `C…` id", async () => {
-  let touched = false;
-  const res = await so.sweepSessionOutcomes({
-    sessionId: "s-gate-private-c",
-    resultText: "OUTCOMES:\n- Prepare the confidential redundancy list — due: Friday",
-    enabled: true,
-    cfg: ENABLED_CFG,
-    item: {
-      service: "slack",
-      channel: "leadership",
-      channel_id: "C0LEADERSHIP",
-      channel_type: "group",
-      subject: "Headcount plan",
-    },
-    classResult: { summary: "headcount plan" },
-    createItemImpl: async () => { touched = true; return { ok: true }; },
-    rememberImpl: async () => { touched = true; return { ok: true }; },
-  });
-  assert.equal(res.created, 0);
-  assert.equal(res.captured, 0, "a private channel's commitments are never even captured");
-  assert.equal(res.reason, "source-private-channel");
-  assert.equal(touched, false, "no board row, no episode");
-});
-
-test("GATE: the WRITER refuses a non-public source, not just the sweep", async () => {
-  let touched = false;
-  for (const item of [undefined, { service: "slack", channel_id: "D01ALICE" }]) {
-    const res = await so.landOutcomes({
-      sessionId: "s-gate",
-      outcomes: [{ title: "Send the redlined MSA" }],
-      cfg: ENABLED_CFG,
-      item,
-      createItemImpl: async () => { touched = true; return { ok: true }; },
-      rememberImpl: async () => { touched = true; return { ok: true }; },
-    });
-    assert.equal(res.created, 0);
-    assert.equal(res.skipped, true);
-    assert.match(res.reason, /^source-/, "the refusal is reported honestly");
-  }
-  assert.equal(touched, false, "no protocol call for a private source");
-});
-
-test("GATE: the SWEEP refuses a DM before it even parses the text", async () => {
-  let touched = false;
-  const res = await so.sweepSessionOutcomes({
-    sessionId: "s-gate-2",
-    resultText: "OUTCOMES:\n- Send Alice the term sheet she asked for in confidence",
-    enabled: true,
-    cfg: ENABLED_CFG,
-    item: { service: "slack", channel: "dm/alice", channel_id: "D01ALICE", is_dm: true },
-    createItemImpl: async () => { touched = true; return { ok: true }; },
-    rememberImpl: async () => { touched = true; return { ok: true }; },
-  });
-  assert.equal(res.created, 0);
-  assert.equal(res.captured, 0, "a private turn's commitments are never even captured");
-  assert.equal(res.reason, "source-dm");
-  assert.equal(touched, false);
-  assert.deepEqual(so.getSessionOutcomes("s-gate-2"), [], "and nothing is retained in memory");
-});
-
-// ---------------------------------------------------------------------------
-// LAND — via the existing org protocol only
-// ---------------------------------------------------------------------------
-
-test("LAND: writes one board.create per commitment plus ONE knowledge episode", async () => {
-  const created = [];
-  const remembered = [];
-  const res = await so.landOutcomes({
-    sessionId: "s-1",
-    outcomes: [
-      { title: "Send the redlined MSA", owner: "Robin", due: "Friday" },
-      { title: "Book the pricing review" },
-    ],
-    cfg: ENABLED_CFG,
-    item: PUBLIC_ITEM,
-    classResult: { summary: "Acme renewal" },
-    agentName: "Robin",
-    createItemImpl: fakeCreate(created),
-    rememberImpl: fakeRemember(remembered),
-  });
-
-  assert.equal(res.created, 2, "both commitments landed");
-  assert.equal(created.length, 2);
-  assert.equal(created[0].item.title, "Send the redlined MSA");
-  assert.equal(created[0].item.priority, "P2");
-  assert.ok(created[0].item.itemId, "carries a caller-supplied id for replay safety");
-  assert.ok(created[0].item.detail.includes("Robin"), "owner recorded in the detail");
-  assert.ok(created[0].item.detail.includes("Friday"), "timing recorded in the detail");
-  assert.ok(created[0].item.detail.includes("s-1"), "provenance names the session");
-  // board.create is `.strict()` server-side — sending an unknown field would 400.
-  assert.deepEqual(
-    Object.keys(created[0].item).sort(),
-    ["detail", "itemId", "priority", "title"],
-    "only board.create's own fields are sent"
-  );
-  assert.equal(created[0].opts.base, "https://org.example", "connection from the org config");
-
-  assert.equal(remembered.length, 1, "exactly one episode for the whole set");
-  assert.equal(remembered[0].opts.kind, "episode");
-  assert.equal(remembered[0].opts.provenance.sessionId, "s-1");
-  assert.ok(remembered[0].text.includes("Send the redlined MSA"));
-  assert.equal(remembered[0].opts.group, undefined, "no group hint — the server derives the ACL");
-});
-
-test("LAND: the board id is deterministic, so a replay cannot double a row", () => {
-  const a = so.outcomeItemId("s-1", "Send the redlined MSA");
-  const b = so.outcomeItemId("s-1", "  send the   REDLINED msa  ");
-  const c = so.outcomeItemId("s-2", "Send the redlined MSA");
-  assert.equal(a, b, "stable under whitespace/case");
-  assert.notEqual(a, c, "scoped to the session");
-  assert.match(a, /^so-[0-9a-f]{24}$/);
-});
-
-test("LAND: fail-open when the org integration is disabled", async () => {
-  let touched = false;
-  const res = await so.landOutcomes({
-    sessionId: "s-1",
-    outcomes: [{ title: "x" }],
-    cfg: {},
-    item: PUBLIC_ITEM,
-    createItemImpl: async () => { touched = true; return { ok: true }; },
-    rememberImpl: async () => { touched = true; return { ok: true }; },
-  });
-  assert.equal(res.skipped, true);
-  assert.equal(res.created, 0);
-  assert.equal(touched, false, "no protocol call when disabled");
-});
-
-test("LAND: never throws, and one bad row does not strand the rest", async () => {
-  const created = [];
-  const res = await so.landOutcomes({
-    sessionId: "s-1",
-    outcomes: [{ title: "first" }, { title: "second" }, { title: "third" }],
-    cfg: ENABLED_CFG,
-    item: PUBLIC_ITEM,
-    createItemImpl: async (item) => {
-      created.push(item.title);
-      if (item.title === "second") throw new Error("network down");
-      if (item.title === "third") return { error: { code: "INTERNAL" } };
-      return { ok: true };
-    },
-    rememberImpl: async () => { throw new Error("also down"); },
-  });
-  assert.equal(res.created, 1, "only the row that actually landed is counted");
-  assert.deepEqual(created, ["first", "second", "third"], "every row was attempted");
-  assert.equal(res.remembered, false, "a failed episode is reported honestly");
-});
-
-// ---------------------------------------------------------------------------
-// SWEEP — driven, idempotent, off by default
-// ---------------------------------------------------------------------------
-
-test("SWEEP: off by default — the flag must be set explicitly", async () => {
-  assert.equal(so.outcomesEnabled({}), false, "absent flag ⇒ off");
-  assert.equal(so.outcomesEnabled({ DAEMON_SESSION_OUTCOMES: "0" }), false);
-  assert.equal(so.outcomesEnabled({ DAEMON_SESSION_OUTCOMES: "true" }), false, "only '1' arms it");
-  assert.equal(so.outcomesEnabled({ DAEMON_SESSION_OUTCOMES: "1" }), true);
-
-  let touched = false;
-  const res = await so.sweepSessionOutcomes({
-    sessionId: "s-1",
-    resultText: "OUTCOMES:\n- Do the thing",
-    cfg: ENABLED_CFG,
-    item: PUBLIC_ITEM,
-    createItemImpl: async () => { touched = true; return { ok: true }; },
-    rememberImpl: async () => { touched = true; return { ok: true }; },
-    // `enabled` omitted ⇒ reads the (unset) env flag
-  });
-  assert.equal(res.skipped, true);
-  assert.equal(res.reason, "disabled");
-  assert.equal(touched, false, "nothing lands while the flag is off");
-});
-
-test("SWEEP: lands a turn's commitments end to end", async () => {
-  const created = [];
-  const remembered = [];
-  const stdout = JSON.stringify({
-    result: "Handled it.\n\nOUTCOMES:\n- Send the deck to Alice — due: Monday\n",
-  });
-  const res = await so.sweepSessionOutcomes({
-    sessionId: "s-9",
-    stdout,
-    enabled: true,
-    cfg: ENABLED_CFG,
-    item: { ...PUBLIC_ITEM, subject: "Deck review" },
-    agentName: "Robin",
-    createItemImpl: fakeCreate(created),
-    rememberImpl: fakeRemember(remembered),
-  });
-  assert.equal(res.captured, 1);
-  assert.equal(res.created, 1);
-  assert.equal(created[0].item.title, "Send the deck to Alice");
-  assert.equal(remembered.length, 1);
-});
-
-test("SWEEP: a turn that committed to nothing is a clean no-op", async () => {
-  let touched = false;
-  const res = await so.sweepSessionOutcomes({
-    sessionId: "s-10",
-    resultText: "Answered inline. OUTCOMES: none",
-    enabled: true,
-    cfg: ENABLED_CFG,
-    item: PUBLIC_ITEM,
-    createItemImpl: async () => { touched = true; return { ok: true }; },
-    rememberImpl: async () => { touched = true; return { ok: true }; },
-  });
-  assert.equal(res.captured, 0);
-  assert.equal(res.reason, "nothing-captured");
-  assert.equal(touched, false);
-});
-
-test("SWEEP: idempotent — a second close never re-lands", async () => {
-  const created = [];
-  const args = {
-    sessionId: "s-11",
-    resultText: "OUTCOMES:\n- Do the thing",
-    enabled: true,
-    cfg: ENABLED_CFG,
-    item: PUBLIC_ITEM,
-    createItemImpl: fakeCreate(created),
-    rememberImpl: fakeRemember([]),
-  };
-  const first = await so.sweepSessionOutcomes(args);
-  assert.equal(first.created, 1);
-
-  // Re-arm the in-process state as a double-fire would, then sweep again.
-  so.noteOutcomes("s-11", [{ title: "Do the thing" }]);
-  so.markOutcomesLanded("s-11");
-  const second = await so.sweepSessionOutcomes(args);
-  assert.equal(second.reason, "already-landed");
-  assert.equal(created.length, 1, "board.create called exactly once");
-});
-
-test("SWEEP: never throws, whatever the session emitted", async () => {
-  for (const stdout of [undefined, null, "", "{{{", "not json at all"]) {
-    const res = await so.sweepSessionOutcomes({
-      sessionId: "s-12",
-      stdout,
-      enabled: true,
-      cfg: ENABLED_CFG,
-      item: PUBLIC_ITEM,
-      createItemImpl: async () => { throw new Error("boom"); },
-      rememberImpl: async () => { throw new Error("boom"); },
-    });
-    assert.ok(res && typeof res.created === "number", `benign result for ${JSON.stringify(stdout)}`);
-  }
-  const noSession = await so.sweepSessionOutcomes({
-    enabled: true,
-    resultText: "OUTCOMES:\n- x",
-    item: PUBLIC_ITEM,
-  });
-  assert.equal(noSession.reason, "no-session");
-});
-
-test("STATE: capture is bounded and self-evicting so a long-lived daemon cannot leak", () => {
-  const many = Array.from({ length: 30 }, (_, i) => ({ title: `step ${i}` }));
-  const kept = so.noteOutcomes("s-13", many);
-  assert.equal(kept.length, so.MAX_OUTCOMES);
-  assert.equal(so.getSessionOutcomes("s-13").length, so.MAX_OUTCOMES);
-
-  so.clearSessionOutcomes("s-13");
-  assert.deepEqual(so.getSessionOutcomes("s-13"), []);
-
-  for (let i = 0; i < 400; i += 1) so.noteOutcomes(`bulk-${i}`, [{ title: "x" }]);
-  assert.deepEqual(so.getSessionOutcomes("bulk-0"), [], "oldest sessions are evicted");
-  assert.equal(so.getSessionOutcomes("bulk-399").length, 1, "newest is retained");
-});

package/scripts/daemon/typing-registry.test.mjs

@@ -1,102 +0,0 @@
-/**
- * typing-registry.test.mjs — node:test coverage for typing-registry.mjs
- *
- * Verifies start/stop route to the registered adapter keyed by service, that
- * sources are derived from items (incl. YAML-round-tripped items lacking a
- * structured source), and that unknown/backlog channels no-op. Hermetic.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  registerTypingAdapter,
-  clearTypingAdapters,
-  startTyping,
-  stopTyping,
-  sourceFromItem,
-} from "./typing-registry.mjs";
-import { resetCohortTypingAdapter } from "../../lib/org/typing.mjs";
-
-function fakeAdapter() {
-  return {
-    started: [],
-    stopped: [],
-    startTypingHeartbeat(source) { this.started.push(source); return "key"; },
-    stopTypingHeartbeat(source) { this.stopped.push(source); },
-  };
-}
-
-test("startTyping/stopTyping route to the adapter for the item's service", () => {
-  clearTypingAdapters();
-  const tg = fakeAdapter();
-  registerTypingAdapter("telegram", tg);
-  const item = { service: "telegram", channel_id: "987", channel: "dm/casey", thread_id: "" };
-  startTyping(item);
-  stopTyping(item);
-  assert.equal(tg.started.length, 1);
-  assert.equal(tg.started[0].chatId, "987");
-  assert.equal(tg.started[0].userScope, "dm");
-  assert.equal(tg.stopped.length, 1);
-  clearTypingAdapters();
-});
-
-test("unknown service no-ops (no adapter registered)", () => {
-  clearTypingAdapters();
-  assert.doesNotThrow(() => startTyping({ service: "gmail", channel_id: "x" }));
-  assert.doesNotThrow(() => stopTyping({ service: "gmail", channel_id: "x" }));
-});
-
-test("item without a chatId no-ops", () => {
-  clearTypingAdapters();
-  const tg = fakeAdapter();
-  registerTypingAdapter("telegram", tg);
-  startTyping({ service: "telegram", channel: "dm/x" }); // no channel_id
-  assert.equal(tg.started.length, 0);
-  clearTypingAdapters();
-});
-
-test("sourceFromItem prefers a structured source, else reconstructs from item", () => {
-  const explicit = sourceFromItem({ service: "telegram", source: { channel: "telegram", chatId: "1", userScope: "group" } });
-  assert.equal(explicit.userScope, "group");
-
-  const dm = sourceFromItem({ service: "slack", channel: "dm/casey", channel_id: "DABC", thread_id: "" });
-  assert.equal(dm.userScope, "dm");
-  assert.equal(dm.chatId, "DABC");
-
-  const group = sourceFromItem({ service: "telegram", channel: "ops", channel_id: "-100", thread_id: "77" });
-  assert.equal(group.userScope, "group");
-  assert.equal(group.threadRef, "77");
-});
-
-test("cohort resolves the BUILT-IN adapter with nothing registered (the SDK parity gap)", () => {
-  clearTypingAdapters();
-  resetCohortTypingAdapter();
-  // No registerTypingAdapter("cohort", …) anywhere — nothing constructs a
-  // cohort channel adapter, which is why the indicator was missing entirely.
-  const item = { service: "cohort", channel_id: "ch_1", channel: "#build", thread_id: "" };
-  assert.doesNotThrow(() => startTyping(item));
-  assert.doesNotThrow(() => stopTyping(item));
-  clearTypingAdapters();
-  resetCohortTypingAdapter();
-});
-
-test("an explicitly registered cohort adapter still wins over the built-in", () => {
-  clearTypingAdapters();
-  resetCohortTypingAdapter();
-  const fake = fakeAdapter();
-  registerTypingAdapter("cohort", fake);
-  startTyping({ service: "cohort", channel_id: "ch_1", channel: "#build" });
-  assert.equal(fake.started.length, 1);
-  assert.equal(fake.started[0].chatId, "ch_1");
-  clearTypingAdapters();
-  resetCohortTypingAdapter();
-});
-
-test("registerTypingAdapter ignores adapters lacking startTypingHeartbeat", () => {
-  clearTypingAdapters();
-  registerTypingAdapter("bad", { foo: 1 });
-  // No throw, and startTyping no-ops.
-  assert.doesNotThrow(() => startTyping({ service: "bad", channel_id: "1" }));
-  clearTypingAdapters();
-});