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

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

@@ -105,11 +105,14 @@ export interface ThreadStartParams {
 }
 export interface ThreadResumeParams extends ThreadStartParams {
     threadId: string;
-    /** When true, the resume response omits the thread's `turns` backlog (used to
-     *  SUBSCRIBE without re-replaying history). When false/absent, the response
-     *  carries `thread.turns[].items[]` — the backfill the forwarder replays for a
-     *  fresh thread's first turn (reference implementation's `_replay_resume_response`). */
+    /** Legacy whole-backlog suppression. New callers should prefer
+     * `initialTurnsPage` so recovery can fetch one summarized terminal status. */
     excludeTurns?: boolean;
+    initialTurnsPage?: {
+        limit?: number | null;
+        sortDirection?: "asc" | "desc" | null;
+        itemsView?: "notLoaded" | "summary" | "full" | null;
+    } | null;
 }
 /** One turn in a resumed thread's backlog (`thread/resume` response). */
 export interface ResumedTurn {
@@ -169,7 +172,7 @@ export interface TurnSteerParams {
     expectedTurnId: string;
     input: UserInput[];
 }
-export type TurnStatus = "completed" | "interrupted" | "failed" | "inProgress";
+export type TurnStatus = "completed" | "interrupted" | "cancelled" | "canceled" | "failed" | "errored" | "inProgress";
 export interface TurnPlanStep {
     step: string;
     status: "pending" | "inProgress" | "completed";

package/dist/codex-app-server/ws-channel.js

@@ -28,6 +28,7 @@ async function freeLoopbackPort() {
         });
     });
 }
