pikiloom 0.4.60 → 0.4.62

package/packages/kernel/dist/drivers/claude.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
-import { extname } from 'node:path';
-import { discoverClaudeNativeSessions } from '../workspace/native.js';
+import { discoverClaudeNativeSessions } from './native.js';
+import { attachedFileNote, contextPercent, createLineBuffer, imageMimeForFile, parseJsonLine, sigterm, wireAbort } from './shared.js';
 // Real driver: shells the local `claude` CLI in stream-json mode and normalizes its
 // events into kernel DriverEvents. Faithful to pikiloom's claude.ts event shapes
 // (system / stream_event{message_start,content_block_delta,message_delta} / assistant / result),
@@ -71,14 +71,21 @@ export class ClaudeDriver {
             taskList: new Map(),
             taskOrder: [],
             pendingTaskCreates: new Map(),
-            // run_in_background lifecycle: task ids seen as started vs. reached a terminal status.
-            bgStarted: new Set(), bgTerminal: new Set(),
+            todoPlan: null,
+            seenImages: new Set(),
+            // run_in_background lifecycle: task ids seen as started vs. reached a terminal status;
+            // bgAgentTasks marks the sub-agent-backed ones (they earn the longer hold cap).
+            bgStarted: new Set(), bgTerminal: new Set(), bgAgentTasks: new Set(),
         };
         return new Promise((resolve) => {
             let child;
             let settled = false;
             // One-shot guard for the truncated-turn recovery injection (see the result handler).
             let truncatedRecoveryAttempted = false;
+            // Bounded counter for the no-op-resume recovery re-injection (see the result handler): a
+            // resume of a session left incomplete by a prior turn can no-op several times before the
+            // CLI's repair clears and it runs our prompt for real.
+            let noopResumeRetries = 0;
             // holdCap: hard backstop while a background task is still running (never-completing daemon).
             // quiet: fires once all known background tasks finished AND Claude has gone quiet, so trailing
             // wake-up turns can still land before we close (see claudeBgSettleQuietMs).
@@ -120,17 +127,10 @@ export class ClaudeDriver {
                 }
                 catch { /* ignore */ }
                 if (!child.killed && child.exitCode == null) {
-                    if (kill) {
-                        try {
-                            child.kill('SIGTERM');
-                        }
-                        catch { /* ignore */ }
-                    }
+                    if (kill)
+                        sigterm(child);
                     else {
-                        const guard = setTimeout(() => { try {
-                            child?.kill('SIGTERM');
-                        }
-                        catch { /* ignore */ } }, CLAUDE_EXIT_LEAK_GUARD_MS);
+                        const guard = setTimeout(() => sigterm(child), CLAUDE_EXIT_LEAK_GUARD_MS);
                         unref(guard);
                     }
                 }
@@ -203,14 +203,7 @@ export class ClaudeDriver {
                 finish({ ok: false, text: '', error: `spawn failed: ${err?.message || err}`, stopReason: 'error' });
                 return;
             }
-            const onAbort = () => { try {
-                child.kill('SIGTERM');
-            }
-            catch { /* ignore */ } };
-            if (ctx.signal.aborted)
-                onAbort();
-            else
-                ctx.signal.addEventListener('abort', onAbort, { once: true });
+            wireAbort(ctx.signal, () => sigterm(child));
             if (steerable) {
                 ctx.registerSteer(async (prompt, attachments) => {
                     try {
@@ -222,27 +215,17 @@ export class ClaudeDriver {
                     }
                 });
             }
-            let buf = '';
+            const nextLines = createLineBuffer();
             let stderr = '';
             child.stdout.on('data', (chunk) => {
                 if (settled)
                     return; // ignore the process's post-settle shutdown chatter
-                buf += chunk.toString('utf8');
-                const lines = buf.split('\n');
-                buf = lines.pop() || '';
-                for (const line of lines) {
+                for (const line of nextLines(chunk)) {
                     if (settled)
                         return;
-                    const trimmed = line.trim();
-                    if (!trimmed)
-                        continue;
-                    let ev;
-                    try {
-                        ev = JSON.parse(trimmed);
-                    }
-                    catch {
+                    const ev = parseJsonLine(line);
+                    if (ev === undefined)
                         continue;
-                    }
                     state.lastEventAt = Date.now();
                     handleClaudeEvent(ev, state, ctx.emit);
                     const pending = pendingClaudeBackgroundTasks(state);
@@ -278,6 +261,29 @@ export class ClaudeDriver {
                                 settleResult({ stopReason: 'truncated', kill: false });
                                 return;
                             }
+                            // No-op resume repair: resuming a session whose previous turn was left incomplete (a
+                            // background hold that reclaimed its sub-agents/workflow — the ultra "no response"
+                            // report — an interrupt, a stall) makes the CLI answer with a synthetic "No response
+                            // requested." no-op that ran NONE of our prompt (no model turn at all), instead of
+                            // processing the message. Settling here delivers a silent "(no textual response)" and
+                            // drops the user's send. stdin is still open: re-issue the prompt so the CLI drives
+                            // through its repair to a real answer within this one turn. Bounded (the repair can
+                            // no-op more than once); the post-tool stall watchdog is the backstop if the CLI never
+                            // engages. Scoped to resumes (input.sessionId) — a fresh session has no dangling turn.
+                            if (!hasError && !!input.sessionId && !claudeProducedRealOutput(state)
+                                && noopResumeRetries < claudeResumeNoopRetryLimit()) {
+                                noopResumeRetries++;
+                                let injected = false;
+                                try {
+                                    child.stdin.write(claudeUserMessage(input.prompt, input.attachments) + '\n');
+                                    injected = true;
+                                }
+                                catch { /* fall through to settle */ }
+                                if (injected) {
+                                    armModelStall();
+                                    continue;
+                                }
+                            }
                             // kill=false: the CLI persists the turn into the session jsonl AFTER emitting
                             // `result`, and on a large session that flush (a whole-file rewrite) takes long
                             // enough that an immediate SIGTERM kills the process mid-write — the reply was
@@ -347,7 +353,7 @@ export class ClaudeDriver {
         return claudeUsageOf(s);
     }
 }
-export function claudeUsageOf(s) {
+function claudeUsageOf(s) {
     // While a message is still streaming, the CLI's live thinking estimate (system/thinking_tokens)
     // is often the ONLY output signal — subscription accounts stream no plaintext thinking and no
     // usage until the message settles. Fold it into the derived numbers (never into the raw
@@ -355,22 +361,20 @@ export function claudeUsageOf(s) {
     // output_tokens supersedes it at message_delta.
     const effOutput = Math.max(s.output ?? 0, s.thinkingEstTokens ?? 0);
     const used = (s.input ?? 0) + (s.cached ?? 0) + (s.cacheCreation ?? 0) + effOutput;
-    const window = s.contextWindow ?? null;
-    const contextPercent = window && used > 0 ? Math.min(99.9, Math.round((used / window) * 1000) / 10) : null;
     const turnOutput = (s.turnOutputTokensBase ?? 0) + effOutput;
     return {
         inputTokens: s.input,
         outputTokens: s.output,
         cachedInputTokens: s.cached,
         contextUsedTokens: used > 0 ? used : null,
-        contextPercent,
+        contextPercent: contextPercent(used > 0 ? used : null, s.contextWindow ?? null),
         turnOutputTokens: turnOutput > 0 ? turnOutput : null,
     };
 }
 // Accumulate the CLI's live thinking-token estimate onto driver state. Prefer the per-event
 // delta (correct whether the CLI's running total is per-message or per-turn); fall back to a
 // monotonic max of the running total. Returns true when the estimate advanced.
-export function applyClaudeThinkingEstimate(s, ev) {
+function applyClaudeThinkingEstimate(s, ev) {
     const prev = s.thinkingEstTokens ?? 0;
     const delta = Number(ev?.estimated_tokens_delta);
     const total = Number(ev?.estimated_tokens);
@@ -383,7 +387,7 @@ export function applyClaudeThinkingEstimate(s, ev) {
 // Advertised context window by Claude model id (best-effort; unknown -> null so the
 // percent simply stays absent rather than wrong). Anchor-free so vendor-prefixed ids
 // (us.anthropic.claude-…) still match.
-export function claudeContextWindowFromModel(model) {
+function claudeContextWindowFromModel(model) {
     const id = String(model ?? '').trim().toLowerCase();
     if (!id)
         return null;
@@ -397,7 +401,7 @@ export function claudeContextWindowFromModel(model) {
 }
 // Usable window = advertised minus Claude's max-output (20k) + autocompact (13k) reserve.
 const CLAUDE_USABLE_WINDOW_RESERVE = 33_000;
-export function claudeEffectiveContextWindow(advertised) {
+function claudeEffectiveContextWindow(advertised) {
     if (advertised == null)
         return null;
     return advertised <= CLAUDE_USABLE_WINDOW_RESERVE ? advertised : advertised - CLAUDE_USABLE_WINDOW_RESERVE;
@@ -523,6 +527,13 @@ export function handleClaudeEvent(ev, s, emit) {
         return;
     }
     if (t === 'assistant') {
+        // Synthetic resume-repair no-op: resuming a session whose previous turn was left incomplete
+        // makes the CLI emit an assistant message with model '<synthetic>' whose only text is
+        // "No response requested." (paired with an isMeta "Continue from where you left off." user
+        // record). It is NOT model output — mirror the legacy driver and drop it, so it neither shows
+        // as the reply nor counts as real output (the no-op-resume recovery keys off that emptiness).
+        if (ev.message?.model === '<synthetic>' && isClaudeSyntheticResumeNoise(claudeContentText(ev.message?.content)))
+            return;
         const contents = ev.message?.content || [];
         for (const b of contents) {
             if (b?.type !== 'tool_use')
@@ -791,6 +802,31 @@ export function claudeTruncatedRecoveryEnabled() {
     const v = String(process.env.PIKILOOM_CLAUDE_TRUNCATED_RECOVERY ?? '').trim().toLowerCase();
     return v !== '0' && v !== 'false' && v !== 'off';
 }
+// The CLI's resume-repair placeholder for a turn that never concluded: an assistant message with
+// model '<synthetic>' whose only text is "No response requested." (paired with an isMeta "Continue
+// from where you left off." user record). It is NOT model output. Mirrors the legacy driver.
+export function isClaudeSyntheticResumeNoise(text) {
+    const t = (text || '').trim().toLowerCase();
+    return t === 'no response requested.' || t === 'no response requested';
+}
+// True once the turn produced ANY real model output — streamed or whole-message text/reasoning, a
+// tool use, or a spawned sub-agent. False for a pure no-op (a synthetic resume-repair result that
+// ran none of the prompt), which is exactly what the no-op-resume recovery keys off. Pure +
+// exported for hermetic testing.
+export function claudeProducedRealOutput(s) {
+    return !!(s?.streamedText || s?.streamedReasoning
+        || (s?.tools?.size ?? 0) > 0 || (s?.subAgents?.size ?? 0) > 0
+        || (typeof s?.text === 'string' && s.text.trim().length > 0)
+        || (typeof s?.reasoning === 'string' && s.reasoning.trim().length > 0));
+}
+// How many times to re-issue the prompt when a resume comes back a pure no-op before giving up and
+// settling (see the result handler). Bounded so a genuinely dead session can't loop forever; 0
+// disables the recovery. Override with PIKILOOM_CLAUDE_RESUME_NOOP_RETRIES.
+const CLAUDE_RESUME_NOOP_RETRY_DEFAULT = 3;
+export function claudeResumeNoopRetryLimit() {
+    const raw = Number(process.env.PIKILOOM_CLAUDE_RESUME_NOOP_RETRIES);
+    return Number.isFinite(raw) && raw >= 0 ? raw : CLAUDE_RESUME_NOOP_RETRY_DEFAULT;
+}
 // True when a claude `type:'user'` stream event carries at least one tool_result block — i.e. the
 // tool loop just handed control back to the model. Pure + exported for hermetic testing.
 export function claudeUserEventHasToolResult(ev) {
@@ -885,11 +921,6 @@ export function decideClaudeResultSettle(input) {
         return 'hold';
     return input.sawBackground ? 'quiet-settle' : 'settle';
 }
-// Claude vision input formats (matches the legacy driver / Anthropic API: png, jpeg, gif, webp).
-const CLAUDE_IMAGE_MIME = {
-    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif', '.webp': 'image/webp',
-};
 // A stream-json user message (for --input-format stream-json; used to send the prompt and to
 // inject mid-turn steer messages while stdin stays open). Image attachments are inlined as base64
 // image content blocks so the model actually sees them; other files become a text note. Without
@@ -897,7 +928,7 @@ const CLAUDE_IMAGE_MIME = {
 export function claudeUserMessage(text, attachments) {
     const content = [];
     for (const filePath of attachments || []) {
-        const mime = CLAUDE_IMAGE_MIME[extname(filePath).toLowerCase()];
+        const mime = imageMimeForFile(filePath);
         if (mime) {
             try {
                 content.push({ type: 'image', source: { type: 'base64', media_type: mime, data: readFileSync(filePath).toString('base64') } });
@@ -905,13 +936,13 @@ export function claudeUserMessage(text, attachments) {
             }
             catch { /* unreadable -> fall through to a text note */ }
         }
-        content.push({ type: 'text', text: `[Attached file: ${filePath}]` });
+        content.push({ type: 'text', text: attachedFileNote(filePath) });
     }
     content.push({ type: 'text', text });
     return JSON.stringify({ type: 'user', message: { role: 'user', content } });
 }
 // Surface base64 image content blocks as artifacts (data URLs), deduped per turn.
-export function emitClaudeImages(blocks, s, emit) {
+function emitClaudeImages(blocks, s, emit) {
     if (!Array.isArray(blocks))
         return;
     s.seenImages ||= new Set();
@@ -955,7 +986,7 @@ export function todoWriteToPlan(input) {
 // dashboard's task-list card never renders. Ported from pikiloom's legacy claude driver.
 // The assigned task id from a TaskCreate tool_result. Prefer the structured field; fall back
 // to parsing "Task #N" from a string result.
-export function readClaudeTaskCreateId(ev, block) {
+function readClaudeTaskCreateId(ev, block) {
     const structured = ev?.toolUseResult?.task?.id;
     if (structured != null && String(structured).trim())
         return String(structured).trim();
@@ -967,7 +998,7 @@ export function readClaudeTaskCreateId(ev, block) {
     }
     return null;
 }
-export function rebuildClaudeTaskPlan(s) {
+function rebuildClaudeTaskPlan(s) {
     if (!Array.isArray(s?.taskOrder) || !s.taskOrder.length)
         return null;
     const steps = [];
@@ -989,7 +1020,7 @@ export function rebuildClaudeTaskPlan(s) {
 // Used when the id isn't in the TaskCreate store, so an update issued AFTER a TodoWrite still
 // lands on the displayed list — the plan reflects the state after the LAST change, whichever
 // mechanism wrote it. Returns a fresh plan (never mutates) or null when inapplicable.
-export function applyTaskUpdateToTodoPlan(plan, taskId, rawStatus) {
+function applyTaskUpdateToTodoPlan(plan, taskId, rawStatus) {
     if (!plan || !Array.isArray(plan.steps) || !plan.steps.length)
         return null;
     if (!/^\d+$/.test(taskId))
@@ -1013,7 +1044,7 @@ export function applyTaskUpdateToTodoPlan(plan, taskId, rawStatus) {
 // Turns a Claude tool_use {name,input} into a one-line human summary. The runtime's
 // activity projector joins these into snapshot.activity; the structured form lives in
 // toolCalls. Kept driver-local: knowing Claude's tool input shapes is the driver's job.
-export function shortToolValue(value, max = 140) {
+function shortToolValue(value, max = 140) {
     if (value == null)
         return '';
     const text = (typeof value === 'string' ? value : String(value)).replace(/\s+/g, ' ').trim();
@@ -1025,7 +1056,7 @@ function toolInputDetail(name, input) {
     const i = input || {};
     return i.command || i.file_path || i.path || i.pattern || i.query || i.url || i.description || '';
 }
-export function summarizeToolUse(name, input) {
+function summarizeToolUse(name, input) {
     const tool = String(name || '').trim() || 'Tool';
     const i = input || {};
     const description = shortToolValue(i.description, 120);
@@ -1090,7 +1121,7 @@ export function summarizeToolUse(name, input) {
     }
 }
 // First non-empty line of a tool_result content (string | block[]), for the "summary -> detail" form.
-export function firstResultLine(content) {
+function firstResultLine(content) {
     let text = '';
     if (typeof content === 'string')
         text = content;

package/packages/kernel/dist/drivers/codex.d.ts

@@ -1,5 +1,4 @@
 import type { AgentDriver, AgentTurnInput, DriverContext, DriverEvent, DriverResult, TuiInput, TuiSpec, NativeSessionInfo } from '../contracts/driver.js';
-import type { UniversalUsage } from '../protocol/index.js';
 export declare function codexToolSummary(item: any): {
     id: string;
     name: string;
@@ -34,12 +33,3 @@ export declare class CodexDriver implements AgentDriver {
         limit?: number;
     }): NativeSessionInfo[];
 }
-export interface CodexUsageState {
-    input: number | null;
-    output: number | null;
-    cached: number | null;
-    contextUsed?: number | null;
-    contextWindow?: number | null;
-}
-export declare function applyCodexTokenUsage(s: CodexUsageState, rawUsage: any): void;
-export declare function codexUsageOf(s: CodexUsageState): UniversalUsage;

package/packages/kernel/dist/drivers/codex.js

@@ -1,112 +1,6 @@
-import { spawn } from 'node:child_process';
-import { discoverCodexNativeSessions } from '../workspace/native.js';
-// Minimal newline-delimited JSON-RPC client for `codex app-server` (ported faithfully
-// from pikiloom's CodexAppServer; trimmed to what the kernel needs).
-class AppServer {
-    bin;
-    configOverrides;
-    env;
-    proc = null;
-    buf = '';
-    nextId = 1;
-    pending = new Map();
-    notify;
-    requestResponder;
-    constructor(bin, configOverrides, env) {
-        this.bin = bin;
-        this.configOverrides = configOverrides;
-        this.env = env;
-    }
-    onNotification(cb) { this.notify = cb; }
-    onServerRequest(cb) { this.requestResponder = cb; }
-    async start() {
-        const args = ['app-server'];
-        // Do NOT force model_reasoning_summary — codex reasoning summaries stay OFF by default
-        // (respecting ~/.codex/config.toml, which is the original behavior). A caller that wants
-        // thinking can pass `model_reasoning_summary=...` via configOverrides; we never inject it.
-        const overrides = [...this.configOverrides];
-        if (!overrides.some(c => /^features\.goals\s*=/.test(c)))
-            overrides.push('features.goals=true');
-        for (const c of overrides)
-            args.push('-c', c);
-        try {
-            this.proc = spawn(this.bin, args, { stdio: ['pipe', 'pipe', 'pipe'], env: this.env ? { ...process.env, ...this.env } : process.env });
-        }
-        catch {
-            return false;
-        }
-        this.proc.stdout.on('data', (chunk) => this.onData(chunk));
-        this.proc.on('close', () => { for (const cb of this.pending.values())
-            cb({ error: { message: 'app-server exited' } }); this.pending.clear(); });
-        this.proc.on('error', () => { });
-        const init = await this.call('initialize', { clientInfo: { name: '@pikiloom/kernel', version: '0.1.0' }, capabilities: { experimentalApi: true } }, 15_000);
-        return !init.error;
-    }
-    onData(chunk) {
-        this.buf += chunk.toString('utf8');
-        const lines = this.buf.split('\n');
-        this.buf = lines.pop() || '';
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            let msg;
-            try {
-                msg = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (msg.method && msg.id != null) { // server -> client request
-                const id = msg.id;
-                Promise.resolve(this.requestResponder ? this.requestResponder(msg.method, msg.params ?? {}, id) : {})
-                    .then((result) => this.respond(id, result ?? {}))
-                    .catch(() => this.respond(id, {}));
-            }
-            else if (msg.id != null) { // response to our call
-                const cb = this.pending.get(msg.id);
-                if (cb) {
-                    this.pending.delete(msg.id);
-                    cb(msg);
-                }
-            }
-            else if (msg.method) { // notification
-                this.notify?.(msg.method, msg.params ?? {});
-            }
-        }
-    }
-    call(method, params, timeoutMs = 60_000) {
-        return new Promise((resolve) => {
-            if (!this.proc || this.proc.killed) {
-                resolve({ error: { message: 'not connected' } });
-                return;
-            }
-            const id = this.nextId++;
-            const timer = setTimeout(() => { this.pending.delete(id); resolve({ error: { message: `RPC '${method}' timed out` } }); }, timeoutMs);
-            this.pending.set(id, (m) => { clearTimeout(timer); resolve(m); });
-            const msg = { jsonrpc: '2.0', id, method };
-            if (params !== undefined)
-                msg.params = params;
-            try {
-                this.proc.stdin.write(JSON.stringify(msg) + '\n');
-            }
-            catch {
-                clearTimeout(timer);
-                this.pending.delete(id);
-                resolve({ error: { message: 'write failed' } });
-            }
-        });
-    }
-    respond(id, result) {
-        try {
-            this.proc?.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
-        }
-        catch { /* closed */ }
-    }
-    kill() { try {
-        this.proc?.kill('SIGTERM');
-    }
-    catch { /* ignore */ } this.proc = null; }
-}
+import { discoverCodexNativeSessions } from './native.js';
+import { StdioRpcClient } from './rpc.js';
+import { attachedFileNote, contextPercent, imageMimeForFile, wireAbort } from './shared.js';
 function planFromUpdate(params) {
     const rawSteps = Array.isArray(params?.plan?.steps) ? params.plan.steps : Array.isArray(params?.steps) ? params.steps : Array.isArray(params?.plan) ? params.plan : [];
     const steps = rawSteps.map((st) => {
@@ -247,16 +141,23 @@ export class CodexDriver {
         // BYOK provider routing arrives as `-c key=value` overrides; pass them through so the
         // kernel path keeps third-party models (e.g. glm via OpenRouter) instead of falling back
         // to the native account.
-        const config = [...(input.configOverrides || [])];
-        const srv = new AppServer(this.bin, config, input.env);
+        // Do NOT force model_reasoning_summary — codex reasoning summaries stay OFF by default
+        // (respecting ~/.codex/config.toml, which is the original behavior). A caller that wants
+        // thinking can pass `model_reasoning_summary=...` via configOverrides; we never inject it.
+        const overrides = [...(input.configOverrides || [])];
+        if (!overrides.some(c => /^features\.goals\s*=/.test(c)))
+            overrides.push('features.goals=true');
+        const args = ['app-server'];
+        for (const c of overrides)
+            args.push('-c', c);
+        const srv = new StdioRpcClient({ command: this.bin, args, env: input.env, label: 'codex app-server' });
         const state = { text: '', reasoning: '', streamedReasoning: false, msgs: [], thinkParts: [], sessionId: input.sessionId ?? null, input: null, output: null, cached: null, contextUsed: null, contextWindow: null, status: null, error: null, turnId: null };
         const phases = new Map();
         const toolSummaries = new Map();
         const deltaItems = new Set();
         let lastTextItemId = null;
         let steerRegistered = false;
-        const ok = await srv.start();
-        if (!ok)
+        if (!srv.start())
             return { ok: false, text: '', error: 'failed to start codex app-server', stopReason: 'error' };
         let settle = () => { };
         const turnDone = new Promise((res) => { settle = res; });
@@ -264,20 +165,19 @@ export class CodexDriver {
         // srv.kill() (SIGTERM) never produces a turn/completed notification, so without this explicit
         // settle() the `await turnDone` below hangs forever — run() never resolves and the task stays
         // "running" in the orchestrator even though the codex process is already dead ("停止不掉，但实际上已经停了").
-        const onAbort = () => {
+        wireAbort(ctx.signal, () => {
             if (state.sessionId && state.turnId) {
-                srv.call('turn/interrupt', { threadId: state.sessionId, turnId: state.turnId }, 5_000).finally(() => settle());
+                srv.request('turn/interrupt', { threadId: state.sessionId, turnId: state.turnId }, 5_000).finally(() => settle());
             }
             else {
                 srv.kill();
                 settle();
             }
-        };
-        if (ctx.signal.aborted)
-            onAbort();
-        else
-            ctx.signal.addEventListener('abort', onAbort, { once: true });
+        });
         try {
+            const init = await srv.request('initialize', { clientInfo: { name: '@pikiloom/kernel', version: '0.1.0' }, capabilities: { experimentalApi: true } }, 15_000);
+            if (init.error)
+                return { ok: false, text: '', error: 'failed to start codex app-server', stopReason: 'error' };
             const threadParams = { cwd: input.workdir, model: input.model || null };
             if (input.systemPrompt)
                 threadParams.developerInstructions = input.systemPrompt;
@@ -286,8 +186,8 @@ export class CodexDriver {
                 threadParams.sandbox = 'danger-full-access';
             }
             const threadResp = input.sessionId
-                ? await srv.call('thread/resume', { threadId: input.sessionId, ...threadParams })
-                : await srv.call('thread/start', threadParams);
+                ? await srv.request('thread/resume', { threadId: input.sessionId, ...threadParams })
+                : await srv.request('thread/start', threadParams);
             if (threadResp.error)
                 return { ok: false, text: '', error: threadResp.error.message || 'thread/start failed', stopReason: 'error' };
             const threadId = threadResp.result?.thread?.id ?? input.sessionId ?? null;
@@ -306,7 +206,7 @@ export class CodexDriver {
                             ctx.registerSteer(async (prompt, attachments = []) => {
                                 if (!state.sessionId || !state.turnId)
                                     return false;
-                                const r = await srv.call('turn/steer', { threadId: state.sessionId, expectedTurnId: state.turnId, input: buildTurnInput(prompt, attachments) }, 30_000);
+                                const r = await srv.request('turn/steer', { threadId: state.sessionId, expectedTurnId: state.turnId, input: buildTurnInput(prompt, attachments) }, 30_000);
                                 if (r.error)
                                     return false;
                                 state.turnId = r.result?.turnId ?? state.turnId;
@@ -400,22 +300,28 @@ export class CodexDriver {
                 }
             });
             // Codex server->client requests: route user-input to the HITL seam (ctx.askUser),
-            // accept approvals by default (parity with the legacy codex driver).
-            srv.onServerRequest(async (method, params, id) => {
-                if (method === 'item/tool/requestUserInput') {
-                    const interaction = codexUserInputToInteraction(params, `codex-input-${id}`);
-                    if (!interaction)
-                        return { answers: {} };
-                    const answers = await ctx.askUser(interaction);
-                    return { answers: Object.fromEntries(Object.entries(answers).map(([qid, vals]) => [qid, { answers: vals }])) };
+            // accept approvals by default (parity with the legacy codex driver). Never throw —
+            // an unanswerable request degrades to an empty response, not a JSON-RPC error.
+            srv.onRequest(async (method, params, id) => {
+                try {
+                    if (method === 'item/tool/requestUserInput') {
+                        const interaction = codexUserInputToInteraction(params, `codex-input-${id}`);
+                        if (!interaction)
+                            return { answers: {} };
+                        const answers = await ctx.askUser(interaction);
+                        return { answers: Object.fromEntries(Object.entries(answers).map(([qid, vals]) => [qid, { answers: vals }])) };
+                    }
+                    if (method === 'item/commandExecution/requestApproval' || method === 'item/fileChange/requestApproval')
+                        return { decision: 'accept' };
+                    if (method === 'item/permissions/requestApproval')
+                        return { permissions: {}, scope: 'turn' };
+                    return {};
+                }
+                catch {
+                    return {};
                 }
-                if (method === 'item/commandExecution/requestApproval' || method === 'item/fileChange/requestApproval')
-                    return { decision: 'accept' };
-                if (method === 'item/permissions/requestApproval')
-                    return { permissions: {}, scope: 'turn' };
-                return {};
             });
-            const turnResp = await srv.call('turn/start', {
+            const turnResp = await srv.request('turn/start', {
                 threadId: state.sessionId,
                 input: buildTurnInput(input.prompt, input.attachments || []),
                 model: input.model || undefined,
@@ -453,12 +359,10 @@ export class CodexDriver {
         return discoverCodexNativeSessions(opts.workdir, { limit: opts.limit });
     }
 }
-const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp']);
 function buildTurnInput(prompt, attachments) {
     const input = [];
     for (const f of attachments) {
-        const ext = f.slice(f.lastIndexOf('.')).toLowerCase();
-        input.push(IMAGE_EXTS.has(ext) ? { type: 'localImage', path: f } : { type: 'text', text: `[Attached file: ${f}]` });
+        input.push(imageMimeForFile(f) ? { type: 'localImage', path: f } : { type: 'text', text: attachedFileNote(f) });
     }
     input.push({ type: 'text', text: prompt });
     return input;
@@ -486,7 +390,7 @@ function codexContextUsed(raw) {
 }
 // Fold a codex tokenUsage payload into driver state: last-turn counts, context
 // occupancy, and the model window. Tolerant of nested {info:{…}} and flat shapes.
-export function applyCodexTokenUsage(s, rawUsage) {
+function applyCodexTokenUsage(s, rawUsage) {
     if (!rawUsage || typeof rawUsage !== 'object')
         return;
     const info = rawUsage.info && typeof rawUsage.info === 'object' ? rawUsage.info : rawUsage;
@@ -521,18 +425,17 @@ export function applyCodexTokenUsage(s, rawUsage) {
     if (cw != null && cw > 0)
         s.contextWindow = cw;
 }
-export function codexUsageOf(s) {
+function codexUsageOf(s) {
     const fallback = (s.input ?? 0) + (s.cached ?? 0);
     const used = s.contextUsed ?? (fallback > 0 ? fallback : null);
     const window = s.contextWindow ?? null;
-    const contextPercent = used != null && window ? Math.min(99.9, Math.round((used / window) * 1000) / 10) : null;
     const turnOutput = s.output ?? 0;
     return {
         inputTokens: s.input,
         outputTokens: s.output,
         cachedInputTokens: s.cached,
         contextUsedTokens: used,
-        contextPercent,
+        contextPercent: contextPercent(used, window),
         turnOutputTokens: turnOutput > 0 ? turnOutput : null,
     };
 }