@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/subagents/client.test.mjs

@@ -1,309 +0,0 @@
-/**
- * client.test.mjs — the hq half of the registry (§2.1, §4). The contract under
- * test is FAIL-OPEN: nothing in this module may throw, because `apply()` throws
- * are fatal to the whole wizard (lib/setup/runner.mjs:220-227).
- * Run: node --test lib/subagents/client.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  TIMEOUT_MS,
-  createDefinition,
-  fetchResolve,
-  fetchRoster,
-  flushOutbox,
-  forkDefinition,
-  getDefinition,
-  getRead,
-  listDefinitions,
-  pinDefinition,
-  postRpc,
-  publishVersion,
-  resolveConfig,
-  unpinDefinition,
-  writeVerb,
-  yankDefinition,
-} from "./client.mjs";
-import { latestCached, listOutbox, queueOutbox } from "./lock.mjs";
-import { hashBody, parseAgentMd } from "./schema.mjs";
-
-const CFG = { enabled: true, base: "https://hq.example.com", token: "sk-test", orgId: "org_1", memberId: "mem_1" };
-const root = () => mkdtempSync(join(tmpdir(), "subagent-client-"));
-
-/** A recording fake fetch. `reply(url, init)` returns {ok,status,body} or throws. */
-function fakeFetch(reply) {
-  const calls = [];
-  const fn = async (url, init) => {
-    calls.push({ url: String(url), method: init && init.method, headers: (init && init.headers) || {}, body: init && init.body ? JSON.parse(init.body) : null });
-    const r = typeof reply === "function" ? await reply(String(url), init, calls.length) : reply;
-    if (r instanceof Error) throw r;
-    return { ok: r.ok !== false, status: r.status || 200, json: async () => r.body };
-  };
-  fn.calls = calls;
-  return fn;
-}
-const okFrame = (result) => ({ ok: true, status: 200, body: { ok: true, result } });
-const errFrame = (status, code, message) => ({ ok: false, status, body: { ok: false, error: { code, message } } });
-/** A fetch that never resolves — exercises the AbortController timeout. */
-const hangingFetch = () => async (_u, init) => new Promise((_res, rej) => {
-  if (init && init.signal) init.signal.addEventListener("abort", () => rej(Object.assign(new Error("aborted"), { name: "AbortError" })));
-});
-
-// ---------------------------------------------------------------------------
-// config
-// ---------------------------------------------------------------------------
-
-test("resolveConfig: env supplies base/token/org; enabled needs BOTH base and token", () => {
-  const c = resolveConfig({ cfg: {}, env: { COHORT_BASE: "https://hq.example.com/", COHORT_API_KEY: "sk", COHORT_ORG_ID: "org_9", COHORT_MEMBER_ID: "mem_9" } });
-  assert.equal(c.base, "https://hq.example.com", "trailing slash trimmed");
-  assert.equal(c.token, "sk");
-  assert.equal(c.orgId, "org_9");
-  assert.equal(c.memberId, "mem_9");
-  assert.equal(c.enabled, true);
-
-  assert.equal(resolveConfig({ cfg: {}, env: {} }).enabled, false);
-  assert.equal(resolveConfig({ cfg: {}, env: { COHORT_BASE: "https://x" } }).enabled, false);
-});
-
-test("resolveConfig: not enrolled is a legitimate steady state, not an error", () => {
-  // §4 — layer 1 simply does not exist; the section reports status:"skipped".
-  const c = resolveConfig({ cfg: {}, env: {} });
-  assert.deepEqual(c, { enabled: false, base: "", token: "", orgId: "", memberId: "" });
-});
-
-// ---------------------------------------------------------------------------
-// transport
-// ---------------------------------------------------------------------------
-
-test("postRpc: POSTs /v1/<method> with bearer, protocol and tenant-pin headers", async () => {
-  const f = fakeFetch(okFrame({ hello: "world" }));
-  const r = await postRpc("subagent.list", { a: 1 }, { cfg: CFG, fetchImpl: f, idempotencyKey: "k1" });
-  assert.deepEqual(r, { ok: true, result: { hello: "world" } });
-  const call = f.calls[0];
-  assert.equal(call.url, "https://hq.example.com/v1/subagent.list");
-  assert.equal(call.method, "POST");
-  assert.equal(call.headers.authorization, "Bearer sk-test");
-  assert.equal(call.headers["x-org-protocol"], "1");
-  assert.equal(call.headers["x-org-id"], "org_1");
-  assert.equal(call.headers["x-idempotency-key"], "k1");
-  assert.deepEqual(call.body, { a: 1 });
-});
-
-test("postRpc: a REJECTION (the server said no) is not degraded", async () => {
-  const r = await postRpc("subagent.pin", {}, { cfg: CFG, fetchImpl: fakeFetch(errFrame(403, "FORBIDDEN", "nope")) });
-  assert.equal(r.ok, false);
-  assert.equal(r.degraded, false, "the distinction that decides outbox-queue vs surface-the-error");
-  assert.equal(r.error.code, "FORBIDDEN");
-  assert.equal(r.status, 403);
-});
-
-test("postRpc: a transport failure (no answer) IS degraded, and never throws", async () => {
-  const r = await postRpc("subagent.pin", {}, { cfg: CFG, fetchImpl: fakeFetch(new Error("ECONNREFUSED")) });
-  assert.equal(r.ok, false);
-  assert.equal(r.degraded, true);
-  assert.match(r.error.message, /ECONNREFUSED/);
-});
-
-test("postRpc: a hung server aborts on the timeout and reports it as degraded", async () => {
-  const r = await postRpc("subagent.list", {}, { cfg: CFG, fetchImpl: hangingFetch(), timeoutMs: 20 });
-  assert.equal(r.degraded, true);
-  assert.match(r.error.message, /timeout after 20ms/);
-  assert.equal(TIMEOUT_MS, 5000, "5 s — a human waiting on a dead server is the worse outcome");
-});
-
-test("postRpc: unparseable / non-frame JSON is an error, not a crash", async () => {
-  const r = await postRpc("subagent.list", {}, { cfg: CFG, fetchImpl: fakeFetch({ ok: true, status: 200, body: "not-a-frame" }) });
-  assert.equal(r.ok, false);
-  assert.equal(r.error.code, "HTTP_200");
-});
-
-test("postRpc / getRead: no base or token → UNAUTHORIZED + degraded, with NO request made", async () => {
-  const f = fakeFetch(okFrame({}));
-  const r = await postRpc("subagent.list", {}, { cfg: { base: "", token: "" }, fetchImpl: f });
-  assert.equal(r.degraded, true);
-  assert.equal(r.error.code, "UNAUTHORIZED");
-  assert.equal((await getRead("subagent.roster", { cfg: {}, fetchImpl: f })).error.code, "UNAUTHORIZED");
-  assert.equal(f.calls.length, 0);
-});
-
-test("getRead: reads return the BARE payload on 200 (not an envelope)", async () => {
-  const f = fakeFetch({ ok: true, status: 200, body: { rosterVersion: 4, entries: [] } });
-  const r = await getRead("subagent.roster", { cfg: CFG, fetchImpl: f });
-  assert.deepEqual(r.payload, { rosterVersion: 4, entries: [] });
-  assert.equal(f.calls[0].method, "GET");
-  assert.equal("content-type" in f.calls[0].headers, false, "no body, no content-type");
-});
-
-// ---------------------------------------------------------------------------
-// reads
-// ---------------------------------------------------------------------------
-
-test("fetchRoster: the cheap poll — rosterVersion + bodiless entries", async () => {
-  const f = fakeFetch({ ok: true, status: 200, body: { rosterVersion: 11, entries: [{ slug: "alpha", definitionId: "d1", version: 3, contentHash: "h" }] } });
-  const r = await fetchRoster({ cfg: CFG, fetchImpl: f });
-  assert.equal(r.ok, true);
-  assert.equal(r.rosterVersion, 11);
-  assert.equal(r.entries[0].slug, "alpha");
-  assert.equal(f.calls[0].url, "https://hq.example.com/v1/subagent.roster");
-});
-
-test("fetchRoster: a dead server returns an empty, degraded roster — never throws", async () => {
-  const r = await fetchRoster({ cfg: CFG, fetchImpl: fakeFetch(new Error("down")) });
-  assert.deepEqual([r.ok, r.degraded, r.rosterVersion, r.entries], [false, true, 0, []]);
-});
-
-test("fetchResolve: sends the selector params and returns bodies + advice", async () => {
-  const f = fakeFetch(okFrame({ rosterVersion: 5, entries: [], rewire: [{ ref: "x", suggest: "y" }], unmatched: ["z"] }));
-  const r = await fetchResolve({ cfg: CFG, memberId: "mem_1", function: "executive-operator", altitude: "c-suite", refs: ["ghost"], fetchImpl: f });
-  assert.deepEqual(f.calls[0].body, { memberId: "mem_1", function: "executive-operator", altitude: "c-suite", refs: ["ghost"] });
-  assert.equal(r.rosterVersion, 5);
-  assert.deepEqual(r.unmatched, ["z"]);
-  assert.equal(r.rewire[0].suggest, "y");
-});
-
-test("fetchResolve: every returned body is cached so the NEXT run needs no network", async () => {
-  const agentRoot = root();
-  const f = fakeFetch(okFrame({
-    rosterVersion: 5,
-    entries: [{ slug: "alpha", version: 3, contentHash: "h", frontmatter: { name: "alpha", description: "d", model: "sonnet", tools: ["Read"] }, body: "# alpha\n\ncached body\n" }],
-  }));
-  await fetchResolve({ cfg: CFG, agentRoot, fetchImpl: f });
-  const cached = latestCached(agentRoot, "alpha");
-  assert.equal(cached.version, 3);
-  // Emitted through the same serializer the resolver parses with — lossless.
-  const parsed = parseAgentMd(cached.text);
-  assert.equal(parsed.frontmatter.name, "alpha");
-  assert.equal(parsed.body, "# alpha\n\ncached body\n");
-});
-
-test("fetchResolve: a failure yields an empty degraded result (layer 1 just vanishes)", async () => {
-  const r = await fetchResolve({ cfg: CFG, fetchImpl: fakeFetch(new Error("down")) });
-  assert.deepEqual([r.ok, r.degraded, r.entries.length], [false, true, 0]);
-});
-
-test("listDefinitions / getDefinition: shaped results, fail-open on error", async () => {
-  const l = await listDefinitions({ cfg: CFG, fetchImpl: fakeFetch(okFrame({ items: [{ slug: "alpha" }] })) });
-  assert.deepEqual(l.items, [{ slug: "alpha" }]);
-  const bad = await listDefinitions({ cfg: CFG, fetchImpl: fakeFetch(new Error("x")) });
-  assert.deepEqual(bad.items, []);
-  const g = await getDefinition("alpha", { cfg: CFG, fetchImpl: fakeFetch(okFrame({ slug: "alpha" })) });
-  assert.deepEqual(g.definition, { slug: "alpha" });
-  assert.equal((await getDefinition("alpha", { cfg: CFG, fetchImpl: fakeFetch(errFrame(404, "NOT_FOUND", "x")) })).definition, null);
-});
-
-// ---------------------------------------------------------------------------
-// writes + the outbox — the distinction that keeps work from being lost
-// ---------------------------------------------------------------------------
-
-test("writeVerb: a DEGRADED failure queues to the outbox for `maestro sync`", async () => {
-  const agentRoot = root();
-  const r = await writeVerb("subagent.create", { slug: "alpha" }, { cfg: CFG, agentRoot, fetchImpl: fakeFetch(new Error("offline")) });
-  assert.equal(r.degraded, true);
-  assert.ok(r.queued);
-  const queued = listOutbox(agentRoot);
-  assert.equal(queued.length, 1);
-  assert.deepEqual(queued[0].payload, { slug: "alpha" }, "queued verbatim — never re-derived at replay time");
-});
-
-test("writeVerb: a REJECTION is NOT queued (it would be rejected forever, invisibly)", async () => {
-  const agentRoot = root();
-  const r = await writeVerb("subagent.pin", { slug: "alpha" }, { cfg: CFG, agentRoot, fetchImpl: fakeFetch(errFrame(403, "FORBIDDEN", "nope")) });
-  assert.equal(r.ok, false);
-  assert.equal(r.degraded, false);
-  assert.equal(r.queued, undefined);
-  assert.deepEqual(listOutbox(agentRoot), []);
-});
-
-test("writeVerb: queue:false opts out (used where a caller wants the raw verdict)", async () => {
-  const agentRoot = root();
-  await writeVerb("subagent.pin", {}, { cfg: CFG, agentRoot, fetchImpl: fakeFetch(new Error("offline")), queue: false });
-  assert.deepEqual(listOutbox(agentRoot), []);
-});
-
-test("createDefinition: stamps contentHash, strips provenance, sends an idempotency key", async () => {
-  const f = fakeFetch(okFrame({ definitionId: "d1", version: 1 }));
-  await createDefinition({
-    slug: "alpha", title: "Alpha", summary: "s", tags: ["x"], functions: ["f"], altitudes: ["a"],
-    frontmatter: { name: "alpha", layer: "sdk", source: "sdk://1/alpha", contentHash: "old" },
-    body: "# alpha\n",
-  }, { cfg: CFG, fetchImpl: f });
-  const sent = f.calls[0].body;
-  assert.equal(sent.contentHash, hashBody("# alpha\n"));
-  assert.deepEqual(Object.keys(sent.frontmatter), ["name"], "a definition is prose, not a record of one copy of it");
-  assert.equal(sent.baseLayer, "none");
-  assert.equal(f.calls[0].headers["x-idempotency-key"], "subagent.create:org_1:alpha");
-});
-
-test("publishVersion: the idempotency key is (slug, contentHash) — a replay is a no-op", async () => {
-  const f = fakeFetch(okFrame({ version: 4 }));
-  await publishVersion({ slug: "alpha", definitionId: "d1", frontmatter: { name: "alpha" }, body: "b\n" }, { cfg: CFG, fetchImpl: f });
-  assert.equal(f.calls[0].headers["x-idempotency-key"], `subagent.publishVersion:alpha:${hashBody("b\n")}`);
-  assert.equal(f.calls[0].body.definitionId, "d1");
-});
-
-test("forkDefinition: records baseLayer/baseSlug and a fork generator", async () => {
-  const f = fakeFetch(okFrame({ definitionId: "d2", version: 1 }));
-  await forkDefinition({ slug: "alpha-mine", baseSlug: "alpha", frontmatter: { name: "alpha-mine" }, body: "b\n" }, { cfg: CFG, fetchImpl: f });
-  const sent = f.calls[0].body;
-  assert.equal(sent.baseLayer, "sdk");
-  assert.equal(sent.baseSlug, "alpha");
-  assert.deepEqual(sent.generator, { source: "fork", forkedFrom: "alpha" });
-});
-
-test("pin / unpin / yank: send only the identifiers they were given", async () => {
-  const f = fakeFetch(okFrame({}));
-  await pinDefinition({ slug: "alpha", definitionId: "d1", version: 3 }, { cfg: CFG, fetchImpl: f });
-  await unpinDefinition({ slug: "alpha" }, { cfg: CFG, fetchImpl: f });
-  await yankDefinition({ slug: "alpha", reason: "superseded" }, { cfg: CFG, fetchImpl: f });
-  assert.deepEqual(f.calls.map((c) => c.url.split("/v1/")[1]), ["subagent.pin", "subagent.unpin", "subagent.yank"]);
-  assert.equal(f.calls[0].body.version, 3);
-  assert.equal(f.calls[0].body.memberId, undefined, "an absent memberId means 'me' — hq fills it from the actor");
-  assert.equal(f.calls[2].body.reason, "superseded");
-});
-
-// ---------------------------------------------------------------------------
-// replay
-// ---------------------------------------------------------------------------
-
-test("flushOutbox: replays oldest-first and removes what landed", async () => {
-  const agentRoot = root();
-  queueOutbox(agentRoot, "subagent.create", { slug: "alpha" });
-  queueOutbox(agentRoot, "subagent.pin", { slug: "alpha" });
-  const f = fakeFetch(okFrame({}));
-  const r = await flushOutbox({ agentRoot, cfg: CFG, fetchImpl: f });
-  assert.deepEqual([r.replayed, r.remaining, r.stopped], [2, 0, false]);
-  assert.deepEqual(listOutbox(agentRoot), []);
-});
-
-test("flushOutbox: STOPS at the first degraded failure (the server is down again)", async () => {
-  const agentRoot = root();
-  queueOutbox(agentRoot, "subagent.create", { slug: "a" });
-  queueOutbox(agentRoot, "subagent.pin", { slug: "a" });
-  const f = fakeFetch((_u, _i, n) => (n === 1 ? okFrame({}) : new Error("down")));
-  const r = await flushOutbox({ agentRoot, cfg: CFG, fetchImpl: f });
-  assert.deepEqual([r.replayed, r.stopped, r.remaining], [1, true, 1]);
-  assert.equal(listOutbox(agentRoot).length, 1, "the undelivered write is still queued");
-});
-
-test("flushOutbox: DROPS a rejected entry and reports it (or the outbox never empties)", async () => {
-  const agentRoot = root();
-  queueOutbox(agentRoot, "subagent.pin", { slug: "a" });
-  queueOutbox(agentRoot, "subagent.pin", { slug: "b" });
-  const f = fakeFetch((_u, _i, n) => (n === 1 ? errFrame(409, "CONFLICT", "already there") : okFrame({})));
-  const r = await flushOutbox({ agentRoot, cfg: CFG, fetchImpl: f });
-  assert.equal(r.replayed, 1);
-  assert.equal(r.dropped.length, 1);
-  assert.equal(r.dropped[0].error.code, "CONFLICT");
-  assert.deepEqual(listOutbox(agentRoot), []);
-});
-
-test("flushOutbox: an empty outbox is a clean no-op", async () => {
-  const r = await flushOutbox({ agentRoot: root(), cfg: CFG, fetchImpl: fakeFetch(okFrame({})) });
-  assert.deepEqual(r, { replayed: 0, dropped: [], remaining: 0, stopped: false });
-});

