agent-relay-runner 0.90.0 → 0.91.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.90.0",
+  "version": "0.91.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.69"
+    "agent-relay-sdk": "0.2.70"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.90.0",
+  "version": "0.91.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapter.ts

@@ -100,6 +100,10 @@ export interface RunnerSpawnConfig {
   // Stage 2 (#215): the MCP endpoint the agent connects to — the runner-local proxy URL when the
   // proxy is active. Undefined → the adapter targets the relay's MCP endpoint directly (Stage 1).
   relayMcpEndpoint?: string;
+  // #672: the shared host-listener URL the per-agent `callmux bridge` connects to, when the
+  // profile/spawn opted into `agentProfile.sharedMcp`. Resolved runner-side (env → default);
+  // the launch assembler only emits the bridge entry when sharedMcp is on.
+  sharedMcpUrl?: string;
   monitor?: {
     deliver(messages: Message[]): Promise<number[]>;
   };

package/src/launch-assembly.ts

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync } from "node:fs";
 import { resolve, join } from "node:path";
-import type { AgentProfile, AgentProfileBase, SpawnProvider } from "agent-relay-sdk";
+import type { AgentProfile, AgentProfileBase, ProvisioningMcpServer, SpawnProvider } from "agent-relay-sdk";
 import {
   profileAllowsRelayFeature,
   profileIsVanillaBase,
@@ -20,8 +20,11 @@ import {
   claudeMcpLaunchArgs,
   codexProvisionedMcpArgs,
   relayMcpCodexConfigArgs,
+  resolveSharedMcpUrl,
+  sharedMcpBridgeServer,
   tomlString,
   RELAY_MCP_SERVER_NAME,
+  SHARED_MCP_SERVER_NAME,
 } from "./relay-mcp";
 
 // #557 — THE single launch-assembly contract. Given a resolved AgentProfile (+ its
@@ -84,6 +87,14 @@ export interface AssembledMcp {
    *  the ambient host MCP (callmux/qmd/gh) instead of dropping it. Empty for non-host mcp
    *  modes, isolated bases (own config home, never had host MCP), and Codex. */
   hostServers: string[];
+  /** #672 — when the profile/spawn opted into `sharedMcp`, the agent's NON-IDENTITY MCP
+   *  (tokenlean, github) is routed through one orchestrator-owned shared `callmux` listener via
+   *  a per-agent `callmux bridge --cwd "$WORKTREE"` (session-cwd isolation), injected through
+   *  the same `--mcp-config` / `-c` channel so it survives strict. `url` is the listener the
+   *  bridge connects to. Undefined when projection is OFF (the default). The bridge is opaque
+   *  at assembly time — its server SET is owned by the listener config, not enumerated here.
+   *  The identity-bearing relay endpoint is never on the shared listener (#215). */
+  sharedListener?: { url: string };
 }
 
 export interface AssembledLaunch {
@@ -220,7 +231,21 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
     ),
   );
   const projectServers = Object.keys(projectMcp);
-  const declaredMcp = { ...projectMcp, ...provisionedMcp };
+
+  // #672 — shared host-listener MCP (opt-in, default OFF). When on, route the agent's
+  // NON-IDENTITY MCP (tokenlean, github) through ONE orchestrator-owned shared `callmux`
+  // listener via a per-agent `callmux bridge --url <listener> --cwd "$WORKTREE"` stdio entry:
+  // the MCP session survives a listener/downstream restart, and --cwd gives each isolated
+  // worktree session-cwd isolation. It's a plain stdio server descriptor, so it rides the same
+  // controlled --mcp-config channel as provisioned servers (survives --strict-mcp-config) — no
+  // ambient discovery, no modal. Relay-owned infra → authoritative on its name (spread last);
+  // the relay endpoint stays per-agent (#215), NEVER on the shared listener.
+  const sharedListenerOn = Boolean(config.agentProfile?.sharedMcp);
+  const sharedListenerUrl = sharedListenerOn ? resolveSharedMcpUrl(config.sharedMcpUrl) : undefined;
+  const sharedMcp: Record<string, ProvisioningMcpServer> = sharedListenerUrl
+    ? { [SHARED_MCP_SERVER_NAME]: sharedMcpBridgeServer(sharedListenerUrl, config.cwd) }
+    : {};
+  const declaredMcp = { ...projectMcp, ...provisionedMcp, ...sharedMcp };
 
   // #662 — EVERY managed Claude launch is --strict-mcp-config, not just vanilla. A managed
   // agent runs headless (no human at the keyboard), so Claude's blocking "N new MCP servers
@@ -278,7 +303,10 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
     statusLine,
     skills: skills.map((s) => ({ name: s.name, dir: s.dir })),
     plugins: provisionedPlugins.map((p) => ({ name: p.name, dir: p.dir })),
