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

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

@@ -134,13 +134,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())

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,4 +1,4 @@
-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";
@@ -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. */
@@ -339,7 +349,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;