@rynx-ai/runtime 0.1.11-beta.4 → 0.1.11-beta.41

package/dist/runner/protocol.d.ts

@@ -6,7 +6,8 @@
  * (`live.ensure` / `inject` / `live.interrupt`) plus per-thread capabilities and
  * terminal attachment; the reply channels mirror each request's `reqId`.
  */
-import { AgentRuntimeError, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+import { AgentRuntimeError, type InjectResult, type ResolvedExecutionSnapshot, type RuntimeTurnOptions, type RuntimeUserInput, type SessionCollaborationMode, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+export type { InjectOutcome, InjectResult } from "@rynx-ai/core";
 import type { ResolveInteractionResult } from "../interactions.js";
 /** A runtime error flattened for the wire; rebuilt parent-side as `AgentRuntimeError`. */
 export interface WireError {
@@ -15,6 +16,10 @@ export interface WireError {
     code: string;
     statusCode: number;
 }
+/** Parent classification for a mirror write. `ambiguous` means persistence
+ * crossed the bounded response deadline: the
+ * operation may still commit, so retrying it would risk a duplicate. */
+export type MirrorNackClassification = "transient" | "permanent" | "ambiguous";
 /** Capabilities forwarded to a runner (parent serves status/listModels itself). */
 export type CapName = "getGoal" | "setGoal" | "clearGoal" | "forkSession";
 /** A live terminal role: `owner` is read-write, `read-only` a viewer. */
@@ -22,16 +27,50 @@ export type TerminalRole = "owner" | "read-only";
 /** Stable reason for a terminal attach failure. `terminal_not_live` is an
  * expected, retryable absence; `terminal_open_failed` is an infrastructure error. */
 export type TerminalOpenErrorCode = "terminal_not_live" | "terminal_open_failed";
-/** Outcome of an `inject`. `injected` = the app-server / tmux accepted the turn.
- *  `notLive` = no live forwarder for this session (caller may use the run path).
- *  `notReady` = live but not ready within the park window; `failed` = injection
- *  threw. For BOTH notReady and failed the caller reports an error and MUST NOT
- *  re-run the turn (re-running would double-write alongside the forwarder).
- *  Mirrors reference implementation's "inject failure ⇒ response.failed, never re-run locally". */
-export type InjectOutcome = "injected" | "notLive" | "notReady" | "failed";
-/** Parent → child. Terminal PTY bytes ride `term.input` base64-encoded so the
+/** Parent → child. Raw terminal bytes ride `term.input` base64-encoded so the
  *  NDJSON line framing stays intact (raw bytes contain newlines). */
 export type ToChild = {
+    t: "mirror.ack";
+    deliveryId: string;
+    generation: number;
+} | {
+    t: "mirror.nack";
+    deliveryId: string;
+    generation: number;
+    classification: MirrorNackClassification;
+    message: string;
+} | {
+    t: "mirror.image.ack";
+    transferId: string;
+    seq: number;
+    generation: number;
+} | {
+    t: "mirror.image.hold";
+    transferId: string;
+    seq: number;
+    generation: number;
+} | {
+    t: "mirror.image.nack";
+    transferId: string;
+    seq: number;
+    generation: number;
+    classification: MirrorNackClassification;
+    message: string;
+} | {
+    t: "rotate.ack";
+    rotationId: string;
+    generation: number;
+} | {
+    t: "rotate.nack";
+    rotationId: string;
+    generation: number;
+    classification: MirrorNackClassification;
+    message: string;
+} | {
+    t: "rotate.applied.ack";
+    rotationId: string;
+    generation: number;
+} | {
     t: "cap";
     capId: string;
     name: CapName;
@@ -49,13 +88,31 @@ export type ToChild = {
     rows: number;
     command?: string;
     args?: string[];
+} | {
+    t: "term.seed.read";
+    attachId: string;
+    reqId: string;
+    offset: number;
+    maxBytes: number;
+} | {
+    t: "term.start";
+    attachId: string;
+    reqId: string;
+} | {
+    t: "term.read";
+    attachId: string;
+    reqId: string;
+    offset: number;
+    maxBytes: number;
 } | {
     t: "term.input";
     attachId: string;
+    reqId: string;
     dataB64: string;
 } | {
     t: "term.resize";
     attachId: string;
+    reqId: string;
     cols: number;
     rows: number;
 } | {
@@ -70,8 +127,9 @@ export type ToChild = {
 }
 /** Eagerly bring up a session's live codex TUI + forwarder (codex-native), so
  *  its turns mirror to the bus regardless of whether the web has attached the
- *  terminal. Idempotent; the child replies `live.ready` (echoing `reqId`) once
- *  the thread is bound. */
+ *  terminal. Fresh sessions connect the discovery listener before TUI launch;
+ *  known-thread resumes launch the TUI after backend preload and attach their
+ *  observer in the background. */
  | {
     t: "live.ensure";
     reqId: string;
@@ -93,6 +151,7 @@ export type ToChild = {
     t: "inject";
     reqId: string;
     localThreadId: string;
+    options?: RuntimeTurnOptions;
 } & ({
     input: RuntimeUserInput;
     text?: never;
@@ -100,6 +159,14 @@ export type ToChild = {
     text: string;
     input?: never;
 }))
+/** Apply a Codex-lineage collaboration mode to an already-loaded native
+ * thread. This control path never starts a runner or waits for a new Turn. */
+ | {
+    t: "collaboration.update";
+    reqId: string;
+    localThreadId: string;
+    mode: SessionCollaborationMode;
+}
 /** Interrupt the session's active turn — the web Stop button. codex: app-server
  *  `turn/interrupt`; claude: an Escape keystroke to the pane. The child replies
  *  `interrupted` (echoing `reqId`). */
@@ -107,10 +174,18 @@ export type ToChild = {
     t: "live.interrupt";
     reqId: string;
     localThreadId: string;
+}
+/** Pane-scoped idle cleanup. The child removes the terminal resource and
+ * performs the lifecycle adapter's explicit cleanup before acknowledging. */
+ | {
+    t: "terminal.reap";
+    reqId: string;
+    localThreadId: string;
+    terminalId: string;
 } | {
     t: "shutdown";
 };
-/** Child → parent. `term.data` carries base64 PTY output (line-safe NDJSON). */
+/** Child → parent. `term.data` carries raw pane output as base64 (line-safe NDJSON). */
 export type FromChild = {
     t: "ready";
 } | {
@@ -124,20 +199,52 @@ export type FromChild = {
     ok: false;
     error: WireError;
 } | {
-    t: "term.opened";
+    t: "term.prepared";
     attachId: string;
     role: TerminalRole;
+    seedBytes: number;
+    cols?: number;
+    rows?: number;
 } | {
-    t: "term.data";
+    t: "term.seed.chunk";
     attachId: string;
+    reqId: string;
     dataB64: string;
+    nextOffset: number;
+    done: boolean;
+    finalOffset?: number;
+} | {
+    t: "term.started";
+    attachId: string;
+    reqId: string;
 } | {
-    t: "term.exit";
+    t: "term.chunk";
     attachId: string;
+    reqId: string;
+    dataB64: string;
+    nextOffset: number;
+    done: boolean;
+    finalOffset?: number;
+} | {
+    t: "term.reader.done";
+    attachId: string;
+    finalOffset: number;
+    reason: "terminal_exited" | "client_closed" | "backpressure" | "internal";
     exitCode: number;
+} | {
+    t: "term.ack";
+    attachId: string;
+    reqId: string;
+    operation: "input" | "resize";
+} | {
+    t: "term.dimensions";
+    attachId: string;
+    cols: number;
+    rows: number;
 } | {
     t: "term.error";
     attachId: string;
+    reqId?: string;
     code: TerminalOpenErrorCode;
     message: string;
 }
@@ -147,6 +254,62 @@ export type FromChild = {
     t: "mirror";
     sessionId: string;
     event: SessionEvent;
+    /** Correlates the event with the parent's post-persistence ACK. */
+    deliveryId: string;
+    /** Logical mirror generation. A clear/fork supersedes every pending
+     * delivery from an older generation. */
+    generation: number;
+    /** One-based attempt for the same logical ordinary delivery. Lets the
+     * parent settle process-local projections exactly when the permanent
+     * retry budget is exhausted. */
+    attempt: number;
+}
+/** The child stopped waiting for an ordinary delivery after an ambiguous
+ * outcome or an exhausted permanent budget. The parent keeps the exact
+ * delivery-to-projection association until the listener settles, so a late
+ * persistence failure can retire only the matching optimistic input. */
+ | {
+    t: "mirror.abandon";
+    deliveryId: string;
+    generation: number;
+} | {
+    t: "mirror.image.begin";
+    transferId: string;
+    sessionId: string;
+    event: SessionEvent;
+    totalChars: number;
+    generation: number;
+} | {
+    t: "mirror.image.chunk";
+    transferId: string;
+    seq: number;
+    data: string;
+    generation: number;
+} | {
+    t: "mirror.image.commit";
+    transferId: string;
+    seq: number;
+    generation: number;
+}
+/** Child no longer waits for this transfer (ambiguous handled, permanent
+ * budget exhausted, or generation superseded); parent may release chunks. */
+ | {
+    t: "mirror.image.abandon";
+    transferId: string;
+    generation: number;
+} | {
+    t: "terminal.lifecycle.ended";
+    localThreadId: string;
+    terminalId: string;
+    lifecycle: "required" | "auxiliary";
+    status: "idle" | "running" | "failed" | "unknown";
+} | {
+    t: "terminal.reaped";
+    reqId: string;
+    localThreadId: string;
+    terminalId: string;
+    ok: boolean;
+    error?: WireError;
 }
 /** The session rotated to a fresh machine-session (claude `/clear`·`/fork`): the
  *  child re-pointed its mirror to `to` and asks the daemon to alias the runner
@@ -155,29 +318,43 @@ export type FromChild = {
     t: "rotate";
     from: string;
     to: string;
+    rotationId: string;
+    generation: number;
     kind: "clear" | "fork";
     workspace: SessionWorkspaceSnapshot;
     execution: ResolvedExecutionSnapshot;
     parentSessionId?: string;
 }
-/** Result of a `live.ensure`: `ok` once the requested gate is reached (pane
- *  started for setup, otherwise native thread bound). Echoes `reqId`. */
+/** Child-side terminal/runtime ownership has moved to the durable target.
+ * The parent must not expose the target routing alias before this frame. */
+ | {
+    t: "rotate.applied";
+    rotationId: string;
+    generation: number;
+    from: string;
+    to: string;
+}
+/** Result of a `live.ensure`: for Codex-lineage sessions `ok` means backend
+ *  preload and pane launch completed. A resume observer and fresh-thread
+ *  discovery may continue in the background. Other Providers retain their
+ *  own readiness gate. */
  | {
     t: "live.ready";
     reqId: string;
     localThreadId: string;
     ok: boolean;
-    error?: string;
+    error?: WireError;
 }
-/** Result of an `inject`: `outcome` distinguishes injected / notLive / notReady /
- *  failed so the caller never falls back to a second output path on a live
- *  session. Echoes the request `reqId`. */
+/** Result of an `inject`: `result.outcome` distinguishes a new turn, an
+ * active-turn steer, and failures. RPC-backed success carries the canonical
+ * Response identity immediately; transcript-backed success may publish it on
+ * the mirrored user record shortly afterward. Echoes the request `reqId`. */
  | {
     t: "injected";
     reqId: string;
     localThreadId: string;
-    outcome: InjectOutcome;
-    error?: string;
+    result: InjectResult;
+    error?: WireError;
 }
 /** Result of a `live.interrupt`: `ok` when an active turn was interrupted (false
  *  when there was none). Echoes the request `reqId`. */
@@ -186,13 +363,24 @@ export type FromChild = {
     reqId: string;
     localThreadId: string;
     ok: boolean;
-    error?: string;
+    error?: WireError;
+} | {
+    t: "collaboration.updated";
+    reqId: string;
+    localThreadId: string;
+    ok: boolean;
+    error?: WireError;
 } | {
     t: "interaction.resolved";
     reqId: string;
     localThreadId: string;
     result: ResolveInteractionResult;
 };
+/** Internal runner wire bounds. Generated images are already subject to the
+ * Session image byte limit; chunks keep the NDJSON pipe and parser bounded and
+ * each chunk is acknowledged before the next is sent. */
+export declare const RUNNER_IMAGE_CHUNK_CHARS: number;
+export declare const RUNNER_IMAGE_MAX_RESULT_CHARS: number;
 /** Encode a message as a single NDJSON line (newline included). */
 export declare function encodeMessage(msg: ToChild | FromChild): string;
 /** Parse one NDJSON line; returns `null` for blank lines or malformed JSON. */

package/dist/runner/protocol.js

@@ -7,6 +7,11 @@
  * terminal attachment; the reply channels mirror each request's `reqId`.
  */
 import { AgentRuntimeError, } from "@rynx-ai/core";
+/** Internal runner wire bounds. Generated images are already subject to the
+ * Session image byte limit; chunks keep the NDJSON pipe and parser bounded and
+ * each chunk is acknowledged before the next is sent. */
+export const RUNNER_IMAGE_CHUNK_CHARS = 32 * 1024;
+export const RUNNER_IMAGE_MAX_RESULT_CHARS = 8 * 1024 * 1024;
 /** Encode a message as a single NDJSON line (newline included). */
 export function encodeMessage(msg) {
     return `${JSON.stringify(msg)}\n`;

package/dist/runner/startup-policy.d.ts

@@ -0,0 +1,7 @@
+import type { AgentRuntimeId } from "@rynx-ai/core";
+/** Current live providers are native CLI sessions. Keep this explicit so a
+ * future non-native provider does not silently inherit their startup budget. */
+export declare function isManagedNativeProvider(provider: AgentRuntimeId | undefined): provider is AgentRuntimeId;
+/** Codex-lineage providers own app-server, thread-discovery, and injection
+ * phase errors. Claude instead retains its parent-owned SessionStart gate. */
+export declare function isCodexLineageProvider(provider: AgentRuntimeId | undefined): provider is Exclude<AgentRuntimeId, "claude">;

package/dist/runner/startup-policy.js

@@ -0,0 +1,10 @@
+/** Current live providers are native CLI sessions. Keep this explicit so a
+ * future non-native provider does not silently inherit their startup budget. */
+export function isManagedNativeProvider(provider) {
+    return provider === "codex" || provider === "traex" || provider === "claude";
+}
+/** Codex-lineage providers own app-server, thread-discovery, and injection
+ * phase errors. Claude instead retains its parent-owned SessionStart gate. */
+export function isCodexLineageProvider(provider) {
+    return provider === "codex" || provider === "traex";
+}

package/dist/runner/transport.d.ts

@@ -3,9 +3,13 @@ import { type FromChild, type ToChild } from "./protocol.js";
 export interface RunnerTransport<TSend, TRecv> {
     /** Send one message. Best-effort: a dead peer is surfaced via {@link onClose}. */
     send(msg: TSend): void;
+    /** Send one bounded message and resolve only after the writable accepts and
+     * drains it. Terminal pull responses use this to keep stdio end-to-end
+     * demand-driven. */
+    sendAndDrain(msg: TSend): Promise<void>;
     /** Register the single message handler. */
     onMessage(cb: (msg: TRecv) => void): void;
-    /** Register a close/error handler (peer stream ended). */
+    /** Register a close/error observer (peer stream ended). */
     onClose(cb: (error?: Error) => void): void;
     /** Stop reading and release the readline interface. */
     close(): void;
@@ -14,6 +18,15 @@ export interface RunnerTransport<TSend, TRecv> {
 export type ParentTransport = RunnerTransport<ToChild, FromChild>;
 /** Child-side transport: sends {@link FromChild}, receives {@link ToChild}. */
 export type ChildTransport = RunnerTransport<FromChild, ToChild>;
+/** Structured write failure used by delivery code to distinguish a frame that
+ * definitely never entered the pipe from one whose post-write result is
+ * uncertain. */
+export declare class RunnerTransportWriteError extends Error {
+    readonly delivery: "not-sent" | "ambiguous";
+    constructor(message: string, delivery: "not-sent" | "ambiguous", options?: {
+        cause?: unknown;
+    });
+}
 /**
  * NDJSON-over-streams transport. `input` is line-read for inbound messages;
  * `output` receives one JSON line per {@link send}. Used on both ends:
@@ -25,12 +38,15 @@ export declare class StdioRunnerTransport<TSend, TRecv> implements RunnerTranspo
     private readonly output;
     private readonly rl;
     private messageHandler;
-    private closeHandler;
+    private readonly closeHandlers;
     private closed;
+    private writeTail;
     constructor(input: Readable, output: Writable);
     send(msg: TSend): void;
+    sendAndDrain(msg: TSend): Promise<void>;
     onMessage(cb: (msg: TRecv) => void): void;
     onClose(cb: (error?: Error) => void): void;
     close(): void;
     private handleClose;
+    private writeMessage;
 }

package/dist/runner/transport.js

@@ -11,6 +11,17 @@
  */
 import readline from "node:readline";
 import { decodeMessage, encodeMessage } from "./protocol.js";
+/** Structured write failure used by delivery code to distinguish a frame that
+ * definitely never entered the pipe from one whose post-write result is
+ * uncertain. */
+export class RunnerTransportWriteError extends Error {
+    delivery;
+    constructor(message, delivery, options) {
+        super(message, options);
+        this.delivery = delivery;
+        this.name = "RunnerTransportWriteError";
+    }
+}
 /**
  * NDJSON-over-streams transport. `input` is line-read for inbound messages;
  * `output` receives one JSON line per {@link send}. Used on both ends:
@@ -22,8 +33,9 @@ export class StdioRunnerTransport {
     output;
     rl;
     messageHandler = null;
-    closeHandler = null;
+    closeHandlers = new Set();
     closed = false;
+    writeTail = Promise.resolve();
     constructor(input, output) {
         this.input = input;
         this.output = output;
@@ -52,11 +64,16 @@ export class StdioRunnerTransport {
         }
         this.output.write(encodeMessage(msg));
     }
+    sendAndDrain(msg) {
+        const operation = this.writeTail.then(() => this.writeMessage(msg));
+        this.writeTail = operation.catch(() => undefined);
+        return operation;
+    }
     onMessage(cb) {
         this.messageHandler = cb;
     }
     onClose(cb) {
-        this.closeHandler = cb;
+        this.closeHandlers.add(cb);
     }
     close() {
         this.closed = true;
@@ -67,6 +84,68 @@ export class StdioRunnerTransport {
             return;
         }
         this.closed = true;
-        this.closeHandler?.(error);
+        for (const handler of this.closeHandlers)
+            handler(error);
+    }
+    writeMessage(msg) {
+        if (this.closed) {
+            return Promise.reject(new RunnerTransportWriteError("runner transport is closed before write", "not-sent"));
+        }
+        let encoded;
+        try {
+            encoded = encodeMessage(msg);
+        }
+        catch (error) {
+            return Promise.reject(new RunnerTransportWriteError("runner transport frame could not be encoded", "not-sent", { cause: error }));
+        }
+        return new Promise((resolve, reject) => {
+            let callbackDone = false;
+            let drainDone = false;
+            let settled = false;
+            const cleanup = () => {
+                this.output.off("drain", onDrain);
+                this.output.off("error", onError);
+            };
+            const finish = () => {
+                if (settled || !callbackDone || !drainDone)
+                    return;
+                settled = true;
+                cleanup();
+                resolve();
+            };
+            const onDrain = () => {
+                drainDone = true;
+                finish();
+            };
+            const onError = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(new RunnerTransportWriteError("runner transport write result is uncertain", "ambiguous", { cause: error }));
+            };
+            this.output.once("error", onError);
+            let accepted;
+            try {
+                accepted = this.output.write(encoded, (error) => {
+                    if (error) {
+                        onError(error);
+                        return;
+                    }
+                    callbackDone = true;
+                    finish();
+                });
+            }
+            catch (error) {
+                settled = true;
+                cleanup();
+                reject(new RunnerTransportWriteError("runner transport rejected the frame before write", "not-sent", { cause: error }));
+                return;
+            }
+            drainDone = accepted;
+            if (!accepted)
+                this.output.once("drain", onDrain);
+            finish();
+        });
     }
 }

package/dist/runner-main.js

@@ -20,6 +20,8 @@ import { loadConfig } from "@rynx-ai/core";
 import { FileCodexSessionStore, LocalAgentHost, resolveCodexSessionStorePath, } from "./host.js";
 import { RunnerSession } from "./runner/child.js";
 import { StdioRunnerTransport } from "./runner/transport.js";
+import { reapOrphanedTerminals } from "./terminal/tmux.js";
+import { reconcileRuntimeProcesses } from "./codex-app-server/process-registry.js";
 // stdout is the protocol channel — keep all logging on stderr.
 console.log = console.error.bind(console);
 console.info = console.error.bind(console);
@@ -34,6 +36,8 @@ for (const stream of [process.stdout, process.stderr]) {
     });
 }
 async function main() {
+    reapOrphanedTerminals();
+    reconcileRuntimeProcesses();
     const config = loadConfig();
     const sessionStore = new FileCodexSessionStore(resolveCodexSessionStorePath(config));
     const sessionId = process.env.RYNX_RUNNER_SESSION;
@@ -51,8 +55,7 @@ async function main() {
     const transport = new StdioRunnerTransport(process.stdin, process.stdout);
     let runner;
     transport.onClose(() => {
-        runner?.shutdown();
-        process.exit(0);
+        void runner?.shutdown().finally(() => process.exit(0));
     });
     runner = new RunnerSession({
         transport,
@@ -64,7 +67,9 @@ async function main() {
     });
     // A parent SIGTERM (idle reap / shutdown) uses the same ordered cleanup path
     // as the protocol shutdown before ending the process.
-    process.on("SIGTERM", () => runner?.shutdown());
+    process.on("SIGTERM", () => {
+        void runner?.shutdown();
+    });
 }
 void main().catch((error) => {
     console.error(error);

package/dist/terminal/claude-tui.d.ts

@@ -18,6 +18,8 @@ export interface ClaudeTuiArgs {
     settingSources?: string;
     /** Launch model (`--model`); omit to use claude's default. */
     model?: string;
+    /** Native Claude Code effort (`--effort`); omit to use its default. */
+    reasoningEffort?: string;
     /** Agent instructions appended to Claude Code's native system prompt. */
     appendSystemPrompt?: string;
     /** Resume a specific prior claude session (`--resume <id>`). */
@@ -36,4 +38,4 @@ export interface ClaudeTuiArgs {
  * Build the `claude` argv for an interactive, co-drivable TUI:
  * `[..extra] [--resume <id>] [--model <m>] [--append-system-prompt <text>] --settings <json>`.
  */
-export declare function buildClaudeTuiArgs({ settingsJson, settingSources, model, appendSystemPrompt, resume, forkSession, sessionId, additionalDirs, extraArgs, }: ClaudeTuiArgs): string[];
+export declare function buildClaudeTuiArgs({ settingsJson, settingSources, model, reasoningEffort, appendSystemPrompt, resume, forkSession, sessionId, additionalDirs, extraArgs, }: ClaudeTuiArgs): string[];

package/dist/terminal/claude-tui.js

@@ -2,7 +2,7 @@
  * Build the `claude` argv for an interactive, co-drivable TUI:
  * `[..extra] [--resume <id>] [--model <m>] [--append-system-prompt <text>] --settings <json>`.
  */
-export function buildClaudeTuiArgs({ settingsJson, settingSources, model, appendSystemPrompt, resume, forkSession = false, sessionId, additionalDirs = [], extraArgs = [], }) {
+export function buildClaudeTuiArgs({ settingsJson, settingSources, model, reasoningEffort, appendSystemPrompt, resume, forkSession = false, sessionId, additionalDirs = [], extraArgs = [], }) {
     const args = [...extraArgs];
     if (additionalDirs.length > 0)
         args.push("--add-dir", ...additionalDirs);
@@ -16,6 +16,8 @@ export function buildClaudeTuiArgs({ settingsJson, settingSources, model, append
         args.push("--session-id", sessionId);
     if (model)
         args.push("--model", model);
+    if (reasoningEffort)
+        args.push("--effort", reasoningEffort);
     if (appendSystemPrompt)
         args.push("--append-system-prompt", appendSystemPrompt);
     args.push("--settings", settingsJson);

package/dist/terminal/codex-tui.d.ts

@@ -49,6 +49,10 @@ export interface LaunchCodexTuiOptions extends CodexRemoteArgs {
     env?: Record<string, string>;
     cols?: number;
     rows?: number;
+    scrollback?: number;
+    tmuxAllowPassthrough?: boolean;
+    tmuxStartOnAttach?: boolean;
+    keepAliveAfterExit?: boolean;
 }
 /**
  * Create (idempotently) the codex TUI terminal in the registry, running the real

package/dist/terminal/codex-tui.js

@@ -25,11 +25,16 @@ export function buildCodexRemoteArgs({ remoteUrl, threadId, configOverrides = []
  */
 export function launchCodexTui(opts) {
     opts.registry.getOrCreate(opts.terminalId, {
+        lifecycle: "auxiliary",
         cwd: opts.cwd,
         command: opts.codexBin,
         args: buildCodexRemoteArgs(opts),
         env: opts.env,
         cols: opts.cols,
         rows: opts.rows,
+        scrollback: opts.scrollback ?? 100_000,
+        tmuxAllowPassthrough: opts.tmuxAllowPassthrough ?? true,
+        tmuxStartOnAttach: opts.tmuxStartOnAttach ?? false,
+        keepAliveAfterExit: opts.keepAliveAfterExit ?? false,
     });
 }