@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/lib/subagents/lock.test.mjs

@@ -1,248 +0,0 @@
-/**
- * lock.test.mjs — the registry's on-disk state (§3, §4): the lock (provenance),
- * the cache (the offline fourth layer), the outbox (offline writes) and the
- * headless gaps report.
- * Run: node --test lib/subagents/lock.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-
-import {
-  CACHE_REL,
-  GAPS_REL,
-  LOCK_REL,
-  OUTBOX_REL,
-  acceptDrop,
-  cacheDir,
-  cachePath,
-  emptyLock,
-  gapsPath,
-  isAcceptedDrop,
-  latestCached,
-  listOutbox,
-  lockPath,
-  mergeLock,
-  outboxDir,
-  queueOutbox,
-  readCache,
-  readGaps,
-  readLock,
-  removeOutbox,
-  writeCache,
-  writeGaps,
-  writeLock,
-} from "./lock.mjs";
-
-const root = () => mkdtempSync(join(tmpdir(), "subagent-lock-"));
-
-// ---------------------------------------------------------------------------
-// lock
-// ---------------------------------------------------------------------------
-
-test("paths: the lock is provenance (.maestro/), the rest is scratch (state/)", () => {
-  // Blowing away state/ must DEGRADE the registry (cold cache) but never lose
-  // provenance — that split is the whole reason for two directories.
-  assert.equal(LOCK_REL, join(".maestro", "subagents.lock.json"));
-  assert.equal(CACHE_REL, join("state", "subagents", "cache"));
-  assert.equal(OUTBOX_REL, join("state", "subagents", "outbox"));
-  assert.equal(GAPS_REL, join("state", "subagents", "gaps.json"));
-  const r = root();
-  assert.equal(lockPath(r), join(r, LOCK_REL));
-  assert.equal(cacheDir(r), join(r, CACHE_REL));
-  assert.equal(outboxDir(r), join(r, OUTBOX_REL));
-  assert.equal(gapsPath(r), join(r, GAPS_REL));
-});
-
-test("readLock: missing OR corrupt → the empty-but-valid shape, never null", () => {
-  const r = root();
-  assert.deepEqual(readLock(r), emptyLock());
-  mkdirSync(join(r, ".maestro"), { recursive: true });
-  writeFileSync(lockPath(r), "{ not json");
-  assert.deepEqual(readLock(r), emptyLock());
-  writeFileSync(lockPath(r), '"a string"');
-  assert.deepEqual(readLock(r), emptyLock());
-});
-
-test("readLock: coerces every field so a hand-edited lock cannot crash a consumer", () => {
-  const r = root();
-  mkdirSync(join(r, ".maestro"), { recursive: true });
-  writeFileSync(lockPath(r), JSON.stringify({
-    version: "nope",
-    rosterVersion: "7",
-    degraded: "workspace",
-    acceptedDrops: [{ ref: "x" }, "junk", null],
-    agents: { alpha: { layer: 3, version: "9", contentHash: 5, localEdits: "yes" }, bad: "not-an-object" },
-  }));
-  const lock = readLock(r);
-  assert.equal(lock.version, 1);
-  assert.equal(lock.rosterVersion, 0, "a string rosterVersion is not finite → 0");
-  assert.deepEqual(lock.degraded, []);
-  assert.deepEqual(lock.acceptedDrops, [{ ref: "x" }]);
-  assert.equal(lock.agents.alpha.layer, "3");
-  assert.equal(lock.agents.alpha.version, null);
-  assert.equal(lock.agents.alpha.contentHash, "5");
-  assert.equal(lock.agents.alpha.localEdits, true);
-  assert.equal("bad" in lock.agents, false);
-});
-
-test("writeLock / mergeLock: per-slug merge, null deletes, arrays replace", () => {
-  const r = root();
-  assert.equal(writeLock(r, { ...emptyLock(), agents: { alpha: { layer: "sdk", fileHash: "h1" } } }), true);
-
-  const merged = mergeLock(r, { agents: { alpha: { fileHash: "h2" }, beta: { layer: "workspace" } }, rosterVersion: 5 });
-  assert.equal(merged.agents.alpha.layer, "sdk", "existing keys survive the merge");
-  assert.equal(merged.agents.alpha.fileHash, "h2");
-  assert.equal(merged.agents.beta.layer, "workspace");
-  assert.equal(merged.rosterVersion, 5);
-  assert.deepEqual(readLock(r).agents.beta.layer, "workspace", "written to disk");
-
-  const dropped = mergeLock(r, { agents: { beta: null } });
-  assert.equal("beta" in dropped.agents, false);
-  assert.equal(dropped.rosterVersion, 5, "unsupplied fields are untouched");
-});
-
-test("mergeLock: degraded is deduped", () => {
-  const r = root();
-  const l = mergeLock(r, { degraded: ["workspace", "workspace", "assessment"] });
-  assert.deepEqual(l.degraded, ["workspace", "assessment"]);
-});
-
-test("writeLock: fail-open (returns false) rather than throwing", () => {
-  // A failed lock write degrades the NEXT run to "everything looks locally
-  // edited" — safe. It must not abort the current one, because apply() throws
-  // are fatal to the whole wizard.
-  const r = root();
-  writeFileSync(join(r, ".maestro"), "i am a file, not a directory");
-  assert.equal(writeLock(r, emptyLock()), false);
-});
-
-// ---------------------------------------------------------------------------
-// accepted drops — the section NEVER edits a workflow, it records the location
-// ---------------------------------------------------------------------------
-
-test("acceptDrop: records ref + file:line, dedupes on the same location", () => {
-  const r = root();
-  acceptDrop(r, { ref: "ghost", file: "workflows/a.yaml", line: 12, reason: "vestigial" });
-  acceptDrop(r, { ref: "ghost", file: "workflows/a.yaml", line: 12, reason: "vestigial again" });
-  acceptDrop(r, { ref: "ghost", file: "workflows/b.yaml", line: 3 });
-  const lock = readLock(r);
-  assert.equal(lock.acceptedDrops.length, 2);
-  assert.equal(lock.acceptedDrops[0].reason, "vestigial again");
-  assert.ok(lock.acceptedDrops[0].acceptedAt);
-  assert.equal(isAcceptedDrop(lock, "ghost"), true);
-  assert.equal(isAcceptedDrop(lock, "other"), false);
-  assert.equal(isAcceptedDrop(null, "ghost"), false);
-});
-
-// ---------------------------------------------------------------------------
-// cache — the offline fourth layer
-// ---------------------------------------------------------------------------
-
-test("writeCache / readCache: version lives in the filename so versions coexist", () => {
-  const r = root();
-  assert.equal(writeCache(r, "alpha", 1, "v1 body"), true);
-  assert.equal(writeCache(r, "alpha", 2, "v2 body"), true);
-  assert.equal(readCache(r, "alpha", 1), "v1 body");
-  assert.equal(readCache(r, "alpha", 2), "v2 body");
-  assert.equal(readCache(r, "alpha", 3), null);
-  assert.equal(cachePath(r, "alpha", 2).endsWith("alpha@2.md"), true);
-  assert.equal(cachePath(r, "alpha", null).endsWith("alpha@head.md"), true);
-});
-
-test("latestCached: highest numeric version wins; null when nothing is cached", () => {
-  const r = root();
-  assert.equal(latestCached(r, "alpha"), null);
-  writeCache(r, "alpha", 2, "two");
-  writeCache(r, "alpha", 10, "ten");
-  writeCache(r, "alpha", 3, "three");
-  writeCache(r, "beta", 1, "beta-one");
-  const best = latestCached(r, "alpha");
-  assert.equal(best.version, 10);
-  assert.equal(best.text, "ten");
-  assert.equal(latestCached(r, "gamma"), null, "prefix match must not leak across slugs");
-});
-
-// ---------------------------------------------------------------------------
-// outbox — offline writes
-// ---------------------------------------------------------------------------
-
-test("queueOutbox / listOutbox: chronological, payload stored VERBATIM", () => {
-  const r = root();
-  // Verbatim matters: at replay time the local file may have changed again, and
-  // replaying a different body than the operator approved is the worst outcome.
-  const p1 = queueOutbox(r, "subagent.create", { slug: "alpha", body: "b1" });
-  const p2 = queueOutbox(r, "subagent.pin", { slug: "alpha" });
-  assert.ok(p1 && p2);
-  const list = listOutbox(r);
-  assert.equal(list.length, 2);
-  assert.deepEqual(list.map((e) => e.op).sort(), ["subagent.create", "subagent.pin"]);
-  const create = list.find((e) => e.op === "subagent.create");
-  assert.deepEqual(create.payload, { slug: "alpha", body: "b1" });
-  assert.ok(create.queuedAt);
-  assert.equal(listOutbox(r).map((e) => e.path).every(existsSync), true);
-});
-
-test("queueOutbox: two writes of the SAME op in the same millisecond do not collide", () => {
-  // `create` immediately followed by `pin` queues twice inside one millisecond.
-  // A timestamp-only filename made the second overwrite the first and silently
-  // lost the operator's work — the exact failure the outbox exists to prevent.
-  const r = root();
-  for (let i = 0; i < 25; i++) queueOutbox(r, "subagent.pin", { slug: `s${i}` });
-  const list = listOutbox(r);
-  assert.equal(list.length, 25);
-  assert.deepEqual(list.map((e) => e.payload.slug), Array.from({ length: 25 }, (_, i) => `s${i}`), "and replay order is still chronological");
-});
-
-test("listOutbox: a corrupt entry is skipped, never fatal; missing dir → []", () => {
-  const r = root();
-  assert.deepEqual(listOutbox(r), []);
-  queueOutbox(r, "subagent.pin", { slug: "alpha" });
-  writeFileSync(join(outboxDir(r), "0000-corrupt.json"), "{ nope");
-  const list = listOutbox(r);
-  assert.equal(list.length, 1);
-  assert.equal(list[0].op, "subagent.pin");
-});
-
-test("removeOutbox: removes a replayed entry, fail-open on a missing path", () => {
-  const r = root();
-  const p = queueOutbox(r, "subagent.pin", {});
-  assert.equal(removeOutbox(p), true);
-  assert.deepEqual(listOutbox(r), []);
-  assert.equal(removeOutbox(p), false);
-});
-
-test("queueOutbox: sanitises the op so a hostile op name cannot escape the outbox", () => {
-  const r = root();
-  const p = queueOutbox(r, "subagent.pin/../../evil", {});
-  // The separators are stripped, so the file lands in the outbox directory
-  // itself — path traversal via the op name is not representable.
-  assert.equal(dirname(p), outboxDir(r));
-  assert.equal(listOutbox(r).length, 1);
-});
-
-// ---------------------------------------------------------------------------
-// gaps report
-// ---------------------------------------------------------------------------
-
-test("writeGaps / readGaps: stamps generatedAt and round trips", () => {
-  const r = root();
-  assert.equal(readGaps(r), null);
-  assert.equal(writeGaps(r, { summary: "1 missing", counts: { missing: 1 } }), true);
-  const g = readGaps(r);
-  assert.equal(g.summary, "1 missing");
-  assert.deepEqual(g.counts, { missing: 1 });
-  assert.ok(g.generatedAt);
-  assert.equal(JSON.parse(readFileSync(gapsPath(r), "utf8")).summary, "1 missing");
-});
-
-test("readGaps: fail-open on a corrupt report", () => {
-  const r = root();
-  mkdirSync(join(r, "state", "subagents"), { recursive: true });
-  writeFileSync(gapsPath(r), "{ nope");
-  assert.equal(readGaps(r), null);
-});

package/lib/subagents/manifest.test.mjs

@@ -1,175 +0,0 @@
-/**
- * manifest.test.mjs — layer 0's index (§2.2): the sha256 classification that
- * makes shipped agent.md files updatable WITHOUT touching `create`'s copy list
- * or `UPGRADE_PATHS`.
- * Run: node --test lib/subagents/manifest.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import {
-  MANIFEST_REL,
-  buildManifest,
-  isManagedByManifest,
-  listAgentDirs,
-  manifestPath,
-  manifestShas,
-  manifestSlugs,
-  readManifest,
-  readSdkAgent,
-  writeManifest,
-} from "./manifest.mjs";
-import { hashBody, hashFile, stringifyAgentMd } from "./schema.mjs";
-
-const MAESTRO_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
-
-function sdkRoot() {
-  return mkdtempSync(join(tmpdir(), "subagent-manifest-"));
-}
-function putAgent(root, slug, over = {}, body = "# body\n\nprose\n") {
-  const fm = { name: slug, description: `${slug} does things`, model: "sonnet", tools: ["Read"], ...over };
-  const text = stringifyAgentMd(fm, body);
-  mkdirSync(join(root, "agents", slug), { recursive: true });
-  writeFileSync(join(root, "agents", slug, "agent.md"), text);
-  return text;
-}
-
-// ---------------------------------------------------------------------------
-
-test("listAgentDirs: an agents/<slug>/ with NO agent.md is reported empty, not ignored", () => {
-  // That empty directory is exactly what used to pass `doctor`.
-  const root = sdkRoot();
-  putAgent(root, "alpha");
-  mkdirSync(join(root, "agents", "hollow"), { recursive: true });
-  writeFileSync(join(root, "agents", "loose-file.txt"), "x");
-  const { slugs, empty } = listAgentDirs(root);
-  assert.deepEqual(slugs, ["alpha"]);
-  assert.deepEqual(empty, ["hollow"]);
-});
-
-test("listAgentDirs: fail-open when agents/ does not exist", () => {
-  assert.deepEqual(listAgentDirs(sdkRoot()), { slugs: [], empty: [] });
-});
-
-test("buildManifest: one entry per agent, with BOTH hashes and the routing facts", () => {
-  const root = sdkRoot();
-  const text = putAgent(root, "alpha", { tier: "standard", functions: ["executive-operator"] }, "# alpha\n\nhi {{agent.firstName}}\n");
-  const { manifest, invalid } = buildManifest({ maestroRoot: root, sdkVersion: "9.9.9", now: new Date("2026-01-01T00:00:00Z") });
-
-  assert.deepEqual(invalid, []);
-  assert.equal(manifest.sdkVersion, "9.9.9");
-  assert.equal(manifest.generatedAt, "2026-01-01T00:00:00.000Z");
-  const e = manifest.agents.alpha;
-  assert.equal(e.sha256, hashFile(text), "sha256 is the WHOLE file (local-edit classification)");
-  assert.equal(e.bodyHash, hashBody("# alpha\n\nhi {{agent.firstName}}\n"), "bodyHash matches hq's contentHash preimage");
-  assert.notEqual(e.sha256, e.bodyHash);
-  assert.equal(e.model, "claude-sonnet-4-6", "the alias is normalised in the manifest");
-  assert.deepEqual(e.tools, ["Read"]);
-  assert.equal(e.tier, "standard");
-  assert.deepEqual(e.functions, ["executive-operator"]);
-  assert.deepEqual(e.tokens, ["agent.firstName"]);
-});
-
-test("buildManifest: an INVALID agent.md still gets an entry (so it stays classifiable)", () => {
-  const root = sdkRoot();
-  putAgent(root, "alpha", { name: "wrong-name" });
-  const { manifest, invalid } = buildManifest({ maestroRoot: root });
-  assert.equal(invalid.length, 1);
-  assert.equal(invalid[0].slug, "alpha");
-  assert.ok(manifest.agents.alpha, "still listed — otherwise every deployed copy would freeze as a local edit");
-});
-
-test("buildManifest: carries the PREVIOUS sha forward as history (multi-release upgrades)", () => {
-  const root = sdkRoot();
-  putAgent(root, "alpha", {}, "v1\n");
-  const first = buildManifest({ maestroRoot: root, sdkVersion: "1.0.0" }).manifest;
-  const shaV1 = first.agents.alpha.sha256;
-
-  putAgent(root, "alpha", {}, "v2\n");
-  const second = buildManifest({ maestroRoot: root, sdkVersion: "2.0.0", previous: first }).manifest;
-  assert.notEqual(second.agents.alpha.sha256, shaV1);
-  assert.deepEqual(second.agents.alpha.history, [shaV1]);
-
-  // An agent still holding the v1 bytes classifies as MANAGED, not locally edited.
-  assert.equal(manifestShas(second).has(shaV1), true);
-});
-
-test("buildManifest: history never contains the current sha and is capped at 10", () => {
-  const root = sdkRoot();
-  let manifest = { agents: {} };
-  for (let i = 0; i < 14; i++) {
-    putAgent(root, "alpha", {}, `v${i}\n`);
-    manifest = buildManifest({ maestroRoot: root, previous: manifest }).manifest;
-  }
-  const e = manifest.agents.alpha;
-  assert.equal(e.history.length, 10);
-  assert.equal(e.history.includes(e.sha256), false);
-});
-
-test("buildManifest: empty directories are recorded on the manifest", () => {
-  const root = sdkRoot();
-  putAgent(root, "alpha");
-  mkdirSync(join(root, "agents", "hollow"), { recursive: true });
-  assert.deepEqual(buildManifest({ maestroRoot: root }).manifest.emptyDirs, ["hollow"]);
-});
-
-test("writeManifest / readManifest round trip, and manifestSlugs is sorted", () => {
-  const root = sdkRoot();
-  putAgent(root, "zeta");
-  putAgent(root, "alpha");
-  const { manifest } = buildManifest({ maestroRoot: root, sdkVersion: "3.2.1" });
-  const p = writeManifest(root, manifest);
-  assert.equal(p, manifestPath(root));
-  assert.equal(p.endsWith(MANIFEST_REL), true);
-  const read = readManifest(root);
-  assert.equal(read.sdkVersion, "3.2.1");
-  assert.deepEqual(manifestSlugs(read), ["alpha", "zeta"]);
-});
-
-test("readManifest: fail-open on a missing OR corrupt manifest — degrades SAFELY", () => {
-  // Degrading to "layer 0 has no managed files" makes every on-disk file look
-  // locally edited, which means nothing is overwritten. Safe direction.
-  const root = sdkRoot();
-  assert.deepEqual(readManifest(root), { sdkVersion: "", agents: {} });
-  mkdirSync(join(root, "agents"), { recursive: true });
-  writeFileSync(manifestPath(root), "{ not json");
-  assert.deepEqual(readManifest(root), { sdkVersion: "", agents: {} });
-  assert.deepEqual([...manifestShas(readManifest(root))], []);
-});
-
-test("isManagedByManifest: exact file bytes only", () => {
-  const root = sdkRoot();
-  const text = putAgent(root, "alpha");
-  const { manifest } = buildManifest({ maestroRoot: root });
-  assert.equal(isManagedByManifest(manifest, text), true);
-  assert.equal(isManagedByManifest(manifest, text + "\n# edited\n"), false);
-  assert.equal(isManagedByManifest(manifest, ""), false);
-  assert.equal(isManagedByManifest(manifest, null), false);
-});
-
-test("readSdkAgent: returns parsed text + fileHash, null when absent", () => {
-  const root = sdkRoot();
-  const text = putAgent(root, "alpha");
-  const a = readSdkAgent(root, "alpha");
-  assert.equal(a.slug, "alpha");
-  assert.equal(a.text, text);
-  assert.equal(a.fileHash, hashFile(text));
-  assert.equal(a.frontmatter.name, "alpha");
-  assert.equal(readSdkAgent(root, "nope"), null);
-});
-
-test("the REAL SDK tree builds a manifest with no invalid agents", () => {
-  const { manifest, invalid } = buildManifest({ maestroRoot: MAESTRO_ROOT, sdkVersion: "test" });
-  assert.deepEqual(invalid.map((i) => i.slug), []);
-  assert.ok(Object.keys(manifest.agents).length >= 1);
-  for (const [slug, e] of Object.entries(manifest.agents)) {
-    const text = readFileSync(join(MAESTRO_ROOT, "agents", slug, "agent.md"), "utf8");
-    assert.equal(e.sha256, hashFile(text), `${slug} sha must be the file hash`);
-  }
-});

package/lib/subagents/refs.test.mjs

@@ -1,204 +0,0 @@
-/**
- * refs.test.mjs — THE single sub-agent reference parser (§2.1).
- * Run: node --test lib/subagents/refs.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";
-
-import {
-  AGENT_REF_PATTERN,
-  AGENT_VIA,
-  SELF_SENTINELS,
-  agentRefRegex,
-  groupRefs,
-  parseAgentRefs,
-  parseEventRoutingRefs,
-  parseTeamRefs,
-  scanAgentRefs,
-} from "./refs.mjs";
-
-/** The two regexes this module replaces, verbatim, so the fixes are provable. */
-const OLD_DOCTOR = () => /^\s+agent:\s*([\w-]+)\b/gm;
-
-function repo() {
-  const root = mkdtempSync(join(tmpdir(), "subagent-refs-"));
-  mkdirSync(join(root, "workflows"), { recursive: true });
-  mkdirSync(join(root, "teams"), { recursive: true });
-  mkdirSync(join(root, "config"), { recursive: true });
-  return root;
-}
-const refsOf = (list) => list.map((r) => r.ref);
-
-// ---------------------------------------------------------------------------
-// parseAgentRefs — the grammar and the two bugs it fixes
-// ---------------------------------------------------------------------------
-
-test("parseAgentRefs: matches all four keys at any indent, including a list item", () => {
-  const text = [
-    "agent: top-level",
-    "  agent: indented",
-    "  - agent: in-a-list",
-    "  delegate: delegated",
-    "  subagent: subbed",
-    "  handler: handled",
-  ].join("\n");
-  assert.deepEqual(refsOf(parseAgentRefs(text, { kind: "workflow" })),
-    ["top-level", "indented", "in-a-list", "delegated", "subbed", "handled"]);
-});
-
-test("parseAgentRefs: a TOP-LEVEL `agent:` is visible (the old doctor regex missed it)", () => {
-  const text = "agent: top-level\n";
-  assert.equal(OLD_DOCTOR().exec(text), null, "sanity: the old regex really did miss it");
-  assert.deepEqual(refsOf(parseAgentRefs(text)), ["top-level"]);
-});
-
-test("parseAgentRefs: a malformed value is INVISIBLE, not silently truncated", () => {
-  // The old `\b` regex matched `agent: foo bar` and reported `foo`, hiding the
-  // malformation. Anchoring to end-of-line makes a bad value a non-match, which
-  // is what lets a caller trust the set it gets.
-  const text = "  agent: foo bar\n";
-  assert.equal(OLD_DOCTOR().exec(text)[1], "foo", "sanity: the old regex truncated");
-  assert.deepEqual(parseAgentRefs(text), []);
-});
-
-test("parseAgentRefs: a trailing comment is allowed and stripped", () => {
-  assert.deepEqual(refsOf(parseAgentRefs("  agent: alpha   # why\n")), ["alpha"]);
-});
-
-test("parseAgentRefs: self sentinels are skipped", () => {
-  const text = ["  agent: agent-self", "  agent: agent_self", "  agent: self", "  agent: real"].join("\n");
-  assert.deepEqual(refsOf(parseAgentRefs(text)), ["real"]);
-  for (const s of ["agent-self", "agent_self", "self"]) assert.equal(SELF_SENTINELS.has(s), true);
-});
-
-test("parseAgentRefs: reports 1-indexed line numbers and carries kind/file", () => {
-  const out = parseAgentRefs("x: 1\ny: 2\n  agent: alpha\n", { kind: "workflow", file: "workflows/a.yaml" });
-  assert.deepEqual(out, [{ ref: "alpha", key: "agent", line: 3, kind: "workflow", file: "workflows/a.yaml" }]);
-});
-
-test("agentRefRegex: a FRESH regex per call (a shared /g carries lastIndex)", () => {
-  const text = "  agent: alpha\n  agent: beta\n";
-  assert.deepEqual(refsOf(parseAgentRefs(text)), ["alpha", "beta"]);
-  assert.deepEqual(refsOf(parseAgentRefs(text)), ["alpha", "beta"], "second call must not resume mid-string");
-  assert.equal(agentRefRegex().source, AGENT_REF_PATTERN);
-  assert.equal(agentRefRegex().lastIndex, 0);
-});
-
-test("parseAgentRefs: non-string / empty input returns []", () => {
-  assert.deepEqual(parseAgentRefs(null), []);
-  assert.deepEqual(parseAgentRefs(""), []);
-  assert.deepEqual(parseAgentRefs(42), []);
-});
-
-// ---------------------------------------------------------------------------
-// teams/*.yaml — membership was never checked before
-// ---------------------------------------------------------------------------
-
-test("parseTeamRefs: reads `lead:` and the `members:` block sequence", () => {
-  const y = [
-    "id: growth",
-    "lead: growth-lead",
-    "members:",
-    "  - desktop-operator   # comment",
-    "  - research-analyst",
-    "responsibilities:",
-    "  - not-an-agent",
-  ].join("\n");
-  const out = parseTeamRefs(y, { file: "teams/growth.yaml" });
-  assert.deepEqual(refsOf(out), ["growth-lead", "desktop-operator", "research-analyst"]);
-  assert.equal(out.every((r) => r.kind === "team" && r.file === "teams/growth.yaml"), true);
-});
-
-test("parseTeamRefs: a sibling key ENDS the members block", () => {
-  const y = ["members:", "  - alpha", "other:", "  - beta"].join("\n");
-  assert.deepEqual(refsOf(parseTeamRefs(y)), ["alpha"]);
-});
-
-test("parseTeamRefs: skips self sentinels", () => {
-  assert.deepEqual(refsOf(parseTeamRefs("members:\n  - agent-self\n  - alpha\n")), ["alpha"]);
-});
-
-// ---------------------------------------------------------------------------
-// event-routing — `via:` is what stops every workflow id being reported
-// ---------------------------------------------------------------------------
-
-test("parseEventRoutingRefs: `via` decides whether a handler is an AGENT", () => {
-  const y = [
-    "routes:",
-    "  - event: inbox.received",
-    "    handler: triage-agent",
-    "    via: standard-agent",
-    "  - event: cadence.tick",
-    "    handler: daily-brief",
-    "    via: workflow",
-    "  - event: x.y",
-    "    handler: some-skill",
-    "    via: skill",
-  ].join("\n");
-  const out = parseEventRoutingRefs(y, { file: "config/event-routing.yaml" });
-  assert.deepEqual(out.map((r) => [r.ref, r.isAgent]), [
-    ["triage-agent", true],
-    ["daily-brief", false],
-    ["some-skill", false],
-  ]);
-});
-
-test("parseEventRoutingRefs: a route with NO `via` is treated as an agent handler", () => {
-  const out = parseEventRoutingRefs("  - event: e\n    handler: mystery\n");
-  assert.deepEqual(out.map((r) => [r.ref, r.isAgent, r.via]), [["mystery", true, ""]]);
-});
-
-test("parseEventRoutingRefs: key order within a route does not matter", () => {
-  const y = ["  - via: standard-agent", "    handler: alpha", "  - handler: beta", "    via: workflow"].join("\n");
-  assert.deepEqual(parseEventRoutingRefs(y).map((r) => [r.ref, r.isAgent]), [["alpha", true], ["beta", false]]);
-  for (const v of ["standard-agent", "role-agent", "agent"]) assert.equal(AGENT_VIA.has(v), true);
-});
-
-// ---------------------------------------------------------------------------
-// scanAgentRefs — all three sources in one pass
-// ---------------------------------------------------------------------------
-
-test("scanAgentRefs: covers workflows + teams + event-routing, and filters non-agent routes", () => {
-  const root = repo();
-  mkdirSync(join(root, "workflows", "nested"), { recursive: true });
-  writeFileSync(join(root, "workflows", "a.yaml"), "steps:\n  - agent: alpha\n  - agent: agent-self\n");
-  writeFileSync(join(root, "workflows", "nested", "b.yml"), "  agent: nested-one\n");
-  writeFileSync(join(root, "workflows", "notes.md"), "  agent: ignored-non-yaml\n");
-  writeFileSync(join(root, "teams", "t.yaml"), "members:\n  - team-member\n");
-  writeFileSync(join(root, "config", "event-routing.yaml"),
-    "  - event: e\n    handler: routed-agent\n    via: standard-agent\n  - event: f\n    handler: some-workflow\n    via: workflow\n");
-
-  const refs = scanAgentRefs({ agentRoot: root });
-  assert.deepEqual(refsOf(refs).sort(), ["alpha", "nested-one", "routed-agent", "team-member"]);
-  assert.deepEqual([...new Set(refs.map((r) => r.kind))].sort(), ["event-routing", "team", "workflow"]);
-  assert.equal(refs.every((r) => r.file && !r.file.startsWith("/")), true, "paths are agentRoot-relative");
-});
-
-test("scanAgentRefs: includeNonAgentRouting surfaces workflow/skill handlers too", () => {
-  const root = repo();
-  writeFileSync(join(root, "config", "event-routing.yaml"), "  - event: f\n    handler: some-workflow\n    via: workflow\n");
-  assert.deepEqual(refsOf(scanAgentRefs({ agentRoot: root })), []);
-  assert.deepEqual(refsOf(scanAgentRefs({ agentRoot: root, includeNonAgentRouting: true })), ["some-workflow"]);
-});
-
-test("scanAgentRefs: fail-open on a missing root / missing dirs", () => {
-  assert.deepEqual(scanAgentRefs({}), []);
-  assert.deepEqual(scanAgentRefs({ agentRoot: join(tmpdir(), "definitely-not-here-12345") }), []);
-});
-
-test("groupRefs: collapses to slug → locations", () => {
-  const m = groupRefs([
-    { ref: "alpha", file: "w/a.yaml", line: 2, kind: "workflow" },
-    { ref: "alpha", file: "w/b.yaml", line: 9, kind: "workflow" },
-    { ref: "beta", file: "t/t.yaml", line: 1, kind: "team" },
-    null,
-  ]);
-  assert.equal(m.get("alpha").length, 2);
-  assert.deepEqual(m.get("beta"), [{ file: "t/t.yaml", line: 1, kind: "team" }]);
-  assert.equal(m.size, 2);
-});