specrails-desktop 2.36.0 → 2.42.2

package/server/dist/provider-detection.js

@@ -89,12 +89,24 @@ function probeAuthState(id, home) {
                 // also live in the OS keychain, so absence is 'unknown', never a hard
                 // 'unauthenticated'.
                 return fs.existsSync(path.join(home, '.claude.json')) ? 'authenticated' : 'unknown';
-            case 'codex':
-                // Codex persists auth at ~/.codex/auth.json; its absence reliably means
-                // no login has happened on this machine.
-                return fs.existsSync(path.join(home, '.codex', 'auth.json'))
-                    ? 'authenticated'
-                    : 'unauthenticated';
+            case 'codex': {
+                // Match the invocation's custom home without reading credential bytes.
+                // A relative override depends on the invocation cwd, so do not guess
+                // an identity from this process's different working directory.
+                const override = process.env.CODEX_HOME;
+                if (override && !path.isAbsolute(override))
+                    return 'unknown';
+                const authPath = path.join(override || path.join(home, '.codex'), 'auth.json');
+                try {
+                    if (!fs.statSync(authPath).isFile())
+                        return 'unknown';
+                    fs.accessSync(authPath, fs.constants.R_OK);
+                    return 'authenticated';
+                }
+                catch (error) {
+                    return error.code === 'ENOENT' ? 'unauthenticated' : 'unknown';
+                }
+            }
             case 'gemini': {
                 // OAuth creds land under ~/.gemini; an API key via env also counts.
                 if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY)

package/server/dist/provider-limit.js

@@ -0,0 +1,64 @@
+"use strict";
+// Provider usage/rate limits as a FIRST-CLASS loop signal.
+//
+// Run 52124009 (2026-09-04): the claude subscription hit its session limit
+// mid-batch. The CLI answered every later spawn in ~0.5 s with a `result`
+// frame whose text was "You've hit your session limit · resets 3am
+// (Europe/Madrid)" and `is_error: true`. The engine saw a non-empty, exit-0
+// reply → step `ok` → verify → decider (unparseable → continue) → fix … three
+// full cycles until the no-progress stall guard finally stopped the run. A
+// limit is not something to iterate on: detect it on the step's FINAL text,
+// stop the loop at once with an honest reason, and tell the user when it
+// resets.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLimitReset = extractLimitReset;
+exports.classifyProviderLimit = classifyProviderLimit;
+exports.describeProviderLimit = describeProviderLimit;
+/** Only the tail of a transcript is judged — a spec discussing rate limiting
+ *  must never trip the classifier; the provider's own notice is always last. */
+const TAIL_CHARS = 600;
+const PATTERNS = [
+    // claude: "You've hit your session limit · resets 3am (Europe/Madrid)"
+    //         "You've hit your usage limit …", "…weekly limit…"
+    { kind: 'session_limit', re: /\byou(?:'|’)?ve hit your (?:session|usage|weekly|daily|monthly|plan)?\s*limit\b/i },
+    // claude API error wrapper: "(error type rate_limit, HTTP 429 …)"
+    { kind: 'rate_limit', re: /\berror type rate_limit\b/i },
+    { kind: 'rate_limit', re: /\bHTTP 429\b|\b429 Too Many Requests\b|\brate[ _-]?limit(?:ed|s)? (?:exceeded|reached|hit)\b|\brate_limit_error\b/i },
+    // codex / openai
+    { kind: 'quota', re: /\binsufficient_quota\b|\byou(?:'|’)?ve reached your (?:usage )?limit\b|\busage limit (?:reached|exceeded)\b/i },
+    // gemini / google
+    { kind: 'quota', re: /\bRESOURCE_EXHAUSTED\b|\bquota (?:exceeded|exhausted)\b/i },
+];
+// "resets 3am (Europe/Madrid)", "resets at 14:00", "resets in 2 hours".
+const RESETS_RE = /\bresets?\s+(?:at\s+|in\s+)?([^\n·(]*?\d[^\n·(]*?)(\s*\([^)]*\))?(?=\s*(?:\(error|[.,;]\s|\n|$))/i;
+function extractLimitReset(text) {
+    const m = RESETS_RE.exec(text);
+    if (!m)
+        return null;
+    const value = `${m[1].trim()}${m[2] ? ` ${m[2].trim()}` : ''}`.trim().replace(/[.,;:]+$/, '');
+    return value.length > 0 && value.length <= 80 ? value : null;
+}
+/** Classify a step's FINAL text / error text. Null when no provider limit
+ *  notice is present. Never throws. */
+function classifyProviderLimit(text) {
+    if (!text)
+        return null;
+    const tail = text.length > TAIL_CHARS ? text.slice(-TAIL_CHARS) : text;
+    for (const { kind, re } of PATTERNS) {
+        const m = re.exec(tail);
+        if (!m)
+            continue;
+        // The provider's sentence: the line carrying the match, trimmed.
+        const lineStart = tail.lastIndexOf('\n', m.index) + 1;
+        const lineEndIdx = tail.indexOf('\n', m.index);
+        const line = tail.slice(lineStart, lineEndIdx === -1 ? undefined : lineEndIdx).trim();
+        return { kind, message: line.slice(0, 300), resetsAt: extractLimitReset(tail) };
+    }
+    return null;
+}
+/** Human line for logs/toasts: "<message> — resets 3am (Europe/Madrid)". */
+function describeProviderLimit(limit) {
+    return limit.resetsAt && !limit.message.toLowerCase().includes('reset')
+        ? `${limit.message} — resets ${limit.resetsAt}`
+        : limit.message;
+}

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

@@ -11,10 +11,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.claudeAdapter = void 0;
+exports.isClaudeNotificationResultFrame = isClaudeNotificationResultFrame;
 exports._normaliseClaudeModel = normaliseModel;
 exports._resolveClaudeSpawnModel = resolveSpawnModel;
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
+const openspec_runtime_plugin_1 = require("../openspec-runtime-plugin");
 const WHICH_CMD = process.platform === 'win32' ? 'where' : 'which';
 const CLAUDE_MODELS = [
     { value: 'sonnet', label: 'Claude Sonnet', default: true },
@@ -104,6 +106,7 @@ function commonFlagsFor(opts) {
                 ? ['--permission-mode', 'plan', '--safe-mode']
                 : []),
         ...toolArgs,
+        ...(toolPolicy === 'default' ? (0, openspec_runtime_plugin_1.getOpenSpecRuntimePluginArgs)() : []),
         '--output-format', 'stream-json',
         '--verbose',
         '--setting-sources',
@@ -249,6 +252,22 @@ function withAssistantUsage(ev, msg) {
         carrier.model = msg.model;
     return ev;
 }
+/** True when a claude `result` frame is a CLI-INTERNAL notification turn, NOT
+ *  the answer to a prompt the caller wrote. Live evidence (loop run 5c958db2,
+ *  claude 2.1.260): a `--resume` of a session whose previous process exited
+ *  with background tasks still running makes the CLI report those tasks as
+ *  orphaned and emit a turn of its own — `origin: {kind:'task-notification'}`,
+ *  `num_turns: 0`, `stop_reason: null`, empty `result`, zero usage — BEFORE it
+ *  processes the caller's prompt. A consumer that closes its turn on the first
+ *  `result` (interactive job/loop sessions, persistent Explore turns) would
+ *  settle on that frame and tear the real turn down mid-thought. The caller's
+ *  own turns carry no `origin` at all. */
+function isClaudeNotificationResultFrame(frame) {
+    const origin = frame.origin;
+    if (!origin || typeof origin !== 'object')
+        return false;
+    return origin.kind === 'task-notification';
+}
 function parseClaudeStreamLine(line) {
     if (line.length === 0)
         return null;
@@ -270,7 +289,12 @@ function parseClaudeStreamLine(line) {
         return { kind: 'other', type, raw: parsed };
     }
     if (type === 'result') {
-        return { kind: 'result', payload: parsed };
+        // A CLI-internal notification turn surfaces as a NON-terminal 'other'
+        // event so no consumer (turn-closing sessions, extractResult, recovery)
+        // mistakes it for the caller's turn result.
+        if (isClaudeNotificationResultFrame(parsed))
+            return { kind: 'other', type, raw: parsed };
+        return { kind: 'result', payload: parsed, ...(parsed.is_error === true ? { isError: true } : {}) };
     }
     if (type === 'assistant') {
         const msg = parsed.message;
@@ -456,6 +480,7 @@ exports.claudeAdapter = {
         profileEnvSupport: true,
         systemPromptArg: true,
         persistentStdin: true,
+        liveInputTransport: 'claude-stream-json',
         supportsReasoningEffort: true,
         reasoningEfforts: ['low', 'medium', 'high', 'xhigh'], // claude-code --effort tiers
         supportsImageInput: true, // images ride as `@<abs-path>` prompt refs

package/server/dist/providers/claude-background-tasks.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readClaudeBackgroundTasks = readClaudeBackgroundTasks;
+/** Claude's authoritative background roster. null means "no valid update",
+ * whereas [] explicitly confirms that the provider has no live workers. */
+function readClaudeBackgroundTasks(frame) {
+    if (frame?.type !== 'system' || frame.subtype !== 'background_tasks_changed' || !Array.isArray(frame.tasks))
+        return null;
+    // Claude marks live-update watchers and skip-transcript tasks as ambient:
+    // they are not foreground activity and need not finish for a step to end.
+    // Only the explicit boolean opts out; older/malformed entries still block.
+    return frame.tasks.filter((task) => task?.ambient !== true).map((task) => {
+        const item = (task ?? {});
+        const id = typeof item.task_id === 'string' ? item.task_id : '';
+        const description = typeof item.description === 'string' ? item.description.trim() : '';
+        return (description ? `${id ? `${id}: ` : ''}${description}` : id || 'task').slice(0, 500);
+    });
+}

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

@@ -0,0 +1,383 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runClaudeLiveSession = runClaudeLiveSession;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const node_readline_1 = require("node:readline");
+const win_spawn_1 = require("../util/win-spawn");
+const cli_prompt_1 = require("../util/cli-prompt");
+const runtime_1 = require("./runtime");
+const live_session_types_1 = require("./live-session-types");
+// Claude Code 2.1.261: stdin user frames enter the native command queue. The
+// query loop handles priority "next" messages after the running tool batch and
+// re-emits the queued_command as {type:"user",isReplay:true,uuid:source_uuid}.
+// That replay precedes committing absorption and may also precede a cancelled
+// turn or hooks: it confirms receipt, not model consumption. Reading requires
+// an explicit agent acknowledgement. A successful stdin.write only means bytes
+// were buffered, so it is never an acknowledgement.
+// https://code.claude.com/docs/en/cli-reference#cli-flags
+// https://code.claude.com/docs/en/agent-sdk/streaming-vs-single-mode
+// We deliberately do not issue control_request/interrupt for steering: that
+// aborts Claude's active tools rather than letting their results finish.
+const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+const STDERR_CAP = 64 * 1024;
+const IMAGE_TYPES = {
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp',
+};
+async function inputContent(input) {
+    if (!input.imagePaths?.length)
+        return input.text;
+    const content = [{ type: 'text', text: input.text }];
+    let remaining = MAX_IMAGE_BYTES;
+    for (const imagePath of input.imagePaths) {
+        try {
+            const mimeType = IMAGE_TYPES[node_path_1.default.extname(imagePath).toLowerCase()];
+            if (!mimeType)
+                throw new Error('unsupported image type');
+            // Read at most the remaining budget + one byte through one file handle:
+            // a growing file cannot evade a stat-then-read limit and exhaust memory.
+            const file = await (0, promises_1.open)(imagePath, 'r');
+            try {
+                const stat = await file.stat();
+                if (!stat.isFile() || stat.size > remaining)
+                    throw new Error('the images exceed the 8 MiB input budget');
+                const bytes = Buffer.alloc(remaining + 1);
+                let length = 0;
+                for (;;) {
+                    const read = await file.read(bytes, length, bytes.length - length, null);
+                    length += read.bytesRead;
+                    if (length > remaining)
+                        throw new Error('the images exceed the 8 MiB input budget');
+                    if (read.bytesRead === 0)
+                        break;
+                }
+                remaining -= length;
+                content.push({ type: 'image', source: { type: 'base64', media_type: mimeType, data: bytes.subarray(0, length).toString('base64') } });
+            }
+            finally {
+                await file.close();
+            }
+        }
+        catch (error) {
+            content.push({ type: 'text', text: `[Image attachment ${imagePath} was not delivered: ${error instanceof Error ? error.message : String(error)}. The original attachment is retained by Specrails. Do not infer its contents.]` });
+        }
+    }
+    return content;
+}
+/** One native Claude process, accepting input until its final result. Tool
+ * batches finish normally. If an update misses a fold boundary Claude may
+ * process it as a subsequent native turn in the SAME process; keep stdin open
+ * until those written inputs have been echoed and their result has arrived. */
+function runClaudeLiveSession(hooks) {
+    if (hooks.adapter.id !== 'claude' || !hooks.buildOpts)
+        throw new Error('Claude live sessions require the Claude adapter and buildOpts.');
+    const opts = hooks.buildOpts;
+    return new Promise(resolveInvocation => {
+        const events = [];
+        const pending = new Map();
+        const submitted = new Map();
+        const initialId = (0, node_crypto_1.randomUUID)();
+        let child = null;
+        let ended = false;
+        let accepting = true;
+        let initialWritten = false;
+        let initialAccepted = false;
+        let sessionId = opts.sessionId ?? null;
+        let lastResultEvent = null;
+        let stderrTail = '';
+        let promptDirectory;
+        let timeout;
+        let inactivity;
+        let closeDeadline;
+        let stdoutReader;
+        let stderrReader;
+        let writeSequence = Promise.resolve();
+        let escalation;
+        const rejectPending = (reason) => {
+            for (const input of pending.values()) {
+                if (input.written)
+                    input.reject(new live_session_types_1.LiveInputDeliveryError(reason, true));
+                else
+                    input.resolve(false);
+            }
+            pending.clear();
+        };
+        const settle = (code, timedOut = false, spawnFailed = false) => {
+            if (ended)
+                return;
+            ended = true;
+            accepting = false;
+            clearTimeout(timeout);
+            clearTimeout(inactivity);
+            clearTimeout(closeDeadline);
+            rejectPending('Claude ended before acknowledging the live input. Delivery is uncertain; do not replay automatically.');
+            stdoutReader?.close();
+            stderrReader?.close();
+            // Leave the child's close/error listeners in place until it exits, so
+            // late EPIPE is contained and close cancels the owned SIGKILL deadline.
+            try {
+                child?.stdin?.destroy();
+            }
+            catch { /* best effort */ }
+            try {
+                child?.stdout?.destroy();
+            }
+            catch { /* best effort */ }
+            try {
+                child?.stderr?.destroy();
+            }
+            catch { /* best effort */ }
+            if (promptDirectory) {
+                try {
+                    (0, node_fs_1.rmSync)(promptDirectory, { recursive: true, force: true });
+                }
+                catch { /* best effort */ }
+            }
+            resolveInvocation({ code, timedOut, spawnFailed, events, lastResultEvent, sessionId, stderrTail, child });
+        };
+        const terminate = () => {
+            if (!child || escalation)
+                return;
+            try {
+                if (child.pid)
+                    (0, win_spawn_1.treeKillSafe)(child.pid, 'SIGTERM');
+                else
+                    child.kill('SIGTERM');
+            }
+            catch { /* child already gone */ }
+            const ownedChild = child;
+            escalation = setTimeout(() => {
+                try {
+                    if (ownedChild.pid)
+                        (0, win_spawn_1.treeKillSafe)(ownedChild.pid, 'SIGKILL');
+                    else
+                        ownedChild.kill('SIGKILL');
+                }
+                catch { /* already gone */ }
+            }, 2000);
+            escalation.unref?.();
+            ownedChild.once('close', () => clearTimeout(escalation));
+        };
+        const expire = (kind) => {
+            if (ended)
+                return;
+            if (kind === 'wall')
+                hooks.onTimeout?.();
+            else
+                hooks.onInactivityTimeout?.();
+            terminate();
+            settle(null, true);
+        };
+        const activity = () => {
+            clearTimeout(inactivity);
+            if (!ended && hooks.inactivityTimeoutMs && hooks.inactivityTimeoutMs > 0) {
+                inactivity = setTimeout(() => expire('inactivity'), hooks.inactivityTimeoutMs);
+                inactivity.unref?.();
+            }
+        };
+        const event = (value) => {
+            events.push(value);
+            if (value.kind === 'session-started')
+                sessionId = value.sessionId;
+            if (value.kind === 'result') {
+                lastResultEvent = value;
+                if (typeof value.payload.session_id === 'string')
+                    sessionId = value.payload.session_id;
+            }
+            hooks.onEvent?.(value);
+        };
+        const send = (input, onAccepted) => {
+            const fingerprint = JSON.stringify([input.text, input.imagePaths ?? []]);
+            const existing = submitted.get(input.id);
+            if (existing)
+                return existing.fingerprint === fingerprint ? existing.promise : Promise.reject(new live_session_types_1.LiveInputDeliveryError('Live input ID already has different content.', existing.written));
+            if (!accepting || ended || !child?.stdin || child.stdin.destroyed || child.stdin.writableEnded || child.killed)
+                return Promise.resolve(false);
+            let resolve, reject;
+            const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
+            const entry = { id: input.id, nativeId: (0, node_crypto_1.randomUUID)(), fingerprint, written: false, promise, resolve, reject, onAccepted };
+            submitted.set(input.id, entry);
+            pending.set(entry.nativeId, entry);
+            const writing = writeSequence.then(async () => {
+                if (!accepting || ended) {
+                    pending.delete(entry.nativeId);
+                    entry.resolve(false);
+                    return;
+                }
+                const content = await inputContent(input);
+                if (!accepting || ended || !child?.stdin || child.stdin.destroyed || child.stdin.writableEnded || child.killed) {
+                    pending.delete(entry.nativeId);
+                    entry.resolve(false);
+                    return;
+                }
+                // Mark BEFORE write: a custom writable can synchronously emit the echo,
+                // and an EPIPE callback cannot prove no bytes reached the CLI.
+                entry.written = true;
+                child.stdin.write(JSON.stringify({ type: 'user', uuid: entry.nativeId, session_id: sessionId ?? '',
+                    parent_tool_use_id: null, priority: 'next', message: { role: 'user', content } }) + '\n', error => {
+                    if (!error)
+                        return;
+                    pending.delete(entry.nativeId);
+                    entry.reject(new live_session_types_1.LiveInputDeliveryError(`Claude input write failed: ${error.message}`, true));
+                });
+            });
+            // Keep input order even when an earlier message reads a large image.
+            // Waiting for its write (not its echo) still permits genuine streaming.
+            writeSequence = writing.catch(() => { });
+            void writing.catch(error => {
+                pending.delete(entry.nativeId);
+                entry.reject(error instanceof live_session_types_1.LiveInputDeliveryError ? error : new live_session_types_1.LiveInputDeliveryError(error instanceof Error ? error.message : String(error), entry.written));
+            });
+            return promise;
+        };
+        const finishAfterResult = () => {
+            if (ended || !accepting)
+                return;
+            accepting = false;
+            // Any image preparation which has NOT written yet can safely use the
+            // caller's ordinary continuation. Written entries must first receive ACK.
+            for (const [id, input] of pending)
+                if (!input.written) {
+                    pending.delete(id);
+                    input.resolve(false);
+                }
+            child?.stdin?.end();
+            // The native turn has finished; EOF should close its resident process.
+            // Reap a CLI that ignores EOF, without aborting an active tool batch.
+            closeDeadline = setTimeout(() => { terminate(); settle(0); }, 2000);
+            closeDeadline.unref?.();
+        };
+        try {
+            let spawnOpts = opts;
+            const extraArgs = [...(opts.extraArgs ?? []), '--replay-user-messages'];
+            // The shared Windows wrapper moves inline prompt flags to stdin and ends
+            // it. A private prompt FILE avoids that transform for this live channel.
+            if (process.platform === 'win32' && opts.systemPrompt) {
+                promptDirectory = (0, node_fs_1.mkdtempSync)(node_path_1.default.join((0, node_os_1.tmpdir)(), 'specrails-claude-live-'));
+                const promptFile = node_path_1.default.join(promptDirectory, 'system.txt');
+                (0, node_fs_1.writeFileSync)(promptFile, opts.systemPrompt, { mode: 0o600 });
+                extraArgs.push('--system-prompt-file', promptFile);
+                spawnOpts = { ...opts, systemPrompt: undefined };
+            }
+            const args = hooks.adapter.buildArgs('chat-stream', { ...spawnOpts, extraArgs });
+            child = (hooks.spawn ?? cli_prompt_1.spawnAiCli)(hooks.binary ?? hooks.adapter.binary, args, {
+                cwd: hooks.cwd, env: (0, runtime_1.buildProviderEnv)(hooks.adapter, opts, hooks.env ?? process.env), stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch (error) {
+            hooks.onSpawnError?.(error);
+            settle(null, false, true);
+            return;
+        }
+        child.on('error', error => { hooks.onSpawnError?.(error); settle(null, false, true); });
+        child.on('close', code => {
+            if (!ended && !lastResultEvent && !child?.killed)
+                event({ kind: 'error', message: 'Claude closed before producing a terminal result.' });
+            settle(code);
+        });
+        child.stdin?.on('error', error => {
+            if (ended)
+                return;
+            rejectPending(`Claude stdin failed: ${error.message}; delivery is uncertain.`);
+            event({ kind: 'error', message: `Claude stdin failed: ${error.message}` });
+            terminate();
+            settle(null);
+        });
+        if (!child.stdout || !child.stdin) {
+            terminate();
+            settle(null, false, true);
+            return;
+        }
+        stdoutReader = (0, node_readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
+        child.stdout.on('data', () => { activity(); hooks.onData?.('stdout'); });
+        stdoutReader.on('line', line => {
+            if (ended)
+                return;
+            try {
+                hooks.onStdoutLine?.(line);
+                let raw;
+                try {
+                    raw = JSON.parse(line);
+                }
+                catch { /* adapter ignores malformed lines */ }
+                if (raw?.type === 'user' && raw.isReplay === true && raw.parent_tool_use_id == null && raw.message?.role === 'user' && typeof raw.uuid === 'string') {
+                    if (raw.uuid === initialId && initialWritten && !initialAccepted) {
+                        initialAccepted = true;
+                        hooks.onInitialInputAccepted?.();
+                    }
+                    const input = pending.get(raw.uuid);
+                    if (input?.written) {
+                        pending.delete(raw.uuid);
+                        try {
+                            input.onAccepted?.();
+                            input.resolve(true);
+                        }
+                        catch (error) {
+                            input.reject(new live_session_types_1.LiveInputDeliveryError(`Claude accepted the input but local acknowledgement failed: ${String(error)}`, true));
+                        }
+                    }
+                    // Echoes carry input resources, not tool outcomes or generated text.
+                    return;
+                }
+                for (const parsed of (0, runtime_1.parseStreamEvents)(hooks.adapter, line)) {
+                    event(parsed);
+                    if (parsed.kind === 'result') {
+                        if (parsed.isError) {
+                            const errors = parsed.payload.errors;
+                            const reason = typeof parsed.payload.result === 'string' && parsed.payload.result || (Array.isArray(errors) ? errors.join('\n') : 'Claude returned an error result.');
+                            event({ kind: 'error', message: String(reason) });
+                            rejectPending('Claude failed before confirming the input. Do not replay automatically.');
+                            finishAfterResult();
+                        }
+                        else if (initialWritten && ![...pending.values()].some(input => input.written))
+                            finishAfterResult();
+                    }
+                }
+            }
+            catch (error) {
+                // A callback/parser must not throw out of an EventEmitter into the
+                // sidecar's uncaught-exception handler.
+                console.error('[claude-live-session] stdout handler failed:', error);
+            }
+        });
+        if (child.stderr) {
+            child.stderr.on('data', (chunk) => {
+                activity();
+                hooks.onData?.('stderr');
+                stderrTail = (stderrTail + chunk.toString()).slice(-STDERR_CAP);
+            });
+            if (hooks.onStderrLine) {
+                stderrReader = (0, node_readline_1.createInterface)({ input: child.stderr, crlfDelay: Infinity });
+                stderrReader.on('line', line => hooks.onStderrLine?.(line));
+            }
+        }
+        hooks.onSpawn?.(child);
+        activity();
+        if (hooks.timeoutMs && hooks.timeoutMs > 0) {
+            timeout = setTimeout(() => expire('wall'), hooks.timeoutMs);
+            timeout.unref?.();
+        }
+        // Initial content also uses the native channel, with a unique UUID. The
+        // caller owns initial-message persistence; replay confirms its receipt.
+        void inputContent({ id: initialId, text: opts.prompt, imagePaths: opts.imagePaths }).then(content => {
+            if (ended || !accepting || !child?.stdin || child.killed || child.stdin.destroyed)
+                return;
+            initialWritten = true;
+            child.stdin.write(JSON.stringify({ type: 'user', uuid: initialId, session_id: sessionId ?? '', parent_tool_use_id: null,
+                priority: 'next', message: { role: 'user', content } }) + '\n', error => {
+                if (error) {
+                    event({ kind: 'error', message: `Claude initial input failed: ${error.message}` });
+                    terminate();
+                    settle(null);
+                }
+            });
+            hooks.onInputReady?.({ send, acceptedReceipt: 'received' });
+        }).catch(error => { event({ kind: 'error', message: `Claude initial input failed: ${String(error)}` }); terminate(); settle(null); });
+    });
+}

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

@@ -37,6 +37,9 @@ const WHICH_CMD = process.platform === 'win32' ? 'where' : 'which';
 const CODEX_MIN_VERSION = '0.128.0';
 exports._CODEX_MIN_VERSION = CODEX_MIN_VERSION;
 const CODEX_MODELS = [
+    // Newest first. gpt-6-astra has no rate card in `server/pricing.ts` yet, so
+    // its turns show cost as unavailable (honest-metrics: never fabricated).
+    { value: 'gpt-6-astra', label: 'GPT-6 Astra' },
     { value: 'gpt-5.6-sol', label: 'GPT-5.6 Sol' },
     { value: 'gpt-5.6-terra', label: 'GPT-5.6 Terra' },
     { value: 'gpt-5.6-luna', label: 'GPT-5.6 Luna' },
@@ -45,6 +48,17 @@ const CODEX_MODELS = [
     { value: 'gpt-5.4-mini', label: 'GPT-5.4 Mini' },
     { value: 'gpt-5.3-codex', label: 'GPT-5.3 Codex' },
 ];
+// Model-specific CLI capabilities (models/list, reviewed 2026-09-05).
+// Keep the provider-wide union for legacy models without current metadata.
+const BASE_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
+const CODEX_MODEL_EFFORTS = {
+    'gpt-6-astra': [...BASE_EFFORTS, 'max', 'ultra'],
+    'gpt-5.6-sol': [...BASE_EFFORTS, 'max', 'ultra'],
+    'gpt-5.6-terra': [...BASE_EFFORTS, 'max', 'ultra'],
+    'gpt-5.6-luna': [...BASE_EFFORTS, 'max'],
+    'gpt-5.5': BASE_EFFORTS,
+    'gpt-5.4-mini': BASE_EFFORTS,
+};
 const SANDBOX_FLAGS = ['--sandbox', 'workspace-write'];
 const RAIL_SANDBOX_FLAGS = ['--sandbox', 'danger-full-access'];
 // `codex exec resume` does NOT accept `--sandbox` (the flag only exists on
@@ -55,6 +69,8 @@ const SKIP_GIT_CHECK = '--skip-git-repo-check';
 function sandboxFlags(opts, rail = false) {
     if (opts.toolPolicy === 'read-only')
         return ['--sandbox', 'read-only'];
+    if (opts.scopedWorkingDirectories)
+        return [...SANDBOX_FLAGS];
     return rail ? [...RAIL_SANDBOX_FLAGS] : [...SANDBOX_FLAGS];
 }
 function resumeSandboxFlags(opts) {
@@ -341,6 +357,7 @@ exports.codexAdapter = {
     instructionsFilename: 'AGENTS.md',
     mcpRegistration: 'cli-add',
     capabilities: {
+        liveInputTransport: 'codex-app-server',
         nativeResume: true,
         nativeStreamJson: true,
         nativeCostUsd: false,
@@ -362,6 +379,8 @@ exports.codexAdapter = {
         userMcp: false,
     },
     modelCatalog: () => CODEX_MODELS,
+    reasoningEffortsForModel: (model) => CODEX_MODEL_EFFORTS[model]
+        ?? ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
     defaultModel: () => 'gpt-5.5',
     buildArgs: buildCodexArgs,
     parseStreamLine: parseCodexStreamLine,