agent-relay-server 0.102.2 → 0.103.4

package/src/automations/validation.ts

@@ -1,4 +1,4 @@
-import { errMessage, VALID_WORKSPACE_MODES } from "agent-relay-sdk";
+import { errMessage, SPAWN_PROVIDERS, VALID_WORKSPACE_MODES, type SpawnProvider } from "agent-relay-sdk";
 import { resolveProviderSelection, type ProviderEffort } from "agent-relay-sdk/provider-catalog";
 import { getAgentProfile } from "../config-store";
 import { ValidationError } from "../db";
@@ -85,7 +85,7 @@ function normalizeTargetPolicy(value: unknown): AutomationTargetPolicy {
     return {
       mode,
       selector: {
-        provider: cleanString(selectorInput.provider, "targetPolicy.selector.provider", { max: 40 }) as "claude" | "codex" | undefined,
+        provider: cleanString(selectorInput.provider, "targetPolicy.selector.provider", { max: 40 }) as SpawnProvider | undefined,
         label: cleanString(selectorInput.label, "targetPolicy.selector.label", { max: 120 }),
         tags: cleanStringArray(selectorInput.tags, "targetPolicy.selector.tags", { itemMax: 100 }),
         capabilities: cleanStringArray(selectorInput.capabilities, "targetPolicy.selector.capabilities", { itemMax: 100 }),
@@ -93,7 +93,7 @@ function normalizeTargetPolicy(value: unknown): AutomationTargetPolicy {
       ifNoMatch: optionalEnum(input.ifNoMatch, "targetPolicy.ifNoMatch", ["fail", "spawn"] as const, "fail"),
     };
   }
-  const provider = optionalEnum(input.provider, "targetPolicy.provider", ["claude", "codex"] as const, "codex");
+  const provider = optionalEnum(input.provider, "targetPolicy.provider", SPAWN_PROVIDERS, "codex");
   const model = cleanString(input.model, "targetPolicy.model", { max: 120 });
   const effort = cleanString(input.effort, "targetPolicy.effort", { max: 120 }) as ProviderEffort | undefined;
   const profile = cleanString(input.profile, "targetPolicy.profile", { max: 120 });

package/src/cli/orchestrator.ts

@@ -3,6 +3,7 @@
 import { chmodSync, existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
 import { hostname as osHostname, homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { getAllManifests, getManifest } from "agent-relay-providers";
 import {
   createDaemonPlan,
   detectDaemonEnvironment,
@@ -28,7 +29,7 @@ export async function handleOrchestratorCommand(args: string[]): Promise<void> {
   let bootstrapToken = "";
   let id = sanitizeOrchestratorId(osHostname());
   let baseDir = join(homedir(), "projects");
-  let providers = "claude,codex";
+  let providers = getAllManifests().map((manifest) => manifest.id).join(",");
   let apiPort = 4860;
   let runtimePrefix = defaultRuntimePrefix();
   let serviceName = "agent-relay-orchestrator";
@@ -65,9 +66,9 @@ export async function handleOrchestratorCommand(args: string[]): Promise<void> {
 
   const providerList = providers.split(",").map((p) => p.trim()).filter(Boolean);
   for (const provider of providerList) {
-    if (provider !== "claude" && provider !== "codex") throw new Error(`Unknown provider "${provider}". Expected claude or codex.`);
+    if (!getManifest(provider)) throw new Error(`Unknown provider "${provider}". Expected one of ${getAllManifests().map((manifest) => manifest.id).join(", ")}.`);
   }
-  const detectedPathPrefix = [...pathPrefix, ...detectProviderPathPrefixes(providerList as Array<"claude" | "codex">)];
+  const detectedPathPrefix = [...pathPrefix, ...detectProviderPathPrefixes(providerList)];
   const uniquePathPrefix = [...new Set(detectedPathPrefix)];
   const envToken = token || (dryRun || json ? "<runtime-token-from-bootstrap>" : await exchangeOrchestratorBootstrapToken(relayUrl, bootstrapToken, id, baseDir));
   const envFile = defaultOrchestratorEnvFile();
@@ -165,10 +166,11 @@ function sanitizeOrchestratorId(value: string): string {
   return clean.slice(0, 120);
 }
 
-function detectProviderPathPrefixes(providers: Array<"claude" | "codex">): string[] {
+function detectProviderPathPrefixes(providers: string[]): string[] {
   const prefixes: string[] = [];
   for (const provider of providers) {
-    const path = resolveExecutableOnPath(provider);
+    const command = getManifest(provider)?.probe?.command ?? provider;
+    const path = resolveExecutableOnPath(command);
     if (path) prefixes.push(dirname(path));
   }
   return prefixes;

package/src/cli/provider.ts

@@ -5,16 +5,19 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { getAllManifests, getManifest } from "agent-relay-providers";
 
 export async function handleProviderCommand(args: string[]): Promise<void> {
   const action = args[0];
   const provider = args[1];
-  if ((action !== "wrap" && action !== "unwrap") || (provider !== "claude" && provider !== "codex")) {
-    throw new Error("Usage: agent-relay provider <wrap|unwrap> <claude|codex>");
+  const providerList = shimmableProviderIds();
+  const manifest = typeof provider === "string" ? getManifest(provider) : undefined;
+  if ((action !== "wrap" && action !== "unwrap") || !provider || !manifest?.shim) {
+    throw new Error(`Usage: agent-relay provider <wrap|unwrap> <${providerList.join("|")}>`);
   }
   const dir = join(process.env.HOME || homedir(), ".agent-relay", "bin");
   const shims = providerShimPaths(provider);
-  if (provider === "codex") cleanLegacyCodexSessionStartHook();
+  if (manifest.shim.cleanLegacyHooks) cleanLegacyCodexSessionStartHook();
   if (action === "wrap") {
     for (const shim of shims) {
       mkdirSync(dirname(shim), { recursive: true });
@@ -31,6 +34,12 @@ export async function handleProviderCommand(args: string[]): Promise<void> {
   }
 }
 
+function shimmableProviderIds(): string[] {
+  return getAllManifests()
+    .filter((manifest) => manifest.shim)
+    .map((manifest) => manifest.id);
+}
+
 function cleanLegacyCodexSessionStartHook(): void {
   const configPath = join(process.env.HOME || homedir(), ".codex", "config.toml");
   if (!existsSync(configPath)) return;
@@ -111,16 +120,23 @@ function isLegacyCodexSessionStartHook(text: string): boolean {
     /agent-relay.*(SessionStart|UserPromptSubmit|Stop).*hook/i.test(text);
 }
 
-function providerShimPaths(provider: "claude" | "codex"): string[] {
+function providerShimPaths(provider: string): string[] {
+  const manifest = getManifest(provider);
+  if (!manifest?.shim) throw new Error(`Provider "${provider}" does not support PATH shims.`);
   const root = join(process.env.HOME || homedir(), ".agent-relay");
-  const paths = [join(root, "bin", provider)];
-  if (provider === "codex") paths.push(join(root, "codex", "bin", "codex"));
-  return paths;
+  return [
+    join(root, "bin", provider),
+    ...(manifest.shim.extraBinPaths ?? []).map((path: string) => join(root, path)),
+  ];
 }
 
-function providerShimContent(provider: "claude" | "codex"): string {
-  if (provider === "claude") {
-    return `#!/usr/bin/env bash\nexec claude-relay claude -- "$@"\n`;
+function providerShimContent(provider: string): string {
+  const shimKind = getManifest(provider)?.shim?.kind;
+  if (shimKind === "claude-relay") {
+    return `#!/usr/bin/env bash\nexec claude-relay ${provider} -- "$@"\n`;
+  }
+  if (shimKind !== "codex-relay") {
+    throw new Error(`Provider "${provider}" does not define a shim template.`);
   }
   return `#!/usr/bin/env bash
 set -e

package/src/cli/upgrade.ts

@@ -1,5 +1,6 @@
 // Upgrade commands — auto-split from cli.ts (#294). Local runtime upgrade plus
 // remote-host fan-out over the relay command bus (#210).
+import { getAllManifests, getManifest } from "agent-relay-providers";
 import {
   createUpgradePlan,
   detectUpgradeSnapshot,
@@ -27,6 +28,7 @@ export async function handleUpgradeCommand(args: string[]): Promise<void> {
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
+    const providerFlag = arg?.startsWith("--") ? arg.slice(2) : undefined;
     if (arg === "--version" && i + 1 < args.length) targetVersion = args[++i];
     else if (arg === "--runtime-prefix" && i + 1 < args.length) runtimePrefix = args[++i];
     else if (arg === "--providers" && i + 1 < args.length) {
@@ -34,8 +36,7 @@ export async function handleUpgradeCommand(args: string[]): Promise<void> {
     } else if (arg === "--provider" && i + 1 < args.length) providers.push(parseUpgradeProvider(args[++i]!));
     else if (arg === "--host" && i + 1 < args.length) hosts.push(args[++i]!);
     else if (arg === "--all-hosts") allHosts = true;
-    else if (arg === "--codex") providers.push("codex");
-    else if (arg === "--claude") providers.push("claude");
+    else if (providerFlag && getManifest(providerFlag)) providers.push(parseUpgradeProvider(providerFlag));
     else if (arg === "--orchestrator") providers.push("orchestrator");
     else if (arg === "--all") providers.push("all");
     else if (arg === "--dry-run") dryRun = true;
@@ -188,6 +189,6 @@ async function runRemoteOrchestratorUpgrades(opts: {
 }
 
 function parseUpgradeProvider(value: string): UpgradeProvider {
-  if (value === "auto" || value === "all" || value === "codex" || value === "claude" || value === "orchestrator") return value;
-  throw new Error(`Unknown upgrade provider "${value}". Expected auto, all, codex, claude, or orchestrator.`);
+  if (value === "auto" || value === "all" || value === "orchestrator" || getManifest(value)) return value;
+  throw new Error(`Unknown upgrade provider "${value}". Expected auto, all, orchestrator, or one of ${getAllManifests().map((manifest) => manifest.id).join(", ")}.`);
 }

package/src/commands-db.ts

@@ -131,7 +131,7 @@ export function expireCommands(now: number = Date.now()): Command[] {
 }
 
 function defaultExpiresAt(type: string, now: number): number | undefined {
-  if (type === "agent.spawn") return now + 60_000;
+  if (type === "agent.spawn") return now + 180_000;
   if (type === "agent.shutdown" || type === "agent.restart" || type === "agent.reconnect" || type === "agent.kill" || type === "agent.compact" || type === "agent.clearContext" || type === "agent.injectContext") return now + 30_000;
   return undefined;
 }

package/src/config-store.ts

@@ -16,7 +16,7 @@ import { PROJECT_SETTINGS_POLICY_NAMES } from "./project-settings";
 import { PROJECT_SKILLS_POLICY_NAMES } from "./project-skills";
 import { SHARED_MCP_POLICY_NAMES } from "./shared-mcp";
 import { resolveProviderSelection, type ProviderEffort } from "agent-relay-sdk/provider-catalog";
-import { errMessage, isRecord, SPAWN_PROVIDERS, VALID_WORKSPACE_MODES } from "agent-relay-sdk"; import { effectiveProviderCatalogList } from "./provider-catalog-store";
+import { errMessage, isRecord, isSpawnProvider, SPAWN_PROVIDERS, VALID_WORKSPACE_MODES } from "agent-relay-sdk"; import { effectiveProviderCatalogList } from "./provider-catalog-store";
 import type {
   AgentProfile,
   AgentProfileBase,
@@ -50,7 +50,7 @@ const WORKSPACE_KEY = "default";
 const LANDING_NAMESPACE = "landing";
 const LANDING_KEY = "default";
 const VALID_LANDING_STRATEGIES = ["direct", "pr"] as const;
-const VALID_PROFILE_PROVIDERS = ["any", "claude", "codex"] as const;
+const VALID_PROFILE_PROVIDERS = ["any", ...SPAWN_PROVIDERS] as const;
 const VALID_PROFILE_BASES = ["host", "minimal", "isolated", "vanilla"] as const;
 const VALID_PROFILE_INSTRUCTION_POLICIES = ["allow", "ignore"] as const;
 const VALID_PROFILE_CATEGORY_MODES = ["host", "profile", "repo", "none"] as const;
@@ -957,7 +957,7 @@ function listManagedAgentStates(): ManagedAgentState[] {
 
 export function upsertManagedAgentState(input: ManagedAgentStateInput): ManagedAgentState {
   if (!VALID_MANAGED_STATUSES.includes(input.status)) throw new ValidationError("status must be a managed-agent status");
-  if (!SPAWN_PROVIDERS.includes(input.provider)) throw new ValidationError("provider must be claude or codex");
+  if (!isSpawnProvider(input.provider)) throw new ValidationError(`provider must be one of: ${SPAWN_PROVIDERS.join(", ")}`);
   const now = input.updatedAt ?? Date.now();
   getDb().query(`
     INSERT INTO managed_agent_state (

package/src/config.ts

@@ -48,9 +48,9 @@ function envTrimmedOrUndefined(name: string): string | undefined {
 
 export const STALE_TTL_MS = envPositiveInt("STALE_TTL_MS", 120_000); // 2min without heartbeat → offline
 // Backstop for agent-initiated spawns whose orchestrator command succeeded but whose runner never
-// registered with Relay. Keep this above the runner's own 60s registration timeout so the runner's
-// direct failure path wins first; this is the relay-side dead-man switch.
-export const SPAWN_REGISTRATION_DEADLINE_MS = envPositiveInt("AGENT_RELAY_SPAWN_REGISTRATION_DEADLINE_MS", 120_000);
+// registered with Relay. Keep this above the command TTL (180s) so the command's direct failure
+// path wins first; this is the relay-side dead-man switch.
+export const SPAWN_REGISTRATION_DEADLINE_MS = envPositiveInt("AGENT_RELAY_SPAWN_REGISTRATION_DEADLINE_MS", 300_000);
 export const SPAWN_REGISTRATION_NOTIFY_MAX_AGE_MS = envPositiveInt("AGENT_RELAY_SPAWN_REGISTRATION_NOTIFY_MAX_AGE_MS", 15 * 60_000);
 // #451 — default TTL for fire-and-forget FAN-OUT messages (broadcast/tag/cap/label/team) that the
 // sender didn't bound. A stale fan-out push must not wake an agent that matches the target hours

package/src/context-advisory.ts

@@ -1,5 +1,5 @@
 import { deriveContextThresholdFromWindowTokens, findProviderCatalogModel, resolveProviderContextThreshold, type ProviderModelCatalogEntry, type ResolvedProviderContextThreshold } from "agent-relay-sdk/provider-catalog";
-import { isRecord, SPAWN_PROVIDERS } from "agent-relay-sdk";
+import { isRecord, isSpawnProvider } from "agent-relay-sdk";
 import { getConfig } from "./config-store";
 import { validateContextThresholdConfig } from "./context-threshold-config";
 import { getResolvedNotificationsConfig } from "./notification-settings-store";
@@ -170,8 +170,8 @@ function hasExplicitContextThreshold(agent: AgentCard): boolean {
 
 function findAgentCatalogModel(agent: AgentCard, observedWindowTokens: number | undefined): ProviderModelCatalogEntry | undefined {
   const runtime = agent.providerCapabilities?.model;
-  const provider = runtime?.provider;
-  if (!provider || !(SPAWN_PROVIDERS as readonly string[]).includes(provider)) return undefined;
+  if (!runtime || !isSpawnProvider(runtime.provider)) return undefined;
+  const provider = runtime.provider;
   const catalog = effectiveProviderCatalogList().find((entry) => entry.provider === provider);
   if (!catalog) return undefined;
   const ids = [runtime.alias, runtime.id, runtime.providerModel].filter((value): value is string => Boolean(value));

package/src/db/provider-quotas.ts

@@ -1,5 +1,6 @@
+import { createHash } from "node:crypto";
 import { DAY_MS, QUOTA_HISTORY_RETENTION_MS } from "../config";
-import { credentialAccountKey } from "agent-relay-sdk/provider-quota";
+import { quotaAccountKeyAliases, registerAccountKeyAliases } from "agent-relay-providers";
 import { parseJson } from "../utils";
 import { getDb } from "./connection.ts";
 import { deriveProviderQuotaBurn } from "./provider-quota-burn.ts";
@@ -12,6 +13,14 @@ const QUOTA_RESET_BOUNDARY_ADVANCE_MS = 5_000;
 const QUOTA_RESET_UTILIZATION_MAX = 0.01;
 const FIVE_HOUR_MS = 5 * 60 * 60_000;
 
+registerAccountKeyAliases("codex", (accountKey) => {
+  if (accountKey.startsWith("account:")) {
+    const hash = createHash("sha256").update(accountKey.slice("account:".length)).digest("hex").slice(0, 16);
+    return [`credential:${hash}`];
+  }
+  return [];
+});
+
 export interface ProviderQuotaAdvisoryInput {
   provider: string;
   accountKey: string;
@@ -101,7 +110,7 @@ function quotaRowsForProvider(provider: string): ProviderQuotaRow[] {
 function supersededAccountKeys(provider: string, accountKey: string, rawAccountKey: string, sourceAgentId: string | undefined): string[] {
   const candidates = new Set<string>();
   if (rawAccountKey && rawAccountKey !== accountKey) candidates.add(rawAccountKey);
-  if (provider === "codex" && accountKey.startsWith("account:")) candidates.add(credentialAccountKey(accountKey.slice("account:".length)));
+  for (const alias of quotaAccountKeyAliases(provider, accountKey)) candidates.add(alias);
   const host = hostFromAccountKey(accountKey) ?? sourceAgentHost(sourceAgentId);
   if (host) {
     candidates.add(`host:${host}:${provider}`);

package/src/db/provisioning-registry.ts

@@ -2,9 +2,12 @@ import { randomUUID } from "node:crypto";
 import { Buffer } from "node:buffer";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { basename, join, posix, resolve } from "node:path";
+import "agent-relay-providers";
+import { getManifest } from "agent-relay-providers/registry";
+import type { ProviderManifest } from "agent-relay-providers/types";
 import { getDb, ValidationError } from "./connection.ts";
 import { parseJson } from "../utils";
-import { errMessage, isRecord } from "agent-relay-sdk";
+import { errMessage, isRecord, SPAWN_PROVIDERS } from "agent-relay-sdk";
 import type {
   AgentProfile,
   AgentProfileAssetRef,
@@ -30,16 +33,14 @@ import type {
 // this stays the single home for asset definition + resolution — not three modules.
 
 const PROVISIONING_ASSET_KINDS = ["skill", "mcp", "plugin"] as const;
-const PROVISIONING_PROVIDERS = ["claude", "codex", "any"] as const;
+const PROVISIONING_PROVIDERS = [...SPAWN_PROVIDERS, "any"];
 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 BUNDLED_SOURCE_TYPE = "bundled";
-const BUNDLED_RELAY_CLAUDE_PLUGIN_REF = "agent-relay-claude-plugin";
-const BUNDLED_CODEX_SKILL_PREFIX = "agent-relay-codex-";
-const BUNDLED_CLAUDE_PLUGIN_DIR = resolve(import.meta.dir, "../../runner/plugins/claude");
-const BUNDLED_CODEX_SKILLS_DIR = resolve(import.meta.dir, "../../runner/plugins/codex/skills");
+
+type ProviderBundledSkillSetDescriptor = NonNullable<NonNullable<ProviderManifest["provisioning"]>["bundledSkills"]>;
 
 interface ProvisioningAssetRow {
   id: string;
@@ -150,6 +151,8 @@ interface BundledFile {
   size: number;
 }
 
+type BundledFileReadOptions = { omitFiles?: string[]; fileOverrides?: Array<{ path: string; sourcePath: string }> };
+
 export interface ProvisioningCapabilityWithVariants {
   capability: ProvisioningCapability;
   variants: ProvisioningAsset[];
@@ -345,11 +348,11 @@ function parseJsonFile(file: VendoredFile, label: string): Record<string, unknow
 }
 
 function assertPlugin(files: VendoredFile[], provider: AgentProfileProvider): void {
-  const manifests = [
-    { provider: "claude" as const, path: ".claude-plugin/plugin.json" },
-    { provider: "codex" as const, path: ".codex-plugin/plugin.json" },
-  ];
+  const manifests = SPAWN_PROVIDERS.flatMap((manifestProvider) => getManifest(manifestProvider)?.provisioning?.pluginManifestPath
+    ? [{ provider: manifestProvider, path: getManifest(manifestProvider)!.provisioning!.pluginManifestPath! }]
+    : []);
   const expected = provider === "any" ? manifests : manifests.filter((m) => m.provider === provider);
+  if (!expected.length) throw new ValidationError(`plugin import has no manifest descriptor configured for provider ${provider}`);
   const present = expected.filter((manifest) => files.some((file) => file.path === manifest.path));
   if (!present.length) throw new ValidationError(`plugin import requires ${expected.map((m) => m.path).join(" or ")}`);
   for (const manifest of present) {
@@ -455,22 +458,22 @@ function fileProvenance(files: VendoredFile[]): Array<{ path: string; sha: strin
   return files.map(({ path, sha, size }) => ({ path, sha, size }));
 }
 
-function readBundledFiles(root: string): BundledFile[] {
+function readBundledFiles(root: string, options: BundledFileReadOptions = {}): BundledFile[] {
   if (!existsSync(root)) return [];
   const files: BundledFile[] = [];
+  const omitted = new Set(options.omitFiles ?? []);
+  const overrides = new Map((options.fileOverrides ?? []).map((item) => [item.path, item.sourcePath]));
   const visit = (dir: string, prefix = "") => {
     const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
       const cleanRel = cleanRelativePath(rel, "file path");
-      if (root === BUNDLED_CLAUDE_PLUGIN_DIR && cleanRel === "monitors/relay-monitor.provisioned.mjs") continue;
+      if (omitted.has(cleanRel)) continue;
       const abs = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        visit(abs, rel);
-        continue;
-      }
+      if (entry.isDirectory()) { visit(abs, rel); continue; }
       if (!entry.isFile()) continue;
-      const content = root === BUNDLED_CLAUDE_PLUGIN_DIR && cleanRel === "monitors/relay-monitor.ts" ? readFileSync(join(root, "monitors/relay-monitor.provisioned.mjs"), "utf8") : readFileSync(abs, "utf8");
+      const overrideSource = overrides.get(cleanRel);
+      const content = overrideSource ? readFileSync(join(root, overrideSource), "utf8") : readFileSync(abs, "utf8");
       files.push({ path: cleanRel, content, size: Buffer.byteLength(content, "utf8") });
     }
   };
@@ -507,51 +510,35 @@ function upsertBundledProvisioningAsset(input: {
   description: string;
 }): void {
   if (!input.files.length) return;
-  const definition = {
-    kind: input.kind,
-    name: input.name,
-    files: input.files.map(({ path, content }) => ({ path, content })),
-  } as SkillAssetDefinition | PluginAssetDefinition;
+  const definition = { kind: input.kind, name: input.name, files: input.files.map(({ path, content }) => ({ path, content })) } as SkillAssetDefinition | PluginAssetDefinition;
   assertDefinition(input.kind, definition);
-  const asset = upsertProvisioningAsset({
-    kind: input.kind,
-    name: input.name,
-    provider: input.provider,
-    definition,
-  });
+  const asset = upsertProvisioningAsset({ kind: input.kind, name: input.name, provider: input.provider, definition });
   updateBundledAssetMetadata(asset, input.root, input.files, input.title, input.description);
 }
 
-function bundledCodexSkillRefs(): string[] {
-  if (!existsSync(BUNDLED_CODEX_SKILLS_DIR)) return [];
-  return readdirSync(BUNDLED_CODEX_SKILLS_DIR, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && existsSync(join(BUNDLED_CODEX_SKILLS_DIR, entry.name, "SKILL.md")))
-    .map((entry) => `${BUNDLED_CODEX_SKILL_PREFIX}${entry.name}`)
-    .sort();
+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 {
-  upsertBundledProvisioningAsset({
-    kind: "plugin",
-    name: BUNDLED_RELAY_CLAUDE_PLUGIN_REF,
-    provider: "claude",
-    root: "runner/plugins/claude",
-    files: readBundledFiles(BUNDLED_CLAUDE_PLUGIN_DIR),
-    title: "Agent Relay Claude plugin",
-    description: "Bundled Agent Relay Claude plugin, materialized whole through the provisioning registry.",
-  });
-
-  for (const ref of bundledCodexSkillRefs()) {
-    const skillName = ref.slice(BUNDLED_CODEX_SKILL_PREFIX.length);
-    upsertBundledProvisioningAsset({
-      kind: "skill",
-      name: ref,
-      provider: "codex",
-      root: `runner/plugins/codex/skills/${skillName}`,
-      files: readBundledFiles(join(BUNDLED_CODEX_SKILLS_DIR, skillName)),
-      title: `Agent Relay Codex skill: ${skillName}`,
-      description: "Bundled Agent Relay Codex skill, materialized through the provisioning registry.",
-    });
+  for (const provider of SPAWN_PROVIDERS) {
+    const provisioning = getManifest(provider)?.provisioning;
+    if (!provisioning) continue;
+    if (provisioning.bundledPlugin) {
+      const plugin = provisioning.bundledPlugin;
+      upsertBundledProvisioningAsset({ kind: "plugin", name: plugin.ref, provider, root: plugin.dir, files: readBundledFiles(resolve(import.meta.dir, "../../", plugin.dir), { omitFiles: plugin.omitFiles, fileOverrides: plugin.fileOverrides }), title: plugin.title, description: plugin.description });
+    }
+    if (!provisioning.bundledSkills) continue;
+    const skills = provisioning.bundledSkills;
+    const skillsDir = resolve(import.meta.dir, "../../", skills.dir);
+    for (const ref of bundledSkillRefs(skills)) {
+      const skillName = ref.slice(skills.refPrefix.length);
+      upsertBundledProvisioningAsset({ kind: "skill", name: ref, provider, root: posix.join(skills.dir, skillName), files: readBundledFiles(join(skillsDir, skillName)), title: `${skills.titlePrefix}${skillName}`, description: skills.description });
+    }
   }
 }
 
@@ -1034,7 +1021,7 @@ function resolveRegistryDefinition(kind: ProvisioningAssetKind, ref: string, pro
     .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 = provider === "codex" ? "Codex" : "Claude";
+    const label = getManifest(provider)?.label ?? provider;
     return { definition: null, skip: skip(kind, ref, provider, "provider_mismatch", `No ${label} variant exists for capability ${ref}.`) };
   }
 
@@ -1059,13 +1046,14 @@ function hasAssetRef(refs: AgentProfileAssetRef[], source: AgentProfileAssetRef[
 function relayBundledProvisioningRefs(profile: AgentProfile, provider: SpawnProvider): Pick<AgentProfile, "skills" | "plugins"> {
   const skills = [...(profile.skills ?? [])];
   const plugins = [...(profile.plugins ?? [])];
-  if (provider === "codex" && profile.relay.skills !== false) {
-    for (const ref of bundledCodexSkillRefs()) {
-      if (!hasAssetRef(skills, "relay", ref)) skills.push({ source: "relay", ref, enabled: true, provider: "codex" });
+  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 (provider === "claude" && profile.relay.plugins !== false && !hasAssetRef(plugins, "relay", BUNDLED_RELAY_CLAUDE_PLUGIN_REF)) {
-    plugins.push({ source: "relay", ref: BUNDLED_RELAY_CLAUDE_PLUGIN_REF, enabled: true, provider: "claude" });
+  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 };
 }

package/src/managed-policy.ts

@@ -1,3 +1,4 @@
+import { getManifest } from "agent-relay-providers";
 import { getAgentProfile } from "./config-store";
 import { withResolvedProvisioning } from "./db";
 import { runnerRuntimeTokenEnv } from "./runtime-tokens";
@@ -5,15 +6,19 @@ import { buildSpawnCommand, resolveSpawnModelParams } from "./spawn-command";
 import { applyDefaultSharedMcp } from "./shared-mcp";
 import type { SpawnPolicy, WorkspaceMode } from "./types";
 
+function managedPolicyPromptMode(policy: SpawnPolicy): "prompt" | "append-system-prompt" {
+  return getManifest(policy.provider)?.launch?.managedPolicyPrompt?.alwaysOn ?? "prompt";
+}
+
 export function managedPolicyProviderArgs(policy: SpawnPolicy): string[] {
-  if (policy.provider === "claude" && policy.mode === "always-on" && policy.prompt?.trim()) {
+  if (policy.mode === "always-on" && policy.prompt?.trim() && managedPolicyPromptMode(policy) === "append-system-prompt") {
     return [...policy.providerArgs, "--append-system-prompt", policy.prompt.trim()];
   }
   return policy.providerArgs;
 }
 
 export function managedPolicyLaunchPrompt(policy: SpawnPolicy): string | undefined {
-  if (policy.provider === "claude" && policy.mode === "always-on") return undefined;
+  if (policy.mode === "always-on" && managedPolicyPromptMode(policy) === "append-system-prompt") return undefined;
   return policy.prompt;
 }
 

package/src/mcp/tools-spawn.ts

@@ -71,7 +71,7 @@ export const SPAWN_TOOLS: ToolDefinition[] = [
           required: ["branch", "mode"],
           additionalProperties: false,
         },
-        waitForRegistrationMs: { type: "integer", minimum: 0, maximum: 30000, description: "How long to wait for the spawned agent to register before returning, so the response carries its resolved agent id (default 8000; 0 = return immediately with just spawnRequestId)." },
+        waitForRegistrationMs: { type: "integer", minimum: 0, maximum: 30000, description: "How long to wait for the spawned agent to register before returning, so the response carries its resolved agent id (default 0 = fire-and-forget; you will be PUSHED agent.ready when the child is ready)." },
       },
       required: ["provider"],
       additionalProperties: false,
@@ -158,7 +158,7 @@ export async function relaySpawnAgent(auth: McpAuthContext, args: Record<string,
     providerArgs: optionalStringArray(args.providerArgs, "providerArgs"),
     spawnRequestId: optionalString(args.spawnRequestId, "spawnRequestId", 160),
     requestedVia: "mcp",
-    waitForRegistrationMs: optionalNonNegativeInt(args.waitForRegistrationMs, "waitForRegistrationMs") ?? 8000,
+    waitForRegistrationMs: optionalNonNegativeInt(args.waitForRegistrationMs, "waitForRegistrationMs") ?? 0,
     resumeWorkspace: parseResumeWorkspace(args.resumeWorkspace),
   };
   const result = await spawnAgent(input, authContextFromMcp(auth));

package/src/mcp-team-template-tools.ts

@@ -1,4 +1,4 @@
-import { APPROVAL_MODES, VALID_AGENT_LIFECYCLES, VALID_WORKSPACE_MODES } from "agent-relay-sdk";
+import { APPROVAL_MODES, SPAWN_PROVIDERS, VALID_AGENT_LIFECYCLES, VALID_WORKSPACE_MODES } from "agent-relay-sdk";
 import { McpAuthError } from "./mcp-errors";
 import { authContextFromMcp } from "./services/auth-context";
 import { deleteTeamTemplate, getTeamTemplate, instantiateTeamTemplate, listTeamTemplates, saveTeamTemplate } from "./services/team-templates";
@@ -9,7 +9,7 @@ const COMPOSITION_ENTRY_SCHEMA = {
   type: "object",
   properties: {
     label: { type: "string" },
-    provider: { type: "string", enum: ["claude", "codex"] },
+    provider: { type: "string", enum: SPAWN_PROVIDERS },
     model: { type: "string" },
     effort: { type: "string" },
     profile: { type: "string" },

package/src/provider-catalog-store.ts

@@ -138,7 +138,7 @@ export function mergeProviderCatalog(
 }
 
 function normalizeOverrideInput(input: ProviderModelOverrideInput): ProviderModelOverrideInput {
-  if (!SPAWN_PROVIDERS.includes(input.provider)) throw new ValidationError("provider must be claude or codex");
+  if (!SPAWN_PROVIDERS.includes(input.provider)) throw new ValidationError(`provider must be one of: ${SPAWN_PROVIDERS.join(", ")}`);
   const alias = input.alias.trim();
   if (!alias) throw new ValidationError("model alias is required");
   if (input.entry.alias !== alias) throw new ValidationError("model entry alias must match override alias");

package/src/recipe-validator.ts

@@ -1,6 +1,6 @@
 import type { MemoryType, Recipe, RecipeAgent, RecipeMemoryPolicy } from "./types";
 import { resolveProviderSelection, type ProviderEffort } from "agent-relay-sdk/provider-catalog";
-import { errMessage, isRecord } from "agent-relay-sdk";
+import { errMessage, isRecord, isSpawnProvider, SPAWN_PROVIDERS } from "agent-relay-sdk";
 import { effectiveProviderCatalogList } from "./provider-catalog-store";
 
 class RecipeValidationError extends Error {}
@@ -41,7 +41,9 @@ export function validateRecipe(value: unknown): Recipe {
 function validateAgent(value: unknown): RecipeAgent {
   if (!isRecord(value)) throw new RecipeValidationError("agent must be an object");
   const provider = value.provider;
-  if (provider !== "claude" && provider !== "codex") throw new RecipeValidationError("agent.provider must be claude or codex");
+  if (!isSpawnProvider(provider)) {
+    throw new RecipeValidationError(`agent.provider must be one of: ${SPAWN_PROVIDERS.join(", ")}`);
+  }
   const capabilities = stringArray(value.capabilities, "agent.capabilities");
   if (capabilities.length === 0) throw new RecipeValidationError("agent.capabilities must not be empty");
   const approvalMode = value.approvalMode;

package/src/routes/agent-profiles.ts

@@ -5,7 +5,7 @@ import { deleteAgentProfile, getAgentProfile, listAgentProfiles, setAgentProfile
 import { emitConfigChanged } from "../sse";
 import { error, isRootCredentialRequest, json, normalizeConfigPathParam, parseBody, type Handler } from "./_shared";
 import { getComponentAuth, hasComponentScope } from "../security";
-import { isRecord } from "agent-relay-sdk";
+import { isRecord, isSpawnProvider } from "agent-relay-sdk";
 import { SPAWN_PROVIDERS, type AgentProfile, type SpawnProvider } from "../types";
 
 export const getAgentProfilesRoute: Handler = () => json(listAgentProfiles());
@@ -29,7 +29,7 @@ export const getResolvedAgentProfileRoute: Handler = (req, params) => {
     const entry = getAgentProfile(name);
     if (!entry) return error("agent profile not found", 404);
     const requestedProvider = new URL(req.url).searchParams.get("provider") ?? undefined;
-    const profileProvider = entry.value.provider === "claude" || entry.value.provider === "codex" ? entry.value.provider : undefined;
+    const profileProvider = isSpawnProvider(entry.value.provider) ? entry.value.provider : undefined;
     const provider = optionalEnum(requestedProvider, "provider", SPAWN_PROVIDERS, profileProvider ?? "codex") as SpawnProvider;
     const profile = withResolvedProvisioning(entry.value, provider);
     return profile ? json({ provider, profile }) : error("agent profile not found", 404);