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

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

@@ -1,5 +1,7 @@
 import { codexUserContent } from "../input-resources.js";
-import { mapCodexItem, mapCodexNotification } from "./mapping.js";
+import { codexResumeTerminalStatus, mapCodexItem, mapCodexNotification, } from "./mapping.js";
+const MCP_STARTUP_STATUS_METHOD = "mcpServer/startupStatus/updated";
+const MCP_TERMINAL_STATES = new Set(["ready", "failed", "cancelled"]);
 function threadIdFrom(params) {
     const p = params;
     return p?.threadId ?? p?.thread?.id;
@@ -31,6 +33,32 @@ function indicatesActive(method, params) {
     }
     return false;
 }
+function isThreadIdle(method, params) {
+    if (method !== "thread/status/changed")
+        return false;
+    const status = params?.status;
+    return status === "idle" || (typeof status === "object" && status?.type === "idle");
+}
+function isModelOutput(method, params) {
+    if (method !== "item/started" && method !== "item/completed")
+        return false;
+    const item = params?.item;
+    return Boolean(item?.type && item.type !== "userMessage");
+}
+function isTerminalTurnMethod(method) {
+    return method === "turn/completed" || method === "turn/failed";
+}
+/** Turn-scoped notifications must never be reassigned to whichever newer turn
+ * happens to be current when an app-server frame arrives late. */
+function isTurnScopedMethod(method) {
+    return method.startsWith("turn/") || method.startsWith("item/") ||
+        method === "queue/status" || method === "error";
+}
+/** Recover a missed turn/started only from visible, fully-scoped assistant/plan
+ * deltas. Other deltas require an already matching active turn. */
+function canRecoverMissedTurnFrom(method) {
+    return method === "item/agentMessage/delta" || method === "item/plan/delta";
+}
 export class CodexSessionForwarder {
     client;
     sink;
@@ -41,9 +69,16 @@ export class CodexSessionForwarder {
     currentThreadIdValue = null;
     activeSignaled = false;
     completionTimer = null;
+    /** Turn id retained only for late-item dedup while a terminal response waits
+     * for its bounded output-ordering grace. It is not an active provider turn. */
+    pendingCompletionTurnId = null;
     assistantMessageTimer = null;
     deferredAssistantMessage = null;
     pendingCompletion = null;
+    pendingMcpServers = new Set();
+    failedMcpServers = new Map();
+    mcpStartupTimer = null;
+    lastMcpStatusNote = null;
     /** Completed-item dedup keys already mirrored (live vs resume backfill). Key =
      *  `threadId:turnId:item.id`; anonymous items use a per-(thread,turn) position
      *  counter. Mirrors reference implementation `_completed_item_key` + `synced_item_keys`. */
@@ -63,29 +98,91 @@ export class CodexSessionForwarder {
         this.unsubscribe = this.client.onNotification((method, params) => {
             this.handle(method, params);
         });
+        const startup = this.options.mcpStartup;
+        if (startup?.servers.length) {
+            for (const server of startup.servers)
+                this.pendingMcpServers.add(server);
+            this.mcpStartupTimer = setTimeout(() => this.settleMcpStartup(), startup.settleTimeoutMs);
+            this.mcpStartupTimer.unref?.();
+        }
     }
     stop() {
         this.unsubscribe?.();
         this.unsubscribe = null;
+        this.clearMcpStartupTimer();
         this.flushPendingCompletion();
         this.flushDeferredAssistantMessage();
         if (this.turnOpen) {
             this.turnOpen = false;
+            this.currentTurnIdValue = null;
             this.sink.onTurnEnd();
         }
+        else {
+            this.currentTurnIdValue = null;
+        }
     }
-    /** True while a turn is open — injection uses `turn/steer` then, else `turn/start`. */
+    /** True while the provider owns an active turn, including the short interval
+     * between injection acceptance and observer confirmation. */
     isTurnOpen() {
-        return this.turnOpen;
+        return this.turnOpen || this.currentTurnIdValue !== null;
     }
     /** The current turn's codex id (only meaningful while {@link isTurnOpen}). */
     currentTurnId() {
         return this.currentTurnIdValue;
     }
+    /**
+     * Record a turn accepted by the injection connection before the independent
+     * observer receives `turn/started`. This closes the read-decide-RPC-write race:
+     * another web message arriving in that window must steer this turn, not start
+     * a second one.
+     */
+    noteTurnAccepted(turnId) {
+        if (!turnId)
+            return;
+        if (this.pendingCompletion)
+            this.flushPendingCompletion();
+        this.currentTurnIdValue = turnId;
+        this.emitMcpStartupStatus();
+    }
+    hasPendingMcpStartup() {
+        return this.pendingMcpServers.size > 0;
+    }
+    /** Mark and return the startup servers cancelled by a web Stop. */
+    cancelMcpStartup() {
+        const pending = [...this.pendingMcpServers].sort();
+        if (pending.length === 0)
+            return pending;
+        this.pendingMcpServers.clear();
+        this.clearMcpStartupTimer();
+        if (this.isTurnOpen()) {
+            this.emitMcpStatus(`MCP startup cancelled: ${pending.join(", ")}`);
+        }
+        return pending;
+    }
+    /** Diagnostic suffix for an injection failure during Provider startup. */
+    mcpStartupDetail() {
+        const pending = [...this.pendingMcpServers].sort();
+        if (pending.length)
+            return `MCP startup still waiting on ${pending.join(", ")}`;
+        const failed = [...this.failedMcpServers.entries()]
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([name, error]) => error ? `${name}: ${error}` : name);
+        return failed.length ? `MCP startup failed for ${failed.join(", ")}` : null;
+    }
     /** The bound codex thread id captured from `thread/started` (null until then). */
     threadId() {
         return this.currentThreadIdValue;
     }
+    /** Seed an already-persisted/resumed thread binding. The bridge retains this
+     * state even when app-server does not rebroadcast `thread/started`, so
+     * terminal-boundary recovery must know it too. */
+    noteThreadBound(threadId) {
+        if (!threadId || this.currentThreadIdValue === threadId)
+            return;
+        if (this.currentThreadIdValue !== null || this.turnOpen)
+            return;
+        this.currentThreadIdValue = threadId;
+    }
     /**
      * Replay the backlog turns from a `thread/resume` response as if they were live
      * `item/completed` notifications — the fresh-thread first-turn backfill. Each
@@ -101,16 +198,73 @@ export class CodexSessionForwarder {
             this.ensureTurn();
             for (const item of turn.items ?? [])
                 this.processCompletedItem(item);
-            if (turn.status === "inProgress")
+            if (codexResumeTerminalStatus(turn) === undefined)
                 continue;
             const mapped = mapCodexNotification("turn/completed", { turn });
             this.turnOpen = false;
+            this.currentTurnIdValue = null;
             if (mapped.fatalError)
                 this.sink.onTurnError(mapped.fatalError);
             else
                 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())
+            return false;
+        this.ensureTurn();
+        this.settle({ kind: "error", error });
+        return true;
+    }
     handle(method, params) {
         if (method === "thread/started" || method === "thread.started") {
             const tid = threadIdFrom(params);
@@ -138,6 +292,13 @@ export class CodexSessionForwarder {
             notificationThreadId &&
             notificationThreadId !== this.currentThreadIdValue)
             return;
+        if (method === MCP_STARTUP_STATUS_METHOD) {
+            this.handleMcpStartupStatus(params);
+            return;
+        }
+        if (isThreadIdle(method, params) || isModelOutput(method, params)) {
+            this.settleMcpStartup();
+        }
         // Release a parked resume as soon as the thread shows activity (rollout now
         // exists). Fire once.
         if (!this.activeSignaled && indicatesActive(method, params)) {
@@ -148,17 +309,63 @@ export class CodexSessionForwarder {
         // behavior unchanged unless the Traex host explicitly opts in.
         if (method === "queue/status" && !this.options.surfaceQueueStatus)
             return;
+        if (method === "queue/status" && this.currentTurnIdValue === null)
+            return;
         const carriedTurnId = turnIdFrom(params);
         if (method === "turn/started") {
-            this.flushPendingCompletion();
-            this.flushDeferredAssistantMessage();
-            if (carriedTurnId)
+            this.beginTurn(carriedTurnId);
+            this.sink.onTurnObserved?.(carriedTurnId);
+            return;
+        }
+        if (isTerminalTurnMethod(method)) {
+            if (!this.terminalBoundaryMatchesActiveTurn(carriedTurnId, notificationThreadId)) {
+                return;
+            }
+            const hadActiveTurn = this.currentTurnIdValue !== null;
+            const hadOpenResponse = this.turnOpen;
+            const mapped = mapCodexNotification(method, params);
+            if (!hadActiveTurn && !hadOpenResponse) {
+                const turn = params?.turn;
+                const recoveredStatus = mapped.fatalError ||
+                    method === "turn/failed" ||
+                    codexResumeTerminalStatus(turn) === "failed"
+                    ? "failed"
+                    : "idle";
+                this.sink.onRecoveredTurnStatus?.(recoveredStatus, carriedTurnId, mapped.fatalError);
+                return;
+            }
+            if (carriedTurnId && this.currentTurnIdValue === null) {
                 this.currentTurnIdValue = carriedTurnId;
+            }
             this.ensureTurn();
+            this.pendingCompletionTurnId = carriedTurnId ?? this.currentTurnIdValue;
+            // The provider lifecycle closes immediately. A configured grace keeps
+            // only the canonical response open long enough to absorb late items.
+            this.currentTurnIdValue = null;
+            for (const event of mapped.events.filter((event) => event.type !== "runtime_debug")) {
+                this.sink.onEvent(event);
+            }
+            this.scheduleCompletion(mapped.fatalError
+                ? { kind: "error", error: mapped.fatalError }
+                : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
+            return;
+        }
+        // A late event from an older turn must not replace the app-server's active
+        // turn id. That was the source of stale completions closing a newer turn.
+        if (carriedTurnId &&
+            this.currentTurnIdValue &&
+            carriedTurnId !== this.currentTurnIdValue &&
+            isTurnScopedMethod(method)) {
             return;
         }
-        if (carriedTurnId)
-            this.currentTurnIdValue = carriedTurnId;
+        if (carriedTurnId && this.currentTurnIdValue === null) {
+            if (canRecoverMissedTurnFrom(method)) {
+                if (!this.notificationMatchesCurrentThread(notificationThreadId))
+                    return;
+                this.currentTurnIdValue = carriedTurnId;
+                this.ensureTurn();
+            }
+        }
         // Completed items (user echo, assistant, tool, reasoning) go through the
         // deduped path so a resume backfill and the live stream never double them.
         if (method === "item/completed") {
@@ -238,11 +445,80 @@ export class CodexSessionForwarder {
     settle(completion) {
         this.flushDeferredAssistantMessage();
         this.turnOpen = false;
+        this.currentTurnIdValue = null;
+        this.pendingCompletionTurnId = null;
         if (completion.kind === "error")
             this.sink.onTurnError(completion.error);
         else
             this.sink.onTurnEnd(completion.usage);
     }
+    handleMcpStartupStatus(params) {
+        const update = params;
+        const name = typeof update?.name === "string" ? update.name : "";
+        const status = typeof update?.status === "string" ? update.status : "";
+        if (!name || (status !== "starting" && !MCP_TERMINAL_STATES.has(status)))
+            return;
+        if (status === "starting") {
+            this.pendingMcpServers.add(name);
+            this.failedMcpServers.delete(name);
+        }
+        else {
+            this.pendingMcpServers.delete(name);
+            if (status === "failed") {
+                this.failedMcpServers.set(name, typeof update?.error === "string" && update.error ? update.error : undefined);
+            }
+            else {
+                this.failedMcpServers.delete(name);
+            }
+            if (this.pendingMcpServers.size === 0)
+                this.clearMcpStartupTimer();
+        }
+        this.emitMcpStartupStatus();
+    }
+    settleMcpStartup() {
+        if (this.pendingMcpServers.size === 0) {
+            this.clearMcpStartupTimer();
+            return;
+        }
+        this.pendingMcpServers.clear();
+        this.clearMcpStartupTimer();
+        this.emitMcpStartupStatus();
+    }
+    clearMcpStartupTimer() {
+        if (this.mcpStartupTimer)
+            clearTimeout(this.mcpStartupTimer);
+        this.mcpStartupTimer = null;
+    }
+    emitMcpStartupStatus() {
+        if (!this.isTurnOpen())
+            return;
+        const pending = [...this.pendingMcpServers].sort();
+        if (pending.length) {
+            this.emitMcpStatus(`Starting MCP servers: ${pending.join(", ")}`);
+            return;
+        }
+        const failed = [...this.failedMcpServers.keys()].sort();
+        if (failed.length) {
+            this.emitMcpStatus(`MCP startup failed: ${failed.join(", ")}`);
+            return;
+        }
+        if (this.lastMcpStatusNote !== null) {
+            this.lastMcpStatusNote = null;
+            if (this.sink.onStatus)
+                this.sink.onStatus(undefined);
+            else
+                this.sink.onEvent({ type: "status" });
+        }
+    }
+    emitMcpStatus(note) {
+        if (this.lastMcpStatusNote === note)
+            return;
+        this.lastMcpStatusNote = note;
+        if (this.sink.onStatus)
+            this.sink.onStatus(note, "startup");
+        else
+            this.sink.onEvent({ type: "status", statusKind: "startup", note });
+    }
     /** Map + emit one completed codex item, deduped by a TOTAL key and routing the
      *  user echo to {@link CodexForwarderSink.onUserMessage}. Shared by live + backfill. */
     processCompletedItem(item) {
@@ -305,14 +581,15 @@ export class CodexSessionForwarder {
      *  {@link advanceAnonCounter}). Mirrors reference implementation `_completed_item_key`. */
     completedItemKey(item) {
         const threadId = this.currentThreadIdValue ?? "thread";
-        const turnId = this.currentTurnIdValue ?? "turn";
+        const turnId = this.currentTurnIdValue ?? this.pendingCompletionTurnId ?? "turn";
         if (item.id)
             return { key: `${threadId}:${turnId}:${item.id}`, isAnon: false };
         const n = this.anonCounters.get(`${threadId}:${turnId}`) ?? 0;
         return { key: `${threadId}:${turnId}:anon:${n}`, isAnon: true };
     }
     advanceAnonCounter() {
-        const k = `${this.currentThreadIdValue ?? "thread"}:${this.currentTurnIdValue ?? "turn"}`;
+        const turnId = this.currentTurnIdValue ?? this.pendingCompletionTurnId ?? "turn";
+        const k = `${this.currentThreadIdValue ?? "thread"}:${turnId}`;
         this.anonCounters.set(k, (this.anonCounters.get(k) ?? 0) + 1);
     }
     ensureTurn() {
@@ -321,4 +598,45 @@ export class CodexSessionForwarder {
             this.sink.onTurnStart(this.currentTurnIdValue ?? undefined);
         }
     }
+    /** Start (or confirm) the app-server's authoritative active turn. A newer
+     * start supersedes an older response whose terminal edge arrived late; a
+     * pending Traex completion is flushed first so its final item grace remains
+     * intact. */
+    beginTurn(turnId) {
+        if (this.pendingCompletion)
+            this.flushPendingCompletion();
+        const nextTurnId = turnId ?? null;
+        const changesIdentifiedTurn = this.turnOpen &&
+            this.currentTurnIdValue !== null &&
+            nextTurnId !== null &&
+            this.currentTurnIdValue !== nextTurnId;
+        if (changesIdentifiedTurn) {
+            this.flushPendingCompletion();
+            this.flushDeferredAssistantMessage();
+            if (this.turnOpen) {
+                this.turnOpen = false;
+                this.sink.onTurnEnd(undefined, "superseded");
+            }
+        }
+        this.currentTurnIdValue = nextTurnId;
+        this.ensureTurn();
+    }
+    /** Active-turn clearing contract:
+     *
+     * - an identified active turn is closed only by the same id;
+     * - an id-less boundary cannot close an identified active turn;
+     * - with no observed active turn, an identified boundary may recover a
+     *   missed start only when it carries the currently-bound thread id. */
+    terminalBoundaryMatchesActiveTurn(terminalTurnId, notificationThreadId) {
+        if (this.currentTurnIdValue !== null) {
+            return terminalTurnId === this.currentTurnIdValue;
+        }
+        if (terminalTurnId === undefined)
+            return true;
+        return this.notificationMatchesCurrentThread(notificationThreadId);
+    }
+    notificationMatchesCurrentThread(notificationThreadId) {
+        return this.currentThreadIdValue !== null &&
+            notificationThreadId === this.currentThreadIdValue;
+    }
 }

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

@@ -13,6 +13,8 @@ export interface CodexMapResult {
     turnCompleted?: boolean;
     fatalError?: Error;
 }
+export declare function codexTurnStatus(turn: unknown): string | undefined;
+export declare function codexResumeTerminalStatus(turn: unknown): "idle" | "failed" | undefined;
 /** Map one thread item (`item/started` | `item/completed`) to events. */
 export declare function mapCodexItem(method: string, item: ThreadItem): CodexMapResult;
 /** Map one codex app-server notification to events (+ turn/usage/error signals). */

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

@@ -1,12 +1,98 @@
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+const CODEX_AUTH_ERROR_FRAGMENTS = [
+    "401",
+    "403",
+    "unauthorized",
+    "authentication",
+    "not logged in",
+    "not authenticated",
+    "log in",
+    "login",
+    "sign in",
+    "re-authenticate",
+    "reauthenticate",
+    "credentials",
+    "access token",
+    "token expired",
+    "expired token",
+    "session expired",
+    "api key",
+];
+const CODEX_REAUTH_HINT = "Codex needs you to re-authenticate. Run `codex login` and retry.";
+function codexErrorMessage(error) {
+    for (const key of ["message", "error", "text", "detail"]) {
+        const value = error[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return "Codex turn ended with an unspecified error.";
+}
+function codexErrorIsAuth(error, message) {
+    const info = error.codexErrorInfo;
+    let variant;
+    let httpStatusCode;
+    if (typeof info === "string") {
+        variant = info;
+    }
+    else if (isRecord(info)) {
+        variant = info.type ?? info.kind ?? info.variant;
+        httpStatusCode = info.httpStatusCode;
+    }
+    if (typeof variant === "string" && variant.toLowerCase() === "unauthorized")
+        return true;
+    if (httpStatusCode === 401 || httpStatusCode === 403)
+        return true;
+    const lowered = message.toLowerCase();
+    return CODEX_AUTH_ERROR_FRAGMENTS.some((fragment) => lowered.includes(fragment));
+}
 function turnError(error, fallback) {
-    if (typeof error === "string" && error.trim())
-        return new Error(error);
-    if (error && typeof error === "object" && "message" in error) {
-        const message = error.message;
-        if (typeof message === "string" && message.trim())
-            return new Error(message);
+    if (!error)
+        return new Error(fallback);
+    const message = codexErrorMessage(error);
+    return new Error(codexErrorIsAuth(error, message)
+        ? `${message}\n\n${CODEX_REAUTH_HINT}`
+        : message);
+}
+export function codexTurnStatus(turn) {
+    if (!isRecord(turn))
+        return undefined;
+    const status = turn.status;
+    if (typeof status === "string")
+        return status;
+    if (!isRecord(status))
+        return undefined;
+    const value = status.type ?? status.status;
+    return typeof value === "string" ? value : undefined;
+}
+export function codexResumeTerminalStatus(turn) {
+    if (terminalTurnError(turn, "turn/completed"))
+        return "failed";
+    const status = codexTurnStatus(turn);
+    if (status === "completed" || status === "interrupted" ||
+        status === "cancelled" || status === "canceled") {
+        return "idle";
     }
-    return new Error(fallback);
+    if (status === "failed" || status === "errored")
+        return "failed";
+    return undefined;
+}
+function terminalTurnError(turn, method) {
+    if (!isRecord(turn)) {
+        return method === "turn/failed" ? new Error("Codex turn failed") : undefined;
+    }
+    let error = turn.error;
+    if (!isRecord(error) && Array.isArray(turn.items)) {
+        error = turn.items.find((item) => isRecord(item) && item.type === "error");
+    }
+    if (isRecord(error))
+        return turnError(error, "Codex turn failed");
+    const status = codexTurnStatus(turn);
+    if (method === "turn/failed" || status === "failed" || status === "errored") {
+        return turnError(undefined, "Codex turn failed");
+    }
+    return undefined;
 }
 function webSearchInput(item) {
     const action = item.action;
@@ -151,23 +237,11 @@ export function mapCodexNotification(method, params) {
             return { events };
         case "turn/started":
             return { events };
-        case "turn/completed": {
+        case "turn/completed":
+        case "turn/failed": {
             const turnPayload = typed.params?.turn;
-            if (turnPayload?.status === "failed") {
-                return {
-                    events,
-                    fatalError: turnError(turnPayload.error, "Codex turn failed"),
-                    turnCompleted: true,
-                };
-            }
-            if (turnPayload?.status === "interrupted") {
-                return {
-                    events,
-                    fatalError: turnError(turnPayload.error, "Codex turn was interrupted"),
-                    turnCompleted: true,
-                };
-            }
-            return { events, turnCompleted: true };
+            const fatalError = terminalTurnError(turnPayload, typed.method);
+            return { events, ...(fatalError ? { fatalError } : {}), turnCompleted: true };
         }
         case "turn/plan/updated": {
             const planParams = typed.params;

package/dist/codex-app-server/mcp-startup.d.ts

@@ -0,0 +1,13 @@
+import type { CodexLineageRuntime } from "../codex-home.js";
+export interface McpStartupPlan {
+    servers: string[];
+    settleTimeoutMs: number;
+}
+/**
+ * Read the MCP table fields needed for startup tracking. Provider config stays
+ * authoritative: malformed TOML disables the synthesized status rather than
+ * preventing the native CLI from reporting its own startup error.
+ */
+export declare function parseMcpStartupToml(input: string): McpStartupPlan | null;
+/** Enabled Provider-configured MCP servers and their synthesized settle window. */
+export declare function readMcpStartupPlan(runtimeHome: string, runtime: CodexLineageRuntime): McpStartupPlan | null;

package/dist/codex-app-server/mcp-startup.js

@@ -0,0 +1,63 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "smol-toml";
+const DEFAULT_SERVER_TIMEOUT_MS = 10_000;
+const SETTLE_GRACE_MS = 15_000;
+const MAX_SETTLE_TIMEOUT_MS = 240_000;
+function configNames(runtime) {
+    return runtime === "codex"
+        ? ["config.toml"]
+        : ["traecli.toml"];
+}
+function isTomlTable(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Read the MCP table fields needed for startup tracking. Provider config stays
+ * authoritative: malformed TOML disables the synthesized status rather than
+ * preventing the native CLI from reporting its own startup error.
+ */
+export function parseMcpStartupToml(input) {
+    let config;
+    try {
+        config = parse(input);
+    }
+    catch {
+        return null;
+    }
+    const servers = config.mcp_servers;
+    if (!isTomlTable(servers))
+        return null;
+    const enabled = Object.entries(servers)
+        .filter(([name, server]) => Boolean(name) && isTomlTable(server) && server.enabled !== false)
+        .sort(([left], [right]) => left.localeCompare(right));
+    if (enabled.length === 0)
+        return null;
+    const slowest = Math.max(DEFAULT_SERVER_TIMEOUT_MS, ...enabled.map(([, server]) => {
+        if (!isTomlTable(server))
+            return DEFAULT_SERVER_TIMEOUT_MS;
+        const seconds = server.startup_timeout_sec;
+        return typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0
+            ? seconds * 1_000
+            : DEFAULT_SERVER_TIMEOUT_MS;
+    }));
+    return {
+        servers: enabled.map(([name]) => name),
+        settleTimeoutMs: Math.min(slowest + SETTLE_GRACE_MS, MAX_SETTLE_TIMEOUT_MS),
+    };
+}
+/** Enabled Provider-configured MCP servers and their synthesized settle window. */
+export function readMcpStartupPlan(runtimeHome, runtime) {
+    for (const name of configNames(runtime)) {
+        try {
+            const plan = parseMcpStartupToml(readFileSync(join(runtimeHome, name), "utf8"));
+            if (plan)
+                return plan;
+        }
+        catch {
+            // Missing/unreadable config: the Provider still owns startup; Rynx simply
+            // cannot synthesize per-server progress for this launch.
+        }
+    }
+    return null;
+}