agent-relay-orchestrator 0.119.11 → 0.120.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.119.11",
+  "version": "0.120.0",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "agent-relay-providers": "0.104.3",
-    "agent-relay-sdk": "0.2.106",
+    "agent-relay-sdk": "0.2.107",
     "callmux": "0.23.0"
   },
   "devDependencies": {

package/src/config.ts

@@ -93,6 +93,8 @@ export const TERMINAL_COMMAND_TIMEOUT_MS = envNonNegativeMax("AGENT_RELAY_TERMIN
 export const TERMINAL_GROUND_WAIT_MAX_MS = envNonNegativeMax("AGENT_RELAY_TERMINAL_GROUND_WAIT_MAX_MS", 500, 0);
 export const TERMINAL_BACKFILL_SCROLLBACK_LINES = envNonNegativeMax("AGENT_RELAY_TERMINAL_BACKFILL_SCROLLBACK", 1000, 0);
 export const TERMINAL_DEBUG = process.env.AGENT_RELAY_TERMINAL_DEBUG === "1";
+export const SCHEDULER_COMMAND_MAX_CONCURRENT = envNonNegativeMax("AGENT_RELAY_SCHEDULER_COMMAND_MAX_CONCURRENT", 4, 1);
+export const SCHEDULER_COMMAND_MAX_OUTPUT_BYTES = envNonNegativeMax("AGENT_RELAY_SCHEDULER_COMMAND_MAX_OUTPUT_BYTES", 256 * 1024, 4096);
 
 interface RawConfig {
   id?: string;

package/src/control.ts

@@ -1,6 +1,6 @@
-import { errMessage, isRecord, normalizeAgentLifecycle, normalizeWorkspaceMode, Semaphore } from "agent-relay-sdk";
+import { errMessage, isPathWithinBase, isRecord, normalizeAgentLifecycle, normalizeWorkspaceMode, Semaphore } from "agent-relay-sdk";
 import { getAllManifests, getManifest } from "agent-relay-providers";
-import type { OrchestratorConfig } from "./config";
+import { SCHEDULER_COMMAND_MAX_CONCURRENT, SCHEDULER_COMMAND_MAX_OUTPUT_BYTES, type OrchestratorConfig } from "./config";
 import type { ManagedAgentReport, RelayClient, RelayCommand } from "./relay";
 import { handleSelfUpgrade } from "./self-upgrade";
 import { readLocalProviderConfigs } from "./provider-config-migration";
@@ -9,6 +9,7 @@ import { cleanupWorkspace, discardRecoveryBranch, idleRefreshWorktree, mergeWork
 import { withMergePhaseTimeout } from "./workspace-probe/merge-timeouts";
 import { armWorkspacePrAutoMerge, mergeWorkspacePr, refreshWorkspacePrBranch } from "./workspace-pr";
 import type { WorkspaceMergeResult } from "agent-relay-sdk";
+import { execProcess } from "./process";
 
 // #638 — settle a `workspace.merge` command on whether it made progress, not on whether
 // the merge function threw. Every no-progress outcome (origin moved ahead, an unpredicted
@@ -64,6 +65,22 @@ export function resolveSpawnRegistrationTimeoutMs(env: NodeJS.ProcessEnv = proce
   return parsed;
 }
 
+export function resolveMaxConcurrentSchedulerCommands(env: NodeJS.ProcessEnv = process.env): number {
+  const raw = env.AGENT_RELAY_SCHEDULER_COMMAND_MAX_CONCURRENT;
+  if (raw === undefined || raw.trim() === "") return SCHEDULER_COMMAND_MAX_CONCURRENT;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 1) return SCHEDULER_COMMAND_MAX_CONCURRENT;
+  return parsed;
+}
+
+export function resolveSchedulerCommandMaxOutputBytes(env: NodeJS.ProcessEnv = process.env): number {
+  const raw = env.AGENT_RELAY_SCHEDULER_COMMAND_MAX_OUTPUT_BYTES;
+  if (raw === undefined || raw.trim() === "") return SCHEDULER_COMMAND_MAX_OUTPUT_BYTES;
+  const parsed = Number(raw);
+  if (!Number.isSafeInteger(parsed) || parsed < 4096) return SCHEDULER_COMMAND_MAX_OUTPUT_BYTES;
+  return parsed;
+}
+
 /** Awaits a spawn slot until the child registers, or resolves false at the fail-safe deadline. */
 export type WaitForRegistration = (agent: ManagedAgentReport, timeoutMs: number) => Promise<boolean>;
 
@@ -98,6 +115,8 @@ interface ControlHandlerDeps {
   registrationTimeoutMs?: number;
   // Injectable stop dispatch — production uses tmux/system process teardown.
   stopSession?: typeof stopSession;
+  maxConcurrentSchedulerCommands?: number;
+  schedulerCommandMaxOutputBytes?: number;
 }
 
 export function createControlHandler(
@@ -113,10 +132,13 @@ export function createControlHandler(
   const spawnSlots = new Semaphore(deps.maxConcurrentSpawns ?? resolveMaxConcurrentSpawns());
   const waitForRegistration = deps.waitForRegistration ?? waitForManagedRegistration;
   const registrationTimeoutMs = deps.registrationTimeoutMs ?? resolveSpawnRegistrationTimeoutMs();
+  const schedulerCommandSlots = new Semaphore(deps.maxConcurrentSchedulerCommands ?? resolveMaxConcurrentSchedulerCommands());
+  const schedulerCommandMaxOutputBytes = deps.schedulerCommandMaxOutputBytes ?? resolveSchedulerCommandMaxOutputBytes();
   // Backgrounded spawn tasks: each is claimed synchronously (status → accepted)
   // then runs to completion off the poll tick, holding a slot across the child's
   // registration window. Tracked so tests/shutdown can observe and settle them.
   const backgroundSpawns = new Set<Promise<void>>();
+  const backgroundCommands = new Set<Promise<void>>();
 
   async function spawnManagedAgent(opts: SpawnOptions, action = "Spawned"): Promise<ManagedAgentReport> {
     const agent = await dispatchSpawn(opts, config);
@@ -272,9 +294,69 @@ export function createControlHandler(
     // per-host cap (see dispatchSpawnCommand). Every other command is handled
     // inline, synchronously with the poll tick, exactly as before.
     if (command.type === "agent.spawn") return dispatchSpawnCommand(command);
+    if (command.type === "scheduler.command") return dispatchSchedulerCommand(command);
     return handleNonSpawnCommand(command);
   }
 
+  async function dispatchSchedulerCommand(command: RelayCommand): Promise<boolean> {
+    await relay.updateCommand(command.id, "accepted");
+    const startedAt = Date.now();
+    const run = (async () => {
+      await schedulerCommandSlots.acquire();
+      try {
+        await relay.updateCommand(command.id, "running");
+        const commandText = typeof command.params.command === "string" ? command.params.command : "";
+        const cwd = typeof command.params.cwd === "string" ? command.params.cwd : config.baseDir;
+        if (!commandText.trim()) throw new Error("scheduler.command missing command");
+        if (!isPathWithinBase(cwd, config.baseDir)) throw new Error("scheduler.command cwd escapes orchestrator baseDir");
+        const timeoutMs = typeof command.params.timeoutMs === "number" && Number.isSafeInteger(command.params.timeoutMs) && command.params.timeoutMs > 0
+          ? command.params.timeoutMs
+          : undefined;
+        const env = isRecord(command.params.env)
+          ? Object.fromEntries(Object.entries(command.params.env).filter((entry): entry is [string, string] => typeof entry[1] === "string"))
+          : undefined;
+        const result = await execProcess(["bash", "-lc", commandText], {
+          cwd,
+          env: { ...process.env, ...(env ?? {}) },
+          timeoutMs,
+          timeoutLabel: `scheduler command ${command.id}`,
+          trimStdout: false,
+          trimStderr: false,
+          maxOutputBytes: schedulerCommandMaxOutputBytes,
+          // #968 hole 2 — reap the whole tree on every exit path so a backgrounded/daemonized
+          // child (e.g. `setsid … &`) can't survive after the command returns.
+          reapProcessGroup: true,
+        });
+        const finishedAt = Date.now();
+        await relay.updateCommand(command.id, result.ok ? "succeeded" : result.timedOut ? "timed_out" : "failed", {
+          command: commandText,
+          cwd,
+          startedAt,
+          finishedAt,
+          durationMs: finishedAt - startedAt,
+          exitCode: result.exitCode,
+          success: result.ok,
+          timedOut: result.timedOut === true,
+          stdoutTail: result.stdout,
+          stderrTail: result.stderr,
+          outputTruncated: result.outputTruncated === true,
+          outputLimitExceeded: result.outputLimitExceeded === true,
+        }, result.ok ? undefined : result.stderr || `command exited ${result.exitCode ?? "without code"}`);
+      } catch (error) {
+        await relay.updateCommand(command.id, "failed", {
+          startedAt,
+          finishedAt: Date.now(),
+          durationMs: Date.now() - startedAt,
+        }, errMessage(error));
+      } finally {
+        schedulerCommandSlots.release();
+      }
+    })();
+    backgroundCommands.add(run);
+    run.finally(() => backgroundCommands.delete(run));
+    return true;
+  }
+
   async function handleNonSpawnCommand(command: RelayCommand): Promise<boolean> {
     await relay.updateCommand(command.id, "accepted");
     await relay.updateCommand(command.id, "running");

package/src/process.ts

@@ -1,9 +1,14 @@
+import { mkdirSync, readFileSync, rmdirSync, writeFileSync } from "node:fs";
+import { isPidAlive, killPid, processTreePids, waitForPidsExit } from "agent-relay-sdk/process-utils";
+
 export interface ExecResult {
   ok: boolean;
   exitCode: number | null;
   stdout: string;
   stderr: string;
   timedOut?: boolean;
+  outputTruncated?: boolean;
+  outputLimitExceeded?: boolean;
 }
 
 interface ExecOptions {
@@ -16,31 +21,117 @@ interface ExecOptions {
   timeoutMs?: number;
   timeoutLabel?: string;
   streamDrainGraceMs?: number;
+  maxOutputBytes?: number;
   signal?: AbortSignal;
+  /** Reap ALL descendants on EVERY exit path — normal exit included — not just on timeout/abort
+   * (#968 hole 2). Set for scheduler commands, which may background/daemonize children that would
+   * otherwise outlive the parent shell. On Linux this confines the command to a dedicated cgroup v2
+   * and kills the whole cgroup (bulletproof: a `setsid`-detached child cannot escape cgroup
+   * membership); elsewhere it falls back to a detached process-group + descendant-tree kill. */
+  reapProcessGroup?: boolean;
 }
 
 const DEFAULT_STREAM_DRAIN_GRACE_MS = 1_000;
+const DEFAULT_KILL_GRACE_MS = 1_000;
+
+let commandCgroupSeq = 0;
+
+/** Create a dedicated child cgroup (v2) for a command so its entire process tree — including any
+ * `setsid`-detached grandchildren that reparent away and escape the process group — can be reaped
+ * in one shot via `cgroup.kill`. Returns the new cgroup's absolute path, or undefined when cgroup v2
+ * isn't available/writable (non-Linux, cgroup v1, or missing delegation) so callers fall back. */
+function createCommandCgroup(): string | undefined {
+  if (process.platform !== "linux") return undefined;
+  try {
+    const self = readFileSync("/proc/self/cgroup", "utf8").trim();
+    const idx = self.indexOf("::"); // cgroup v2 line: "0::/rel/path"
+    if (idx < 0) return undefined;
+    const rel = self.slice(idx + 2).trim();
+    const path = `/sys/fs/cgroup${rel}/arcmd-${process.pid}-${Date.now()}-${commandCgroupSeq++}`;
+    mkdirSync(path);
+    return path;
+  } catch {
+    return undefined;
+  }
+}
+
+function cgroupPids(cgPath: string): number[] {
+  try {
+    return readFileSync(`${cgPath}/cgroup.procs`, "utf8")
+      .split("\n")
+      .map((line) => Number(line.trim()))
+      .filter((pid) => Number.isFinite(pid) && pid > 0);
+  } catch {
+    return [];
+  }
+}
+
+/** Kill every process in the command's cgroup and remove the cgroup. `cgroup.kill` SIGKILLs the
+ * whole subtree atomically; we then wait out any lingering PID-table entries and rmdir (retrying
+ * a few times, never hanging) so we don't leak an empty cgroup dir. */
+async function reapCommandCgroup(cgPath: string): Promise<void> {
+  try { writeFileSync(`${cgPath}/cgroup.kill`, "1"); } catch {}
+  await waitForPidsExit(cgroupPids(cgPath), DEFAULT_KILL_GRACE_MS);
+  for (const pid of cgroupPids(cgPath)) killPid(pid, "SIGKILL");
+  for (let attempt = 0; attempt < 5; attempt++) {
+    try { rmdirSync(cgPath); return; } catch {}
+    await sleep(50);
+  }
+}
+
+/** Fallback reaper for hosts without cgroup v2: the command was spawned detached (its own process
+ * group, pgid === proc.pid), so signal the whole group plus any still-living descendants. Reuses the
+ * shared process helpers. NOTE: a `setsid`-detached child escapes the process group entirely — only
+ * the cgroup path above reaps those; this is the best achievable without cgroups. */
+async function reapDetachedProcessGroup(proc: Bun.Subprocess): Promise<void> {
+  try { process.kill(-proc.pid, "SIGTERM"); } catch {}
+  const pids = await processTreePids([proc.pid]).catch(() => [proc.pid]);
+  for (const pid of pids) killPid(pid, "SIGTERM");
+  const all = [proc.pid, ...pids];
+  if (await waitForPidsExit(all, DEFAULT_KILL_GRACE_MS)) return;
+  try { process.kill(-proc.pid, "SIGKILL"); } catch {}
+  for (const pid of all.filter(isPidAlive)) killPid(pid, "SIGKILL");
+}
 
 interface StreamCapture {
   done: Promise<void>;
   text(): string;
+  truncated(): boolean;
+  limitExceeded(): boolean;
   cancel(): void;
 }
 
-function captureStream(stream: ReadableStream<Uint8Array> | undefined): StreamCapture {
-  if (!stream) return { done: Promise.resolve(), text: () => "", cancel: () => {} };
+function captureStream(
+  stream: ReadableStream<Uint8Array> | undefined,
+  options: { maxOutputBytes?: number; onLimitExceeded?: () => void } = {},
+): StreamCapture {
+  if (!stream) return { done: Promise.resolve(), text: () => "", truncated: () => false, limitExceeded: () => false, cancel: () => {} };
   const reader = stream.getReader();
   const decoder = new TextDecoder();
   let output = "";
   let canceled = false;
+  let truncated = false;
+  let limitExceeded = false;
   const done = (async () => {
     try {
       while (!canceled) {
         const chunk = await reader.read();
         if (chunk.done) break;
         output += decoder.decode(chunk.value, { stream: true });
+        if (options.maxOutputBytes && output.length > options.maxOutputBytes) {
+          truncated = true;
+          output = output.slice(output.length - options.maxOutputBytes);
+          if (!limitExceeded) {
+            limitExceeded = true;
+            options.onLimitExceeded?.();
+          }
+        }
       }
       output += decoder.decode();
+      if (options.maxOutputBytes && output.length > options.maxOutputBytes) {
+        truncated = true;
+        output = output.slice(output.length - options.maxOutputBytes);
+      }
     } catch {
       // Intentional cancellation on process timeout or a stuck post-exit pipe.
     } finally {
@@ -50,6 +141,8 @@ function captureStream(stream: ReadableStream<Uint8Array> | undefined): StreamCa
   return {
     done,
     text: () => output,
+    truncated: () => truncated,
+    limitExceeded: () => limitExceeded,
     cancel: () => {
       canceled = true;
       void reader.cancel().catch(() => {});
@@ -74,35 +167,69 @@ function abortMessage(cmd: string[], options: ExecOptions): string {
   return `${label} aborted`;
 }
 
+async function terminateProcessTree(proc: Bun.Subprocess): Promise<void> {
+  const pids = await processTreePids([proc.pid]).catch(() => [proc.pid]);
+  for (const target of pids) killPid(target, "SIGTERM");
+  try { proc.kill("SIGTERM"); } catch {}
+  const exited = await waitForPidsExit(pids, DEFAULT_KILL_GRACE_MS);
+  const alive = exited ? [] : pids.filter(isPidAlive);
+  for (const target of alive) killPid(target, "SIGKILL");
+  if (alive.includes(proc.pid)) {
+    try { proc.kill("SIGKILL"); } catch {}
+  }
+  if (alive.length > 0) await waitForPidsExit(alive, DEFAULT_KILL_GRACE_MS);
+}
+
 export async function execProcess(cmd: string[], options: ExecOptions = {}): Promise<ExecResult> {
   if (options.signal?.aborted) {
     return { ok: false, exitCode: null, stdout: "", stderr: abortMessage(cmd, options) };
   }
-  const proc = Bun.spawn(cmd, {
+  // #968 hole 2 — for reap-on-every-exit commands, confine the whole tree to a dedicated cgroup so a
+  // `setsid`-detached child can't survive the parent. The wrapper joins the cgroup (writes its own
+  // pid to cgroup.procs) BEFORE exec-ing the real command, so every descendant is a member from birth
+  // (race-free); `exec "$0" "$@"` passes the original argv through untouched.
+  const cgroup = options.reapProcessGroup ? createCommandCgroup() : undefined;
+  const spawnCmd = cgroup
+    ? ["sh", "-c", `echo $$ > ${cgroup}/cgroup.procs 2>/dev/null || true; exec "$0" "$@"`, ...cmd]
+    : cmd;
+  const proc = Bun.spawn(spawnCmd, {
     cwd: options.cwd,
     env: options.env,
     stdin: "ignore",
     stdout: options.stdout ?? "pipe",
     stderr: options.stderr ?? "pipe",
+    // Own process group so the fallback reaper can group-signal without touching the orchestrator.
+    ...(options.reapProcessGroup ? { detached: true } : {}),
   });
-  const stdoutCapture = options.stdout === "ignore" ? captureStream(undefined) : captureStream(proc.stdout);
-  const stderrCapture = options.stderr === "ignore" ? captureStream(undefined) : captureStream(proc.stderr);
   let timedOut = false;
   let aborted = false;
+  let outputLimitExceeded = false;
+  let abortStarted = false;
   let timeout: ReturnType<typeof setTimeout> | undefined;
-  let killTimeout: ReturnType<typeof setTimeout> | undefined;
   let timeoutResolve: ((value: null) => void) | undefined;
   const timeoutPromise = new Promise<null>((resolve) => { timeoutResolve = resolve; });
-  const abortProcess = () => {
+  let abortDone: Promise<void> = Promise.resolve();
+  const abortProcess = (killParentImmediately = false) => {
+    if (abortStarted) return;
+    abortStarted = true;
     aborted = true;
-    try { proc.kill("SIGTERM"); } catch {}
-    killTimeout = setTimeout(() => {
-      try { proc.kill("SIGKILL"); } catch {}
-    }, 1_000);
-    killTimeout.unref?.();
-    timeoutResolve?.(null);
+    if (killParentImmediately) {
+      try { proc.kill("SIGTERM"); } catch {}
+    }
+    abortDone = terminateProcessTree(proc).finally(() => timeoutResolve?.(null));
+  };
+  const abortForOutputLimit = () => {
+    outputLimitExceeded = true;
+    abortProcess();
   };
-  options.signal?.addEventListener("abort", abortProcess, { once: true });
+  const stdoutCapture = options.stdout === "ignore"
+    ? captureStream(undefined)
+    : captureStream(proc.stdout, { maxOutputBytes: options.maxOutputBytes, onLimitExceeded: abortForOutputLimit });
+  const stderrCapture = options.stderr === "ignore"
+    ? captureStream(undefined)
+    : captureStream(proc.stderr, { maxOutputBytes: options.maxOutputBytes, onLimitExceeded: abortForOutputLimit });
+  const abortFromSignal = () => abortProcess(true);
+  options.signal?.addEventListener("abort", abortFromSignal, { once: true });
   if (options.timeoutMs && options.timeoutMs > 0) {
     timeout = setTimeout(() => {
       timedOut = true;
@@ -112,10 +239,10 @@ export async function execProcess(cmd: string[], options: ExecOptions = {}): Pro
   }
 
   const exitCode = await (timeout || options.signal ? Promise.race([proc.exited, timeoutPromise]) : proc.exited);
-  options.signal?.removeEventListener("abort", abortProcess);
+  options.signal?.removeEventListener("abort", abortFromSignal);
   if (timeout) clearTimeout(timeout);
-  if (!timedOut && !aborted && killTimeout) clearTimeout(killTimeout);
   if (timedOut || aborted) {
+    await abortDone;
     stdoutCapture.cancel();
     stderrCapture.cancel();
   }
@@ -125,20 +252,32 @@ export async function execProcess(cmd: string[], options: ExecOptions = {}): Pro
   stdoutCapture.cancel();
   stderrCapture.cancel();
 
+  // #968 hole 2 — reap the command's whole process tree on EVERY exit path (normal exit included),
+  // so a backgrounded/daemonized child can't outlive the command. Runs regardless of exit reason.
+  if (options.reapProcessGroup) {
+    if (cgroup) await reapCommandCgroup(cgroup);
+    else await reapDetachedProcessGroup(proc);
+  }
+
   const stdout = stdoutCapture.text();
   let stderr = stderrCapture.text();
   if (timedOut) {
     const msg = timeoutMessage(cmd, options);
     stderr = stderr ? `${stderr}\n${msg}` : msg;
+  } else if (outputLimitExceeded) {
+    const msg = `output exceeded ${options.maxOutputBytes} bytes`;
+    stderr = stderr ? `${stderr}\n${msg}` : msg;
   } else if (aborted) {
     const msg = abortMessage(cmd, options);
     stderr = stderr ? `${stderr}\n${msg}` : msg;
   }
   return {
-    ok: !timedOut && !aborted && exitCode === 0,
+    ok: !timedOut && !aborted && !outputLimitExceeded && exitCode === 0,
     exitCode,
     stdout: options.trimStdout === false ? stdout : stdout.trim(),
     stderr: options.trimStderr === false ? stderr : stderr.trim(),
     ...(timedOut ? { timedOut } : {}),
+    ...(stdoutCapture.truncated() || stderrCapture.truncated() ? { outputTruncated: true } : {}),
+    ...(outputLimitExceeded ? { outputLimitExceeded: true } : {}),
   };
 }

package/src/shared-callmux.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { errMessage, isRecord } from "agent-relay-sdk";
+import { errMessage, isRecord, SHARED_CALLMUX_TOOL_CALL_TIMEOUT_MS } from "agent-relay-sdk";
 import { createListener, type CallmuxConfig, type CreateListenerOptions, type ListenerHealthSnapshot, type ProgrammaticListener } from "callmux";
 import type { OrchestratorConfig } from "./config";
 import { agentRelayHome } from "./config";
@@ -78,14 +78,18 @@ export function sharedMcpListenerUrl(): string {
 export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "configPath" | "sourceConfigPath"> & { registryServers?: CallmuxConfig["servers"] }): CallmuxConfig {
   const source = readJsonObject(opts.sourceConfigPath);
   const sourceServers = isRecord(source.servers) ? source.servers : {};
-  const servers = opts.registryServers && Object.keys(opts.registryServers).length > 0
+  const rawServers = opts.registryServers && Object.keys(opts.registryServers).length > 0
     ? cloneServers(opts.registryServers)
     : fallbackSharedServers(sourceServers);
+  const servers = withSharedCallTimeoutFloor(rawServers);
   const generated: CallmuxConfig = {
     servers,
     cacheTtlSeconds: numberFromRecord(source, "cacheTtlSeconds") ?? 10,
     maxConcurrency: numberFromRecord(source, "maxConcurrency") ?? 20,
-    callTimeoutMs: numberFromRecord(source, "callTimeoutMs") ?? 180_000,
+    callTimeoutMs: Math.max(
+      numberFromRecord(source, "callTimeoutMs") ?? SHARED_CALLMUX_TOOL_CALL_TIMEOUT_MS,
+      SHARED_CALLMUX_TOOL_CALL_TIMEOUT_MS,
+    ),
     outputFormat: outputFormatFromRecord(source, "outputFormat") ?? "auto",
     // Relay workers consume only proxied tokenlean+github tools; suppress callmux meta-tools.
     exposeMetaTools: false,
@@ -305,6 +309,16 @@ function fallbackSharedServers(sourceServers: Record<string, unknown>): CallmuxC
   };
 }
 
+function withSharedCallTimeoutFloor(servers: CallmuxConfig["servers"]): CallmuxConfig["servers"] {
+  return Object.fromEntries(Object.entries(servers).map(([name, server]) => {
+    const callTimeoutMs = Math.max(
+      server.callTimeoutMs ?? SHARED_CALLMUX_TOOL_CALL_TIMEOUT_MS,
+      SHARED_CALLMUX_TOOL_CALL_TIMEOUT_MS,
+    );
+    return [name, { ...server, callTimeoutMs }];
+  }));
+}
+
 function callmuxServerFromProvisioningVariant(value: unknown): { name: string; server: CallmuxConfig["servers"][string] } | null {
   if (!isRecord(value) || value.enabled === false || value.approvalStatus === "pending" || value.validationStatus === "invalid") return null;
   if (typeof value.name !== "string" || !value.name) return null;
@@ -383,7 +397,7 @@ function defaultGithubServer(): CallmuxConfig["servers"][string] {
     command: "github-mcp-server",
     args: ["stdio"],
     prefix: "gh",
-    callTimeoutMs: 60_000,
+    callTimeoutMs: SHARED_CALLMUX_TOOL_CALL_TIMEOUT_MS,
     tools: GITHUB_TOOLS,
     cachePolicy: { allowTools: ["issue_read", "list_issues", "search_issues", "search_code", "get_file_contents"] },
   };