@cohortapp/agent-sdk 2.9.0 → 2.10.0

package/scripts/daemon/board-mirror.test.mjs

@@ -1,34 +1,56 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import {
-  boardItemId,
-  boardTitle,
-  openBoardItem,
-  closeBoardItem,
-} from "./board-mirror.mjs";
+import { boardPriority, boardTitle, closeStageFor, closeBoardItem } from "./board-mirror.mjs";
 
 // ---------------------------------------------------------------------------
-// The board mirror exists because lib/org/board.mjs had exactly ONE caller —
-// the self-directed goal path — and nothing on the responder path touched it.
-// An agent could spend forty minutes on a DM ask and leave the board showing
-// whatever seed rows the workspace shipped with.
+// This file used to open AND close a board row of its own through
+// `board.create` + `board.claim` + `board.complete`. That was a second
+// implementation of a lifecycle hq and this repo already share exactly one of
+// (`lib/org/work-ledger.mjs` → `board.track` → hq `server/work/ledger.ts`), and
+// the daemon called BOTH on the same item — two cards per ask on one board, one
+// of them carrying no requester, no comments and no provenance. Worse,
+// `board.create` gives a channel-less row ORG-WIDE visibility and the mirror
+// sent no channel for Slack/email/voice, so a private ask's topic was published
+// to the whole workspace.
 //
-// Its cardinal rule is that it FAILS OPEN: the work and the answer matter, the
-// row is bookkeeping. Most of these tests are about it staying out of the way.
+// What survives is the CLOSE hook, because `closeObligation` is the funnel every
+// terminal path goes through and only two of them reach the daemon's onClose.
+// These tests pin that it goes through the SHARED ledger, that it never
+// overstates, and that it still fails open.
 // ---------------------------------------------------------------------------
 
-const CFG = { base: "https://hq.example", token: "t" };
+const CFG = { org: { cohort: { enabled: true, base: "https://hq.example", token: "t" } } };
 const okCfg = { loadOrgConfig: () => CFG };
 
