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

package/dist/index.d.ts

@@ -13,6 +13,6 @@ export type { InjectOutcome, TerminalOpenErrorCode, TerminalRole } from "./runne
 export type { ResolveInteractionResult, RuntimeInteractionEvent, RuntimeInteractionListener, } from "./interactions.js";
 export { probeRuntimeStatus } from "./runtime-status.js";
 export { listRuntimeModels } from "./models-catalog.js";
-export { TmuxTerminal, isTmuxAvailable } from "./terminal/tmux.js";
+export { TmuxTerminal, isTmuxAvailable, terminateTmuxServer, tmuxSocketPath, } from "./terminal/tmux.js";
 export type { TerminalAttachment, TmuxTerminalOptions } from "./terminal/tmux.js";
 export { TerminalRegistry } from "./terminal/registry.js";

package/dist/index.js

@@ -12,5 +12,5 @@ export { RunnerManager, TerminalOpenError } from "./runner/manager.js";
 export { probeRuntimeStatus } from "./runtime-status.js";
 export { listRuntimeModels } from "./models-catalog.js";
 // Live-terminal subsystem (Phase C): tmux-backed terminals + per-runner registry.
-export { TmuxTerminal, isTmuxAvailable } from "./terminal/tmux.js";
+export { TmuxTerminal, isTmuxAvailable, terminateTmuxServer, tmuxSocketPath, } from "./terminal/tmux.js";
 export { TerminalRegistry } from "./terminal/registry.js";

package/dist/models-catalog.d.ts

@@ -1,11 +1,12 @@
 import { type AgentRuntimeId, type AppConfig } from "@rynx-ai/core";
 import type { ModelListResponse } from "./codex-app-server/protocol.js";
 export interface RuntimeModelCatalogDeps {
+    readCodexModels?: () => Promise<unknown>;
     readTraexModels?: () => Promise<unknown>;
     readTraexDebugModels?: () => Promise<unknown>;
 }
 /**
  * The model list for a runtime, without an execution backend.
- * Falls back to the configured model if live Traex discovery is unavailable.
+ * Falls back to the configured model if local/native discovery is unavailable.
  */
 export declare function listRuntimeModels(config: AppConfig, runtime: AgentRuntimeId, deps?: RuntimeModelCatalogDeps): Promise<ModelListResponse | null>;

package/dist/models-catalog.js

@@ -3,24 +3,37 @@
  *
  * The parent control plane no longer holds an app-server, so `/models` can't be
  * a live `model/list` RPC anymore. Following reference implementation's static-catalog model, we
- * serve a config-derived Codex list and Traex's native `models --json` catalog.
+ * serve Codex's local model cache and Traex's native `models --json` catalog.
  * claude already has its own static list ({@link listClaudeModels}).
  */
 import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
 import { promisify } from "node:util";
