@rynx-ai/runtime 0.1.11-beta.22 → 0.1.11-beta.24

package/dist/host.js

@@ -9,7 +9,7 @@ import { getRuntimeProfile, } from "@rynx-ai/core";
 import { resolveRuntimeBinary, } from "@rynx-ai/core";
 import { createCodexChildEnv } from "./codex-child-env.js";
 import { prepareRuntimeHome, populateCodexSkills, runtimeHomePath, } from "./codex-home.js";
-import { materializeSkillPlugin } from "./claude/executor.js";
+import { materializeClaudePlugin, reuseClaudePlugin, } from "./claude/executor.js";
 import { listClaudeModels } from "./claude/models.js";
 import { CodexAppServerClient, buildRuntimeUserInput, } from "./codex-app-server/client.js";
 import { buildAppServerBaseArgs, CodexTransportError, } from "./codex-app-server/transport.js";
@@ -529,16 +529,21 @@ export class LocalAgentHost {
             return sameSessionSnapshots(existingClaude.workspace, existingClaude.execution, snapshotOpts);
         }
         // Dedupe concurrent triggers so only one forwarder is ever created per
-        // session (two would double-mirror every turn). Check this before the live
-        // map: startLiveCodexSession publishes its partially initialized session
-        // before thread/start completes, so a concurrent Terminal start must await
-        // the thread id instead of launching a bare `codex --remote` pane.
+        // session (two would double-mirror every turn). startLiveCodexSession
+        // publishes its partially initialized session before thread/start completes,
+        // so wait for that startup and then adopt any newer mutable Turn settings.
         const inflight = this.liveEnsuring.get(localThreadId);
-        if (inflight)
-            return inflight;
+        if (inflight) {
+            if (!await inflight)
+                return false;
+            const startedLive = this.liveSessions.get(localThreadId);
+            return startedLive
+                ? updateLiveCodexTurnSettings(startedLive, snapshotOpts)
+                : false;
+        }
         const live = this.liveSessions.get(localThreadId);
         if (live)