+const DEFAULT_CONNECT_TIMEOUT_MS = 10_000;
 export class WsRpcChannel {
     opts;
     child = null;
@@ -40,7 +41,7 @@ export class WsRpcChannel {
     url = "";
     constructor(opts) {
         this.opts = opts;
-        this.readyTimeoutMs = opts.readyTimeoutMs ?? 15_000;
+        this.readyTimeoutMs = opts.readyTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
     }
     onLine(cb) {
         this.lineCb = cb;
@@ -114,7 +115,7 @@ export class WsRpcChannel {
         // eslint-disable-next-line no-constant-condition
         while (Date.now() < deadline) {
             try {
-                return await this.tryConnect(url);
+                return await this.tryConnect(url, Math.max(1, deadline - Date.now()));
             }
             catch (error) {
                 lastError = error;
@@ -123,9 +124,9 @@ export class WsRpcChannel {
         }
         throw new Error(`codex app-server ws did not become ready at ${url}: ${lastError?.message ?? "timeout"}`);
     }
-    tryConnect(url) {
+    tryConnect(url, handshakeTimeout) {
         return new Promise((resolve, reject) => {
-            const ws = new WebSocket(url);
+            const ws = new WebSocket(url, { handshakeTimeout });
             const onOpen = () => {
                 ws.off("error", onError);
                 resolve(ws);
@@ -166,7 +167,7 @@ export class ExternalWsChannel {
     /** The `ws://IP:PORT` of the already-running app-server to attach to. */
     url, opts = {}) {
         this.url = url;
-        this.readyTimeoutMs = opts.readyTimeoutMs ?? 15_000;
+        this.readyTimeoutMs = opts.readyTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
     }
     onLine(cb) {
         this.lineCb = cb;
@@ -178,20 +179,16 @@ export class ExternalWsChannel {
         return this.ws?.readyState === WebSocket.OPEN;
     }
     async start() {
-        const deadline = Date.now() + this.readyTimeoutMs;
-        let lastError;
-        while (Date.now() < deadline) {
-            try {
-                this.ws = await this.connect(this.url);
-                break;
-            }
-            catch (error) {
-                lastError = error;
-                await new Promise((r) => setTimeout(r, 150));
-            }
+        // A channel instance is reusable after an observer disconnect. Do not let
+        // the prior closed socket make a failed reconnect look successful, and arm
+        // close delivery for the newly connected socket.
+        this.ws = null;
+        this.closedEmitted = false;
+        try {
+            this.ws = await this.connect(this.url);
         }
-        if (!this.ws) {
-            throw new Error(`could not attach to app-server ws ${this.url}: ${lastError?.message ?? "timeout"}`);
+        catch (error) {
+            throw new Error(`could not attach to app-server ws ${this.url}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
         this.ws.on("message", (data) => this.lineCb?.(data.toString()));
         this.ws.on("close", (code) => this.emitClose(code ?? null, null, null));
@@ -227,7 +224,10 @@ export class ExternalWsChannel {
     }
     connect(url) {
         return new Promise((resolve, reject) => {
-            const ws = new WebSocket(url);
+            // The app-server owner has already completed its readiness probe. Use one
+            // bounded attach, then reuse this exact connection as the forwarder
+            // instead of running a second startup retry stage.
+            const ws = new WebSocket(url, { handshakeTimeout: this.readyTimeoutMs });
             const onOpen = () => {
                 ws.off("error", onError);
                 resolve(ws);

package/dist/codex-home.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { copyFileSync, cpSync, existsSync, mkdirSync, renameSync, rmSync, symlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { getRuntimeProfile, resolveRuntimeHome, SAFE_SKILL_NAME, } from "@rynx-ai/core";
+import { assertSkillPathComponent, getRuntimeProfile, resolveRuntimeHome, } from "@rynx-ai/core";
 import { adoptLegacyRuntimeDirectory, legacyRuntimeStateRoot, runtimeSessionDigest, runtimeSessionStateDir, } from "./runtime-state-paths.js";
 /** Inherit the user's LIVE login by symlink (stays in sync). */
 const SYMLINK_FILES = ["auth.json"];
@@ -113,9 +113,7 @@ export function prepareRuntimeHome(sessionId, runtime, realHome = runtime === "c
 export function populateCodexSkills(codexHome, skills) {
     const skillsDir = join(codexHome, "skills");
     for (const skill of skills) {
-        if (!SAFE_SKILL_NAME.test(skill.name)) {
-            throw new Error(`unsafe skill name: ${skill.name}`);
-        }
+        assertSkillPathComponent(skill.name);
     }
     if (skills.length === 0)
         return;

package/dist/host.d.ts

@@ -125,6 +125,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
     private readonly clock;
     private readonly backendIdleTtlMs;
     private readonly forwarderClientFactory;
+    private readonly observerReconnectTimeoutMs;
     private readonly backends;
     private readonly sessionId;
     private readonly runtimeHomeSessionId;
@@ -133,6 +134,10 @@ export declare class LocalAgentHost implements CodexCapabilities {
     private readonly runtimeHomes;
     private readonly liveSessions;
     private readonly liveClaudeSessions;
+    /** Exact pre-live startup failure, retained after the partial handle has been
+     * cleaned up so Core/plugin callers receive the failed phase, not a generic
+     * `live session unavailable` wrapper. */
+    private readonly liveStartupErrors;
     /** Claude forwarders stopped before their terminal is killed. Runner shutdown
      * finalizes these synchronously afterwards to scrub raw interaction answers. */
     private readonly pendingClaudeFinalizers;
@@ -141,7 +146,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, sessionId, runtimeHomeSessionId, }: {
+    constructor({ config, commandRunner, sessionStore, allowedRoots, appServerClient, now, backendIdleTtlMs, forwarderClientFactory, observerReconnectTimeoutMs, sessionId, runtimeHomeSessionId, }: {
         config: AppConfig;
         commandRunner?: CodexCommandRunner;
         sessionStore?: CodexSessionStore;
@@ -153,6 +158,8 @@ 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;
         /** 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
@@ -191,6 +198,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
         args: string[];
         cwd: string;
         env?: Record<string, string>;
+        skipTraexStartupPrompts?: boolean;
     } | null>;
     /**
      * Bring up (idempotently) a session's persistent codex forwarder and emit its
@@ -217,20 +225,31 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * 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 WITHOUT `excludeTurns` so the response backfills the
-     * first turn's items (replayed, deduped against the live stream). Once resume
-     * succeeds, subsequent turns arrive as live notifications on this connection.
+     * 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.
      */
     private subscribeUntilReady;
-    /** Await a live session's thread binding (bounded). Returns false on timeout /
+    /** 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): Promise<boolean>;
+    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. */
-    waitTerminalReady(localThreadId: string, timeoutMs?: number): Promise<boolean>;
+    waitTerminalReady(localThreadId: string, timeoutMs?: number | null): Promise<boolean>;
     /** Diagnostic from the provider adapter when native discovery/resume failed. */
     liveSessionError(localThreadId: string): string | 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. */
+    failLiveStartup(localThreadId: string, error: Error): boolean;
     /**
      * Inject a user turn into a session's live codex thread — reference implementation's
      * single-writer web send. `turn/steer` when a turn is open (mid-turn
@@ -290,6 +309,8 @@ export declare class LocalAgentHost implements CodexCapabilities {
      *  terminal registry — the host does not hold tmux). Ignored for codex sessions
      *  (they inject via the app-server). Idempotent. */
     attachTerminalInjector(localThreadId: string, injector: TerminalInjector): void;
+    /** Close an active native response when its terminal or runner disappears. */
+    failLiveSession(localThreadId: string, error: Error): boolean;
     /** List the models a runtime exposes (App Server for codex/traex; static for claude). */
     listModels(runtime?: AgentRuntimeId): Promise<ModelListResponse | null>;
     /**