-import { resolveRuntimeBinary, resolveRuntimeModel, } from "@rynx-ai/core";
+import { getRuntimeProfile, resolveRuntimeBinary, resolveRuntimeHome, resolveRuntimeModel, } from "@rynx-ai/core";
 import { listClaudeModels } from "./claude/models.js";
 const execFileAsync = promisify(execFile);
 const TRAEX_MODELS_TIMEOUT_MS = 8_000;
 const TRAEX_MODELS_MAX_BYTES = 2 * 1024 * 1024;
 /**
  * The model list for a runtime, without an execution backend.
- * Falls back to the configured model if live Traex discovery is unavailable.
+ * Falls back to the configured model if local/native discovery is unavailable.
  */
 export async function listRuntimeModels(config, runtime, deps = {}) {
     if (runtime === "claude") {
         return listClaudeModels();
     }
+    if (runtime === "codex") {
+        try {
+            const configuredDefault = resolveRuntimeModel(config, runtime).trim();
+            const models = normalizeCodexModels(await (deps.readCodexModels ?? readCodexModels)(), configuredDefault);
+            if (models.length > 0)
+                return { data: models };
+        }
+        catch {
+            // Keep the configured fallback usable before Codex has populated its cache.
+        }
+    }
     if (runtime === "traex") {
         try {
             const value = await (deps.readTraexModels ?? readTraexModels)();
@@ -48,6 +61,72 @@ export async function listRuntimeModels(config, runtime, deps = {}) {
     }
     return { data: [{ id: model, model, isDefault: true }] };
 }
+async function readCodexModels() {
+    const cachePath = join(resolveRuntimeHome(getRuntimeProfile("codex")), "models_cache.json");
+    return JSON.parse(await readFile(cachePath, "utf8"));
+}
+function normalizeCodexModels(value, configuredDefault) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+    const entries = value.models;
+    if (!Array.isArray(entries))
+        return [];
+    const models = [];
+    const seen = new Set();
+    for (const item of entries) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const record = item;
+        const id = typeof record.slug === "string" ? record.slug.trim() : "";
+        if (!id || seen.has(id) || record.visibility === "hide")
+            continue;
+        seen.add(id);
+        const supportedReasoningEfforts = Array.isArray(record.supported_reasoning_levels)
+            ? record.supported_reasoning_levels.flatMap((raw) => {
+                if (!raw || typeof raw !== "object" || Array.isArray(raw))
+                    return [];
+                const effort = typeof raw.effort === "string"
+                    ? raw.effort.trim()
+                    : "";
+                if (!effort)
+                    return [];
+                const description = raw.description;
+                return [{
+                        reasoningEffort: effort,
+                        ...(typeof description === "string" && description.trim()
+                            ? { description: description.trim() }
+                            : {}),
+                    }];
+            })
+            : [];
+        const displayName = typeof record.display_name === "string"
+            ? record.display_name.trim()
+            : "";
+        const description = typeof record.description === "string"
+            ? record.description.trim()
+            : "";
+        const defaultReasoningEffort = typeof record.default_reasoning_level === "string"
+            ? record.default_reasoning_level.trim()
+            : "";
+        models.push({
+            id,
+            model: id,
+            ...(displayName ? { displayName } : {}),
+            ...(description ? { description } : {}),
+            isDefault: id === configuredDefault,
+            ...(supportedReasoningEfforts.length > 0 ? { supportedReasoningEfforts } : {}),
+            ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
+        });
+    }
+    if (configuredDefault && !seen.has(configuredDefault)) {
+        models.unshift({
+            id: configuredDefault,
+            model: configuredDefault,
+            isDefault: true,
+        });
+    }
+    return models;
+}
 async function readTraexModels() {
     const { stdout } = await execFileAsync(resolveRuntimeBinary("traex"), ["models", "--json"], {
         encoding: "utf8",

package/dist/runner/child.d.ts

@@ -31,15 +31,20 @@ interface LiveCodexProvider {
         args: string[];
         cwd: string;
         env?: Record<string, string>;
+        skipTraexStartupPrompts?: boolean;
     } | null>;
     ensureLiveCodexSession?(localThreadId: string, emit: (event: SessionEvent) => void, opts: {
         workspace: SessionWorkspaceSnapshot;
         execution: ResolvedExecutionSnapshot;
         retargetMirror?: RetargetMirror;
     }): Promise<boolean>;
-    waitLiveReady?(localThreadId: string, timeoutMs?: number): Promise<boolean>;
-    waitTerminalReady?(localThreadId: string, timeoutMs?: number): Promise<boolean>;
+    /** `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;
+    failLiveStartup?(localThreadId: string, error: Error): boolean;
+    failLiveSession?(localThreadId: string, error: Error): boolean;
     injectMessage?(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
     interruptLive?(localThreadId: string): Promise<boolean>;
     stopLiveCodexSession?(localThreadId: string, opts?: {
@@ -71,6 +76,9 @@ export declare class RunnerSession {
     /** Live terminals hosted by this session, and per-attach client handles. */
     private readonly terminals;
     private readonly attachments;
+    private readonly attachmentThreadIds;
+    private readonly traexStartupWatchers;
+    private readonly terminalWatchers;
     /** Opens are async; a close received before attach resolves tombstones the id. */
     private readonly pendingTerminalOpens;
     private readonly cancelledTerminalOpens;
@@ -89,18 +97,26 @@ export declare class RunnerSession {
     private mirrorChannel;
     /**
      * Eagerly bring up a session's codex-native live view: start the persistent
-     * forwarder connection (which resume-subscribes to mirror every turn) and
-     * launch the detached `codex --remote resume` TUI against the thread the
-     * structured runtime created. The forwarder subscribes to that same thread,
-     * so the TUI is usable immediately and its turns mirror to chat.
+     * 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.
      */
     private ensureLive;
+    private monitorCodexThreadStartup;
+    /** 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. */
+    private failCodexThreadStartup;
     private inject;
     private interruptLive;
     /** 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. */
     private launchCodexPane;
+    private watchNativeTerminal;
+    private cancelTraexStartupWatcher;
+    private skipTraexStartupPrompts;
     private stopLive;
     /** Stop event forwarding, kill native terminals/hooks, then synchronously
      * scrub provider handoff files before the child process is allowed to exit. */

package/dist/runner/child.js

@@ -1,5 +1,28 @@
 import { TerminalRegistry } from "../terminal/registry.js";
 import { toWireError } from "./protocol.js";
+import { isManagedNativeProvider } 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;
+const TRAEX_STARTUP_WATCH_MS = 20_000;
+const TRAEX_STARTUP_POLL_MS = 100;
+const TRAEX_AUTHORIZATION_POLL_MS = 500;
+const TRAEX_AUTHORIZATION_WAIT_MS = 15 * 60_000;
+const TRAEX_PROMPT_RETRY_MS = 500;
+function normalizeTraexPane(pane) {
+    return pane.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function isTraexAuthorizationPending(pane) {
+    return pane.includes("waiting for authorization") &&
+        pane.includes("open this link in your browser") &&
+        pane.includes("press esc to cancel");
+}
+function isTerminalProtocolResponse(input) {
+    // xterm answers terminal queries through the same onData channel as real
+    // keystrokes. CSI carries device/focus/position reports; OSC carries color
+    // query replies such as `OSC 10;rgb:... ST` and `OSC 11;rgb:... ST`.
+    // Neither is evidence that the user has taken over startup prompt handling.
+    return /^(?:\x1b\[(?:(?:\?|>)[0-9;]*c|[0-9;]*(?:n|R|t)|[IO])|\x1b\][0-9]+;[^\x07\x1b]*(?:\x07|\x1b\\))+$/.test(input);
+}
 export class RunnerSession {
     transport;
     executor;
@@ -7,6 +30,9 @@ export class RunnerSession {
     /** Live terminals hosted by this session, and per-attach client handles. */
     terminals = new TerminalRegistry();
     attachments = new Map();
+    attachmentThreadIds = new Map();
+    traexStartupWatchers = new Map();
+    terminalWatchers = new Map();
     /** Opens are async; a close received before attach resolves tombstones the id. */
     pendingTerminalOpens = new Set();
     cancelledTerminalOpens = new Set();
@@ -46,7 +72,17 @@ export class RunnerSession {
                 });
                 return;
             case "term.input":
-                this.attachments.get(msg.attachId)?.write(Buffer.from(msg.dataB64, "base64").toString("utf8"));
+                {
+                    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);
+                }
                 return;
             case "term.resize":
                 this.attachments.get(msg.attachId)?.resize(msg.cols, msg.rows);
@@ -57,6 +93,7 @@ export class RunnerSession {
                 }
                 const attachment = this.attachments.get(msg.attachId);
                 this.attachments.delete(msg.attachId);
+                this.attachmentThreadIds.delete(msg.attachId);
                 attachment?.kill();
                 return;
             }
@@ -123,10 +160,9 @@ export class RunnerSession {
     }
     /**
      * Eagerly bring up a session's codex-native live view: start the persistent
-     * forwarder connection (which resume-subscribes to mirror every turn) and
-     * launch the detached `codex --remote resume` TUI against the thread the
-     * structured runtime created. The forwarder subscribes to that same thread,
-     * so the TUI is usable immediately and its turns mirror to chat.
+     * 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.
      */
     async ensureLive(msg) {
         const provider = this.liveProvider;
@@ -143,51 +179,59 @@ export class RunnerSession {
                     reqId: msg.reqId,
                     localThreadId: msg.localThreadId,
                     ok: false,
-                    error: "live provider did not start",
+                    error: provider.liveSessionError?.(msg.localThreadId)
+                        ?? "live provider 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;
             // 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)
+                    ? await provider.waitTerminalReady(msg.localThreadId, terminalReadyTimeoutMs)
                     : true;
                 if (!terminalReady) {
+                    const providerName = runtime === "traex" ? "Traex" : runtime === "codex" ? "Codex" : "Provider";
                     this.transport.send({
                         t: "live.ready",
                         reqId: msg.reqId,
                         localThreadId: msg.localThreadId,
                         ok: false,
-                        error: "Provider thread was not ready for Terminal resume",
+                        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",
                     });
                     return;
                 }
                 await this.launchCodexPane(msg.localThreadId, msg.cols, msg.rows);
             }
-            const ready = msg.waitForReady === false
-                ? true
-                : provider.waitLiveReady
-                    ? await provider.waitLiveReady(msg.localThreadId)
-                    : true;
-            const terminal = this.terminals.get(`${msg.localThreadId}-main`);
-            const paneFailure = !ready && terminal && !terminal.isAlive()
-                ? terminal
-                    .capturePane()
-                    .split("\n")
-                    .map((line) => line.trim())
-                    .filter(Boolean)
-                    .slice(-6)
-                    .join(" ")
-                    .slice(-1_000)
-                : "";
-            const readinessError = provider.liveSessionError?.(msg.localThreadId)
-                ?? (paneFailure
-                    ? `Provider terminal exited before session discovery: ${paneFailure}`
-                    : "live session was not ready before timeout");
+            let ready = true;
+            if (runtime === "codex" || runtime === "traex") {
+                // Discover thread/started in the background for 30s while injection
+                // waits up to 60s for either bridge readiness or that startup error.
+                // Do not serialize the two waits here.
+                this.monitorCodexThreadStartup(msg.localThreadId, runtime, provider);
+            }
+            else if (msg.waitForReady !== false && provider.waitLiveReady) {
+                ready = await provider.waitLiveReady(msg.localThreadId, terminalReadyTimeoutMs);
+            }
+            const readinessError = ready
+                ? undefined
+                : provider.liveSessionError?.(msg.localThreadId)
+                    ?? "live session was not ready before timeout";
             this.transport.send({
                 t: "live.ready",
                 reqId: msg.reqId,
@@ -206,12 +250,70 @@ export class RunnerSession {
             });
         }
     }
+    monitorCodexThreadStartup(localThreadId, runtime, provider) {
+        if (!provider.waitLiveReady)
+            return;
+        void provider.waitLiveReady(localThreadId, CODEX_THREAD_START_TIMEOUT_MS).then((ready) => {
+            if (ready)
+                return;
+            const terminal = this.terminals.get(`${localThreadId}-main`);
+            const paneFailure = terminal && !terminal.isAlive()
+                ? terminal
+                    .capturePane()
+                    .split("\n")
+                    .map((line) => line.trim())
+                    .filter(Boolean)
+                    .slice(-6)
+                    .join(" ")
+                    .slice(-1_000)
+                : "";
+            const detail = provider.liveSessionError?.(localThreadId)
+                ?? (paneFailure
+                    ? `Provider terminal exited before 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));
+        }).catch((error) => {
+            this.failCodexThreadStartup(localThreadId, provider, error instanceof Error ? error : new Error(String(error)));
+        });
+    }
+    /** 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) {
+        if (!provider.failLiveStartup?.(localThreadId, error))
+            return;
+        const watcher = this.terminalWatchers.get(localThreadId);
+        if (watcher)
+            clearInterval(watcher);
+        this.terminalWatchers.delete(localThreadId);
+        this.cancelTraexStartupWatcher(localThreadId);
+        try {
+            this.terminals.close(`${localThreadId}-main`);
+        }
+        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);
+        this.liveIds.delete(localThreadId);
+    }
     async inject(msg) {
         const provider = this.liveProvider;
         try {
             const input = msg.input ?? msg.text;
             const outcome = (await provider.injectMessage?.(msg.localThreadId, input)) ?? "notLive";
-            this.transport.send({ t: "injected", reqId: msg.reqId, localThreadId: msg.localThreadId, outcome });
+            // 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"
+                ? undefined
+                : provider.liveSessionError?.(msg.localThreadId);
+            this.transport.send({
+                t: "injected",
+                reqId: msg.reqId,
+                localThreadId: msg.localThreadId,
+                outcome,
+                ...(error ? { error } : {}),
+            });
         }
         catch (error) {
             this.transport.send({
@@ -248,7 +350,8 @@ export class RunnerSession {
         const spec = await this.liveProvider.codexTerminalSpec?.(localThreadId);
         if (!spec)
             return;
-        const term = this.terminals.getOrCreate(`${localThreadId}-main`, {
+        const terminalId = `${localThreadId}-main`;
+        const term = this.terminals.getOrCreate(terminalId, {
             cwd: spec.cwd,
             command: spec.command,
             args: spec.args,
@@ -256,9 +359,110 @@ export class RunnerSession {
             rows: rows ?? 40,
             ...(spec.env ? { env: spec.env } : {}),
         });
+        if (spec.skipTraexStartupPrompts) {
+            const watcher = Symbol(localThreadId);
+            this.traexStartupWatchers.set(localThreadId, watcher);
+            void this.skipTraexStartupPrompts(localThreadId, term, watcher);
+        }
         this.liveProvider.attachTerminalInjector?.(localThreadId, term);
+        this.watchNativeTerminal(localThreadId, terminalId, term);
+    }
+    watchNativeTerminal(localThreadId, terminalId, terminal) {
+        const previous = this.terminalWatchers.get(localThreadId);
+        if (previous)
+            clearInterval(previous);
+        let checking = false;
+        const timer = setInterval(() => {
+            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)
+                    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"));
+            }).finally(() => {
+                checking = false;
+            });
+        }, 1_000);
+        timer.unref?.();
+        this.terminalWatchers.set(localThreadId, timer);
+    }
+    cancelTraexStartupWatcher(localThreadId) {
+        if (localThreadId)
+            this.traexStartupWatchers.delete(localThreadId);
+    }
+    async skipTraexStartupPrompts(localThreadId, terminal, watcher) {
+        const prompts = [
+            {
+                id: "welcome",
+                matches: (pane) => pane.includes("welcome to trae cli") && pane.includes("press enter to continue"),
+                dismiss: () => terminal.sendEnter(),
+            },
+            {
+                id: "migration",
+                matches: (pane) => pane.includes("legacy trae cli data detected") &&
+                    pane.includes("select what to import") &&
+                    (pane.includes("skip for now") || pane.includes("don't ask again")),
+                dismiss: () => terminal.interrupt(),
+            },
+            {
+                id: "hooks",
+                matches: (pane) => pane.includes("hooks need review") &&
+                    pane.includes("trust all and continue") &&
+                    pane.includes("continue without trusting"),
+                dismiss: () => terminal.interrupt(),
+            },
+        ];
+        let activePromptId;
+        let lastDismissedAt = 0;
+        const startedAt = Date.now();
+        let deadline = startedAt + TRAEX_STARTUP_WATCH_MS;
+        const authorizationDeadline = startedAt + TRAEX_AUTHORIZATION_WAIT_MS;
+        const terminalId = `${localThreadId}-main`;
+        while (!this.shuttingDown &&
+            Date.now() < deadline &&
+            this.traexStartupWatchers.get(localThreadId) === watcher &&
+            this.terminals.get(terminalId) === terminal) {
+            // Do not treat a composer frame as completion: Traex can render it before
+            // the startup modals arrive. The bounded deadline stops this watcher.
+            const pane = normalizeTraexPane(terminal.capturePane());
+            const prompt = prompts.find((candidate) => candidate.matches(pane));
+            const now = Date.now();
+            const authorizationPending = isTraexAuthorizationPending(pane);
+            // Human device authorization routinely takes longer than the normal
+            // startup-modal window. Keep watching while that known screen remains,
+            // then preserve a full window for welcome/migration/hooks after sign-in.
+            // The separate cap prevents an abandoned auth screen from polling forever.
+            if (authorizationPending && now < authorizationDeadline) {
+                deadline = now + TRAEX_STARTUP_WATCH_MS;
+            }
+            if (!prompt) {
+                activePromptId = undefined;
+            }
+            else if (prompt.id !== activePromptId ||
+                now - lastDismissedAt >= TRAEX_PROMPT_RETRY_MS) {
+                prompt.dismiss();
+                activePromptId = prompt.id;
+                lastDismissedAt = now;
+            }
+            await new Promise((resolve) => {
+                const timer = setTimeout(resolve, authorizationPending ? TRAEX_AUTHORIZATION_POLL_MS : TRAEX_STARTUP_POLL_MS);
+                timer.unref();
+            });
+        }
+        if (this.traexStartupWatchers.get(localThreadId) === watcher) {
+            this.traexStartupWatchers.delete(localThreadId);
+        }
     }
     stopLive() {
+        for (const timer of this.terminalWatchers.values())
+            clearInterval(timer);
+        this.terminalWatchers.clear();
         for (const id of this.liveIds) {
             this.liveProvider.stopLiveCodexSession?.(id, {
                 deferClaudeInteractionCleanup: true,
@@ -336,6 +540,8 @@ export class RunnerSession {
             return;
         }
         this.attachments.set(msg.attachId, attachment);
+        if (msg.localThreadId)
+            this.attachmentThreadIds.set(msg.attachId, msg.localThreadId);
         attachment.onData((chunk) => this.transport.send({
             t: "term.data",
             attachId: msg.attachId,
@@ -343,6 +549,7 @@ export class RunnerSession {
         }));
         attachment.onExit((info) => {
             this.attachments.delete(msg.attachId);
+            this.attachmentThreadIds.delete(msg.attachId);
             this.transport.send({ t: "term.exit", attachId: msg.attachId, exitCode: info.exitCode });
         });
         this.transport.send({ t: "term.opened", attachId: msg.attachId, role });