fix(server): unload Codex threads left idle on the shared app-server

[RhysSullivan]

Follow-up to #13331 (item 4) and #14187.

Problem

All Codex threads share one codex app-server, and every loaded native thread runs its own copy of each configured stdio MCP server. Since #14187, a thread is unloaded (thread/unsubscribe) when it detaches: settle, archive, delete, selection change, or handoff. A thread that finishes its turn and is left alone never detaches, so its native thread and MCP servers stay up as long as the shared app-server does. The app-server itself is only released after 30 idle minutes across all threads, which a busy environment rarely reaches.

Delegated tasks hit this constantly. Each delegate_task child is a new thread that runs one turn, completes, and is never settled. On one machine over about 22 hours, T3's provider logs showed 89 thread/start against 5 thread/unsubscribe, and the shared app-server had 1,244 descendant processes using about 28 GB (about 19 MCP servers per native thread, 4 of them stdio).

Fix

ProviderSessionManager now applies its existing idle timeout to each thread on a shared runtime. When a thread's turn ends (turn.terminal, or a failed start) and it has no other busy turn, a per-thread timer starts. If no turn starts within idleTimeoutMs, the thread is unloaded through the same unloadThread (thread/unsubscribe) that detach uses, and its loaded mark is cleared, so the next turn's resume calls thread/resume and reloads it.

• A resume or turn start cancels the pending timer before it checks whether the thread is loaded, so an unload cannot land between a resume that skipped reloading and the turn that relies on it. The unload runs under the per-thread attachment lock, like detach.
• A thread with pending background work (hasPendingBackgroundWorkForThread) stays loaded, because unloading stops Codex background terminals. The timer re-checks after each further idle window.
• Detach drops the timer and unloads the thread itself, as before. Runtimes without unloadThread, and exclusive runtimes, are unaffected.

Evidence

Codex contract. The script below drives codex app-server (codex-cli 0.157.0) directly, with an isolated CODEX_HOME, one stdio MCP server, and thread_unload_delay_secs = 2:

$ node repro.mjs
after 3x thread/start: 3 MCP server processes
thread/unsubscribe -> unsubscribed   (x3)
7s later (unsubscribed): 0 MCP server processes

$ UNSUBSCRIBE=0 node repro.mjs
after 3x thread/start: 3 MCP server processes
7s later (still subscribed): 3 MCP server processes

MCP servers exit if and only if the client unsubscribes, so the cleanup has to come from T3.

Through T3 Code (Nightly 0.0.46-nightly.20261005.2676, macOS), counting descendants of T3's shared app-server:

19:16     descendants: 0
19:17     delegate_task to Codex ("Reply with exactly OK"), completed in ~5s
19:19     descendants: 8      # the child's MCP servers; no thread/unsubscribe sent
19:19:56  settle the child -> T3 sends thread/unsubscribe
19:20:56  Codex emits thread/closed
19:21     descendants: 0

Tests. There are two new tests in ProviderSessionManager.test.ts. Both fail on main and pass with this change.

• unloads a shared-runtime thread left idle, and reloads it on its next turn: a follow-up turn inside the timeout keeps the thread loaded. A full idle timeout after its last turn unloads it, while another thread's running turn keeps the runtime up. The next resume reaches the provider again.
• keeps an idle shared-runtime thread loaded while its background work runs: no unload while the per-thread probe reports pending work; unloaded one idle window after it clears.

Commands run:

• vp test run on ProviderSessionManager.test.ts, CodexAdapterV2.test.ts, ProviderTurnStartService.test.ts, ProviderTurnControlService.test.ts, runtimeLayer.test.ts, EffectWorker.test.ts, BackgroundWorkStop.integration.test.ts, RuntimeRequestService.test.ts, CheckpointRollbackService.test.ts, OpenCode2AdapterV2.test.ts: all passed.
• vp exec tsc --noEmit -p . in apps/server: no errors.
• vp lint on the touched files: clean.

Not checked: a patched server running end to end against a live Codex app-server for the full 30-minute default timeout.

repro.mjs and fake-mcp.mjs

// fake-mcp.mjs
// Minimal stdio MCP server. argv[2] is a marker so the repro can count instances.
import { createInterface } from "node:readline";
const send = (m) => process.stdout.write(JSON.stringify(m) + "\n");
createInterface({ input: process.stdin }).on("line", (line) => {
  const msg = JSON.parse(line);
  if (msg.id === undefined) return;
  if (msg.method === "initialize")
    send({ jsonrpc: "2.0", id: msg.id, result: { protocolVersion: msg.params.protocolVersion, capabilities: { tools: {} }, serverInfo: { name: "fake", version: "0" } } });
  else if (msg.method === "tools/list") send({ jsonrpc: "2.0", id: msg.id, result: { tools: [] } });
  else send({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: "nope" } });
});

// repro.mjs  (CODEX=/path/to/codex node repro.mjs; UNSUBSCRIBE=0 for the control)
// Drives `codex app-server` over stdio: start N threads, unsubscribe them, and
// count the MCP server processes left behind after the unload delay.
import { spawn, execFileSync } from "node:child_process";
import { mkdtempSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, resolve } from "node:path";
import { createInterface } from "node:readline";

const N = Number(process.env.N ?? 3);
const UNSUBSCRIBE = process.env.UNSUBSCRIBE !== "0";
const DELAY = 2;
const marker = `fake-mcp-${process.pid}`;
const home = mkdtempSync(join(tmpdir(), "codex-leak-"));
writeFileSync(join(home, "config.toml"), `thread_unload_delay_secs = ${DELAY}
[mcp_servers.fake]
command = "node"
args = [${JSON.stringify(resolve("fake-mcp.mjs"))}, "${marker}"]
`);

const server = spawn(process.env.CODEX ?? "codex", ["app-server"], {
  env: { ...process.env, CODEX_HOME: home },
  stdio: ["pipe", "pipe", "inherit"],
});
let nextId = 1;
const pending = new Map();
createInterface({ input: server.stdout }).on("line", (line) => {
  const msg = JSON.parse(line);
  if (msg.id !== undefined && pending.has(msg.id)) {
    const { ok, fail } = pending.get(msg.id);
    pending.delete(msg.id);
    msg.error ? fail(new Error(JSON.stringify(msg.error))) : ok(msg.result);
  }
});
const request = (method, params) =>
  new Promise((ok, fail) => {
    const id = nextId++;
    pending.set(id, { ok, fail });
    server.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
  });
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const count = () => {
  try { return execFileSync("pgrep", ["-f", marker]).toString().trim().split("\n").length; }
  catch { return 0; }
};

await request("initialize", { clientInfo: { name: "leak-repro", version: "0" } });
server.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "initialized" }) + "\n");

const threads = [];
for (let i = 0; i < N; i++) {
  const { thread } = await request("thread/start", { cwd: home });
  threads.push(thread.id);
}
await sleep(2000);
console.log(`after ${N}x thread/start: ${count()} MCP server processes`);

if (UNSUBSCRIBE) {
  for (const threadId of threads)
    console.log("thread/unsubscribe ->", (await request("thread/unsubscribe", { threadId })).status);
}
await sleep((DELAY + 5) * 1000);
console.log(`${DELAY + 5}s later (${UNSUBSCRIBE ? "unsubscribed" : "still subscribed"}): ${count()} MCP server processes`);

server.kill();
await sleep(1000);
console.log(`after app-server exit: ${count()}`);
process.exit(0);