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

package/dist/host.js

@@ -955,8 +955,59 @@ export class LocalAgentHost {
             }
             live.canonicalInteractions.clear();
         };
+        const completeCurrentTurn = (usage, reason) => {
+            closeCanonicalInteractions();
+            if (!normalizer)
+                return;
+            const completedResponseId = currentResponseId;
+            if (usage) {
+                for (const se of normalizer.next({ type: "turn_completed", usage }))
+                    emitCurrent(se);
+            }
+            for (const se of normalizer.next({ type: "done" })) {
+                if (reason === "superseded" && se.type === "session.status")
+                    continue;
+                emitCurrent(se);
+            }
+            clearPendingInputsForResponse(completedResponseId);
+            normalizer = null;
+            currentResponseId = null;
+        };
+        const failCurrentTurn = (error) => {
+            closeCanonicalInteractions();
+            if (!normalizer)
+                return;
+            const failedResponseId = currentResponseId;
+            const responseStopped = error.message === "Codex turn was interrupted";
+            const providerName = runtime === "traex" ? "Traex" : "Codex";
+            const message = responseStopped
+                ? "Response stopped"
+                : runtime === "traex"
+                    ? error.message.replace(/^Codex\b/, providerName)
+                    : error.message;
+            for (const se of normalizer.fail({
+                code: responseStopped
+                    ? "response_stopped"
+                    : runtime === "traex" ? "traex_error" : "codex_error",
+                message,
+                source: "execution",
+            })) {
+                emitCurrent(se.type === "session.status"
+                    ? { ...se, status: "failed", note: message }
+                    : se);
+            }
+            clearPendingInputsForResponse(failedResponseId);
+            normalizer = null;
+            currentResponseId = null;
+        };
         const sink = {
             onTurnStart: (turnId) => startNormalizer(turnId),
+            onTurnObserved: (turnId) => {
+                const n = startNormalizer(turnId);
+                for (const event of n.next({ type: "turn_started", ...(turnId ? { turnId } : {}) })) {
+                    emitCurrent(event);
+                }
+            },
             onUserMessage: (content) => {
                 const normalizedContent = typeof content === "string"
                     ? [{ type: "input_text", text: content }]
@@ -990,45 +1041,28 @@ export class LocalAgentHost {
                     ...(statusKind ? { statusKind } : {}),
                 });
             },
