@rynx-ai/runtime 0.1.11-beta.30 → 0.1.11-beta.31

package/dist/codex-app-server/forwarder.js

@@ -52,13 +52,13 @@ function isTurnScopedMethod(method) {
 function canRecoverMissedTurnFrom(method) {
     return method === "item/agentMessage/delta" || method === "item/plan/delta";
 }
-/** Omnigent forwards these live deltas only for the bridge's exact active
- * Codex turn. Assistant/plan deltas may recover a missed `turn/started` when
+/** Live deltas require the bridge's exact active Codex turn. Assistant/plan
+ * deltas may recover a missed `turn/started` when
  * fully scoped; command output never opens or recovers a Turn. */
 function requiresMatchingActiveTurn(method) {
     return canRecoverMissedTurnFrom(method) || method === "item/commandExecution/outputDelta";
 }
-/** Content Omnigent forwards independently from the active-turn status edge. */
+/** Turn content that remains valid independently of lifecycle status. */
 function isIndependentTurnContent(method) {
     return method === "item/started" ||
         method === "item/reasoning/textDelta" ||
@@ -412,8 +412,8 @@ export class CodexSessionForwarder {
         }
         if (requiresMatchingActiveTurn(method)) {
             if (this.currentTurnIdValue !== null) {
-                // An id-less delta is not attributable to the active Turn. Omnigent's
-                // `_is_active_turn_delta` applies the same exact-id requirement.
+                // An id-less delta is not attributable to the active Turn. Require
+                // the exact active Turn id before forwarding it.
                 if (carriedTurnId !== this.currentTurnIdValue)
                     return;
             }
@@ -465,8 +465,8 @@ export class CodexSessionForwarder {
         if (canonicalEvents.some((event) => event.type !== "reasoning_delta" && event.type !== "reasoning_completed")) {
             this.flushDeferredAssistantMessage();
         }
-        // Omnigent's item/content channel is independent from its turn-status
-        // channel. A scoped item or reasoning delta that arrives after the terminal
+        // Item/content delivery is independent from turn lifecycle status. A
+        // scoped item or reasoning delta that arrives after the terminal
         // edge remains visible, but must not synthesize another running response.
         if (!this.turnOpen &&
             this.currentTurnIdValue === null &&

package/dist/host.js

@@ -21,7 +21,7 @@ import { buildCodexRemoteArgs } from "./terminal/codex-tui.js";
 import { buildClaudeTuiArgs } from "./terminal/claude-tui.js";
 import { providerAdditionalDirs, threadWorkspaceParams, turnWorkspaceParams, } from "./provider-workspace.js";
 import { ensureProjectTrusted } from "./claude/trust.js";
-import { claudeAttachmentToken, claudeInputText, codexUserEchoContent, runtimeUserContent, } from "./input-resources.js";
+import { claudeAttachmentToken, claudeInputText, runtimeUserContent, } from "./input-resources.js";
 import { claudeBridgeDir, prepareClaudeBridgeDir, removeManagedClaudeSettings, writeManagedClaudeSettings, } from "./claude/native-bridge.js";
 import { ClaudeLiveSession, injectViaTerminal, } from "./claude/native-integration.js";
 import { buildClaudeHookSettings } from "./claude/native-hooks.js";
@@ -873,7 +873,6 @@ export class LocalAgentHost {
             markTerminalReady,
             injectLock: Promise.resolve(),
             pendingInjectedInputs: [],
-            publishInjectedInput: () => undefined,
             publishTurnAdmission: () => undefined,
             publishTurnAdmissionFailure: () => undefined,
             publishInterrupted: () => undefined,
@@ -930,14 +929,6 @@ export class LocalAgentHost {
             });
             return normalizer;
         };
-        live.publishInjectedInput = (turnId, content) => {
-            const n = startNormalizer(turnId);
-            const pending = live.pendingInjectedInputs.find((entry) => entry.signature === JSON.stringify(content) && entry.responseId === undefined);
-            if (pending && currentResponseId)
-                pending.responseId = currentResponseId;
-            for (const se of n.userInput(content))
-                emitCurrent(se);
-        };
         live.publishTurnAdmission = () => {
             emitCurrent({
                 type: "session.status",
@@ -970,7 +961,7 @@ export class LocalAgentHost {
                 contentNormalizers.set(responseId, contentNormalizer);
             }
             for (const event of produce(contentNormalizer)) {
-                // Omnigent posts item/transient content under the Turn's response id
+                // Item/transient content is attached to the Turn's response id
                 // independently of lifecycle status. Reuse Rynx's canonical item
                 // normalization but suppress its synthetic lifecycle edges.
                 if (event.type !== "response.created" && event.type !== "session.status") {
@@ -982,14 +973,16 @@ export class LocalAgentHost {
             const normalizedContent = typeof content === "string"
                 ? [{ type: "input_text", text: content }]
                 : content;
-            const signature = JSON.stringify(normalizedContent);
-            const pending = live.pendingInjectedInputs.find((entry) => entry.signature === signature || entry.providerEchoSignature === signature);
-            if (pending?.state === "optimistic") {
-                live.pendingInjectedInputs.splice(live.pendingInjectedInputs.indexOf(pending), 1);
-                return null;
-            }
-            if (pending)
+            // The Provider does not echo a caller id and may reformat the text, so the
+            // first native user record drains the oldest injected input instead of
+            // comparing message text.
+            const pending = live.pendingInjectedInputs[0];
+            if (pending) {
                 pending.observed = true;
+                if (pending.state === "accepted") {
+                    live.pendingInjectedInputs.shift();
+                }
+            }
             return normalizedContent;
         };
         const rememberSettledInteraction = (interactionId) => {
@@ -1293,16 +1286,12 @@ export class LocalAgentHost {
             },
             onUserMessage: (content) => {
                 const normalizedContent = observedUserContent(content);
-                if (!normalizedContent)
-                    return;
                 const n = normalizer ?? startNormalizer();
                 for (const se of n.userInput(normalizedContent))
                     emitCurrent(se);
             },
             onTurnContentUserMessage: (turnId, content) => {
                 const normalizedContent = observedUserContent(content);
-                if (!normalizedContent)
-                    return;
                 turnContentEvents(turnId, (n) => n.userInput(normalizedContent));
             },
             onEvent: (event) => {
@@ -1823,8 +1812,6 @@ export class LocalAgentHost {
             const text = claudeInputText(runtimeInput);
             const content = runtimeUserContent(runtimeInput);
             const pendingInput = {
-                content,
-                signature: JSON.stringify(content),
                 state: "awaiting",
                 observed: false,
             };
@@ -1855,8 +1842,12 @@ export class LocalAgentHost {
                 if (token)
                     claude.pendingImageInputs.delete(token);
             }
-            else if (pendingInput.observed) {
-                forgetPendingInput();
+            else {
+                pendingInput.responseId = result.responseId;
+                if (pendingInput.observed)
+                    forgetPendingInput();
+                else
+                    pendingInput.state = "accepted";
             }
             return result;
         }
@@ -1873,17 +1864,7 @@ export class LocalAgentHost {
             if (!bound || !threadId)
                 return { outcome: "notReady" };
             const nativeInput = buildRuntimeUserInput(runtimeInput);
-            const content = runtimeUserContent(runtimeInput);
-            const providerEcho = codexUserEchoContent(nativeInput);
-            const providerEchoContent = typeof providerEcho === "string"
-                ? [{ type: "input_text", text: providerEcho }]
-                : providerEcho;
             const pendingInput = {
-                content,
-                signature: JSON.stringify(content),
-                ...(providerEchoContent
-                    ? { providerEchoSignature: JSON.stringify(providerEchoContent) }
-                    : {}),
                 state: "awaiting",
                 observed: false,
             };
@@ -1921,13 +1902,11 @@ export class LocalAgentHost {
                             expectedTurnId: turnId,
                             input: nativeInput,
                         });
-                        if (pendingInput.observed) {
+                        pendingInput.responseId = `resp_codex_${steered.turnId}`;
+                        if (pendingInput.observed)
                             forgetPendingInput();
-                        }
-                        else {
-                            live.publishInjectedInput(steered.turnId, pendingInput.content);
-                            pendingInput.state = "optimistic";
-                        }
+                        else
+                            pendingInput.state = "accepted";
                         live.forwarder.noteTurnAccepted(steered.turnId);
                         return { outcome: "steered", responseId: `resp_codex_${steered.turnId}` };
                     }
@@ -1985,13 +1964,11 @@ export class LocalAgentHost {
                     ...turnWorkspaceParams(live.runtime, live.workspace, live.sandbox),
                     approvalPolicy: live.approvalPolicy,
                 });
-                if (pendingInput.observed) {
+                pendingInput.responseId = `resp_codex_${started.turnId}`;
+                if (pendingInput.observed)
                     forgetPendingInput();
-                }
-                else {
-                    live.publishInjectedInput(started.turnId, pendingInput.content);
-                    pendingInput.state = "optimistic";
-                }
+                else
+                    pendingInput.state = "accepted";
                 // The injection RPC and active-turn write are one serialized operation.
                 // Do not wait for the independent observer connection's `turn/started`:
                 // a second message accepted in that window must steer, not double-start.
@@ -2515,14 +2492,13 @@ export class LocalAgentHost {
                 if (token && content)
                     live.pendingImageInputs.delete(token);
                 const normalizedContent = content ?? [{ type: "input_text", text }];
-                const signature = JSON.stringify(normalizedContent);
-                const pending = live.pendingInjectedInputs.find((entry) => entry.signature === signature);
+                const pending = live.pendingInjectedInputs[0];
                 if (pending) {
                     pending.responseId = currentResponseId;
-                    live.pendingInjectedInputs.splice(live.pendingInjectedInputs.indexOf(pending), 1);
-                    if (pending.state === "optimistic")
-                        return;
                     pending.observed = true;
+                    if (pending.state === "accepted") {
+                        live.pendingInjectedInputs.shift();
+                    }
                 }
                 for (const se of n.userInput(normalizedContent))
                     emitCurrent(se);
@@ -2574,7 +2550,7 @@ export class LocalAgentHost {
                 const message = error.message || "Agent turn failed";
                 if (!normalizer) {
                     // Native pane/forwarder death is Session-level even when Claude is
-                    // between Turns. Omnigent publishes the same bare failed edge; the
+                    // between Turns. Emit a bare failed edge; the
                     // explicit zero also retires any sticky background-shell tally.
                     emitCurrent({
                         type: "session.status",

package/dist/runner/child.d.ts

@@ -80,6 +80,7 @@ export declare class RunnerSession {
     private readonly attachments;
     private readonly attachmentThreadIds;
     private readonly traexStartupWatchers;
+    private readonly traexStartupGates;
     private readonly terminalWatchers;
     /** Opens are async; a close received before attach resolves tombstones the id. */
     private readonly pendingTerminalOpens;

package/dist/runner/child.js

@@ -45,10 +45,13 @@ function terminalFailureDetail(pane) {
         .slice(-1_000);
 }
 const TRAEX_STARTUP_WATCH_MS = 20_000;
+const TRAEX_STARTUP_DISCOVERY_MS = 5_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;
+const TRAEX_ESCAPE_CONFIRM_MS = 1_000;
+const TRAEX_ESCAPE_COOLDOWN_MS = 1_000;
+const TRAEX_REPEAT_PROMPT_CONFIRM_MS = 5_000;
 const MIRROR_IMAGE_ACK_TIMEOUT_MS = 30_000;
 function normalizeTraexPane(pane) {
     return pane.toLowerCase().replace(/\s+/g, " ").trim();
@@ -58,6 +61,9 @@ function isTraexAuthorizationPending(pane) {
         pane.includes("open this link in your browser") &&
         pane.includes("press esc to cancel");
 }
+function isTraexStartupActivity(pane) {
+    return pane.includes("updating traecode cli") || pane.includes("updating trae cli");
+}
 function isTerminalProtocolResponse(input) {
     // xterm answers terminal queries through the same onData channel as real
     // keystrokes. CSI carries device/focus/position reports; OSC carries color
@@ -116,6 +122,7 @@ export class RunnerSession {
     attachments = new Map();
     attachmentThreadIds = new Map();
     traexStartupWatchers = new Map();
+    traexStartupGates = new Map();
     terminalWatchers = new Map();
     /** Opens are async; a close received before attach resolves tombstones the id. */
     pendingTerminalOpens = new Set();
@@ -437,6 +444,13 @@ export class RunnerSession {
             else if (msg.waitForReady !== false && provider.waitLiveReady) {
                 ready = await provider.waitLiveReady(msg.localThreadId);
             }
+            // Message delivery is serialized behind Traex's startup modal handling.
+            // Otherwise app-server can accept a Turn while the TUI watcher is still
+            // sending Escape, and the same key becomes `turn/interrupt` as soon as
+            // the modal disappears. Setup-terminal opens remain non-blocking.
+            if (runtime === "traex" && msg.waitForReady !== false) {
+                await this.traexStartupGates.get(msg.localThreadId);
+            }
             const readinessError = ready
                 ? undefined
                 : providerFailure(provider, msg.localThreadId, {
@@ -619,7 +633,13 @@ export class RunnerSession {
         if (spec.skipTraexStartupPrompts) {
             const watcher = Symbol(localThreadId);
             this.traexStartupWatchers.set(localThreadId, watcher);
-            void this.skipTraexStartupPrompts(localThreadId, term, watcher);
+            const gate = this.skipTraexStartupPrompts(localThreadId, term, watcher);
+            this.traexStartupGates.set(localThreadId, gate);
+            void gate.finally(() => {
+                if (this.traexStartupGates.get(localThreadId) === gate) {
+                    this.traexStartupGates.delete(localThreadId);
+                }
+            });
         }
         this.liveProvider.attachTerminalInjector?.(localThreadId, term);
         this.watchNativeTerminal(localThreadId, terminalId, term);
@@ -694,6 +714,7 @@ export class RunnerSession {
                 id: "welcome",
                 matches: (pane) => pane.includes("welcome to trae cli") && pane.includes("press enter to continue"),
                 dismiss: () => terminal.sendEnter(),
+                requiresEscapeConfirmation: false,
             },
             {
                 id: "migration",
@@ -702,6 +723,7 @@ export class RunnerSession {
                     pane.includes("select what to import") &&
                     (pane.includes("skip for now") || pane.includes("don't ask again")),
                 dismiss: () => terminal.interrupt(),
+                requiresEscapeConfirmation: true,
             },
             {
                 id: "hooks",
@@ -709,12 +731,16 @@ export class RunnerSession {
                     pane.includes("trust all and continue") &&
                     pane.includes("continue without trusting"),
                 dismiss: () => terminal.interrupt(),
+                requiresEscapeConfirmation: true,
             },
         ];
-        let activePromptId;
-        let lastDismissedAt = 0;
+        let activeWelcome = false;
+        let pendingEscapePromptId;
+        const dismissedPromptIds = new Set();
+        let dismissedAnyPrompt = false;
         const startedAt = Date.now();
         let deadline = startedAt + TRAEX_STARTUP_WATCH_MS;
+        let discoveryDeadline = startedAt + TRAEX_STARTUP_DISCOVERY_MS;
         const authorizationDeadline = startedAt + TRAEX_AUTHORIZATION_WAIT_MS;
         const terminalId = `${localThreadId}-main`;
         while (!this.shuttingDown &&
@@ -727,6 +753,9 @@ export class RunnerSession {
             const prompt = prompts.find((candidate) => candidate.matches(pane));
             const now = Date.now();
             const authorizationPending = isTraexAuthorizationPending(pane);
+            if (isTraexStartupActivity(pane)) {
+                discoveryDeadline = now + TRAEX_STARTUP_DISCOVERY_MS;
+            }
             // 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.
@@ -735,13 +764,63 @@ export class RunnerSession {
                 deadline = now + TRAEX_STARTUP_WATCH_MS;
             }
             if (!prompt) {
-                activePromptId = undefined;
+                activeWelcome = false;
+                pendingEscapePromptId = undefined;
+                // Every dismissal is followed by a one-second cooldown before the next
+                // capture. If no known modal remains then, startup prompt handling is
+                // complete and message injection may safely begin.
+                if (dismissedAnyPrompt)
+                    break;
+                // A clean Traex home may have no startup modal at all. Preserve a
+                // five-second discovery window for late modals, but do not impose the
+                // old full 20-second watcher lifetime on every cold message. A visible
+                // updater keeps the full startup window because prompts may follow it.
+                if (now >= discoveryDeadline &&
+                    !authorizationPending &&
+                    !isTraexStartupActivity(pane))
+                    break;
             }
-            else if (prompt.id !== activePromptId ||
-                now - lastDismissedAt >= TRAEX_PROMPT_RETRY_MS) {
+            else if (!prompt.requiresEscapeConfirmation) {
+                pendingEscapePromptId = undefined;
+                if (!activeWelcome && !dismissedPromptIds.has(prompt.id)) {
+                    prompt.dismiss();
+                    dismissedPromptIds.add(prompt.id);
+                    dismissedAnyPrompt = true;
+                    await new Promise((resolve) => {
+                        const timer = setTimeout(resolve, TRAEX_ESCAPE_COOLDOWN_MS);
+                        timer.unref();
+                    });
+                    continue;
+                }
+                activeWelcome = true;
+            }
+            else if (prompt.id !== pendingEscapePromptId) {
+                activeWelcome = false;
+                pendingEscapePromptId = prompt.id;
+                await new Promise((resolve) => {
+                    // Traex can show hooks -> migration -> hooks during one startup. The
+                    // trailing hooks screen normally disappears on its own, so observe a
+                    // previously handled prompt type for five seconds before acting.
+                    const timer = setTimeout(resolve, dismissedPromptIds.has(prompt.id)
+                        ? TRAEX_REPEAT_PROMPT_CONFIRM_MS
+                        : TRAEX_ESCAPE_CONFIRM_MS);
+                    timer.unref();
+                });
+                continue;
+            }
+            else {
                 prompt.dismiss();
-                activePromptId = prompt.id;
-                lastDismissedAt = now;
+                dismissedPromptIds.add(prompt.id);
+                dismissedAnyPrompt = true;
+                // Keep the id through the cooldown. If the same prompt is genuinely
+                // still active after a sent key, the next check retries it; a prompt
+                // that disappeared during the cooldown never receives another key.
+                pendingEscapePromptId = prompt.id;
+                await new Promise((resolve) => {
+                    const timer = setTimeout(resolve, TRAEX_ESCAPE_COOLDOWN_MS);
+                    timer.unref();
+                });
+                continue;
             }
             await new Promise((resolve) => {
                 const timer = setTimeout(resolve, authorizationPending ? TRAEX_AUTHORIZATION_POLL_MS : TRAEX_STARTUP_POLL_MS);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.30",
+  "version": "0.1.11-beta.31",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -27,7 +27,7 @@
     "node-pty": "1.2.0-beta.15",
     "smol-toml": "1.7.1",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.30"
+    "@rynx-ai/core": "0.1.11-beta.31"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"