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

package/dist/claude/native-integration.d.ts

@@ -22,6 +22,11 @@ export interface ClaudeForwarderSink {
     /** The current turn finished (a new user prompt, or the inactivity backstop).
      *  `usage` carries the latest statusLine context/cost snapshot, when captured. */
     onTurnEnd(usage?: Record<string, unknown>): void;
+    /** The current turn ended because the user explicitly interrupted it. */
+    onTurnInterrupted?(usage?: Record<string, unknown>): void;
+    /** Escape was sent for the open Turn. Publish cancelled UI state immediately;
+     *  the final close remains delayed so a late transcript record can join it. */
+    onTurnInterruptRequested?(): void;
     /** The runtime status changed according to Claude's session metadata. */
     onStatus?(status: ClaudeRunnerStatus, blockedOn?: string): void;
     /** The runtime went idle on the legacy hook fallback — surface idle WITHOUT finalizing
@@ -102,6 +107,8 @@ export declare class ClaudeLiveSession {
     private readonly seenClaudeSessionIds;
     private turnOpen;
     private currentTurnId?;
+    /** The open turn received an explicit Escape/Stop and must close cancelled. */
+    private turnInterrupted;
     /** The Turn opened from a pre-transcript interaction. Its unique provisional
      * id keeps responses distinct until the real prompt uuid can be adopted. */
     private syntheticTurn;

package/dist/claude/native-integration.js

@@ -27,6 +27,10 @@ const MAX_SETTLED_INTERACTIONS = 512;
 const MAX_MESSAGE_CORRELATION_BACKLOG = 64;
 const MAX_SUBMISSION_OBSERVATIONS = 64;
 const INTERACTION_ACK_TIMEOUT_MS = 5_000;
+// Claude writes this synthetic user record after Escape (including a tool-use
+// interruption). It is lifecycle, not a new prompt. Kept aligned with
+// Omnigent's `_CLAUDE_INTERRUPT_RECORD_RE`.
+const CLAUDE_INTERRUPT_RECORD_RE = /^\[Request interrupted by user(?: for tool use)?\]$/;
 const INTERACTION_LEASE_TIMEOUT_MS = 30_000;
 function processIsAlive(pid) {
     try {
@@ -165,6 +169,8 @@ export class ClaudeLiveSession {
     seenClaudeSessionIds = new Set();
     turnOpen = false;
     currentTurnId;
+    /** The open turn received an explicit Escape/Stop and must close cancelled. */
+    turnInterrupted = false;
     /** The Turn opened from a pre-transcript interaction. Its unique provisional
      * id keeps responses distinct until the real prompt uuid can be adopted. */
     syntheticTurn = false;
@@ -846,6 +852,12 @@ export class ClaudeLiveSession {
         }
         const content = userStringContent(rec);
         if (content !== undefined) {
+            const firstLine = content.trim().split("\n", 1)[0] ?? "";
+            if (CLAUDE_INTERRUPT_RECORD_RE.test(firstLine)) {
+                this.noteInterrupted();
+                this.lastActivityAt = this.now();
+                return;
+            }
             const candidates = submissionCandidates(content);
             const queuedPromotion = rec.promptSource !== "typed" &&
                 candidates.some((candidate) => this.consumeQueuedPromotion(candidate));
@@ -890,6 +902,7 @@ export class ClaudeLiveSession {
                     this.closeTurn();
                     this.currentTurnId = turnId;
                     this.turnOpen = true;
+                    this.turnInterrupted = false;
                     this.syntheticTurn = false;
                     this.providerIdleAt = null;
                     this.openToolIds.clear();
@@ -1100,6 +1113,7 @@ export class ClaudeLiveSession {
         }
         this.providerIdleAt = null;
         this.turnOpen = true;
+        this.turnInterrupted = false;
         this.sink.onTurnStart(this.currentTurnId);
     }
     /** Mirror a local `!` command as its own mini-turn: close any open turn, then
@@ -1120,8 +1134,10 @@ export class ClaudeLiveSession {
      *  turn's close via the same short grace. The Escape has stopped claude, so this
      *  does not race a still-running response. */
     noteInterrupted() {
-        if (!this.turnOpen)
+        if (!this.turnOpen || this.turnInterrupted)
             return;
+        this.turnInterrupted = true;
+        this.sink.onTurnInterruptRequested?.();
         this.cancelPendingInteractions("turn_interrupted");
         this.stopSignalPending = false;
         if (this.statusPoller?.active)
@@ -1160,7 +1176,13 @@ export class ClaudeLiveSession {
         this.stopSignalPending = false;
         this.stopPendingAt = null;
         this.resetMessageCorrelation();
-        this.sink.onTurnEnd(this.statusUsage());
+        const interrupted = this.turnInterrupted;
+        this.turnInterrupted = false;
+        const usage = this.statusUsage();
+        if (interrupted && this.sink.onTurnInterrupted)
+            this.sink.onTurnInterrupted(usage);
+        else
+            this.sink.onTurnEnd(usage);
     }
     closeTurnError(error) {
         if (!this.turnOpen)
@@ -1171,6 +1193,7 @@ export class ClaudeLiveSession {
         this.currentTurnId = undefined;
         this.syntheticTurn = false;
         this.openToolIds.clear();
+        this.turnInterrupted = false;
         this.stopSignalPending = false;
         this.stopPendingAt = null;
         this.resetMessageCorrelation();

package/dist/codex-app-server/forwarder.d.ts

@@ -39,6 +39,8 @@ export interface CodexForwarderSink {
     onStatus?(note: string | undefined, statusKind?: "startup"): void;
     /** The current turn finished; `usage` is the runtime's raw snapshot if any. */
     onTurnEnd(usage?: Record<string, unknown>, reason?: "superseded"): void;
+    /** The provider confirmed that the active turn was explicitly interrupted. */
+    onTurnInterrupted?(usage?: Record<string, unknown>): void;
     /** Resume proved that the newest turn is terminal even though its live edge
      * was missed. This updates session state without replaying historical items. */
     onRecoveredTurnStatus?(status: "idle" | "failed", turnId: string | undefined, error?: Error): void;

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

@@ -299,7 +299,9 @@ export class CodexSessionForwarder {
             }
             this.scheduleCompletion(mapped.fatalError
                 ? { kind: "error", error: mapped.fatalError }
-                : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
+                : mapped.turnInterrupted
+                    ? { kind: "interrupted", ...(mapped.usage ? { usage: mapped.usage } : {}) }
+                    : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
             return;
         }
         // A late event from an older turn must not replace the app-server's active
@@ -359,7 +361,9 @@ export class CodexSessionForwarder {
             return;
         }
         if (mapped.turnCompleted) {
-            this.scheduleCompletion({ kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
+            this.scheduleCompletion(mapped.turnInterrupted
+                ? { kind: "interrupted", ...(mapped.usage ? { usage: mapped.usage } : {}) }
+                : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
         }
         else {
             this.refreshCompletionGrace();
@@ -401,6 +405,12 @@ export class CodexSessionForwarder {
         this.pendingCompletionTurnId = null;
         if (completion.kind === "error")
             this.sink.onTurnError(completion.error);
+        else if (completion.kind === "interrupted") {
+            if (this.sink.onTurnInterrupted)
+                this.sink.onTurnInterrupted(completion.usage);
+            else
+                this.sink.onTurnEnd(completion.usage);
+        }
         else
             this.sink.onTurnEnd(completion.usage);
     }

package/dist/codex-app-server/mapping.d.ts

@@ -11,6 +11,7 @@ export interface CodexMapResult {
     finalText?: string;
     usage?: Record<string, unknown>;
     turnCompleted?: boolean;
+    turnInterrupted?: boolean;
     fatalError?: Error;
 }
 export declare function codexTurnStatus(turn: unknown): string | undefined;

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

@@ -241,7 +241,14 @@ export function mapCodexNotification(method, params) {
         case "turn/failed": {
             const turnPayload = typed.params?.turn;
             const fatalError = terminalTurnError(turnPayload, typed.method);
-            return { events, ...(fatalError ? { fatalError } : {}), turnCompleted: true };
+            const turnInterrupted = typed.method === "turn/completed" &&
+                ["interrupted", "cancelled", "canceled"].includes(codexTurnStatus(turnPayload) ?? "");
+            return {
+                events,
+                ...(fatalError ? { fatalError } : {}),
+                turnCompleted: true,
+                ...(turnInterrupted ? { turnInterrupted: true } : {}),
+            };
         }
         case "turn/plan/updated": {
             const planParams = typed.params;

package/dist/host.d.ts

@@ -2,7 +2,7 @@ import { type ResolvedExecutionSnapshot, type ResolvedExecutionBudget, type Runt
 import { type AgentRuntimeId } from "@rynx-ai/core";
 import { type AppConfig } from "@rynx-ai/core";
 import { createCodexChildEnv } from "./codex-child-env.js";
-import type { InjectOutcome } from "./runner/protocol.js";
+import type { InjectResult } from "./runner/protocol.js";
 import type { ResolveInteractionResult } from "./interactions.js";
 import { CodexAppServerClient } from "./codex-app-server/client.js";
 import type { ModelListResponse, ThreadGoal } from "./codex-app-server/protocol.js";
@@ -267,13 +267,13 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * 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
      * the bridge instead of a short race that falls back to a second output path.
      */
-    injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
+    injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectResult>;
     /**
      * Interrupt the session's active turn — the web Stop button. codex: the
      * app-server `turn/interrupt` on the active `{threadId, turnId}` (exactly what
@@ -287,6 +287,11 @@ export declare class LocalAgentHost implements CodexCapabilities {
     stopLiveCodexSession(localThreadId: string, opts?: {
         deferClaudeInteractionCleanup?: boolean;
     }): void;
+    /** 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: string, error?: Error): boolean;
     /** Complete the second shutdown phase after the runner has killed all native
      * terminals and hook subprocesses. Must run before the runner process exits. */
     finalizeStoppedLiveSessions(): void;
@@ -308,7 +313,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
      *  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}. */
+     *  fall-through-to-run signal. Returns {@link InjectResult}. */
     private injectClaude;
     /** Park until the claude session's tmux injector is (re)attached by the
      *  runner-child, or the deadline passes. Pane relaunch re-attaches it via

package/dist/host.js

@@ -681,6 +681,8 @@ export class LocalAgentHost {
             injectLock: Promise.resolve(),
             pendingInjectedInputs: [],
             publishInjectedInput: () => undefined,
+            publishInterrupted: () => undefined,
+            interruptedResponseId: null,
             subscribing: false,
             rotationPending: false,
             stopped: false,
@@ -698,11 +700,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;
@@ -842,6 +853,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 +883,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 +914,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 +1160,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 +1315,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 +1332,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 +1347,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,28 +1365,27 @@ 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";
@@ -1378,11 +1408,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,7 +1416,7 @@ 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
@@ -1403,11 +1429,7 @@ export class LocalAgentHost {
                     ...(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 +1440,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();
@@ -1501,6 +1523,7 @@ export class LocalAgentHost {
             if (turnId) {
                 try {
                     await interruptClient.turnInterrupt({ threadId, turnId });
+                    live.publishInterrupted(`resp_codex_${turnId}`);
                     handled = true;
                 }
                 catch {
@@ -1555,6 +1578,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() {
@@ -1776,8 +1820,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 +1865,8 @@ export class LocalAgentHost {
             injectLock: Promise.resolve(),
             pendingImageInputs: new Map(),
             pendingInjectedInputs: [],
+            currentResponseId: () => currentResponseId,
+            publishInterrupted: () => undefined,
             ready,
             markReady,
             failed,
@@ -1833,6 +1878,55 @@ export class LocalAgentHost {
             ...(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),
             onUserMessage: (text) => {
@@ -1844,12 +1938,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 +1971,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 +2111,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 +2133,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)

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";