@rynx-ai/runtime 0.1.11-beta.21 → 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/client.d.ts

@@ -29,9 +29,11 @@ export declare class CodexAppServerClient {
     private interactionListener;
     private connectionListener;
     private connectionState;
+    private connectionEstablished;
     private readonly pendingInteractions;
     private readonly settledInteractions;
     private initializeResponse;
+    private initializePromise;
     constructor({ spawner, channel, logger, clientInfo, approvalDecisionPolicy, }: CodexAppServerClientOptions);
     /**
      * The multi-client endpoint a `codex --remote` TUI can attach to, when this
@@ -94,9 +96,8 @@ export declare class CodexAppServerClient {
      * resolver still wins correctly.
      */
     setInteractionListener(listener: RuntimeInteractionListener | null): void;
-    /** Observe the underlying app-server connection independently from any one
-     * interaction. A disconnected client that never received the duplicate
-     * native request still has to count as unavailable during host failover. */
+    /** Observe the initialized connection lifecycle. Registration never reports
+     * disconnected for a client that has not connected yet. */
     setConnectionListener(listener: ((state: "connected" | "disconnected") => void) | null): void;
     private setConnectionState;
     resolveInteraction(interactionId: string, resolution: SessionInteractionResolution): ResolveInteractionResult;

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

@@ -953,9 +953,11 @@ export class CodexAppServerClient {
     interactionListener = null;
     connectionListener = null;
     connectionState = "disconnected";
+    connectionEstablished = false;
     pendingInteractions = new Map();
     settledInteractions = new Set();
     initializeResponse = null;
+    initializePromise = null;
     constructor({ spawner, channel, logger = defaultLogger, clientInfo = DEFAULT_CLIENT_INFO, approvalDecisionPolicy = "auto-approve-session", }) {
         this.logger = logger;
         this.clientInfo = clientInfo;
@@ -988,14 +990,31 @@ export class CodexAppServerClient {
         if (this.initializeResponse) {
             return this.initializeResponse;
         }
-        await this.transport.ensureStarted();
-        const response = await this.transport.sendRequest("initialize", {
-            clientInfo: this.clientInfo,
-            capabilities: { experimentalApi: true },
-        });
-        this.initializeResponse = response;
-        this.setConnectionState("connected");
-        return response;
+        if (this.initializePromise)
+            return this.initializePromise;
+        const initializing = (async () => {
+            await this.transport.ensureStarted();
+            const response = await this.transport.sendRequest("initialize", {
+                clientInfo: this.clientInfo,
+                capabilities: { experimentalApi: true },
+            });
+            // Codex app-server uses the full initialize handshake: it does not accept
+            // capability requests after merely replying to `initialize`. The client
+            // must acknowledge that response with the `initialized` notification
+            // before `thread/resume`, `turn/start`, and the other APIs are legal.
+            await this.transport.sendNotification("initialized");
+            this.initializeResponse = response;
+            this.setConnectionState("connected");
+            return response;
+        })();
+        this.initializePromise = initializing;
+        try {
+            return await initializing;
+        }
+        finally {
+            if (this.initializePromise === initializing)
+                this.initializePromise = null;
+        }
     }
     async getAuthStatus(params = {}) {
         await this.ensureInitialized();
@@ -1146,14 +1165,18 @@ export class CodexAppServerClient {
     setInteractionListener(listener) {
         this.interactionListener = listener;
     }
-    /** Observe the underlying app-server connection independently from any one
-     * interaction. A disconnected client that never received the duplicate
-     * native request still has to count as unavailable during host failover. */
+    /** Observe the initialized connection lifecycle. Registration never reports
+     * disconnected for a client that has not connected yet. */
     setConnectionListener(listener) {
         this.connectionListener = listener;
-        listener?.(this.connectionState);
+        if (listener && this.connectionEstablished)
+            listener(this.connectionState);
     }
     setConnectionState(state) {
+        if (state === "connected")
+            this.connectionEstablished = true;
+        if (state === "disconnected" && !this.connectionEstablished)
+            return;
         if (this.connectionState === state)
             return;
         this.connectionState = state;

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;
@@ -134,13 +136,6 @@ export declare class CodexSessionForwarder {
      * not doubled.
      */
     replayBackfill(turns: ResumedTurn[]): void;
-    /** Reconcile only the exact active turn after an observer resume. Historical
-     * items are intentionally not replayed on an existing-thread reconnect. */
-    reconcileActiveTurn(turn: ResumedTurn | undefined): boolean;
-    /** Reconcile an observer reconnect from the explicit resume snapshot. An
-     * identified active turn must match exactly; with no active turn, only the
-     * newest explicit terminal status is published and no history is replayed. */
-    reconcileResumeTurns(turns: ResumedTurn[]): boolean;
     /** Fail an open response exactly once when its observer or terminal exits. */
     failOpenTurn(error: Error): boolean;
     private handle;

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

@@ -209,54 +209,6 @@ export class CodexSessionForwarder {
                 this.sink.onTurnEnd(mapped.usage);
         }
     }
-    /** Reconcile only the exact active turn after an observer resume. Historical
-     * items are intentionally not replayed on an existing-thread reconnect. */
-    reconcileActiveTurn(turn) {
-        if (!this.isTurnOpen() || !turn || codexResumeTerminalStatus(turn) === undefined)
-            return false;
-        const resumedTurnId = turn.id ?? turn.turnId;
-        if (!this.currentTurnIdValue || resumedTurnId !== this.currentTurnIdValue)
-            return false;
-        const mapped = mapCodexNotification("turn/completed", { turn });
-        this.ensureTurn();
-        this.settle(mapped.fatalError
-            ? { kind: "error", error: mapped.fatalError }
-            : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
-        return true;
-    }
-    /** Reconcile an observer reconnect from the explicit resume snapshot. An
-     * identified active turn must match exactly; with no active turn, only the
-     * newest explicit terminal status is published and no history is replayed. */
-    reconcileResumeTurns(turns) {
-        if (this.currentThreadIdValue === null)
-            return false;
-        for (let index = turns.length - 1; index >= 0; index -= 1) {
-            const turn = turns[index];
-            if (!turn)
-                continue;
-            const turnId = turn.id ?? turn.turnId;
-            if (!turnId)
-                return false;
-            if (this.currentTurnIdValue !== null && this.currentTurnIdValue !== turnId) {
-                return false;
-            }
-            const status = codexResumeTerminalStatus(turn);
-            if (!status)
-                return false;
-            const mapped = mapCodexNotification("turn/completed", { turn });
-            if (this.currentTurnIdValue !== null || this.turnOpen) {
-                this.ensureTurn();
-                this.settle(mapped.fatalError
-                    ? { kind: "error", error: mapped.fatalError }
-                    : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
-            }
-            else {
-                this.sink.onRecoveredTurnStatus?.(status, turnId, mapped.fatalError);
-            }
-            return true;
-        }
-        return false;
-    }
     /** Fail an open response exactly once when its observer or terminal exits. */
     failOpenTurn(error) {
         if (!this.isTurnOpen())
@@ -347,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
@@ -407,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();
@@ -449,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/codex-app-server/protocol.d.ts

@@ -105,8 +105,7 @@ export interface ThreadStartParams {
 }
 export interface ThreadResumeParams extends ThreadStartParams {
     threadId: string;
-    /** Legacy whole-backlog suppression. New callers should prefer
-     * `initialTurnsPage` so recovery can fetch one summarized terminal status. */
+    /** Suppress rollout history when the caller only needs to load/subscribe. */
     excludeTurns?: boolean;
     initialTurnsPage?: {
         limit?: number | null;

package/dist/host.d.ts

@@ -1,8 +1,8 @@
-import { type ResolvedExecutionSnapshot, type ResolvedExecutionBudget, type RuntimeUserInput, type SessionWorkspaceSnapshot, type SessionInteractionResolution, type SessionEvent } from "@rynx-ai/core";
+import { type ResolvedExecutionSnapshot, type ResolvedExecutionBudget, type RuntimeUserInput, type LiveSessionFailure, type SessionWorkspaceSnapshot, type SessionInteractionResolution, type SessionEvent } from "@rynx-ai/core";
 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";
@@ -125,7 +125,9 @@ export declare class LocalAgentHost implements CodexCapabilities {
     private readonly clock;
     private readonly backendIdleTtlMs;
     private readonly forwarderClientFactory;
-    private readonly observerReconnectTimeoutMs;
+    private readonly preloadClientFactory;
+    /** Builds one short-lived message/interrupt client. */
+    private readonly injectionClientFactory;
     private readonly backends;
     private readonly sessionId;
     private readonly runtimeHomeSessionId;
@@ -146,7 +148,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
     /** Short-lived dedupe for managed fork notifications delivered after the
      * `thread/fork` response. Values are expected source Provider thread ids. */
     private readonly managedForkThreadStarts;
-    constructor({ config, commandRunner, sessionStore, allowedRoots, appServerClient, now, backendIdleTtlMs, forwarderClientFactory, observerReconnectTimeoutMs, sessionId, runtimeHomeSessionId, }: {
+    constructor({ config, commandRunner, sessionStore, allowedRoots, appServerClient, now, backendIdleTtlMs, forwarderClientFactory, preloadClientFactory, injectionClientFactory, sessionId, runtimeHomeSessionId, }: {
         config: AppConfig;
         commandRunner?: CodexCommandRunner;
         sessionStore?: CodexSessionStore;
@@ -158,8 +160,10 @@ export declare class LocalAgentHost implements CodexCapabilities {
         backendIdleTtlMs?: number;
         /** Override the live-session forwarder connection factory (tests inject a fake). */
         forwarderClientFactory?: (appServerUrl: string) => CodexAppServerClient;
-        /** Grace window for observer reconnect before an active response is failed. */
-        observerReconnectTimeoutMs?: number;
+        /** Override the short-lived known-thread preload connection factory. */
+        preloadClientFactory?: (appServerUrl: string) => CodexAppServerClient;
+        /** Override the short-lived message/interrupt connection factory. */
+        injectionClientFactory?: (appServerUrl: string) => CodexAppServerClient;
         /** The rynx session (localThreadId) this host serves — a per-session runner
          *  child sets it from `RYNX_RUNNER_SESSION` so the private CODEX_HOME is
          *  session-scoped. The shared `__cap__` child / tests fall back to a sentinel
@@ -219,33 +223,39 @@ export declare class LocalAgentHost implements CodexCapabilities {
     /** Bind a session's codex thread id once known (TUI broadcast or store): persist
      *  it, unblock injection, and kick off the resume-subscribe loop (once). */
     private onLiveThreadStarted;
+    /** Start the known-thread observer after the replacement TUI has launched.
+     * Fresh sessions already connected their discovery listener before launch;
+     * this is therefore an idempotent no-op for them and for a healthy observer. */
+    startLiveCodexObserver(localThreadId: string): void;
+    /** Omnigent treats the forwarder as a required component of one native
+     * lifecycle: if its transport dies, it closes the app-server instead of
+     * accepting turns that can no longer reach the canonical mirror. */
+    private failObserverLifecycle;
     private shouldIgnoreManagedForkThreadStarted;
     private rememberManagedForkThreadStart;
     /**
      * Subscribe the forwarder connection to a thread (reference implementation's
      * `_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 or publishes the newest explicit
-     * terminal status without replaying historical items. Once resume succeeds,
-     * subsequent turns arrive live.
+     * thread active, then retry. Like Omnigent, the first attempt always uses
+     * `excludeTurns`: a known-session cold resume therefore never reconstructs
+     * historical running/completed state. Only a fresh thread whose first attempt
+     * failed as not-ready retries without `excludeTurns`, backfilling the newly
+     * materialized first turn and de-duplicating it against live notifications.
      */
     private subscribeUntilReady;
-    /** Restore the independent observer after an unexpected exit. The active turn
-     * remains open during the bounded grace so resume can reconcile its exact id. */
-    private reconnectForwarder;
-    private armObserverReconnectDeadline;
-    private clearObserverReconnectDeadline;
     /** Await a live session's thread binding. `null` leaves the deadline to the
      *  caller; a number keeps the Provider-local bound. Returns false on timeout /
      *  no live session. Injection and the runner's `live.ready` gate on this. */
     waitLiveReady(localThreadId: string, timeoutMs?: number | null): Promise<boolean>;
-    /** Await the stronger Terminal gate: another app-server connection has
-     * successfully resumed the thread, so the detached TUI cannot race rollout
-     * discovery or indexing. */
+    /** Await the observer subscription diagnostic. Codex/Traex Terminal startup
+     * deliberately does not gate on this promise: the dedicated preload owns resume,
+     * while the independent observer attaches in the background. */
     waitTerminalReady(localThreadId: string, timeoutMs?: number | null): Promise<boolean>;
     /** Diagnostic from the provider adapter when native discovery/resume failed. */
     liveSessionError(localThreadId: string): string | undefined;
+    /** Structured phase + concrete cause used by the runner wire protocol. */
+    liveSessionFailure(localThreadId: string): LiveSessionFailure | undefined;
     /** Publish the background TUI/thread discovery failure so an executor
      * already waiting in the 60s bridge window exits immediately with the exact
      * 30s discovery cause. */
@@ -257,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
@@ -277,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;
@@ -298,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
@@ -339,7 +354,3 @@ export declare function isUnsupportedMethodError(error: unknown): boolean;
  *  — a fresh TUI thread before its first turn. Retryable (park until active).
  *  Mirrors reference implementation's `_is_thread_not_ready_error`. */
 export declare function isThreadNotReadyError(error: unknown): boolean;
-/** A persisted thread id that a freshly started app-server cannot load yet.
- * During startup, both errors can be transient while the rollout index catches
- * up. Retry the same id; never use either error as permission to replace it. */
-export declare function isRetryableThreadResumeError(error: unknown): boolean;