agent-relay-server 0.102.1 → 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/channels.ts

@@ -284,7 +284,35 @@ function channelTargetHealth(binding: ChannelBinding, now: number = Date.now()):
   };
 }
 
+// #797 — outbound (egress-only) channel liveness. Bidirectional channels (e.g. Telegram)
+// have a backing pool agent that heartbeats, so their agent `lastSeen`/`status` track
+// reality. Outbound-only channels (e.g. ntfy) are just a channels-host daemon SSE
+// subscription with NO agent behind them to heartbeat — so the registration's `lastSeen`
+// goes stale and the offline sweep flips it offline even while the daemon's subscription is
+// live and delivery works. For these, liveness is "is the channels-host subscribed for this
+// channel agent on the SSE bus?", not heartbeat freshness. A late-bound probe (not a direct
+// import) because sse.ts imports the db barrel — sse registers this at startup, mirroring
+// `onWorkspaceChange`.
+type ChannelSubscriberProbe = (channelAgentId: string) => boolean;
+let channelSubscriberProbe: ChannelSubscriberProbe | null = null;
+export function setChannelSubscriberProbe(probe: ChannelSubscriberProbe | null): void {
+  channelSubscriberProbe = probe;
+}
+function hasActiveChannelSubscriber(channelAgentId: string): boolean {
+  try {
+    return channelSubscriberProbe ? channelSubscriberProbe(channelAgentId) : false;
+  } catch {
+    return false;
+  }
+}
+
 function rowToChannelSummary(row: any): ChannelSummary {
+  // Outbound channels report online iff their channels-host SSE subscription is active,
+  // overriding the heartbeat-derived agent status/ready (which is meaningless for an
+  // agentless egress channel). Inbound/bidirectional keep the backing agent's signal.
+  const subscriberLive = row.direction === "outbound" ? hasActiveChannelSubscriber(row.agent_id) : null;
+  const status: ChannelSummary["status"] = subscriberLive === null ? row.agent_status : (subscriberLive ? "online" : "offline");
+  const ready = subscriberLive === null ? row.agent_ready === 1 : subscriberLive;
   const binding = row.binding_id ? rowToChannelBinding({
     id: row.binding_id,
     channel_id: row.id,
@@ -308,8 +336,8 @@ function rowToChannelSummary(row: any): ChannelSummary {
     transport: row.transport,
     agentId: row.agent_id,
     accountId: row.account_id,
-    status: row.agent_status,
-    ready: row.agent_ready === 1,
+    status,
+    ready,
     direction: row.direction,
     target: binding ? bindingTargetToLegacyTarget(binding.target) : undefined,
     binding,

package/src/db/provider-quota-burn.ts

@@ -15,6 +15,17 @@ const WINDOW_NOMINAL_MS: Record<ProviderQuotaBurnRole, number> = {
 // observed rate (and burnRatio) back toward 0 instead of freezing the endpoint slope.
 const RECENCY_HALFLIFE_FRACTION = 0.25;
 
+// #798 — idle de-bias: once a provider's utilization has held flat for this long, any residual
+// forward-burn rate is a stale-burst artifact (the recency half-life decays it, but for the 7d
+// window — half-life ~42h — far too slowly: codex idle ~24h still projected ~1.07 at reset,
+// walking the band boundary tick-to-tick). When idle this long the forward-burn term is collapsed
+// so projectedUtilAtReset → current utilization. The threshold is absolute (NOT window-scaled): a
+// 5h window resets long before reaching it, so this only de-biases the slow-decaying 7d window;
+// shorter idle stretches keep the graceful #760 recency decay. The over-target avoid is preserved
+// by the position penalty in spawn-targets (a stable, position-based floor), not by this rate.
+const IDLE_FORWARD_COLLAPSE_MS = 6 * 3_600_000;
+const IDLE_UTILIZATION_EPSILON = 1e-9;
+
 type QuotaWindow = QuotaState["windows"][number];
 
 // Provider-agnostic: window role is expressed by name only. Each adapter uses the
@@ -80,6 +91,19 @@ function recencyWeightedRatePerMs(
   return Math.max(0, weightedDelta / weightedDt);
 }
 
+// #798 — when did utilization last differ from its current value? Scanning back from the newest
+// sample, the first sample that differs marks the last change; everything after it (up to now) is
+// the flat idle stretch. If every sample equals the current value the window has been flat since
+// the oldest sample. Samples are assumed sorted ascending by capturedAt.
+function lastUtilizationChangeAt(samples: Array<{ capturedAt: number; utilization: number }>, current: number): number {
+  for (let i = samples.length - 1; i >= 0; i--) {
+    if (Math.abs(samples[i]!.utilization - current) > IDLE_UTILIZATION_EPSILON) {
+      return samples[i + 1]?.capturedAt ?? samples[i]!.capturedAt;
+    }
+  }
+  return samples[0]?.capturedAt ?? 0;
+}
+
 function deriveProviderQuotaBurnWindow(input: {
   provider: string;
   currentWindow: QuotaWindow;
@@ -137,17 +161,25 @@ function deriveProviderQuotaBurnWindow(input: {
     ? [...samples, { capturedAt: input.now, utilization: utilizationNow }]
     : samples;
   const observedRatePerMs = recencyWeightedRatePerMs(rateSamples, input.now, halfLifeMs);
+  // #798 — idle de-bias: if utilization has held flat (no change vs. now) for IDLE_FORWARD_COLLAPSE_MS,
+  // treat the forward-burn term as a stale-burst artifact and collapse it to 0 so the projection
+  // pins to current utilization instead of walking the band boundary. lastChangeAt is the moment
+  // utilization last differed from the current value (the synthetic "still X as of now" interval is
+  // what makes a deduped idle stretch observable here).
+  const lastChangeAt = lastUtilizationChangeAt(samples, utilizationNow);
+  const effectiveRate = input.now - lastChangeAt >= IDLE_FORWARD_COLLAPSE_MS ? 0 : observedRatePerMs;
   // #760 (Defect 2) — pace against a configurable target (<100%); slack carries the underburn
   // signal. The query layer (spawn-targets) may re-derive these against a per-provider target;
   // the ingest-time values use the default so direct burn consumers (dashboard) have a number.
   const pace = quotaPaceMetrics({
     utilization: utilizationNow,
-    observedRatePerMs,
+    observedRatePerMs: effectiveRate,
     timeToResetMs,
     target: DEFAULT_QUOTA_TARGET_UTILIZATION,
   });
-  if (observedRatePerMs <= 0) {
-    // Idle (or decayed-to-idle): no projected wall, but slack still flags the headroom.
+  if (effectiveRate <= 0) {
+    // Idle (decayed-to-idle, or #798 idle-collapsed): no projected wall, but slack still flags the
+    // headroom (positive = underburn) or, when over target, the position the band-floor avoids.
     return {
       ...low,
       confidence: "high",
@@ -158,13 +190,13 @@ function deriveProviderQuotaBurnWindow(input: {
       target: pace.target,
     };
   }
-  const timeToWallMs = remainingQuota / observedRatePerMs;
+  const timeToWallMs = remainingQuota / effectiveRate;
   const projectedWallAt = input.now + timeToWallMs;
   return {
     ...low,
     confidence: "high",
     burnRatio: pace.burnRatio,
-    observedRatePerMs,
+    observedRatePerMs: effectiveRate,
     timeToWallMs,
     projectedWallAt,
     // #760 (Defect 2) — symmetric: negative means the wall lands AFTER reset (headroom left).

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;
 }