-test("board item ids are derived from the obligation key, so re-entry is idempotent", () => {
-  const a = boardItemId("cohort:dm:abc123:7");
-  const b = boardItemId("cohort:dm:abc123:7");
-  assert.equal(a, b, "the same obligation must map to the same row");
-  assert.match(a, /^ob-/);
-  assert.ok(!/[^a-zA-Z0-9_-]/.test(a.slice(3)), "id is transport-safe");
-  assert.equal(boardItemId(null), null);
-});
+/** A recording ledger seam. Answers the way `work-ledger.mjs` does. */
+function ledger(over = {}) {
+  const seen = { calls: [] };
+  return {
+    seen,
+    deps: {
+      ...okCfg,
+      recordWorkStep: async (a) => {
+        seen.calls.push(a);
+        if (over.impl) return over.impl(a);
+        return { tracked: true, reason: "ok", taskId: "task_1", col: a.stage === "done" ? "done" : "blocked" };
+      },
+    },
+  };
+}
+
+const REC = {
+  key: "cohort:dm:C1:9",
+  state: "answered",
+  summary: "compiling the regulatory filing calendar",
+  item: {
+    id: "cohort-msg_1",
+    raw_ref: "cohort:messaging:msg_1:1",
+    service: "cohort",
+    channel_id: "chan_1",
+    content: "can you compile the regulatory filing calendar",
+  },
+};
 
 test("the title is the topic the acknowledgement already speaks aloud", () => {
   assert.equal(
@@ -41,67 +63,103 @@ test("the title is the topic the acknowledgement already speaks aloud", () => {
   assert.ok(boardTitle({ summary: "x".repeat(400) }).length <= 120);
 });
 
-test("opens the row in `running`, which is what the product's On now reads", async () => {
-  let sent = null;
-  const r = await openBoardItem({
-    rec: { key: "k1", summary: "drafting a reply to Karen", sender: "Karen" },
-    agentRoot: "/x",
-    deps: { ...okCfg, createItem: async (item) => { sent = item; return { ok: true }; } },
-  });
+test("the classifier's priority words are mapped onto hq's P-scale, which is all it accepts", () => {
+  // hq validates priority against z.enum(["P0".."P4"]); "critical" 400s the
+  // whole call, so the obligation vocabulary has to be translated here.
+  assert.equal(boardPriority("critical"), "P0");
+  assert.equal(boardPriority("high"), "P1");
+  assert.equal(boardPriority("normal"), "P2");
+  assert.equal(boardPriority("ignore"), "P3");
+  assert.equal(boardPriority("P1"), "P1");
+  // No mapping → omit, and let hq's own default (P2) answer.
+  assert.equal(boardPriority("whatever"), undefined);
+  assert.equal(boardPriority(undefined), undefined);
+});
+
+test("only `answered` closes the row as done — every other verdict blocks it", () => {
+  assert.equal(closeStageFor("answered"), "done");
+  assert.equal(closeStageFor(undefined), "done");
+  for (const bad of ["failed", "undeliverable", "stale", "anything-else"]) {
+    assert.equal(closeStageFor(bad), "failed", `${bad} must not read as delivered`);
+  }
+});
+
+test("the close goes through the SHARED ledger, not a second board writer", async () => {
+  const { seen, deps } = ledger();
+  const r = await closeBoardItem({ rec: REC, agentRoot: "/x", deps });
+
   assert.equal(r.mirrored, true);
-  assert.equal(sent.status, "running");
-  assert.equal(sent.col, "running", "a row parked in todo is invisible to the banner");
-  assert.equal(sent.title, "Drafting a reply to Karen");
-  assert.equal(sent.obligationKey, "k1");
-  assert.match(sent.detail, /Karen/);
+  assert.equal(r.taskId, "task_1");
+  assert.equal(seen.calls.length, 1);
+  const call = seen.calls[0];
+  // The ledger identifies the ask from the ITEM (service + channel + message),
+  // and derives the dedupe key server-side — which is what makes this land on
+  // the SAME row the daemon's `accepted`/`working` steps opened, rather than a
+  // second card beside it.
+  assert.equal(call.item, REC.item);
+  assert.equal(call.stage, "done");
+  assert.equal(call.deferred, true);
+  assert.equal(call.cfg, CFG);
+  assert.match(call.note, /Answered in the conversation/);
 });
 
-test("a missing org credential is a no-op, not a throw", async () => {
-  const r = await openBoardItem({
-    rec: { key: "k1" },
-    deps: { loadOrgConfig: () => ({}), createItem: async () => { throw new Error("must not be called"); } },
-  });
-  assert.equal(r.mirrored, false);
-  assert.equal(r.reason, "no-org-credential");
+test("a failed obligation lands the row blocked, and says why", async () => {
+  const { seen, deps } = ledger();
+  await closeBoardItem({ rec: { ...REC, state: "failed", closeNote: "exit 1" }, deps });
+  assert.equal(seen.calls[0].stage, "failed");
+  assert.match(seen.calls[0].note, /exit 1/);
+  assert.match(seen.calls[0].note, /blocked/);
 });
 
-test("a refusing board does not throw — the reply must still go out", async () => {
-  const r = await openBoardItem({
-    rec: { key: "k1", summary: "x" },
-    deps: { ...okCfg, createItem: async () => ({ ok: false, error: { code: "FORBIDDEN", message: "no" } }) },
-  });
-  assert.equal(r.mirrored, false);
-  assert.equal(r.reason, "refused");
+test("an undeliverable obligation says so, and still does not read as delivered", async () => {
+  const { seen, deps } = ledger();
+  await closeBoardItem({ rec: { ...REC, state: "undeliverable" }, deps });
+  assert.equal(seen.calls[0].stage, "failed");
+  assert.match(seen.calls[0].note, /no way to deliver/);
 });
 
-test("a throwing transport does not throw — same reason", async () => {
-  const r = await openBoardItem({
-    rec: { key: "k1", summary: "x" },
-    deps: { ...okCfg, createItem: async () => { throw new Error("socket hang up"); } },
+test("an explicit outcome overrides the record's own state", async () => {
+  const { seen, deps } = ledger();
+  await closeBoardItem({ rec: REC, outcome: "failed", deps });
+  assert.equal(seen.calls[0].stage, "failed");
+});
+
+test("a non-Cohort obligation writes NO row — a private ask is not published org-wide", async () => {
+  // THE LEAK THIS REPLACED: `board.create` with no channelId produces a row
+  // every member of the org can read, titled after the ask. The daemon polls
+  // Slack, two Gmail accounts, telegram, whatsapp and voice. The shared gate
+  // refuses all of them (`not-a-cohort-channel`) — this test pins that the
+  // refusal reaches us as a benign no-op rather than being worked around.
+  const { seen, deps } = ledger({ impl: async () => ({ tracked: false, reason: "not-a-cohort-channel" }) });
+  const r = await closeBoardItem({
+    rec: { ...REC, item: { ...REC.item, service: "slack", channel_id: "D0123" } },
+    deps,
   });
   assert.equal(r.mirrored, false);
-  assert.equal(r.reason, "error");
+  assert.equal(r.reason, "not-a-cohort-channel");
+  assert.equal(seen.calls.length, 1, "the decision is the ledger's, not a rule re-implemented here");
 });
 
-test("closing carries the obligation's own verdict, so a failure does not read as delivered", async () => {
-  let sent = null;
+test("an obligation with no item snapshot is a no-op, not a throw", async () => {
   const r = await closeBoardItem({
     rec: { key: "k1" },
-    outcome: "failed",
-    deps: { ...okCfg, completeItem: async (p) => { sent = p; return { ok: true }; } },
+    deps: { ...okCfg, recordWorkStep: async () => { throw new Error("must not be called"); } },
   });
-  assert.equal(r.mirrored, true);
-  assert.equal(sent.proof, "outcome:failed");
-  assert.equal(sent.itemId, boardItemId("k1"));
+  assert.equal(r.mirrored, false);
+  assert.equal(r.reason, "no-item");
 });
 
-test("close is as fail-open as open", async () => {
-  for (const deps of [
-    { ...okCfg, completeItem: async () => ({ ok: false, error: { code: "GONE" } }) },
-    { ...okCfg, completeItem: async () => { throw new Error("boom"); } },
-    { loadOrgConfig: () => ({}), completeItem: async () => { throw new Error("nope"); } },
+test("the close is fail-open: a refusal, a throw and a missing credential all resolve", async () => {
+  for (const [label, impl] of [
+    ["refused", async () => ({ tracked: false, reason: "FORBIDDEN_SCOPE: no" })],
+    ["threw", async () => { throw new Error("socket hang up"); }],
+    ["disabled", async () => ({ tracked: false, reason: "org-disabled" })],
   ]) {
-    const r = await closeBoardItem({ rec: { key: "k1" }, outcome: "answered", deps });
-    assert.equal(r.mirrored, false);
+    const r = await closeBoardItem({
+      rec: REC,
+      deps: { ...okCfg, recordWorkStep: impl },
+    });
+    assert.equal(r.mirrored, false, label);
+    assert.ok(r.reason, `${label} must report why`);
   }
 });