@rynx-ai/runtime 0.1.11-beta.21 → 0.1.11-beta.23

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export type { CodexCapabilities, CapabilityResult, CodexRuntimeStatus, } from ".
 export type { ClaudeForkIntent, CodexSessionStore, CodexSessionRecord, } from "./codex-session-store.js";
 export { RunnerManager, TerminalOpenError } from "./runner/manager.js";
 export type { RunnerManagerOptions, RunnerSessionContext, RunnerSessionContextProvider, OpenTerminalOptions, ParentTerminal, } from "./runner/manager.js";
-export type { InjectOutcome, TerminalOpenErrorCode, TerminalRole } from "./runner/protocol.js";
+export type { InjectOutcome, InjectResult, TerminalOpenErrorCode, TerminalRole } from "./runner/protocol.js";
 export type { ResolveInteractionResult, RuntimeInteractionEvent, RuntimeInteractionListener, } from "./interactions.js";
 export { probeRuntimeStatus } from "./runtime-status.js";
 export { listRuntimeModels } from "./models-catalog.js";

package/dist/runner/child.d.ts

@@ -7,11 +7,11 @@
  * per-thread capabilities, answered against the same backend so the parent never
  * needs an app-server of its own.
  */
-import { type AgentCapabilities, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+import { type AgentCapabilities, type LiveSessionFailure, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
 import type { SessionEvent } from "@rynx-ai/core";
 import type { TerminalInjector } from "../claude/native-integration.js";
 import type { ResolveInteractionResult } from "../interactions.js";
-import { type InjectOutcome } from "./protocol.js";
+import { type InjectResult } from "./protocol.js";
 import type { ChildTransport } from "./transport.js";
 /** Re-target the mirror to a freshly minted rynx session (claude `/clear`·`/fork`)
  *  + record the terminal transfer with the daemon. The child owns the transport,
@@ -38,14 +38,23 @@ interface LiveCodexProvider {
         execution: ResolvedExecutionSnapshot;
         retargetMirror?: RetargetMirror;
     }): Promise<boolean>;
+    /** Known-thread Codex/Traex resume only: start the independent transcript
+     * observer after the replacement TUI has launched. Fresh discovery connects
+     * its listener before launch and this method is an idempotent no-op. */
+    startLiveCodexObserver?(localThreadId: string): void;
     /** `null` delegates the deadline to RunnerManager. */
     waitLiveReady?(localThreadId: string, timeoutMs?: number | null): Promise<boolean>;
     /** `null` delegates the deadline to RunnerManager. */
     waitTerminalReady?(localThreadId: string, timeoutMs?: number | null): Promise<boolean>;
     liveSessionError?(localThreadId: string): string | undefined;
+    liveSessionFailure?(localThreadId: string): LiveSessionFailure | undefined;
     failLiveStartup?(localThreadId: string, error: Error): boolean;
     failLiveSession?(localThreadId: string, error: Error): boolean;
-    injectMessage?(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
+    /** Codex/Traex auxiliary Terminal lifecycle: settle the current Turn, stop
+     * observer/forwarder, and evict the owned app-server while preserving the
+     * durable native-session binding for a later cold resume. */
+    teardownLiveCodexSession?(localThreadId: string, error?: Error): boolean;
+    injectMessage?(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectResult>;
     interruptLive?(localThreadId: string): Promise<boolean>;
     stopLiveCodexSession?(localThreadId: string, opts?: {
         deferClaudeInteractionCleanup?: boolean;
@@ -84,6 +93,8 @@ export declare class RunnerSession {
     private readonly cancelledTerminalOpens;
     /** Session ids with a live codex forwarder started here (stopped on shutdown). */
     private readonly liveIds;
+    /** Provider name retained for asynchronous Terminal-exit diagnostics. */
+    private readonly liveRuntimes;
     private shuttingDown;
     constructor({ transport, executor, onShutdown }: RunnerSessionDeps);
     private handle;
@@ -96,10 +107,10 @@ export declare class RunnerSession {
      *  the new session stays injectable. */
     private mirrorChannel;
     /**
-     * Eagerly bring up a session's codex-native live view: start the persistent
-     * observer connection before launching the detached Codex TUI. Fresh-session
-     * thread discovery then continues in the background while the first
-     * injection waits for the same bridge state.
+     * Eagerly bring up a session's codex-native live view. Fresh sessions connect
+     * the discovery listener before launching the detached TUI; known-thread
+     * resumes preload first, launch the replacement TUI, then start their
+     * persistent observer in the background.
      */
     private ensureLive;
     private monitorCodexThreadStartup;

package/dist/runner/child.js

@@ -1,8 +1,48 @@
+/**
+ * Child-side runner session. One per runner process (i.e. per session); owns the
+ * single execution backend via the injected executor (a {@link LocalAgentHost}
+ * in production, which in a per-session process holds exactly one backend). It
+ * translates inbound {@link ToChild} control messages into the live co-drive
+ * surface (bring up the session's forwarder + TUI, inject / interrupt turns) and
+ * per-thread capabilities, answered against the same backend so the parent never
+ * needs an app-server of its own.
+ */
+import { AgentRuntimeError, } from "@rynx-ai/core";
 import { TerminalRegistry } from "../terminal/registry.js";
-import { toWireError } from "./protocol.js";
-import { isManagedNativeProvider } from "./startup-policy.js";
+import { toWireError, } from "./protocol.js";
+import { isCodexLineageProvider } from "./startup-policy.js";
 /** Maximum time for a fresh Codex-lineage TUI to publish its native thread. */
 const CODEX_THREAD_START_TIMEOUT_MS = 30_000;
+function providerDisplayName(runtime) {
+    return runtime === "traex" ? "Traex" : runtime === "claude" ? "Claude" : "Codex";
+}
+function providerFailure(provider, localThreadId, fallback) {
+    return provider.liveSessionFailure?.(localThreadId) ?? {
+        message: provider.liveSessionError?.(localThreadId) ?? fallback.message,
+        code: fallback.code,
+        statusCode: 503,
+    };
+}
+function nativePhaseError(runtime, code, phase, cause) {
+    const detail = cause === undefined
+        ? ""
+        : `: ${cause instanceof Error ? cause.message : String(cause)}`;
+    return new AgentRuntimeError(`${providerDisplayName(runtime)} ${phase}${detail}`, 503, code);
+}
+function terminalFailureDetail(pane) {
+    // A captured pane is a screen snapshot, not stderr. Do not present ordinary
+    // TUI chrome ("Working", shortcuts, model/status bars) as the process's exit
+    // cause. Retain only lines that plausibly carry an actual startup/runtime
+    // failure; the structured error still reports the proven pane exit itself.
+    return pane
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .filter((line) => /\b(?:error|fatal|failed|failure|panic|refused|denied|unauthorized|invalid)\b/i.test(line))
+        .slice(-6)
+        .join(" ")
+        .slice(-1_000);
+}
 const TRAEX_STARTUP_WATCH_MS = 20_000;
 const TRAEX_STARTUP_POLL_MS = 100;
 const TRAEX_AUTHORIZATION_POLL_MS = 500;
@@ -38,6 +78,8 @@ export class RunnerSession {
     cancelledTerminalOpens = new Set();
     /** Session ids with a live codex forwarder started here (stopped on shutdown). */
     liveIds = new Set();
+    /** Provider name retained for asynchronous Terminal-exit diagnostics. */
+    liveRuntimes = new Map();
     shuttingDown = false;
     constructor({ transport, executor, onShutdown }) {
         this.transport = transport;
@@ -159,10 +201,10 @@ export class RunnerSession {
         return { emit, retarget };
     }
     /**
-     * Eagerly bring up a session's codex-native live view: start the persistent
-     * observer connection before launching the detached Codex TUI. Fresh-session
-     * thread discovery then continues in the background while the first
-     * injection waits for the same bridge state.
+     * Eagerly bring up a session's codex-native live view. Fresh sessions connect
+     * the discovery listener before launching the detached TUI; known-thread
+     * resumes preload first, launch the replacement TUI, then start their
+     * persistent observer in the background.
      */
     async ensureLive(msg) {
         const provider = this.liveProvider;
@@ -174,34 +216,38 @@ export class RunnerSession {
                 retargetMirror: retarget,
             });
             if (!started) {
+                const runtime = msg.execution?.provider;
                 this.transport.send({
                     t: "live.ready",
                     reqId: msg.reqId,
                     localThreadId: msg.localThreadId,
                     ok: false,
-                    error: provider.liveSessionError?.(msg.localThreadId)
-                        ?? "live provider did not start",
+                    error: providerFailure(provider, msg.localThreadId, {
+                        runtime,
+                        code: "native_start_failed",
+                        message: `${providerDisplayName(runtime)} native session did not start`,
+                    }),
                 });
                 return;
             }
             this.liveIds.add(msg.localThreadId);
-            // Codex-lineage startup is phase-bounded: app-server readiness is
-            // handled by its channel, then the already-connected
-            // observer gets a full window for the TUI's thread/started event.
-            // Claude retains the parent-owned SessionStart deadline.
             const runtime = msg.execution?.provider;
-            // Do not add another provider-local deadline around resume/preload. The
-            // parent control request remains bounded for process safety; fresh-thread
-            // discovery owns the separate 30s phase below.
-            const terminalReadyTimeoutMs = isManagedNativeProvider(runtime) ? null : undefined;
+            if (runtime)
+                this.liveRuntimes.set(msg.localThreadId, runtime);
             // Launch the TUI attached to the already-bound thread. Re-launch when the
             // pane is absent OR its process has died (`isAlive` probes `#{pane_dead}`) — so a
             // reconnect after the TUI exited restarts it instead of skipping (a
             // launched-once guard would leave a dead "Pane is dead" husk forever).
             if (!this.terminals.get(`${msg.localThreadId}-main`)?.isAlive()) {
-                const terminalReady = provider.waitTerminalReady
-                    ? await provider.waitTerminalReady(msg.localThreadId, terminalReadyTimeoutMs)
-                    : true;
+                // Codex/Traex `ensureLiveCodexSession` already performs the backend
+                // preload for an existing thread. Match the native lifecycle: launch
+                // the TUI immediately after that preload and let the observer subscribe
+                // in the background. Fresh sessions likewise launch before discovery.
+                const terminalReady = isCodexLineageProvider(runtime)
+                    ? true
+                    : provider.waitTerminalReady
+                        ? await provider.waitTerminalReady(msg.localThreadId)
+                        : true;
                 if (!terminalReady) {
                     const providerName = runtime === "traex" ? "Traex" : runtime === "codex" ? "Codex" : "Provider";
                     this.transport.send({
@@ -209,14 +255,31 @@ export class RunnerSession {
                         reqId: msg.reqId,
                         localThreadId: msg.localThreadId,
                         ok: false,
-                        error: runtime === "codex" || runtime === "traex"
-                            ? provider.liveSessionError?.(msg.localThreadId)
-                                ?? `${providerName} app-server was ready, but its existing thread could not be resumed for the Terminal`
-                            : "Provider thread was not ready for Terminal resume",
+                        error: providerFailure(provider, msg.localThreadId, {
+                            runtime,
+                            code: "native_resume_failed",
+                            message: runtime === "codex" || runtime === "traex"
+                                ? `${providerName} app-server was ready, but its existing session could not be resumed for the Terminal`
+                                : "Provider thread was not ready for Terminal resume",
+                        }),
                     });
                     return;
                 }
-                await this.launchCodexPane(msg.localThreadId, msg.cols, msg.rows);
+                try {
+                    await this.launchCodexPane(msg.localThreadId, msg.cols, msg.rows);
+                }
+                catch (error) {
+                    throw error instanceof AgentRuntimeError
+                        ? error
+                        : nativePhaseError(runtime, "native_terminal_launch_failed", "Terminal failed to launch", error);
+                }
+            }
+            // Omnigent's known-thread path launches `codex --remote resume` first,
+            // then creates `_codex_forward_known_thread` as background work. Keep the
+            // ordering explicit here: observer connection failure cannot delay or
+            // reject cold-resume admission.
+            if (isCodexLineageProvider(runtime)) {
+                provider.startLiveCodexObserver?.(msg.localThreadId);
             }
             let ready = true;
             if (runtime === "codex" || runtime === "traex") {
@@ -226,12 +289,15 @@ export class RunnerSession {
                 this.monitorCodexThreadStartup(msg.localThreadId, runtime, provider);
             }
             else if (msg.waitForReady !== false && provider.waitLiveReady) {
-                ready = await provider.waitLiveReady(msg.localThreadId, terminalReadyTimeoutMs);
+                ready = await provider.waitLiveReady(msg.localThreadId);
             }
             const readinessError = ready
                 ? undefined
-                : provider.liveSessionError?.(msg.localThreadId)
-                    ?? "live session was not ready before timeout";
+                : providerFailure(provider, msg.localThreadId, {
+                    runtime,
+                    code: "native_readiness_failed",
+                    message: `${providerDisplayName(runtime)} native session was not ready`,
+                });
             this.transport.send({
                 t: "live.ready",
                 reqId: msg.reqId,
@@ -246,7 +312,7 @@ export class RunnerSession {
                 reqId: msg.reqId,
                 localThreadId: msg.localThreadId,
                 ok: false,
-                error: error instanceof Error ? error.message : String(error),
+                error: toWireError(error),
             });
         }
     }
@@ -269,11 +335,15 @@ export class RunnerSession {
                 : "";
             const detail = provider.liveSessionError?.(localThreadId)
                 ?? (paneFailure
-                    ? `Provider terminal exited before session discovery: ${paneFailure}`
+                    ? `${providerDisplayName(runtime)} Terminal exited before native session discovery: ${paneFailure}`
                     : `${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 Error(detail));
+            this.failCodexThreadStartup(localThreadId, provider, new AgentRuntimeError(detail, 503, paneFailure
+                ? "native_terminal_exited_before_session"
+                : "native_thread_discovery_timeout"));
         }).catch((error) => {
-            this.failCodexThreadStartup(localThreadId, provider, error instanceof Error ? error : new Error(String(error)));
+            this.failCodexThreadStartup(localThreadId, provider, error instanceof AgentRuntimeError
+                ? error
+                : nativePhaseError(runtime, "native_thread_discovery_failed", "native session discovery failed", error));
         });
     }
     /** Discovery failure is terminal for this partial native launch. Publish the
@@ -282,7 +352,7 @@ export class RunnerSession {
      * already-rejected readiness promise. */
     failCodexThreadStartup(localThreadId, provider, error) {
         if (!provider.failLiveStartup?.(localThreadId, error))
-            return;
+            return false;
         const watcher = this.terminalWatchers.get(localThreadId);
         if (watcher)
             clearInterval(watcher);
@@ -294,24 +364,42 @@ export class RunnerSession {
         catch (closeError) {
             console.warn(`[runner] session=${localThreadId} failed to close native Terminal after startup failure: ${closeError instanceof Error ? closeError.message : String(closeError)}`);
         }
-        provider.stopLiveCodexSession?.(localThreadId);
+        if (provider.teardownLiveCodexSession) {
+            provider.teardownLiveCodexSession(localThreadId);
+        }
+        else {
+            provider.stopLiveCodexSession?.(localThreadId);
+        }
         this.liveIds.delete(localThreadId);
+        return true;
     }
     async inject(msg) {
         const provider = this.liveProvider;
         try {
             const input = msg.input ?? msg.text;
-            const outcome = (await provider.injectMessage?.(msg.localThreadId, input)) ?? "notLive";
+            const result = (await provider.injectMessage?.(msg.localThreadId, input))
+                ?? { outcome: "notLive" };
             // App-server injection is independent of the Terminal TUI startup, so it
             // must not cancel prompt handling for the pane that is still starting.
-            const error = outcome === "injected" || outcome === "steered"
+            const error = result.outcome === "injected" || result.outcome === "steered"
                 ? undefined
-                : provider.liveSessionError?.(msg.localThreadId);
+                : providerFailure(provider, msg.localThreadId, {
+                    code: result.outcome === "notReady"
+                        ? "native_thread_not_ready"
+                        : result.outcome === "notLive"
+                            ? "native_session_not_live"
+                            : "native_message_injection_failed",
+                    message: result.outcome === "notReady"
+                        ? "Native session was not ready for message injection"
+                        : result.outcome === "notLive"
+                            ? "Native session was not live for message injection"
+                            : "Native message injection failed",
+                });
             this.transport.send({
                 t: "injected",
                 reqId: msg.reqId,
                 localThreadId: msg.localThreadId,
-                outcome,
+                result,
                 ...(error ? { error } : {}),
             });
         }
@@ -320,8 +408,8 @@ export class RunnerSession {
                 t: "injected",
                 reqId: msg.reqId,
                 localThreadId: msg.localThreadId,
-                outcome: "failed",
-                error: error instanceof Error ? error.message : String(error),
+                result: { outcome: "failed" },
+                error: toWireError(error),
             });
         }
     }
@@ -333,7 +421,7 @@ export class RunnerSession {
             ok = (await provider.interruptLive?.(msg.localThreadId)) ?? false;
         }
         catch (e) {
-            error = e instanceof Error ? e.message : String(e);
+            error = toWireError(e);
         }
         this.transport.send({
             t: "interrupted",
@@ -376,15 +464,50 @@ export class RunnerSession {
             if (checking || this.shuttingDown || this.terminals.get(terminalId) !== terminal)
                 return;
             checking = true;
-            const probe = terminal.isAliveAsync?.() ?? Promise.resolve(terminal.isAlive());
-            void probe.then((alive) => {
-                if (alive || this.shuttingDown || this.terminals.get(terminalId) !== terminal)
+            const probe = terminal.lifecycleLivenessAsync
+                ? terminal.lifecycleLivenessAsync()
+                : terminal.livenessAsync
+                    ? terminal.livenessAsync()
+                    : terminal.isAliveAsync
+                        ? terminal.isAliveAsync().then((alive) => alive ? "alive" : "dead")
+                        : Promise.resolve(terminal.isAlive() ? "alive" : "dead");
+            void probe.then((liveness) => {
+                // A failed pane probe is inconclusive. Only Omnigent's lifecycle
+                // evidence — capture target gone or explicit pane_dead — may fail it.
+                if (liveness !== "dead" ||
+                    this.shuttingDown ||
+                    this.terminals.get(terminalId) !== terminal)
                     return;
                 clearInterval(timer);
                 this.terminalWatchers.delete(localThreadId);
                 this.cancelTraexStartupWatcher(localThreadId);
-                this.liveProvider.failLiveSession?.(localThreadId, new Error("Provider terminal exited unexpectedly"));
-                this.failCodexThreadStartup(localThreadId, this.liveProvider, new Error("Provider terminal exited before native thread discovery completed"));
+                const runtime = this.liveRuntimes.get(localThreadId);
+                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));
+                if (isCodexLineageProvider(runtime)) {
+                    if (!startupFailed) {
+                        try {
+                            this.terminals.close(terminalId);
+                        }
+                        catch (closeError) {
+                            console.warn(`[runner] session=${localThreadId} failed to close exited native Terminal: ${closeError instanceof Error ? closeError.message : String(closeError)}`);
+                        }
+                        const exitError = nativePhaseError(runtime, "native_terminal_exited", "Terminal exited unexpectedly", paneFailure || undefined);
+                        if (this.liveProvider.teardownLiveCodexSession) {
+                            this.liveProvider.teardownLiveCodexSession(localThreadId, exitError);
+                        }
+                        else {
+                            this.liveProvider.failLiveSession?.(localThreadId, exitError);
+                            this.liveProvider.stopLiveCodexSession?.(localThreadId);
+                        }
+                        this.liveIds.delete(localThreadId);
+                        console.warn(`[runner] session=${localThreadId} ${providerDisplayName(runtime)} auxiliary Terminal exited; native runtime torn down for cold resume`);
+                    }
+                    return;
+                }
+                this.liveProvider.failLiveSession?.(localThreadId, nativePhaseError(runtime, "native_terminal_exited", "Terminal exited unexpectedly", paneFailure || undefined));
+            }).catch((error) => {
+                console.warn(`[runner] session=${localThreadId} native Terminal liveness probe failed: ${error instanceof Error ? error.message : String(error)}`);
             }).finally(() => {
                 checking = false;
             });
@@ -469,6 +592,7 @@ export class RunnerSession {
             });
         }
         this.liveIds.clear();
+        this.liveRuntimes.clear();
     }
     /** Stop event forwarding, kill native terminals/hooks, then synchronously
      * scrub provider handoff files before the child process is allowed to exit. */

package/dist/runner/manager.d.ts

@@ -16,10 +16,10 @@
  * channel.
  */
 import { spawn as nodeSpawn, type ChildProcess } from "node:child_process";
-import { type AdmissionReservation, type AgentCapabilities, type AgentRuntimeId, type AppConfig, type CapabilityResult, type ModelListResponse, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot, type ThreadGoal } from "@rynx-ai/core";
+import { type AdmissionReservation, type AgentCapabilities, type AgentRuntimeId, type AppConfig, type CapabilityResult, type ModelListResponse, type LiveSessionFailure, type InjectResult, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot, type ThreadGoal } from "@rynx-ai/core";
 import { type CodexSessionStore } from "../host.js";
 import type { ResolveInteractionResult } from "../interactions.js";
-import { type InjectOutcome, type TerminalOpenErrorCode, type TerminalRole } from "./protocol.js";
+import { type TerminalOpenErrorCode, type TerminalRole } from "./protocol.js";
 /** Runtime-local context attached to one Session runner process. The provider is
  * intentionally generic: package-specific resources stay in the composition
  * root that implements this port. */
@@ -53,12 +53,13 @@ export interface RunnerManagerOptions {
     shutdownGraceMs?: number;
     /** Final bounded wait for child exit after SIGKILL. */
     shutdownKillGraceMs?: number;
-    /** Max wait for a setup-pane launch acknowledgement. */
+    /** Max wait for a legacy setup-pane launch acknowledgement. Codex/Traex use
+     * their internal phase deadlines and are not wrapped by this timer. */
     liveStartTimeoutMs?: number;
     /** Max wait for a Provider-native thread to become ready. */
     liveReadyTimeoutMs?: number;
-    /** Claude SessionStart deadline. Codex/Traex use `liveStartTimeoutMs` for the
-     * pane/observer acknowledgement; their thread discovery is asynchronous. */
+    /** Claude SessionStart deadline. Codex/Traex have no parent-owned startup
+     * deadline; their app-server/discovery/injection phases report directly. */
     nativeLiveStartTimeoutMs?: number;
     /** Max wait for a native interrupt acknowledgement before reporting it
      * unproven. Callers may then use the explicit force-stop path. */
@@ -66,15 +67,13 @@ export interface RunnerManagerOptions {
     /** Max wait for an accepted owner TUI submission to become observable as a
      * mirrored response or a published native rotation. */
     terminalInputHandoffTimeoutMs?: number;
-    /** Initial exponential backoff for retrying unproven terminal cleanup. */
-    terminalInputCleanupRetryMs?: number;
     /** Injected for tests. */
     spawn?: typeof nodeSpawn;
     /** Injected for tests. Defaults to signaling the whole POSIX process group
      * created for the runner child, with direct-child fallback. */
     signalChild?: (child: ChildProcess, signal: NodeJS.Signals, processGroup: boolean) => void;
-    /** Injected for tests. Kills and verifies the deterministic private tmux
-     * server owned by a Session runner. */
+    /** Injected for tests. Best-effort close of the deterministic private tmux
+     * server owned by a Session runner; Omnigent does not verify/retry close. */
     terminateTerminalServer?: (terminalName: string) => boolean | Promise<boolean>;
     /** Injected tmux `#{window_activity}` reader. Returns epoch seconds. */
     terminalWindowActivityAt?: (terminalName: string) => number | null | Promise<number | null>;
@@ -175,7 +174,6 @@ export declare class RunnerManager implements AgentCapabilities {
     private readonly nativeLiveStartTimeoutMs;
     private readonly liveInterruptTimeoutMs;
     private readonly terminalInputHandoffTimeoutMs;
-    private readonly terminalInputCleanupRetryMs;
     private reapPromise;
     private stopping;
     private stopPromise;
@@ -242,14 +240,14 @@ export declare class RunnerManager implements AgentCapabilities {
     private finishTerminalInputHandoff;
     private finishAllTerminalInputHandoffs;
     private preserveTerminalInputHandoffsAsActivity;
-    private scheduleTerminalInputCleanupRetry;
     private expireTerminalInputHandoffs;
     /**
      * Eagerly bring up a session's codex-native live view (persistent forwarder +
      * detached `codex --remote` TUI) in its runner child, spawning the runner if
-     * needed. Idempotent. For Codex-lineage fresh sessions, resolves after the
-     * app-server/observer and pane are launched; thread discovery continues in
-     * parallel with injection. Other providers retain their readiness gate.
+     * needed. Idempotent. For Codex-lineage sessions, resolves after backend
+     * preload and pane launch; known-thread observer attach and fresh-thread
+     * discovery continue in the background. Other providers retain their
+     * readiness gate.
      */
     ensureLiveSession(localThreadId: string, opts: {
         workspace: SessionWorkspaceSnapshot;
@@ -268,13 +266,14 @@ export declare class RunnerManager implements AgentCapabilities {
     }): Promise<boolean>;
     private requestLiveSession;
     lastLiveSessionError(localThreadId: string): string | undefined;
+    lastLiveSessionFailure(localThreadId: string): LiveSessionFailure | undefined;
     /**
      * Inject a user turn into a session's live codex thread — reference implementation's
      * single-writer web send (`turn/start` / `turn/steer`); the forwarder mirrors
      * all output. Resolves true when the app-server accepted the turn, false when
      * the session has no live forwarder (caller falls back to the run path).
      */
-    injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
+    injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectResult>;
     private injectMessageAdmitted;
     /**
      * Interrupt a session's active live turn — the web Stop button (codex