-    mcp: { relayEndpoint, strict: strictMcp, servers: mcpServers, projectServers, hostServers: hostMcpServers },
+    mcp: {
+      relayEndpoint, strict: strictMcp, servers: mcpServers, projectServers, hostServers: hostMcpServers,
+      ...(sharedListenerUrl ? { sharedListener: { url: sharedListenerUrl } } : {}),
+    },
     instructions,
     args,
     env: configHome ? { CLAUDE_CONFIG_DIR: configHome } : {},
@@ -308,7 +336,18 @@ function assembleCodex(config: RunnerSpawnConfig, _providerConfig: ProviderConfi
     ),
   );
   const projectServers = Object.keys(projectMcp);
-  const declaredMcp = { ...projectMcp, ...provisionedMcp };
+
+  // #672 — shared host-listener MCP (opt-in, default OFF), same as Claude: a per-agent
+  // `callmux bridge --url <listener> --cwd "$WORKTREE"` stdio entry routes the agent's
+  // NON-IDENTITY MCP (tokenlean, github) through the shared listener (session survives a
+  // restart; --cwd gives session-cwd isolation). Emitted via the same `-c mcp_servers.*`
+  // overrides as provisioned servers. The relay endpoint stays per-agent (#215).
+  const sharedListenerOn = Boolean(config.agentProfile?.sharedMcp);
+  const sharedListenerUrl = sharedListenerOn ? resolveSharedMcpUrl(config.sharedMcpUrl) : undefined;
+  const sharedMcp: Record<string, ProvisioningMcpServer> = sharedListenerUrl
+    ? { [SHARED_MCP_SERVER_NAME]: sharedMcpBridgeServer(sharedListenerUrl, config.cwd) }
+    : {};
+  const declaredMcp = { ...projectMcp, ...provisionedMcp, ...sharedMcp };
 
   const instructions = assembleInstructions(config);
 
@@ -333,7 +372,10 @@ function assembleCodex(config: RunnerSpawnConfig, _providerConfig: ProviderConfi
     statusLine: false,
     skills: provisionedSkills.map((s) => ({ name: s.name, dir: s.dir })),
     plugins: [],
-    mcp: { relayEndpoint, strict: false, servers: mcpServers, projectServers, hostServers: [] },
+    mcp: {
+      relayEndpoint, strict: false, servers: mcpServers, projectServers, hostServers: [],
+      ...(sharedListenerUrl ? { sharedListener: { url: sharedListenerUrl } } : {}),
+    },
     instructions,
     args,
     env: configHome ? { CODEX_HOME: configHome } : {},

package/src/profile-projection.ts

@@ -34,6 +34,7 @@ export function agentProfileProjectionReport(input: AgentProfileProjectionInput)
   add(provisioningPluginsEntry(assembled));
   add(provisioningMcpEntry(assembled));
   add(projectMcpEntry(assembled));
+  add(sharedMcpEntry(assembled));
   if (profile) add(filesystemEntry(profile));
   add(configHomeEntry(assembled));
   if (assembled.vanilla) add(vanillaLaunchEntry(provider));
@@ -158,6 +159,19 @@ function projectMcpEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
     : `Project .mcp.json servers emitted as -c mcp_servers.* overrides (${names.join(", ")}).`);
 }
 
+// #672 — shared host-listener MCP provenance. `not-applicable` when the profile/spawn didn't
+// opt in (the default); `applied` reports the per-agent `callmux bridge` routing the agent's
+// non-identity MCP (tokenlean, github) through the shared listener it points at. The server SET
+// is owned by the listener config, so this surfaces the route + URL, not an enumerated list.
+function sharedMcpEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
+  const optedIn = Boolean(a.profile?.sharedMcp);
+  const listener = a.mcp.sharedListener;
+  if (!optedIn || !listener) return notApplicable("sharedMcp", "off", "Shared host-listener MCP is off (opt in via the sharedMcp profile/spawn option); non-identity MCP is injected per-agent.");
+  return applied("sharedMcp", "on", a.provider === "claude"
+    ? `Non-identity MCP (e.g. tokenlean, github) routed through the shared callmux listener (${listener.url}) via a per-agent 'callmux bridge --cwd "$WORKTREE"', injected into --mcp-config (survives --strict-mcp-config); session survives a listener restart, session-cwd isolated. Relay endpoint stays per-agent (#215).`
+    : `Non-identity MCP (e.g. tokenlean, github) routed through the shared callmux listener (${listener.url}) via a per-agent 'callmux bridge --cwd "$WORKTREE"' emitted as -c mcp_servers.* overrides; session survives a listener restart, session-cwd isolated. Relay endpoint stays per-agent (#215).`);
+}
+
 function globalInstructionsEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
   const disposition = a.instructions.global;
   if (disposition === "allow") return applied("instructions.global", "allow", "Host/global provider instructions are left available.");

