specrails-desktop 2.36.0 → 2.42.2

package/server/dist/providers/codex-live-session.js

@@ -0,0 +1,545 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCodexLiveSession = runCodexLiveSession;
+const node_string_decoder_1 = require("node:string_decoder");
+const cli_prompt_1 = require("../util/cli-prompt");
+const win_spawn_1 = require("../util/win-spawn");
+const runtime_1 = require("./runtime");
+const live_session_types_1 = require("./live-session-types");
+// Verified against codex-cli 0.153.4's generated app-server v2 protocol and
+// https://learn.chatgpt.com/docs/app-server. No SDK or paid probe is required.
+const RPC_TIMEOUT_MS = 60_000;
+const STEER_TIMEOUT_MS = 30_000;
+const MAX_FRAME_BYTES = 16 * 1024 * 1024;
+const STDERR_CAP = 64 * 1024;
+class RpcFailure extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
+const string = (value) => typeof value === 'string' ? value : '';
+const preview = (value, limit = 4000) => (typeof value === 'string' ? value : JSON.stringify(value ?? '')).slice(0, limit);
+const count = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : 0;
+const userInput = (text, imagePaths) => [
+    { type: 'text', text, text_elements: [] },
+    ...(imagePaths ?? []).map(path => ({ type: 'localImage', path })),
+];
+/** One native Codex turn, retaining a full-duplex app-server connection until
+ * completion. Steering never interrupts, restarts, or replays an active action. */
+function runCodexLiveSession(hooks) {
+    const opts = hooks.buildOpts;
+    const events = [];
+    let child = null;
+    let sessionId = null;
+    let lastResultEvent = null;
+    let stderrTail = '';
+    let activeTurnId = null;
+    let terminal = null;
+    let settled = false;
+    let transportFailed = false;
+    let closing = false;
+    let childClosed = false;
+    let turnRequested = false;
+    let nextId = 0;
+    let inputReady = false;
+    let lineBuffer = '';
+    const decoder = new node_string_decoder_1.StringDecoder('utf8');
+    const pending = new Map();
+    const messages = new Map();
+    const completedItems = new Set();
+    const startedTools = new Set();
+    const submissions = new Map();
+    let sendChain = Promise.resolve();
+    let inactivityTimer;
+    let wallTimer;
+    let shutdownTimer;
+    let killTimer;
+    let baselineUsage = null;
+    let lastTotal = null;
+    let usageSeen = false;
+    const usage = { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0 };
+    return new Promise(resolve => {
+        const emit = (event) => {
+            if (settled)
+                return;
+            events.push(event);
+            if (event.kind === 'result')
+                lastResultEvent = event;
+            try {
+                hooks.onEvent?.(event);
+            }
+            catch { /* renderer failure must not replay provider actions */ }
+        };
+        const finish = (code, timedOut = false, spawnFailed = false) => {
+            if (settled)
+                return;
+            activeTurnId = null;
+            if (terminal || usageSeen) {
+                // Usage arrives before the terminal notification. Preserve observed
+                // billable work even after Stop, timeout, or an app-server disconnect.
+                // Without a terminal response, a normal exit is still not success.
+                const status = terminal?.status ?? (transportFailed || timedOut || spawnFailed || code !== null ? 'failed' : 'interrupted');
+                emit({ kind: 'result', payload: {
+                        session_id: sessionId,
+                        ...(usageSeen ? { usage: {
+                                input_tokens: usage.inputTokens,
+                                cached_input_tokens: usage.cachedInputTokens,
+                                // The existing adapter adds reasoning_output_tokens to output.
+                                // App-server outputTokens already includes them: avoid double billing.
+                                output_tokens: Math.max(0, usage.outputTokens - usage.reasoningOutputTokens),
+                                reasoning_output_tokens: usage.reasoningOutputTokens,
+                            } } : {}),
+                        status,
+                        ...(typeof terminal?.durationMs === 'number' ? { duration_ms: terminal.durationMs } : {}),
+                    }, ...(status === 'failed' ? { isError: true } : {}) });
+            }
+            settled = true;
+            clearTimeout(inactivityTimer);
+            clearTimeout(wallTimer);
+            clearTimeout(shutdownTimer);
+            if (childClosed)
+                clearTimeout(killTimer);
+            for (const request of pending.values()) {
+                clearTimeout(request.timer);
+                request.reject(request.method === 'turn/steer'
+                    ? new live_session_types_1.LiveInputDeliveryError('Codex disconnected before acknowledging the input. Its delivery is unknown; do not resend it automatically.', true)
+                    : new Error('Codex app-server closed before responding.'));
+            }
+            pending.clear();
+            child?.stdout?.removeListener('data', onStdout);
+            child?.stderr?.removeListener('data', onStderr);
+            // Keep error listeners on the dying pipes: a late EPIPE must not crash Desktop.
+            // Settlement no longer consumes output, so release all pipe handles even
+            // when a failed child needs the bounded SIGKILL fallback to finally exit.
+            try {
+                child?.stdin?.destroy();
+            }
+            catch { /* best effort */ }
+            try {
+                child?.stdout?.destroy();
+            }
+            catch { /* best effort */ }
+            try {
+                child?.stderr?.destroy();
+            }
+            catch { /* best effort */ }
+            resolve({ code, timedOut, spawnFailed, events, lastResultEvent, sessionId, stderrTail, child });
+        };
+        const terminate = () => {
+            if (!child || childClosed)
+                return;
+            const signal = (value) => {
+                try {
+                    if (child?.pid)
+                        (0, win_spawn_1.treeKillSafe)(child.pid, value, () => { });
+                    else
+                        child?.kill(value);
+                }
+                catch { /* exit/close remain authoritative */ }
+            };
+            signal('SIGTERM');
+            if (!childClosed && !killTimer) {
+                killTimer = setTimeout(() => { signal('SIGKILL'); finish(terminal?.status === 'completed' ? 0 : null); }, 2000);
+                killTimer.unref?.();
+            }
+        };
+        const fail = (message, timedOut = false) => {
+            if (settled)
+                return;
+            transportFailed = true;
+            emit({ kind: 'error', message });
+            finish(null, timedOut);
+            terminate();
+        };
+        const armIdle = () => {
+            if (settled || closing || !hooks.inactivityTimeoutMs || hooks.inactivityTimeoutMs <= 0)
+                return;
+            clearTimeout(inactivityTimer);
+            inactivityTimer = setTimeout(() => {
+                hooks.onInactivityTimeout?.();
+                fail('Codex stopped reporting progress before the turn completed.', true);
+            }, hooks.inactivityTimeoutMs);
+            inactivityTimer.unref?.();
+        };
+        const maybeClose = () => {
+            // A completion notification can precede a steering acknowledgement in
+            // the same stream. Drain those replies before closing stdin.
+            if (!terminal || settled || closing || pending.size > 0)
+                return;
+            closing = true;
+            activeTurnId = null;
+            clearTimeout(inactivityTimer);
+            shutdownTimer = setTimeout(terminate, 1500);
+            shutdownTimer.unref?.();
+            try {
+                child?.stdin?.end();
+            }
+            catch {
+                terminate();
+            }
+        };
+        const write = (frame) => {
+            if (settled || closing || childClosed || !child?.stdin || child.stdin.destroyed)
+                throw new Error('Codex app-server input is closed.');
+            child.stdin.write(JSON.stringify(frame) + '\n', error => {
+                if (error && !settled)
+                    fail('Codex app-server input transport failed. Pending input delivery is unknown.');
+            });
+        };
+        const rpc = (method, params, onAccepted) => {
+            if (settled || closing || childClosed)
+                return Promise.reject(new live_session_types_1.LiveInputDeliveryError('Codex turn is closed.', false));
+            return new Promise((accept, reject) => {
+                const id = ++nextId;
+                const timer = setTimeout(() => {
+                    if (!pending.delete(id))
+                        return;
+                    if (method === 'turn/steer')
+                        reject(new live_session_types_1.LiveInputDeliveryError('Codex did not acknowledge the input in time. Delivery is unknown; do not resend it automatically.', true));
+                    else
+                        reject(new Error(`Codex app-server timed out during ${method}.`));
+                    maybeClose();
+                }, method === 'turn/steer' ? STEER_TIMEOUT_MS : RPC_TIMEOUT_MS);
+                timer.unref?.();
+                pending.set(id, { method, resolve: accept, reject, timer, onAccepted });
+                try {
+                    write({ id, method, params });
+                }
+                catch (error) {
+                    clearTimeout(timer);
+                    pending.delete(id);
+                    reject(method === 'turn/steer'
+                        ? new live_session_types_1.LiveInputDeliveryError('Codex could not confirm writing the input. Delivery is unknown; do not resend it automatically.', true)
+                        : error);
+                }
+            });
+        };
+        const sink = {
+            // Core acknowledges submission before updating model context or sampling.
+            // A matching userMessage item also does not prove model consumption.
+            acceptedReceipt: 'received',
+            send(input, onAccepted) {
+                if (!input.id || typeof input.text !== 'string' || (input.imagePaths?.some(path => typeof path !== 'string'))) {
+                    return Promise.reject(new live_session_types_1.LiveInputDeliveryError('Invalid Codex live input.', false));
+                }
+                const fingerprint = JSON.stringify([input.text, input.imagePaths ?? []]);
+                const existing = submissions.get(input.id);
+                if (existing)
+                    return existing.fingerprint === fingerprint ? existing.promise
+                        : Promise.reject(new live_session_types_1.LiveInputDeliveryError('The same live input ID was used for different content.', false));
+                const promise = sendChain.then(async () => {
+                    const expectedTurnId = activeTurnId;
+                    if (!expectedTurnId || terminal || settled || closing || child?.killed)
+                        return false;
+                    try {
+                        await rpc('turn/steer', {
+                            threadId: sessionId, expectedTurnId,
+                            clientUserMessageId: input.id, input: userInput(input.text, input.imagePaths),
+                        }, value => {
+                            if (value.turnId !== expectedTurnId)
+                                throw new live_session_types_1.LiveInputDeliveryError('Codex acknowledged an unexpected turn. Input delivery is unknown.', true);
+                            // Commit before parsing the next stdout line, including when ACK
+                            // and assistant text arrived in one OS pipe chunk.
+                            try {
+                                onAccepted?.();
+                            }
+                            catch {
+                                throw new live_session_types_1.LiveInputDeliveryError('Codex accepted the input but local confirmation could not be saved. Do not resend it.', true);
+                            }
+                        });
+                        return true;
+                    }
+                    catch (error) {
+                        if (error instanceof RpcFailure) {
+                            if (/no active turn|no turn (?:is )?(?:active|running)|(?:expected|active) turn.*(?:mismatch|does not match)|turn.*(?:already (?:completed|finished)|not found)/i.test(error.message))
+                                return false;
+                            throw new live_session_types_1.LiveInputDeliveryError(`Codex rejected the input: ${error.message}`, false);
+                        }
+                        throw error;
+                    }
+                });
+                submissions.set(input.id, { fingerprint, promise });
+                sendChain = promise.catch(() => { });
+                return promise;
+            },
+        };
+        const item = (value, completed) => {
+            const entry = object(value), id = string(entry.id), type = string(entry.type);
+            if (!id || completedItems.has(id))
+                return;
+            if (type === 'agentMessage') {
+                if (completed) {
+                    const text = string(entry.text), previous = messages.get(id) ?? '';
+                    if (text.startsWith(previous) && text.length > previous.length)
+                        emit({ kind: 'text-delta', text: text.slice(previous.length) });
+                    messages.set(id, text);
+                }
+            }
+            else if (['commandExecution', 'mcpToolCall', 'fileChange', 'dynamicToolCall', 'collabAgentToolCall', 'webSearch'].includes(type)) {
+                if (!startedTools.has(id)) {
+                    startedTools.add(id);
+                    emit({ kind: 'tool-use', toolUseId: id,
+                        name: type === 'mcpToolCall' ? `${string(entry.server)}.${string(entry.tool)}` : type,
+                        inputPreview: preview(entry.command ?? entry.arguments ?? entry.changes ?? entry.prompt ?? entry.query ?? '', 1000) });
+                }
+                if (completed)
+                    emit({ kind: 'tool-result', toolUseId: id,
+                        outputPreview: preview(entry.aggregatedOutput ?? entry.result ?? entry.error ?? entry.changes ?? entry.contentItems ?? { status: entry.status }),
+                        ...(['failed', 'declined'].includes(string(entry.status)) || entry.success === false || (typeof entry.exitCode === 'number' && entry.exitCode !== 0) || entry.error ? { isError: true } : {}) });
+            }
+            if (completed)
+                completedItems.add(id);
+        };
+        const notification = (method, params) => {
+            if (settled)
+                return;
+            if (method === 'thread/started')
+                return; // only the requested thread's response establishes identity
+            if (params.threadId !== sessionId || !sessionId)
+                return;
+            if (method === 'thread/tokenUsage/updated') {
+                const snapshot = object(params.tokenUsage), total = object(snapshot.total), last = object(snapshot.last);
+                if (!activeTurnId || params.turnId !== activeTurnId) {
+                    if (!turnRequested)
+                        baselineUsage = total;
+                    return;
+                }
+                if (terminal)
+                    return;
+                const previous = lastTotal ?? baselineUsage;
+                for (const key of Object.keys(usage))
+                    usage[key] += previous
+                        ? Math.max(0, count(total[key]) - count(previous[key])) : count(last[key]);
+                lastTotal = total;
+                usageSeen = true;
+                return;
+            }
+            if (method === 'turn/started') {
+                const turn = object(params.turn), id = string(turn.id);
+                if (turnRequested && !terminal && !activeTurnId && id)
+                    activeTurnId = id;
+                return;
+            }
+            const turn = object(params.turn);
+            const turnId = string(params.turnId) || string(turn.id);
+            if (!turnRequested || !turnId || (activeTurnId && turnId !== activeTurnId))
+                return;
+            // The initial turn may complete before its start response is flushed.
+            if (!activeTurnId && !terminal)
+                activeTurnId = turnId;
+            if (terminal)
+                return;
+            if (method === 'item/agentMessage/delta') {
+                const id = string(params.itemId), delta = string(params.delta);
+                if (id && delta && !completedItems.has(id)) {
+                    messages.set(id, (messages.get(id) ?? '') + delta);
+                    emit({ kind: 'text-delta', text: delta });
+                }
+            }
+            else if (method === 'item/started' || method === 'item/completed')
+                item(params.item, method === 'item/completed');
+            else if (method === 'error') {
+                const error = string(object(params.error).message) || 'Codex reported an error.';
+                if (params.willRetry === true)
+                    emit({ kind: 'other', type: 'codex.retrying', raw: { message: error } });
+                else
+                    emit({ kind: 'error', message: error });
+            }
+            else if (method === 'turn/completed') {
+                if (!['completed', 'failed', 'interrupted'].includes(string(turn.status))) {
+                    fail('Codex returned an invalid terminal turn status.');
+                    return;
+                }
+                if (Array.isArray(turn.items))
+                    turn.items.forEach(entry => item(entry, true));
+                terminal = turn;
+                activeTurnId = null;
+                if (turn.status === 'failed')
+                    emit({ kind: 'error', message: string(object(turn.error).message) || 'Codex turn failed.' });
+                maybeClose();
+            }
+        };
+        const frame = (value) => {
+            const record = object(value), id = record.id;
+            if (typeof record.method === 'string') {
+                if (typeof id === 'string' || typeof id === 'number') {
+                    // No approval is inferred from a server request. Native commands keep
+                    // the requested sandbox; MCP permissions remain in the MCP server.
+                    if (record.method === 'item/commandExecution/requestApproval' || record.method === 'item/fileChange/requestApproval')
+                        write({ id, result: { decision: 'decline' } });
+                    else if (record.method === 'item/tool/requestUserInput')
+                        write({ id, result: { answers: {} } });
+                    else
+                        write({ id, error: { code: -32601, message: 'This client does not implement that request. Ask the user in the mission conversation when input is needed.' } });
+                }
+                else
+                    notification(record.method, object(record.params));
+                return;
+            }
+            if (typeof id !== 'number' && typeof id !== 'string')
+                return;
+            const request = pending.get(id);
+            if (!request)
+                return;
+            pending.delete(id);
+            clearTimeout(request.timer);
+            if (record.error) {
+                const error = object(record.error);
+                request.reject(new RpcFailure(string(error.message) || 'Codex rejected the request.', typeof error.code === 'number' ? error.code : undefined));
+            }
+            else if ('result' in record) {
+                const result = object(record.result);
+                try {
+                    request.onAccepted?.(result);
+                    request.resolve(result);
+                }
+                catch (error) {
+                    request.reject(error);
+                    if (request.method === 'turn/steer' && error instanceof live_session_types_1.LiveInputDeliveryError && error.ambiguous)
+                        fail(error.message);
+                }
+            }
+            else
+                request.reject(new live_session_types_1.LiveInputDeliveryError('Codex returned a malformed acknowledgement. Delivery is unknown.', request.method === 'turn/steer'));
+            maybeClose();
+        };
+        function onStdout(chunk) {
+            if (settled)
+                return;
+            armIdle();
+            hooks.onData?.('stdout');
+            lineBuffer += typeof chunk === 'string' ? chunk : decoder.write(chunk);
+            for (;;) {
+                const end = lineBuffer.indexOf('\n');
+                if (end < 0) {
+                    if (Buffer.byteLength(lineBuffer) > MAX_FRAME_BYTES)
+                        fail('Codex app-server exceeded the protocol frame limit.');
+                    return;
+                }
+                const line = lineBuffer.slice(0, end).replace(/\r$/, '');
+                lineBuffer = lineBuffer.slice(end + 1);
+                if (!line.trim())
+                    continue;
+                if (Buffer.byteLength(line) > MAX_FRAME_BYTES) {
+                    fail('Codex app-server exceeded the protocol frame limit.');
+                    return;
+                }
+                try {
+                    hooks.onStdoutLine?.(line);
+                    frame(JSON.parse(line));
+                }
+                catch {
+                    fail('Codex app-server returned an invalid protocol frame.');
+                    return;
+                }
+                if (settled)
+                    return;
+            }
+        }
+        function onStderr(chunk) {
+            if (settled)
+                return;
+            armIdle();
+            hooks.onData?.('stderr');
+            const text = chunk.toString();
+            stderrTail = (stderrTail + text).slice(-STDERR_CAP);
+            if (hooks.onStderrLine)
+                for (const line of text.split(/\r?\n/).filter(Boolean))
+                    hooks.onStderrLine(line);
+        }
+        if (!opts || hooks.adapter.id !== 'codex' || !['chat-turn', 'chat-resume'].includes(hooks.action ?? '')) {
+            emit({ kind: 'error', message: 'Codex live sessions require chat-turn/chat-resume build options.' });
+            finish(null, false, true);
+            return;
+        }
+        if (hooks.action === 'chat-resume' && !opts.sessionId) {
+            emit({ kind: 'error', message: 'Codex live resume requires a session id.' });
+            finish(null, false, true);
+            return;
+        }
+        if (opts.toolPolicy === 'none') {
+            emit({ kind: 'error', message: 'Codex cannot enforce a no-tools live session.' });
+            finish(null, false, true);
+            return;
+        }
+        try {
+            child = (hooks.spawn ?? cli_prompt_1.spawnAiCli)(hooks.binary ?? hooks.adapter.binary, ['app-server', '--listen', 'stdio://', ...(opts.extraArgs ?? [])], {
+                cwd: hooks.cwd, env: (0, runtime_1.buildProviderEnv)(hooks.adapter, opts, hooks.env ?? process.env), stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch (error) {
+            hooks.onSpawnError?.(error);
+            emit({ kind: 'error', message: error instanceof Error ? error.message : 'Could not spawn Codex app-server.' });
+            finish(null, false, true);
+            return;
+        }
+        child.on('error', error => { hooks.onSpawnError?.(error); emit({ kind: 'error', message: error.message }); finish(null, false, true); });
+        child.on('close', code => {
+            childClosed = true;
+            clearTimeout(killTimer);
+            if (!settled && !terminal)
+                emit({ kind: 'error', message: 'Codex app-server closed before the turn completed.' });
+            finish(terminal?.status === 'completed' ? 0 : terminal?.status === 'failed' ? 1 : terminal?.status === 'interrupted' ? null : code);
+        });
+        child.stdout?.on('data', onStdout);
+        child.stderr?.on('data', onStderr);
+        child.stdin?.on('error', () => { if (!settled)
+            fail('Codex app-server input transport failed. Pending input delivery is unknown.'); });
+        hooks.onSpawn?.(child);
+        if (settled)
+            return;
+        if (!child.stdin || !child.stdout) {
+            fail('Codex app-server requires stdin/stdout pipes.');
+            return;
+        }
+        armIdle();
+        if (hooks.timeoutMs && hooks.timeoutMs > 0) {
+            wallTimer = setTimeout(() => { hooks.onTimeout?.(); fail('Codex live turn exceeded its time limit.', true); }, hooks.timeoutMs);
+            wallTimer.unref?.();
+        }
+        void (async () => {
+            try {
+                await rpc('initialize', { clientInfo: { name: 'specrails_desktop', title: 'Specrails Desktop', version: '1.0.0' }, capabilities: { experimentalApi: true } });
+                write({ method: 'initialized' });
+                const thread = await rpc(hooks.action === 'chat-resume' ? 'thread/resume' : 'thread/start', {
+                    ...(hooks.action === 'chat-resume' ? { threadId: opts.sessionId } : {}),
+                    model: opts.model, cwd: hooks.cwd, approvalPolicy: 'never', sandbox: opts.toolPolicy === 'read-only' ? 'read-only' : 'workspace-write',
+                });
+                sessionId = string(object(thread.thread).id) || null;
+                if (!sessionId)
+                    throw new Error('Codex did not return a thread id.');
+                if (hooks.action === 'chat-resume' && sessionId !== opts.sessionId)
+                    throw new Error('Codex resumed an unexpected thread.');
+                emit({ kind: 'session-started', sessionId });
+                turnRequested = true;
+                await rpc('turn/start', {
+                    threadId: sessionId, input: userInput(opts.prompt, opts.imagePaths), model: opts.model,
+                    ...(opts.reasoning_effort ? { effort: opts.reasoning_effort } : {}),
+                }, response => {
+                    const turn = object(response.turn), id = string(turn.id);
+                    if (!id || (activeTurnId && id !== activeTurnId))
+                        throw new Error('Codex did not acknowledge the expected turn.');
+                    if (!terminal)
+                        activeTurnId = id;
+                    hooks.onInitialInputAccepted?.();
+                    // A fast turn can already be terminal in this response. Publish that
+                    // state before exposing the sink so queued input remains unsent.
+                    if (!terminal && ['completed', 'failed', 'interrupted'].includes(string(turn.status))) {
+                        notification('turn/completed', { threadId: sessionId, turn });
+                    }
+                    if (!inputReady) {
+                        inputReady = true;
+                        hooks.onInputReady?.(sink);
+                    }
+                });
+            }
+            catch (error) {
+                if (!settled)
+                    fail(error instanceof Error ? error.message : 'Codex live session failed to initialize.');
+            }
+        })();
+    });
+}

package/server/dist/providers/gemini-adapter.js

@@ -261,6 +261,7 @@ exports.geminiAdapter = {
     modelCatalog: () => GEMINI_MODELS,
     defaultModel: () => 'gemini-3.5-flash',
     buildArgs: buildGeminiArgs,
+    buildRepoAccessArgs: (paths) => paths.flatMap((repoPath) => ['--include-directories', repoPath]),
     parseStreamLine: parseGeminiStreamLine,
     extractResult: extractGeminiResult,
     projectMcpPath: (root) => path_1.default.join(root, '.gemini', 'settings.json'),

package/server/dist/providers/live-session-types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveInputDeliveryError = void 0;
+class LiveInputDeliveryError extends Error {
+    ambiguous;
+    constructor(message, ambiguous) {
+        super(message);
+        this.ambiguous = ambiguous;
+        this.name = 'LiveInputDeliveryError';
+    }
+}
+exports.LiveInputDeliveryError = LiveInputDeliveryError;

package/server/dist/providers/live-session.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeLiveSessionRunner = nativeLiveSessionRunner;
+const claude_live_session_1 = require("./claude-live-session");
+const codex_live_session_1 = require("./codex-live-session");
+/** A capability decision, kept out of conversation management. */
+function nativeLiveSessionRunner(adapter) {
+    switch (adapter.capabilities.liveInputTransport) {
+        case 'claude-stream-json': return claude_live_session_1.runClaudeLiveSession;
+        case 'codex-app-server': return codex_live_session_1.runCodexLiveSession;
+        default: return undefined;
+    }
+}

package/server/dist/providers/terminal-result.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.terminalResultError = terminalResultError;
+/** Failure carried by a terminal provider result, independently of exit code.
+ * Keep the result event intact so its usage remains available for accounting.
+ * This deliberately does not inspect nested tool_result errors: a tool can
+ * fail and the model can recover within an otherwise successful turn. */
+function terminalResultError(payload) {
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const result = payload;
+    if (result.type !== undefined && result.type !== 'result')
+        return null;
+    const subtype = typeof result.subtype === 'string' ? result.subtype : '';
+    if (result.is_error !== true && !/^error(?:_|$)/.test(subtype))
+        return null;
+    const errors = Array.isArray(result.errors)
+        ? result.errors.filter((error) => typeof error === 'string' && Boolean(error.trim()))
+        : [];
+    const detail = errors.length > 0
+        ? errors.join('; ')
+        : typeof result.result === 'string' ? result.result.trim() : '';
+    return [/^error(?:_|$)/.test(subtype) ? subtype : 'terminal result error', detail].filter(Boolean).join(': ').slice(0, 2000);
+}

package/server/dist/queue-manager.js

@@ -24,6 +24,7 @@ const feature_flags_1 = require("./feature-flags");
 const file_provenance_1 = require("./file-provenance");
 const result_event_1 = require("./result-event");
 const crypto_1 = require("crypto");
+const codex_spawn_1 = require("./plugins/codex-spawn");
 const providers_1 = require("./providers");
 const runtime_1 = require("./providers/runtime");
 const agent_defaults_1 = require("./agent-defaults");
@@ -2297,6 +2298,7 @@ class QueueManager {
         const railExtraArgs = execution.relocated
             ? (0, runtime_1.buildProviderRepoAccessArgs)(adapter, [execution.repoDir])
             : [];
+        railExtraArgs.push(...(0, codex_spawn_1.buildCodexPluginArgs)({ providerId: adapter.id, stateRoot: execution.cwd, repositoryPath: execution.repoDir, legacyProviderId: this._adapter.id }));
         // Resolve agent profile (if any) and snapshot per-job before spawn.
         // Super mode only (projectId + projectSlug + cwd all present).
         // Skipped when the adapter does not honour `SPECRAILS_PROFILE_PATH` AND