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

package/dist/runner/child.js

@@ -9,9 +9,10 @@
  */
 import { randomUUID } from "node:crypto";
 import { AgentRuntimeError, } from "@rynx-ai/core";
-import { TerminalRegistry } from "../terminal/registry.js";
+import { TerminalRegistry, } from "../terminal/registry.js";
 import { RUNNER_IMAGE_CHUNK_CHARS, RUNNER_IMAGE_MAX_RESULT_CHARS, toWireError, } from "./protocol.js";
 import { isCodexLineageProvider } from "./startup-policy.js";
+const TERMINAL_PREPARATION_TTL_MS = 30_000;
 /** Maximum time for a fresh Codex-lineage TUI to publish its native thread. */
 const CODEX_THREAD_START_TIMEOUT_MS = 30_000;
 function providerDisplayName(runtime) {
@@ -119,8 +120,10 @@ export class RunnerSession {
     onShutdown;
     /** Live terminals hosted by this session, and per-attach client handles. */
     terminals = new TerminalRegistry();
+    preparations = new Map();
     attachments = new Map();
     attachmentThreadIds = new Map();
+    attachmentRoles = new Map();
     traexStartupWatchers = new Map();
     traexStartupGates = new Map();
     terminalWatchers = new Map();
@@ -133,7 +136,9 @@ export class RunnerSession {
     mirrorImageAcks = new Map();
     /** Provider name retained for asynchronous Terminal-exit diagnostics. */
     liveRuntimes = new Map();
+    terminalStatuses = new Map();
     shuttingDown = false;
+    shutdownPromise = null;
     constructor({ transport, executor, onShutdown }) {
         this.transport = transport;
         this.executor = executor;
@@ -177,7 +182,9 @@ export class RunnerSession {
                 void this.runCap(msg.capId, msg.name, msg.args);
                 return;
             case "term.open":
-                if (this.pendingTerminalOpens.has(msg.attachId) || this.attachments.has(msg.attachId)) {
+                if (this.pendingTerminalOpens.has(msg.attachId) ||
+                    this.preparations.has(msg.attachId) ||
+                    this.attachments.has(msg.attachId)) {
                     this.transport.send({
                         t: "term.error",
                         attachId: msg.attachId,
@@ -192,29 +199,35 @@ export class RunnerSession {
                     this.cancelledTerminalOpens.delete(msg.attachId);
                 });
                 return;
+            case "term.seed.read":
+                void this.readTerminalSeed(msg);
+                return;
+            case "term.start":
+                void this.startTerminal(msg);
+                return;
+            case "term.read":
+                void this.readTerminalOutput(msg);
+                return;
             case "term.input":
-                {
-                    const localThreadId = this.attachmentThreadIds.get(msg.attachId);
-                    const input = Buffer.from(msg.dataB64, "base64").toString("utf8");
-                    // xterm sends device/focus reports through the same onData channel as
-                    // keystrokes. They must reach the TUI without pretending the user has
-                    // taken over startup prompt handling.
-                    if (!isTerminalProtocolResponse(input)) {
-                        this.cancelTraexStartupWatcher(localThreadId);
-                    }
-                    this.attachments.get(msg.attachId)?.write(input);
-                }
+                void this.writeTerminalInput(msg);
                 return;
             case "term.resize":
-                this.attachments.get(msg.attachId)?.resize(msg.cols, msg.rows);
+                void this.resizeTerminal(msg);
                 return;
             case "term.close": {
                 if (this.pendingTerminalOpens.has(msg.attachId)) {
                     this.cancelledTerminalOpens.add(msg.attachId);
                 }
+                const pending = this.preparations.get(msg.attachId);
+                if (pending) {
+                    clearTimeout(pending.timer);
+                    this.preparations.delete(msg.attachId);
+                    pending.preparation.kill();
+                }
                 const attachment = this.attachments.get(msg.attachId);
                 this.attachments.delete(msg.attachId);
                 this.attachmentThreadIds.delete(msg.attachId);
+                this.attachmentRoles.delete(msg.attachId);
                 attachment?.kill();
                 return;
             }
@@ -234,8 +247,11 @@ export class RunnerSession {
             case "live.interrupt":
                 void this.interruptLive(msg);
                 return;
+            case "terminal.reap":
+                void this.reapTerminal(msg);
+                return;
             case "shutdown":
-                this.shutdown();
+                void this.shutdown();
                 return;
         }
     }
@@ -269,14 +285,19 @@ export class RunnerSession {
         const target = { id: localThreadId };
         const emit = (event) => {
             const sessionId = target.id;
+            if (event.type === "session.status") {
+                this.terminalStatuses.set(sessionId, event.status);
+            }
             this.enqueueMirror(() => this.sendMirroredEvent(sessionId, event));
         };
         const retarget = (newId, meta) => {
+            const previousId = target.id;
+            this.transferNativeSessionResources(previousId, newId);
             target.id = newId;
             this.enqueueMirror(() => {
                 this.transport.send({
                     t: "rotate",
-                    from: localThreadId,
+                    from: previousId,
                     to: newId,
                     kind: meta.kind,
                     workspace: meta.workspace,
@@ -287,11 +308,41 @@ export class RunnerSession {
         };
         return { emit, retarget };
     }
+    transferNativeSessionResources(sourceId, targetId) {
+        if (sourceId === targetId)
+            return;
+        const sourceTerminalId = `${sourceId}-main`;
+        const targetTerminalId = `${targetId}-main`;
+        this.terminals.transfer(sourceTerminalId, targetTerminalId);
+        const watcher = this.terminalWatchers.get(sourceId);
+        if (watcher)
+            clearInterval(watcher);
+        this.terminalWatchers.delete(sourceId);
+        const runtime = this.liveRuntimes.get(sourceId);
+        if (runtime) {
+            this.liveRuntimes.delete(sourceId);
+            this.liveRuntimes.set(targetId, runtime);
+        }
+        const status = this.terminalStatuses.get(sourceId);
+        if (status) {
+            this.terminalStatuses.delete(sourceId);
+            this.terminalStatuses.set(targetId, status);
+        }
+        if (this.liveIds.delete(sourceId))
+            this.liveIds.add(targetId);
+        for (const [attachId, sessionId] of this.attachmentThreadIds) {
+            if (sessionId === sourceId)
+                this.attachmentThreadIds.set(attachId, targetId);
+        }
+        const terminal = this.terminals.get(targetTerminalId);
+        if (terminal)
+            this.watchNativeTerminal(targetId, targetTerminalId, terminal);
+    }
     enqueueMirror(operation) {
         this.mirrorQueue = this.mirrorQueue.then(operation).catch((error) => {
             if (!this.shuttingDown) {
                 this.rejectMirrorImageAcks(error instanceof Error ? error : new Error(String(error)));
-                this.shutdown();
+                void this.shutdown();
             }
         });
     }
@@ -614,6 +665,43 @@ export class RunnerSession {
             ...(error ? { error } : {}),
         });
     }
+    async reapTerminal(msg) {
+        let error;
+        try {
+            const lifecycle = this.terminals.lifecycle(msg.terminalId);
+            const watcher = this.terminalWatchers.get(msg.localThreadId);
+            if (watcher)
+                clearInterval(watcher);
+            this.terminalWatchers.delete(msg.localThreadId);
+            this.cancelTraexStartupWatcher(msg.localThreadId);
+            for (const [attachId, sessionId] of this.attachmentThreadIds) {
+                if (sessionId !== msg.localThreadId)
+                    continue;
+                this.attachments.get(attachId)?.kill();
+                this.attachments.delete(attachId);
+                this.attachmentThreadIds.delete(attachId);
+                this.attachmentRoles.delete(attachId);
+            }
+            this.terminals.close(msg.terminalId);
+            if (lifecycle === "auxiliary") {
+                await this.liveProvider.teardownAuxiliaryTerminalRuntime?.(msg.localThreadId);
+                this.liveIds.delete(msg.localThreadId);
+                this.liveRuntimes.delete(msg.localThreadId);
+                this.terminalStatuses.delete(msg.localThreadId);
+            }
+        }
+        catch (cause) {
+            error = toWireError(cause);
+        }
+        this.transport.send({
+            t: "terminal.reaped",
+            reqId: msg.reqId,
+            localThreadId: msg.localThreadId,
+            terminalId: msg.terminalId,
+            ok: error === undefined,
+            ...(error ? { error } : {}),
+        });
+    }
     /** Launch (idempotently) the session's codex TUI pane from the executor's
      *  `codexTerminalSpec`. Shares the `${id}-main` terminal id with `term.open`,
      *  so the web attach reuses the same detached pane. */
@@ -623,12 +711,23 @@ export class RunnerSession {
             return;
         const terminalId = `${localThreadId}-main`;
         const term = this.terminals.getOrCreate(terminalId, {
+            lifecycle: spec.lifecycle,
             cwd: spec.cwd,
             command: spec.command,
             args: spec.args,
             cols: cols ?? 120,
             rows: rows ?? 40,
             ...(spec.env ? { env: spec.env } : {}),
+            ...(spec.scrollback === undefined ? {} : { scrollback: spec.scrollback }),
+            ...(spec.tmuxAllowPassthrough === undefined
+                ? {}
+                : { tmuxAllowPassthrough: spec.tmuxAllowPassthrough }),
+            ...(spec.tmuxStartOnAttach === undefined
+                ? {}
+                : { tmuxStartOnAttach: spec.tmuxStartOnAttach }),
+            ...(spec.keepAliveAfterExit === undefined
+                ? {}
+                : { keepAliveAfterExit: spec.keepAliveAfterExit }),
         });
         if (spec.skipTraexStartupPrompts) {
             const watcher = Symbol(localThreadId);
@@ -671,30 +770,39 @@ export class RunnerSession {
                 this.terminalWatchers.delete(localThreadId);
                 this.cancelTraexStartupWatcher(localThreadId);
                 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));
-                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`);
-                    }
+                if (startupFailed || lifecycle === undefined)
                     return;
+                try {
+                    this.terminals.close(terminalId);
                 }
-                this.liveProvider.failLiveSession?.(localThreadId, nativePhaseError(runtime, "native_terminal_exited", "Terminal exited unexpectedly", paneFailure || undefined));
+                catch (closeError) {
+                    console.warn(`[runner] session=${localThreadId} failed to close exited native Terminal: ${closeError instanceof Error ? closeError.message : String(closeError)}`);
+                }
+                const status = this.terminalStatuses.get(localThreadId) ?? "unknown";
+                if (lifecycle === "auxiliary") {
+                    console.warn(`[runner] session=${localThreadId} ${providerDisplayName(runtime)} auxiliary Terminal exited`);
+                }
+                else {
+                    if (status !== "idle") {
+                        this.liveProvider.failLiveSession?.(localThreadId, nativePhaseError(runtime, "required_terminal_exited", "Required Terminal exited unexpectedly", paneFailure || undefined));
+                    }
+                    this.liveProvider.stopLiveCodexSession?.(localThreadId);
+                    this.liveIds.delete(localThreadId);
+                    this.liveRuntimes.delete(localThreadId);
+                    this.terminalStatuses.delete(localThreadId);
+                }
+                this.enqueueMirror(() => {
+                    this.transport.send({
+                        t: "terminal.lifecycle.ended",
+                        localThreadId,
+                        terminalId,
+                        lifecycle,
+                        status,
+                    });
+                });
             }).catch((error) => {
                 console.warn(`[runner] session=${localThreadId} native Terminal liveness probe failed: ${error instanceof Error ? error.message : String(error)}`);
             }).finally(() => {
@@ -846,19 +954,31 @@ export class RunnerSession {
     /** Stop event forwarding, kill native terminals/hooks, then synchronously
      * scrub provider handoff files before the child process is allowed to exit. */
     shutdown() {
-        if (this.shuttingDown)
-            return;
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
         this.shuttingDown = true;
-        this.rejectMirrorImageAcks(new Error("runner is shutting down"));
-        this.stopLive();
-        this.terminals.closeAll();
-        this.liveProvider.finalizeStoppedLiveSessions?.();
-        this.onShutdown();
+        this.shutdownPromise = (async () => {
+            this.rejectMirrorImageAcks(new Error("runner is shutting down"));
+            this.stopLive();
+            for (const pending of this.preparations.values()) {
+                clearTimeout(pending.timer);
+                pending.preparation.kill();
+            }
+            this.preparations.clear();
+            for (const attachment of this.attachments.values())
+                attachment.kill();
+            this.terminals.closeAll();
+            this.attachments.clear();
+            this.attachmentThreadIds.clear();
+            this.attachmentRoles.clear();
+            await this.liveProvider.finalizeStoppedLiveSessions?.();
+            this.onShutdown();
+        })();
+        return this.shutdownPromise;
     }
     async openTerminal(msg) {
         try {
-            // codex/claude-native session (no explicit command): DUMB ATTACH — reference implementation's
-            // reattach (codex_native.py:905-942, `app_server=None`). A tab switch ONLY
+            // codex/claude-native session (no explicit command): DUMB ATTACH. A tab switch ONLY
             // attaches an already-live pane; it NEVER ensures the forwarder or relaunches a
             // dead pane. Creation/relaunch happens on message-send (`live.ensure`) or an
             // explicit restart. A missing/dead pane → `term.error`, so the web shows the
@@ -880,6 +1000,7 @@ export class RunnerSession {
             }
             // Login-shell terminal (explicit command): create-or-reuse as before.
             this.terminals.getOrCreate(msg.terminalId, {
+                lifecycle: "auxiliary",
                 cwd: msg.cwd,
                 command: msg.command,
                 args: msg.args,
@@ -897,14 +1018,14 @@ export class RunnerSession {
             });
         }
     }
-    /** Attach an already-created terminal and forward its data/exit to the parent. */
+    /** Prepare captured history without starting the live control client. */
     async attachExisting(msg) {
-        const { attachment, role } = await this.terminals.attach(msg.terminalId, msg.role, {
+        const { preparation, role } = await this.terminals.prepare(msg.terminalId, msg.role, {
             cols: msg.cols,
             rows: msg.rows,
         });
         if (this.cancelledTerminalOpens.has(msg.attachId)) {
-            attachment.kill();
+            preparation.kill();
             this.transport.send({
                 t: "term.error",
                 attachId: msg.attachId,
@@ -913,20 +1034,168 @@ export class RunnerSession {
             });
             return;
         }
-        this.attachments.set(msg.attachId, attachment);
+        const timer = setTimeout(() => {
+            const pending = this.preparations.get(msg.attachId);
+            if (!pending || pending.preparation !== preparation)
+                return;
+            this.preparations.delete(msg.attachId);
+            this.attachmentThreadIds.delete(msg.attachId);
+            this.attachmentRoles.delete(msg.attachId);
+            preparation.kill();
+        }, TERMINAL_PREPARATION_TTL_MS);
+        timer.unref?.();
+        this.preparations.set(msg.attachId, { preparation, timer });
+        this.attachmentRoles.set(msg.attachId, role);
         if (msg.localThreadId)
             this.attachmentThreadIds.set(msg.attachId, msg.localThreadId);
-        attachment.onData((chunk) => this.transport.send({
-            t: "term.data",
+        this.transport.send({
+            t: "term.prepared",
             attachId: msg.attachId,
-            dataB64: Buffer.from(chunk, "utf8").toString("base64"),
-        }));
-        attachment.onExit((info) => {
-            this.attachments.delete(msg.attachId);
+            role,
+            seedBytes: preparation.seedBytes,
+            ...(preparation.dimensions ?? {}),
+        });
+    }
+    async readTerminalSeed(msg) {
+        const pending = this.preparations.get(msg.attachId);
+        if (!pending) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, "terminal is not prepared");
+            return;
+        }
+        try {
+            const result = await pending.preparation.readSeed(msg.offset, msg.maxBytes);
+            await this.transport.sendAndDrain({
+                t: "term.seed.chunk",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+                dataB64: Buffer.from(result.data).toString("base64"),
+                nextOffset: result.nextOffset,
+                done: result.done,
+                ...(result.finalOffset === undefined ? {} : { finalOffset: result.finalOffset }),
+            });
+        }
+        catch (error) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, error);
+        }
+    }
+    async startTerminal(msg) {
+        const pending = this.preparations.get(msg.attachId);
+        if (!pending) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, "terminal is not prepared");
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.preparations.delete(msg.attachId);
+        try {
+            const attachment = await pending.preparation.start();
+            this.attachments.set(msg.attachId, attachment);
+            attachment.onResize(({ cols, rows }) => {
+                this.transport.send({ t: "term.dimensions", attachId: msg.attachId, cols, rows });
+            });
+            await this.transport.sendAndDrain({
+                t: "term.started",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+            });
+            void attachment.readerDone.then(async (info) => {
+                await this.transport.sendAndDrain({
+                    t: "term.reader.done",
+                    attachId: msg.attachId,
+                    finalOffset: info.finalOffset,
+                    reason: info.reason,
+                    exitCode: info.exitCode,
+                }).catch(() => undefined);
+            });
+        }
+        catch (error) {
+            pending.preparation.kill();
             this.attachmentThreadIds.delete(msg.attachId);
-            this.transport.send({ t: "term.exit", attachId: msg.attachId, exitCode: info.exitCode });
+            this.attachmentRoles.delete(msg.attachId);
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, error);
+        }
+    }
+    async readTerminalOutput(msg) {
+        const attachment = this.attachments.get(msg.attachId);
+        if (!attachment) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, "terminal has not started");
+            return;
+        }
+        try {
+            const result = await attachment.read(msg.offset, msg.maxBytes);
+            await this.transport.sendAndDrain({
+                t: "term.chunk",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+                dataB64: Buffer.from(result.data).toString("base64"),
+                nextOffset: result.nextOffset,
+                done: result.done,
+                ...(result.finalOffset === undefined ? {} : { finalOffset: result.finalOffset }),
+            });
+        }
+        catch (error) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, error);
+        }
+    }
+    async writeTerminalInput(msg) {
+        if (this.attachmentRoles.get(msg.attachId) !== "owner") {
+            await this.transport.sendAndDrain({
+                t: "term.ack",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+                operation: "input",
+            });
+            return;
+        }
+        const attachment = this.attachments.get(msg.attachId);
+        if (!attachment) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, "terminal has not started");
+            return;
+        }
+        const localThreadId = this.attachmentThreadIds.get(msg.attachId);
+        const input = Buffer.from(msg.dataB64, "base64");
+        if (!isTerminalProtocolResponse(input.toString("utf8"))) {
+            this.cancelTraexStartupWatcher(localThreadId);
+        }
+        try {
+            await attachment.write(input);
+            await this.transport.sendAndDrain({
+                t: "term.ack",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+                operation: "input",
+            });
+        }
+        catch (error) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, error);
+        }
+    }
+    async resizeTerminal(msg) {
+        const attachment = this.attachments.get(msg.attachId);
+        if (!attachment) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, "terminal has not started");
+            return;
+        }
+        try {
+            await attachment.resize(msg.cols, msg.rows);
+            await this.transport.sendAndDrain({
+                t: "term.ack",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+                operation: "resize",
+            });
+        }
+        catch (error) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, error);
+        }
+    }
+    sendTerminalOperationError(attachId, reqId, error) {
+        this.transport.send({
+            t: "term.error",
+            attachId,
+            reqId,
+            code: "terminal_open_failed",
+            message: error instanceof Error ? error.message : String(error),
         });
-        this.transport.send({ t: "term.opened", attachId: msg.attachId, role });
     }
     async runCap(capId, name, args) {
         try {

package/dist/runner/manager.d.ts

@@ -74,11 +74,11 @@ export interface RunnerManagerOptions {
     signalChild?: (child: ChildProcess, signal: NodeJS.Signals, processGroup: boolean) => void;
     /** Injected for tests. Best-effort close of the deterministic private tmux
      * server owned by a Session runner; reference implementation does not verify/retry close. */
-    terminateTerminalServer?: (terminalName: string) => boolean | Promise<boolean>;
+    terminateTerminalServer?: (terminalName: string, ownerPid?: number) => boolean | Promise<boolean>;
     /** Injected tmux `#{window_activity}` reader. Returns epoch seconds. */
-    terminalWindowActivityAt?: (terminalName: string) => number | null | Promise<number | null>;
+    terminalWindowActivityAt?: (terminalName: string, ownerPid?: number) => number | null | Promise<number | null>;
     /** Injected tmux attached-client probe. */
-    terminalHasAttachedClient?: (terminalName: string) => boolean | Promise<boolean>;
+    terminalHasAttachedClient?: (terminalName: string, ownerPid?: number) => boolean | Promise<boolean>;
     now?: () => number;
     /** Wall clock used to compare tmux's epoch timestamp. */
     wallNow?: () => number;
@@ -116,24 +116,39 @@ export interface OpenTerminalOptions {
     command?: string;
     args?: string[];
 }
-/**
- * Parent-side handle to a live terminal on a runner child. Bytes flow through
- * {@link onData} / {@link write} (decoded from the base64 wire frames); resize
- * and close are forwarded as control messages. {@link ready} resolves with the
- * granted role once the child attaches (an `owner` request is downgraded to
- * read-only when the owner slot is taken).
- */
+export interface ParentTerminalRead {
+    data: Uint8Array;
+    nextOffset: number;
+    done: boolean;
+    finalOffset?: number;
+}
+export interface ParentTerminalReaderDone {
+    finalOffset: number;
+    reason: "terminal_exited" | "client_closed" | "backpressure" | "internal";
+    exitCode: number;
+}
+/** Parent-side demand-driven terminal handle. `ready` publishes only captured
+ * history metadata; the caller must pull every seed byte before `start`. */
 export interface ParentTerminal {
     readonly attachId: string;
     readonly ready: Promise<{
         role: TerminalRole;
+        seedBytes: number;
+        dimensions?: {
+            cols: number;
+            rows: number;
+        };
     }>;
-    onData(listener: (chunk: string) => void): void;
-    onExit(listener: (info: {
-        exitCode: number;
+    readonly readerDone: Promise<ParentTerminalReaderDone>;
+    readSeed(offset: number, maxBytes: number): Promise<ParentTerminalRead>;
+    start(): Promise<void>;
+    read(offset: number, maxBytes: number): Promise<ParentTerminalRead>;
+    onResize?(listener: (dimensions: {
+        cols: number;
+        rows: number;
     }) => void): void;
-    write(data: string): void;
-    resize(cols: number, rows: number): void;
+    write(data: string | Uint8Array): Promise<void>;
+    resize(cols: number, rows: number): Promise<void>;
     close(): void;
 }
 /** A typed attach failure so transport adapters can distinguish an expected
@@ -210,9 +225,8 @@ export declare class RunnerManager implements AgentCapabilities {
     /**
      * Open a live terminal on the session's runner child (spawning it if needed).
      * Phase C hosts one terminal ("main") per session; the returned handle is a
-     * single attach client — `owner` (read-write) or a downgraded `read-only`
-     * viewer per the child's ownership rule. Not part of `AgentExecutor`; the WS
-     * bridge calls it directly.
+     * single attach client with the requested `owner` (read-write) or `read-only`
+     * role. Not part of `AgentExecutor`; the WS bridge calls it directly.
      */
     openTerminal(localThreadId: string, opts: OpenTerminalOptions): ParentTerminal;
     /**
@@ -345,6 +359,7 @@ export declare class RunnerManager implements AgentCapabilities {
      * and tmux's own activity clock are independent busy evidence. There is no
      * "user was inactive for an hour" override for an active turn. */
     private reapNativePane;
+    private reapNativeTerminal;
     private isNativePaneBusy;
     private isManagedNativeHandle;
     private failActiveResponses;