@rynx-ai/runtime 0.1.11-beta.34 → 0.1.11-beta.35

package/dist/host.js

@@ -8,7 +8,7 @@ import { buildAgentSkillEnvironment, hashPluginPackageTree, scanSkillsDir, Sessi
 import { getRuntimeProfile, } from "@rynx-ai/core";
 import { resolveRuntimeBinary, } from "@rynx-ai/core";
 import { createCodexChildEnv } from "./codex-child-env.js";
-import { prepareRuntimeHome, populateCodexSkills, runtimeHomePath, } from "./codex-home.js";
+import { applyCodexProviderRetryPolicy, codexLaunchRequiresLogin, prepareRuntimeHome, populateCodexSkills, readCodexDeveloperInstructionsState, runtimeHomePath, syncCodexDeveloperInstructions, trustCodexProject, } from "./codex-home.js";
 import { materializeClaudePlugin, reuseClaudePlugin, } from "./claude/executor.js";
 import { listClaudeModels } from "./claude/models.js";
 import { validateInteractionResolution } from "./interactions.js";
@@ -275,45 +275,6 @@ async function dismissCodexPlanImplementationPrompt(injector, ownsPrompt) {
         return "failed";
     }
 }
-/**
- * The `OPENAI_*` retry env for a codex-lineage app-server spawn, or `undefined`
- * when the budget declares no retry or the runtime is claude. claude applies
- * its retry budget per-run in `buildOptions` (see the claude executor), so it
- * never needs a dedicated app-server.
- */
-export function codexRetryEnv(runtime, budget) {
-    if (runtime === "claude") {
-        return undefined;
-    }
-    const retry = budget?.retry;
-    if (!retry) {
-        return undefined;
-    }
-    const env = {};
-    if (retry.maxRetries != null) {
-        env.OPENAI_MAX_RETRIES = String(retry.maxRetries);
-    }
-    if (retry.timeoutPerRequestSeconds != null) {
-        env.OPENAI_TIMEOUT = String(Math.round(retry.timeoutPerRequestSeconds));
-    }
-    return Object.keys(env).length > 0 ? env : undefined;
-}
-/**
- * The cache key for a runtime backend. A retry budget on a codex-lineage
- * runtime forks a dedicated app-server (its own retry env) under a composite
- * `${runtime}::${hash}` key; everything else shares the base `${runtime}`
- * backend — so budget-less agents keep today's shared-process behaviour.
- */
-function hashRetryEnv(env) {
-    return Object.keys(env)
-        .sort()
-        .map((key) => `${key}=${env[key]}`)
-        .join("&");
-}
-export function codexBackendKey(runtime, budget) {
-    const env = codexRetryEnv(runtime, budget);
-    return env ? `${runtime}::${hashRetryEnv(env)}` : runtime;
-}
 export class LocalAgentHost {
     config;
     sessionStore;
@@ -324,8 +285,6 @@ export class LocalAgentHost {
     // auto-create. The command runner override backs the status probe.
     injectedCommandRunner;
     injectedAppServerClient;
-    clock;
-    backendIdleTtlMs;
     // Builds the SEPARATE forwarder connection for a live codex session (reference implementation's
     // multi-connection model). Defaults to an ExternalWsChannel client attached to
     // the backend's app-server; tests inject a fake.
@@ -337,8 +296,8 @@ export class LocalAgentHost {
     preloadClientFactory;
     /** Builds one short-lived message/interrupt client. */
     injectionClientFactory;
-    // Keyed by `codexBackendKey` — the bare runtime id for budget-less agents, or
-    // a `${runtime}::${retryHash}` composite for a per-agent retry budget.
+    // One backend per runtime. The host belongs to one Session runner, and Codex
+    // retry settings live in that Session's private config rather than process env.
     backends = new Map();
     // The rynx Session this host serves (set from `RYNX_RUNNER_SESSION`).
     sessionId;
@@ -371,7 +330,7 @@ export class LocalAgentHost {
     /** Short-lived dedupe for managed fork notifications delivered after the
      * `thread/fork` response. Values are expected source Provider thread ids. */
     managedForkThreadStarts = new Map();
-    constructor({ config, commandRunner, sessionStore = new FileCodexSessionStore(resolveCodexSessionStorePath(config)), allowedRoots = resolveAllowedRoots(config), appServerClient, now = () => Date.now(), backendIdleTtlMs = 300_000, forwarderClientFactory, preloadClientFactory, injectionClientFactory, sessionId, runtimeHomeSessionId, }) {
+    constructor({ config, commandRunner, sessionStore = new FileCodexSessionStore(resolveCodexSessionStorePath(config)), allowedRoots = resolveAllowedRoots(config), appServerClient, forwarderClientFactory, preloadClientFactory, injectionClientFactory, sessionId, runtimeHomeSessionId, }) {
         this.config = config;
         this.sessionId = sessionId ?? "__default__";
         this.runtimeHomeSessionId = runtimeHomeSessionId ?? this.sessionId;
@@ -380,62 +339,22 @@ export class LocalAgentHost {
         this.defaultRuntime = config.DEFAULT_RUNTIME ?? "codex";
         this.injectedCommandRunner = commandRunner;
         this.injectedAppServerClient = appServerClient;
-        this.clock = now;
-        this.backendIdleTtlMs = backendIdleTtlMs;
         const defaultAttachedClientFactory = (appServerUrl) => new CodexAppServerClient({ channel: new ExternalWsChannel(appServerUrl) });
         this.forwarderClientFactory = forwarderClientFactory ?? defaultAttachedClientFactory;
         this.preloadClientFactory = preloadClientFactory ?? defaultAttachedClientFactory;
         this.injectionClientFactory = injectionClientFactory ?? defaultAttachedClientFactory;
     }
-    getBackend(runtime, budget) {
-        this.reapIdleBackends();
-        // In forced exec mode (the default runtime's injected app-server is null) a
-        // retry budget must NOT fork a composite backend: there is no app-server to
-        // carry the retry env, and forking one would spawn a real app-server and
-        // defeat the forced-exec override. Fall back to the base key — codex retry is
-        // then a no-op in exec mode (consistent with the broader codex-retry caveat).
-        const execMode = runtime === this.defaultRuntime && this.injectedAppServerClient === null;
-        const retryEnv = execMode ? undefined : codexRetryEnv(runtime, budget);
-        const key = retryEnv ? `${runtime}::${hashRetryEnv(retryEnv)}` : runtime;
-        const existing = this.backends.get(key);
-        if (existing) {
-            existing.lastUsedAt = this.clock();
+    getBackend(runtime) {
+        const existing = this.backends.get(runtime);
+        if (existing)
             return existing;
-        }
-        const backend = this.createBackend(runtime, retryEnv);
-        backend.lastUsedAt = this.clock();
-        this.backends.set(key, backend);
+        const backend = this.createBackend(runtime);
+        this.backends.set(runtime, backend);
         return backend;
     }
-    /**
-     * Stop + drop per-budget composite backends that have been idle longer than
-     * the TTL and have no in-flight run. Base per-runtime backends (key === the
-     * bare runtime id) are never reaped — they live for the process lifetime, as
-     * before. There are no per-conversation close hooks, so this lazy sweep (run
-     * on every `getBackend`) is how dedicated app-servers get reclaimed.
-     */
-    reapIdleBackends() {
-        const now = this.clock();
-        for (const [key, backend] of this.backends) {
-            if (!key.includes("::")) {
-                continue;
-            }
-            if ((backend.inFlight ?? 0) > 0 || backend.lastUsedAt === undefined) {
-                continue;
-            }
-            if (now - backend.lastUsedAt < this.backendIdleTtlMs) {
-                continue;
-            }
-            void backend.appServerClient?.stop();
-            this.backends.delete(key);
-        }
-    }
-    createBackend(runtime, retryEnv) {
+    createBackend(runtime) {
         const profile = getRuntimeProfile(runtime);
-        // A composite (per-budget) backend is inherently non-default: it gets a
-        // fresh app-server with the retry env, never the test-injected default deps.
-        const isComposite = retryEnv !== undefined;
-        const isDefault = runtime === this.defaultRuntime && !isComposite;
+        const isDefault = runtime === this.defaultRuntime;
         const commandRunner = (isDefault && this.injectedCommandRunner) ||
             new SpawnCodexCommandRunner(resolveRuntimeBinary(runtime));
         // The claude runtime is not codex-lineage: it has no app-server (its live
@@ -450,7 +369,7 @@ export class LocalAgentHost {
             ? this.injectedAppServerClient === null
                 ? null
                 : this.injectedAppServerClient ?? this.createAppServerClient(runtime)
-            : this.createAppServerClient(runtime, retryEnv);
+            : this.createAppServerClient(runtime);
         return { runtime, profile, appServerClient, commandRunner };
     }
     /** This session's private native home, shared by its app-server + TUI. */
@@ -464,7 +383,7 @@ export class LocalAgentHost {
         this.runtimeHomes.set(runtime, prepared);
         return prepared;
     }
-    createAppServerClient(runtime, extraEnv) {
+    createAppServerClient(runtime) {
         const cliPath = resolveRuntimeBinary(runtime);
         // Per-agent knobs (resolved at live-session start) win over the daemon
         // default — the app-server is private to this session's agent.
@@ -482,7 +401,6 @@ export class LocalAgentHost {
             baseArgs: buildAppServerBaseArgs(sandbox),
             stateDir: runtimeSessionStateDir(this.runtimeHomeSessionId),
             extraEnv: {
-                ...(extraEnv ?? {}),
                 [profile.homeEnvVar]: this.runtimeHome(runtime),
             },
         });
@@ -544,7 +462,7 @@ export class LocalAgentHost {
             const modelChanged = desiredModel !== live.appliedModel;
             const effortChanged = desiredReasoningEffort !== live.appliedReasoningEffort;
             const collaborationMode = mode && live.appliedCollaborationMode !== mode
-                ? await resolveLiveCollaborationMode(client, live, mode)
+                ? await resolveLiveCollaborationMode(client, live, mode, live.runtime === "codex" ? this.runtimeHome(live.runtime) : undefined)
                 : undefined;
             const settings = {
                 threadId,
@@ -600,7 +518,7 @@ export class LocalAgentHost {
             throw new CodexRuntimeError("session snapshots are not live", 409, "session_not_live");
         }
         const runtime = live.runtime;
-        const backend = this.getBackend(runtime, live.execution.budget ?? undefined);
+        const backend = this.getBackend(runtime);
         const client = backend.appServerClient;
         if (!client) {
             throw new CodexRuntimeError(`no app-server for runtime ${runtime}`, 500, "app_server_unavailable");
@@ -620,6 +538,10 @@ export class LocalAgentHost {
         const traexYolo = runtime === "traex" &&
             sandbox === "danger-full-access" &&
             approvalPolicy === "never";
+        // Runner-owned Codex terminals start detached, so nobody can answer the
+        // interactive hook-review prompt. The private CODEX_HOME is provisioned
+        // before launch; use Codex's native bypass flag for this managed TUI.
+        const bypassHookTrust = runtime === "codex" || traexYolo;
         const configOverrides = sandbox === "workspace-write"
             ? ["sandbox_workspace_write.network_access=true"]
             : [];
@@ -637,7 +559,7 @@ export class LocalAgentHost {
         const launchEffort = live.reasoningEffort;
         if (launchEffort)
             configOverrides.push(`model_reasoning_effort=${JSON.stringify(launchEffort)}`);
-        if (live?.instructions) {
+        if (runtime === "traex" && live?.instructions) {
             configOverrides.push(`developer_instructions=${JSON.stringify(live.instructions)}`);
         }
         const profile = getRuntimeProfile(runtime);
@@ -649,7 +571,7 @@ export class LocalAgentHost {
                 remoteUrl,
                 ...(activeThreadId ? { threadId: activeThreadId } : {}),
                 configOverrides,
-                codexArgs: traexYolo ? ["--dangerously-bypass-hook-trust"] : [],
+                codexArgs: bypassHookTrust ? ["--dangerously-bypass-hook-trust"] : [],
                 additionalDirs: providerAdditionalDirs(live.workspace),
             }),
             cwd: live.workspace.cwd,
@@ -748,11 +670,25 @@ export class LocalAgentHost {
                 return false;
             }
         }
-        // Persist the owner's skills before the app-server boots. Fork targets reuse
-        // the owner's immutable copies and never mutate the shared Provider home.
+        // Persist headless project trust before the app-server boots. Fork targets
+        // reuse the owner's immutable Provider home.
         const liveSkills = snapshotSkills.selectedSkills.map((s) => ({ name: s.name, dir: s.dir }));
+        const runtimeHome = this.runtimeHome(runtime);
+        if (runtime === "codex") {
+            try {
+                trustCodexProject(runtimeHome, workspace.cwd);
+                syncCodexDeveloperInstructions(runtimeHome, nativeAuthoredInstructions(execution));
+                applyCodexProviderRetryPolicy(runtimeHome, execution.budget?.retry);
+            }
+            catch (err) {
+                void snapshotSkills.skillsCleanup();
+                this.liveStartupErrors.set(localThreadId, nativeLiveFailure(runtime, "native_project_trust_failed", "project trust preparation failed", err));
+                console.error(`[session-snapshot] session=${localThreadId} project trust preparation failed: ${err instanceof Error ? err.message : String(err)}`);
+                return false;
+            }
+        }
         try {
-            populateCodexSkills(this.runtimeHome(runtime), liveSkills);
+            populateCodexSkills(runtimeHome, liveSkills);
         }
         catch (err) {
             void snapshotSkills.skillsCleanup();
@@ -775,12 +711,19 @@ export class LocalAgentHost {
             return false;
         };
         reapRuntimeProcessesForStateDir(runtimeSessionStateDir(this.runtimeHomeSessionId));
-        const appServerOwner = this.getBackend(runtime, execution.budget ?? undefined).appServerClient;
+        const backend = this.getBackend(runtime);
+        const appServerOwner = backend.appServerClient;
         if (!appServerOwner) {
             this.liveStartupErrors.set(localThreadId, nativeLiveFailure(runtime, "native_app_server_unavailable", "app-server is unavailable for this Session"));
             console.error(`[codex-live] session=${localThreadId} runtime=${runtime} no app-server client`);
             return abandon();
         }
+        let loginRequired;
+        if (!coldResume &&
+            runtime === "codex" &&
+            codexLaunchRequiresLogin(runtimeHome, createCodexChildEnv({ ...process.env, CODEX_HOME: runtimeHome }))) {
+            loginRequired = new CodexRuntimeError("Codex is not signed in and no configured Provider can run this Session, so the Terminal is waiting at the sign-in screen. Sign in from the Session Terminal, then send the message again.", 401, "login_required");
+        }
         try {
             await appServerOwner.ensureInitialized();
         }
@@ -873,12 +816,15 @@ export class LocalAgentHost {
             appliedModel: coldResume ? "" : model,
             appliedReasoningEffort: coldResume ? undefined : reasoningEffort,
             appliedCollaborationMode: undefined,
-            ...(execution.instructions ? { instructions: execution.instructions } : {}),
+            ...(runtime === "traex" && execution.instructions
+                ? { instructions: execution.instructions }
+                : {}),
             threadId: record?.codexSessionId ?? null,
             ready,
             markReady,
             startupFailed,
             markStartupFailed,
+            ...(loginRequired ? { startupError: loginRequired } : {}),
             terminalReady,
             markTerminalReady,
             injectLock: Promise.resolve(),
@@ -1090,7 +1036,7 @@ export class LocalAgentHost {
                         const client = this.injectionClientFactory(live.appServerUrl);
                         try {
                             await client.ensureInitialized();
-                            const collaborationMode = await resolveLiveCollaborationMode(client, live, "default");
+                            const collaborationMode = await resolveLiveCollaborationMode(client, live, "default", live.runtime === "codex" ? this.runtimeHome(live.runtime) : undefined);
                             let threadId = prompt.threadId;
                             let text = CODEX_PLAN_IMPLEMENTATION_CODING_MESSAGE;
                             if (choice === CODEX_PLAN_IMPLEMENTATION_CLEAR_CONTEXT) {
@@ -1458,6 +1404,8 @@ export class LocalAgentHost {
         };
         bindObserverClient(forwarderClient);
         this.liveSessions.set(localThreadId, live);
+        if (loginRequired)
+            this.liveStartupErrors.set(localThreadId, loginRequired);
         forwarder.start();
         // Existing bindings resume through the public app-server API. A fresh thread
         // is created by the native remote TUI instead: its `thread/started`
@@ -1537,12 +1485,19 @@ export class LocalAgentHost {
             console.error(`[codex-live] session=${localThreadId} runtime=${runtime} thread bind failed: ${err instanceof Error ? err.message : String(err)}`);
             return abandon();
         }
-        this.liveStartupErrors.delete(localThreadId);
+        if (!loginRequired)
+            this.liveStartupErrors.delete(localThreadId);
         return true;
     }
     /** Bind a session's codex thread id once known (TUI broadcast or store): persist
      *  it, unblock injection, and kick off the resume-subscribe loop (once). */
     onLiveThreadStarted(live, localThreadId, threadId, forkedFromId) {
+        if (live.startupError?.code === "login_required") {
+            delete live.startupError;
+            if (this.liveStartupErrors.get(localThreadId)?.code === "login_required") {
+                this.liveStartupErrors.delete(localThreadId);
+            }
+        }
         const previousThreadId = live.threadId;
         if (previousThreadId !== threadId) {
             live.threadActive = false;
@@ -1866,6 +1821,8 @@ export class LocalAgentHost {
         const live = this.liveSessions.get(localThreadId);
         if (!live)
             return { outcome: "notLive" };
+        if (live.startupError?.code === "login_required")
+            return { outcome: "notReady" };
         const run = live.injectLock.then(async () => {
             if (live.rotationPending || live.stopped)
                 return { outcome: "failed" };
@@ -1935,7 +1892,7 @@ export class LocalAgentHost {
                 const desiredCollaborationMode = options?.collaborationMode ?? live.execution.collaborationMode;
                 const collaborationMode = desiredCollaborationMode &&
                     desiredCollaborationMode !== live.appliedCollaborationMode
-                    ? await resolveLiveCollaborationMode(injectionClient, live, desiredCollaborationMode)
+                    ? await resolveLiveCollaborationMode(injectionClient, live, desiredCollaborationMode, live.runtime === "codex" ? this.runtimeHome(live.runtime) : undefined)
                     : undefined;
                 const settings = {
                     threadId,
@@ -1990,7 +1947,8 @@ export class LocalAgentHost {
             catch (error) {
                 forgetPendingInput();
                 if (error instanceof CodexRuntimeError &&
-                    error.code === "collaboration_mode_model_unknown") {
+                    (error.code === "collaboration_mode_model_unknown" ||
+                        error.code === "collaboration_mode_instructions_unknown")) {
                     throw error;
                 }
                 // Preserve the app-server's error instead of collapsing every failure
@@ -2145,7 +2103,7 @@ export class LocalAgentHost {
         if (!live)
             return false;
         const turnFailed = error ? live.forwarder.failOpenTurn(error) : false;
-        const backendKey = codexBackendKey(live.runtime, live.execution.budget ?? undefined);
+        const backendKey = live.runtime;
         const backend = this.backends.get(backendKey);
         const appServerOwner = live.appServerOwner;
         this.stopLiveCodexSession(localThreadId);
@@ -2229,8 +2187,8 @@ export class LocalAgentHost {
             ...(live.execution.reasoningEffort
                 ? { reasoningEffort: live.execution.reasoningEffort }
                 : {}),
-            ...(live.execution.instructions
-                ? { appendSystemPrompt: live.execution.instructions }
+            ...(nativeAuthoredInstructions(live.execution)
+                ? { appendSystemPrompt: nativeAuthoredInstructions(live.execution) }
                 : {}),
             additionalDirs: providerAdditionalDirs(live.workspace),
             ...(live.forkIntent
@@ -2894,7 +2852,7 @@ export class LocalAgentHost {
             }
             const runtime = execution.provider;
             const client = live?.appServerOwner ??
-                this.getBackend(runtime, execution.budget ?? undefined).appServerClient;
+                this.getBackend(runtime).appServerClient;
             if (!client) {
                 return { ok: false, reason: "unsupported" };
             }
@@ -3029,7 +2987,7 @@ function adoptResumedThreadSettings(live, settings) {
 /** Resolve the model required by a full collaboration-mode snapshot. Only a
  * fresh thread with no explicit/config model may use the catalog default; a
  * resumed thread must report its own authoritative model. */
-async function resolveLiveCollaborationMode(client, live, mode) {
+async function resolveLiveCollaborationMode(client, live, mode, codexHome) {
     let model = live.model.trim();
     if (!model && live.mayUseProviderDefaultModel) {
         let catalog;
@@ -3048,11 +3006,21 @@ async function resolveLiveCollaborationMode(client, live, mode) {
         }
         model = defaults[0];
     }
-    return buildCollaborationMode(mode, model, live.reasoningEffort);
+    let developerInstructions = null;
+    if (live.runtime === "codex") {
+        const state = codexHome
+            ? readCodexDeveloperInstructionsState(codexHome)
+            : { state: "unreadable" };
+        if (state.state === "unreadable") {
+            throw new CodexRuntimeError("collaboration mode requires the current developer instructions, but the private Codex config could not be read", 503, "collaboration_mode_instructions_unknown");
+        }
+        developerInstructions = state.state === "present" ? state.value : null;
+    }
+    return buildCollaborationMode(mode, model, live.reasoningEffort, developerInstructions);
 }
 /** Expand the public mode enum into the App Server's required settings
  * snapshot using the Session's tracked effective model. */
-function buildCollaborationMode(mode, desiredModel, desiredReasoningEffort) {
+function buildCollaborationMode(mode, desiredModel, desiredReasoningEffort, developerInstructions) {
     const model = desiredModel.trim();
     if (!model) {
         throw new CodexRuntimeError("collaboration mode requires the current model, but the Provider did not report one", 503, "collaboration_mode_model_unknown");
@@ -3062,12 +3030,19 @@ function buildCollaborationMode(mode, desiredModel, desiredReasoningEffort) {
         settings: {
             model,
             reasoning_effort: desiredReasoningEffort ?? null,
-            // `null` asks the App Server to install the built-in instructions for
-            // the selected mode; thread-level Agent instructions remain separate.
-            developer_instructions: null,
+            developer_instructions: developerInstructions,
         },
     };
 }
+/** New snapshots distinguish authored Agent text from framework-rendered
+ * instructions. Older persisted snapshots fall back to their only available
+ * field so existing sessions preserve their launch behavior. */
+function nativeAuthoredInstructions(execution) {
+    const value = execution.authoredInstructions === undefined
+        ? execution.instructions
+        : execution.authoredInstructions;
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
 function sameSessionSnapshots(workspace, execution, opts) {
     return JSON.stringify(stableValue({
         workspace,
@@ -3124,6 +3099,12 @@ function applyClaudePermissionModeSnapshot(settings, permissionMode) {
         permissions.defaultMode = permissionMode;
     else
         delete permissions.defaultMode;
+    if (permissionMode === "bypassPermissions") {
+        next.skipDangerousModePermissionPrompt = true;
+    }
+    else {
+        delete next.skipDangerousModePermissionPrompt;
+    }
     if (Object.keys(permissions).length > 0)
         next.permissions = permissions;
     else

package/dist/runner/child.d.ts

@@ -92,6 +92,7 @@ export declare class RunnerSession {
     private readonly attachmentRoles;
     private readonly traexStartupWatchers;
     private readonly traexStartupGates;
+    private readonly codexStartupMonitors;
     private readonly terminalWatchers;
     /** Opens are async; a close received before attach resolves tombstones the id. */
     private readonly pendingTerminalOpens;

package/dist/runner/child.js

@@ -126,6 +126,7 @@ export class RunnerSession {
     attachmentRoles = new Map();
     traexStartupWatchers = new Map();
     traexStartupGates = new Map();
+    codexStartupMonitors = new Map();
     terminalWatchers = new Map();
     /** Opens are async; a close received before attach resolves tombstones the id. */
     pendingTerminalOpens = new Set();
@@ -528,10 +529,31 @@ export class RunnerSession {
         }
     }
     monitorCodexThreadStartup(localThreadId, runtime, provider) {
+        // Starting (or declining to start) a new monitor invalidates every callback
+        // owned by the previous launch before it can touch the replacement state.
+        this.codexStartupMonitors.delete(localThreadId);
         if (!provider.waitLiveReady)
             return;
+        if (provider.liveSessionFailure?.(localThreadId)?.code === "login_required")
+            return;
+        const expectedTerminal = this.terminals.get(`${localThreadId}-main`);
+        const monitor = Symbol(localThreadId);
+        this.codexStartupMonitors.set(localThreadId, monitor);
+        const claimCurrentLaunch = () => {
+            if (this.codexStartupMonitors.get(localThreadId) !== monitor ||
+                this.terminals.get(`${localThreadId}-main`) !== expectedTerminal)
+                return false;
+            this.codexStartupMonitors.delete(localThreadId);
+            return true;
+        };
         void provider.waitLiveReady(localThreadId, CODEX_THREAD_START_TIMEOUT_MS).then((ready) => {
-            if (ready)
+            if (ready) {
+                if (this.codexStartupMonitors.get(localThreadId) === monitor) {
+                    this.codexStartupMonitors.delete(localThreadId);
+                }
+                return;
+            }
+            if (!claimCurrentLaunch())
                 return;
             const terminal = this.terminals.get(`${localThreadId}-main`);
             const paneFailure = terminal && !terminal.isAlive()
@@ -550,27 +572,30 @@ export class RunnerSession {
                     : `${runtime === "traex" ? "Traex" : "Codex"} TUI did not publish thread/started within ${CODEX_THREAD_START_TIMEOUT_MS / 1_000}s after app-server and observer readiness`);
             this.failCodexThreadStartup(localThreadId, provider, new AgentRuntimeError(detail, 503, paneFailure
                 ? "native_terminal_exited_before_session"
-                : "native_thread_discovery_timeout"));
+                : "native_thread_discovery_timeout"), expectedTerminal);
         }).catch((error) => {
+            if (!claimCurrentLaunch())
+                return;
             this.failCodexThreadStartup(localThreadId, provider, error instanceof AgentRuntimeError
                 ? error
-                : nativePhaseError(runtime, "native_thread_discovery_failed", "native session discovery failed", error));
+                : nativePhaseError(runtime, "native_thread_discovery_failed", "native session discovery failed", error), expectedTerminal);
         });
     }
     /** Discovery failure is terminal for this partial native launch. Publish the
      * exact cause first so an in-flight injection wakes, then drop the observer
      * and TUI so a later task retry creates a clean launch instead of reusing an
      * already-rejected readiness promise. */
-    failCodexThreadStartup(localThreadId, provider, error) {
+    failCodexThreadStartup(localThreadId, provider, error, expectedTerminal) {
         if (!provider.failLiveStartup?.(localThreadId, error))
             return false;
+        this.codexStartupMonitors.delete(localThreadId);
         const watcher = this.terminalWatchers.get(localThreadId);
         if (watcher)
             clearInterval(watcher);
         this.terminalWatchers.delete(localThreadId);
         this.cancelTraexStartupWatcher(localThreadId);
         try {
-            this.terminals.close(`${localThreadId}-main`);
+            this.terminals.close(`${localThreadId}-main`, expectedTerminal);
         }
         catch (closeError) {
             console.warn(`[runner] session=${localThreadId} failed to close native Terminal after startup failure: ${closeError instanceof Error ? closeError.message : String(closeError)}`);
@@ -772,11 +797,11 @@ export class RunnerSession {
                 const runtime = this.liveRuntimes.get(localThreadId);
                 const lifecycle = this.terminals.lifecycle(terminalId);
                 const paneFailure = terminalFailureDetail(terminal.capturePane?.() ?? "");
-                const startupFailed = this.failCodexThreadStartup(localThreadId, this.liveProvider, nativePhaseError(runtime, "native_terminal_exited_before_session", "Terminal exited before native session discovery completed", paneFailure || undefined));
+                const startupFailed = this.failCodexThreadStartup(localThreadId, this.liveProvider, nativePhaseError(runtime, "native_terminal_exited_before_session", "Terminal exited before native session discovery completed", paneFailure || undefined), terminal);
                 if (startupFailed || lifecycle === undefined)
                     return;
                 try {
-                    this.terminals.close(terminalId);
+                    this.terminals.close(terminalId, terminal);
                 }
                 catch (closeError) {
                     console.warn(`[runner] session=${localThreadId} failed to close exited native Terminal: ${closeError instanceof Error ? closeError.message : String(closeError)}`);
@@ -943,6 +968,7 @@ export class RunnerSession {
         for (const timer of this.terminalWatchers.values())
             clearInterval(timer);
         this.terminalWatchers.clear();
+        this.codexStartupMonitors.clear();
         for (const id of this.liveIds) {
             this.liveProvider.stopLiveCodexSession?.(id, {
                 deferClaudeInteractionCleanup: true,

package/dist/terminal/registry.d.ts

@@ -37,8 +37,9 @@ export declare class TerminalRegistry {
         cols?: number;
         rows?: number;
     }): Promise<PrepareResult>;
-    /** Kill a terminal's tmux server and drop it. */
-    close(id: string): void;
+    /** Kill a terminal's tmux server and drop it. When `expected` is supplied,
+     *  close only if that exact instance still owns the id. */
+    close(id: string, expected?: TmuxTerminal): boolean;
     /** Kill every terminal (runner shutdown). */
     closeAll(): void;
 }

package/dist/terminal/registry.js

@@ -71,15 +71,17 @@ export class TerminalRegistry {
         const preparation = await terminal.terminal.prepare(requestedRole, dims);
         return { preparation, role: requestedRole };
     }
-    /** Kill a terminal's tmux server and drop it. */
-    close(id) {
+    /** Kill a terminal's tmux server and drop it. When `expected` is supplied,
+     *  close only if that exact instance still owns the id. */
+    close(id, expected) {
         const entry = this.terminals.get(id);
-        if (!entry)
-            return;
+        if (!entry || (expected && entry.terminal !== expected))
+            return false;
         // Remove the resource before best-effort close so a failed kill cannot
         // leave a dead registry entry that later attaches will reuse.
         this.terminals.delete(id);
         entry.terminal.kill();
+        return true;
     }
     /** Kill every terminal (runner shutdown). */
     closeAll() {