dev-sessions 0.2.2 → 0.2.3

package/dist/backends/codex-appserver.d.ts

@@ -17,6 +17,7 @@ export interface CodexTurnWaitResult {
     elapsedMs: number;
     status: TurnCompletionStatus;
     errorMessage?: string;
+    assistantText?: string;
 }
 export interface CodexSendMessageOptions {
     workspacePath: string;
@@ -26,6 +27,8 @@ export interface CodexSendResult {
     threadId: string;
     appServerPid: number;
     appServerPort: number;
+    turnId?: string;
+    assistantText?: string;
 }
 export interface CodexRpcClient {
     readonly currentTurnText: string;
@@ -33,7 +36,7 @@ export interface CodexRpcClient {
     readonly lastTurnError?: string;
     connectAndInitialize(): Promise<void>;
     request(method: string, params?: unknown): Promise<unknown>;
-    waitForTurnCompletion(timeoutMs: number): Promise<CodexTurnWaitResult>;
+    waitForTurnCompletion(timeoutMs: number, expectedThreadId?: string, expectedTurnId?: string): Promise<CodexTurnWaitResult>;
     close(): Promise<void>;
 }
 export interface CodexAppServerDaemonManager {
@@ -47,6 +50,40 @@ export interface CodexAppServerBackendDependencies {
     clientFactory?: (url: string) => CodexRpcClient;
     daemonManager?: CodexAppServerDaemonManager;
 }
+export declare class CodexWebSocketRpcClient implements CodexRpcClient {
+    private readonly url;
+    private ws?;
+    private connectPromise?;
+    private nextRequestId;
+    private readonly pendingRequests;
+    private waiters;
+    private currentText;
+    private turnStatus?;
+    private turnError?;
+    private turnThreadId?;
+    private turnId?;
+    private closed;
+    private closing;
+    constructor(url: string);
+    get currentTurnText(): string;
+    get lastTurnStatus(): TurnCompletionStatus | undefined;
+    get lastTurnError(): string | undefined;
+    connectAndInitialize(): Promise<void>;
+    request(method: string, params?: unknown): Promise<unknown>;
+    waitForTurnCompletion(timeoutMs: number, expectedThreadId?: string, expectedTurnId?: string): Promise<CodexTurnWaitResult>;
+    close(): Promise<void>;
+    private connect;
+    private attachSocketHandlers;
+    private handleMessageFrame;
+    private handleMaybeJsonLine;
+    private handleRpcMessage;
+    private handleRpcResponse;
+    private handleNotification;
+    private hasMatchingWaiterForTurn;
+    private resolveWaiters;
+    private failConnection;
+    private notify;
+}
 export declare class CodexAppServerBackend {
     private readonly sessionState;
     private readonly daemonManager;
@@ -55,9 +92,13 @@ export declare class CodexAppServerBackend {
     createSession(championId: string, workspacePath: string, model?: string): Promise<CodexSessionCreateResult>;
     sendMessage(championId: string, threadId: string, message: string, options?: CodexSendMessageOptions): Promise<CodexSendResult>;
     getThreadRuntimeStatus(threadId: string): Promise<'active' | 'idle' | 'notLoaded' | 'systemError' | 'unknown'>;
-    waitForThread(championId: string, threadId: string, timeoutMs?: number): Promise<CodexTurnWaitResult>;
+    waitForThread(championId: string, threadId: string, timeoutMs?: number, expectedTurnId?: string): Promise<CodexTurnWaitResult>;
     waitForTurn(championId: string, timeoutMs?: number): Promise<CodexTurnWaitResult>;
     getLastAssistantMessages(championId: string, threadId: string, count: number): Promise<string[]>;
+    getThreadTurns(threadId: string): Promise<Array<{
+        role: 'human' | 'assistant';
+        text: string;
+    }>>;
     getSessionStatus(championId: string): AgentTurnStatus;
     killSession(championId: string, pid?: number, threadId?: string, port?: number): Promise<void>;
     stopAppServer(): Promise<void>;
@@ -69,5 +110,6 @@ export declare class CodexAppServerBackend {
     private shouldResetDaemonAfterConnectionFailure;
     private isResumeNotFoundError;
     private isThreadReadUnmaterializedError;
+    private isThreadReadNotFoundError;
 }
 export {};

package/dist/backends/codex-appserver.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodexAppServerBackend = void 0;
+exports.CodexAppServerBackend = exports.CodexWebSocketRpcClient = void 0;
 const node_child_process_1 = require("node:child_process");
 const promises_1 = require("node:fs/promises");
 const node_net_1 = require("node:net");
@@ -19,6 +19,7 @@ const CLOSE_TIMEOUT_MS = 500;
 const STATE_FILE_VERSION = 1;
 const RESUME_NOT_FOUND_PATTERN = /no rollout found|thread not found/i;
 const THREAD_READ_UNMATERIALIZED_PATTERN = /includeTurns is unavailable before first user message/i;
+const THREAD_READ_NOT_FOUND_PATTERN = /thread not loaded|thread not found|no rollout found|unknown thread/i;
 const APP_SERVER_URL_PATTERN = /ws:\/\/127\.0\.0\.1:(\d+)/i;
 function defaultSpawnCodexDaemon(args, options) {
     return (0, node_child_process_1.spawn)('codex', args, options);
@@ -231,12 +232,13 @@ class CodexWebSocketRpcClient {
     ws;
     connectPromise;
     nextRequestId = 1;
-    stdoutBuffer = '';
     pendingRequests = new Map();
     waiters = [];
     currentText = '';
     turnStatus;
     turnError;
+    turnThreadId;
+    turnId;
     closed = false;
     closing = false;
     constructor(url) {
@@ -303,8 +305,11 @@ class CodexWebSocketRpcClient {
             }
         });
     }
-    async waitForTurnCompletion(timeoutMs) {
-        if (this.turnStatus) {
+    async waitForTurnCompletion(timeoutMs, expectedThreadId, expectedTurnId) {
+        const cachedMatchesThread = !expectedThreadId || (typeof this.turnThreadId === 'string' && this.turnThreadId === expectedThreadId);
+        const cachedMatchesTurn = !expectedTurnId || (typeof this.turnId === 'string' && this.turnId === expectedTurnId);
+        const cachedMatchesExpected = cachedMatchesThread && cachedMatchesTurn;
+        if (this.turnStatus && cachedMatchesExpected) {
             return {
                 completed: true,
                 timedOut: false,
@@ -331,6 +336,8 @@ class CodexWebSocketRpcClient {
             this.waiters.push({
                 startTime,
                 timeoutHandle,
+                expectedThreadId,
+                expectedTurnId,
                 resolve
             });
         });
@@ -424,21 +431,7 @@ class CodexWebSocketRpcClient {
         });
     }
     handleMessageFrame(frame) {
-        if (!frame.includes('\n') && this.stdoutBuffer.length === 0) {
-            this.handleMaybeJsonLine(frame);
-            return;
-        }
-        this.stdoutBuffer += frame;
-        const lines = this.stdoutBuffer.split('\n');
-        this.stdoutBuffer = lines.pop() ?? '';
-        for (const line of lines) {
-            this.handleMaybeJsonLine(line);
-        }
-        if (this.stdoutBuffer.trim().length > 0) {
-            const pendingBuffer = this.stdoutBuffer;
-            this.stdoutBuffer = '';
-            this.handleMaybeJsonLine(pendingBuffer);
-        }
+        this.handleMaybeJsonLine(frame);
     }
     handleMaybeJsonLine(rawLine) {
         const trimmed = rawLine.trim();
@@ -450,10 +443,6 @@ class CodexWebSocketRpcClient {
             payload = JSON.parse(trimmed);
         }
         catch {
-            // If parsing fails, keep buffering behavior for newline-delimited mode.
-            if (!rawLine.includes('\n')) {
-                this.stdoutBuffer = rawLine;
-            }
             return;
         }
         this.handleRpcMessage(payload);
@@ -492,6 +481,15 @@ class CodexWebSocketRpcClient {
             }
             return;
         }
+        if (notification.method === 'turn/started') {
+            const turn = notification.params?.turn;
+            this.turnStatus = undefined;
+            this.turnError = undefined;
+            this.turnThreadId = extractNotificationThreadId(notification.params);
+            this.turnId = extractTurnId(turn);
+            this.currentText = '';
+            return;
+        }
         if (notification.method !== 'turn/completed') {
             return;
         }
@@ -500,20 +498,42 @@ class CodexWebSocketRpcClient {
         if (!status) {
             return;
         }
+        const notificationThreadId = extractNotificationThreadId(notification.params);
+        const notificationTurnId = extractTurnId(turn);
+        if (this.waiters.length > 0 && !this.hasMatchingWaiterForTurn(notificationThreadId, notificationTurnId)) {
+            return;
+        }
         this.turnStatus = status;
         this.turnError = extractTurnError(turn);
+        this.turnThreadId = notificationThreadId;
+        this.turnId = notificationTurnId;
         this.resolveWaiters({
             completed: true,
             timedOut: false,
             elapsedMs: 0,
             status,
-            errorMessage: this.turnError
+            errorMessage: this.turnError,
+            assistantText: this.currentText.length > 0 ? this.currentText : undefined
+        }, notificationThreadId, notificationTurnId);
+    }
+    hasMatchingWaiterForTurn(threadId, turnId) {
+        return this.waiters.some((waiter) => {
+            const threadMatches = !waiter.expectedThreadId || threadId === waiter.expectedThreadId;
+            const turnMatches = !waiter.expectedTurnId || turnId === waiter.expectedTurnId;
+            return threadMatches && turnMatches;
         });
     }
-    resolveWaiters(baseResult) {
-        const waiters = this.waiters.splice(0, this.waiters.length);
+    resolveWaiters(baseResult, completedThreadId, completedTurnId, forceAll = false) {
+        const waiters = this.waiters;
+        this.waiters = [];
         const now = Date.now();
         for (const waiter of waiters) {
+            const threadMatches = !waiter.expectedThreadId || completedThreadId === waiter.expectedThreadId;
+            const turnMatches = !waiter.expectedTurnId || completedTurnId === waiter.expectedTurnId;
+            if (!forceAll && !(threadMatches && turnMatches)) {
+                this.waiters.push(waiter);
+                continue;
+            }
             clearTimeout(waiter.timeoutHandle);
             waiter.resolve({
                 ...baseResult,
@@ -540,7 +560,7 @@ class CodexWebSocketRpcClient {
             elapsedMs: 0,
             status: this.turnStatus,
             errorMessage: this.turnError
-        });
+        }, undefined, undefined, true);
     }
     notify(method, params) {
         const ws = this.ws;
@@ -550,6 +570,7 @@ class CodexWebSocketRpcClient {
         ws.send(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`);
     }
 }
+exports.CodexWebSocketRpcClient = CodexWebSocketRpcClient;
 function extractThreadId(result) {
     const threadId = result?.thread?.id;
     if (typeof threadId !== 'string' || threadId.trim().length === 0) {
@@ -557,35 +578,25 @@ function extractThreadId(result) {
     }
     return threadId;
 }
-// ThreadStatus uses #[serde(tag = "type", rename_all = "camelCase")]:
-//   { "type": "idle" } | { "type": "notLoaded" } | { "type": "systemError" } | { "type": "active", "activeFlags": [...] }
-// Older Codex versions omit the status field entirely — treat absent status as idle.
+// Codex 0.104.0 shipped before ThreadStatus was added to the protocol and omits
+// thread.status entirely for idle threads, so missing status must be treated as
+// idle. Starting with the post-0.104.0 protocol (expected in 0.105.0 stable),
+// ThreadStatus is a tagged serde enum and will appear as objects such as
+// {"type":"idle"} / {"type":"active","activeFlags":[...]}. When 0.105.0 is
+// supported here, update this parser to handle both shapes.
 function extractThreadRuntimeStatus(result) {
     const thread = result?.thread;
     if (!thread || !('status' in thread)) {
-        // Old Codex version without Thread.status field — assume idle
         return 'idle';
     }
     const status = thread.status;
-    const type = status?.type;
-    if (type === 'active' || type === 'idle' || type === 'systemError' || type === 'notLoaded') {
-        return type;
-    }
-    return 'unknown';
-}
-function extractThreadListPage(result) {
-    if (!result || typeof result !== 'object') {
-        throw new Error('thread/list returned an invalid response');
+    if (status === 'idle' || status === 'notLoaded' || status === 'systemError') {
+        return status;
     }
-    const record = result;
-    if (!Array.isArray(record.data)) {
-        throw new Error('thread/list response is missing result.data');
+    if (status !== null && typeof status === 'object' && 'active' in status) {
+        return 'active';
     }
-    const threadIds = record.data
-        .map((item) => (item && typeof item === 'object' ? item.id : undefined))
-        .filter((id) => typeof id === 'string' && id.trim().length > 0);
-    const nextCursor = typeof record.nextCursor === 'string' && record.nextCursor.length > 0 ? record.nextCursor : undefined;
-    return { threadIds, nextCursor };
+    return 'unknown';
 }
 function extractThreadReadAssistantMessages(result) {
     if (!result || typeof result !== 'object') {
@@ -617,32 +628,92 @@ function extractThreadReadAssistantMessages(result) {
     }
     return messages;
 }
+function extractUserMessageText(item) {
+    if (Array.isArray(item.content)) {
+        const parts = [];
+        for (const part of item.content) {
+            if (typeof part === 'string') {
+                parts.push(part);
+            }
+            else if (part && typeof part === 'object') {
+                const p = part;
+                if (typeof p.text === 'string' && p.text.length > 0) {
+                    parts.push(p.text);
+                }
+            }
+        }
+        if (parts.length > 0) {
+            return parts.join('');
+        }
+    }
+    if (typeof item.text === 'string') {
+        return item.text;
+    }
+    return '';
+}
+function extractThreadTurns(result) {
+    if (!result || typeof result !== 'object') {
+        throw new Error('thread/read returned an invalid response');
+    }
+    const thread = result.thread;
+    if (!thread || typeof thread !== 'object') {
+        throw new Error('thread/read response is missing result.thread');
+    }
+    const turns = thread.turns;
+    if (!Array.isArray(turns)) {
+        throw new Error('thread/read response is missing result.thread.turns');
+    }
+    const sessionTurns = [];
+    for (const turn of turns) {
+        if (!turn || typeof turn !== 'object')
+            continue;
+        const items = turn.items;
+        if (!Array.isArray(items))
+            continue;
+        for (const item of items) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const rec = item;
+            if (rec.type === 'userMessage') {
+                const text = extractUserMessageText(rec);
+                if (text.length > 0) {
+                    sessionTurns.push({ role: 'human', text });
+                }
+            }
+            else if (rec.type === 'agentMessage' && typeof rec.text === 'string' && rec.text.length > 0) {
+                sessionTurns.push({ role: 'assistant', text: rec.text });
+            }
+        }
+    }
+    return sessionTurns;
+}
 function extractDeltaText(params) {
     if (!params || typeof params !== 'object') {
         return '';
     }
-    const asRecord = params;
-    const directText = asRecord.text;
-    if (typeof directText === 'string') {
-        return directText;
-    }
-    const delta = asRecord.delta;
-    if (typeof delta === 'string') {
-        return delta;
+    const delta = params.delta;
+    return typeof delta === 'string' ? delta : '';
+}
+function extractNotificationThreadId(params) {
+    if (!params || typeof params !== 'object') {
+        return undefined;
     }
-    if (delta && typeof delta === 'object' && typeof delta.text === 'string') {
-        return delta.text;
+    const rec = params;
+    const threadId = rec.threadId ?? rec.thread_id;
+    return typeof threadId === 'string' && threadId.length > 0 ? threadId : undefined;
+}
+function extractTurnId(turn) {
+    if (!turn || typeof turn !== 'object') {
+        return undefined;
     }
-    const item = asRecord.item;
-    if (item && typeof item === 'object') {
-        const nestedDelta = item.delta;
-        if (nestedDelta &&
-            typeof nestedDelta === 'object' &&
-            typeof nestedDelta.text === 'string') {
-            return nestedDelta.text;
-        }
+    const turnId = turn.id;
+    return typeof turnId === 'string' && turnId.length > 0 ? turnId : undefined;
+}
+function extractStartedTurnId(result) {
+    if (!result || typeof result !== 'object') {
+        return undefined;
     }
-    return '';
+    return extractTurnId(result.turn);
 }
 function extractTurnStatus(turn) {
     if (!turn || typeof turn !== 'object') {
@@ -735,16 +806,30 @@ class CodexAppServerBackend {
                 });
                 tid = extractThreadId(threadResult);
             }
-            await client.request('turn/start', {
+            const turnStartResult = await client.request('turn/start', {
                 threadId: tid,
                 input: [{ type: 'text', text: message }]
             });
-            return tid;
+            const startedTurnId = extractStartedTurnId(turnStartResult);
+            // Best-effort: wait a short time for the turn to complete on this connection.
+            // Captures fast responses (e.g. short answers) without blocking for long tasks.
+            // Only use the result if the exact initiated turn actually completed — not
+            // if it timed out or a different turn completed on the same thread.
+            const FAST_CAPTURE_TIMEOUT_MS = 3_000;
+            const earlyResult = await client.waitForTurnCompletion(FAST_CAPTURE_TIMEOUT_MS, tid, startedTurnId);
+            const completedEarly = !earlyResult.timedOut && earlyResult.status === 'completed';
+            return { tid, turnId: startedTurnId, assistantText: completedEarly ? earlyResult.assistantText : undefined };
         });
+        const state = this.ensureSessionState(championId);
+        if (activeThreadId.assistantText) {
+            state.assistantHistory.push(activeThreadId.assistantText);
+        }
         return {
-            threadId: activeThreadId,
+            threadId: activeThreadId.tid,
             appServerPid: server.pid,
-            appServerPort: server.port
+            appServerPort: server.port,
+            turnId: activeThreadId.turnId,
+            assistantText: activeThreadId.assistantText
         };
     }
     async getThreadRuntimeStatus(threadId) {
@@ -758,34 +843,110 @@ class CodexAppServerBackend {
         });
         return result;
     }
-    async waitForThread(championId, threadId, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    async waitForThread(championId, threadId, timeoutMs = DEFAULT_TIMEOUT_MS, expectedTurnId) {
         const normalizedThreadId = threadId.trim();
         if (normalizedThreadId.length === 0) {
             return { completed: true, timedOut: false, elapsedMs: 0, status: 'completed' };
         }
+        const normalizedExpectedTurnId = expectedTurnId?.trim() ?? '';
         const state = this.ensureSessionState(championId);
         const safeTimeoutMs = Math.max(1, timeoutMs);
-        const { result } = await this.withConnectedClient(async (client) => {
-            const resumeResult = await client.request('thread/resume', { threadId: normalizedThreadId });
-            const runtimeStatus = extractThreadRuntimeStatus(resumeResult);
-            if (runtimeStatus === 'active') {
-                return client.waitForTurnCompletion(safeTimeoutMs);
+        const overallStart = Date.now();
+        let lastAssistantText;
+        let sawActiveTurn = false;
+        let result;
+        if (normalizedExpectedTurnId.length > 0) {
+            // Codex 0.104.0 can report thread/resume=idle and thread/read turn.status=completed
+            // while the initiated turn is still running tools. When we know the exact turn ID
+            // from turn/start, block on that turn's completion notification instead of trusting
+            // thread runtime status.
+            const waitCycle = await this.withConnectedClient(async (client) => {
+                // Resume first so this connection is subscribed to notifications for the thread.
+                await client.request('thread/resume', { threadId: normalizedThreadId });
+                return client.waitForTurnCompletion(safeTimeoutMs, normalizedThreadId, normalizedExpectedTurnId);
+            });
+            if (waitCycle.result.assistantText) {
+                lastAssistantText = waitCycle.result.assistantText;
             }
-            if (runtimeStatus === 'systemError' || runtimeStatus === 'unknown') {
+            result = {
+                ...waitCycle.result,
+                elapsedMs: waitCycle.result.timedOut
+                    ? Math.max(waitCycle.result.elapsedMs, Date.now() - overallStart)
+                    : waitCycle.result.elapsedMs,
+                assistantText: waitCycle.result.assistantText ?? lastAssistantText
+            };
+        }
+        while (!result) {
+            const elapsedMs = Date.now() - overallStart;
+            const remainingMs = safeTimeoutMs - elapsedMs;
+            if (remainingMs <= 0) {
+                result = {
+                    completed: false,
+                    timedOut: true,
+                    elapsedMs: Math.max(1, elapsedMs),
+                    status: 'interrupted',
+                    errorMessage: 'Timed out waiting for Codex turn completion',
+                    assistantText: lastAssistantText
+                };
+                break;
+            }
+            const cycle = await this.withConnectedClient(async (client) => {
+                const resumeResult = await client.request('thread/resume', { threadId: normalizedThreadId });
+                const runtimeStatus = extractThreadRuntimeStatus(resumeResult);
+                if (runtimeStatus === 'active') {
+                    const waitResult = await client.waitForTurnCompletion(remainingMs, normalizedThreadId);
+                    return { kind: 'wait', waitResult };
+                }
+                if (runtimeStatus === 'systemError' || runtimeStatus === 'unknown') {
+                    return {
+                        kind: 'terminal',
+                        waitResult: {
+                            completed: true,
+                            timedOut: false,
+                            elapsedMs: 0,
+                            status: 'failed',
+                            errorMessage: runtimeStatus === 'systemError'
+                                ? 'Codex thread is in systemError state'
+                                : 'Unable to determine Codex thread runtime status'
+                        }
+                    };
+                }
                 return {
-                    completed: true,
-                    timedOut: false,
-                    elapsedMs: 0,
-                    status: 'failed',
-                    errorMessage: runtimeStatus === 'systemError'
-                        ? 'Codex thread is in systemError state'
-                        : 'Unable to determine Codex thread runtime status'
+                    kind: 'idle',
+                    waitResult: { completed: true, timedOut: false, elapsedMs: 0, status: 'completed' }
                 };
+            });
+            if (cycle.result.kind === 'wait') {
+                sawActiveTurn = true;
+                if (cycle.result.waitResult.assistantText) {
+                    lastAssistantText = cycle.result.waitResult.assistantText;
+                }
+                if (cycle.result.waitResult.timedOut ||
+                    cycle.result.waitResult.status === 'failed' ||
+                    cycle.result.waitResult.status === 'interrupted') {
+                    result = {
+                        ...cycle.result.waitResult,
+                        elapsedMs: Math.max(cycle.result.waitResult.elapsedMs, Date.now() - overallStart),
+                        assistantText: cycle.result.waitResult.assistantText ?? lastAssistantText
+                    };
+                    break;
+                }
+                // One turn completed, but the logical task may continue in a subsequent turn.
+                // Reconnect and re-check thread runtime state until the thread is quiescent.
+                continue;
             }
-            return { completed: true, timedOut: false, elapsedMs: 0, status: 'completed' };
-        });
+            const totalElapsedMs = Date.now() - overallStart;
+            result = {
+                ...cycle.result.waitResult,
+                elapsedMs: sawActiveTurn ? Math.max(1, totalElapsedMs) : 0,
+                assistantText: lastAssistantText
+            };
+        }
         state.lastTurnStatus = result.status;
         state.lastTurnError = result.errorMessage;
+        if (result.assistantText) {
+            state.assistantHistory.push(result.assistantText);
+        }
         return result;
     }
     async waitForTurn(championId, timeoutMs = DEFAULT_TIMEOUT_MS) {
@@ -840,6 +1001,28 @@ class CodexAppServerBackend {
             throw error;
         }
     }
+    async getThreadTurns(threadId) {
+        const normalizedThreadId = threadId.trim();
+        if (normalizedThreadId.length === 0) {
+            return [];
+        }
+        try {
+            const { result } = await this.withConnectedClient(async (client) => {
+                const readResult = await client.request('thread/read', {
+                    threadId: normalizedThreadId,
+                    includeTurns: true
+                });
+                return extractThreadTurns(readResult);
+            });
+            return result;
+        }
+        catch (error) {
+            if (this.isThreadReadUnmaterializedError(error)) {
+                return [];
+            }
+            throw error;
+        }
+    }
     getSessionStatus(championId) {
         const state = this.ensureSessionState(championId);
         if (state.lastTurnStatus === 'failed') {
@@ -888,33 +1071,26 @@ class CodexAppServerBackend {
         if (!threadId || threadId.trim().length === 0) {
             return this.daemonManager.isServerRunning(pid, port);
         }
-        try {
-            const { result } = await this.withConnectedClient(async (client) => {
-                return this.threadExistsOnServer(client, threadId.trim());
-            });
-            return result;
-        }
-        catch {
-            return false;
-        }
+        // Let transport errors propagate — callers that need tri-state liveness
+        // should catch and treat as 'unknown' rather than 'dead'.
+        const { result } = await this.withConnectedClient(async (client) => {
+            return this.threadExistsOnServer(client, threadId.trim());
+        });
+        return result;
     }
     async threadExistsOnServer(client, threadId) {
-        let cursor;
-        const pageLimit = 100;
-        while (true) {
-            const listResult = await client.request('thread/list', {
-                cursor,
-                limit: pageLimit,
-                modelProviders: []
+        try {
+            await client.request('thread/read', {
+                threadId,
+                includeTurns: false
             });
-            const page = extractThreadListPage(listResult);
-            if (page.threadIds.includes(threadId)) {
-                return true;
-            }
-            if (!page.nextCursor) {
+            return true;
+        }
+        catch (error) {
+            if (this.isThreadReadNotFoundError(error)) {
                 return false;
             }
-            cursor = page.nextCursor;
+            throw error;
         }
     }
     ensureSessionState(championId) {
@@ -979,6 +1155,12 @@ class CodexAppServerBackend {
         }
         return THREAD_READ_UNMATERIALIZED_PATTERN.test(error.message);
     }
+    isThreadReadNotFoundError(error) {
+        if (!(error instanceof Error)) {
+            return false;
+        }
+        return THREAD_READ_NOT_FOUND_PATTERN.test(error.message);
+    }
 }
 exports.CodexAppServerBackend = CodexAppServerBackend;
 //# sourceMappingURL=codex-appserver.js.map