-            onTurnEnd: (usage) => {
-                closeCanonicalInteractions();
-                if (!normalizer)
+            // A newer authoritative turn/started completes the old canonical
+            // response without publishing a false idle edge in a running→running
+            // transition.
+            onTurnEnd: completeCurrentTurn,
+            onRecoveredTurnStatus: (status, turnId, error) => {
+                const responseId = turnId ? `resp_codex_${turnId}` : undefined;
+                if (normalizer && (!responseId || currentResponseId === responseId)) {
+                    if (status === "failed")
+                        failCurrentTurn(error ?? new Error("Codex turn failed"));
+                    else
+                        completeCurrentTurn();
                     return;
-                const completedResponseId = currentResponseId;
-                if (usage) {
-                    for (const se of normalizer.next({ type: "turn_completed", usage }))
-                        emitCurrent(se);
                 }
-                for (const se of normalizer.next({ type: "done" }))
-                    emitCurrent(se);
-                clearPendingInputsForResponse(completedResponseId);
-                normalizer = null;
-                currentResponseId = null;
-            },
-            onTurnError: (error) => {
-                closeCanonicalInteractions();
-                if (!normalizer)
-                    return;
-                const failedResponseId = currentResponseId;
-                const responseStopped = error.message === "Codex turn was interrupted";
-                const providerName = runtime === "traex" ? "Traex" : "Codex";
-                const message = responseStopped
-                    ? "Response stopped"
-                    : runtime === "traex"
-                        ? error.message.replace(/^Codex\b/, providerName)
-                        : error.message;
-                for (const se of normalizer.fail({
-                    code: responseStopped
-                        ? "response_stopped"
-                        : runtime === "traex" ? "traex_error" : "codex_error",
-                    message,
-                    source: "execution",
-                }))
-                    emitCurrent(se);
-                clearPendingInputsForResponse(failedResponseId);
-                normalizer = null;
-                currentResponseId = null;
+                emitCurrent({
+                    type: "session.status",
+                    sessionId: currentSessionId,
+                    ...(responseId ? { responseId } : {}),
+                    status,
+                    ...(error ? { note: error.message } : {}),
+                });
             },
+            onTurnError: failCurrentTurn,
             // A resumed TUI may rebroadcast `thread/started`; binding is idempotent.
             shouldIgnoreThreadStarted: (threadId, forkedFromId) => this.shouldIgnoreManagedForkThreadStarted(live, threadId, forkedFromId),
             onThreadStarted: (threadId, forkedFromId) => this.onLiveThreadStarted(live, localThreadId, threadId, forkedFromId),
@@ -1140,6 +1174,7 @@ export class LocalAgentHost {
                     }
                 }
                 if (resumedThreadId) {
+                    forwarder.noteThreadBound(resumedThreadId);
                     this.onLiveThreadStarted(live, localThreadId, resumedThreadId);
                 }
                 else if (resumeError &&
@@ -1238,8 +1273,9 @@ export class LocalAgentHost {
      * `_subscribe_until_ready`). A fresh TUI thread has no rollout until its first
      * turn, so `thread/resume` is retried: park until the forwarder observes the
      * thread active, then retry. Resume only fetches the newest summarized Turn:
-     * recovery reconciles the exact active Turn's terminal status and never replays
-     * historical items. Once resume succeeds, subsequent turns arrive live.
+     * recovery reconciles the exact active Turn or publishes the newest explicit
+     * terminal status without replaying historical items. Once resume succeeds,
+     * subsequent turns arrive live.
      */
     async subscribeUntilReady(live, threadId) {
         while (!live.stopped) {
@@ -1255,13 +1291,12 @@ export class LocalAgentHost {
                     },
                 });
                 // Codex 0.146.1 accepts initialTurnsPage but can still return the entire
-                // rollout in chronological order. Never infer newest from array position:
-                // recovery may settle only the exact active turn id already owned here.
-                const activeTurnId = live.forwarder.currentTurnId();
-                const activeTurn = activeTurnId && Array.isArray(resp.thread.turns)
-                    ? resp.thread.turns.find((turn) => (turn.id ?? turn.turnId) === activeTurnId)
-                    : undefined;
-                live.forwarder.reconcileActiveTurn(activeTurn);
+                // rollout in chronological order. An identified active turn is matched
+                // by id; the no-active fallback reads only the final explicit status.
+                const turns = Array.isArray(resp.thread.turns)
+                    ? resp.thread.turns
+                    : [];
+                live.forwarder.reconcileResumeTurns(turns);
                 return true; // subscribed — live item/turn notifications now flow to the forwarder
             }
             catch (error) {
@@ -1476,30 +1511,11 @@ export class LocalAgentHost {
                     const turnId = live.forwarder.currentTurnId();
                     if (turnId) {
                         injectionMethod = "turn/steer";
-                        let steered;
-                        let retryIndex = 0;
-                        while (!steered) {
-                            try {
-                                steered = await live.injectClient.turnSteer({
-                                    threadId,
-                                    expectedTurnId: turnId,
-                                    input: nativeInput,
-                                });
-                            }
-                            catch (error) {
-                                const delayMs = TURN_STEER_ACTIVATION_RETRY_DELAYS_MS[retryIndex];
-                                if (delayMs === undefined ||
-                                    !isTransientTurnSteerActivationRace(error) ||
-                                    live.stopped ||
-                                    live.rotationPending ||
-                                    !live.forwarder.isTurnOpen() ||
-                                    live.forwarder.currentTurnId() !== turnId) {
-                                    throw error;
-                                }
-                                retryIndex += 1;
-                                await new Promise((resolve) => setTimeout(resolve, delayMs));
-                            }
-                        }
+                        const steered = await live.injectClient.turnSteer({
+                            threadId,
+                            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.
@@ -1515,7 +1531,7 @@ export class LocalAgentHost {
                         if (!live.observerAvailable) {
                             this.armObserverReconnectDeadline(live);
                         }
-                        return "injected";
+                        return "steered";
                     }
                 }
                 // Carry the agent-spec model on the turn so a web-injected turn runs the
@@ -1988,6 +2004,17 @@ export class LocalAgentHost {
                     emitCurrent(se);
             },
             onInteraction: forwardInteraction,
+            onStatus: (status, blockedOn) => {
+                const responseId = currentResponseId ??
+                    live.pendingInjectedInputs.find((entry) => entry.responseId)?.responseId;
+                emitCurrent({
+                    type: "session.status",
+                    sessionId: currentSessionId,
+                    ...(responseId ? { responseId } : {}),
+                    status,
+                    ...(blockedOn ? { note: blockedOn } : {}),
+                });
+            },
             onTurnEnd: (usage) => {
                 if (!normalizer)
                     return;
@@ -2028,16 +2055,20 @@ export class LocalAgentHost {
                     });
                 }
             },
-            onTurnError: () => {
+            onTurnError: (error) => {
                 if (!normalizer)
                     return;
                 const rid = currentResponseId;
+                const message = error.message || "Agent turn failed";
                 for (const se of normalizer.fail({
                     code: "agent_error",
-                    message: "Agent turn failed",
+                    message,
                     source: "execution",
-                }))
-                    emitCurrent(se);
+                })) {
+                    emitCurrent(se.type === "session.status"
+                        ? { ...se, status: "failed", note: message }
+                        : se);
+                }
                 live.pendingInjectedInputs = live.pendingInjectedInputs.filter((entry) => entry.responseId !== rid);
                 normalizer = null;
                 currentResponseId = undefined;
@@ -2196,14 +2227,18 @@ export class LocalAgentHost {
      *  (they inject via the app-server). Idempotent. */
     attachTerminalInjector(localThreadId, injector) {
         const live = this.liveClaudeSessions.get(localThreadId);
-        if (live)
+        if (live) {
+            if (live.injector === injector)
+                return;
             live.injector = injector;
+            live.forwarder.attachStatusSource({ panePid: () => injector.panePid?.() });
+        }
     }
     /** Close an active native response when its terminal or runner disappears. */
     failLiveSession(localThreadId, error) {
         const claude = this.liveClaudeSessions.get(localThreadId);
         if (claude)
-            return claude.forwarder.failOpenTurn(error);
+            return claude.forwarder.noteTerminalExit(error);
         const codex = this.liveSessions.get(localThreadId);
         if (!codex)
             return false;
@@ -2387,20 +2422,6 @@ function codexRpcError(error, method) {
     }
     return `Codex ${method} failed: ${error instanceof Error ? error.message : String(error)}`;
 }
-/**
- * Codex 0.146 can acknowledge `turn/start` a few milliseconds before its
- * internal active-turn pointer becomes visible to `turn/steer`. The injection
- * lock still prevents double-starts, but the immediately following steer must
- * briefly retry the same expected turn id. Keep this narrow: all other RPC
- * errors remain terminal and visible to the caller.
- */
-function isTransientTurnSteerActivationRace(error) {
-    return error instanceof CodexTransportError &&
-        error.code === -32600 &&
-        (/no active turn to steer/i.test(error.message) ||
-            /expected active turn id\b.+\bfound\b/i.test(error.message));
-}
-const TURN_STEER_ACTIVATION_RETRY_DELAYS_MS = [10, 20, 40, 80, 160, 250, 440];
 export function parseCodexLoginStatus(exitCode, output) {
     const normalized = output.trim();
     const match = normalized.match(/Logged in using (.+)$/im);

package/dist/runner/child.js

@@ -304,7 +304,7 @@ export class RunnerSession {
             const outcome = (await provider.injectMessage?.(msg.localThreadId, input)) ?? "notLive";
             // App-server injection is independent of the Terminal TUI startup, so it
             // must not cancel prompt handling for the pane that is still starting.
-            const error = outcome === "injected"
+            const error = outcome === "injected" || outcome === "steered"
                 ? undefined
                 : provider.liveSessionError?.(msg.localThreadId);
             this.transport.send({

package/dist/runner/manager.d.ts

@@ -43,9 +43,10 @@ export interface RunnerManagerOptions {
     runnerEntry?: string;
     /** Idle TTL (ms) after which an unused runner is reaped. */
     idleTtlMs?: number;
-    /** Maximum time without user/control activity that an active response may
-     * protect a detached runner from idle reaping. */
-    staleActiveTtlMs?: number;
+    /** Native pane idle window. `<= 0` disables native-pane idle reaping. */
+    nativePaneIdleTtlMs?: number;
+    /** Recent tmux-output window used as independent native-pane busy evidence. */
+    nativePaneOutputBusyWindowMs?: number;
     /** Background reap sweep interval (ms); `0` disables the timer (tests). */
     reapIntervalMs?: number;
     /** Grace period between SIGTERM and SIGKILL during runner shutdown. */
@@ -75,7 +76,13 @@ export interface RunnerManagerOptions {
     /** Injected for tests. Kills and verifies the deterministic private tmux
      * server owned by a Session runner. */
     terminateTerminalServer?: (terminalName: string) => boolean | Promise<boolean>;
+    /** Injected tmux `#{window_activity}` reader. Returns epoch seconds. */
+    terminalWindowActivityAt?: (terminalName: string) => number | null | Promise<number | null>;
+    /** Injected tmux attached-client probe. */
+    terminalHasAttachedClient?: (terminalName: string) => boolean | Promise<boolean>;
     now?: () => number;
+    /** Wall clock used to compare tmux's epoch timestamp. */
+    wallNow?: () => number;
     /** Extra env merged into every spawned runner child — e.g. the control-plane
      *  URL + token so a claude-native PermissionRequest hook can POST back. */
     childEnv?: Record<string, string>;
@@ -142,7 +149,8 @@ export declare class RunnerManager implements AgentCapabilities {
     private readonly sessionStore;
     private readonly runnerEntry;
     private readonly idleTtlMs;
-    private readonly staleActiveTtlMs;
+    private readonly nativePaneIdleTtlMs;
+    private readonly nativePaneOutputBusyWindowMs;
     private readonly spawn;
     private readonly childEnv;
     private readonly sessionContextProvider;
@@ -159,12 +167,16 @@ export declare class RunnerManager implements AgentCapabilities {
     private readonly shutdownKillGraceMs;
     private readonly signalChild;
     private readonly terminateTerminalServer;
+    private readonly terminalWindowActivityAt;
+    private readonly terminalHasAttachedClient;
+    private readonly wallNow;
     private readonly liveStartTimeoutMs;
     private readonly liveReadyTimeoutMs;
     private readonly nativeLiveStartTimeoutMs;
     private readonly liveInterruptTimeoutMs;
     private readonly terminalInputHandoffTimeoutMs;
     private readonly terminalInputCleanupRetryMs;
+    private reapPromise;
     private stopping;
     private stopPromise;
     /** Sink for mirrored {@link SessionEvent}s from every session's forwarder. */
@@ -321,14 +333,17 @@ export declare class RunnerManager implements AgentCapabilities {
     private failHandle;
     private terminateHandle;
     private reapIdle;
-    /** Close server-side runtime state before fencing a Provider that stayed
-     * active past its hard inactivity deadline. The child transport is closed by
-     * terminateHandle immediately afterwards, so these are the final events for
-     * the abandoned responses. */
-    private failStaleActiveResponses;
+    private reapIdleOnce;
+    /** Provider-authoritative turn state is the lifecycle truth; attached clients
+     * and tmux's own activity clock are independent busy evidence. There is no
+     * "user was inactive for an hour" override for an active turn. */
+    private reapNativePane;
+    private isNativePaneBusy;
+    private isManagedNativeHandle;
     private failActiveResponses;
-    /** Track only response lifecycle, not output volume. Output deltas from a
-     * runaway TUI/Provider must not refresh the stale-active deadline. */
+    /** Track the provider-authoritative response lifecycle. Native-pane busy
+     * classification consumes this level directly; output volume is separately
+     * grounded in tmux's own activity clock. */
     private observeHandleRuntimeEvent;
     private openSessionContext;
 }

package/dist/runner/manager.js

@@ -22,7 +22,7 @@ import { fileURLToPath } from "node:url";
 import { AgentRuntimeError, } from "@rynx-ai/core";
 import { listRuntimeModels } from "../models-catalog.js";
 import { probeRuntimeStatus } from "../runtime-status.js";
-import { terminateTmuxServer } from "../terminal/tmux.js";
+import { terminateTmuxServer, tmuxHasAttachedClient, tmuxWindowActivityAt, } from "../terminal/tmux.js";
 import { fromWireError, } from "./protocol.js";
 import { isManagedNativeProvider } from "./startup-policy.js";
 import { StdioRunnerTransport } from "./transport.js";
@@ -51,12 +51,10 @@ const DEFAULT_TERMINAL_INPUT_HANDOFF_TIMEOUT_MS = 30_000;
 /** Retry transient terminal-server cleanup without spinning forever. */
 const DEFAULT_TERMINAL_INPUT_CLEANUP_RETRY_MS = 1_000;
 const MAX_TERMINAL_INPUT_CLEANUP_RETRY_MS = 30_000;
-/** A Provider that never closes its active response must not keep a detached
- * runner + tmux server alive forever. This is intentionally much longer than
- * the normal idle TTL so legitimate long-running turns are not treated as
- * stale. User input/control activity refreshes the deadline; Provider output
- * does not, because a runaway redraw loop is the failure mode this bounds. */
-const DEFAULT_STALE_ACTIVE_TTL_MS = 60 * 60_000;
+/** Full idle window before an inactive native pane becomes reapable. */
+const DEFAULT_NATIVE_PANE_IDLE_TTL_MS = 60 * 60_000;
+/** tmux output this recent independently proves that a native pane is busy. */
+const DEFAULT_NATIVE_PANE_OUTPUT_BUSY_WINDOW_MS = 120_000;
 /** Keep per-Session spawn context small enough to remain an environment handoff,
  * not an unbounded transport. */
 const MAX_SESSION_CONTEXT_ENV_ENTRIES = 32;
@@ -157,7 +155,8 @@ export class RunnerManager {
     sessionStore;
     runnerEntry;
     idleTtlMs;
-    staleActiveTtlMs;
+    nativePaneIdleTtlMs;
+    nativePaneOutputBusyWindowMs;
     spawn;
     childEnv;
     sessionContextProvider;
@@ -174,12 +173,16 @@ export class RunnerManager {
     shutdownKillGraceMs;
     signalChild;
     terminateTerminalServer;
+    terminalWindowActivityAt;
+    terminalHasAttachedClient;
+    wallNow;
     liveStartTimeoutMs;
     liveReadyTimeoutMs;
     nativeLiveStartTimeoutMs;
     liveInterruptTimeoutMs;
     terminalInputHandoffTimeoutMs;
     terminalInputCleanupRetryMs;
+    reapPromise = null;
     stopping = false;
     stopPromise;
     /** Sink for mirrored {@link SessionEvent}s from every session's forwarder. */
@@ -213,18 +216,22 @@ export class RunnerManager {
         this.sessionStore = opts.sessionStore;
         this.runnerEntry = opts.runnerEntry ?? defaultRunnerEntry();
         this.idleTtlMs = opts.idleTtlMs ?? 300_000;
-        this.staleActiveTtlMs = Math.max(this.idleTtlMs, opts.staleActiveTtlMs ?? DEFAULT_STALE_ACTIVE_TTL_MS);
+        this.nativePaneIdleTtlMs = opts.nativePaneIdleTtlMs ?? DEFAULT_NATIVE_PANE_IDLE_TTL_MS;
+        this.nativePaneOutputBusyWindowMs = Math.max(0, opts.nativePaneOutputBusyWindowMs ?? DEFAULT_NATIVE_PANE_OUTPUT_BUSY_WINDOW_MS);
         this.spawn = opts.spawn ?? nodeSpawn;
         this.childEnv = opts.childEnv ?? {};
         this.sessionContextProvider = opts.sessionContextProvider;
         this.admissionOpen = opts.admissionOpen ?? (() => true);
         this.admissionReserve = opts.admissionReserve;
         this.now = opts.now ?? (() => Date.now());
+        this.wallNow = opts.wallNow ?? (() => Date.now());
         this.defaultRuntime = opts.config.DEFAULT_RUNTIME ?? "codex";
         this.shutdownGraceMs = Math.max(0, opts.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS);
         this.shutdownKillGraceMs = Math.max(0, opts.shutdownKillGraceMs ?? DEFAULT_SHUTDOWN_KILL_GRACE_MS);
         this.signalChild = opts.signalChild ?? signalRunnerChild;
         this.terminateTerminalServer = opts.terminateTerminalServer ?? terminateTmuxServer;
+        this.terminalWindowActivityAt = opts.terminalWindowActivityAt ?? tmuxWindowActivityAt;
+        this.terminalHasAttachedClient = opts.terminalHasAttachedClient ?? tmuxHasAttachedClient;
         this.liveStartTimeoutMs = Math.max(1, opts.liveStartTimeoutMs ?? DEFAULT_LIVE_START_TIMEOUT_MS);
         this.liveReadyTimeoutMs = Math.max(1, opts.liveReadyTimeoutMs ?? DEFAULT_LIVE_READY_TIMEOUT_MS);
         this.nativeLiveStartTimeoutMs = Math.max(1, opts.nativeLiveStartTimeoutMs ?? DEFAULT_NATIVE_LIVE_START_TIMEOUT_MS);
@@ -233,7 +240,7 @@ export class RunnerManager {
         this.terminalInputCleanupRetryMs = Math.max(1, opts.terminalInputCleanupRetryMs ?? DEFAULT_TERMINAL_INPUT_CLEANUP_RETRY_MS);
         const reapIntervalMs = opts.reapIntervalMs ?? 60_000;
         if (reapIntervalMs > 0) {
-            this.reapTimer = setInterval(() => this.reapIdle(), reapIntervalMs);
+            this.reapTimer = setInterval(() => void this.reapIdle(), reapIntervalMs);
             this.reapTimer.unref?.();
         }
         else {
@@ -648,7 +655,7 @@ export class RunnerManager {
             handle.live.set(reqId, (res) => {
                 const outcome = res.outcome ?? "failed";
                 const finish = () => {
-                    if (outcome === "injected") {
+                    if (outcome === "injected" || outcome === "steered") {
                         this.liveErrors.delete(localThreadId);
                     }
                     else {
@@ -902,7 +909,6 @@ export class RunnerManager {
                 !allowReservedForkTarget) {
                 throw new AgentRuntimeError("Session fork is still being committed", 409, "session_fork_pending");
             }
-            this.reapIdle();
             const existing = this.handles.get(key);
             if (existing && !existing.dead) {
                 existing.lastUsedAt = this.now();
@@ -1369,8 +1375,24 @@ export class RunnerManager {
         return attempt;
     }
     reapIdle() {
+        if (this.reapPromise)
+            return this.reapPromise;
+        const attempt = this.reapIdleOnce();
+        this.reapPromise = attempt;
+        const clear = () => {
+            if (this.reapPromise === attempt)
+                this.reapPromise = null;
+        };
+        void attempt.then(clear, clear);
+        return attempt;
+    }
+    async reapIdleOnce() {
         const now = this.now();
         for (const [key, handle] of this.handles) {
+            if (this.isManagedNativeHandle(handle)) {
+                await this.reapNativePane(handle, now);
+                continue;
+            }
             if (handle.caps.size > 0 || handle.terminals.size > 0 || handle.live.size > 0) {
                 continue;
             }
@@ -1379,28 +1401,74 @@ export class RunnerManager {
                 continue;
             }
             const hasActiveResponse = handle.activeResponseIds.size > 0;
-            if (hasActiveResponse && idleForMs < this.staleActiveTtlMs) {
+            if (hasActiveResponse)
                 continue;
-            }
-            const reason = hasActiveResponse
-                ? "stale active runner reaped"
-                : this.liveSessionKeys.has(key)
-                    ? "idle live runner reaped"
-                    : "idle runner reaped";
-            if (hasActiveResponse) {
-                this.failStaleActiveResponses(handle, idleForMs);
-            }
+            const reason = this.liveSessionKeys.has(key)
+                ? "idle live runner reaped"
+                : "idle runner reaped";
             void this.terminateHandle(handle, reason).catch((error) => {
                 logTerminationFailure(handle, error);
             });
         }
     }
-    /** Close server-side runtime state before fencing a Provider that stayed
-     * active past its hard inactivity deadline. The child transport is closed by
-     * terminateHandle immediately afterwards, so these are the final events for
-     * the abandoned responses. */
-    failStaleActiveResponses(handle, idleForMs) {
-        this.failActiveResponses(handle, "stale_runner_reaped", `Runner was reaped after ${Math.floor(idleForMs / 1000)}s without user activity`);
+    /** Provider-authoritative turn state is the lifecycle truth; attached clients
+     * and tmux's own activity clock are independent busy evidence. There is no
+     * "user was inactive for an hour" override for an active turn. */
+    async reapNativePane(handle, now) {
+        if (this.nativePaneIdleTtlMs <= 0 || handle.dead)
+            return;
+        if (await this.isNativePaneBusy(handle)) {
+            handle.nativePaneLastBusyAt = now;
+            return;
+        }
+        const lastBusyAt = handle.nativePaneLastBusyAt;
+        if (lastBusyAt === undefined) {
+            // First idle observation starts a full grace window.
+            handle.nativePaneLastBusyAt = now;
+            return;
+        }
+        if (now - lastBusyAt < this.nativePaneIdleTtlMs)
+            return;
+        // Close the select→reap race: activity may begin after classification but
+        // before teardown.
+        if (await this.isNativePaneBusy(handle)) {
+            handle.nativePaneLastBusyAt = this.now();
+            return;
+        }
+        // A failed teardown must re-arm on the next scan instead of retrying on
+        // every sweep forever.
+        delete handle.nativePaneLastBusyAt;
+        await this.terminateHandle(handle, "idle native pane reaped").catch((error) => logTerminationFailure(handle, error));
+    }
+    async isNativePaneBusy(handle) {
+        if (handle.activeResponseIds.size > 0 ||
+            handle.caps.size > 0 ||
+            handle.live.size > 0 ||
+            handle.terminals.size > 0) {
+            return true;
+        }
+        const terminalName = `${handle.key}-main`;
+        try {
+            if (await this.terminalHasAttachedClient(terminalName))
+                return true;
+        }
+        catch {
+            // A failed probe contributes no busy evidence; check activity next.
+        }
+        let activityAt = null;
+        try {
+            activityAt = await this.terminalWindowActivityAt(terminalName);
+        }
+        catch {
+            // A failed probe contributes no busy evidence.
+        }
+        return activityAt !== null &&
+            this.wallNow() - activityAt * 1_000 < this.nativePaneOutputBusyWindowMs;
+    }
+    isManagedNativeHandle(handle) {
+        const sessionId = this.currentTerminalSessionId(handle, handle.key);
+        const provider = this.liveOptions.get(sessionId)?.execution.provider;
+        return isManagedNativeProvider(provider);
     }
     failActiveResponses(handle, code, message) {
         const responseIds = [...handle.activeResponseIds];
@@ -1418,8 +1486,9 @@ export class RunnerManager {
             });
         }
     }
-    /** Track only response lifecycle, not output volume. Output deltas from a
-     * runaway TUI/Provider must not refresh the stale-active deadline. */
+    /** Track the provider-authoritative response lifecycle. Native-pane busy
+     * classification consumes this level directly; output volume is separately
+     * grounded in tmux's own activity clock. */
     observeHandleRuntimeEvent(handle, event) {
         switch (event.type) {
             case "response.created":

package/dist/runner/protocol.d.ts

@@ -6,7 +6,8 @@
  * (`live.ensure` / `inject` / `live.interrupt`) plus per-thread capabilities and
  * terminal attachment; the reply channels mirror each request's `reqId`.
  */
-import { AgentRuntimeError, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+import { AgentRuntimeError, type InjectOutcome, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+export type { InjectOutcome } from "@rynx-ai/core";
 import type { ResolveInteractionResult } from "../interactions.js";
 /** A runtime error flattened for the wire; rebuilt parent-side as `AgentRuntimeError`. */
 export interface WireError {
@@ -22,13 +23,6 @@ export type TerminalRole = "owner" | "read-only";
 /** Stable reason for a terminal attach failure. `terminal_not_live` is an
  * expected, retryable absence; `terminal_open_failed` is an infrastructure error. */
 export type TerminalOpenErrorCode = "terminal_not_live" | "terminal_open_failed";
-/** Outcome of an `inject`. `injected` = the app-server / tmux accepted the turn.
- *  `notLive` = no live forwarder for this session (caller may use the run path).
- *  `notReady` = live but not ready within the park window; `failed` = injection
- *  threw. For BOTH notReady and failed the caller reports an error and MUST NOT
- *  re-run the turn (re-running would double-write alongside the forwarder).
- *  Mirrors reference implementation's "inject failure ⇒ response.failed, never re-run locally". */
-export type InjectOutcome = "injected" | "notLive" | "notReady" | "failed";
 /** Parent → child. Terminal PTY bytes ride `term.input` base64-encoded so the
  *  NDJSON line framing stays intact (raw bytes contain newlines). */
 export type ToChild = {
@@ -171,9 +165,9 @@ export type FromChild = {
     ok: boolean;
     error?: string;
 }
-/** Result of an `inject`: `outcome` distinguishes injected / notLive / notReady /
- *  failed so the caller never falls back to a second output path on a live
- *  session. Echoes the request `reqId`. */
+/** Result of an `inject`: `outcome` distinguishes a new turn, an active-turn
+ *  steer, and failures so the caller never falls back to a second output path.
+ *  Echoes the request `reqId`. */
  | {
     t: "injected";
     reqId: string;