@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/lib/goals/admission.test.mjs

@@ -1,164 +0,0 @@
-/**
- * admission.test.mjs — the gates between "the number is off" and "work exists".
- * Run: `node --test lib/goals/admission.test.mjs`
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import { admit, decideForGap, titleSimilarity, GATES, DUPLICATE_THRESHOLD } from "./admission.mjs";
-
-// `adoptedById` is load-bearing, not decoration: an active objective with no
-// adopter on record admits no work (the gate's contract has always been "adopted
-// by SOMEBODY WHO IS NOT ITS OWNER", and it used to check only the state column).
-const OBJ = { key: "pipeline", state: "active", metric: "pipeline_coverage_x", target: 3, cadence: "weekly", memberId: "M-OWNER", adoptedById: "M-SUPERVISOR" };
-const GAP = { gap: 1, target: 3, value: 2, withinTolerance: false, trend: "flat", normalizedGap: 0.33, stale: false };
-const SAMPLE = { source: "method", value: 2, window: "2026-W33" };
-
-function candidate(over = {}) {
-  return {
-    title: "Close the pipeline coverage gap",
-    advances: ["pipeline"],
-    estCents: 40,
-    why: { reason: "kpi-gap", objectiveKey: "pipeline" },
-    ...over,
-  };
-}
-function ctx(over = {}) {
-  return {
-    objective: OBJ,
-    gap: GAP,
-    latestSample: SAMPLE,
-    openItems: [],
-    admittedThisRun: 0,
-    remainingCents: 500,
-    staleness: { outcome: "full" },
-    ...over,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// the decision table
-// ---------------------------------------------------------------------------
-
-test("decision table: within tolerance → nothing; no coverage → create", () => {
-  assert.equal(decideForGap({ ...GAP, withinTolerance: true }).action, "none");
-  assert.equal(decideForGap(GAP, { coverage: 0 }).action, "create");
-});
-
-test("decision table: work in flight + flat/worsening → escalate, NOT more tasks", () => {
-  assert.equal(decideForGap({ ...GAP, trend: "flat" }, { coverage: 2 }).action, "escalate");
-  assert.equal(decideForGap({ ...GAP, trend: "worsening" }, { coverage: 1 }).action, "escalate");
-});
-
-test("decision table: work in flight + improving → log and be patient", () => {
-  assert.equal(decideForGap({ ...GAP, trend: "improving" }, { coverage: 1 }).action, "log");
-});
-
-test("decision table: a stale sensor is a drift to fix, never a gap to work", () => {
-  const d = decideForGap({ ...GAP, stale: true, stalenessPeriods: 3.2 }, { coverage: 0 });
-  assert.equal(d.action, "drift");
-  assert.match(d.reason, /stale/);
-  assert.equal(decideForGap({ gap: null }).action, "drift");
-});
-
-// ---------------------------------------------------------------------------
-// the gates
-// ---------------------------------------------------------------------------
-
-test("a clean candidate passes every gate, in the declared order", () => {
-  const v = admit(candidate(), ctx());
-  assert.equal(v.admitted, true, v.reason);
-  assert.deepEqual(v.checks.map((c) => c.gate), GATES);
-  assert.ok(v.checks.every((c) => c.ok));
-});
-
-test("GATE honesty — an llm-sourced sample is advisory and can NEVER create work", () => {
-  const v = admit(candidate(), ctx({ latestSample: { source: "llm", value: 2 } }));
-  assert.equal(v.admitted, false);
-  assert.equal(v.gate, "honesty");
-  assert.match(v.reason, /only method\/human samples may create work/);
-
-  // human-entered numbers DO count.
-  assert.equal(admit(candidate(), ctx({ latestSample: { source: "human", value: 2 } })).admitted, true);
-});
-
-test("GATE adoption — a proposed objective admits nothing", () => {
-  const v = admit(candidate(), ctx({ objective: { ...OBJ, state: "proposed" } }));
-  assert.equal(v.admitted, false);
-  assert.equal(v.gate, "adoption");
-  assert.match(v.reason, /proposed objective admits no work/);
-});
-
-test("GATE freshness — a stale mandate suspends self-directed work entirely", () => {
-  const v = admit(candidate(), ctx({ staleness: { outcome: "suspended" } }));
-  assert.equal(v.admitted, false);
-  assert.equal(v.gate, "freshness");
-});
-
-test("GATE provenance — no advances[] and no why.reason are both refusals", () => {
-  assert.equal(admit(candidate({ advances: [] }), ctx()).gate, "provenance");
-  assert.equal(admit(candidate({ why: {} }), ctx()).gate, "provenance");
-});
-
-test("GATE wip — the per-objective cap and the per-run cap both bite", () => {
-  const open = [{ title: "a" }, { title: "b" }, { title: "c" }];
-  const capped = admit(candidate(), ctx({ openItems: open, gap: { ...GAP, trend: "improving" } }));
-  assert.equal(capped.gate, "trend", "coverage>0 + improving is caught by the trend gate first");
-
-  const wip = admit(candidate({ title: "totally unrelated new push" }), ctx({ openItems: open, gap: { ...GAP, trend: "unknown" } }));
-  assert.equal(wip.admitted, false);
-
-  const perRun = admit(candidate(), ctx({ admittedThisRun: 2 }));
-  assert.equal(perRun.gate, "wip");
-  assert.match(perRun.reason, /already admitted this run/);
-});
-
-test("GATE dedupe — a near-duplicate of an open item is refused", () => {
-  // coverage>0 would trip the trend gate, so give it an unknown trend to reach dedupe.
-  const v = admit(
-    candidate({ title: "Close the pipeline coverage gap" }),
-    ctx({ openItems: [{ title: "Close the pipeline coverage gap now" }], gap: { ...GAP, trend: "unknown" } })
-  );
-  assert.equal(v.admitted, false);
-  assert.equal(v.gate, "dedupe");
-  assert.ok(titleSimilarity("Close the pipeline coverage gap", "Close the pipeline coverage gap now") >= DUPLICATE_THRESHOLD);
-});
-
-test("NEGATIVE — GATE budget: no budget left means no work, and the reason names both numbers", () => {
-  const v = admit(candidate({ estCents: 900 }), ctx({ remainingCents: 100 }));
-  assert.equal(v.admitted, false);
-  assert.equal(v.gate, "budget");
-  assert.match(v.reason, /900c exceeds the remaining envelope 100c/);
-});
-
-test("every rejection carries its gate and the full check trail — nothing is dropped silently", () => {
-  const v = admit(candidate(), ctx({ latestSample: { source: "llm" } }));
-  assert.ok(v.checks.length > 0);
-  assert.equal(v.checks[v.checks.length - 1].ok, false);
-  assert.equal(v.checks[v.checks.length - 1].gate, v.gate);
-});
-
-// ---------------------------------------------------------------------------
-// the adoption gate reads the LAW, not the state column
-// ---------------------------------------------------------------------------
-
-test("GATE adoption — an active objective with NO adoptedById admits nothing", () => {
-  // The cheap tamper. Forging a supervisor id is work; DELETING the field was one
-  // keystroke, and `isSelfAdopted` returned false for a missing field, so the row
-  // sailed through both the compiler and this gate.
-  const { adoptedById, ...noProvenance } = OBJ;
-  const v = admit(candidate(), ctx({ objective: noProvenance }));
-  assert.equal(v.admitted, false);
-  assert.equal(v.gate, "adoption");
-  assert.match(v.reason, /no adoptedById/);
-});
-
-test("GATE adoption — a SELF-adopted objective admits nothing", () => {
-  const v = admit(candidate(), ctx({ objective: { ...OBJ, adoptedById: "M-OWNER" } }));
-  assert.equal(v.admitted, false);
-  assert.equal(v.gate, "adoption");
-  assert.match(v.reason, /own owning seat/);
-});

package/lib/goals/classify.test.mjs

@@ -1,167 +0,0 @@
-/**
- * classify.test.mjs — SELF / COLLABORATE / HANDOFF / NEEDS_REVIEW.
- * Run: `node --test lib/goals/classify.test.mjs`
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import { classifyWorkItem, capabilityGaps, WORK_DISPOSITIONS, isWorkDisposition } from "./classify.mjs";
-
-const ME = "mem_self";
-const PEER = "mem_peer";
-const BOSS = "mem_boss";
-
-const OBJ = { key: "pipeline", state: "active", collaborators: [] };
-const REACHABLE = new Set(["crm_list_deals", "task_create"]);
-
-function ctx(over = {}) {
-  return { memberId: ME, objective: OBJ, reachable: REACHABLE, peers: [], ...over };
-}
-
-test("the four dispositions are the vocabulary and nothing else is", () => {
-  assert.deepEqual(WORK_DISPOSITIONS, ["SELF", "COLLABORATE", "HANDOFF", "NEEDS_REVIEW"]);
-  assert.equal(isWorkDisposition("SELF"), true);
-  assert.equal(isWorkDisposition("react_now"), false, "inbound dispositions are a different vocabulary");
-});
-
-test("SELF — mine alone, nothing gated, every capability reachable", () => {
-  const c = classifyWorkItem({ title: "Raise coverage", requiredCapabilities: ["crm_list_deals"] }, ctx());
-  assert.equal(c.disposition, "SELF");
-  assert.equal(c.reason, "self");
-  assert.equal(c.capabilityGap, null);
-});
-
-test("HANDOFF — another seat owns the work outright", () => {
-  const c = classifyWorkItem({ title: "x", ownerMemberId: PEER }, ctx());
-  assert.equal(c.disposition, "HANDOFF");
-  assert.equal(c.target, PEER);
-  assert.equal(c.reason, "owned-by-another-seat");
-});
-
-test("HANDOFF — a collaborator carrying role DOER is the doer, not me", () => {
-  const c = classifyWorkItem({ title: "x", collaborators: [{ memberId: PEER, role: "DOER" }] }, ctx());
-  assert.equal(c.disposition, "HANDOFF");
-  assert.equal(c.target, PEER);
-});
-
-test("HANDOFF — a capability I cannot reach but a peer declares goes to the peer, not to a refusal", () => {
-  const c = classifyWorkItem(
-    { title: "Post to the ledger", requiredCapabilities: ["books_invoices"] },
-    ctx({ peers: [{ memberId: PEER, capabilities: ["books_invoices"] }] })
-  );
-  assert.equal(c.disposition, "HANDOFF");
-  assert.equal(c.target, PEER);
-  assert.equal(c.reason, "capability-only-reachable-by-peer");
-});
-
-test("NEEDS_REVIEW — a gated action class outranks collaboration", () => {
-  const c = classifyWorkItem(
-    { title: "Email the customer base", actionClasses: ["external"], collaborators: [{ memberId: PEER, role: "CONTRIBUTOR" }] },
-    ctx()
-  );
-  assert.equal(c.disposition, "NEEDS_REVIEW");
-  assert.deepEqual(c.gatedClasses, ["external"]);
-  assert.equal(c.reason, "gated-action-class");
-});
-
-test("NEEDS_REVIEW — a named APPROVER, and a named REVIEWER on the OBJECTIVE", () => {
-  const approver = classifyWorkItem({ title: "x", collaborators: [{ memberId: BOSS, role: "APPROVER" }] }, ctx());
-  assert.equal(approver.disposition, "NEEDS_REVIEW");
-  assert.equal(approver.target, BOSS);
-
-  // Objective-level reviewers apply to every task under the objective.
-  const reviewer = classifyWorkItem({ title: "x" }, ctx({ objective: { ...OBJ, collaborators: [{ memberId: PEER, role: "REVIEWER" }] } }));
-  assert.equal(reviewer.disposition, "NEEDS_REVIEW");
-  assert.equal(reviewer.target, PEER);
-  assert.equal(reviewer.reason, "review-required");
-});
-
-test("COLLABORATE — a named contributor works alongside me", () => {
-  const c = classifyWorkItem({ title: "x", collaborators: [{ memberId: PEER, role: "CONTRIBUTOR" }] }, ctx());
-  assert.equal(c.disposition, "COLLABORATE");
-  assert.deepEqual(c.contributors, [PEER]);
-});
-
-test("a collaborator that IS me never turns my own work into a handoff", () => {
-  const c = classifyWorkItem({ title: "x", collaborators: [{ memberId: ME, role: "DOER" }, { memberId: ME, role: "REVIEWER" }] }, ctx());
-  assert.equal(c.disposition, "SELF");
-});
-
-test("NEGATIVE — a missing capability with NO peer cover stays SELF but carries the gap forward", () => {
-  const c = classifyWorkItem({ title: "x", requiredCapabilities: ["stripe_refund"] }, ctx());
-  assert.equal(c.disposition, "SELF");
-  assert.equal(c.reason, "self-with-capability-gap");
-  assert.deepEqual(c.capabilityGap.uncovered, ["stripe_refund"]);
-  assert.match(c.why.join(" "), /capability gap with no peer cover/);
-});
-
-test("capabilityGaps splits missing into peer-covered and uncovered, deterministically", () => {
-  const g = capabilityGaps(["a", "b", "c"], ["a"], [
-    { memberId: "p1", capabilities: ["b"] },
-    { memberId: "p2", capabilities: ["b", "c"] },
-  ]);
-  assert.deepEqual(g.missing, ["b", "c"]);
-  assert.deepEqual(g.coveredByPeer, [{ capability: "b", memberId: "p1" }, { capability: "c", memberId: "p2" }]);
-  assert.deepEqual(g.uncovered, []);
-});
-
-// ---------------------------------------------------------------------------
-// The derived-governance-edge regression (found end-to-end, 2026-08-11)
-// ---------------------------------------------------------------------------
-
-test("REGRESSION — an objective's ADOPTER does not by itself force NEEDS_REVIEW", () => {
-  // hq's mandate.adopt refuses self-adoption, and projectObjective then emits the
-  // adopter as {role:"APPROVER", source:"objective.adoptedById"} on EVERY adopted
-  // objective. Rule 4 fired on it, so 100% of goal-steward candidates went out
-  // for signature and none was ever done SELF. Adopting the NUMBER is not
-  // per-task sign-off on the actions taken to move it.
-  const objective = {
-    key: "board-on-time-delivery",
-    collaborators: [{ memberId: "boss", role: "APPROVER", source: "objective.adoptedById" }],
-  };
-  const c = classifyWorkItem({ title: "Close the gap" }, { memberId: "me", objective, reachable: [] });
-  assert.equal(c.disposition, "SELF");
-  assert.equal(c.reason, "self");
-  // The edge is not discarded — it is still on file as an approver.
-  assert.deepEqual(c.approvers, ["boss"]);
-});
-
-test("REGRESSION — the seat's SUPERVISOR does not force NEEDS_REVIEW either", () => {
-  const c = classifyWorkItem(
-    { title: "Close the gap" },
-    {
-      memberId: "me",
-      objective: { collaborators: [{ memberId: "boss", role: "REVIEWER", source: "workforceMember.supervisorId" }] },
-      reachable: [],
-    }
-  );
-  assert.equal(c.disposition, "SELF");
-  assert.deepEqual(c.reviewers, ["boss"]);
-});
-
-test("a DELIBERATELY named reviewer (no derived source) still routes to NEEDS_REVIEW", () => {
-  const c = classifyWorkItem(
-    { title: "Close the gap", collaborators: [{ memberId: "peer", role: "REVIEWER" }] },
-    { memberId: "me", reachable: [] }
-  );
-  assert.equal(c.disposition, "NEEDS_REVIEW");
-  assert.equal(c.reason, "review-required");
-  assert.equal(c.target, "peer");
-});
-
-test("a GATED action class still gates — and falls back to the adopter as the target", () => {
-  const c = classifyWorkItem(
-    { title: "Wire the payment", actionClasses: ["financial"] },
-    {
-      memberId: "me",
-      objective: { collaborators: [{ memberId: "boss", role: "APPROVER", source: "objective.adoptedById" }] },
-      reachable: [],
-    }
-  );
-  assert.equal(c.disposition, "NEEDS_REVIEW");
-  assert.equal(c.reason, "gated-action-class");
-  assert.equal(c.target, "boss", "the derived edge is a fallback TARGET, never a trigger");
-});

package/lib/goals/collaborate.test.mjs

@@ -1,336 +0,0 @@
-/**
- * lib/goals/collaborate.test.mjs — the four dispositions route through the
- * collaboration primitives that ALREADY EXIST.
- *
- * The design claim being tested is a negative one: no new coordination
- * mechanism. COLLABORATE takes a `work-claim` lease, HANDOFF sends a handoff
- * envelope, NEEDS_REVIEW goes through `approval.request` when the action class
- * is gated, and "ask, don't pile on" uses `escalation.*`. If any of these grew
- * a parallel mechanism, these tests are where it shows up.
- *
- * Every test drives the failure side too: an unreachable org must produce
- * `{ok:false, reason}` plus a log line, never a silent success and never a
- * throw into the loop.
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  createWorkItem, routeWorkItem, routeSelf, routeCollaborate, routeHandoff,
-  routeNeedsReview, raiseEscalation, workResourceId, WORK_LEASE_SCOPE,
-} from "./collaborate.mjs";
-import { classifyWorkItem } from "./classify.mjs";
-
-const SELF = "mem_self";
-const PEER = "mem_peer";
-
-const ITEM = {
-  id: "goal-pipeline-1",
-  title: "Book 6 discovery calls",
-  objectiveKey: "pipeline",
-  obligationKey: "outcome.pipeline",
-  priority: "high",
-  expectedDelta: 0.5,
-  successCriteria: ["6 calls booked"],
-  why: { reason: "kpi-gap", objectiveKey: "pipeline", clause: "cs_12" },
-};
-
-function spy(over = {}) {
-  const calls = { board: [], handoff: [], approval: [], lease: [], rpc: [], logs: [] };
-  const deps = {
-    memberId: SELF,
-    log: (lvl, msg) => calls.logs.push(`${lvl}:${msg}`),
-    createItem: async (p) => { calls.board.push(p); return { ok: true, result: { id: "bi_1" } }; },
-    sendHandoff: async (o) => { calls.handoff.push(o); return { sent: true, runId: "run_1", transport: { reason: "offered" } }; },
-    requestApproval: async (o) => { calls.approval.push(o); return { requested: true, id: "appr_1" }; },
-    claimLease: async (scope, resourceId) => { calls.lease.push({ scope, resourceId }); return { held: true, leaseToken: "lt_1" }; },
-    callImpl: async (method, params) => { calls.rpc.push({ method, params }); return { ok: true, result: { id: "r_1" } }; },
-    ...over,
-  };
-  return { calls, deps };
-}
-
-/** Build the classification the loop would have produced. */
-function classify(candidate, ctx = {}) {
-  return classifyWorkItem(candidate, { memberId: SELF, ...ctx });
-}
-
-// ---------------------------------------------------------------------------
-// The board item — the one thing every disposition creates
-// ---------------------------------------------------------------------------
-
-test("workResourceId is stable and objective-scoped", () => {
-  const a = workResourceId("pipeline", "Book 6 discovery calls");
-  assert.equal(a, workResourceId("pipeline", "Book 6 discovery calls"));
-  assert.notEqual(a, workResourceId("pipeline", "A different task"));
-  assert.notEqual(a, workResourceId("retention", "Book 6 discovery calls"));
-  assert.match(a, /^objective:pipeline:[0-9a-f]{10}$/);
-});
-
-test("every work item carries the full provenance chain onto the board", async () => {
-  const { calls, deps } = spy();
-  const r = await createWorkItem(ITEM, deps);
-  assert.equal(r.ok, true);
-  assert.equal(r.itemId, "bi_1");
-  const payload = calls.board[0];
-  // The payload is shaped for hq's REAL schema (board.createTask): the owner is
-  // `assigneeId`, the priority is the P0..P4 enum, and `why` is the CLOSED
-  // {reason, options, clause, wouldChange} block. `objectiveKey`/`obligationKey`
-  // have no column there, so they ride in `detail` — the trace survives even
-  // though the fields do not. (The old spellings were rejected BAD_REQUEST by
-  // every hq that ever received them.)
-  assert.equal(payload.why.clause, "cs_12");
-  assert.equal(payload.why.reason, "kpi-gap");
-  assert.equal(payload.assigneeId, SELF);
-  assert.equal(payload.priority, "P1", "the item is high priority → P1, not the word \"high\"");
-  assert.equal(payload.col, "todo");
-  assert.match(payload.detail, /Advances objective: pipeline/);
-  assert.match(payload.detail, /Obligation: outcome\.pipeline/);
-  assert.equal(payload.objectiveKey, undefined, "a spelling hq rejects must not be sent");
-  assert.equal(payload.assignee, undefined);
-  assert.equal(payload.status, undefined);
-});
-
-test("SERVER UNREACHABLE: a thrown board.create is reported, logged, and never throws out", async () => {
-  const { calls, deps } = spy({ createItem: async () => { throw new Error("ECONNREFUSED"); } });
-  const r = await createWorkItem(ITEM, deps);
-  assert.equal(r.ok, false);
-  assert.equal(r.itemId, null);
-  assert.equal(r.reason, "board-create-threw");
-  assert.ok(calls.logs.some((l) => l.startsWith("warn:")), "the failure must be logged");
-});
-
-test("SERVER UNREACHABLE: an error FRAME is distinguished from a throw", async () => {
-  const { calls, deps } = spy({ createItem: async () => ({ ok: false, error: { code: "RATE_LIMITED" } }) });
-  const r = await createWorkItem(ITEM, deps);
-  assert.equal(r.ok, false);
-  assert.equal(r.reason, "RATE_LIMITED");
-  assert.ok(calls.logs.some((l) => /the local backlog item still stands/.test(l)));
-});
-
-// ---------------------------------------------------------------------------
-// SELF
-// ---------------------------------------------------------------------------
-
-test("SELF creates the board item and nothing else", async () => {
-  const { calls, deps } = spy();
-  const c = classify({ title: ITEM.title, advances: ["pipeline"] });
-  assert.equal(c.disposition, "SELF");
-  const r = await routeSelf(ITEM, c, deps);
-  assert.equal(r.primitive, "board.create");
-  assert.equal(r.ok, true);
-  assert.equal(calls.handoff.length, 0);
-  assert.equal(calls.approval.length, 0);
-  assert.equal(calls.lease.length, 0);
-});
-
-test("SELF carries a capability gap forward rather than losing it", async () => {
-  const { deps } = spy();
-  const c = classify(
-    { title: "Do the thing", advances: ["pipeline"], requiredCapabilities: ["stripe_refund"] },
-    { reachable: new Set([]), peers: [] }
-  );
-  assert.equal(c.disposition, "SELF");
-  const r = await routeSelf(ITEM, c, deps);
-  assert.ok(r.capabilityGap, "an unreachable capability must travel with the route result");
-  assert.ok(r.capabilityGap.uncovered.includes("stripe_refund"));
-});
-
-// ---------------------------------------------------------------------------
-// COLLABORATE — the existing lease, not a new mechanism
-// ---------------------------------------------------------------------------
-
-test("COLLABORATE claims the work-claim lease BEFORE creating the item", async () => {
-  const order = [];
-  const { calls, deps } = spy();
-  const baseLease = deps.claimLease;
-  const baseBoard = deps.createItem;
-  deps.claimLease = async (s, r, o) => { order.push("lease"); return baseLease(s, r, o); };
-  deps.createItem = async (p) => { order.push("board"); return baseBoard(p); };
-  const c = classify({ title: ITEM.title, advances: ["pipeline"], collaborators: [{ memberId: PEER, role: "CONTRIBUTOR" }] });
-  assert.equal(c.disposition, "COLLABORATE");
-  const r = await routeCollaborate(ITEM, c, deps);
-  assert.deepEqual(order, ["lease", "board"], "claiming after creating would race two agents onto one item");
-  assert.equal(calls.lease[0].scope, WORK_LEASE_SCOPE);
-  assert.equal(r.ok, true);
-  // The contributor is told, over the existing board comment method.
-  const comment = calls.rpc.find((x) => x.method === "board.comment");
-  assert.ok(comment);
-  assert.deepEqual(comment.params.mentionedMemberIds, [PEER]);
-});
-
-test("COLLABORATE: losing the lease stands down — no board item at all", async () => {
-  const { calls, deps } = spy({ claimLease: async () => ({ held: false, reason: "held-by-peer" }) });
-  const c = classify({ title: ITEM.title, advances: ["pipeline"], collaborators: [{ memberId: PEER, role: "CONTRIBUTOR" }] });
-  const r = await routeCollaborate(ITEM, c, deps);
-  assert.equal(r.ok, false);
-  assert.match(r.reason, /^lease-lost:/);
-  assert.equal(calls.board.length, 0, "a peer owns it — creating a second item is the duplicate-work bug");
-  assert.ok(calls.logs.some((l) => /standing down/.test(l)));
-});
-
-test("COLLABORATE: a lease service that THROWS fails open — loudly, and duplicate work is flagged", async () => {
-  const { calls, deps } = spy({ claimLease: async () => { throw new Error("lease service down"); } });
-  const c = classify({ title: ITEM.title, advances: ["pipeline"], collaborators: [{ memberId: PEER, role: "CONTRIBUTOR" }] });
-  const r = await routeCollaborate(ITEM, c, deps);
-  // Fail-open: the work proceeds…
-  assert.equal(r.ok, true);
-  assert.equal(r.failedOpen, true);
-  // …but never silently.
-  assert.ok(calls.logs.some((l) => /FAILED OPEN/.test(l) && /duplicate work is possible/.test(l)));
-});
-
-// ---------------------------------------------------------------------------
-// HANDOFF — the existing envelope
-// ---------------------------------------------------------------------------
-
-test("HANDOFF assigns the item to the target and sends the envelope with full context", async () => {
-  const { calls, deps } = spy();
-  const c = classify({ title: ITEM.title, advances: ["pipeline"], collaborators: [{ memberId: PEER, role: "DOER" }] });
-  assert.equal(c.disposition, "HANDOFF");
-  const r = await routeHandoff(ITEM, c, deps);
-  assert.equal(r.ok, true);
-  assert.equal(r.primitive, "handoff.offer");
-  assert.equal(calls.board[0].assigneeId, PEER, "the board item must be assigned to whoever is doing it");
-  const env = calls.handoff[0];
-  assert.equal(env.to, PEER);
-  assert.equal(env.from, SELF);
-  assert.equal(env.itemId, "bi_1");
-  assert.equal(env.payload.objectiveKey, "pipeline");
-  assert.equal(env.payload.obligationKey, "outcome.pipeline");
-  assert.deepEqual(env.payload.successCriteria, ["6 calls booked"]);
-});
-
-test("HANDOFF that is not sent leaves the item effectively unassigned — and says so", async () => {
-  const { calls, deps } = spy({ sendHandoff: async () => ({ sent: false, transport: { reason: "no-channel" } }) });
-  const c = classify({ title: ITEM.title, advances: ["pipeline"], collaborators: [{ memberId: PEER, role: "DOER" }] });
-  const r = await routeHandoff(ITEM, c, deps);
-  assert.equal(r.ok, false);
-  assert.equal(r.reason, "no-channel");
-  assert.ok(calls.logs.some((l) => /was NOT sent/.test(l)));
-});
-
-test("HANDOFF that throws still leaves the work item behind", async () => {
-  const { calls, deps } = spy({ sendHandoff: async () => { throw new Error("boom"); } });
-  const c = classify({ title: ITEM.title, advances: ["pipeline"], collaborators: [{ memberId: PEER, role: "DOER" }] });
-  const r = await routeHandoff(ITEM, c, deps);
-  assert.equal(r.ok, false);
-  assert.equal(r.reason, "handoff-threw");
-  assert.equal(r.itemId, "bi_1", "the work must not evaporate because the envelope failed");
-  assert.equal(calls.board.length, 1);
-});
-
-// ---------------------------------------------------------------------------
-// NEEDS_REVIEW — approvals are the gate, and the gate holds
-// ---------------------------------------------------------------------------
-
-test("a gated action class goes through approval.request, carrying the classification", async () => {
-  const { calls, deps } = spy();
-  const c = classify({ title: "Wire the money", advances: ["pipeline"], actionClasses: ["financial"] });
-  assert.equal(c.disposition, "NEEDS_REVIEW");
-  const r = await routeNeedsReview({ ...ITEM, title: "Wire the money" }, c, deps);
-  assert.equal(r.primitive, "approval.request");
-  assert.equal(r.ok, true);
-  assert.deepEqual(calls.approval[0].classification, ["financial"]);
-  assert.equal(calls.approval[0].requester, SELF);
-  assert.equal(calls.approval[0].itemId, "bi_1");
-  assert.equal(calls.approval[0].payload.why.clause, "cs_12");
-});
-
-test("APPROVAL GATE HOLDS: an approval that cannot be requested BLOCKS the work", async () => {
-  const { calls, deps } = spy({ requestApproval: async () => ({ requested: false, id: null }) });
-  const c = classify({ title: "Send the external note", advances: ["pipeline"], actionClasses: ["external"] });
-  const r = await routeNeedsReview(ITEM, c, deps);
-  assert.equal(r.ok, false);
-  assert.equal(r.blocked, true, "a gated action with no approval must NOT execute");
-  assert.ok(calls.logs.some((l) => /stays BLOCKED, not executed/.test(l)));
-});
-
-test("APPROVAL GATE HOLDS: a throwing approval service also blocks", async () => {
-  const { deps } = spy({ requestApproval: async () => { throw new Error("503"); } });
-  const c = classify({ title: "Delete the bucket", advances: ["pipeline"], actionClasses: ["irreversible"] });
-  const r = await routeNeedsReview(ITEM, c, deps);
-  assert.equal(r.ok, false);
-  assert.equal(r.reason, "approval-threw");
-});
-
-test("a plain named reviewer does NOT consume an approval — it degrades to a review envelope, logged", async () => {
-  const { calls, deps } = spy();
-  const c = classify({ title: ITEM.title, advances: ["pipeline"], collaborators: [{ memberId: PEER, role: "REVIEWER" }] });
-  assert.equal(c.disposition, "NEEDS_REVIEW");
-  assert.deepEqual(c.gatedClasses, []);
-  const r = await routeNeedsReview(ITEM, c, deps);
-  assert.equal(calls.approval.length, 0, "a review is not an approval — do not burn the approval path on it");
-  // Either the first-class method (once hq ships it) or the logged fallback.
-  assert.ok(["board.requestReview", "handoff.offer(review)"].includes(r.primitive));
-  if (r.primitive === "handoff.offer(review)") {
-    assert.equal(r.degraded, true);
-    assert.ok(calls.logs.some((l) => /falling back to a REVIEW handoff/.test(l)),
-      "a degradation must be announced, not silent");
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Escalation — "ask, don't pile on"
-// ---------------------------------------------------------------------------
-
-test("an escalation carries concrete OPTIONS, not prose", async () => {
-  const { calls, deps } = spy();
-  const r = await raiseEscalation({
-    objectiveKey: "pipeline",
-    question: "Coverage is flat at 1.5 against a target of 3. What should change?",
-    options: [{ label: "Re-target" }, { label: "Add resourcing" }, "Accept the miss"],
-    gap: { gap: 1.5, target: 3, trend: "flat" },
-  }, deps);
-  assert.equal(r.ok, true);
-  const call = calls.rpc[0];
-  assert.match(call.method, /^escalation\./);
-  assert.equal(call.params.options.length, 3);
-  // A bare string option is normalised to {label} so the consumer has one shape.
-  assert.deepEqual(call.params.options[2], { label: "Accept the miss" });
-  assert.equal(call.params.objectiveKey, "pipeline");
-});
-
-test("SERVER UNREACHABLE: a failed escalation is reported, and the question survives in the ledger", async () => {
-  const { calls, deps } = spy({ callImpl: async () => { throw new Error("ECONNREFUSED"); } });
-  const r = await raiseEscalation({ objectiveKey: "pipeline", question: "?", options: [] }, deps);
-  assert.equal(r.ok, false);
-  assert.equal(r.reason, "escalation-threw");
-  assert.ok(calls.logs.some((l) => l.startsWith("warn:")));
-});
-
-test("an escalation error FRAME still records the question", async () => {
-  const { calls, deps } = spy({ callImpl: async () => ({ ok: false, error: { code: "FORBIDDEN" } }) });
-  const r = await raiseEscalation({ objectiveKey: "pipeline", question: "?", options: [] }, deps);
-  assert.equal(r.ok, false);
-  assert.equal(r.reason, "FORBIDDEN");
-  assert.ok(calls.logs.some((l) => /still recorded in the audit ledger/.test(l)));
-});
-
-// ---------------------------------------------------------------------------
-// The dispatcher
-// ---------------------------------------------------------------------------
-
-test("routeWorkItem dispatches each disposition to its own primitive", async () => {
-  for (const [collaborators, actionClasses, expected] of [
-    [[], [], "board.create"],
-    [[{ memberId: PEER, role: "DOER" }], [], "handoff.offer"],
-    [[{ memberId: PEER, role: "CONTRIBUTOR" }], [], "lease+board"],
-    [[], ["financial"], "approval.request"],
-  ]) {
-    const { deps } = spy();
-    const c = classify({ title: ITEM.title, advances: ["pipeline"], collaborators, actionClasses });
-    const r = await routeWorkItem(ITEM, c, deps);
-    assert.equal(r.primitive, expected, `${c.disposition} must route to ${expected}`);
-  }
-});
-
-test("an unknown disposition falls back to SELF rather than dropping the work", async () => {
-  const { calls, deps } = spy();
-  const r = await routeWorkItem(ITEM, { disposition: "NONSENSE", contributors: [], gatedClasses: [] }, deps);
-  assert.equal(r.routed, "SELF");
-  assert.equal(calls.board.length, 1);
-});