agent-relay-server 0.120.4 → 0.120.6

package/src/db/provisioning-registry.ts

@@ -1,15 +1,13 @@
 import { randomUUID } from "node:crypto";
 import { Buffer } from "node:buffer";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { basename, join, posix, resolve } from "node:path";
-import { getManifest, type ProviderManifest } from "agent-relay-providers";
+import { getManifest } from "agent-relay-providers";
 import { getDb, ValidationError } from "./connection.ts";
+import { bundledSkillRefs, stringRecord } from "./provisioning-resolve.ts";
 import { parseJson } from "../utils";
 import { errMessage, isRecord, SPAWN_PROVIDERS } from "agent-relay-sdk";
 import type {
-  AgentProfile,
-  AgentProfileAssetRef,
   AgentProfileProvider,
   McpAssetDefinition,
   PluginAssetDefinition,
@@ -17,11 +15,8 @@ import type {
   ProvisioningAsset,
   ProvisioningAssetKind,
   ProvisioningMcpServer,
-  ProvisioningSkip,
   ResolvedAssetDefinition,
-  ResolvedProvisioning,
   SkillAssetDefinition,
-  SpawnProvider,
 } from "agent-relay-sdk";
 
 // Relay-owned provisioning registry (#554/#555/#556). One table, one shape across
@@ -37,15 +32,13 @@ const GITHUB_API = "https://api.github.com";
 const DEFAULT_MAX_FILE_BYTES = 256 * 1024;
 const DEFAULT_MAX_TOTAL_BYTES = 2 * 1024 * 1024;
 const ENV_PLACEHOLDER = /^\$?\{?[A-Z_][A-Z0-9_]*\}?$/;
+const ENV_NAME = /^[A-Z_][A-Z0-9_]*$/;
+const SECRETISH_ENV_NAME = /(^|_)(TOKEN|SECRET|PASSWORD|PASSWD|KEY|COOKIE|DSN|PRIVATE|AUTH|SESSION|CREDENTIALS?)(_|$)/i;
 const BUNDLED_SOURCE_TYPE = "bundled";
-const HOST_CALLMUX_SOURCE_TYPE = "host-callmux";
-export const SHARED_CALLMUX_SEED_SERVER_NAMES = ["tokenlean", "github", "vent", "reasoning", "scribe", "searxng", "qmd"] as const;
-export const SHARED_CALLMUX_SOURCE_CONFIG_ENV = "AGENT_RELAY_SHARED_CALLMUX_SOURCE_CONFIG";
-// Servers seeded from the host callmux config but NOT eligible for the shared listener (deno not provisioned, etc.).
-const SHARED_CALLMUX_SEED_NON_LISTENER_NAMES: ReadonlySet<string> = new Set(["scribe"]);
-const SHARED_CALLMUX_CONFIG_ENV_ALLOWLIST: Readonly<Record<string, readonly string[]>> = { vent: ["VENT_REPO"] };
-
-type ProviderBundledSkillSetDescriptor = NonNullable<NonNullable<ProviderManifest["provisioning"]>["bundledSkills"]>;
+// Per-server allowlist of non-secret literal configEnv keys. Enforced by
+// assertConfigEnv below and consumed by the shared-callmux seed scrub
+// (src/db/provisioning-callmux.ts) when splitting literals from placeholders.
+export const SHARED_CALLMUX_CONFIG_ENV_ALLOWLIST: Readonly<Record<string, readonly string[]>> = { vent: ["VENT_REPO"] };
 
 interface ProvisioningAssetRow {
   id: string;
@@ -145,23 +138,12 @@ interface ProvisioningCapabilityRow {
   updated_at?: number;
 }
 
-interface RegistryResolution {
-  definition: ResolvedAssetDefinition | null;
-  skip?: ProvisioningSkip;
-}
-
 interface BundledFile {
   path: string;
   content: string;
   size: number;
 }
 
-export interface SharedCallmuxSeedResult {
-  sourceConfigPath: string;
-  seeded: string[];
-  skipped: Array<{ name: string; reason: string }>;
-}
-
 type BundledFileReadOptions = { omitFiles?: string[]; fileOverrides?: Array<{ path: string; sourcePath: string }> };
 
 export interface ProvisioningCapabilityWithVariants {
@@ -229,7 +211,7 @@ function assertDefinition(kind: ProvisioningAssetKind, definition: ResolvedAsset
     if (!isRecord(def.server)) throw new ValidationError("mcp definition requires a server object");
     assertMcpSecretPlaceholders(def.server, def.name);
     const metadata = isRecord(def.metadata) ? def.metadata : {};
-    if (isRecord(metadata.callmuxServer)) assertMcpSecretPlaceholders(metadata.callmuxServer as ProvisioningMcpServer, def.name);
+    if (isRecord(metadata.callmuxServer)) assertCallmuxServerPlaceholders(metadata.callmuxServer as ProvisioningMcpServer, def.name);
   }
   if ((kind === "skill" || kind === "plugin")) {
     const def = definition as SkillAssetDefinition | PluginAssetDefinition;
@@ -378,23 +360,39 @@ function assertPlugin(files: VendoredFile[], provider: AgentProfileProvider): vo
   }
 }
 
-function isEnvPlaceholder(value: string): boolean {
+export function isEnvPlaceholder(value: string): boolean {
   return ENV_PLACEHOLDER.test(value);
 }
 
+function isSecretLikeEnvName(key: string): boolean {
+  return SECRETISH_ENV_NAME.test(key);
+}
+
+function assertConfigEnv(
+  value: unknown,
+  opts: { serverName?: string; allowlist?: readonly string[] } = {},
+): void {
+  if (value === undefined) return;
+  if (!isRecord(value)) throw new ValidationError("mcp configEnv must be an object");
+  for (const [key, raw] of Object.entries(value)) {
+    if (!ENV_NAME.test(key)) throw new ValidationError(`mcp configEnv key ${key} is not a valid env name`);
+    if (typeof raw !== "string") throw new ValidationError(`mcp configEnv ${key} must be a string`);
+    if (isEnvPlaceholder(raw)) throw new ValidationError(`mcp configEnv ${key} must be a literal value; use env for placeholders`);
+    if (opts.allowlist && !opts.allowlist.includes(key)) {
+      throw new ValidationError(`mcp configEnv ${key} is not allowlisted for ${opts.serverName ?? "this server"}`);
+    }
+    if (isSecretLikeEnvName(key)) {
+      throw new ValidationError(`mcp configEnv ${key} looks secret; use env placeholders instead`);
+    }
+  }
+}
+
 function assertMcpSecretPlaceholders(server: ProvisioningMcpServer, serverName?: string): void {
   for (const [key, value] of Object.entries(server.env ?? {})) {
-    if (!/^[A-Z_][A-Z0-9_]*$/.test(key)) throw new ValidationError(`mcp env key ${key} is not a valid env name`);
+    if (!ENV_NAME.test(key)) throw new ValidationError(`mcp env key ${key} is not a valid env name`);
     if (!isEnvPlaceholder(value)) throw new ValidationError(`mcp env ${key} must reference an env placeholder name`);
   }
-  const configEnv = (server as ProvisioningMcpServer & { configEnv?: unknown }).configEnv;
-  if (configEnv !== undefined) {
-    if (!isRecord(configEnv)) throw new ValidationError("mcp configEnv must be an object");
-    for (const [key, value] of Object.entries(configEnv)) {
-      if (typeof value !== "string") throw new ValidationError(`mcp configEnv ${key} must be a string`);
-      if (!SHARED_CALLMUX_CONFIG_ENV_ALLOWLIST[serverName ?? ""]?.includes(key)) throw new ValidationError(`mcp configEnv ${key} is not allowlisted for ${serverName ?? "this server"}`);
-    }
-  }
+  assertConfigEnv(server.configEnv);
   for (const [key, value] of Object.entries(server.headers ?? {})) {
     if (/authorization|token|secret|key|api/i.test(key) && !/^Bearer \$\{[A-Z_][A-Z0-9_]*\}$/.test(value) && !isEnvPlaceholder(value)) {
       throw new ValidationError(`mcp header ${key} must reference an env placeholder name`);
@@ -402,6 +400,11 @@ function assertMcpSecretPlaceholders(server: ProvisioningMcpServer, serverName?:
   }
 }
 
+function assertCallmuxServerPlaceholders(server: ProvisioningMcpServer, serverName?: string): void {
+  assertMcpSecretPlaceholders({ ...server, configEnv: undefined }, serverName);
+  assertConfigEnv(server.configEnv, { serverName, allowlist: SHARED_CALLMUX_CONFIG_ENV_ALLOWLIST[serverName ?? ""] });
+}
+
 function cleanStringRecord(value: unknown, label: string): Record<string, string> | undefined {
   if (value === undefined) return undefined;
   if (!isRecord(value)) throw new ValidationError(`${label} must be an object`);
@@ -433,8 +436,10 @@ function coerceMcpServer(raw: unknown): ProvisioningMcpServer {
     server.url = raw.url;
   }
   const env = cleanStringRecord(raw.env, "mcp env");
+  const configEnv = cleanStringRecord(raw.configEnv, "mcp configEnv");
   const headers = cleanStringRecord(raw.headers, "mcp headers");
   if (env) server.env = env;
+  if (configEnv) server.configEnv = configEnv;
   if (headers) server.headers = headers;
   if (!server.command && !server.url) throw new ValidationError("mcp server requires command or url");
   if (server.command && server.url) throw new ValidationError("mcp server cannot set both command and url");
@@ -539,14 +544,6 @@ function upsertBundledProvisioningAsset(input: {
   updateBundledAssetMetadata(asset, input.root, input.files, input.title, input.description);
 }
 
-function bundledSkillRefs(descriptor: ProviderBundledSkillSetDescriptor): string[] {
-  const skillsDir = resolve(import.meta.dir, "../../", descriptor.dir);
-  const entryFile = descriptor.entryFile ?? "SKILL.md";
-  if (!existsSync(skillsDir)) return [];
-  return readdirSync(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync(join(skillsDir, entry.name, entryFile)))
-    .map((entry) => `${descriptor.refPrefix}${entry.name}`).sort();
-}
-
 export function seedBundledProvisioningAssets(): void {
   for (const provider of SPAWN_PROVIDERS) {
     const provisioning = getManifest(provider)?.provisioning;
@@ -565,150 +562,9 @@ export function seedBundledProvisioningAssets(): void {
   }
 }
 
-export function sharedCallmuxSourceConfigPath(env: Record<string, string | undefined> = process.env): string {
-  return env[SHARED_CALLMUX_SOURCE_CONFIG_ENV] || env.CALLMUX_CONFIG || join(homedir(), ".config", "callmux", "config.json");
-}
-
-function cloneJsonRecord(value: Record<string, unknown>): Record<string, unknown> {
-  return JSON.parse(JSON.stringify(value)) as Record<string, unknown>;
-}
-
-function scrubEnvPlaceholders(serverName: string, value: unknown): { env: Record<string, string> | undefined; configEnv: Record<string, string> | undefined } {
-  if (!isRecord(value)) return { env: undefined, configEnv: undefined };
-  const env: Record<string, string> = {};
-  const configEnv: Record<string, string> = {};
-  for (const [key, raw] of Object.entries(value)) {
-    if (typeof raw !== "string") continue;
-    if (isEnvPlaceholder(raw)) {
-      env[key] = raw;
-    } else if (SHARED_CALLMUX_CONFIG_ENV_ALLOWLIST[serverName]?.includes(key)) {
-      configEnv[key] = raw;
-    } else {
-      env[key] = `$${key}`;
-    }
-  }
-  return {
-    env: Object.keys(env).length ? env : undefined,
-    configEnv: Object.keys(configEnv).length ? configEnv : undefined,
-  };
-}
-
-function envPlaceholderForLiteral(value: string, env: Record<string, string | undefined>): string | undefined {
-  for (const [key, candidate] of Object.entries(env)) {
-    if (!candidate || candidate !== value || !/^[A-Z_][A-Z0-9_]*$/.test(key)) continue;
-    return `$${key}`;
-  }
-  return undefined;
-}
-
-function envPlaceholderName(value: string): string | undefined {
-  const match = value.match(/^\$?\{?([A-Z_][A-Z0-9_]*)\}?$/);
-  return match?.[1];
-}
-
-function scrubHeaderPlaceholders(value: unknown, env: Record<string, string | undefined>): Record<string, string> | undefined {
-  if (!isRecord(value)) return undefined;
-  const headers: Record<string, string> = {};
-  for (const [key, raw] of Object.entries(value)) {
-    if (typeof raw !== "string") continue;
-    if (!/authorization|token|secret|key|api/i.test(key) || isEnvPlaceholder(raw) || /^Bearer \$\{[A-Z_][A-Z0-9_]*\}$/.test(raw)) {
-      headers[key] = raw;
-      continue;
-    }
-    const bearer = raw.match(/^Bearer\s+(.+)$/i);
-    const bearerValue = bearer?.[1];
-    const bearerPlaceholderName = bearerValue ? envPlaceholderName(bearerValue) : undefined;
-    if (bearerPlaceholderName) {
-      headers[key] = `Bearer \${${bearerPlaceholderName}}`;
-      continue;
-    }
-    const placeholder = envPlaceholderForLiteral(bearerValue ?? raw, env);
-    if (placeholder) headers[key] = bearer ? `Bearer ${placeholder.startsWith("${") ? placeholder : `\${${placeholder.slice(1)}}`}` : placeholder;
-  }
-  return Object.keys(headers).length ? headers : undefined;
-}
-
-function scrubCallmuxServerSecrets(serverName: string, server: Record<string, unknown>, env: Record<string, string | undefined>): Record<string, unknown> {
-  const scrubbed = cloneJsonRecord(server);
-  const { env: scrubbedEnv, configEnv } = scrubEnvPlaceholders(serverName, scrubbed.env);
-  const scrubbedHeaders = scrubHeaderPlaceholders(scrubbed.headers, env);
-  if (scrubbedEnv !== undefined) scrubbed.env = scrubbedEnv;
-  else delete scrubbed.env;
-  if (configEnv !== undefined) scrubbed.configEnv = configEnv;
-  else delete scrubbed.configEnv;
-  if (scrubbedHeaders) scrubbed.headers = scrubbedHeaders;
-  else delete scrubbed.headers;
-  return scrubbed;
-}
-
-function mcpServerFromCallmuxServer(server: Record<string, unknown>): ProvisioningMcpServer {
-  const projected: ProvisioningMcpServer = {};
-  if (typeof server.command === "string") {
-    projected.type = "stdio";
-    projected.command = server.command;
-    if (Array.isArray(server.args)) projected.args = server.args.filter((arg): arg is string => typeof arg === "string");
-    if (isRecord(server.env)) projected.env = stringRecord(server.env);
-  } else if (typeof server.url === "string") {
-    projected.type = server.transport === "sse" ? "sse" : "http";
-    projected.url = server.url;
-    if (isRecord(server.headers)) projected.headers = stringRecord(server.headers);
-  }
-  return projected;
-}
-
-function updateSharedCallmuxAssetMetadata(asset: ProvisioningAsset, sourceConfigPath: string, callmuxServer: Record<string, unknown>, sharedListenerEligible = true): void {
-  if (!asset.capabilityId) throw new ValidationError("shared callmux seed missing capability id");
-  const now = Date.now();
-  const provenance = {
-    importedBy: "agent-relay-shared-callmux-seed",
-    sharedListenerEligible,
-    callmux: { sourceConfigPath, serverName: asset.name },
-  };
-  getDb().query(`
-    UPDATE provisioning_assets
-    SET source_type = ?, source_ref = ?, provenance = ?, updated_at = ?
-    WHERE id = ?
-  `).run(HOST_CALLMUX_SOURCE_TYPE, sourceConfigPath, JSON.stringify(provenance), now, asset.id);
-  getDb().query("UPDATE provisioning_capabilities SET title = ?, description = ?, updated_at = ? WHERE id = ?")
-    .run(asset.name, `Host callmux MCP server ${asset.name}`, now, asset.capabilityId);
-}
-
-export function seedSharedCallmuxProvisioningAssets(
-  input: { sourceConfigPath?: string; env?: Record<string, string | undefined> } = {},
-): SharedCallmuxSeedResult {
-  const sourceConfigPath = input.sourceConfigPath ?? sharedCallmuxSourceConfigPath(input.env);
-  const result: SharedCallmuxSeedResult = { sourceConfigPath, seeded: [], skipped: [] };
-  if (!existsSync(sourceConfigPath)) return result;
-  const source = parseJson(readFileSync(sourceConfigPath, "utf8"), {}) as unknown;
-  const sourceServers = isRecord(source) && isRecord(source.servers) ? source.servers : {};
-  for (const name of SHARED_CALLMUX_SEED_SERVER_NAMES) {
-    const rawServer = sourceServers[name];
-    if (!isRecord(rawServer)) {
-      result.skipped.push({ name, reason: "missing" });
-      continue;
-    }
-    const callmuxServer = scrubCallmuxServerSecrets(name, rawServer, input.env ?? process.env);
-    const server = mcpServerFromCallmuxServer(callmuxServer);
-    try {
-      const sharedListenerEligible = !SHARED_CALLMUX_SEED_NON_LISTENER_NAMES.has(name);
-      const asset = upsertProvisioningAsset({
-        kind: "mcp",
-        name,
-        definition: {
-          kind: "mcp",
-          name,
-          server,
-          metadata: { sharedListenerEligible, callmuxServer },
-        },
-      });
-      updateSharedCallmuxAssetMetadata(asset, sourceConfigPath, callmuxServer, sharedListenerEligible);
-      result.seeded.push(name);
-    } catch (err) {
-      result.skipped.push({ name, reason: errMessage(err) });
-    }
-  }
-  return result;
-}
+// Shared-callmux seeding (sharedCallmuxSourceConfigPath, the secret scrub, and
+// seedSharedCallmuxProvisioningAssets) lives in src/db/provisioning-callmux.ts —
+// split out of this file under the file-size ratchet (epic #291).
 
 function upsertImportedAsset(
   input: ImportProvisioningAssetFromGitHubInput,
@@ -1157,188 +1013,3 @@ export function deleteProvisioningAsset(
     .run(kind, name, provider);
   return result.changes > 0;
 }
-
-function skip(kind: ProvisioningAssetKind, ref: string, provider: SpawnProvider, reason: ProvisioningSkip["reason"], detail: string): ProvisioningSkip {
-  return { kind, ref, provider, reason, detail };
-}
-
-function variantSkipReason(row: ProvisioningAssetRow): Pick<ProvisioningSkip, "reason" | "detail"> | null {
-  if (row.enabled !== 1) return { reason: "disabled", detail: "Registry variant is disabled." };
-  if (row.approval_status !== "approved") return { reason: "unapproved", detail: `Registry variant approval_status is ${row.approval_status ?? "unset"}.` };
-  if (row.validation_status !== "valid") {
-    const errors = parseJson<unknown[]>(row.validation_errors ?? "[]", []);
-    const detail = errors.length ? `Registry variant validation_status is ${row.validation_status}; ${JSON.stringify(errors)}` : `Registry variant validation_status is ${row.validation_status ?? "unset"}.`;
-    return { reason: "invalid", detail };
-  }
-  return null;
-}
-
-// Resolve a registry ref for a target provider: an approved/valid/enabled exact
-// provider match wins, else provider-neutral "any". MCP is intentionally
-// provider-neutral in v1, so only "any" MCP variants are candidates.
-function resolveRegistryDefinition(kind: ProvisioningAssetKind, ref: string, provider: SpawnProvider): RegistryResolution {
-  const capability = getDb()
-    .query("SELECT id, slug, kind, status FROM provisioning_capabilities WHERE kind = ? AND slug = ?")
-    .get(kind, ref) as ProvisioningCapabilityRow | undefined;
-  if (!capability) {
-    return { definition: null, skip: skip(kind, ref, provider, "missing", "No provisioning capability exists for this ref.") };
-  }
-
-  const rows = getDb()
-    .query("SELECT * FROM provisioning_assets WHERE capability_id = ? ORDER BY CASE provider WHEN ? THEN 0 WHEN 'any' THEN 1 ELSE 2 END, provider")
-    .all(capability.id, provider) as ProvisioningAssetRow[];
-  const providerCandidates = rows.filter((row) => kind === "mcp" ? row.provider === "any" : row.provider === provider || row.provider === "any");
-  if (!providerCandidates.length) {
-    const label = getManifest(provider)?.label ?? provider;
-    return { definition: null, skip: skip(kind, ref, provider, "provider_mismatch", `No ${label} variant exists for capability ${ref}.`) };
-  }
-
-  for (const row of providerCandidates) {
-    if (!variantSkipReason(row)) return { definition: rowToAsset(row).definition };
-  }
-
-  const blocked = variantSkipReason(providerCandidates[0]!);
-  return { definition: null, skip: skip(kind, ref, provider, blocked?.reason ?? "missing", blocked?.detail ?? "No resolvable registry variant exists.") };
-}
-
-// A ref applies to a launch iff it's enabled and its provider scope includes the
-// target ("any"/undefined → all providers).
-function refAppliesToProvider(ref: AgentProfileAssetRef, provider: SpawnProvider): boolean {
-  return ref.enabled && (!ref.provider || ref.provider === "any" || ref.provider === provider);
-}
-
-function hasAssetRef(refs: AgentProfileAssetRef[], source: AgentProfileAssetRef["source"], ref: string): boolean {
-  return refs.some((item) => item.source === source && item.ref === ref);
-}
-
-function relayBundledProvisioningRefs(profile: AgentProfile, provider: SpawnProvider): Pick<AgentProfile, "skills" | "plugins"> {
-  const skills = [...(profile.skills ?? [])];
-  const plugins = [...(profile.plugins ?? [])];
-  const provisioning = getManifest(provider)?.provisioning;
-  if (profile.relay.skills !== false && provisioning?.bundledSkills) {
-    for (const ref of bundledSkillRefs(provisioning.bundledSkills)) {
-      if (!hasAssetRef(skills, "relay", ref)) skills.push({ source: "relay", ref, enabled: true, provider });
-    }
-  }
-  if (profile.relay.plugins !== false && provisioning?.bundledPlugin && !hasAssetRef(plugins, "relay", provisioning.bundledPlugin.ref)) {
-    plugins.push({ source: "relay", ref: provisioning.bundledPlugin.ref, enabled: true, provider });
-  }
-  return { skills, plugins };
-}
-
-function withRelayBundledProvisioningRefs(profile: AgentProfile, provider: SpawnProvider): AgentProfile {
-  const { skills, plugins } = relayBundledProvisioningRefs(profile, provider);
-  return { ...profile, skills, plugins };
-}
-
-function inlineFilesFromMeta(meta: Record<string, unknown> | undefined): { path: string; content: string }[] | undefined {
-  const raw = meta?.files;
-  if (!Array.isArray(raw)) return undefined;
-  const files = raw
-    .filter(isRecord)
-    .filter((f) => typeof f.path === "string" && typeof f.content === "string")
-    .map((f) => ({ path: f.path as string, content: f.content as string }));
-  return files.length ? files : undefined;
-}
-
-// Resolve a skill/plugin asset ref into a concrete definition. relay → registry;
-// inline → built from ref.meta (files or dir); repo → a cwd-relative dir token the
-// runner resolves against the launch cwd; provider → skipped (provider built-in).
-function resolveDirAssetRef(
-  kind: "skill" | "plugin",
-  ref: AgentProfileAssetRef,
-  provider: SpawnProvider,
-): { definition: SkillAssetDefinition | PluginAssetDefinition | null; skip?: ProvisioningSkip } {
-  if (ref.source === "relay") {
-    const resolved = resolveRegistryDefinition(kind, ref.ref, provider);
-    const def = resolved.definition;
-    return { definition: def && def.kind === kind ? def : null, skip: resolved.skip };
-  }
-  if (ref.source === "inline") {
-    const files = inlineFilesFromMeta(ref.meta);
-    const dir = typeof ref.meta?.dir === "string" ? ref.meta.dir : undefined;
-    if (!files && !dir) return { definition: null, skip: skip(kind, ref.ref, provider, "invalid_inline", `Inline ${kind} ref requires files or dir metadata.`) };
-    return { definition: { kind, name: ref.ref, ...(files ? { files } : {}), ...(dir ? { dir } : {}) } };
-  }
-  if (ref.source === "repo") {
-    return { definition: { kind, name: ref.ref, dir: ref.ref } };
-  }
-  return { definition: null };
-}
-
-// A profile.mcp.servers entry is either an inline server spec or a registry
-// reference (`{ source: "relay", ref }`). Returns the concrete server spec.
-function resolveMcpEntry(name: string, value: unknown, provider: SpawnProvider): { server: ProvisioningMcpServer | null; skip?: ProvisioningSkip } {
-  if (!isRecord(value)) return { server: null };
-  if (value.source === "relay" && typeof value.ref === "string") {
-    const resolved = resolveRegistryDefinition("mcp", value.ref, provider);
-    const def = resolved.definition;
-    return { server: def && def.kind === "mcp" ? def.server : null, skip: resolved.skip };
-  }
-  if (value.enabled === false) return { server: null };
-  // Inline spec: keep the recognized server fields only.
-  const server: ProvisioningMcpServer = {};
-  if (typeof value.type === "string") server.type = value.type as ProvisioningMcpServer["type"];
-  if (typeof value.command === "string") server.command = value.command;
-  if (Array.isArray(value.args)) server.args = value.args.filter((a): a is string => typeof a === "string");
-  if (isRecord(value.env)) server.env = stringRecord(value.env);
-  if (typeof value.url === "string") server.url = value.url;
-  if (isRecord(value.headers)) server.headers = stringRecord(value.headers);
-  return { server: server.command || server.url ? server : null, skip: server.command || server.url ? undefined : skip("mcp", name, provider, "invalid_inline", "Inline MCP server requires command or url.") };
-}
-
-function stringRecord(value: Record<string, unknown>): Record<string, string> {
-  const out: Record<string, string> = {};
-  for (const [k, v] of Object.entries(value)) {
-    if (typeof v === "string") out[k] = v;
-  }
-  return out;
-}
-
-// Resolve a profile's declared skill/plugin/MCP refs against the registry into the
-// concrete bundle the runner materializes. Relay-side (needs the DB); the result is
-// attached to the in-flight profile (profile.provisioning) before it's serialized
-// into the spawn env. Pure read — never mutates the registry.
-export function resolveProfileProvisioning(profile: AgentProfile, provider: SpawnProvider): ResolvedProvisioning {
-  const skills: SkillAssetDefinition[] = [];
-  const skipped: ProvisioningSkip[] = [];
-  for (const ref of profile.skills ?? []) {
-    if (!refAppliesToProvider(ref, provider)) {
-      if (ref.enabled && ref.source === "relay") skipped.push(skip("skill", ref.ref, provider, "provider_mismatch", `Profile ref is scoped to provider ${ref.provider}.`));
-      continue;
-    }
-    const resolved = resolveDirAssetRef("skill", ref, provider);
-    if (resolved.definition) skills.push(resolved.definition as SkillAssetDefinition);
-    else if (resolved.skip) skipped.push(resolved.skip);
-  }
-
-  const plugins: PluginAssetDefinition[] = [];
-  for (const ref of profile.plugins ?? []) {
-    if (!refAppliesToProvider(ref, provider)) {
-      if (ref.enabled && ref.source === "relay") skipped.push(skip("plugin", ref.ref, provider, "provider_mismatch", `Profile ref is scoped to provider ${ref.provider}.`));
-      continue;
-    }
-    const resolved = resolveDirAssetRef("plugin", ref, provider);
-    if (resolved.definition) plugins.push(resolved.definition as PluginAssetDefinition);
-    else if (resolved.skip) skipped.push(resolved.skip);
-  }
-
-  const mcpServers: Record<string, ProvisioningMcpServer> = {};
-  for (const [name, value] of Object.entries(profile.mcp?.servers ?? {})) {
-    const resolved = resolveMcpEntry(name, value, provider);
-    if (resolved.server) mcpServers[name] = resolved.server;
-    else if (resolved.skip) skipped.push(resolved.skip);
-  }
-
-  return { skills, plugins, mcpServers, ...(skipped.length ? { skipped } : {}) };
-}
-
-// Attach the resolved bundle to a spawn-bound profile. Returns a shallow copy so the
-// cached config-store value is never mutated. undefined passes through (an unresolved
-// profile name stays undefined so callers' not-found guards still fire); the runner
-// treats an absent and an empty bundle identically.
-export function withResolvedProvisioning(profile: AgentProfile | undefined, provider: SpawnProvider): AgentProfile | undefined {
-  if (!profile) return undefined;
-  const composed = withRelayBundledProvisioningRefs(profile, provider);
-  return { ...composed, provisioning: resolveProfileProvisioning(composed, provider) };
-}