@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/cadences.test.mjs

@@ -1,230 +0,0 @@
-/**
- * cadences.test.mjs — tests for the archetype cadence resolver.
- * Run: `node --test lib/cadences.test.mjs`
- * @module cadences.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { resolveCadences, scheduleFor, STANDARD_CADENCES, RECURRING, isQuarterStartMonth, isCadenceDue } from "./cadences.mjs";
-
-function hasSchedule(c) {
-  return typeof c.interval === "number" || (c.calendar && typeof c.calendar === "object");
-}
-
-test("resolveCadences = standard ⊕ function recurring workflows ⊕ altitude cadences", async () => {
-  const cads = await resolveCadences({ function: "technical-leader", altitude: "c-suite" });
-  const ids = cads.map((c) => c.id);
-  // standard present
-  assert.ok(ids.includes("inbox-processor") && ids.includes("daily-morning-brief"));
-  // a function recurring cadence (from the technical-leader capability workflows)
-  assert.ok(ids.includes("engineering-health"), `expected a function cadence; got ${ids.join(",")}`);
-  // altitude cadence (c-suite → strategic memo)
-  assert.ok(ids.includes("weekly-strategic-memo"));
-  // every entry has a concrete schedule + unique ids
-  assert.ok(cads.every(hasSchedule), "every cadence has interval or calendar");
-  assert.equal(ids.length, new Set(ids).size, "no duplicate cadence ids");
-});
-
-test("event-driven workflows are excluded from cadences (pr-review is not scheduled)", async () => {
-  const cads = await resolveCadences({ function: "technical-leader", altitude: "vp" });
-  assert.ok(!cads.some((c) => c.id === "pr-review"), "event-driven pr-review must not be a scheduled cadence");
-});
-
-test("altitude changes the cadence set (c-suite memo vs senior-manager execution review)", async () => {
-  const cSuite = (await resolveCadences({ function: "operations-leader", altitude: "c-suite" })).map((c) => c.id);
-  const srMgr = (await resolveCadences({ function: "operations-leader", altitude: "senior-manager" })).map((c) => c.id);
-  assert.ok(cSuite.includes("weekly-strategic-memo"));
-  assert.ok(srMgr.includes("weekly-execution"));
-  assert.notDeepEqual(cSuite, srMgr);
-});
-
-test("scheduleFor is deterministic and matches the cadence keyword", () => {
-  assert.deepEqual(scheduleFor("weekly", "x"), scheduleFor("weekly", "x"));
-  assert.ok(scheduleFor("continuous", "x").interval);
-  assert.ok(scheduleFor("weekly", "engineering-health").calendar.weekday >= 1);
-  assert.ok(RECURRING.has("weekly") && !RECURRING.has("event-driven"));
-});
-
-test("resolveCadences requires { function, altitude }", async () => {
-  await assert.rejects(() => resolveCadences({}), /requires/);
-});
-
-test("quarter guard: quarterly cadence is due in Jan/Apr/Jul/Oct, not other months", () => {
-  // The plist fires Day=1 of every month; the guard restricts it to the
-  // quarter-start months so the principal gets 4, not 12, reports/year.
-  const due = [1, 4, 7, 10];
-  for (let month = 1; month <= 12; month++) {
-    // Day 1 of each month, midday local to dodge any TZ/DST edge.
-    const d = new Date(2026, month - 1, 1, 12, 0, 0);
-    const expected = due.includes(month);
-    assert.equal(isQuarterStartMonth(d), expected, `month ${month}: isQuarterStartMonth`);
-    assert.equal(isCadenceDue("quarterly-self-assessment", d), expected, `month ${month}: quarterly due`);
-  }
-});
-
-test("quarter guard does not constrain non-quarterly cadences", () => {
-  // A daily cadence is due every month — the guard is quarterly-only.
-  for (let month = 1; month <= 12; month++) {
-    const d = new Date(2026, month - 1, 1, 12, 0, 0);
-    assert.equal(isCadenceDue("daily-morning-brief", d), true, `month ${month}: daily always due`);
-    assert.equal(isCadenceDue("org-pulse", d), true, `month ${month}: org-pulse always due`);
-  }
-});
-
-test("STANDARD_CADENCES all carry a schedule; escalating ones carry a prompt", () => {
-  assert.ok(STANDARD_CADENCES.length >= 8);
-  // Every standard cadence is scheduled.
-  assert.ok(STANDARD_CADENCES.every((c) => hasSchedule(c)));
-  // Cadences that spawn a sub-session must carry a prompt; a guarded-inline
-  // cadence (e.g. skill-curator) legitimately has none — the daemon handles it
-  // in-process and never escalates.
-  assert.ok(STANDARD_CADENCES.filter((c) => c.mode === "escalate").every((c) => c.prompt));
-});
-
-test("economics/scheduling cadences are wired into STANDARD_CADENCES with the right mode + schedule", () => {
-  const byId = Object.fromEntries(STANDARD_CADENCES.map((c) => [c.id, c]));
-  // Deterministic economics cadences run inline (no LLM).
-  for (const id of ["nightly-cost-reconcile", "fleet-cost-digest", "org-cost-sync"]) {
-    assert.ok(byId[id], `${id} present in STANDARD_CADENCES`);
-    assert.equal(byId[id].mode, "inline", `${id} is inline (deterministic)`);
-    assert.ok(hasSchedule(byId[id]), `${id} has a schedule`);
-  }
-  // Calendar-pinned: nightly-cost-reconcile ~3:30am, fleet-cost-digest ~7am.
-  assert.deepEqual(byId["nightly-cost-reconcile"].calendar, { hour: 3, minute: 30 });
-  assert.deepEqual(byId["fleet-cost-digest"].calendar, { hour: 7, minute: 0 });
-  // org-cost-sync is an hourly interval.
-  assert.equal(byId["org-cost-sync"].interval, 3600);
-  // dynamic-jobs is the only GUARDED economics cadence (escalate-when-due) and a
-  // ~60s interval; because it can escalate it must carry a prompt.
-  assert.ok(byId["dynamic-jobs"], "dynamic-jobs present");
-  assert.equal(byId["dynamic-jobs"].mode, "guarded");
-  assert.equal(byId["dynamic-jobs"].interval, 60);
-  assert.ok(byId["dynamic-jobs"].prompt, "guarded dynamic-jobs carries an escalate prompt");
-});
-
-test("economics/scheduling cadences resolve into every agent's cadence set", async () => {
-  const ids = (await resolveCadences({ function: "operations-leader", altitude: "vp" })).map((c) => c.id);
-  for (const id of ["nightly-cost-reconcile", "fleet-cost-digest", "org-cost-sync", "dynamic-jobs"]) {
-    assert.ok(ids.includes(id), `${id} resolves into the standard cadence set`);
-  }
-});
-
-test("every STANDARD_CADENCES entry that declares a prompt has the file on disk", async () => {
-  // A guarded/escalate cadence whose prompt file is missing would DLQ at escalate
-  // time (regression guard for the dynamic-jobs.md gap).
-  const { existsSync } = await import("node:fs");
-  const { resolve, join } = await import("node:path");
-  const { fileURLToPath } = await import("node:url");
-  const root = resolve(fileURLToPath(new URL(".", import.meta.url)), "..");
-  for (const c of STANDARD_CADENCES.filter((x) => x.prompt)) {
-    assert.ok(existsSync(join(root, c.prompt)), `cadence ${c.id} prompt missing: ${c.prompt}`);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// The PLAN leg (SPEC §4/§5.6): mandate-derived obligations graft onto the
-// standard + archetype floor. This is what makes the schedule per-agent and
-// justified rather than a static default list.
-// ---------------------------------------------------------------------------
-
-/** A compiled SCHEDULE obligation, shaped as lib/plan/compile.mjs emits it. */
-function measureObligation(over = {}) {
-  return {
-    key: "schedule.measure.pipeline-coverage",
-    kind: "SCHEDULE",
-    cadence_id: "measure-pipeline-coverage",
-    scope: "mandate",
-    mode: "guarded",
-    prompt: "schedules/triggers/measure-pipeline-coverage.md",
-    schedule: { calendar: { weekday: 2, hour: 14, minute: 30 } },
-    cadence: "weekly",
-    objective_id: "obj_7Kx",
-    status: "active",
-    ...over,
-  };
-}
-
-test("plan leg: an adopted objective's measure obligation becomes a real cadence", async () => {
-  const cads = await resolveCadences({
-    function: "commercial-leader",
-    altitude: "vp",
-    obligations: [measureObligation()],
-  });
-  const c = cads.find((x) => x.id === "measure-pipeline-coverage");
-  assert.ok(c, "mandate-derived cadence resolves");
-  assert.equal(c.scope, "mandate");
-  assert.equal(c.mode, "guarded");
-  // The compiler solved this slot against the principal's calendar — the
-  // resolver's own scheduleFor() stagger must NOT overwrite it.
-  assert.deepEqual(c.calendar, { weekday: 2, hour: 14, minute: 30 });
-  // Provenance rides along so a tick can be walked back to its objective.
-  assert.equal(c.obligationKey, "schedule.measure.pipeline-coverage");
-  assert.equal(c.objectiveId, "obj_7Kx");
-});
-
-test("plan leg: the standard + archetype floor is RETAINED, never replaced", async () => {
-  // An agent whose human has adopted nothing must keep running today's cadences.
-  const withPlan = await resolveCadences({ function: "commercial-leader", altitude: "vp", obligations: [measureObligation()] });
-  const withoutPlan = await resolveCadences({ function: "commercial-leader", altitude: "vp" });
-  const baseIds = withoutPlan.map((c) => c.id);
-  const planIds = withPlan.map((c) => c.id);
-  for (const id of baseIds) assert.ok(planIds.includes(id), `${id} survives the plan leg`);
-  assert.equal(planIds.length, baseIds.length + 1, "the plan leg only ADDS");
-});
-
-test("plan leg: an empty/absent obligation list is exactly today's behaviour", async () => {
-  const none = await resolveCadences({ function: "technical-leader", altitude: "c-suite" });
-  const empty = await resolveCadences({ function: "technical-leader", altitude: "c-suite", obligations: [] });
-  assert.deepEqual(empty, none);
-});
-
-test("plan leg: a plan obligation cannot re-slot or override a standard cadence", async () => {
-  // First writer wins. A mandate obligation colliding with `inbox-processor`
-  // must not move it — that is what keeps existing launchd plists from churning.
-  const base = await resolveCadences({ function: "technical-leader", altitude: "c-suite" });
-  const original = base.find((c) => c.id === "inbox-processor");
-  const cads = await resolveCadences({
-    function: "technical-leader",
-    altitude: "c-suite",
-    obligations: [measureObligation({ cadence_id: "inbox-processor", schedule: { interval: 99999 }, key: "schedule.hijack" })],
-  });
-  const after = cads.find((c) => c.id === "inbox-processor");
-  assert.deepEqual(after, original, "the standard cadence is untouched");
-  assert.equal(cads.filter((c) => c.id === "inbox-processor").length, 1, "no duplicate entry");
-});
-
-test("plan leg: non-active / non-SCHEDULE obligations emit no cadence", async () => {
-  const cads = await resolveCadences({
-    function: "technical-leader",
-    altitude: "c-suite",
-    obligations: [
-      measureObligation({ cadence_id: "suspended-job", status: "suspended", key: "schedule.suspended" }),
-      { key: "outcome.pipeline-coverage", kind: "OUTCOME", cadence_id: "outcome-job", status: "active" },
-      { key: "react.email.received", kind: "REACT", status: "active", trigger: { topic: "email" } },
-    ],
-  });
-  const ids = cads.map((c) => c.id);
-  assert.ok(!ids.includes("suspended-job"), "a suspended obligation is not scheduled");
-  assert.ok(!ids.includes("outcome-job"), "an OUTCOME is measured, not launchd-scheduled");
-  assert.ok(!ids.includes("react.email.received"), "a REACT is event-driven, not scheduled");
-});
-
-test("plan leg: an interval obligation carries its interval through", async () => {
-  const cads = await resolveCadences({
-    function: "technical-leader",
-    altitude: "c-suite",
-    obligations: [measureObligation({ cadence_id: "fast-sensor", schedule: { interval: 300 }, key: "schedule.fast" })],
-  });
-  const c = cads.find((x) => x.id === "fast-sensor");
-  assert.equal(c.interval, 300);
-  assert.equal(c.calendar, undefined);
-});
-
-test("plan leg: founder altitude resolves its own cadences (was unreachable from the wizard)", async () => {
-  const ids = (await resolveCadences({ function: "finance-leader", altitude: "founder" })).map((c) => c.id);
-  assert.ok(ids.includes("weekly-runway-review"), "founder gets the runway review");
-  assert.ok(ids.includes("monthly-investor-update"), "founder gets the investor update");
-});

