@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/lib/org/client.test.mjs

@@ -1,1206 +0,0 @@
-/**
- * client.test.mjs — Cohort /v1 HTTP client: header correctness, method routing,
- * read parsing, fail-open, and back-compat surface. Uses an injected fetchImpl
- * that captures requests and returns canned frames (no network).
- * Run: node --test lib/org/client.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-/** Run `fn` with console.warn captured; returns the captured lines. */
-function captureWarn(fn) {
-  const lines = [];
-  const real = console.warn;
-  console.warn = (...a) => { lines.push(a.join(" ")); };
-  try { fn(); } finally { console.warn = real; }
-  return lines;
-}
-
-import {
-  isEnabled,
-  loadOrgConfig,
-  configFromAgent,
-  pairRequest,
-  call,
-  read,
-  register,
-  heartbeat,
-  presenceBeat,
-  createItem,
-  claimItem,
-  completeItem,
-  listReady,
-  listMine,
-  listMineResult,
-  trackWork,
-  fetchEvents,
-  fetchSnapshot,
-  publishEntry,
-  fetchDirectory,
-  leaseClaim,
-  leaseHeartbeat,
-  leaseRelease,
-  handoffOffer,
-  handoffAccept,
-  handoffDecline,
-  handoffCancel,
-  boardDecompose,
-  boardAssign,
-  boardLink,
-  governanceStatus,
-  approvalRequest,
-  approvalResolve,
-  approvalGet,
-  approvalList,
-  approvalWait,
-  decisionPropose,
-  decisionAdopt,
-  decisionSupersede,
-  decisionList,
-  costReport,
-  costRollup,
-  policyPublish,
-  policyFetch,
-  knowledgeAppend,
-  knowledgeReplace,
-  knowledgeRewrite,
-  knowledgeInvalidate,
-  knowledgeSearch,
-  contactsUpsert,
-  contactsList,
-  meetingsRecord,
-  meetingsList,
-  credentialLease,
-  credentialPut,
-  credentialList,
-  credentialRevoke,
-  fetchSelfProfile,
-  fetchOrgChart,
-  fetchRelationships,
-  fetchStrategy,
-  fetchHierarchy,
-  callingStart,
-  callingJoin,
-  callingInvite,
-  callingEnd,
-  callingAddTranscriptLine,
-  callingChat,
-  callingAppShareStart,
-  callingAppShareAct,
-  callingAppShareEnd,
-  callingGetAppShare,
-  callingGetVisualContext,
-  callingGetCallEvents,
-  pairApprove,
-  brandingRegenerate,
-  brandingRegenerateTemplates,
-  brandingRegenerateTemplate,
-  brandingRegenerateImages,
-  brandingUploadImage,
-  brandingAmendArtifact,
-  brandingAmendTemplate,
-  brandingCloneTemplate,
-  brandingDeleteTemplate,
-  brandingRestoreVersion,
-  brandingUndo,
-  brandingRedo,
-  brandingListVersions,
-  brandingExportTemplate,
-} from "./client.mjs";
-import { PROTOCOL_VERSION } from "./protocol.mjs";
-
-const BASE = "https://org.cohortapp.com";
-const TOKEN = "tok-abc";
-
-// Ambient COHORT_* tokens would leak into the "no token configured" assertions
-// below; clear them so tests are deterministic regardless of the host env.
-delete process.env.COHORT_API_TOKEN;
-delete process.env.COHORT_TOKEN;
-
-/** A fake fetch that records calls and returns a canned res frame. */
-function fakeFetch(responder) {
-  const calls = [];
-  const impl = async (url, init) => {
-    calls.push({ url, init, headers: (init && init.headers) || {} });
-    const r = responder ? responder(url, init, calls.length - 1) : null;
-    const status = r && typeof r.status === "number" ? r.status : 200;
-    const ok = r && typeof r.ok === "boolean" ? r.ok : status >= 200 && status < 300;
-    const body = r ? r.body : { ok: true, result: null };
-    return {
-      ok,
-      status,
-      headers: { get: (k) => (r && r.respHeaders ? r.respHeaders[k.toLowerCase()] : undefined) },
-      json: async () => body,
-    };
-  };
-  impl.calls = calls;
-  return impl;
-}
-
-// --- config ----------------------------------------------------------------
-
-test("isEnabled: requires enabled + (base or apiUrl+orgId)", () => {
-  assert.equal(isEnabled({ org: { cohort: { enabled: true, base: BASE } } }), true);
-  assert.equal(isEnabled({ org: { cohort: { enabled: true, apiUrl: "x", orgId: "o" } } }), true);
-  assert.equal(isEnabled({ org: { cohort: { enabled: false, base: BASE } } }), false);
-  assert.equal(isEnabled({ org: { cohort: { enabled: true } } }), false);
-  assert.equal(isEnabled(null), false);
-});
-
-test("configFromAgent: explicit base wins; legacy apiUrl/orgId derives base; env token", () => {
-  const a = configFromAgent({ org: { cohort: { enabled: true, base: BASE + "/", token: "t1", trustedSignersPem: ["PEM"] } } });
-  assert.equal(a.base, BASE);
-  assert.equal(a.token, "t1");
-  assert.deepEqual(a.trustedSignersPem, ["PEM"]);
-  assert.equal(a.enabled, true);
-
-  const b = configFromAgent({ org: { cohort: { enabled: true, apiUrl: "https://api.x/", orgId: "acme" } } });
-  assert.equal(b.base, "https://api.x/acme");
-
-  const prev = process.env.COHORT_API_TOKEN;
-  process.env.COHORT_API_TOKEN = "env-tok";
-  try {
-    const c = configFromAgent({ org: { cohort: { enabled: true, base: BASE } } });
-    assert.equal(c.token, "env-tok");
-  } finally {
-    if (prev === undefined) delete process.env.COHORT_API_TOKEN; else process.env.COHORT_API_TOKEN = prev;
-  }
-});
-
-test("configFromAgent: COHORT_API_KEY populates token when no config/COHORT_API_TOKEN/COHORT_TOKEN; COHORT_ORG_ID populates orgId", () => {
-  // Snapshot + clear all four hq-documented vars to stay hermetic.
-  const snap = {
-    tok: process.env.COHORT_API_TOKEN,
-    legacy: process.env.COHORT_TOKEN,
-    key: process.env.COHORT_API_KEY,
-    org: process.env.COHORT_ORG_ID,
-  };
-  delete process.env.COHORT_API_TOKEN;
-  delete process.env.COHORT_TOKEN;
-  delete process.env.COHORT_API_KEY;
-  delete process.env.COHORT_ORG_ID;
-  try {
-    process.env.COHORT_API_KEY = "raw-org-key";
-    process.env.COHORT_ORG_ID = "acme";
-    const c = configFromAgent({ org: { cohort: { enabled: true, base: BASE } } });
-    assert.equal(c.token, "raw-org-key", "COHORT_API_KEY is a token source");
-    assert.equal(c.orgId, "acme", "COHORT_ORG_ID is an orgId fallback");
-
-    // config token still wins over the env key.
-    const c2 = configFromAgent({ org: { cohort: { enabled: true, base: BASE, token: "cfg-tok" } } });
-    assert.equal(c2.token, "cfg-tok");
-
-    // COHORT_API_TOKEN takes precedence over COHORT_API_KEY.
-    process.env.COHORT_API_TOKEN = "primary";
-    const c3 = configFromAgent({ org: { cohort: { enabled: true, base: BASE } } });
-    assert.equal(c3.token, "primary");
-  } finally {
-    for (const [k, v] of [["COHORT_API_TOKEN", snap.tok], ["COHORT_TOKEN", snap.legacy], ["COHORT_API_KEY", snap.key], ["COHORT_ORG_ID", snap.org]]) {
-      if (v === undefined) delete process.env[k]; else process.env[k] = v;
-    }
-  }
-});
-
-test("call/read: send x-org-id pin only when an orgId is supplied", async () => {
-  const f1 = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  await call("registry.heartbeat", { id: "a" }, { base: BASE, token: TOKEN, orgId: "acme", fetchImpl: f1 });
-  assert.equal(f1.calls[0].headers["x-org-id"], "acme");
-
-  const f2 = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  await call("registry.heartbeat", { id: "a" }, { base: BASE, token: TOKEN, fetchImpl: f2 });
-  assert.equal(f2.calls[0].headers["x-org-id"], undefined);
-
-  const f3 = fakeFetch(() => ({ body: { members: [] } }));
-  await read("directory", { base: BASE, token: TOKEN, orgId: "acme", fetchImpl: f3 });
-  assert.equal(f3.calls[0].headers["x-org-id"], "acme");
-});
-
-// --- RPC headers + routing -------------------------------------------------
-
-test("call: posts to /api/v1/{method} (hq's canonical mount) with Bearer + x-org-protocol headers", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { id: "x" } } }));
-  const frame = await call("registry.heartbeat", { id: "a" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.deepEqual(frame, { ok: true, result: { id: "x" } });
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/registry.heartbeat`);
-  assert.equal(f.calls[0].init.method, "POST");
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.equal(f.calls[0].headers["x-org-protocol"], String(PROTOCOL_VERSION));
-  assert.equal(f.calls[0].headers["content-type"], "application/json");
-  assert.equal(f.calls[0].init.body, JSON.stringify({ id: "a" }));
-});
-
-test("call: side-effecting method sends x-idempotency-key when supplied", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  await call("board.claim", { id: "item-1" }, { base: BASE, token: TOKEN, idempotencyKey: "key-123", fetchImpl: f });
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "key-123");
-});
-
-test("call: back-compat — a base already carrying the /v1 or /api/v1 mount is respected, not double-prefixed", async () => {
-  const f1 = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  await call("registry.heartbeat", { id: "a" }, { base: `${BASE}/api/v1`, token: TOKEN, fetchImpl: f1 });
-  assert.equal(f1.calls[0].url, `${BASE}/api/v1/registry.heartbeat`);
-  const f2 = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  await call("registry.heartbeat", { id: "a" }, { base: `${BASE}/v1`, token: TOKEN, fetchImpl: f2 });
-  assert.equal(f2.calls[0].url, `${BASE}/v1/registry.heartbeat`, "legacy bare /v1 mount honoured for back-compat");
-});
-
-test("call: idempotent method auto-derives an idempotency key from id", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  await call("board.create", { id: "item-7" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "board.create:item-7");
-});
-
-test("call: non-side-effecting read-style call sends NO idempotency key", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  // registry.heartbeat is side-effecting but NOT idempotent and no key passed → none synthesised
-  await call("registry.heartbeat", { id: "a" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(f.calls[0].headers["x-idempotency-key"], undefined);
-});
-
-test("call: pre-auth method (pairing.request) sends NO bearer token", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { status: "pending", code: "ABCD" } } }));
-  await call("pairing.request", { agentId: "a", pubkey: "P" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(f.calls[0].headers.authorization, undefined);
-});
-
-test("call: unknown method → NOT_FOUND error frame, no fetch", async () => {
-  const f = fakeFetch();
-  const frame = await call("bogus.method", {}, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "NOT_FOUND");
-  assert.equal(f.calls.length, 0);
-});
-
-test("call: missing base → BAD_REQUEST error frame (fail-open)", async () => {
-  const frame = await call("board.claim", { id: "x" }, { token: TOKEN });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "BAD_REQUEST");
-});
-
-test("call: transport throw → INTERNAL error frame (fail-open, no throw)", async () => {
-  const f = async () => { throw new Error("ECONNREFUSED"); };
-  const frame = await call("board.claim", { id: "x" }, { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "INTERNAL");
-});
-
-test("call: HTTP 409 (claim race loser) maps to CONFLICT error frame", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 409, body: { ok: false, error: { code: "CONFLICT", message: "lost race" } } }));
-  const frame = await call("board.claim", { id: "x" }, { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "CONFLICT");
-});
-
-// --- typed helpers route to the right methods ------------------------------
-
-test("typed helpers route to their methods", async () => {
-  const seen = [];
-  const f = fakeFetch((url) => { seen.push(url); return { body: { ok: true, result: null } }; });
-  const o = { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f };
-  await register({ id: "a" }, o);
-  await heartbeat({ id: "a" }, o);
-  await presenceBeat({ id: "a" }, o);
-  await createItem({ id: "i" }, o);
-  await claimItem({ id: "i" }, o);
-  await completeItem({ id: "i" }, o);
-  assert.deepEqual(seen, [
-    `${BASE}/api/v1/registry.register`,
-    `${BASE}/api/v1/registry.heartbeat`,
-    `${BASE}/api/v1/presence.beat`,
-    `${BASE}/api/v1/board.create`,
-    `${BASE}/api/v1/board.claim`,
-    `${BASE}/api/v1/board.complete`,
-  ]);
-});
-
-test("presenceBeat: surfaces directives from result", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { directives: ["halt"] } } }));
-  const frame = await presenceBeat({ id: "a" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.deepEqual(frame.result.directives, ["halt"]);
-});
-
-// --- phase-2 typed helpers: lease / handoff / board DAG / governance --------
-
-test("phase-2 helpers route to their /v1 methods", async () => {
-  const seen = [];
-  const f = fakeFetch((url) => { seen.push(url); return { body: { ok: true, result: null } }; });
-  const o = { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f };
-  await leaseClaim({ scope: "thread-ownership", resourceId: "r" }, o);
-  await leaseHeartbeat({ scope: "thread-ownership", resourceId: "r", leaseToken: "lt" }, o);
-  await leaseRelease({ scope: "thread-ownership", resourceId: "r", leaseToken: "lt" }, o);
-  await handoffOffer({ handoffId: "h1", to: "bob" }, o);
-  await handoffAccept({ handoffId: "h1" }, o);
-  await handoffDecline({ handoffId: "h1" }, o);
-  await handoffCancel({ handoffId: "h1" }, o);
-  await boardDecompose({ itemId: "i", children: [] }, o);
-  await boardAssign({ itemId: "i", assignee: "bob" }, o);
-  await boardLink({ fromItemId: "i", toItemId: "j" }, o);
-  await governanceStatus(o);
-  assert.deepEqual(seen, [
-    `${BASE}/api/v1/lease.claim`,
-    `${BASE}/api/v1/lease.heartbeat`,
-    `${BASE}/api/v1/lease.release`,
-    `${BASE}/api/v1/handoff.offer`,
-    `${BASE}/api/v1/handoff.accept`,
-    `${BASE}/api/v1/handoff.decline`,
-    `${BASE}/api/v1/handoff.cancel`,
-    `${BASE}/api/v1/board.decompose`,
-    `${BASE}/api/v1/board.assign`,
-    `${BASE}/api/v1/board.link`,
-    `${BASE}/api/v1/governance.status`,
-  ]);
-});
-
-test("leaseClaim: side-effecting → sends Bearer + x-idempotency-key when supplied", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { token: "lt-1" } } }));
-  const frame = await leaseClaim({ scope: "thread-ownership", resourceId: "r" }, { base: BASE, token: TOKEN, idempotencyKey: "key-1", fetchImpl: f });
-  assert.equal(frame.result.token, "lt-1");
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "key-1");
-});
-
-test("handoffOffer: governance-gated → surfaces GOVERNANCE_NOT_READY (HTTP 423)", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 423, body: { ok: false, error: { code: "GOVERNANCE_NOT_READY", message: "not ready" } } }));
-  const frame = await handoffOffer({ handoffId: "h1", to: "bob" }, { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "GOVERNANCE_NOT_READY");
-});
-
-test("governanceStatus: returns the readiness result frame", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { governanceReady: false, decisionRightsCount: 0, signingLive: true } } }));
-  const frame = await governanceStatus({ base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(frame.result.governanceReady, false);
-  assert.equal(frame.result.decisionRightsCount, 0);
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/governance.status`);
-});
-
-// --- pairing handshake -----------------------------------------------------
-
-test("pairRequest: POSTs pubkey pre-auth, returns code", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { status: "pending", code: "WXYZ" } } }));
-  const frame = await pairRequest({ base: BASE, agentId: "alex", displayName: "Alex", pubkey: "PEM", fetchImpl: f });
-  assert.equal(frame.ok, true);
-  assert.equal(frame.result.code, "WXYZ");
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/pairing.request`);
-  assert.equal(f.calls[0].headers.authorization, undefined);
-  const body = JSON.parse(f.calls[0].init.body);
-  assert.equal(body.agentId, "alex");
-  assert.equal(body.pubkey, "PEM");
-});
-
-test("pairRequest: missing fields → BAD_REQUEST, no fetch", async () => {
-  const f = fakeFetch();
-  assert.equal((await pairRequest({ base: BASE, fetchImpl: f })).error.code, "BAD_REQUEST");
-  assert.equal((await pairRequest({ agentId: "a", pubkey: "P", fetchImpl: f })).error.code, "BAD_REQUEST");
-  assert.equal(f.calls.length, 0);
-});
-
-test("pairApprove: authed admin call routes to pairing.approve with Bearer", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { status: "approved" } } }));
-  const frame = await pairApprove({ code: "WXYZ" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(frame.result.status, "approved");
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/pairing.approve`);
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.equal(JSON.parse(f.calls[0].init.body).code, "WXYZ");
-});
-
-// --- calling wrappers (SP3/SP10 lifecycle + agent-operability) --------------
-
-test("calling wrappers route to their /v1 methods", async () => {
-  const seen = [];
-  const f = fakeFetch((url) => { seen.push(url); return { body: { ok: true, result: null } }; });
-  const o = { base: BASE, token: TOKEN, fetchImpl: f };
-  await callingStart({ channelId: "c" }, o);
-  await callingJoin({ callId: "k" }, o);
-  await callingInvite({ callId: "k", memberIds: ["m"] }, o);
-  await callingEnd({ callId: "k" }, o);
-  await callingAddTranscriptLine({ callId: "k", text: "hi" }, o);
-  await callingChat({ callId: "k", text: "yo" }, o);
-  assert.deepEqual(seen, [
-    `${BASE}/api/v1/calling.start`,
-    `${BASE}/api/v1/calling.join`,
-    `${BASE}/api/v1/calling.invite`,
-    `${BASE}/api/v1/calling.end`,
-    `${BASE}/api/v1/calling.addTranscriptLine`,
-    `${BASE}/api/v1/calling.chat`,
-  ]);
-});
-
-// --- calling working sessions + vision fusion (2026-08) ---------------------
-
-test("calling working-session wrappers route to their /v1 methods", async () => {
-  const seen = [];
-  const f = fakeFetch((url) => { seen.push(url); return { body: { ok: true, result: null } }; });
-  const o = { base: BASE, token: TOKEN, fetchImpl: f };
-  await callingAppShareStart({ callId: "k", surface: { kind: "doc", ref: "f-1", title: "Q3 plan" } }, o);
-  await callingAppShareAct({ callId: "k", sessionId: "s1", steps: [{ k: "scroll", anchor: "top" }] }, o);
-  await callingAppShareEnd({ callId: "k", sessionId: "s1" }, o);
-  await callingGetAppShare({ callId: "k" }, o);
-  await callingGetVisualContext({ callId: "k", limit: 20 }, o);
-  await callingGetCallEvents({ callId: "k", limit: 30 }, o);
-  assert.deepEqual(seen, [
-    `${BASE}/api/v1/calling.appShareStart`,
-    `${BASE}/api/v1/calling.appShareAct`,
-    `${BASE}/api/v1/calling.appShareEnd`,
-    `${BASE}/api/v1/calling.getAppShare`,
-    `${BASE}/api/v1/calling.getVisualContext`,
-    `${BASE}/api/v1/calling.getCallEvents`,
-  ]);
-});
-
-test("callingAppShareAct: side-effecting → Bearer + supplied idempotency key, POSTs the step batch", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { seq: 2 } } }));
-  const steps = [{ k: "highlight", anchor: "block:3", note: "revenue line" }];
-  const frame = await callingAppShareAct(
-    { callId: "k", sessionId: "s1", steps },
-    { base: BASE, token: TOKEN, idempotencyKey: "ik-1", fetchImpl: f },
-  );
-  assert.equal(frame.result.seq, 2);
-  assert.equal(f.calls[0].init.method, "POST");
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "ik-1");
-  assert.deepEqual(JSON.parse(f.calls[0].init.body).steps, steps);
-});
-
-test("callingGetAppShare: read-style call sends NO idempotency key; null session is a normal result", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  const frame = await callingGetAppShare({ callId: "k" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(frame.ok, true);
-  assert.equal(frame.result, null, "no active session is a result, not an error");
-  assert.equal(f.calls[0].headers["x-idempotency-key"], undefined);
-});
-
-test("callingAppShareStart: CONFLICT while another member presents surfaces as an error frame (fail-open)", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 409, body: { ok: false, error: { code: "CONFLICT", message: "another member is presenting" } } }));
-  const frame = await callingAppShareStart({ callId: "k", surface: { kind: "doc", ref: "f-1" } }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "CONFLICT");
-});
-
-test("callingAddTranscriptLine: side-effecting → sends Bearer, POSTs the line body", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { lineId: "l1" } } }));
-  const frame = await callingAddTranscriptLine({ callId: "k", text: "final line" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(frame.result.lineId, "l1");
-  assert.equal(f.calls[0].init.method, "POST");
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.equal(JSON.parse(f.calls[0].init.body).text, "final line");
-});
-
-test("callingChat: CONFLICT on an ended call surfaces as an error frame (fail-open)", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 409, body: { ok: false, error: { code: "CONFLICT", message: "call has already ended" } } }));
-  const frame = await callingChat({ callId: "k", text: "late" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "CONFLICT");
-});
-
-// --- branding wrappers (Brand Studio v2 write surface) ---------------------
-
-test("branding wrappers route to their /v1 methods", async () => {
-  const seen = [];
-  const f = fakeFetch((url) => { seen.push(url); return { body: { ok: true, result: null } }; });
-  const o = { base: BASE, token: TOKEN, fetchImpl: f };
-  await brandingRegenerate({}, o);
-  await brandingRegenerateTemplates({}, o);
-  await brandingRegenerateTemplate({ slug: "hero" }, o);
-  await brandingRegenerateImages({}, o);
-  await brandingUploadImage({ slot: "logo", dataUrl: "data:," }, o);
-  await brandingAmendArtifact({ key: "tagline", instruction: "punchier" }, o);
-  await brandingAmendTemplate({ slug: "hero", instruction: "warmer" }, o);
-  await brandingCloneTemplate({ baseRef: "registry:hero" }, o);
-  await brandingDeleteTemplate({ slug: "hero" }, o);
-  await brandingRestoreVersion({ targetKind: "TEMPLATE", ref: "hero", seq: 2 }, o);
-  await brandingUndo({ targetKind: "ARTIFACT", ref: "tagline" }, o);
-  await brandingRedo({ targetKind: "ARTIFACT", ref: "tagline" }, o);
-  await brandingListVersions({ targetKind: "TEMPLATE", ref: "hero" }, o);
-  await brandingExportTemplate({ templateId: "hero", sizeId: "desktop", theme: "light" }, o);
-  assert.deepEqual(seen, [
-    `${BASE}/api/v1/branding.regenerate`,
-    `${BASE}/api/v1/branding.regenerateTemplates`,
-    `${BASE}/api/v1/branding.regenerateTemplate`,
-    `${BASE}/api/v1/branding.regenerateImages`,
-    `${BASE}/api/v1/branding.uploadImage`,
-    `${BASE}/api/v1/branding.amendArtifact`,
-    `${BASE}/api/v1/branding.amendTemplate`,
-    `${BASE}/api/v1/branding.cloneTemplate`,
-    `${BASE}/api/v1/branding.deleteTemplate`,
-    `${BASE}/api/v1/branding.restoreVersion`,
-    `${BASE}/api/v1/branding.undo`,
-    `${BASE}/api/v1/branding.redo`,
-    `${BASE}/api/v1/branding.listVersions`,
-    `${BASE}/api/v1/branding.exportTemplate`,
-  ]);
-});
-
-test("design read/propose wrappers route to their /v1 branding.* methods", async () => {
-  const {
-    brandingGetFoundation, brandingGetVoice, brandingListTemplates, brandingRenderTemplate,
-    brandingRewriteInVoice, brandingExportKit, brandingGenerateImage, brandingProposeChange,
-    brandingSaveFoundation, brandingRestoreFoundation,
-  } = await import("./client.mjs");
-  const seen = [];
-  const f = fakeFetch((url) => { seen.push(url); return { body: { ok: true, result: null } }; });
-  const o = { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f };
-  await brandingGetFoundation({ historyLimit: 5 }, o);
-  await brandingGetVoice({}, o);
-  await brandingListTemplates({ category: "email" }, o);
-  await brandingRenderTemplate({ templateId: "hero", format: "html" }, o);
-  await brandingRewriteInVoice({ text: "we are excited to announce" }, o);
-  await brandingExportKit({ unit: "rem" }, o);
-  await brandingGenerateImage({ budgetCents: 0 }, o);
-  await brandingProposeChange({ patch: { fonts: { display: "Söhne" } }, note: "tighter display face" }, o);
-  await brandingSaveFoundation({ foundation: {}, expectedVersionId: null }, o);
-  await brandingRestoreFoundation({ versionId: "v9" }, o);
-  assert.deepEqual(seen, [
-    `${BASE}/api/v1/branding.getFoundation`,
-    `${BASE}/api/v1/branding.getVoice`,
-    `${BASE}/api/v1/branding.listTemplates`,
-    `${BASE}/api/v1/branding.renderTemplate`,
-    `${BASE}/api/v1/branding.rewriteInVoice`,
-    `${BASE}/api/v1/branding.exportKit`,
-    `${BASE}/api/v1/branding.generateImage`,
-    `${BASE}/api/v1/branding.proposeChange`,
-    `${BASE}/api/v1/branding.saveFoundation`,
-    `${BASE}/api/v1/branding.restoreFoundation`,
-  ]);
-  // budgetCents 0 is the QUOTE call — it must survive to the wire, not be
-  // dropped as falsy, or a caller asking for a price silently spends money.
-  assert.equal(JSON.parse(f.calls[6].init.body).budgetCents, 0);
-});
-
-test("branding writes send Bearer but NO idempotency key (surface owns its own versioned audit)", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  await brandingAmendTemplate({ slug: "hero", instruction: "warmer" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.equal(f.calls[0].headers["x-idempotency-key"], undefined);
-});
-
-test("brandingExportTemplate: read surface returns the render result frame", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { dataUrl: "data:image/png;base64,AAAA" } } }));
-  const frame = await brandingExportTemplate({ templateId: "hero" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(frame.result.dataUrl, "data:image/png;base64,AAAA");
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/branding.exportTemplate`);
-});
-
-// --- reads (GET) -----------------------------------------------------------
-
-test("read: GETs /v1/{path}, Bearer, no content-type, returns bare payload", async () => {
-  const f = fakeFetch(() => ({ body: { seq: 9, agents: [] } }));
-  const r = await read("snapshot", { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(r.ok, true);
-  assert.deepEqual(r.payload, { seq: 9, agents: [] });
-  assert.equal(f.calls[0].init.method, "GET");
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.equal(f.calls[0].headers["x-org-protocol"], String(PROTOCOL_VERSION));
-  assert.equal(f.calls[0].headers["content-type"], undefined);
-});
-
-test("read: passes If-None-Match and surfaces 304 notModified + ETag", async () => {
-  const f = fakeFetch(() => ({ ok: true, status: 304, respHeaders: { etag: "v2" } }));
-  const r = await read("directory", { base: BASE, token: TOKEN, etag: "v2", fetchImpl: f });
-  assert.equal(r.notModified, true);
-  assert.equal(r.status, 304);
-  assert.equal(f.calls[0].headers["if-none-match"], "v2");
-});
-
-test("read: surfaces ETag on a 200 response", async () => {
-  const f = fakeFetch(() => ({ body: { agents: [] }, respHeaders: { etag: "v3" } }));
-  const r = await read("directory", { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(r.etag, "v3");
-});
-
-test("read: HTTP error returns error frame body + status", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 401, body: { ok: false, error: { code: "UNAUTHORIZED", message: "bad token" } } }));
-  const r = await read("snapshot", { base: BASE, token: "stale", fetchImpl: f });
-  assert.equal(r.ok, false);
-  assert.equal(r.status, 401);
-  assert.equal(r.error.code, "UNAUTHORIZED");
-});
-
-test("read: transport throw → fail-open error, no throw", async () => {
-  const r = await read("snapshot", { base: BASE, token: TOKEN, fetchImpl: async () => { throw new Error("down"); } });
-  assert.equal(r.ok, false);
-  assert.equal(r.error.code, "INTERNAL");
-});
-
-// --- read helpers parse shapes + fail open ---------------------------------
-
-test("listReady: parses array and {items:[]}, [] on error", async () => {
-  assert.deepEqual(await listReady({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: [{ id: "1" }] })) }), [{ id: "1" }]);
-  assert.deepEqual(await listReady({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: { items: [{ id: "2" }] } })) }), [{ id: "2" }]);
-  assert.deepEqual(await listReady({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ ok: false, status: 500, body: {} })) }), []);
-});
-
-test("fetchEvents: builds cursor+limit query, parses array/{events:[]}", async () => {
-  const f = fakeFetch(() => ({ body: { events: [{ seq: 6 }] } }));
-  const ev = await fetchEvents(5, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.deepEqual(ev, [{ seq: 6 }]);
-  assert.match(f.calls[0].url, /\/v1\/events\?cursor=5&limit=500$/);
-  // custom limit
-  const f2 = fakeFetch(() => ({ body: [] }));
-  await fetchEvents(0, { base: BASE, token: TOKEN, limit: 50, fetchImpl: f2 });
-  assert.match(f2.calls[0].url, /cursor=0&limit=50$/);
-});
-
-test("fetchEvents: [] on transport failure", async () => {
-  assert.deepEqual(await fetchEvents(0, { base: BASE, token: TOKEN, fetchImpl: async () => { throw new Error("x"); } }), []);
-});
-
-test("fetchSnapshot: returns raw signed payload (does not verify), null on error", async () => {
-  const snap = { seq: 3, agents: [], sig: "BASE64SIG" };
-  assert.deepEqual(await fetchSnapshot({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: snap })) }), snap);
-  assert.equal(await fetchSnapshot({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ ok: false, status: 500, body: {} })) }), null);
-});
-
-// --- back-compat surface (drop-in for cohort-client.mjs) ------------------
-
-const ON = { org: { cohort: { enabled: true, base: BASE } } };
-const OFF = { org: { cohort: { enabled: false } } };
-
-test("publishEntry: no-op disabled; registers via /v1 when enabled", async () => {
-  assert.deepEqual(await publishEntry({ cfg: OFF, entry: { id: "a" } }), { ok: false, skipped: true });
-  assert.deepEqual(await publishEntry({ cfg: ON, entry: {} }), { ok: false, skipped: false, reason: "no-entry" });
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  const r = await publishEntry({ cfg: ON, entry: { id: "alex-ai", name: "Alex" }, fetchImpl: f });
-  assert.equal(r.ok, true);
-  assert.equal(r.status, 200);
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/registry.register`);
-  assert.equal(f.calls[0].init.method, "POST");
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "registry.register:alex-ai");
-});
-
-test("publishEntry: server error → {ok:false} (fail-open shape preserved)", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 500, body: { ok: false, error: { code: "INTERNAL", message: "boom" } } }));
-  const r = await publishEntry({ cfg: ON, entry: { id: "x" }, fetchImpl: f });
-  assert.equal(r.ok, false);
-});
-
-test("publishEntry: projects a rich assembleSelfEntry onto the strict registerSchema", async () => {
-  // The hq registerSchema is .strict() — a raw entry with an archetype OBJECT and
-  // extra fields would 400. publishEntry must trim to {displayName,archetype:string,
-  // humanSponsor,card}; everything else rides under `card`.
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  const entry = {
-    id: "robin-ai",
-    name: "Robin",
-    fullName: "Robin Vega",
-    archetype: { function: "engineering", altitude: "vp", label: "VP Eng" },
-    principal: { fullName: "Sam Human", title: "CEO" },
-    towers: [{ id: "t1", name: "Platform" }],
-    focus: [{ title: "ship" }],
-    presence: { active: 2 },
-  };
-  await publishEntry({ cfg: ON, entry, fetchImpl: f });
-  const sent = JSON.parse(f.calls[0].init.body);
-  assert.deepEqual(Object.keys(sent).sort(), ["archetype", "card", "displayName", "humanSponsor"].sort());
-  assert.equal(sent.displayName, "Robin Vega");
-  assert.equal(sent.archetype, "VP Eng");
-  assert.equal(sent.humanSponsor, "Sam Human");
-  assert.equal(sent.card.id, "robin-ai");
-  assert.deepEqual(sent.card.towers, entry.towers);
-});
-
-test("fetchDirectory: [] disabled; parses array + {members:[]} + {agents:[]}; [] on error", async () => {
-  assert.deepEqual(await fetchDirectory({ cfg: OFF }), []);
-  const arr = await fetchDirectory({ cfg: ON, fetchImpl: fakeFetch(() => ({ body: [{ id: "x" }] })) });
-  assert.equal(arr.length, 1);
-  assert.equal(arr[0].id, "x");
-  // hq shape: GET /v1/directory → { members: [...] } with per-member status snapshot
-  const members = await fetchDirectory({ cfg: ON, fetchImpl: fakeFetch(() => ({ body: { members: [{ id: "m1", status: { state: "busy" } }, { id: "m2", status: null }] } })) });
-  assert.equal(members.length, 2);
-  assert.equal(members[0].status.state, "busy");
-  const wrapped = await fetchDirectory({ cfg: ON, fetchImpl: fakeFetch(() => ({ body: { agents: [{ id: "y" }, { id: "z" }] } })) });
-  assert.equal(wrapped.length, 2);
-  const errd = await fetchDirectory({ cfg: ON, fetchImpl: async () => { throw new Error("net down"); } });
-  assert.deepEqual(errd, []);
-});
-
-// --- phase-3 typed helpers: approvals / decisions / cost / policy ----------
-
-test("phase-3 RPC helpers route to their /v1 methods", async () => {
-  const seen = [];
-  const f = fakeFetch((url) => { seen.push(url); return { body: { ok: true, result: null } }; });
-  const o = { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f };
-  await approvalRequest({ id: "ap-1", kind: "exec", subject: "x", payload_hash: "h" }, o);
-  await approvalResolve({ id: "ap-1", decision: "approved" }, o);
-  await approvalGet({ id: "ap-1" }, o);
-  await approvalList({ status: "pending" }, o);
-  await decisionPropose({ id: "d-1", title: "t" }, o);
-  await decisionAdopt({ id: "d-1" }, o);
-  await decisionSupersede({ id: "d-1", supersededBy: "d-2" }, o);
-  await costReport({ rows: [{ id: "r-1" }] }, o);
-  await policyPublish({ bundleId: "b", version: 1, kind: "x", content: "{}", content_sig: "s", source_commit: "c" }, o);
-  assert.deepEqual(seen, [
-    `${BASE}/api/v1/approval.request`,
-    `${BASE}/api/v1/approval.resolve`,
-    `${BASE}/api/v1/approval.get`,
-    `${BASE}/api/v1/approval.list`,
-    `${BASE}/api/v1/decision.propose`,
-    `${BASE}/api/v1/decision.adopt`,
-    `${BASE}/api/v1/decision.supersede`,
-    `${BASE}/api/v1/cost.report`,
-    `${BASE}/api/v1/policy.publish`,
-  ]);
-});
-
-test("approvalRequest: idempotent method auto-derives x-idempotency-key from id", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { id: "ap-9" } } }));
-  await approvalRequest({ id: "ap-9", kind: "exec", payload_hash: "h" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "approval.request:ap-9");
-});
-
-test("approvalResolve: needs approval.decide scope server-side → surfaces FORBIDDEN_SCOPE", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 403, body: { ok: false, error: { code: "FORBIDDEN_SCOPE", message: "approval.decide required" } } }));
-  const frame = await approvalResolve({ id: "ap-1", decision: "approved" }, { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "FORBIDDEN_SCOPE");
-});
-
-test("decisionAdopt: governance-gated → surfaces GOVERNANCE_NOT_READY (423)", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 423, body: { ok: false, error: { code: "GOVERNANCE_NOT_READY", message: "x" } } }));
-  const frame = await decisionAdopt({ id: "d-1" }, { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f });
-  assert.equal(frame.error.code, "GOVERNANCE_NOT_READY");
-});
-
-test("approvalWait: GETs the bounded long-poll, clamps timeoutMs to 55000", async () => {
-  const f = fakeFetch(() => ({ body: { id: "ap-1", status: "approved" } }));
-  const r = await approvalWait({ id: "ap-1", timeoutMs: 999999 }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(r.ok, true);
-  assert.equal(r.payload.status, "approved");
-  assert.match(f.calls[0].url, /\/v1\/approval\.wait\?id=ap-1&timeoutMs=55000$/);
-  assert.equal(f.calls[0].init.method, "GET");
-});
-
-test("approvalWait: default (no timeoutMs) uses the 55000 ceiling; missing id → BAD_REQUEST", async () => {
-  const f = fakeFetch(() => ({ body: { id: "ap-2", status: "pending" } }));
-  await approvalWait({ id: "ap-2" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.match(f.calls[0].url, /timeoutMs=55000$/);
-  const bad = await approvalWait({}, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(bad.ok, false);
-  assert.equal(bad.error.code, "BAD_REQUEST");
-});
-
-test("decisionList: parses array + {decisions:[]}, [] on error; appends status query", async () => {
-  assert.deepEqual(await decisionList({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: [{ id: "d1" }] })) }), [{ id: "d1" }]);
-  const f = fakeFetch(() => ({ body: { decisions: [{ id: "d2" }] } }));
-  const r = await decisionList({ base: BASE, token: TOKEN, status: "adopted", fetchImpl: f });
-  assert.deepEqual(r, [{ id: "d2" }]);
-  assert.match(f.calls[0].url, /\/v1\/decision\.list\?status=adopted$/);
-  assert.deepEqual(await decisionList({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ ok: false, status: 500, body: {} })) }), []);
-});
-
-test("costRollup: returns bare payload, appends day/agent query, null on error", async () => {
-  const f = fakeFetch(() => ({ body: { day: "2026-06-11", byAgent: {} } }));
-  const r = await costRollup({ base: BASE, token: TOKEN, day: "2026-06-11", agent: "alex", fetchImpl: f });
-  assert.equal(r.day, "2026-06-11");
-  assert.match(f.calls[0].url, /\/v1\/cost\.rollup\?day=2026-06-11&agent=alex$/);
-  assert.equal(await costRollup({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ ok: false, status: 500, body: {} })) }), null);
-});
-
-test("policyFetch: returns raw signed bundle (does not verify), null on error; appends kind", async () => {
-  const bundle = { kind: "communication-style", version: 7, content: "{}", content_sig: "SIG" };
-  const f = fakeFetch(() => ({ body: bundle }));
-  const r = await policyFetch({ base: BASE, token: TOKEN, kind: "communication-style", fetchImpl: f });
-  assert.deepEqual(r, bundle);
-  assert.match(f.calls[0].url, /\/v1\/policy\?kind=communication-style$/);
-  assert.equal(await policyFetch({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ ok: false, status: 404, body: {} })) }), null);
-});
-
-test("policyPublish: admin reserved namespace — surfaces FORBIDDEN_SCOPE for a non-admin token", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 403, body: { ok: false, error: { code: "FORBIDDEN_SCOPE", message: "admin required" } } }));
-  const frame = await policyPublish({ bundleId: "b", version: 1, kind: "x", content: "{}", content_sig: "s", source_commit: "c" }, { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f });
-  assert.equal(frame.error.code, "FORBIDDEN_SCOPE");
-});
-
-test("fetchDirectory: GETs /v1/directory; Bearer set when a token is configured", async () => {
-  // no token configured on ON → no authorization header
-  const f1 = fakeFetch(() => ({ body: { agents: [] } }));
-  await fetchDirectory({ cfg: ON, fetchImpl: f1 });
-  assert.equal(f1.calls[0].url, `${BASE}/api/v1/directory`);
-  assert.equal(f1.calls[0].headers.authorization, undefined);
-  // token in config → Bearer header present
-  const f2 = fakeFetch(() => ({ body: { agents: [] } }));
-  await fetchDirectory({ cfg: { org: { cohort: { enabled: true, base: BASE, token: "cfg-tok" } } }, fetchImpl: f2 });
-  assert.equal(f2.calls[0].headers.authorization, "Bearer cfg-tok");
-});
-
-// --- phase-4 typed helpers: knowledge plane / contacts / meetings ----------
-
-test("phase-4 RPC helpers route to their /v1 methods", async () => {
-  const seen = [];
-  const f = fakeFetch((url) => { seen.push(url); return { body: { ok: true, result: null } }; });
-  const o = { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f };
-  await knowledgeAppend({ id: "k-1", text: "episode" }, o);
-  await knowledgeReplace({ id: "k-1", expectedVersion: 2, text: "v2" }, o);
-  await knowledgeRewrite({ id: "k-1", text: "owned rewrite" }, o);
-  await knowledgeInvalidate({ id: "k-1", reason: "stale" }, o);
-  await knowledgeSearch({ query: "deal terms" }, o);
-  await contactsUpsert({ id: "c-1", name: "Jordan" }, o);
-  await meetingsRecord({ id: "m-1", title: "board sync" }, o);
-  assert.deepEqual(seen, [
-    `${BASE}/api/v1/knowledge.append`,
-    `${BASE}/api/v1/knowledge.replace`,
-    `${BASE}/api/v1/knowledge.rewrite`,
-    `${BASE}/api/v1/knowledge.invalidate`,
-    `${BASE}/api/v1/knowledge.search`,
-    `${BASE}/api/v1/contacts.upsert`,
-    `${BASE}/api/v1/meetings.record`,
-  ]);
-});
-
-test("knowledgeAppend: idempotent → auto-derives x-idempotency-key from id; Bearer set", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { id: "k-7" } } }));
-  await knowledgeAppend({ id: "k-7", text: "episode" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "knowledge.append:k-7");
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-});
-
-test("knowledgeReplace: CAS stale version → surfaces CONFLICT (409)", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 409, body: { ok: false, error: { code: "CONFLICT", message: "stale version" } } }));
-  const frame = await knowledgeReplace({ id: "k-1", expectedVersion: 1, text: "x" }, { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "CONFLICT");
-});
-
-test("knowledgeRewrite: non-owner → surfaces FORBIDDEN_SCOPE (403)", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 403, body: { ok: false, error: { code: "FORBIDDEN_SCOPE", message: "owner only" } } }));
-  const frame = await knowledgeRewrite({ id: "k-1", text: "x" }, { base: BASE, token: TOKEN, idempotencyKey: "k", fetchImpl: f });
-  assert.equal(frame.error.code, "FORBIDDEN_SCOPE");
-});
-
-test("knowledgeSearch: side-effecting (POST), Bearer set, posts the query body", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { facts: [{ id: "k-1" }], returned_ids: ["k-1"], groups_considered: ["org"] } } }));
-  const frame = await knowledgeSearch({ query: "q", group: "org", limit: 5 }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(f.calls[0].init.method, "POST");
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/knowledge.search`);
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  // The wire contract canonicalises `query`→`q` (hq reads `p.q ?? p.query`) and
-  // keeps the legacy name alongside for an older server.
-  assert.deepEqual(JSON.parse(f.calls[0].init.body), { query: "q", q: "q", group: "org", limit: 5 });
-  assert.deepEqual(frame.result.returned_ids, ["k-1"]);
-});
-
-test("contactsList: GETs /v1/contacts.list, parses array + {contacts:[]}, [] on error", async () => {
-  assert.deepEqual(await contactsList({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: [{ id: "c1" }] })) }), [{ id: "c1" }]);
-  const f = fakeFetch(() => ({ body: { contacts: [{ id: "c2" }] } }));
-  const r = await contactsList({ base: BASE, token: TOKEN, q: "jord", group: "org", limit: 10, fetchImpl: f });
-  assert.deepEqual(r, [{ id: "c2" }]);
-  assert.match(f.calls[0].url, /\/v1\/contacts\.list\?q=jord&group=org&limit=10$/);
-  assert.deepEqual(await contactsList({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ ok: false, status: 500, body: {} })) }), []);
-});
-
-test("meetingsList: GETs /v1/meetings.list, parses array + {meetings:[]}, [] on error; appends since", async () => {
-  assert.deepEqual(await meetingsList({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: [{ id: "m1" }] })) }), [{ id: "m1" }]);
-  const f = fakeFetch(() => ({ body: { meetings: [{ id: "m2" }] } }));
-  const r = await meetingsList({ base: BASE, token: TOKEN, since: "2026-06-01", fetchImpl: f });
-  assert.deepEqual(r, [{ id: "m2" }]);
-  assert.match(f.calls[0].url, /\/v1\/meetings\.list\?since=2026-06-01$/);
-  assert.deepEqual(await meetingsList({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ ok: false, status: 500, body: {} })) }), []);
-});
-
-// --- org credential broker --------------------------------------------------
-
-test("credentialLease: POSTs /v1/credential.lease with Bearer + protocol; returns plaintext in the result", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { provider: "deepseek", value: "sk-leased", ttlMs: 600000, expiresAt: "2026-06-11T00:10:00Z" } } }));
-  const frame = await credentialLease({ provider: "deepseek" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(f.calls[0].init.method, "POST");
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/credential.lease`);
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.equal(f.calls[0].headers["x-org-protocol"], String(PROTOCOL_VERSION));
-  assert.deepEqual(JSON.parse(f.calls[0].init.body), { provider: "deepseek" });
-  assert.equal(frame.result.value, "sk-leased");
-  assert.equal(frame.result.ttlMs, 600000);
-});
-
-test("credentialLease: side-effecting, but NOT auto-idempotent (each lease is a fresh audited grant)", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { value: "x" } } }));
-  await credentialLease({ provider: "moonshot" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(f.calls[0].headers["x-idempotency-key"], undefined, "no auto key on a non-idempotent method");
-});
-
-test("credentialLease: FORBIDDEN_SCOPE (role not permitted) surfaces as an error frame (403)", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 403, body: { ok: false, error: { code: "FORBIDDEN_SCOPE", message: "role not permitted" } } }));
-  const frame = await credentialLease({ provider: "deepseek" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "FORBIDDEN_SCOPE");
-});
-
-test("credentialLease: unconfigured provider → NOT_FOUND error frame (router falls through to missing_credential)", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 404, body: { ok: false, error: { code: "NOT_FOUND", message: "no such credential" } } }));
-  const frame = await credentialLease({ provider: "openai" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(frame.error.code, "NOT_FOUND");
-});
-
-test("credentialPut: admin — POSTs the value + scoping; auto-derives an idempotency key from provider", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { provider: "deepseek", version: 1 } } }));
-  const frame = await credentialPut(
-    { provider: "deepseek", value: "sk-org-secret", auth_env: "DEEPSEEK_API_KEY", allowedRoles: ["agent"] },
-    { base: BASE, token: TOKEN, fetchImpl: f },
-  );
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/credential.put`);
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "credential.put:deepseek");
-  assert.deepEqual(JSON.parse(f.calls[0].init.body), {
-    provider: "deepseek", value: "sk-org-secret", auth_env: "DEEPSEEK_API_KEY", allowedRoles: ["agent"],
-  });
-  assert.equal(frame.ok, true);
-});
-
-test("credentialPut: caller-supplied idempotency key wins over the derived one", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  await credentialPut({ provider: "deepseek", value: "v" }, { base: BASE, token: TOKEN, idempotencyKey: "custom-key", fetchImpl: f });
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "custom-key");
-});
-
-test("credentialPut: non-admin token → FORBIDDEN_SCOPE error frame (403)", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 403, body: { ok: false, error: { code: "FORBIDDEN_SCOPE", message: "admin only" } } }));
-  const frame = await credentialPut({ provider: "deepseek", value: "v" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(frame.error.code, "FORBIDDEN_SCOPE");
-});
-
-test("credentialList: admin metadata-only read; never carries a value; returns the result frame", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { credentials: [{ provider: "deepseek", auth_env: "DEEPSEEK_API_KEY", allowedRoles: ["agent"] }] } } }));
-  const frame = await credentialList({}, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/credential.list`);
-  assert.equal(frame.result.credentials[0].provider, "deepseek");
-  assert.equal(frame.result.credentials[0].value, undefined, "list NEVER returns the value");
-});
-
-test("credentialRevoke: admin; POSTs the provider + reason", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { provider: "deepseek", revoked: true } } }));
-  const frame = await credentialRevoke({ provider: "deepseek", reason: "rotated upstream" }, { base: BASE, token: TOKEN, fetchImpl: f });
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/credential.revoke`);
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.deepEqual(JSON.parse(f.calls[0].init.body), { provider: "deepseek", reason: "rotated upstream" });
-  assert.equal(frame.result.revoked, true);
-});
-
-test("credential helpers all fail open on transport error (no throw)", async () => {
-  const thrower = fakeFetch(() => { throw new Error("network"); });
-  const lease = await credentialLease({ provider: "deepseek" }, { base: BASE, token: TOKEN, fetchImpl: thrower });
-  const put = await credentialPut({ provider: "deepseek", value: "v" }, { base: BASE, token: TOKEN, fetchImpl: thrower });
-  const list = await credentialList({}, { base: BASE, token: TOKEN, fetchImpl: thrower });
-  const revoke = await credentialRevoke({ provider: "deepseek" }, { base: BASE, token: TOKEN, fetchImpl: thrower });
-  for (const frame of [lease, put, list, revoke]) {
-    assert.equal(frame.ok, false);
-    assert.equal(frame.error.code, "INTERNAL");
-  }
-});
-
-// --- org-data API: fetchSelfProfile (GET /api/v1/org/...) ------------------
-
-const PROFILE = { slug: "robin", kind: "agent", displayName: "Robin Vega", title: "VP Eng", agentEmail: "robin@example.com" };
-
-test("fetchSelfProfile: agentId selects GET /api/v1/org/members/<slug> with Bearer", async () => {
-  const f = fakeFetch(() => ({ body: PROFILE }));
-  const frame = await fetchSelfProfile({ base: BASE, apiKey: "api-key", orgId: "acme", agentId: "robin", fetchImpl: f });
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/org/members/robin?orgId=acme`);
-  assert.equal(f.calls[0].init.method, "GET");
-  assert.equal(f.calls[0].headers.authorization, "Bearer api-key");
-  assert.equal(frame.ok, true);
-  assert.equal(frame.result.slug, "robin");
-});
-
-test("fetchSelfProfile: no agentId → GET /api/v1/org/whoami?orgId= (+ email hint), orgId pins via ?orgId + x-org-id (never as a member slug)", async () => {
-  const f = fakeFetch(() => ({ body: PROFILE }));
-  await fetchSelfProfile({ base: BASE, apiKey: "k", orgId: "acme", emailHint: "robin@example.com", fetchImpl: f });
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/org/whoami?orgId=acme&email=robin%40example.com`);
-  // The org is the TENANT PIN (?orgId + x-org-id header), NOT whoami's member `slug` hint.
-  assert.equal(f.calls[0].url.includes("slug="), false, "org slug is never sent as the member-slug hint");
-  assert.equal(f.calls[0].headers["x-org-id"], "acme");
-});
-
-test("fetchSelfProfile: whoami passes an explicit memberSlug as the ?slug= member hint (reserved for genuine member hints)", async () => {
-  const f = fakeFetch(() => ({ body: PROFILE }));
-  await fetchSelfProfile({ base: BASE, apiKey: "k", orgId: "acme", memberSlug: "robin", fetchImpl: f });
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/org/whoami?orgId=acme&slug=robin`);
-});
-
-test("fetchSelfProfile: unwraps a {member}-wrapped payload", async () => {
-  const f = fakeFetch(() => ({ body: { member: PROFILE } }));
-  const frame = await fetchSelfProfile({ base: BASE, apiKey: "k", orgId: "acme", agentId: "robin", fetchImpl: f });
-  assert.equal(frame.ok, true);
-  assert.equal(frame.result.slug, "robin");
-});
-
-test("fetchSelfProfile: missing key/orgId → fail-open error frame (no throw)", async () => {
-  const noKey = await fetchSelfProfile({ base: BASE, orgId: "acme", fetchImpl: fakeFetch() });
-  assert.equal(noKey.ok, false);
-  assert.equal(noKey.error.code, "UNAUTHORIZED");
-  const noOrg = await fetchSelfProfile({ base: BASE, apiKey: "k", fetchImpl: fakeFetch() });
-  assert.equal(noOrg.ok, false);
-  assert.equal(noOrg.error.code, "BAD_REQUEST");
-});
-
-test("fetchSelfProfile: non-200 maps the status code; fail-open", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 404, body: { error: { code: "NOT_FOUND", message: "no such member" } } }));
-  const frame = await fetchSelfProfile({ base: BASE, apiKey: "k", orgId: "acme", agentId: "nobody", fetchImpl: f });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "NOT_FOUND");
-});
-
-test("fetchSelfProfile: transport throw → fail-open error frame", async () => {
-  const thrower = fakeFetch(() => { throw new Error("network"); });
-  const frame = await fetchSelfProfile({ base: BASE, apiKey: "k", orgId: "acme", agentId: "robin", fetchImpl: thrower });
-  assert.equal(frame.ok, false);
-});
-
-// --- org-data API: structural reads (chart / relationships / strategy) ------
-
-test("fetchOrgChart: GET /api/v1/org/chart?slug= with Bearer; unwraps {ok,nodes,edges}", async () => {
-  const body = { ok: true, nodes: [{ slug: "a001", displayName: "Ada" }], edges: [{ kind: "reporting", from: "a001", to: "b002", type: "SOLID" }] };
-  const f = fakeFetch(() => ({ body }));
-  const frame = await fetchOrgChart({ base: BASE, apiKey: "api-key", orgId: "acme", fetchImpl: f });
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/org/chart?orgId=acme`);
-  assert.equal(f.calls[0].init.method, "GET");
-  assert.equal(f.calls[0].headers.authorization, "Bearer api-key");
-  assert.equal(frame.ok, true);
-  assert.equal(frame.result.nodes.length, 1);
-  assert.equal(frame.result.edges[0].from, "a001");
-});
-
-test("fetchOrgChart: missing key/orgId/base → fail-open error frame (no throw)", async () => {
-  assert.equal((await fetchOrgChart({ base: BASE, orgId: "acme", fetchImpl: fakeFetch() })).error.code, "UNAUTHORIZED");
-  assert.equal((await fetchOrgChart({ base: BASE, apiKey: "k", fetchImpl: fakeFetch() })).error.code, "BAD_REQUEST");
-  assert.equal((await fetchOrgChart({ apiKey: "k", orgId: "acme", fetchImpl: fakeFetch() })).error.code, "BAD_REQUEST");
-});
-
-test("fetchOrgChart: non-200 maps the status; transport throw → fail-open", async () => {
-  const f404 = fakeFetch(() => ({ ok: false, status: 404, body: { error: { code: "NOT_FOUND", message: "x" } } }));
-  assert.equal((await fetchOrgChart({ base: BASE, apiKey: "k", orgId: "acme", fetchImpl: f404 })).error.code, "NOT_FOUND");
-  const thrower = fakeFetch(() => { throw new Error("network"); });
-  assert.equal((await fetchOrgChart({ base: BASE, apiKey: "k", orgId: "acme", fetchImpl: thrower })).ok, false);
-});
-
-test("fetchRelationships: GET /api/v1/org/relationships?slug=&member=; unwraps the DTO", async () => {
-  const body = { ok: true, member: { slug: "robin" }, reportingLine: { manager: { slug: "layla", displayName: "Layla" } }, reports: [{ member: { slug: "kai" } }], governance: [] };
-  const f = fakeFetch(() => ({ body }));
-  const frame = await fetchRelationships({ base: BASE, apiKey: "k", orgId: "acme", member: "robin", fetchImpl: f });
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/org/relationships?orgId=acme&member=robin`);
-  assert.equal(frame.ok, true);
-  assert.equal(frame.result.reportingLine.manager.slug, "layla");
-  assert.equal(frame.result.reports[0].member.slug, "kai");
-});
-
-test("fetchRelationships: falls back to agentId for the member slug; missing → BAD_REQUEST", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, member: { slug: "robin" }, reportingLine: { manager: null }, reports: [], governance: [] } }));
-  await fetchRelationships({ base: BASE, apiKey: "k", orgId: "acme", agentId: "robin", fetchImpl: f });
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/org/relationships?orgId=acme&member=robin`);
-  const noMember = await fetchRelationships({ base: BASE, apiKey: "k", orgId: "acme", fetchImpl: fakeFetch() });
-  assert.equal(noMember.ok, false);
-  assert.equal(noMember.error.code, "BAD_REQUEST");
-});
-
-test("fetchStrategy: GET /api/v1/org/strategy?slug=; unwraps {ok,strategy}", async () => {
-  const body = { ok: true, strategy: { slug: "strategy", northStar: { goal: "win" }, phases: [], streams: [{ code: "S1", name: "Growth", raci: [{ role: "Accountable", member: { slug: "robin", displayName: "Robin" } }] }] } };
-  const f = fakeFetch(() => ({ body }));
-  const frame = await fetchStrategy({ base: BASE, apiKey: "k", orgId: "acme", fetchImpl: f });
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/org/strategy?orgId=acme`);
-  assert.equal(frame.ok, true);
-  assert.equal(frame.result.streams[0].code, "S1");
-});
-
-test("fetchStrategy: 404 (no strategy doc) → fail-open NOT_FOUND frame", async () => {
-  const f = fakeFetch(() => ({ ok: false, status: 404, body: { ok: false, error: { code: "NOT_FOUND", message: "none" } } }));
-  const frame = await fetchStrategy({ base: BASE, apiKey: "k", orgId: "acme", fetchImpl: f });
-  assert.equal(frame.ok, false);
-  assert.equal(frame.error.code, "NOT_FOUND");
-});
-
-test("fetchHierarchy: GET /v1/hierarchy bare payload → {members,reporting}; null on failure", async () => {
-  const body = { members: [{ slug: "a001" }], reporting: [{ from: "a001", to: "b002" }] };
-  const f = fakeFetch(() => ({ body }));
-  const out = await fetchHierarchy({ base: BASE, token: TOKEN, orgId: "acme", fetchImpl: f });
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/hierarchy`);
-  assert.equal(f.calls[0].headers.authorization, `Bearer ${TOKEN}`);
-  assert.equal(out.members.length, 1);
-  assert.equal(out.reporting[0].to, "b002");
-  // failure → null (fail-open)
-  const fail = fakeFetch(() => ({ ok: false, status: 503, body: { error: { code: "INTERNAL", message: "down" } } }));
-  assert.equal(await fetchHierarchy({ base: BASE, token: TOKEN, orgId: "acme", fetchImpl: fail }), null);
-});
-
-// ---------------------------------------------------------------------------
-// loadOrgConfig — an enrolled agent must never go quietly un-enrolled
-// ---------------------------------------------------------------------------
-
-test("loadOrgConfig: absent org.yaml is silent (an un-enrolled agent is not a fault)", () => {
-  const dir = mkdtempSync(join(tmpdir(), "orgcfg-"));
-  const warnings = captureWarn(() => {
-    assert.deepEqual(loadOrgConfig(dir), {});
-  });
-  assert.deepEqual(warnings, [], "no file, no noise");
-});
-
-test("loadOrgConfig: parses config/org.yaml", () => {
-  const dir = mkdtempSync(join(tmpdir(), "orgcfg-"));
-  mkdirSync(join(dir, "config"), { recursive: true });
-  writeFileSync(
-    join(dir, "config", "org.yaml"),
-    "org:\n  cohort:\n    enabled: true\n    base: https://os.example.com\n",
-  );
-  const cfg = loadOrgConfig(dir);
-  assert.equal(cfg.org.cohort.enabled, true);
-  assert.equal(isEnabled(cfg), true);
-});
-
-test("loadOrgConfig: a PRESENT but unparseable org.yaml WARNS (never silently un-enrols)", () => {
-  // Returning {} quietly is how an enrolled agent ends up out of the mesh:
-  // isEnabled({}) is false, so the daemon no-ops, never beats, and cannot
-  // receive `halt`. Fail-open is right; silence is not.
-  const dir = mkdtempSync(join(tmpdir(), "orgcfg-"));
-  mkdirSync(join(dir, "config"), { recursive: true });
-  writeFileSync(join(dir, "config", "org.yaml"), "org:\n  cohort:\n   - [unbalanced\n");
-  let cfg;
-  const warnings = captureWarn(() => { cfg = loadOrgConfig(dir); });
-  assert.deepEqual(cfg, {}, "still fail-open");
-  assert.match(warnings.join("\n"), /could not be loaded/, "the operator must be told");
-  assert.match(warnings.join("\n"), /NOT enrolled/, "and told what it means");
-});
-
-// ── WP-M4: board.mine + board.track passthrough (front-door session §3.5) ──
-
-test("listMineResult: keeps the failure visible — {ok:false} on an error frame or a throwing transport, {ok:true, items:[]} for an empty board", async () => {
-  assert.deepEqual(await listMineResult({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: [{ itemId: "i1" }] })) }), { ok: true, items: [{ itemId: "i1" }] });
-  assert.deepEqual(await listMineResult({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: { items: [] } })) }), { ok: true, items: [] }, "an empty board is a real answer");
-  const failed = await listMineResult({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ ok: false, status: 503, body: { error: { code: "UNAVAILABLE", message: "hq down" } } })) });
-  assert.equal(failed.ok, false);
-  assert.deepEqual(failed.items, []);
-  assert.match(failed.error, /hq down/);
-  const threw = await listMineResult({ base: BASE, token: TOKEN, fetchImpl: () => { throw new Error("ECONNREFUSED"); } });
-  assert.equal(threw.ok, false);
-  assert.deepEqual(threw.items, []);
-  assert.deepEqual(await listMine({ base: BASE, token: TOKEN, fetchImpl: () => { throw new Error("ECONNREFUSED"); } }), [], "listMine stays the fail-open [] its other callers expect");
-});
-
-test("listMine: GET /v1/board.mine; parses array and {items:[]}; [] on error / transport failure (fail-open)", async () => {
-  const f = fakeFetch(() => ({ body: [{ itemId: "i1", title: "Deck" }] }));
-  assert.deepEqual(await listMine({ base: BASE, token: TOKEN, fetchImpl: f }), [{ itemId: "i1", title: "Deck" }]);
-  assert.match(f.calls[0].url, /\/v1\/board\.mine$/);
-  assert.equal(f.calls[0].init.method, "GET");
-  assert.deepEqual(await listMine({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: { items: [{ itemId: "i2" }] } })) }), [{ itemId: "i2" }]);
-  assert.deepEqual(await listMine({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ ok: false, status: 404, body: { error: { code: "NOT_FOUND" } } })) }), [], "an hq without board.mine yet → []");
-  assert.deepEqual(await listMine({ base: BASE, token: TOKEN, fetchImpl: async () => { throw new Error("boom"); } }), []);
-  assert.deepEqual(await listMine({ base: "", token: TOKEN }), [], "no base → []");
-});
-
-test("trackWork: title/why/stage (incl. accepted|done) pass through to board.track verbatim", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: { tracked: true, taskId: "t1" } } }));
-  const r = await trackWork(
-    { service: "cohort", channelId: "c1", messageId: "m1", stage: "accepted", title: "Build the deck", why: "asked in DM" },
-    { base: BASE, token: TOKEN, fetchImpl: f, idempotencyKey: "k1" },
-  );
-  assert.equal(r.ok, true);
-  const body = JSON.parse(f.calls[0].init.body);
-  assert.equal(body.stage, "accepted");
-  assert.equal(body.title, "Build the deck");
-  assert.equal(body.why, "asked in DM");
-  assert.equal(body.channelId, "c1");
-  const f2 = fakeFetch(() => ({ body: { ok: true, result: { tracked: true } } }));
-  await trackWork({ service: "cohort", channelId: "c1", messageId: "m1", stage: "done" }, { base: BASE, token: TOKEN, fetchImpl: f2 });
-  assert.equal(JSON.parse(f2.calls[0].init.body).stage, "done");
-});