@rynx-ai/runtime 0.1.11-beta.42 → 0.1.11-beta.43

package/dist/host.d.ts

@@ -275,8 +275,8 @@ export declare class LocalAgentHost implements CodexCapabilities {
     /** Structured phase + concrete cause used by the runner wire protocol. */
     liveSessionFailure(localThreadId: string): LiveSessionFailure | undefined;
     /** Publish the background TUI/thread discovery failure so an executor
-     * already waiting in the 60s bridge window exits immediately with the exact
-     * 30s discovery cause. */
+     * already waiting in its runtime-specific bridge window exits immediately
+     * with the exact discovery cause. */
     failLiveStartup(localThreadId: string, error: Error): boolean;
     /**
      * Inject a user turn into a session's live codex thread — reference implementation's
@@ -288,8 +288,9 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * Returns an {@link InjectResult}: `notLive` when this session has no live
      * forwarder (caller may use the run path); `notReady`/`failed` are hard errors
      * the caller reports WITHOUT re-running (re-running double-writes alongside the
-     * forwarder). Park-until-ready (~60s), aligning reference implementation's executor waiting for
-     * the bridge instead of a short race that falls back to a second output path.
+     * forwarder). Park until the runtime's discovery window expires, aligning
+     * reference implementation's executor waiting for the bridge instead of a
+     * short race that falls back to a second output path.
      */
     injectMessage(localThreadId: string, input: RuntimeUserInput | string, options?: RuntimeTurnOptions): Promise<InjectResult>;
     /**

package/dist/host.js

@@ -208,6 +208,9 @@ export class SpawnCodexCommandRunner {
 const CONTEXT_WARN_RATIO = 0.8;
 /** Wait for native bridge/thread binding before injection gives up. */
 const CODEX_BRIDGE_READY_TIMEOUT_MS = 60_000;
+/** Match RunnerSession's hard cap when Traex is visibly updating. Its ordinary
+ * 30-second startup failure still resolves readiness before this deadline. */
+const TRAEX_BRIDGE_READY_TIMEOUT_MS = 2 * 60_000;
 function providerPluginSkillName(namespace, name) {
     const candidate = `${namespace}-${name}`;
     if (candidate.length <= 128)
@@ -1769,8 +1772,8 @@ export class LocalAgentHost {
             : undefined;
     }
     /** Publish the background TUI/thread discovery failure so an executor
-     * already waiting in the 60s bridge window exits immediately with the exact
-     * 30s discovery cause. */
+     * already waiting in its runtime-specific bridge window exits immediately
+     * with the exact discovery cause. */
     failLiveStartup(localThreadId, error) {
         const live = this.liveSessions.get(localThreadId);
         if (!live || live.threadId || live.stopped)
@@ -1793,8 +1796,9 @@ export class LocalAgentHost {
      * Returns an {@link InjectResult}: `notLive` when this session has no live
      * forwarder (caller may use the run path); `notReady`/`failed` are hard errors
      * the caller reports WITHOUT re-running (re-running double-writes alongside the
-     * forwarder). Park-until-ready (~60s), aligning reference implementation's executor waiting for
-     * the bridge instead of a short race that falls back to a second output path.
+     * forwarder). Park until the runtime's discovery window expires, aligning
+     * reference implementation's executor waiting for the bridge instead of a
+     * short race that falls back to a second output path.
      */
     async injectMessage(localThreadId, input, options) {
         const runtimeInput = typeof input === "string"
@@ -1853,9 +1857,13 @@ export class LocalAgentHost {
         const run = live.injectLock.then(async () => {
             if (live.rotationPending || live.stopped)
                 return { outcome: "failed" };
-            // Park until the thread binds (~60s, reference implementation codex_native_executor:177-186),
-            // not a 20s race that returns false and lets the caller re-run on a 2nd path.
-            const bound = await this.waitLiveReady(localThreadId, CODEX_BRIDGE_READY_TIMEOUT_MS);
+            // Park until the thread binds, not a short race that lets the caller
+            // re-run on a second path. Traex gets the update-aware Runner deadline;
+            // its ordinary 30s startup failure still wakes this wait immediately.
+            const readyTimeoutMs = live.runtime === "traex"
+                ? TRAEX_BRIDGE_READY_TIMEOUT_MS
+                : CODEX_BRIDGE_READY_TIMEOUT_MS;
+            const bound = await this.waitLiveReady(localThreadId, readyTimeoutMs);
             const threadId = live.threadId ?? live.forwarder.threadId();
             if (!bound || !threadId)
                 return { outcome: "notReady" };

package/dist/runner/child.d.ts

@@ -97,6 +97,8 @@ export declare class RunnerSession {
     private readonly attachmentRoles;
     private readonly traexStartupWatchers;
     private readonly traexStartupGates;
+    private readonly traexUpdateWatchers;
+    private readonly traexStartupUpdateActivity;
     private readonly codexStartupMonitors;
     private readonly terminalWatchers;
     /** Opens are async; a close received before attach resolves tombstones the id. */
@@ -153,6 +155,7 @@ export declare class RunnerSession {
      */
     private ensureLive;
     private monitorCodexThreadStartup;
+    private waitForTraexThreadStartup;
     /** 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
@@ -168,6 +171,11 @@ export declare class RunnerSession {
     private launchCodexPane;
     private watchNativeTerminal;
     private cancelTraexStartupWatcher;
+    private cancelTraexUpdateWatcher;
+    /** Observe update-only startup screens independently from prompt handling.
+     * The low-frequency capture spans the full normal discovery window and only
+     * remains alive longer after a positively identified update. */
+    private watchTraexStartupUpdates;
     private skipTraexStartupPrompts;
     private stopLive;
     /** Stop event forwarding, kill native terminals/hooks, then synchronously

package/dist/runner/child.js

@@ -18,6 +18,10 @@ import { RunnerTransportWriteError, } from "./transport.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;
+/** Traex may spend most of the normal discovery window installing an update.
+ * Keep one fresh discovery window after visible update activity, but never let
+ * a stuck updater hold the partial native launch indefinitely. */
+const TRAEX_UPDATE_THREAD_START_MAX_MS = 2 * 60_000;
 function providerDisplayName(runtime) {
     return runtime === "traex" ? "Traex" : runtime === "claude" ? "Claude" : "Codex";
 }
@@ -51,6 +55,7 @@ function terminalFailureDetail(pane) {
 const TRAEX_STARTUP_WATCH_MS = 20_000;
 const TRAEX_STARTUP_DISCOVERY_MS = 5_000;
 const TRAEX_STARTUP_POLL_MS = 100;
+const TRAEX_UPDATE_POLL_MS = 1_000;
 const TRAEX_AUTHORIZATION_POLL_MS = 500;
 const TRAEX_AUTHORIZATION_WAIT_MS = 15 * 60_000;
 const TRAEX_ESCAPE_CONFIRM_MS = 1_000;
@@ -128,7 +133,14 @@ function isTraexAuthorizationPending(pane) {
         pane.includes("press esc to cancel");
 }
 function isTraexStartupActivity(pane) {
-    return pane.includes("updating traecode cli") || pane.includes("updating trae cli");
+    // The visible pane can include old conversation text. A mounted composer is
+    // evidence that an update phrase belongs to history rather than the active
+    // startup screen.
+    const composerReady = pane.includes("❯") &&
+        pane.includes("context ") &&
+        pane.includes(" left");
+    return !composerReady &&
+        (pane.includes("updating traecode cli") || pane.includes("updating trae cli"));
 }
 function isTerminalProtocolResponse(input) {
     // xterm answers terminal queries through the same onData channel as real
@@ -191,6 +203,8 @@ export class RunnerSession {
     attachmentRoles = new Map();
     traexStartupWatchers = new Map();
     traexStartupGates = new Map();
+    traexUpdateWatchers = new Map();
+    traexStartupUpdateActivity = new Map();
     codexStartupMonitors = new Map();
     terminalWatchers = new Map();
     /** Opens are async; a close received before attach resolves tombstones the id. */
@@ -1061,8 +1075,8 @@ export class RunnerSession {
             }
             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.
+                // Discover thread/started in the background while injection waits for
+                // either bridge readiness or the runtime-specific startup deadline.
                 // Do not serialize the two waits here.
                 this.monitorCodexThreadStartup(msg.localThreadId, runtime, provider);
             }
@@ -1117,12 +1131,20 @@ export class RunnerSession {
                 this.terminals.get(`${localThreadId}-main`) !== expectedTerminal)
                 return false;
             this.codexStartupMonitors.delete(localThreadId);
+            if (runtime === "traex") {
+                this.cancelTraexUpdateWatcher(localThreadId);
+                this.traexStartupUpdateActivity.delete(localThreadId);
+            }
             return true;
         };
-        void provider.waitLiveReady(localThreadId, CODEX_THREAD_START_TIMEOUT_MS).then((ready) => {
-            if (ready) {
+        const handleResult = (result) => {
+            if (result.ready) {
                 if (this.codexStartupMonitors.get(localThreadId) === monitor) {
                     this.codexStartupMonitors.delete(localThreadId);
+                    if (runtime === "traex") {
+                        this.cancelTraexUpdateWatcher(localThreadId);
+                        this.traexStartupUpdateActivity.delete(localThreadId);
+                    }
                 }
                 return;
             }
@@ -1142,16 +1164,81 @@ export class RunnerSession {
             const detail = provider.liveSessionError?.(localThreadId)
                 ?? (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`);
+                    : result.updateObserved
+                        ? `Traex TUI did not publish thread/started before its update-aware startup deadline (${Math.ceil(result.elapsedMs / 1_000)}s elapsed)`
+                        : `${runtime === "traex" ? "Traex" : "Codex"} TUI did not publish thread/started within ${CODEX_THREAD_START_TIMEOUT_MS / 1_000}s after app-server and observer readiness`);
             this.failCodexThreadStartup(localThreadId, provider, new AgentRuntimeError(detail, 503, paneFailure
                 ? "native_terminal_exited_before_session"
                 : "native_thread_discovery_timeout"), expectedTerminal);
-        }).catch((error) => {
+        };
+        const handleError = (error) => {
             if (!claimCurrentLaunch())
                 return;
             this.failCodexThreadStartup(localThreadId, provider, error instanceof AgentRuntimeError
                 ? error
                 : nativePhaseError(runtime, "native_thread_discovery_failed", "native session discovery failed", error), expectedTerminal);
+        };
+        if (runtime === "traex") {
+            void this.waitForTraexThreadStartup(localThreadId, provider, expectedTerminal, monitor).then(handleResult).catch(handleError);
+            return;
+        }
+        void provider.waitLiveReady(localThreadId, CODEX_THREAD_START_TIMEOUT_MS).then((ready) => {
+            handleResult({
+                ready,
+                updateObserved: false,
+                elapsedMs: CODEX_THREAD_START_TIMEOUT_MS,
+            });
+        }).catch(handleError);
+    }
+    async waitForTraexThreadStartup(localThreadId, provider, expectedTerminal, monitor) {
+        const startedAt = Date.now();
+        const hardDeadline = startedAt + TRAEX_UPDATE_THREAD_START_MAX_MS;
+        let deadline = startedAt + CODEX_THREAD_START_TIMEOUT_MS;
+        let updateObserved = false;
+        const readiness = provider.waitLiveReady(localThreadId, null);
+        return await new Promise((resolve, reject) => {
+            let settled = false;
+            let timer;
+            const finish = (ready, now = Date.now()) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                resolve({ ready, updateObserved, elapsedMs: now - startedAt });
+            };
+            const checkDeadline = () => {
+                if (this.codexStartupMonitors.get(localThreadId) !== monitor ||
+                    this.terminals.get(`${localThreadId}-main`) !== expectedTerminal) {
+                    finish(false);
+                    return;
+                }
+                const now = Date.now();
+                const updateObservedAt = this.traexStartupUpdateActivity.get(localThreadId);
+                if (updateObservedAt !== undefined) {
+                    if (!updateObserved) {
+                        console.info(`[runner] session=${localThreadId} Traex startup update detected; extending native thread discovery up to ${TRAEX_UPDATE_THREAD_START_MAX_MS / 1_000}s`);
+                    }
+                    updateObserved = true;
+                    deadline = Math.min(hardDeadline, updateObservedAt + CODEX_THREAD_START_TIMEOUT_MS);
+                }
+                const remainingMs = Math.min(deadline, hardDeadline) - now;
+                if (remainingMs <= 0) {
+                    finish(false, now);
+                    return;
+                }
+                timer = setTimeout(checkDeadline, Math.min(TRAEX_STARTUP_POLL_MS, remainingMs));
+                timer.unref?.();
+            };
+            void readiness.then((ready) => finish(ready), (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                reject(error);
+            });
+            checkDeadline();
         });
     }
     /** Discovery failure is terminal for this partial native launch. Publish the
@@ -1167,6 +1254,8 @@ export class RunnerSession {
             clearInterval(watcher);
         this.terminalWatchers.delete(localThreadId);
         this.cancelTraexStartupWatcher(localThreadId);
+        this.cancelTraexUpdateWatcher(localThreadId);
+        this.traexStartupUpdateActivity.delete(localThreadId);
         try {
             this.terminals.close(`${localThreadId}-main`, expectedTerminal);
         }
@@ -1272,6 +1361,7 @@ export class RunnerSession {
                 clearInterval(watcher);
             this.terminalWatchers.delete(msg.localThreadId);
             this.cancelTraexStartupWatcher(msg.localThreadId);
+            this.cancelTraexUpdateWatcher(msg.localThreadId);
             for (const [attachId, sessionId] of this.attachmentThreadIds) {
                 if (sessionId !== msg.localThreadId)
                     continue;
@@ -1328,9 +1418,13 @@ export class RunnerSession {
                 : { keepAliveAfterExit: spec.keepAliveAfterExit }),
         });
         if (spec.skipTraexStartupPrompts) {
-            const watcher = Symbol(localThreadId);
+            const watcher = Symbol(`${localThreadId}:prompts`);
+            const updateWatcher = Symbol(`${localThreadId}:updates`);
+            this.traexStartupUpdateActivity.delete(localThreadId);
             this.traexStartupWatchers.set(localThreadId, watcher);
+            this.traexUpdateWatchers.set(localThreadId, updateWatcher);
             const gate = this.skipTraexStartupPrompts(localThreadId, term, watcher);
+            void this.watchTraexStartupUpdates(localThreadId, term, updateWatcher);
             this.traexStartupGates.set(localThreadId, gate);
             void gate.finally(() => {
                 if (this.traexStartupGates.get(localThreadId) === gate) {
@@ -1367,6 +1461,7 @@ export class RunnerSession {
                 clearInterval(timer);
                 this.terminalWatchers.delete(localThreadId);
                 this.cancelTraexStartupWatcher(localThreadId);
+                this.cancelTraexUpdateWatcher(localThreadId);
                 const runtime = this.liveRuntimes.get(localThreadId);
                 const lifecycle = this.terminals.lifecycle(terminalId);
                 const paneFailure = terminalFailureDetail(terminal.capturePane?.() ?? "");
@@ -1414,6 +1509,47 @@ export class RunnerSession {
         if (localThreadId)
             this.traexStartupWatchers.delete(localThreadId);
     }
+    cancelTraexUpdateWatcher(localThreadId) {
+        if (localThreadId)
+            this.traexUpdateWatchers.delete(localThreadId);
+    }
+    /** Observe update-only startup screens independently from prompt handling.
+     * The low-frequency capture spans the full normal discovery window and only
+     * remains alive longer after a positively identified update. */
+    async watchTraexStartupUpdates(localThreadId, terminal, watcher) {
+        const startedAt = Date.now();
+        const hardDeadline = startedAt + TRAEX_UPDATE_THREAD_START_MAX_MS;
+        let deadline = startedAt + CODEX_THREAD_START_TIMEOUT_MS;
+        const terminalId = `${localThreadId}-main`;
+        while (!this.shuttingDown &&
+            this.traexUpdateWatchers.get(localThreadId) === watcher &&
+            this.terminals.get(terminalId) === terminal) {
+            const now = Date.now();
+            if (now > deadline)
+                break;
+            try {
+                const pane = normalizeTraexPane(terminal.capturePane());
+                if (isTraexStartupActivity(pane)) {
+                    this.traexStartupUpdateActivity.set(localThreadId, now);
+                    deadline = Math.min(hardDeadline, now + CODEX_THREAD_START_TIMEOUT_MS);
+                }
+            }
+            catch {
+                // A concurrent terminal teardown owns the lifecycle failure. Keep the
+                // bounded observer alive until that path invalidates this watcher.
+            }
+            const remainingMs = deadline - Date.now();
+            if (remainingMs <= 0)
+                break;
+            await new Promise((resolve) => {
+                const timer = setTimeout(resolve, Math.min(TRAEX_UPDATE_POLL_MS, remainingMs));
+                timer.unref();
+            });
+        }
+        if (this.traexUpdateWatchers.get(localThreadId) === watcher) {
+            this.traexUpdateWatchers.delete(localThreadId);
+        }
+    }
     async skipTraexStartupPrompts(localThreadId, terminal, watcher) {
         const prompts = [
             {
@@ -1459,7 +1595,8 @@ export class RunnerSession {
             const prompt = prompts.find((candidate) => candidate.matches(pane));
             const now = Date.now();
             const authorizationPending = isTraexAuthorizationPending(pane);
-            if (isTraexStartupActivity(pane)) {
+            const updateActive = isTraexStartupActivity(pane);
+            if (updateActive) {
                 discoveryDeadline = now + TRAEX_STARTUP_DISCOVERY_MS;
             }
             // Human device authorization routinely takes longer than the normal
@@ -1483,7 +1620,7 @@ export class RunnerSession {
                 // updater keeps the full startup window because prompts may follow it.
                 if (now >= discoveryDeadline &&
                     !authorizationPending &&
-                    !isTraexStartupActivity(pane))
+                    !updateActive)
                     break;
             }
             else if (!prompt.requiresEscapeConfirmation) {
@@ -1542,6 +1679,8 @@ export class RunnerSession {
             clearInterval(timer);
         this.terminalWatchers.clear();
         this.codexStartupMonitors.clear();
+        this.traexUpdateWatchers.clear();
+        this.traexStartupUpdateActivity.clear();
         for (const id of this.liveIds) {
             this.liveProvider.stopLiveCodexSession?.(id, {
                 deferClaudeInteractionCleanup: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.42",
+  "version": "0.1.11-beta.43",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -26,7 +26,7 @@
   "dependencies": {
     "smol-toml": "1.7.1",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.42"
+    "@rynx-ai/core": "0.1.11-beta.43"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"