agent-relay-runner 0.129.0 → 0.129.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.129.0",
+  "version": "0.129.2",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {

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.129.0",
+  "version": "0.129.2",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapters/codex-launch-config.ts

@@ -0,0 +1,143 @@
+// Codex launch/config-arg construction: the `-c` override builders, CLI command
+// resolution (shim detection), and the tool-output token limit. Extracted from
+// codex.ts (file-size ratchet, epic #291); codex.ts re-exports these so existing
+// consumers + tests keep their import path.
+import { accessSync, constants, realpathSync } from "node:fs";
+import { basename, join } from "node:path";
+import { isRecord } from "agent-relay-sdk";
+import type { RunnerSpawnConfig } from "../adapter";
+import { tomlString } from "../relay-mcp";
+
+export const DEFAULT_CODEX_TOOL_OUTPUT_TOKEN_LIMIT = 12_000;
+
+// #1248 — default background-terminal poll window (300000ms/5min) is too short for
+// our long-running commands (tests/releases run 5+ min), forcing agents to poll
+// instead of just waiting. Verified against installed codex-cli's source (rust-v0.144.0):
+// `background_terminal_max_timeout` is a top-level Config field — it replaced the older
+// `background_terminal_timeout` key — and IS correctly threaded through: ConfigManager
+// replays these launch `-c` overrides for every thread (config/mod.rs,
+// app-server/src/config_manager.rs), so `UnifiedExecProcessManager` (unified_exec/mod.rs)
+// is built with this raised ceiling and the `write_stdin` handler clamps empty-poll
+// yield_time_ms against it (unified_exec/process_manager.rs). The config value alone does
+// NOT make agents wait longer, though: codex's `write_stdin` tool schema
+// (tools/handlers/shell_spec.rs::create_write_stdin_tool) ships a hardcoded description —
+// "empty polls wait 5000-300000 ms by default" — that never reflects this override, so a
+// model sees no signal it may request more and keeps polling at ~300000ms. That's why a
+// live probe still saw ~300.001s polls after this override landed. codexRelayContextBlock()
+// (codex.ts) tells Codex agents explicitly that they may request yield_time_ms up to this value.
+const CODEX_BACKGROUND_TERMINAL_MAX_TIMEOUT_MS = 900000;
+
+export const CODEX_BACKGROUND_TERMINAL_HINT =
+  `This Codex session's background-terminal poll window is configured to ${CODEX_BACKGROUND_TERMINAL_MAX_TIMEOUT_MS}ms ` +
+  "(15 min), well above the 300000ms ceiling the write_stdin tool's own description advertises. " +
+  "When polling a long-running background command with write_stdin, pass a larger " +
+  `yield_time_ms (up to ${CODEX_BACKGROUND_TERMINAL_MAX_TIMEOUT_MS}) instead of repeatedly ` +
+  "polling at the tool's documented default — it will be honored.";
+
+export function codexModelConfigArgs(model?: string, effort?: string): string[] {
+  const args: string[] = [];
+  if (model) args.push("-c", `model=${tomlString(model)}`);
+  if (effort) args.push("-c", `model_reasoning_effort=${tomlString(effort)}`);
+  return args;
+}
+
+export function codexApprovalConfigArgs(approvalMode?: string): string[] {
+  const sandboxMode = approvalMode === "open"
+    ? "danger-full-access"
+    : approvalMode === "read-only"
+      ? "read-only"
+      : "workspace-write";
+  return [
+    "-c",
+    'approval_policy="never"',
+    "-c",
+    `sandbox_mode=${tomlString(sandboxMode)}`,
+  ];
+}
+
+// #1248 — see CODEX_BACKGROUND_TERMINAL_MAX_TIMEOUT_MS above for why this override
+// is correct but insufficient on its own.
+export function codexManagedConfigArgs(): string[] {
+  return [
+    "-c",
+    "check_for_update_on_startup=false",
+    "-c",
+    `background_terminal_max_timeout=${CODEX_BACKGROUND_TERMINAL_MAX_TIMEOUT_MS}`,
+  ];
+}
+
+export function isCodexCliCommand(command: string): boolean {
+  return basename(command) === "codex";
+}
+
+export function resolveRealCodexCommand(command: string, pathValue = process.env.PATH || ""): string {
+  const candidates: string[] = [];
+  if (command.includes("/")) candidates.push(command);
+  for (const dir of pathValue.split(":").filter(Boolean)) candidates.push(join(dir, "codex"));
+
+  const seen = new Set<string>();
+  for (const candidate of candidates) {
+    if (seen.has(candidate)) continue;
+    seen.add(candidate);
+    if (!isExecutableFile(candidate)) continue;
+    const real = realPath(candidate);
+    if (isAgentRelayCodexShim(candidate) || isAgentRelayCodexShim(real)) continue;
+    return candidate;
+  }
+  return command;
+}
+
+function isExecutableFile(path: string): boolean {
+  try {
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function realPath(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+
+function isAgentRelayCodexShim(path: string): boolean {
+  return path.includes("/.agent-relay/codex/bin/codex");
+}
+
+export function codexAppServerConfigArgs(...argLists: string[][]): string[] {
+  const result: string[] = [];
+  for (const args of argLists) {
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "-c" || arg === "--config" || arg === "--enable" || arg === "--disable") {
+        const value = args[i + 1];
+        if (value !== undefined) {
+          result.push(arg, value);
+          i++;
+        }
+      } else if (arg?.startsWith("--config=") || arg?.startsWith("--enable=") || arg?.startsWith("--disable=")) {
+        result.push(arg);
+      }
+    }
+  }
+  return result;
+}
+
+export function codexToolOutputTokenLimitConfigArgs(config: Pick<RunnerSpawnConfig, "agentProfile">): string[] {
+  const configured = codexToolOutputTokenLimit(config.agentProfile?.providerOptions);
+  if (configured === null) return [];
+  const limit = configured ?? DEFAULT_CODEX_TOOL_OUTPUT_TOKEN_LIMIT;
+  return ["-c", `tool_output_token_limit=${limit}`];
+}
+
+function codexToolOutputTokenLimit(providerOptions: unknown): number | null | undefined {
+  if (!isRecord(providerOptions)) return undefined;
+  const codex = providerOptions.codex;
+  if (!isRecord(codex)) return undefined;
+  const limit = codex.toolOutputTokenLimit;
+  return typeof limit === "number" || limit === null ? limit : undefined;
+}

package/src/adapters/codex-rollout-context.ts

@@ -0,0 +1,120 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ContextState } from "agent-relay-sdk";
+import { isRecord, stringValue } from "agent-relay-sdk";
+import type { ManagedProcess } from "../adapter";
+
+export function codexTokenUsageContext(params: Record<string, unknown> | undefined, now = Date.now()): ContextState | undefined {
+  const usage = isRecord(params?.tokenUsage) ? params.tokenUsage
+    : isRecord(params?.token_usage) ? params.token_usage
+    : isRecord(params?.usage) ? params.usage
+    : isRecord(params?.info) ? params.info
+    : params;
+  if (!usage) return undefined;
+  const total = isRecord(usage.total) ? usage.total
+    : isRecord(usage.totalTokenUsage) ? usage.totalTokenUsage
+    : isRecord(usage.total_token_usage) ? usage.total_token_usage
+    : undefined;
+  const last = isRecord(usage.last) ? usage.last
+    : isRecord(usage.lastTokenUsage) ? usage.lastTokenUsage
+    : isRecord(usage.last_token_usage) ? usage.last_token_usage
+    : undefined;
+  const tokensUsed = numberValue(last?.totalTokens) ?? numberValue(last?.total_tokens) ??
+    numberValue(total?.totalTokens) ?? numberValue(total?.total_tokens) ??
+    numberValue(usage.totalTokens) ?? numberValue(usage.total_tokens);
+  const tokensMax = numberValue(usage.modelContextWindow) ?? numberValue(usage.model_context_window) ??
+    numberValue(params?.modelContextWindow) ?? numberValue(params?.model_context_window);
+  if (tokensUsed === undefined || tokensMax === undefined || tokensMax <= 0) return undefined;
+  return {
+    utilization: Math.max(0, Math.min(1, tokensUsed / tokensMax)),
+    tokensUsed,
+    tokensMax,
+    lifecycleState: "working",
+    warmTopics: [],
+    activeMemories: [],
+    tasksSinceCompact: 0,
+    lastUpdatedAt: now,
+    source: "api",
+    confidence: "reported",
+  };
+}
+
+export function latestCodexContext(process: ManagedProcess): ContextState | undefined {
+  const meta = process.meta ?? {};
+  const current = isContextState(meta.context) ? meta.context : undefined;
+  const explicitPath = stringValue(meta.threadPath);
+  const threadId = stringValue(meta.threadId);
+  const rolloutPath = explicitPath ?? (threadId ? findCodexRolloutPath(threadId) : undefined);
+  if (!rolloutPath) return current;
+  const context = readCodexRolloutContext(rolloutPath);
+  if (!context) return current;
+  process.meta = { ...meta, context, threadPath: rolloutPath };
+  return context;
+}
+
+function readCodexRolloutContext(path: string): ContextState | undefined {
+  try {
+    return codexRolloutContextFromText(readFileSync(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+export function codexRolloutContextFromText(input: string): ContextState | undefined {
+  const lines = input.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]?.trim();
+    if (!line) continue;
+    let event: unknown;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isRecord(event)) continue;
+    const payload = isRecord(event.payload) ? event.payload : undefined;
+    if (payload?.type !== "token_count") continue;
+    const timestamp = typeof event.timestamp === "string" ? Date.parse(event.timestamp) : Date.now();
+    return codexTokenUsageContext(payload, Number.isFinite(timestamp) ? timestamp : Date.now());
+  }
+  return undefined;
+}
+
+function findCodexRolloutPath(threadId: string): string | undefined {
+  const root = join(process.env.CODEX_HOME || join(homedir(), ".codex"), "sessions");
+  return findFileContaining(root, threadId);
+}
+
+function findFileContaining(dir: string, needle: string, depth = 0): string | undefined {
+  if (depth > 8) return undefined;
+  let entries: Array<{ name: string; isFile(): boolean; isDirectory(): boolean }>;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return undefined;
+  }
+  entries.sort((a, b) => b.name.localeCompare(a.name));
+  for (const entry of entries) {
+    const path = join(dir, entry.name);
+    if (entry.isFile() && entry.name.includes(needle) && entry.name.endsWith(".jsonl")) return path;
+    if (entry.isDirectory()) {
+      const found = findFileContaining(path, needle, depth + 1);
+      if (found) return found;
+    }
+  }
+  return undefined;
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+export function isContextState(value: unknown): value is ContextState {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const state = value as Record<string, unknown>;
+  return typeof state.utilization === "number" &&
+    typeof state.lifecycleState === "string" &&
+    typeof state.source === "string" &&
+    typeof state.confidence === "string";
+}

package/src/adapters/codex.ts

@@ -1,6 +1,3 @@
-import { accessSync, constants, existsSync, readFileSync, realpathSync, readdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { basename, join, resolve } from "node:path";
 import type { ContextState, InteractivePrompt, LivenessSignal, Message, MessageTurnEndReason, ProviderState } from "agent-relay-sdk";
 import { isRecord, stringValue } from "agent-relay-sdk";
 import { isPidAlive, killPid, processTreePids, processTreePidsFromTable, waitForPidsExit } from "agent-relay-sdk/process-utils";
@@ -11,18 +8,32 @@ import { assembleLaunch, bundledCodexSkillDirs, bundledSkillConfigArgs, material
 import { logger } from "../logger";
 import type { SessionEvent } from "../session-insights";
 import { CodexAgentMessageCapture } from "./codex-agent-message-capture";
+import { codexTokenUsageContext, isContextState, latestCodexContext } from "./codex-rollout-context";
 import { computeLivenessSignal, type LivenessInputs } from "../liveness";
 
 /** Relay context prepended to a Codex agent's first turn: the standard relay
- * blurb plus, when running in an isolated workspace, the deps caveat (#159). */
+ * blurb plus, when running in an isolated workspace, the deps caveat (#159),
+ * plus the #1248 background-terminal poll-ceiling hint. */
 function codexRelayContextBlock(): string {
-  return [relayContext(), workspaceDepsNoteFromEnv()].filter(Boolean).join("\n\n");
+  return [relayContext(), workspaceDepsNoteFromEnv(), CODEX_BACKGROUND_TERMINAL_HINT].filter(Boolean).join("\n\n");
 }
 import { prepareCodexProfileHome, profileUsesHostProviderGlobals } from "../profile-home";
 import { CodexAppClient, type ClientEvent } from "./codex-client";
+import { CODEX_BACKGROUND_TERMINAL_HINT, codexApprovalConfigArgs, codexAppServerConfigArgs, codexManagedConfigArgs, codexModelConfigArgs, codexToolOutputTokenLimitConfigArgs, isCodexCliCommand, resolveRealCodexCommand } from "./codex-launch-config";
 
 export { processTreePidsFromTable };
-export const DEFAULT_CODEX_TOOL_OUTPUT_TOKEN_LIMIT = 12_000;
+// Launch/config-arg construction lives in ./codex-launch-config; re-exported so
+// codex.ts consumers + tests keep their import path.
+export {
+  codexApprovalConfigArgs,
+  codexAppServerConfigArgs,
+  codexManagedConfigArgs,
+  codexModelConfigArgs,
+  codexToolOutputTokenLimitConfigArgs,
+  DEFAULT_CODEX_TOOL_OUTPUT_TOKEN_LIMIT,
+  isCodexCliCommand,
+  resolveRealCodexCommand,
+} from "./codex-launch-config";
 
 type PendingCodexApproval = {
   id: string;
@@ -1038,107 +1049,6 @@ export function codexProviderStateFromThreadStatus(status: unknown, params?: Rec
   return undefined;
 }
 
-export function codexTokenUsageContext(params: Record<string, unknown> | undefined, now = Date.now()): ContextState | undefined {
-  const usage = isRecord(params?.tokenUsage) ? params.tokenUsage
-    : isRecord(params?.token_usage) ? params.token_usage
-    : isRecord(params?.usage) ? params.usage
-    : isRecord(params?.info) ? params.info
-    : params;
-  if (!usage) return undefined;
-  const total = isRecord(usage.total) ? usage.total
-    : isRecord(usage.totalTokenUsage) ? usage.totalTokenUsage
-    : isRecord(usage.total_token_usage) ? usage.total_token_usage
-    : undefined;
-  const last = isRecord(usage.last) ? usage.last
-    : isRecord(usage.lastTokenUsage) ? usage.lastTokenUsage
-    : isRecord(usage.last_token_usage) ? usage.last_token_usage
-    : undefined;
-  const tokensUsed = numberValue(last?.totalTokens) ?? numberValue(last?.total_tokens) ??
-    numberValue(total?.totalTokens) ?? numberValue(total?.total_tokens) ??
-    numberValue(usage.totalTokens) ?? numberValue(usage.total_tokens);
-  const tokensMax = numberValue(usage.modelContextWindow) ?? numberValue(usage.model_context_window) ??
-    numberValue(params?.modelContextWindow) ?? numberValue(params?.model_context_window);
-  if (tokensUsed === undefined || tokensMax === undefined || tokensMax <= 0) return undefined;
-  return {
-    utilization: Math.max(0, Math.min(1, tokensUsed / tokensMax)),
-    tokensUsed,
-    tokensMax,
-    lifecycleState: "working",
-    warmTopics: [],
-    activeMemories: [],
-    tasksSinceCompact: 0,
-    lastUpdatedAt: now,
-    source: "api",
-    confidence: "reported",
-  };
-}
-
-function latestCodexContext(process: ManagedProcess): ContextState | undefined {
-  const meta = process.meta ?? {};
-  const current = isContextState(meta.context) ? meta.context : undefined;
-  const explicitPath = stringValue(meta.threadPath);
-  const threadId = stringValue(meta.threadId);
-  const rolloutPath = explicitPath ?? (threadId ? findCodexRolloutPath(threadId) : undefined);
-  if (!rolloutPath) return current;
-  const context = readCodexRolloutContext(rolloutPath);
-  if (!context) return current;
-  process.meta = { ...meta, context, threadPath: rolloutPath };
-  return context;
-}
-
-function readCodexRolloutContext(path: string): ContextState | undefined {
-  try {
-    return codexRolloutContextFromText(readFileSync(path, "utf8"));
-  } catch {
-    return undefined;
-  }
-}
-
-export function codexRolloutContextFromText(input: string): ContextState | undefined {
-  const lines = input.split(/\r?\n/);
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i]?.trim();
-    if (!line) continue;
-    let event: unknown;
-    try {
-      event = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (!isRecord(event)) continue;
-    const payload = isRecord(event.payload) ? event.payload : undefined;
-    if (payload?.type !== "token_count") continue;
-    const timestamp = typeof event.timestamp === "string" ? Date.parse(event.timestamp) : Date.now();
-    return codexTokenUsageContext(payload, Number.isFinite(timestamp) ? timestamp : Date.now());
-  }
-  return undefined;
-}
-
-function findCodexRolloutPath(threadId: string): string | undefined {
-  const root = join(process.env.CODEX_HOME || join(homedir(), ".codex"), "sessions");
-  return findFileContaining(root, threadId);
-}
-
-function findFileContaining(dir: string, needle: string, depth = 0): string | undefined {
-  if (depth > 8) return undefined;
-  let entries: Array<{ name: string; isFile(): boolean; isDirectory(): boolean }>;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return undefined;
-  }
-  entries.sort((a, b) => b.name.localeCompare(a.name));
-  for (const entry of entries) {
-    const path = join(dir, entry.name);
-    if (entry.isFile() && entry.name.includes(needle) && entry.name.endsWith(".jsonl")) return path;
-    if (entry.isDirectory()) {
-      const found = findFileContaining(path, needle, depth + 1);
-      if (found) return found;
-    }
-  }
-  return undefined;
-}
-
 function isSubagentThread(thread: Record<string, unknown> | undefined, params: Record<string, unknown> | undefined): boolean {
   if (thread?.threadSource === "subagent" || params?.threadSource === "subagent") return true;
   const source = isRecord(thread?.sessionSource) ? thread.sessionSource : isRecord(params?.sessionSource) ? params.sessionSource : undefined;
@@ -1174,127 +1084,14 @@ function activeFlags(value: unknown): string[] {
   return value.activeFlags.filter((flag): flag is string => typeof flag === "string" && flag.length > 0);
 }
 
-function numberValue(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function isContextState(value: unknown): value is ContextState {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const state = value as Record<string, unknown>;
-  return typeof state.utilization === "number" &&
-    typeof state.lifecycleState === "string" &&
-    typeof state.source === "string" &&
-    typeof state.confidence === "string";
-}
-
-
-export function codexModelConfigArgs(model?: string, effort?: string): string[] {
-  const args: string[] = [];
-  if (model) args.push("-c", `model=${tomlString(model)}`);
-  if (effort) args.push("-c", `model_reasoning_effort=${tomlString(effort)}`);
-  return args;
-}
-
-export function codexApprovalConfigArgs(approvalMode?: string): string[] {
-  const sandboxMode = approvalMode === "open"
-    ? "danger-full-access"
-    : approvalMode === "read-only"
-      ? "read-only"
-      : "workspace-write";
-  return [
-    "-c",
-    'approval_policy="never"',
-    "-c",
-    `sandbox_mode=${tomlString(sandboxMode)}`,
-  ];
-}
-
-export function codexManagedConfigArgs(): string[] {
-  return ["-c", "check_for_update_on_startup=false"];
-}
-
-export function isCodexCliCommand(command: string): boolean {
-  return basename(command) === "codex";
-}
-
-export function resolveRealCodexCommand(command: string, pathValue = process.env.PATH || ""): string {
-  const candidates: string[] = [];
-  if (command.includes("/")) candidates.push(command);
-  for (const dir of pathValue.split(":").filter(Boolean)) candidates.push(join(dir, "codex"));
-
-  const seen = new Set<string>();
-  for (const candidate of candidates) {
-    if (seen.has(candidate)) continue;
-    seen.add(candidate);
-    if (!isExecutableFile(candidate)) continue;
-    const real = realPath(candidate);
-    if (isAgentRelayCodexShim(candidate) || isAgentRelayCodexShim(real)) continue;
-    return candidate;
-  }
-  return command;
-}
-
-function isExecutableFile(path: string): boolean {
-  try {
-    accessSync(path, constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function realPath(path: string): string {
-  try {
-    return realpathSync(path);
-  } catch {
-    return path;
-  }
-}
-
-function isAgentRelayCodexShim(path: string): boolean {
-  return path.includes("/.agent-relay/codex/bin/codex");
-}
-
 // #557 — bundledCodexSkillDirs + bundledSkillConfigArgs now live in ../launch-assembly
 // (the single launch-arg home, shared with the assembler); re-exported so existing
 // codex.ts consumers + tests keep their import path. tomlString likewise from ../relay-mcp.
 export { bundledCodexSkillDirs, bundledSkillConfigArgs };
 export { tomlString };
-
-export function codexAppServerConfigArgs(...argLists: string[][]): string[] {
-  const result: string[] = [];
-  for (const args of argLists) {
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-      if (arg === "-c" || arg === "--config" || arg === "--enable" || arg === "--disable") {
-        const value = args[i + 1];
-        if (value !== undefined) {
-          result.push(arg, value);
-          i++;
-        }
-      } else if (arg?.startsWith("--config=") || arg?.startsWith("--enable=") || arg?.startsWith("--disable=")) {
-        result.push(arg);
-      }
-    }
-  }
-  return result;
-}
-
-export function codexToolOutputTokenLimitConfigArgs(config: Pick<RunnerSpawnConfig, "agentProfile">): string[] {
-  const configured = codexToolOutputTokenLimit(config.agentProfile?.providerOptions);
-  if (configured === null) return [];
-  const limit = configured ?? DEFAULT_CODEX_TOOL_OUTPUT_TOKEN_LIMIT;
-  return ["-c", `tool_output_token_limit=${limit}`];
-}
-
-function codexToolOutputTokenLimit(providerOptions: unknown): number | null | undefined {
-  if (!isRecord(providerOptions)) return undefined;
-  const codex = providerOptions.codex;
-  if (!isRecord(codex)) return undefined;
-  const limit = codex.toolOutputTokenLimit;
-  return typeof limit === "number" || limit === null ? limit : undefined;
-}
-
+// Rollout/token-usage context parsing lives in ./codex-rollout-context; re-exported
+// so codex.ts consumers + tests keep their import path.
+export { codexTokenUsageContext, codexRolloutContextFromText } from "./codex-rollout-context";
 
 async function connectWithRetry(client: CodexAppClient, attempts = 40): Promise<void> {
   // Give the freshly-spawned app-server a moment to bind its socket before the

package/src/relay-mcp.ts

@@ -41,6 +41,23 @@ export function relayMcpEndpoint(relayUrl: string): string {
   return `${relayUrl.replace(/\/+$/, "")}${RELAY_MCP_PATH}`;
 }
 
+// #1248 — per-server Codex MCP overrides. Default `tool_timeout_sec` (60s) and
+// `startup_timeout_ms` are too short for our long-running tools (tests/releases run
+// 5+ min), forcing agents to poll/sleep instead of just waiting on the call. Verified
+// against the installed codex-cli binary (0.144.0): both fields live on the
+// per-`[mcp_servers.<name>]` McpServerConfig struct, alongside `bearer_token_env_var`.
+export const CODEX_MCP_TOOL_TIMEOUT_SEC = 900;
+export const CODEX_MCP_STARTUP_TIMEOUT_MS = 30000;
+
+function codexTimeoutConfigArgs(key: string): string[] {
+  return [
+    "-c",
+    `${key}.tool_timeout_sec=${CODEX_MCP_TOOL_TIMEOUT_SEC}`,
+    "-c",
+    `${key}.startup_timeout_ms=${CODEX_MCP_STARTUP_TIMEOUT_MS}`,
+  ];
+}
+
 // Codex: `-c mcp_servers.<name>.*` overrides. `bearer_token_env_var` tells Codex to
 // read the token from the env var itself → transport resolves to streamable_http.
 // `endpoint` overrides the target URL (runner-local proxy, Stage 2 #215) — see above.
@@ -51,6 +68,7 @@ export function relayMcpCodexConfigArgs(relayUrl: string, endpoint?: string): st
     `${key}.url=${tomlString(endpoint ?? relayMcpEndpoint(relayUrl))}`,
     "-c",
     `${key}.bearer_token_env_var=${tomlString(RELAY_MCP_TOKEN_ENV)}`,
+    ...codexTimeoutConfigArgs(key),
   ];
 }
 
@@ -151,6 +169,7 @@ export function codexProvisionedMcpArgs(servers?: Record<string, ProvisioningMcp
     for (const [envKey, envVal] of Object.entries(server.env ?? {})) {
       args.push("-c", `${key}.env.${envKey}=${tomlString(envVal)}`);
     }
+    args.push(...codexTimeoutConfigArgs(key)); // #1248
   }
   return args;
 }