package/lib/capability/inventory.test.mjs

@@ -1,232 +0,0 @@
-/**
- * inventory.test.mjs — the capability inventory (SPEC §5.1).
- * Run: node --test lib/capability/inventory.test.mjs
- *
- * Everything external is injected: a fake HOME for ~/.claude/settings.json, a
- * fake org tool table, a fake org probe, a fake capability surface, a fake
- * clock. No network, no real settings file, no real MCP spawn.
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  buildInventory, writeManifest, readManifest, reachableIds, findCapability, byPlane,
-  checksumEntries, blastRadiusOfOrgTool, enumerateSkills, enumerateMcp, MANIFEST_REL,
-} from "./inventory.mjs";
-import { probeSkillPlugin, probeMcpServer, probeOrgPlane, probeGrantedPluginTools } from "./probe.mjs";
-
-const AT = "2026-08-11T09:00:00.000Z";
-
-/** A tmp agent repo + a tmp HOME, so nothing touches the real machine. */
-function fixture({ withMarketplace = false, withEnabled = false, mcp = { cohort: { command: "cohort-mcp" } }, skills = ["morning-brief", "inbox-triage"] } = {}) {
-  const root = mkdtempSync(join(tmpdir(), "maestro-inv-"));
-  const home = mkdtempSync(join(tmpdir(), "maestro-home-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-
-  if (skills) {
-    mkdirSync(join(root, "plugins", "agent-skills", "skills"), { recursive: true });
-    for (const s of skills) writeFileSync(join(root, "plugins", "agent-skills", "skills", `${s}.md`), `# ${s}\n`);
-  }
-  if (withMarketplace) {
-    mkdirSync(join(root, "plugins", "agent-skills", ".claude-plugin"), { recursive: true });
-    writeFileSync(join(root, "plugins", "agent-skills", ".claude-plugin", "marketplace.json"), JSON.stringify({ name: "agent-skills", plugins: [] }));
-  }
-  if (withEnabled) {
-    mkdirSync(join(home, ".claude"), { recursive: true });
-    writeFileSync(join(home, ".claude", "settings.json"), JSON.stringify({ enabledPlugins: { "agent-skills@agent-skills": true } }));
-  }
-  if (mcp) writeFileSync(join(root, ".mcp.json"), JSON.stringify({ mcpServers: mcp }));
-  return { root, home };
-}
-
-const FAKE_ORG_TOOLS = [
-  { name: "board_ready", access: "read", binding: { kind: "rpc", method: "board.ready" } },
-  { name: "task_create", access: "write", binding: { kind: "rpc", method: "task.create" } },
-  { name: "messaging_send", access: "write", outbound: true, binding: { kind: "rpc", method: "messaging.send" } },
-  { name: "books_invoice_send", access: "write", binding: { kind: "rpc", method: "books.invoiceSend" } },
-  { name: "linear_create_issue", access: "write", integration: "linear", binding: { kind: "rpc" } },
-];
-
-function deps({ home, orgOk = true, mandateFamily = true, logs = [] }) {
-  return {
-    homeDir: home,
-    now: () => AT,
-    logImpl: (m) => logs.push(m),
-    orgToolsImpl: async () => FAKE_ORG_TOOLS,
-    orgProbeImpl: async () => (orgOk
-      ? { ok: true, detail: "mandate.version round-trip ok", mandateFamily }
-      : { ok: false, detail: "org.cohort is not enabled", degraded: "org-not-enrolled", mandateFamily: false }),
-    capabilitySurface: async () => ({ workflows: [{ id: "weekly-operating-review", cadence: "weekly", purpose: "run the operating cadence" }] }),
-    wishlistImpl: async () => ([
-      { id: "cohort", env: [], optional: false, purpose: "org spine" },
-      { id: "notion", env: ["NOTION_API_KEY"], optional: true, purpose: "decision log" },
-    ]),
-  };
-}
-
-test("buildInventory: enumerates all four planes and marks unregistered skills UNREACHABLE", async () => {
-  const { root, home } = fixture();
-  const logs = [];
-  const m = await buildInventory({ agentRoot: root, archetype: { function: "executive-operator", altitude: "c-suite" } }, deps({ home, logs }));
-
-  assert.equal(m.schemaVersion, 1);
-  assert.equal(m.generatedAt, AT);
-  assert.ok(m.counts.builtin > 5, "builtins inventoried");
-  assert.ok(m.counts.skill >= 3, "2 skill files + 1 workflow");
-  assert.ok(m.counts.mcp >= 2, "cohort (declared) + notion (wished-for)");
-  assert.equal(m.counts.org, FAKE_ORG_TOOLS.length);
-
-  // The whole point: skills whose marketplace is unregistered are NOT reachable.
-  const skill = findCapability(m, "skill:agent-skills:morning-brief");
-  assert.ok(skill, "skill discovered");
-  assert.equal(skill.reachable, false);
-  assert.match(skill.probe.detail, /marketplace/);
-
-  // ...and it is LOGGED, not swallowed.
-  assert.ok(logs.some((l) => /DEGRADED skill plugin:agent-skills/.test(l)), `expected a logged degradation, got: ${logs.join(" | ")}`);
-});
-
-test("buildInventory: registered + enabled marketplace makes skills reachable", async () => {
-  const { root, home } = fixture({ withMarketplace: true, withEnabled: true });
-  const m = await buildInventory({ agentRoot: root, archetype: { function: "executive-operator", altitude: "c-suite" } }, deps({ home }));
-  const skill = findCapability(m, "skill:agent-skills:inbox-triage");
-  assert.equal(skill.reachable, true);
-  assert.ok(reachableIds(m).has("skill:agent-skills:inbox-triage"));
-});
-
-test("repair:true registers the marketplace and enables the plugin (rung 1 stops being a lie)", async () => {
-  const { root, home } = fixture();
-  const logs = [];
-  const m = await buildInventory({ agentRoot: root, repair: true, archetype: { function: "executive-operator", altitude: "c-suite" } }, deps({ home, logs }));
-  assert.ok(existsSync(join(root, "plugins", "agent-skills", ".claude-plugin", "marketplace.json")), "marketplace written");
-  const settings = JSON.parse(readFileSync(join(home, ".claude", "settings.json"), "utf8"));
-  assert.ok(Object.keys(settings.enabledPlugins).some((k) => k.startsWith("agent-skills")), "plugin enabled");
-  assert.equal(findCapability(m, "skill:agent-skills:morning-brief").reachable, true);
-  assert.ok(m.repairs.length >= 2 && logs.some((l) => /repaired/.test(l)));
-});
-
-test("mcp plane: wished-for server absent from .mcp.json is unreachable with a stated reason", async () => {
-  const { root, home } = fixture();
-  const m = await buildInventory({ agentRoot: root, archetype: { function: "executive-operator", altitude: "c-suite" } }, deps({ home }));
-  const notion = findCapability(m, "mcp:notion");
-  assert.equal(notion.reachable, false);
-  assert.match(notion.probe.detail, /absent from \.mcp\.json|credential env/);
-  const cohort = findCapability(m, "mcp:cohort");
-  assert.equal(cohort.reachable, true);
-});
-
-test("org plane: an un-enrolled agent inventories the tools but NONE are reachable", async () => {
-  const { root, home } = fixture();
-  const logs = [];
-  const m = await buildInventory({ agentRoot: root, archetype: { function: "executive-operator", altitude: "c-suite" } }, deps({ home, orgOk: false, logs }));
-  const org = byPlane(m, "org");
-  assert.equal(org.length, FAKE_ORG_TOOLS.length);
-  assert.equal(org.filter((e) => e.reachable).length, 0);
-  assert.equal(m.mandateFamily, false);
-  assert.ok(logs.some((l) => /org-not-enrolled/.test(l)));
-});
-
-test("blast radius: outbound → external, financial verbs → financial, reads → internal", () => {
-  assert.equal(blastRadiusOfOrgTool({ name: "messaging_send", access: "write", outbound: true }), "external");
-  assert.equal(blastRadiusOfOrgTool({ name: "books_invoice_send", access: "write" }), "financial");
-  assert.equal(blastRadiusOfOrgTool({ name: "board_ready", access: "read" }), "internal");
-  assert.equal(blastRadiusOfOrgTool({ name: "task_create", access: "write" }), "irreversible");
-});
-
-test("determinism: checksum is stable across runs and ignores probedAt", async () => {
-  const { root, home } = fixture({ withMarketplace: true, withEnabled: true });
-  const a = await buildInventory({ agentRoot: root, archetype: { function: "executive-operator", altitude: "c-suite" } }, deps({ home }));
-  const b = await buildInventory({ agentRoot: root, archetype: { function: "executive-operator", altitude: "c-suite" } }, { ...deps({ home }), now: () => "2027-01-01T00:00:00.000Z" });
-  assert.equal(a.checksum, b.checksum, "same capabilities → same checksum despite a different clock");
-  assert.notEqual(a.generatedAt, b.generatedAt);
-});
-
-test("checksum CHANGES when a capability's reachability flips", () => {
-  const base = [{ id: "x", plane: "org", kind: "method_tool", reachable: true }];
-  const flipped = [{ id: "x", plane: "org", kind: "method_tool", reachable: false }];
-  assert.notEqual(checksumEntries(base), checksumEntries(flipped));
-});
-
-test("write/read round-trip is atomic and queryable", async () => {
-  const { root, home } = fixture();
-  const m = await buildInventory({ agentRoot: root, archetype: { function: "executive-operator", altitude: "c-suite" } }, deps({ home }));
-  const p = writeManifest(root, m);
-  assert.equal(p, join(root, MANIFEST_REL));
-  const back = readManifest(root);
-  assert.equal(back.checksum, m.checksum);
-  assert.equal(byPlane(back, "builtin").length, byPlane(m, "builtin").length);
-});
-
-test("degradation is recorded when no archetype is supplied (never silent)", async () => {
-  const { root, home } = fixture();
-  const logs = [];
-  const m = await buildInventory({ agentRoot: root }, deps({ home, logs }));
-  assert.ok(m.degradations.some((d) => /archetype/.test(d.id)));
-  assert.ok(logs.some((l) => /archetype:workflows/.test(l)));
-});
-
-// ── probe-level units ────────────────────────────────────────────────────────
-
-test("probeMcpServer: missing credential env fails closed with the key named", () => {
-  const r = probeMcpServer({ name: "notion", declared: true, requiredEnv: ["NOTION_API_KEY"], env: {} });
-  assert.equal(r.ok, false);
-  assert.equal(r.degraded, "mcp-credential-missing");
-  assert.match(r.detail, /NOTION_API_KEY/);
-});
-
-test("probeMcpServer: an injected handshake decides the verdict", () => {
-  const ok = probeMcpServer({ name: "cohort", declared: true, env: {} }, { handshake: () => ({ ok: true, detail: "hello" }) });
-  assert.equal(ok.ok, true);
-  const bad = probeMcpServer({ name: "cohort", declared: true, env: {} }, { handshake: () => { throw new Error("spawn ENOENT"); } });
-  assert.equal(bad.ok, false);
-  assert.equal(bad.degraded, "mcp-handshake-threw");
-});
-
-test("probeOrgPlane: NOT_FOUND on mandate.version means transport LIVE, mandate family absent", async () => {
-  const r = await probeOrgPlane({ enabled: true, call: async () => ({ ok: false, error: { code: "NOT_FOUND" } }) });
-  assert.equal(r.ok, true, "the transport answered, so the plane is reachable");
-  assert.equal(r.mandateFamily, false);
-  assert.equal(r.degraded, "mandate-family-absent");
-});
-
-test("probeOrgPlane: falls back to a snapshot read, and a dead server is unreachable", async () => {
-  const ok = await probeOrgPlane({ enabled: true, call: async () => ({ ok: false, error: { code: "BAD_REQUEST" } }), read: async () => ({ ok: true }) });
-  assert.equal(ok.ok, true);
-  const dead = await probeOrgPlane({ enabled: true, call: async () => ({ ok: false, error: { code: "BAD_REQUEST" } }), read: async () => ({ ok: false, status: 503 }) });
-  assert.equal(dead.ok, false);
-  assert.equal(dead.degraded, "org-unreachable");
-});
-
-test("probeGrantedPluginTools: an absent toolset cache is reported, not swallowed", () => {
-  const { root } = fixture();
-  const r = probeGrantedPluginTools(root);
-  assert.equal(r.ok, false);
-  assert.equal(r.degraded, "toolset-absent");
-  mkdirSync(join(root, "state", "org"), { recursive: true });
-  writeFileSync(join(root, "state", "org", "toolset.json"), JSON.stringify({ version: 7, tools: [{ name: "linear_create_issue" }] }));
-  const r2 = probeGrantedPluginTools(root);
-  assert.equal(r2.ok, true);
-  assert.equal(r2.toolsetVersion, 7);
-});
-
-test("probeSkillPlugin: a plugin dir with no marketplace fails closed and names the path", () => {
-  const { root, home } = fixture();
-  const r = probeSkillPlugin({ pluginDir: join(root, "plugins", "agent-skills"), pluginId: "agent-skills" }, { homeDir: home });
-  assert.equal(r.ok, false);
-  assert.equal(r.degraded, "marketplace-unregistered");
-});
-
-test("enumerateSkills/enumerateMcp are pure over injected fs state", () => {
-  const { root, home } = fixture({ withMarketplace: true, withEnabled: true, skills: ["a", "b", "c"] });
-  const s = enumerateSkills({ agentRoot: root, at: AT }, { homeDir: home });
-  assert.equal(s.entries.length, 3);
-  assert.ok(s.entries.every((e) => e.plane === "skill" && e.reachable));
-
-  const m = enumerateMcp({ agentRoot: root, at: AT, env: {}, wishlist: [] }, {});
-  assert.deepEqual(m.entries.map((e) => e.id), ["mcp:cohort"]);
-});

package/lib/capability.test.mjs

@@ -1,78 +0,0 @@
-/**
- * capability.test.mjs — tests for the capability-surface resolver.
- * Run: `node --test lib/capability.test.mjs`
- * @module capability.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import {
-  resolveCapabilitySurface,
-  loadCapabilityPack,
-  filterTeamsByBreadth,
-  buildEventRouting,
-  listCapabilityFunctions,
-  STANDARD_DEFAULT_AGENTS,
-} from "./capability.mjs";
-
-const TEAMS = [
-  { id: "a", core: true, agents: [{ id: "a1", tier: "lead" }, { id: "a2", tier: "core" }, { id: "a3", tier: "support" }] },
-  { id: "b", core: false, agents: [{ id: "b1", tier: "lead" }, { id: "b2", tier: "support" }] },
-];
-
-test("filterTeamsByBreadth: breadth scales the roster deterministically", () => {
-  const count = (b) => filterTeamsByBreadth(TEAMS, b).flatMap((t) => t.agents).length;
-  assert.equal(count("broad"), 5); // both teams, all tiers
-  assert.equal(count("moderate"), 3); // both teams, drop support (a: lead+core, b: lead)
-  assert.equal(count("narrow"), 2); // core team only (a), drop support
-  assert.equal(count("none"), 0);
-});
-
-test("technical-leader capability pack loads with mcp/skills/workflows/teams", async () => {
-  assert.ok(listCapabilityFunctions().includes("technical-leader"));
-  const pack = await loadCapabilityPack("technical-leader");
-  assert.ok(pack.mcpServers.length >= 1);
-  assert.ok(pack.skills.length >= 1);
-  assert.ok(pack.workflows.length >= 1);
-  assert.ok(pack.agentTeams.length >= 3);
-});
-
-test("resolveCapabilitySurface composes standard defaults + altitude-scaled role agents", async () => {
-  const s = await resolveCapabilitySurface({ function: "technical-leader", altitude: "c-suite" });
-  assert.equal(s.standardAgents.length, STANDARD_DEFAULT_AGENTS.length);
-  assert.ok(s.roleAgents.length > 0);
-  assert.equal(s.counts.total, s.counts.standard + s.counts.role);
-  assert.ok(s.mcpServers.length >= 1);
-  assert.ok(s.roleAgents.every((a) => a.id && a.role && a.team), "role agents carry id/role/team");
-});
-
-test("altitude scales breadth: c-suite ≥ vp ≥ senior-manager role-agent count", async () => {
-  const c = await resolveCapabilitySurface({ function: "technical-leader", altitude: "c-suite" });
-  const v = await resolveCapabilitySurface({ function: "technical-leader", altitude: "vp" });
-  const m = await resolveCapabilitySurface({ function: "technical-leader", altitude: "senior-manager" });
-  assert.ok(c.counts.role >= v.counts.role, `c-suite(${c.counts.role}) ≥ vp(${v.counts.role})`);
-  assert.ok(v.counts.role >= m.counts.role, `vp(${v.counts.role}) ≥ senior-manager(${m.counts.role})`);
-});
-
-test("buildEventRouting maps standard, workflow, and skill handlers", async () => {
-  const s = await resolveCapabilitySurface({ function: "technical-leader", altitude: "vp" });
-  const { routes } = buildEventRouting(s);
-  assert.ok(routes.some((r) => r.via === "standard-agent"));
-  assert.ok(routes.some((r) => r.via === "workflow"));
-  assert.ok(routes.some((r) => r.via === "skill"));
-});
-
-test("every function pack resolves to a 40–60 role roster at broad altitude, with unique ids + mcp/skills/workflows", async () => {
-  const fns = listCapabilityFunctions();
-  assert.ok(fns.length >= 6, `expected ≥6 capability packs, got ${fns.length}`);
-  for (const fn of fns) {
-    const pack = await loadCapabilityPack(fn);
-    const ids = pack.agentTeams.flatMap((t) => t.agents.map((a) => a.id));
-    assert.equal(ids.length, new Set(ids).size, `${fn}: duplicate agent ids`);
-    assert.ok(pack.mcpServers.length >= 1 && pack.skills.length >= 1 && pack.workflows.length >= 1, `${fn}: missing mcp/skills/workflows`);
-    const broad = await resolveCapabilitySurface({ function: fn, altitude: "founder" }); // founder ⇒ broad
-    assert.ok(broad.counts.role >= 40 && broad.counts.role <= 60, `${fn}: broad role count ${broad.counts.role} not in 40–60`);
-  }
-});