package/lib/subagents/gap.test.mjs

@@ -1,234 +0,0 @@
-/**
- * gap.test.mjs — the three-way diff (§2.3): missing / unrostered / idle, and the
- * deliberately drop-biased rewire classifier.
- * Run: node --test lib/subagents/gap.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  REWIRE_THRESHOLD,
-  agentCorpus,
-  classifyRef,
-  computeGaps,
-  contextFromConfig,
-  rosterFromSurface,
-  scoreRef,
-  tokenize,
-} from "./gap.mjs";
-
-const resolvedOf = (slugs) => ({ entries: slugs.map((s) => ({ slug: s })), bySlug: new Map(slugs.map((s) => [s, { slug: s }])), localEdits: [], emptyDirs: [] });
-const ref = (r, file = "workflows/a.yaml", line = 3, kind = "workflow") => ({ ref: r, file, line, kind });
-
-// ---------------------------------------------------------------------------
-// tokenisation / scoring
-// ---------------------------------------------------------------------------
-
-test("tokenize: handles kebab, snake, camel and free text; drops stopwords and 1-2 char noise", () => {
-  assert.deepEqual(tokenize("regulatory-watch"), ["regulatory", "watch"]);
-  assert.deepEqual(tokenize("regulatory_watch"), ["regulatory", "watch"]);
-  assert.deepEqual(tokenize("regulatoryWatch"), ["regulatory", "watch"]);
-  assert.deepEqual(tokenize("the compliance agent for ops"), ["compliance"]);
-  assert.deepEqual(tokenize(null), []);
-});
-
-test("scoreRef: reference-normalised — a rich corpus is not penalised for being rich", () => {
-  const corpus = new Set(["compliance", "regulatory", "watch", "filings", "audit"]);
-  assert.equal(scoreRef("regulatory-watch", corpus), 1);
-  assert.equal(scoreRef("regulatory-digest", corpus), 0.5);
-  assert.equal(scoreRef("nothing-here", corpus), 0);
-  assert.equal(scoreRef("the-a", corpus), 0, "a ref with no signal tokens scores 0, never NaN");
-});
-
-test("agentCorpus: contextual skills/pillars only reinforce a corpus they already touch", () => {
-  const agent = { id: "compliance-officer", role: "Compliance", purpose: "regulatory filings" };
-  const bare = agentCorpus(agent);
-  assert.equal(bare.has("regulatory"), true);
-  assert.equal(bare.has("sox"), false);
-  const reinforced = agentCorpus(agent, { skills: ["regulatory sox reporting"], pillars: [], governance: [] });
-  assert.equal(reinforced.has("sox"), true, "shares 'regulatory' → the whole skill joins the corpus");
-  const unrelated = agentCorpus(agent, { skills: ["kubernetes cluster tuning"] });
-  assert.equal(unrelated.has("kubernetes"), false, "an unrelated skill must not pollute the corpus");
-});
-
-// ---------------------------------------------------------------------------
-// the classifier — biased to DROP because the signal is usually empty
-// ---------------------------------------------------------------------------
-
-test("classifyRef: proposes a rewire only on real lexical evidence", () => {
-  const roster = [{ id: "compliance-officer", role: "Compliance", purpose: "regulatory watch and filings" }];
-  const hit = classifyRef("regulatory-watch", { roster });
-  assert.equal(hit.action, "rewire");
-  assert.equal(hit.suggest, "compliance-officer");
-  assert.equal(hit.recommend, "rewire");
-  assert.ok(hit.score >= REWIRE_THRESHOLD);
-});
-
-test("classifyRef: below the bar it does NOT guess — the verdict is drop-or-create", () => {
-  // With title:"" and company:"UNCONFIGURED" common in the wild, a classifier
-  // with no signal that still proposes a rewire silently re-points a workflow
-  // step at the wrong agent.
-  const roster = [{ id: "compliance-officer", role: "Compliance", purpose: "regulatory filings" }];
-  const miss = classifyRef("slide-deck-builder", { roster });
-  assert.equal(miss.action, "drop-or-create");
-  assert.equal(miss.recommend, "drop");
-  assert.match(miss.reason, /vestigial step copied by `create`/);
-});
-
-test("classifyRef: an EMPTY roster still yields a usable drop verdict", () => {
-  const none = classifyRef("ghost-writer", { roster: [] });
-  assert.equal(none.action, "drop-or-create");
-  assert.equal(none.suggest, null);
-  assert.equal(none.score, 0);
-});
-
-// ---------------------------------------------------------------------------
-// roster shaping
-// ---------------------------------------------------------------------------
-
-test("rosterFromSurface: standardAgents ∪ roleAgents, deduped, tagged with its source", () => {
-  const roster = rosterFromSurface({
-    standardAgents: [{ id: "alpha", role: "A" }, { id: "shared", role: "S-standard" }],
-    roleAgents: [{ id: "shared", role: "S-role" }, { id: "beta", role: "B" }],
-  });
-  assert.deepEqual(roster.map((a) => [a.id, a.source]), [["alpha", "standard"], ["shared", "standard"], ["beta", "role"]]);
-});
-
-test("rosterFromSurface: tolerates a null/empty surface", () => {
-  assert.deepEqual(rosterFromSurface(null), []);
-  assert.deepEqual(rosterFromSurface({ standardAgents: [{ noId: 1 }] }), []);
-});
-
-// ---------------------------------------------------------------------------
-// the three-way diff
-// ---------------------------------------------------------------------------
-
-test("computeGaps: missing = roster ∖ resolved layers", () => {
-  const g = computeGaps({
-    roster: [{ id: "alpha", role: "A" }, { id: "beta", role: "B" }],
-    resolved: resolvedOf(["alpha"]),
-    refs: [ref("alpha"), ref("beta")],
-  });
-  assert.deepEqual(g.missing.map((m) => m.slug), ["beta"]);
-  assert.deepEqual(g.missing[0].actions, ["adopt-sdk", "fork", "create", "defer"]);
-});
-
-test("computeGaps: unrostered = refs ∖ roster, with file:line for the human to delete", () => {
-  const g = computeGaps({
-    roster: [{ id: "alpha" }],
-    resolved: resolvedOf(["alpha"]),
-    refs: [ref("alpha"), ref("ghost-writer", "workflows/vestigial.yaml", 12)],
-  });
-  assert.deepEqual(g.unrostered.map((u) => u.ref), ["ghost-writer"]);
-  assert.deepEqual(g.unrostered[0].locations, [{ file: "workflows/vestigial.yaml", line: 12, kind: "workflow" }]);
-});
-
-test("computeGaps: idle = roster agents NOTHING references (the check that did not exist)", () => {
-  const g = computeGaps({
-    roster: [{ id: "alpha" }, { id: "never-called", role: "Idle" }],
-    resolved: resolvedOf(["alpha", "never-called"]),
-    refs: [ref("alpha")],
-  });
-  assert.deepEqual(g.idle.map((i) => i.slug), ["never-called"]);
-  assert.equal(g.idle[0].resolves, true, "it exists — it is just dispatched to by nothing");
-});
-
-test("computeGaps: status is complete only with no missing AND no open drops", () => {
-  const clean = computeGaps({ roster: [{ id: "alpha" }], resolved: resolvedOf(["alpha"]), refs: [ref("alpha")] });
-  assert.equal(clean.status, "complete");
-  assert.match(clean.summary, /roster complete/);
-
-  const dirty = computeGaps({ roster: [{ id: "alpha" }], resolved: resolvedOf(["alpha"]), refs: [ref("ghost")] });
-  assert.equal(dirty.status, "partial");
-  assert.equal(dirty.openDrops.length, 1);
-});
-
-test("computeGaps: an ACCEPTED drop stops blocking completion (and stays visible)", () => {
-  const lock = { acceptedDrops: [{ ref: "ghost", file: "workflows/a.yaml", line: 3 }] };
-  const g = computeGaps({ roster: [{ id: "alpha" }], resolved: resolvedOf(["alpha"]), refs: [ref("alpha"), ref("ghost")], lock });
-  assert.equal(g.status, "complete");
-  assert.equal(g.openDrops.length, 0);
-  assert.equal(g.unrostered[0].accepted, true, "still reported — accepting is not forgetting");
-});
-
-test("computeGaps: an off-roster ref that DOES resolve on disk is not an open drop", () => {
-  const g = computeGaps({ roster: [{ id: "alpha" }], resolved: resolvedOf(["alpha", "extra"]), refs: [ref("alpha"), ref("extra")] });
-  assert.equal(g.unrostered[0].resolves, true);
-  assert.equal(g.openDrops.length, 0);
-  assert.equal(g.status, "complete");
-});
-
-test("computeGaps: a rewire suggestion alone is advisory and does not block completion", () => {
-  const roster = [{ id: "compliance-officer", role: "Compliance", purpose: "regulatory watch and filings" }];
-  const g = computeGaps({ roster, resolved: resolvedOf(["compliance-officer"]), refs: [ref("compliance-officer"), ref("regulatory-watch")] });
-  assert.equal(g.unrostered[0].action, "rewire");
-  assert.equal(g.openDrops.length, 0);
-  assert.equal(g.status, "complete");
-});
-
-test("computeGaps: unrostered is sorted by score, then alphabetically", () => {
-  const roster = [{ id: "compliance-officer", purpose: "regulatory watch" }];
-  const g = computeGaps({
-    roster,
-    resolved: resolvedOf([]),
-    refs: [ref("zulu-thing"), ref("alpha-thing"), ref("regulatory-watch")],
-  });
-  assert.deepEqual(g.unrostered.map((u) => u.ref), ["regulatory-watch", "alpha-thing", "zulu-thing"]);
-});
-
-test("computeGaps: carries localEdits/emptyDirs through and counts everything", () => {
-  const resolved = { ...resolvedOf(["alpha"]), localEdits: ["alpha"], emptyDirs: ["hollow"] };
-  const g = computeGaps({ roster: [{ id: "alpha" }, { id: "beta" }], resolved, refs: [ref("alpha"), ref("ghost")] });
-  assert.deepEqual(g.localEdits, ["alpha"]);
-  assert.deepEqual(g.emptyDirs, ["hollow"]);
-  assert.deepEqual(g.counts, { roster: 2, resolved: 1, missing: 1, unrostered: 1, idle: 1 });
-});
-
-test("computeGaps: nothing at all is 'complete' — there is nothing to decide", () => {
-  // An agent whose function has no capability pack has no authoritative roster.
-  // That must not block setup, so it reports complete rather than unconfigured.
-  const g = computeGaps({});
-  assert.equal(g.status, "complete");
-  assert.deepEqual(g.counts, { roster: 0, resolved: 0, missing: 0, unrostered: 0, idle: 0 });
-});
-
-test("computeGaps: 'unconfigured' means we know what is needed and NONE of it resolves", () => {
-  const g = computeGaps({ roster: [{ id: "alpha" }, { id: "beta" }], resolved: resolvedOf([]), refs: [] });
-  assert.equal(g.status, "unconfigured");
-  assert.equal(g.missing.length, 2);
-  // …and once even one resolves, it is merely partial.
-  assert.equal(computeGaps({ roster: [{ id: "alpha" }, { id: "beta" }], resolved: resolvedOf(["alpha"]), refs: [] }).status, "partial");
-});
-
-test("computeGaps: accepts a resolved shape with entries but no bySlug Map", () => {
-  const g = computeGaps({ roster: [{ id: "alpha" }], resolved: { entries: [{ slug: "alpha" }] }, refs: [ref("alpha")] });
-  assert.equal(g.status, "complete");
-});
-
-// ---------------------------------------------------------------------------
-// context extraction
-// ---------------------------------------------------------------------------
-
-test("contextFromConfig: pulls skills, responsibilities/charter pillars and governance themes", () => {
-  const c = contextFromConfig({
-    agentConfig: {
-      orgProfile: {
-        skills: ["regulatory reporting"],
-        governance: [{ theme: "risk", title: "Risk council", description: "quarterly" }, "plain string"],
-      },
-      responsibilities: ["own compliance"],
-      charter: { sections: [{ title: "Mandate", body: "watch filings" }] },
-    },
-  });
-  assert.deepEqual(c.skills, ["regulatory reporting"]);
-  assert.deepEqual(c.pillars, ["own compliance", "Mandate watch filings"]);
-  assert.equal(c.governance.length, 2);
-  assert.match(c.governance[0], /risk/);
-});
-
-test("contextFromConfig: every field absent is the COMMON case, and must not throw", () => {
-  assert.deepEqual(contextFromConfig({}), { skills: [], pillars: [], governance: [] });
-  assert.deepEqual(contextFromConfig({ agentConfig: { orgProfile: { skills: "not-an-array" } } }).skills, []);
-});