package/src/relay-mcp.ts

@@ -19,6 +19,24 @@ export const RELAY_MCP_SERVER_NAME = "agent-relay";
 export const RELAY_MCP_PATH = "/api/mcp";
 export const RELAY_MCP_TOKEN_ENV = "AGENT_RELAY_SESSION_TOKEN";
 
+// #672 — shared host-listener MCP. The agent connects to ONE orchestrator-owned shared
+// `callmux` listener via a per-agent `callmux bridge`, fronting the host's NON-IDENTITY MCP
+// (tokenlean, github). The bridge is a stdio child (auto-reconnect + retry-once on a
+// listener/downstream hiccup; `--cwd` injects `x-callmux-cwd` for per-worktree session-cwd
+// isolation), so it rides the SAME provider injection as any provisioned stdio server. The
+// identity-bearing relay endpoint is NEVER routed here — it stays per-agent on #215.
+export const SHARED_MCP_SERVER_NAME = "callmux";
+// callmux's documented manual-listener endpoint (`callmux --listen 4860`, Streamable HTTP at
+// /mcp). In managed launches the orchestrator owns the real listener URL and passes it through
+// AGENT_RELAY_SHARED_MCP_URL; this fallback is for direct runner/manual-listener use.
+export const DEFAULT_SHARED_MCP_URL = "http://localhost:4860/mcp";
+export const SHARED_MCP_URL_ENV = "AGENT_RELAY_SHARED_MCP_URL";
+
+/** Resolve the shared-listener URL: explicit runner option → env → documented default. */
+export function resolveSharedMcpUrl(explicit?: string): string {
+  return explicit ?? process.env[SHARED_MCP_URL_ENV] ?? DEFAULT_SHARED_MCP_URL;
+}
+
 export function relayMcpEndpoint(relayUrl: string): string {
   return `${relayUrl.replace(/\/+$/, "")}${RELAY_MCP_PATH}`;
 }
@@ -51,6 +69,13 @@ export function tomlString(value: string): string {
 // strict then preserves exactly that set and nothing else.
 import type { ProvisioningMcpServer } from "agent-relay-sdk";
 
+// The shared-listener bridge as a provider-neutral stdio server descriptor: a `callmux bridge`
+// child fronting the host's shared listener, with per-agent `--cwd "$WORKTREE"` for session-cwd
+// isolation (#672). It flows through the existing claude/codex stdio injection unchanged.
+export function sharedMcpBridgeServer(url: string, cwd: string): ProvisioningMcpServer {
+  return { command: "callmux", args: ["bridge", "--url", url, "--cwd", cwd] };
+}
+
 function claudeMcpServerEntry(server: ProvisioningMcpServer): Record<string, unknown> {
   const entry: Record<string, unknown> = {};
   if (server.type) entry.type = server.type;

package/src/runner-core.ts

@@ -17,7 +17,7 @@ import { ReplyObligationCache, obligationRequiresExplicitReply, responseCaptureR
 import { Outbox, type OutboxRecord } from "./outbox";
 import { extractLastAssistantTurn, extractLastAssistantTurnAfterEntry, countTranscriptEntries, extractFinalAssistantMessage, extractFinalAssistantMessageAfterEntry, extractHookAssistantMessage, extractLatestTurnSteps, stepDedupKeys, transcriptLooksComplete } from "./adapters/claude-transcript";
 import { profileUsesHostProviderGlobals } from "./profile-home";
-import { RELAY_MCP_TOKEN_ENV, relayMcpEndpoint } from "./relay-mcp";
+import { RELAY_MCP_TOKEN_ENV, relayMcpEndpoint, resolveSharedMcpUrl } from "./relay-mcp";
 import { RelayMcpProxy } from "./relay-mcp-proxy";
 import { runtimeMetadata } from "./version";
 import { logger, parseLogLevel } from "./logger";
@@ -581,6 +581,9 @@ export class AgentRunner {
       // Stage 2 (#215): the MCP endpoint the agent's client should target — the runner-local
       // proxy when active, undefined when disabled (adapters fall back to the direct relay URL).
       ...(this.mcpProxyEndpoint ? { relayMcpEndpoint: this.mcpProxyEndpoint } : {}),
+      // #672: the shared host-listener URL the `callmux bridge` connects to (env → default).
+      // Always resolved; the assembler only emits the bridge when `agentProfile.sharedMcp` is on.
+      sharedMcpUrl: resolveSharedMcpUrl(),
       monitor: {
         deliver: (messages) => this.control!.deliverToMonitor(messages),
       },