-            return sameSessionSnapshots(live.workspace, live.execution, snapshotOpts);
+            return updateLiveCodexTurnSettings(live, snapshotOpts);
         const started = this.startLiveCodexSession(localThreadId, emit, snapshotOpts);
         this.liveEnsuring.set(localThreadId, started);
         try {
@@ -670,6 +675,8 @@ export class LocalAgentHost {
             approvalPolicy,
             model,
             reasoningEffort,
+            appliedModel: model,
+            appliedReasoningEffort: reasoningEffort,
             ...(execution.instructions ? { instructions: execution.instructions } : {}),
             threadId: record?.codexSessionId ?? null,
             ready,
@@ -681,6 +688,10 @@ export class LocalAgentHost {
             injectLock: Promise.resolve(),
             pendingInjectedInputs: [],
             publishInjectedInput: () => undefined,
+            publishTurnAdmission: () => undefined,
+            publishTurnAdmissionFailure: () => undefined,
+            publishInterrupted: () => undefined,
+            interruptedResponseId: null,
             subscribing: false,
             rotationPending: false,
             stopped: false,
@@ -698,11 +709,20 @@ export class LocalAgentHost {
             }
             emit(event);
         };
+        live.publishInterrupted = (responseId) => {
+            if (live.interruptedResponseId === responseId)
+                return;
+            live.interruptedResponseId = responseId;
+            emitCurrent({
+                type: "session.interrupted",
+                sessionId: currentSessionId,
+                responseId,
+            });
+        };
         let normalizer = null;
         let currentResponseId = null;
         const startNormalizer = (turnId) => {
-            const responseId = live.pendingInjectedInputs.find((entry) => entry.responseId)?.responseId ??
-                (turnId ? `resp_codex_${turnId}` : "resp_codex_native");
+            const responseId = turnId ? `resp_codex_${turnId}` : "resp_codex_native";
             if (normalizer && currentResponseId === responseId)
                 return normalizer;
             currentResponseId = responseId;
@@ -726,6 +746,21 @@ export class LocalAgentHost {
             for (const se of n.userInput(content))
                 emitCurrent(se);
         };
+        live.publishTurnAdmission = () => {
+            emitCurrent({
+                type: "session.status",
+                sessionId: currentSessionId,
+                status: "running",
+            });
+        };
+        live.publishTurnAdmissionFailure = (message) => {
+            emitCurrent({
+                type: "session.status",
+                sessionId: currentSessionId,
+                status: "failed",
+                note: message,
+            });
+        };
         const clearPendingInputsForResponse = (responseId) => {
             if (!responseId)
                 return;
@@ -842,6 +877,22 @@ export class LocalAgentHost {
             normalizer = null;
             currentResponseId = null;
         };
+        const interruptCurrentTurn = () => {
+            closeCanonicalInteractions();
+            if (!normalizer)
+                return;
+            const interruptedResponseId = currentResponseId;
+            for (const se of normalizer.interrupt()) {
+                if (se.type === "session.interrupted" &&
+                    live.interruptedResponseId === interruptedResponseId)
+                    continue;
+                emitCurrent(se);
+            }
+            live.interruptedResponseId = null;
+            clearPendingInputsForResponse(interruptedResponseId);
+            normalizer = null;
+            currentResponseId = null;
+        };
         const sink = {
             onTurnStart: (turnId) => startNormalizer(turnId),
             onTurnObserved: (turnId) => {
@@ -856,7 +907,7 @@ export class LocalAgentHost {
                     : content;
                 const signature = JSON.stringify(normalizedContent);
                 const pending = live.pendingInjectedInputs.find((entry) => entry.signature === signature);
-                if (pending?.state === "optimistic" || pending?.state === "prepublished") {
+                if (pending?.state === "optimistic") {
                     live.pendingInjectedInputs.splice(live.pendingInjectedInputs.indexOf(pending), 1);
                     return;
                 }
@@ -887,6 +938,7 @@ export class LocalAgentHost {
             // response without publishing a false idle edge in a running→running
             // transition.
             onTurnEnd: completeCurrentTurn,
+            onTurnInterrupted: interruptCurrentTurn,
             onRecoveredTurnStatus: (status, turnId, error) => {
                 const responseId = turnId ? `resp_codex_${turnId}` : undefined;
                 if (normalizer && (!responseId || currentResponseId === responseId)) {
@@ -1132,12 +1184,7 @@ export class LocalAgentHost {
             return;
         live.startupError = error;
         this.liveStartupErrors.set(localThreadId, error);
-        live.forwarder.failOpenTurn(error);
-        const appServerOwner = live.appServerOwner;
-        this.stopLiveCodexSession(localThreadId);
-        void appServerOwner.stop().catch((stopError) => {
-            console.warn(`[codex-live] session=${localThreadId} runtime=${live.runtime} app-server cleanup after observer failure failed: ${stopError instanceof Error ? stopError.message : String(stopError)}`);
-        });
+        this.teardownLiveCodexSession(localThreadId, error);
     }
     shouldIgnoreManagedForkThreadStarted(live, threadId, forkedFromId) {
         const pending = live.managedFork;
@@ -1292,7 +1339,7 @@ export class LocalAgentHost {
      * resumed from the persisted native id. Serialized per session so two
      * injects can't double-open a turn.
      *
-     * Returns an {@link InjectOutcome}: `notLive` when this session has no live
+     * 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
@@ -1309,9 +1356,8 @@ export class LocalAgentHost {
             const pendingInput = {
                 content,
                 signature: JSON.stringify(content),
-                state: runtimeInput.responseId ? "prepublished" : "awaiting",
+                state: "awaiting",
                 observed: false,
-                ...(runtimeInput.responseId ? { responseId: runtimeInput.responseId } : {}),
             };
             claude.pendingInjectedInputs.push(pendingInput);
             const forgetPendingInput = () => {
@@ -1325,8 +1371,17 @@ export class LocalAgentHost {
                 const expiry = setTimeout(() => claude.pendingImageInputs.delete(token), 5 * 60_000);
                 expiry.unref?.();
             }
-            const outcome = await this.injectClaude(claude, localThreadId, text);
-            if (outcome !== "injected") {
+            let result;
+            try {
+                result = await this.injectClaude(claude, localThreadId, text, pendingInput);
+            }
+            catch (error) {
+                forgetPendingInput();
+                if (token)
+                    claude.pendingImageInputs.delete(token);
+                throw error;
+            }
+            if (result.outcome !== "injected" && result.outcome !== "steered") {
                 forgetPendingInput();
                 if (token)
                     claude.pendingImageInputs.delete(token);
@@ -1334,31 +1389,37 @@ export class LocalAgentHost {
             else if (pendingInput.observed) {
                 forgetPendingInput();
             }
-            return outcome;
+            return result;
         }
         const live = this.liveSessions.get(localThreadId);
         if (!live)
-            return "notLive";
+            return { outcome: "notLive" };
         const run = live.injectLock.then(async () => {
             if (live.rotationPending || live.stopped)
-                return "failed";
+                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);
             const threadId = live.threadId ?? live.forwarder.threadId();
             if (!bound || !threadId)
-                return "notReady";
+                return { outcome: "notReady" };
             const nativeInput = buildRuntimeUserInput(runtimeInput);
             const content = runtimeUserContent(runtimeInput);
             const pendingInput = {
                 content,
                 signature: JSON.stringify(content),
-                state: runtimeInput.responseId ? "prepublished" : "awaiting",
+                state: "awaiting",
                 observed: false,
-                ...(runtimeInput.responseId ? { responseId: runtimeInput.responseId } : {}),
             };
             live.pendingInjectedInputs.push(pendingInput);
             let injectionMethod = "turn/start";
+            let admissionPublished = false;
+            const publishAdmission = () => {
+                if (admissionPublished)
+                    return;
+                admissionPublished = true;
+                live.publishTurnAdmission();
+            };
             const forgetPendingInput = () => {
                 const index = live.pendingInjectedInputs.indexOf(pendingInput);
                 if (index >= 0)
@@ -1366,6 +1427,12 @@ export class LocalAgentHost {
             };
             const injectionClient = this.injectionClientFactory(live.appServerUrl);
             try {
+                // Omnigent publishes codex-native running only after the native Terminal
+                // is ready and the runner has accepted the message, but before the
+                // short-lived app-server client initializes and starts the Turn. Claude
+                // deliberately has no matching synthesized edge.
+                if (!live.forwarder.isTurnOpen())
+                    publishAdmission();
                 await injectionClient.ensureInitialized();
                 // Match Omnigent's executor: each message uses one initialized client
                 // that closes as soon as turn/start or turn/steer is acknowledged.
@@ -1378,11 +1445,7 @@ export class LocalAgentHost {
                             expectedTurnId: turnId,
                             input: nativeInput,
                         });
-                        if (pendingInput.state === "prepublished") {
-                            // The caller already persisted and published this user input
-                            // before waiting for the native Terminal to become ready.
-                        }
-                        else if (pendingInput.observed) {
+                        if (pendingInput.observed) {
                             forgetPendingInput();
                         }
                         else {
@@ -1390,24 +1453,39 @@ export class LocalAgentHost {
                             pendingInput.state = "optimistic";
                         }
                         live.forwarder.noteTurnAccepted(steered.turnId);
-                        return "steered";
+                        return { outcome: "steered", responseId: `resp_codex_${steered.turnId}` };
                     }
                 }
-                // Carry the agent-spec model on the turn so a web-injected turn runs the
-                // agent's model even if the TUI's config default differs.
+                // Match Omnigent's turn boundary: change the native thread settings
+                // under the same lock immediately before starting the next Turn. Never
+                // put settings on turn/start or mutate a Turn that is already open.
+                const desiredModel = live.model;
+                const desiredReasoningEffort = live.reasoningEffort;
+                const settings = {
+                    threadId,
+                    ...(desiredModel !== live.appliedModel
+                        ? { model: desiredModel || null }
+                        : {}),
+                    ...(desiredReasoningEffort !== live.appliedReasoningEffort
+                        ? { effort: desiredReasoningEffort ?? null }
+                        : {}),
+                };
+                if (Object.keys(settings).length > 1) {
+                    await injectionClient.threadSettingsUpdate(settings);
+                    // Record exactly what this RPC carried. A concurrent settings save may
+                    // already have advanced the desired fields and must remain pending for
+                    // the following new Turn.
+                    live.appliedModel = desiredModel;
+                    live.appliedReasoningEffort = desiredReasoningEffort;
+                }
+                publishAdmission();
                 const started = await injectionClient.turnStart({
                     threadId,
                     input: nativeInput,
                     ...turnWorkspaceParams(live.runtime, live.workspace, live.sandbox),
                     approvalPolicy: live.approvalPolicy,
-                    ...(live.model ? { model: live.model } : {}),
-                    ...(live.reasoningEffort ? { effort: live.reasoningEffort } : {}),
                 });
-                if (pendingInput.state === "prepublished") {
-                    // The caller already persisted and published this user input before
-                    // waiting for the native Terminal to become ready.
-                }
-                else if (pendingInput.observed) {
+                if (pendingInput.observed) {
                     forgetPendingInput();
                 }
                 else {
@@ -1418,7 +1496,7 @@ export class LocalAgentHost {
                 // Do not wait for the independent observer connection's `turn/started`:
                 // a second message accepted in that window must steer, not double-start.
                 live.forwarder.noteTurnAccepted(started.turnId);
-                return "injected";
+                return { outcome: "injected", responseId: `resp_codex_${started.turnId}` };
             }
             catch (error) {
                 forgetPendingInput();
@@ -1427,6 +1505,13 @@ export class LocalAgentHost {
                 const baseDetail = codexRpcError(error, injectionMethod);
                 const startupDetail = live.forwarder.mcpStartupDetail();
                 const detail = startupDetail ? `${baseDetail} (${startupDetail})` : baseDetail;
+                // A turn may open on the observer while this short-lived client is
+                // initializing, converting the submission to steer. A rejected steer
+                // does not fail that already-running Turn; only a new-Turn admission
+                // owns the terminal failed edge.
+                if (admissionPublished && injectionMethod === "turn/start") {
+                    live.publishTurnAdmissionFailure(detail);
+                }
                 console.error(`[codex-live] session=${localThreadId} runtime=${live.runtime} injection failed: ${detail}`);
                 throw nativeLiveFailure(live.runtime, "native_message_injection_failed", `message injection via ${injectionMethod} failed`, detail);
             }
@@ -1501,6 +1586,7 @@ export class LocalAgentHost {
             if (turnId) {
                 try {
                     await interruptClient.turnInterrupt({ threadId, turnId });
+                    live.publishInterrupted(`resp_codex_${turnId}`);
                     handled = true;
                 }
                 catch {
@@ -1528,8 +1614,6 @@ export class LocalAgentHost {
                 claude.forwarder.finalizeStop();
             }
             removeManagedClaudeSettings(claude.bridgeDir);
-            // Remove the throwaway skills --plugin-dir temp so it doesn't leak per launch.
-            void claude.skillCleanup?.();
             return;
         }
         const live = this.liveSessions.get(localThreadId);
@@ -1555,6 +1639,27 @@ export class LocalAgentHost {
         // Remove the session-scoped skills dir — the machine keeps zero task residue.
         void live.skillsCleanup?.();
     }
+    /** Tear down one codex-lineage native runtime without deleting its durable
+     * session-store binding. Omnigent couples its auxiliary Terminal, observer,
+     * forwarder and per-session app-server as one disposable runtime envelope;
+     * the next message recreates that envelope and cold-resumes the native id. */
+    teardownLiveCodexSession(localThreadId, error) {
+        const live = this.liveSessions.get(localThreadId);
+        if (!live)
+            return false;
+        const turnFailed = error ? live.forwarder.failOpenTurn(error) : false;
+        const backendKey = codexBackendKey(live.runtime, live.execution.budget ?? undefined);
+        const backend = this.backends.get(backendKey);
+        const appServerOwner = live.appServerOwner;
+        this.stopLiveCodexSession(localThreadId);
+        if (backend?.appServerClient === appServerOwner) {
+            this.backends.delete(backendKey);
+        }
+        void appServerOwner.stop().catch((stopError) => {
+            console.warn(`[codex-live] session=${localThreadId} runtime=${live.runtime} app-server teardown failed: ${stopError instanceof Error ? stopError.message : String(stopError)}`);
+        });
+        return turnFailed;
+    }
     /** Complete the second shutdown phase after the runner has killed all native
      * terminals and hook subprocesses. Must run before the runner process exits. */
     finalizeStoppedLiveSessions() {
@@ -1745,17 +1850,27 @@ export class LocalAgentHost {
             throw new CodexRuntimeError(`cannot launch Claude from ${execution.provider} execution snapshot`, 422, "invalid_execution_snapshot");
         }
         const cwd = workspace.cwd;
-        let snapshotSkills;
-        try {
-            snapshotSkills = await this.prepareExecutionSkills(execution);
-        }
-        catch (err) {
-            console.error(`[session-snapshot] session=${localThreadId} skill materialization failed: ${err instanceof Error ? err.message : String(err)}`);
-            return false;
+        const hasSkillSnapshot = execution.skills.length > 0 || execution.pluginSkills.length > 0;
+        let skillPlugin = hasSkillSnapshot
+            ? await reuseClaudePlugin(localThreadId)
+            : null;
+        if (!skillPlugin && hasSkillSnapshot) {
+            let snapshotSkills;
+            try {
+                snapshotSkills = await this.prepareExecutionSkills(execution);
+            }
+            catch (err) {
+                console.error(`[session-snapshot] session=${localThreadId} skill materialization failed: ${err instanceof Error ? err.message : String(err)}`);
+                return false;
+            }
+            try {
+                skillPlugin = await materializeClaudePlugin(localThreadId, snapshotSkills.selectedSkills);
+            }
+            finally {
+                await snapshotSkills.skillsCleanup();
+            }
         }
         const model = execution.model ?? "";
-        const skillPlugin = await materializeSkillPlugin(snapshotSkills.selectedSkills);
-        void snapshotSkills.skillsCleanup();
         const permissionMode = execution.permissionMode;
         const launchExtraArgs = [
             ...(skillPlugin?.pluginDir ? ["--plugin-dir", skillPlugin.pluginDir] : []),
@@ -1776,8 +1891,7 @@ export class LocalAgentHost {
         };
         const startNormalizer = (turnId) => {
             // turnId unknown → fixed literal (never random), aligning reference implementation `_response_id`.
-            const responseId = live.pendingInjectedInputs.find((entry) => entry.responseId)?.responseId ??
-                (turnId ? `resp_claude_${turnId}` : "resp_claude_native");
+            const responseId = turnId ? `resp_claude_${turnId}` : "resp_claude_native";
             if (normalizer && currentResponseId === responseId)
                 return normalizer;
             currentResponseId = responseId;
@@ -1822,6 +1936,8 @@ export class LocalAgentHost {
             injectLock: Promise.resolve(),
             pendingImageInputs: new Map(),
             pendingInjectedInputs: [],
+            currentResponseId: () => currentResponseId,
+            publishInterrupted: () => undefined,
             ready,
             markReady,
             failed,
@@ -1831,7 +1947,55 @@ export class LocalAgentHost {
             launchExtraArgs,
             permissionMode,
             ...(forkIntent ? { forkIntent } : {}),
-            ...(skillPlugin?.cleanup ? { skillCleanup: skillPlugin.cleanup } : {}),
+        };
+        live.publishInterrupted = (responseId) => {
+            if (live.interruptedResponseId === responseId)
+                return;
+            live.interruptedResponseId = responseId;
+            emitCurrent({
+                type: "session.interrupted",
+                sessionId: currentSessionId,
+                responseId,
+            });
+        };
+        const settleClaudeTurn = (interrupted, usage) => {
+            if (!normalizer)
+                return;
+            const rid = currentResponseId;
+            if (interrupted) {
+                for (const se of normalizer.interrupt()) {
+                    if (se.type === "session.interrupted" &&
+                        live.interruptedResponseId === rid)
+                        continue;
+                    emitCurrent(se);
+                }
+                live.interruptedResponseId = undefined;
+            }
+            else {
+                // statusLine usage (context/cost) rides the turn's response.completed.
+                if (usage) {
+                    for (const se of normalizer.next({ type: "turn_completed", usage }))
+                        emitCurrent(se);
+                }
+                for (const se of normalizer.next({ type: "done" }))
+                    emitCurrent(se);
+            }
+            live.pendingInjectedInputs = live.pendingInjectedInputs.filter((entry) => entry.responseId !== rid);
+            normalizer = null;
+            currentResponseId = undefined;
+            // One-time context-window banner past CONTEXT_WARN_RATIO (a transient note,
+            // cleared by the next turn's first item). statusLine pre-computes the %.
+            const pct = usage && typeof usage.used_percentage === "number" ? usage.used_percentage : undefined;
+            if (!interrupted && rid && pct !== undefined && !live.contextWarned && pct >= CONTEXT_WARN_RATIO * 100) {
+                live.contextWarned = true;
+                emitCurrent({
+                    type: "session.status",
+                    sessionId: currentSessionId,
+                    responseId: rid,
+                    status: "idle",
+                    note: `context ${Math.round(pct)}% full — consider /compact`,
+                });
+            }
         };
         const sink = {
             onTurnStart: (turnId) => startNormalizer(turnId),
@@ -1844,12 +2008,13 @@ export class LocalAgentHost {
                 const normalizedContent = content ?? [{ type: "input_text", text }];
                 const signature = JSON.stringify(normalizedContent);
                 const pending = live.pendingInjectedInputs.find((entry) => entry.signature === signature);
-                if (pending?.state === "prepublished" || pending?.state === "optimistic") {
+                if (pending) {
+                    pending.responseId = currentResponseId;
                     live.pendingInjectedInputs.splice(live.pendingInjectedInputs.indexOf(pending), 1);
-                    return;
-                }
-                if (pending)
+                    if (pending.state === "optimistic")
+                        return;
                     pending.observed = true;
+                }
                 for (const se of n.userInput(normalizedContent))
                     emitCurrent(se);
             },
@@ -1876,33 +2041,12 @@ export class LocalAgentHost {
                     ...(blockedOn ? { note: blockedOn } : {}),
                 });
             },
-            onTurnEnd: (usage) => {
-                if (!normalizer)
-                    return;
-                const rid = currentResponseId;
-                // statusLine usage (context/cost) rides the turn's response.completed.
-                if (usage) {
-                    for (const se of normalizer.next({ type: "turn_completed", usage }))
-                        emitCurrent(se);
-                }
-                for (const se of normalizer.next({ type: "done" }))
-                    emitCurrent(se);
-                live.pendingInjectedInputs = live.pendingInjectedInputs.filter((entry) => entry.responseId !== rid);
-                normalizer = null;
-                currentResponseId = undefined;
-                // One-time context-window banner past CONTEXT_WARN_RATIO (a transient note,
-                // cleared by the next turn's first item). statusLine pre-computes the %.
-                const pct = usage && typeof usage.used_percentage === "number" ? usage.used_percentage : undefined;
-                if (rid && pct !== undefined && !live.contextWarned && pct >= CONTEXT_WARN_RATIO * 100) {
-                    live.contextWarned = true;
-                    emitCurrent({
-                        type: "session.status",
-                        sessionId: currentSessionId,
-                        responseId: rid,
-                        status: "idle",
-                        note: `context ${Math.round(pct)}% full — consider /compact`,
-                    });
-                }
+            onTurnEnd: (usage) => settleClaudeTurn(false, usage),
+            onTurnInterrupted: (usage) => settleClaudeTurn(true, usage),
+            onTurnInterruptRequested: () => {
+                const responseId = currentResponseId;
+                if (responseId)
+                    live.publishInterrupted(responseId);
             },
             onIdle: () => {
                 // Surface idle on the current turn WITHOUT finalizing it (see the sink's
@@ -2037,17 +2181,18 @@ export class LocalAgentHost {
      *  serialized per session. Parks until the thread is ready AND the tmux injector
      *  is (re)attached, then pastes; `injectViaTerminal` RAISES if the prompt never
      *  appears (reference implementation RAISE), so a not-ready pane is a hard error — NOT a
-     *  fall-through-to-run signal. Returns {@link InjectOutcome}. */
-    injectClaude(live, localThreadId, text) {
+     *  fall-through-to-run signal. Returns {@link InjectResult}. */
+    injectClaude(live, localThreadId, text, pendingInput) {
         const run = live.injectLock.then(async () => {
             const ready = await this.waitLiveReady(localThreadId, 60_000);
             if (!ready)
-                return "notReady";
+                return { outcome: "notReady" };
             // Pane may have just relaunched — park until its injector re-attaches
             // (attachTerminalInjector resets it) instead of returning false → fallback.
             const injector = await this.waitInjector(live, 60_000);
             if (!injector)
-                return "notReady";
+                return { outcome: "notReady" };
+            const steered = live.forwarder.isTurnOpen();
             // Abortable: the web Stop button cancels an in-flight paste/submit (before
             // the message reaches claude) via interruptLive → injectAbort.abort().
             const abort = new AbortController();
@@ -2058,11 +2203,18 @@ export class LocalAgentHost {
                     signal: abort.signal,
                     submissionObserved: () => live.forwarder.hasObservedSubmissionAfter(submissionCheckpoint, text),
                 });
-                return ok ? "injected" : "failed";
+                if (!ok)
+                    return { outcome: "failed" };
+                const responseId = pendingInput.responseId ?? live.currentResponseId();
+                if (!responseId) {
+                    live.error = "Claude accepted the message but did not publish its native Turn identity";
+                    return { outcome: "failed" };
+                }
+                return { outcome: steered ? "steered" : "injected", responseId };
             }
             catch (error) {
                 live.error = error instanceof Error ? error.message : String(error);
-                return "failed";
+                return { outcome: "failed" };
             }
             finally {
                 if (live.injectAbort === abort)
@@ -2329,6 +2481,21 @@ function sameSessionSnapshots(workspace, execution, opts) {
         execution: opts.execution,
     }));
 }
+function sameImmutableSessionSnapshots(workspace, execution, opts) {
+    const current = { ...execution, model: null, reasoningEffort: null };
+    const requested = { ...opts.execution, model: null, reasoningEffort: null };
+    return JSON.stringify(stableValue({ workspace, execution: current })) ===
+        JSON.stringify(stableValue({ workspace: opts.workspace, execution: requested }));
+}
+function updateLiveCodexTurnSettings(live, opts) {
+    if (!sameImmutableSessionSnapshots(live.workspace, live.execution, opts)) {
+        return false;
+    }
+    live.execution = structuredClone(opts.execution);
+    live.model = opts.execution.model ?? "";
+    live.reasoningEffort = opts.execution.reasoningEffort ?? undefined;
+    return true;
+}
 /** Freeze the Session's permission choice into the explicit managed settings.
  * Host/project settings may still contribute allow/deny rules, but changing
  * their defaultMode cannot silently mutate an existing Session on resume. */

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export type { CodexCapabilities, CapabilityResult, CodexRuntimeStatus, } from ".
 export type { ClaudeForkIntent, CodexSessionStore, CodexSessionRecord, } from "./codex-session-store.js";
 export { RunnerManager, TerminalOpenError } from "./runner/manager.js";
 export type { RunnerManagerOptions, RunnerSessionContext, RunnerSessionContextProvider, OpenTerminalOptions, ParentTerminal, } from "./runner/manager.js";
-export type { InjectOutcome, TerminalOpenErrorCode, TerminalRole } from "./runner/protocol.js";
+export type { InjectOutcome, InjectResult, TerminalOpenErrorCode, TerminalRole } from "./runner/protocol.js";
 export type { ResolveInteractionResult, RuntimeInteractionEvent, RuntimeInteractionListener, } from "./interactions.js";
 export { probeRuntimeStatus } from "./runtime-status.js";
 export { listRuntimeModels } from "./models-catalog.js";

package/dist/runner/child.d.ts

@@ -11,7 +11,7 @@ import { type AgentCapabilities, type LiveSessionFailure, type ResolvedExecution
 import type { SessionEvent } from "@rynx-ai/core";
 import type { TerminalInjector } from "../claude/native-integration.js";
 import type { ResolveInteractionResult } from "../interactions.js";
-import { type InjectOutcome } from "./protocol.js";
+import { type InjectResult } from "./protocol.js";
 import type { ChildTransport } from "./transport.js";
 /** Re-target the mirror to a freshly minted rynx session (claude `/clear`·`/fork`)
  *  + record the terminal transfer with the daemon. The child owns the transport,
@@ -50,7 +50,11 @@ interface LiveCodexProvider {
     liveSessionFailure?(localThreadId: string): LiveSessionFailure | undefined;
     failLiveStartup?(localThreadId: string, error: Error): boolean;
     failLiveSession?(localThreadId: string, error: Error): boolean;
-    injectMessage?(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
+    /** Codex/Traex auxiliary Terminal lifecycle: settle the current Turn, stop
+     * observer/forwarder, and evict the owned app-server while preserving the
+     * durable native-session binding for a later cold resume. */
+    teardownLiveCodexSession?(localThreadId: string, error?: Error): boolean;
+    injectMessage?(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectResult>;
     interruptLive?(localThreadId: string): Promise<boolean>;
     stopLiveCodexSession?(localThreadId: string, opts?: {
         deferClaudeInteractionCleanup?: boolean;