@cohortapp/agent-sdk 2.3.2 → 2.4.1

package/lib/capability/inventory.mjs

@@ -0,0 +1,542 @@
+/**
+ * lib/capability/inventory.mjs — the agent's CAPABILITY MAP (SPEC §5.1).
+ *
+ * Exhaustively enumerates everything this agent can actually *do*, across the
+ * four planes of the execution ladder, and probes each one for reachability:
+ *
+ *   builtin — Claude Code's own tools (Read/Write/Edit/Bash/Glob/Grep/Task/…)
+ *   skill   — plugin skills on disk (plugins/<plugin>/skills/*.md) + archetype
+ *             workflows + the sub-agent roster (agents/<id>/agent.md)
+ *   mcp     — servers declared in .mcp.json, cross-read with the role's
+ *             config/mcp-servers.yaml wish-list
+ *   org     — the curated Cohort protocol tools (lib/org/tool-surface.getOrgTools)
+ *             plus the workspace's GRANTED integration tools from
+ *             state/org/toolset.json
+ *
+ * The output is a durable, queryable artefact — `config/capability-manifest.json`
+ * (tracked in git, so a capability appearing or disappearing shows up in a diff)
+ * — that sessions, the schedule compiler and the execution router all consult.
+ *
+ * THE LAW this file exists to enforce: **an entry with `reachable:false` may not
+ * be cited by any obligation.** `lib/plan/compile.mjs` reads this manifest and
+ * refuses to emit an obligation whose `uses[]` is not reachable, so a schedule
+ * can never be built on a capability the agent does not have.
+ *
+ * Determinism: entries are emitted in a stable (plane, id) order and the manifest
+ * carries a `checksum` over the identity-bearing fields only (id/plane/kind/
+ * reachable), so re-running the inventory when nothing changed produces the same
+ * checksum even though `probedAt` moved. That is what lets the plan compiler
+ * decide "nothing on disk needs to move".
+ *
+ * Fail-open, never silent: every plane that cannot be enumerated or probed
+ * records a `degradations[]` entry (id + reason) AND logs. A plane that throws
+ * yields zero entries for that plane, not a failed setup.
+ *
+ * Pure-ish + injectable: all fs/network/clock effects arrive via `deps`.
+ *
+ * @module lib/capability/inventory
+ */
+
+"use strict";
+
+import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+
+import { probeSkillPlugin, probeMcpServer, probeOrgPlane, probeGrantedPluginTools, readJsonSafe, PLANES } from "./probe.mjs";
+
+/** Relative path of the durable manifest (tracked in git). */
+export const MANIFEST_REL = join("config", "capability-manifest.json");
+/** Manifest schema version — bump when the entry shape changes. */
+export const MANIFEST_VERSION = 1;
+
+/**
+ * Claude Code's built-in tool surface. Always reachable (they ship with the
+ * binary) but still inventoried, because the execution router needs to know
+ * a rung-3 session can read/write the filesystem and a rung-0 call cannot.
+ * `blastRadius` follows the SPEC's ACTION_CLASSES vocabulary.
+ */
+export const BUILTIN_TOOLS = Object.freeze([
+  { id: "Read", kind: "tool", blastRadius: "internal", costHint: "free" },
+  { id: "Write", kind: "tool", blastRadius: "irreversible", costHint: "free" },
+  { id: "Edit", kind: "tool", blastRadius: "irreversible", costHint: "free" },
+  { id: "Glob", kind: "tool", blastRadius: "internal", costHint: "free" },
+  { id: "Grep", kind: "tool", blastRadius: "internal", costHint: "free" },
+  { id: "Bash", kind: "tool", blastRadius: "irreversible", costHint: "cheap" },
+  { id: "WebFetch", kind: "tool", blastRadius: "external", costHint: "cheap" },
+  { id: "WebSearch", kind: "tool", blastRadius: "external", costHint: "cheap" },
+  { id: "Task", kind: "tool", blastRadius: "internal", costHint: "session" },
+  { id: "Skill", kind: "tool", blastRadius: "internal", costHint: "cheap" },
+  { id: "TodoWrite", kind: "tool", blastRadius: "internal", costHint: "free" },
+]);
+
+/** Map an org tool descriptor onto the ACTION_CLASSES blast-radius vocabulary. */
+export function blastRadiusOfOrgTool(t) {
+  if (!t) return "internal";
+  if (t.outbound) return "external";
+  if (t.access === "admin") return "irreversible";
+  if (t.access === "write") {
+    if (/^(email|messaging|calling)_/.test(t.name || "")) return "external";
+    if (/(books|payment|invoice|expense)/.test(t.name || "")) return "financial";
+    return "irreversible";
+  }
+  return "internal";
+}
+
+/** Cost hint for an org tool: reads are free, writes cheap, sessions expensive. */
+export function costHintOfOrgTool(t) {
+  return t && t.access === "read" ? "free" : "cheap";
+}
+
+// ---------------------------------------------------------------------------
+// Enumerators — one per plane. Each returns { entries, degradations }.
+// ---------------------------------------------------------------------------
+
+/** Built-in plane. Static; always reachable. */
+export function enumerateBuiltins(at) {
+  return {
+    entries: BUILTIN_TOOLS.map((b) => ({
+      id: `builtin:${b.id}`,
+      plane: "builtin",
+      kind: b.kind,
+      invocation: b.id,
+      reachable: true,
+      probedAt: at,
+      probe: { name: "static", ok: true, detail: "ships with Claude Code" },
+      costHint: b.costHint,
+      blastRadius: b.blastRadius,
+      source: "claude-code",
+    })),
+    degradations: [],
+  };
+}
+
+/**
+ * Skill plane: every `plugins/<plugin>/skills/*.md` under the agent repo AND the
+ * framework repo. A skill is reachable only when its plugin's marketplace is
+ * registered and the plugin is enabled — probed per plugin, not per skill.
+ *
+ * @param {object} o - { agentRoot, maestroRoot, at, repair? }
+ * @param {object} [deps] - fs + { homeDir }
+ */
+export function enumerateSkills(o = {}, deps = {}) {
+  const { agentRoot, maestroRoot, at, repair = false } = o;
+  const ex = deps.existsSync || existsSync;
+  const rdd = deps.readdirSync || readdirSync;
+  const entries = [];
+  const degradations = [];
+  const repairs = [];
+  const seen = new Set();
+
+  for (const root of [agentRoot, maestroRoot].filter(Boolean)) {
+    const pluginsDir = join(root, "plugins");
+    if (!ex(pluginsDir)) continue;
+    let pluginIds = [];
+    try {
+      pluginIds = rdd(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+    } catch (e) {
+      degradations.push({ plane: "skill", id: pluginsDir, reason: `unreadable plugins dir: ${msg(e)}` });
+      continue;
+    }
+    for (const pluginId of pluginIds) {
+      const pluginDir = join(pluginsDir, pluginId);
+      const probe = probeSkillPlugin({ pluginDir, pluginId, repair }, deps);
+      if (Array.isArray(probe.repaired) && probe.repaired.length) repairs.push(...probe.repaired);
+      if (!probe.ok) {
+        degradations.push({ plane: "skill", id: `plugin:${pluginId}`, reason: `${probe.degraded}: ${probe.detail}` });
+      }
+      const skillsDir = join(pluginDir, "skills");
+      if (!ex(skillsDir)) continue;
+      let files = [];
+      try {
+        files = rdd(skillsDir).filter((f) => f.endsWith(".md")).sort();
+      } catch (e) {
+        degradations.push({ plane: "skill", id: `plugin:${pluginId}`, reason: `unreadable skills dir: ${msg(e)}` });
+        continue;
+      }
+      for (const f of files) {
+        const name = f.replace(/\.md$/, "");
+        const id = `skill:${pluginId}:${name}`;
+        if (seen.has(id)) continue;
+        seen.add(id);
+        entries.push({
+          id,
+          plane: "skill",
+          kind: "skill",
+          invocation: `Skill(${pluginId}:${name})`,
+          reachable: probe.ok,
+          probedAt: at,
+          probe: { name: "marketplace+enabledPlugins", ok: probe.ok, detail: probe.detail },
+          costHint: "session",
+          blastRadius: "internal",
+          source: root === agentRoot ? "agent-repo" : "framework",
+        });
+      }
+    }
+  }
+  return { entries, degradations, repairs };
+}
+
+/**
+ * Skill plane, archetype leg: the function's recurring + event-driven workflows.
+ * These are procedures the agent is expected to run; they are reachable as soon
+ * as the capability pack resolved (they are prompts, not credentials).
+ * @param {object} o - { surface, at }  surface = lib/capability.resolveCapabilitySurface()
+ */
+export function enumerateWorkflows(o = {}) {
+  const { surface, at } = o;
+  const list = (surface && Array.isArray(surface.workflows) ? surface.workflows : []).filter((w) => w && w.id);
+  return {
+    entries: list.map((w) => ({
+      id: `workflow:${w.id}`,
+      plane: "skill",
+      kind: "workflow",
+      invocation: `workflows/${w.id}`,
+      reachable: true,
+      probedAt: at,
+      probe: { name: "capability-pack", ok: true, detail: `archetype workflow (${w.cadence || "event-driven"})` },
+      costHint: "session",
+      blastRadius: "internal",
+      source: "archetype",
+      cadence: w.cadence || null,
+      purpose: w.purpose || w.name || "",
+    })),
+    degradations: [],
+  };
+}
+
+/**
+ * Skill plane, sub-agent leg: `agents/<id>/agent.md` on disk.
+ * @param {object} o - { agentRoot, at }
+ */
+export function enumerateSubagents(o = {}, deps = {}) {
+  const { agentRoot, at } = o;
+  const ex = deps.existsSync || existsSync;
+  const rdd = deps.readdirSync || readdirSync;
+  const dir = join(agentRoot, "agents");
+  if (!ex(dir)) return { entries: [], degradations: [] };
+  let ids = [];
+  try {
+    ids = rdd(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  } catch (e) {
+    return { entries: [], degradations: [{ plane: "skill", id: "agents/", reason: `unreadable agents dir: ${msg(e)}` }] };
+  }
+  const entries = [];
+  for (const id of ids) {
+    if (!ex(join(dir, id, "agent.md"))) continue;
+    entries.push({
+      id: `subagent:${id}`,
+      plane: "skill",
+      kind: "subagent",
+      invocation: `Task(subagent_type: ${id})`,
+      reachable: true,
+      probedAt: at,
+      probe: { name: "agent.md-on-disk", ok: true, detail: `agents/${id}/agent.md` },
+      costHint: "session",
+      blastRadius: "internal",
+      source: "agent-repo",
+    });
+  }
+  return { entries, degradations: [] };
+}
+
+/**
+ * MCP plane: `.mcp.json` is the truth of what Claude Code will connect to;
+ * `config/mcp-servers.yaml` is the role's declared wish-list. A wished-for
+ * server that is NOT in `.mcp.json` is inventoried as unreachable with the
+ * reason spelled out, which is precisely the gap the old setup swallowed.
+ *
+ * @param {object} o - { agentRoot, at, env?, mcpJson?, wishlist? }
+ * @param {object} [deps] - fs + { handshake }
+ */
+export function enumerateMcp(o = {}, deps = {}) {
+  const { agentRoot, at, env = process.env } = o;
+  const declaredDoc = o.mcpJson !== undefined ? o.mcpJson : readJsonSafe(join(agentRoot, ".mcp.json"), null, deps);
+  const declared = declaredDoc && declaredDoc.mcpServers && typeof declaredDoc.mcpServers === "object" ? declaredDoc.mcpServers : {};
+  const wishlist = Array.isArray(o.wishlist) ? o.wishlist : [];
+  const degradations = [];
+  if (!declaredDoc) degradations.push({ plane: "mcp", id: ".mcp.json", reason: "absent or unparseable — no MCP servers will be reachable" });
+
+  const names = new Set([...Object.keys(declared), ...wishlist.map((w) => w && w.id).filter(Boolean)]);
+  const entries = [];
+  for (const name of [...names].sort()) {
+    const wish = wishlist.find((w) => w && w.id === name) || null;
+    const probe = probeMcpServer(
+      {
+        name,
+        entry: declared[name] || null,
+        declared: Object.prototype.hasOwnProperty.call(declared, name),
+        requiredEnv: (wish && Array.isArray(wish.env) ? wish.env : []),
+        env,
+      },
+      deps,
+    );
+    if (!probe.ok) degradations.push({ plane: "mcp", id: `mcp:${name}`, reason: `${probe.degraded}: ${probe.detail}` });
+    entries.push({
+      id: `mcp:${name}`,
+      plane: "mcp",
+      kind: "mcp_server",
+      invocation: `mcp__${name}__*`,
+      reachable: probe.ok,
+      probedAt: at,
+      probe: { name: "declaration+credentials", ok: probe.ok, detail: probe.detail },
+      costHint: "cheap",
+      blastRadius: "external",
+      source: Object.prototype.hasOwnProperty.call(declared, name) ? ".mcp.json" : "config/mcp-servers.yaml",
+      optional: wish ? wish.optional !== false : false,
+      purpose: (wish && wish.purpose) || "",
+    });
+  }
+  return { entries, degradations };
+}
+
+/**
+ * Org plane: the curated protocol tools + the granted integration tools.
+ * Reachability of the curated set is one round-trip for the whole plane (they
+ * all ride the same transport + credential); granted plugin tools are reachable
+ * iff cached on disk.
+ *
+ * @param {object} o - { agentRoot, at, orgTools, orgProbe }
+ *        orgTools — array from lib/org/tool-surface.getOrgTools()
+ *        orgProbe — the resolved probeOrgPlane() verdict
+ */
+export function enumerateOrgTools(o = {}, deps = {}) {
+  const { agentRoot, at, orgTools = [], orgProbe = { ok: false, detail: "not probed", degraded: "org-unprobed" } } = o;
+  const degradations = [];
+  if (!orgProbe.ok) degradations.push({ plane: "org", id: "org:*", reason: `${orgProbe.degraded || "unreachable"}: ${orgProbe.detail}` });
+  else if (orgProbe.degraded) degradations.push({ plane: "org", id: "org:mandate", reason: `${orgProbe.degraded}: ${orgProbe.detail}` });
+
+  const entries = [];
+  const seen = new Set();
+  for (const t of orgTools) {
+    if (!t || typeof t.name !== "string" || seen.has(t.name)) continue;
+    seen.add(t.name);
+    const granted = !!t.integration;
+    entries.push({
+      id: t.name,
+      plane: "org",
+      kind: granted ? "integration_tool" : "method_tool",
+      invocation: t.name,
+      reachable: orgProbe.ok,
+      probedAt: at,
+      probe: { name: granted ? "toolset-cache" : "protocol-round-trip", ok: orgProbe.ok, detail: orgProbe.detail },
+      costHint: costHintOfOrgTool(t),
+      blastRadius: blastRadiusOfOrgTool(t),
+      source: granted ? `integration:${t.integration}` : "protocol",
+      method: (t.binding && t.binding.method) || null,
+      access: t.access || "read",
+    });
+  }
+  // Surface the granted-plugin-tool cache state explicitly, even when getOrgTools
+  // already merged them: an empty cache is a real (loggable) degradation.
+  const grant = probeGrantedPluginTools(agentRoot, deps);
+  if (!grant.ok) degradations.push({ plane: "org", id: "org:granted-plugin-tools", reason: `${grant.degraded}: ${grant.detail}` });
+
+  return { entries, degradations, toolsetVersion: grant.toolsetVersion };
+}
+
+// ---------------------------------------------------------------------------
+// The build
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the full capability manifest.
+ *
+ * Everything is injectable so this runs hermetically in tests:
+ *   deps.orgToolsImpl()      → array of org tool descriptors  (default: getOrgTools)
+ *   deps.orgProbeImpl()      → Promise<probe verdict>         (default: probeOrgPlane)
+ *   deps.capabilitySurface() → Promise<surface>               (default: lib/capability)
+ *   deps.wishlistImpl()      → array of {id, env[], optional}  (default: config/mcp-servers.yaml)
+ *   deps.now()               → ISO string                     (default: new Date())
+ *   deps.logImpl(msg)        → degradation logger              (default: console.warn)
+ *
+ * @param {object} o - { agentRoot, maestroRoot, archetype?:{function,altitude}, repair?, env? }
+ * @param {object} [deps]
+ * @returns {Promise<object>} the manifest
+ */
+export async function buildInventory(o = {}, deps = {}) {
+  const agentRoot = o.agentRoot || process.cwd();
+  const maestroRoot = o.maestroRoot || null;
+  const at = typeof deps.now === "function" ? deps.now() : new Date().toISOString();
+  const log = typeof deps.logImpl === "function" ? deps.logImpl : (m) => { try { console.warn(m); } catch { /* never throw from logging */ } };
+
+  const degradations = [];
+  const collect = (r) => {
+    if (!r) return [];
+    if (Array.isArray(r.degradations)) degradations.push(...r.degradations);
+    return Array.isArray(r.entries) ? r.entries : [];
+  };
+
+  const entries = [];
+  const repairs = [];
+
+  // ── builtin ──────────────────────────────────────────────────────────────
+  entries.push(...collect(enumerateBuiltins(at)));
+
+  // ── skill: plugin skills + archetype workflows + sub-agents ──────────────
+  const skillRes = enumerateSkills({ agentRoot, maestroRoot, at, repair: !!o.repair }, deps);
+  if (Array.isArray(skillRes.repairs)) repairs.push(...skillRes.repairs);
+  entries.push(...collect(skillRes));
+
+  let surface = null;
+  if (o.archetype && o.archetype.function && o.archetype.altitude) {
+    try {
+      surface = typeof deps.capabilitySurface === "function"
+        ? await deps.capabilitySurface(o.archetype)
+        : await (await import("../capability.mjs")).resolveCapabilitySurface(o.archetype);
+    } catch (e) {
+      degradations.push({ plane: "skill", id: "archetype:workflows", reason: `capability pack unresolved: ${msg(e)}` });
+    }
+  } else {
+    degradations.push({ plane: "skill", id: "archetype:workflows", reason: "no { function, altitude } supplied — archetype workflows not inventoried" });
+  }
+  entries.push(...collect(enumerateWorkflows({ surface, at })));
+  entries.push(...collect(enumerateSubagents({ agentRoot, at }, deps)));
+
+  // ── mcp ──────────────────────────────────────────────────────────────────
+  let wishlist = [];
+  try {
+    wishlist = typeof deps.wishlistImpl === "function" ? await deps.wishlistImpl(agentRoot) : await readMcpWishlist(agentRoot, deps);
+  } catch (e) {
+    degradations.push({ plane: "mcp", id: "config/mcp-servers.yaml", reason: `unreadable wish-list: ${msg(e)}` });
+  }
+  entries.push(...collect(enumerateMcp({ agentRoot, at, env: o.env || process.env, wishlist }, deps)));
+
+  // ── org ──────────────────────────────────────────────────────────────────
+  let orgTools = [];
+  try {
+    orgTools = typeof deps.orgToolsImpl === "function"
+      ? await deps.orgToolsImpl({ agentRoot })
+      : (await import("../org/tool-surface.mjs")).getOrgTools({ agentRoot });
+  } catch (e) {
+    degradations.push({ plane: "org", id: "org:tool-surface", reason: `tool surface unresolved: ${msg(e)}` });
+  }
+  let orgProbe;
+  try {
+    orgProbe = typeof deps.orgProbeImpl === "function" ? await deps.orgProbeImpl({ agentRoot }) : await defaultOrgProbe(agentRoot);
+  } catch (e) {
+    orgProbe = { ok: false, detail: `org probe threw: ${msg(e)}`, degraded: "org-probe-threw", mandateFamily: false };
+  }
+  const orgRes = enumerateOrgTools({ agentRoot, at, orgTools, orgProbe }, deps);
+  entries.push(...collect(orgRes));
+
+  // Stable order: plane (declaration order), then id.
+  const planeRank = new Map(PLANES.map((p, i) => [p, i]));
+  entries.sort((a, b) => (planeRank.get(a.plane) - planeRank.get(b.plane)) || a.id.localeCompare(b.id));
+
+  const counts = {};
+  for (const p of PLANES) counts[p] = entries.filter((e) => e.plane === p).length;
+  counts.reachable = entries.filter((e) => e.reachable).length;
+  counts.unreachable = entries.length - counts.reachable;
+
+  const manifest = {
+    schemaVersion: MANIFEST_VERSION,
+    generatedAt: at,
+    agentRoot,
+    archetype: o.archetype || null,
+    mandateFamily: !!(orgProbe && orgProbe.mandateFamily),
+    toolsetVersion: orgRes.toolsetVersion ?? null,
+    counts,
+    checksum: checksumEntries(entries),
+    entries,
+    degradations,
+    repairs,
+  };
+
+  // NEVER SILENT: every degradation is logged, once, with its plane + reason.
+  for (const d of degradations) log(`[capability-inventory] DEGRADED ${d.plane} ${d.id}: ${d.reason}`);
+  for (const r of repairs) log(`[capability-inventory] repaired: ${r}`);
+
+  return manifest;
+}
+
+/** sha256 over the identity-bearing fields only (id|plane|kind|reachable). */
+export function checksumEntries(entries) {
+  const canon = (entries || [])
+    .map((e) => `${e.id}|${e.plane}|${e.kind}|${e.reachable ? 1 : 0}`)
+    .sort()
+    .join("\n");
+  return createHash("sha256").update(canon).digest("hex");
+}
+
+/** Default org probe: read config/org.yaml, then round-trip via lib/org/client. */
+async function defaultOrgProbe(agentRoot) {
+  const client = await import("../org/client.mjs");
+  const cfg = client.loadOrgConfig(agentRoot);
+  const enabled = client.isEnabled(cfg);
+  const o = client.configFromAgent(cfg);
+  return probeOrgPlane({
+    enabled,
+    call: (m, p) => client.call(m, p, o),
+    read: (path) => client.read(path, o),
+  });
+}
+
+/** Parse `config/mcp-servers.yaml` into [{id, env[], optional, purpose}]. */
+export async function readMcpWishlist(agentRoot, deps = {}) {
+  const ex = deps.existsSync || existsSync;
+  const rd = deps.readFileSync || readFileSync;
+  const p = join(agentRoot, "config", "mcp-servers.yaml");
+  if (!ex(p)) return [];
+  const mod = await import("js-yaml");
+  const yaml = mod && mod.default ? mod.default : mod;
+  const doc = yaml.load(rd(p, "utf-8"));
+  const list = doc && Array.isArray(doc.mcpServers) ? doc.mcpServers : [];
+  return list
+    .filter((s) => s && s.id)
+    .map((s) => ({ id: String(s.id), env: Array.isArray(s.env) ? s.env : [], optional: s.optional !== false, purpose: s.purpose || "" }));
+}
+
+// ---------------------------------------------------------------------------
+// Persistence + query
+// ---------------------------------------------------------------------------
+
+/** Absolute path of the manifest for an agent root. */
+export function manifestPath(agentRoot) {
+  return join(agentRoot, MANIFEST_REL);
+}
+
+/** Atomically write the manifest. @returns {string} the path written */
+export function writeManifest(agentRoot, manifest, deps = {}) {
+  const wr = deps.writeFileSync || writeFileSync;
+  const mk = deps.mkdirSync || mkdirSync;
+  const mv = deps.renameSync || renameSync;
+  const p = manifestPath(agentRoot);
+  mk(join(agentRoot, "config"), { recursive: true });
+  const tmp = `${p}.${process.pid}.tmp`;
+  wr(tmp, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  mv(tmp, p);
+  return p;
+}
+
+/** Read the manifest (null when absent/unparseable). */
+export function readManifest(agentRoot, deps = {}) {
+  return readJsonSafe(manifestPath(agentRoot), null, deps);
+}
+
+/** Set of ids that are reachable — the gate `lib/plan/compile.mjs` enforces. */
+export function reachableIds(manifest) {
+  const out = new Set();
+  for (const e of (manifest && manifest.entries) || []) if (e && e.reachable) out.add(e.id);
+  return out;
+}
+
+/** Look up one capability entry by id (undefined when unknown). */
+export function findCapability(manifest, id) {
+  return ((manifest && manifest.entries) || []).find((e) => e && e.id === id);
+}
+
+/** All entries on a plane (optionally reachable-only). */
+export function byPlane(manifest, plane, { reachableOnly = false } = {}) {
+  return ((manifest && manifest.entries) || []).filter((e) => e && e.plane === plane && (!reachableOnly || e.reachable));
+}
+
+/** @param {*} e @returns {string} */
+function msg(e) {
+  return e && e.message ? String(e.message) : String(e);
+}
+
+export default {
+  MANIFEST_REL, MANIFEST_VERSION, BUILTIN_TOOLS, buildInventory, writeManifest, readManifest,
+  manifestPath, reachableIds, findCapability, byPlane, checksumEntries, readMcpWishlist,
+};