@pikiloom/kernel 0.3.6 → 0.3.7

package/dist/drivers/claude.d.ts

@@ -24,7 +24,7 @@ export declare function claudeBgAgentHoldCapMs(): number;
 export declare function claudeTurnHasAgentBackground(s: any): boolean;
 export declare function claudeBgHoldRecheckMs(): number;
 export declare function claudeBgSettleQuietMs(): number;
-export declare function claudeModelStallMs(): number;
+export declare function claudeModelStallMs(effort?: string | null): number;
 export declare const CLAUDE_TRUNCATED_RECOVERY_PROMPT: string;
 export declare function claudeTruncatedRecoveryEnabled(): boolean;
 export declare function isClaudeSyntheticResumeNoise(text: string): boolean;

package/dist/drivers/claude.js

@@ -193,7 +193,7 @@ export class ClaudeDriver {
                         return;
                     }
                     settleResult({ stopReason: 'stalled', kill: false, ok: false });
-                }, claudeModelStallMs());
+                }, claudeModelStallMs(input.effort));
                 unref(modelStallTimer);
             };
             try {
@@ -801,15 +801,22 @@ export function claudeBgSettleQuietMs() {
     return Number.isFinite(raw) && raw > 0 ? raw : CLAUDE_BG_SETTLE_QUIET_DEFAULT_MS;
 }
 // How long the model may stay COMPLETELY silent after a tool_result (control handed back to it,
-// no background pending) before the driver gives up and settles the turn as 'stalled'. Deliberately
-// generous: legitimate silent extended-thinking (subscription accounts stream no thinking text) and
-// slow providers must not trip it, and a still-running tool never trips it (it has no tool_result
-// yet). This is the backstop for a turn that would otherwise hang forever with the answer never
-// delivered. Override with PIKILOOM_CLAUDE_MODEL_STALL_MS.
-const CLAUDE_MODEL_STALL_DEFAULT_MS = 120_000;
-export function claudeModelStallMs() {
+// no background pending) before the driver gives up and settles the turn as 'stalled'. Must be
+// generous: subscription accounts stream NO events during extended thinking, and at the reasoning
+// rungs a legitimate silent think regularly exceeds two minutes — the original 120s default
+// misfired on exactly that (settling a LIVE turn as 'stalled' and then killing its still-running
+// tool via the leak-guard; mirasim#111). A too-long window only means a truly hung turn shows its
+// dead spinner longer, so the costs are asymmetric — err long. Effort-laddered: the deep-reasoning
+// rungs (high and up) think the longest. A still-running tool never trips this (it has no
+// tool_result yet). Override with PIKILOOM_CLAUDE_MODEL_STALL_MS (wins over the ladder).
+const CLAUDE_MODEL_STALL_DEFAULT_MS = 300_000;
+const CLAUDE_MODEL_STALL_DEEP_MS = 600_000;
+const CLAUDE_DEEP_REASONING_EFFORTS = new Set(['high', 'xhigh', 'max', 'ultra']);
+export function claudeModelStallMs(effort) {
     const raw = Number(process.env.PIKILOOM_CLAUDE_MODEL_STALL_MS);
-    return Number.isFinite(raw) && raw > 0 ? raw : CLAUDE_MODEL_STALL_DEFAULT_MS;
+    if (Number.isFinite(raw) && raw > 0)
+        return raw;
+    return effort && CLAUDE_DEEP_REASONING_EFFORTS.has(effort) ? CLAUDE_MODEL_STALL_DEEP_MS : CLAUDE_MODEL_STALL_DEFAULT_MS;
 }
 // In-process self-heal for a truncated turn: when a clean result lands while the tool loop is
 // still dangling (the model's closing round came back empty), the stdin is still open — inject

package/dist/drivers/codex.d.ts

@@ -1,9 +1,12 @@
 import type { AgentDriver, AgentTurnInput, DriverContext, DriverEvent, DriverResult, TuiInput, TuiSpec, NativeSessionInfo } from '../contracts/driver.js';
+import type { UniversalToolCall } from '../protocol/index.js';
 export declare function codexToolSummary(item: any): {
     id: string;
     name: string;
     summary: string;
 } | null;
+/** Project one app-server item into the kernel's rich, expandable tool-call shape. */
+export declare function codexToolCall(item: any, fallbackStatus: UniversalToolCall['status']): UniversalToolCall | null;
 export interface CodexContentState {
     text: string;
     reasoning: string;

package/dist/drivers/codex.js

@@ -34,6 +34,89 @@ const CODEX_TOOL_CALL_TYPES = new Set(['dynamicToolCall', 'mcpToolCall', 'collab
 // Field-less placeholder summaries — a completed item with only one of these never overrides
 // a more specific summary cached at item/started.
 const CODEX_GENERIC_TOOL_SUMMARIES = new Set(['Search web', 'Run shell command', 'Edit files', 'Use tool']);
+const CODEX_TOOL_INPUT_MAX = 4 * 1024;
+const CODEX_TOOL_RESULT_MAX = 12 * 1024;
+function codexToolText(value, max) {
+    if (value == null)
+        return null;
+    let text;
+    if (typeof value === 'string')
+        text = value;
+    else {
+        try {
+            text = JSON.stringify(value, null, 2);
+        }
+        catch {
+            text = String(value);
+        }
+    }
+    text = text.replace(/\r\n/g, '\n').trim();
+    if (!text)
+        return null;
+    return text.length <= max ? text : `${text.slice(0, max).trimEnd()}\n… (truncated)`;
+}
+function codexToolInput(item) {
+    switch (item?.type) {
+        case 'commandExecution': {
+            const command = Array.isArray(item.command) ? item.command.join(' ') : item.command;
+            if (!command)
+                return null;
+            const detail = { command };
+            if (typeof item.cwd === 'string' && item.cwd.trim())
+                detail.cwd = item.cwd;
+            return codexToolText(detail, CODEX_TOOL_INPUT_MAX);
+        }
+        case 'fileChange':
+        case 'patch':
+            return codexToolText(item.changes ?? item.patch ?? item.diff, CODEX_TOOL_INPUT_MAX);
+        case 'mcpToolCall':
+        case 'dynamicToolCall':
+            return codexToolText(item.arguments ?? item.input, CODEX_TOOL_INPUT_MAX);
+        case 'collabAgentToolCall':
+            return codexToolText({
+                prompt: item.prompt ?? undefined,
+                model: item.model ?? undefined,
+                reasoningEffort: item.reasoningEffort ?? item.reasoning_effort ?? undefined,
+                receiverThreadIds: item.receiverThreadIds ?? item.receiver_thread_ids ?? undefined,
+            }, CODEX_TOOL_INPUT_MAX);
+        case 'webSearch':
+            return codexToolText(item.action ?? item.query, CODEX_TOOL_INPUT_MAX);
+        default:
+            return null;
+    }
+}
+function codexToolResult(item) {
+    if (item?.type === 'commandExecution') {
+        const output = codexToolText(item.aggregatedOutput ?? item.aggregated_output, CODEX_TOOL_RESULT_MAX);
+        const exitCode = item.exitCode ?? item.exit_code;
+        if (output && typeof exitCode === 'number' && exitCode !== 0)
+            return `${output}\n\n(exit code ${exitCode})`;
+        if (output)
+            return output;
+        return typeof exitCode === 'number' && exitCode !== 0 ? `exit code ${exitCode}` : null;
+    }
+    if (item?.type === 'mcpToolCall') {
+        const error = item.error?.message ?? item.error;
+        if (error)
+            return codexToolText(error, CODEX_TOOL_RESULT_MAX);
+        return codexToolText(item.result, CODEX_TOOL_RESULT_MAX);
+    }
+    if (item?.type === 'dynamicToolCall') {
+        return codexToolText(item.contentItems ?? item.content_items, CODEX_TOOL_RESULT_MAX);
+    }
+    if (item?.type === 'collabAgentToolCall') {
+        return codexToolText(item.agentsStates ?? item.agents_states, CODEX_TOOL_RESULT_MAX);
+    }
+    return null;
+}
+function codexToolStatus(item, fallback) {
+    const raw = String(item?.status || '').toLowerCase();
+    if (raw === 'failed' || raw === 'declined' || item?.success === false || item?.error)
+        return 'failed';
+    if (raw === 'completed' || raw === 'done' || item?.success === true)
+        return 'done';
+    return fallback;
+}
 export function codexToolSummary(item) {
     const id = String(item?.id || '');
     if (!id)
@@ -66,6 +149,27 @@ export function codexToolSummary(item) {
     }
     return null;
 }
+/** Project one app-server item into the kernel's rich, expandable tool-call shape. */
+export function codexToolCall(item, fallbackStatus) {
+    const base = codexToolSummary(item);
+    if (!base)
+        return null;
+    return {
+        ...base,
+        input: codexToolInput(item),
+        result: codexToolResult(item),
+        status: codexToolStatus(item, fallbackStatus),
+    };
+}
+function appendCodexToolOutput(previous, delta) {
+    if (typeof delta !== 'string' || !delta)
+        return previous ?? null;
+    const next = `${previous ?? ''}${delta}`.replace(/\r\n/g, '\n');
+    if (next.length <= CODEX_TOOL_RESULT_MAX)
+        return next;
+    const marker = '… (earlier output truncated)\n';
+    return marker + next.slice(-(CODEX_TOOL_RESULT_MAX - marker.length));
+}
 // codex `item/tool/requestUserInput` params -> a normalized UniversalInteraction
 // (faithful to the legacy codex driver's toAgentInteraction shape).
 function codexUserInputToInteraction(params, promptId) {
@@ -153,7 +257,7 @@ export class CodexDriver {
         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 toolCalls = new Map();
         const deltaItems = new Set();
         let lastTextItemId = null;
         let steerRegistered = false;
@@ -218,13 +322,35 @@ export class CodexDriver {
                         const item = params?.item || {};
                         if (item.type === 'agentMessage' && item.id)
                             phases.set(item.id, item.phase || 'final_answer');
-                        const t = codexToolSummary(item);
-                        if (t && !toolSummaries.has(t.id)) {
-                            toolSummaries.set(t.id, t.summary);
-                            ctx.emit({ type: 'tool', call: { id: t.id, name: t.name, summary: t.summary, status: 'running' } });
+                        const call = codexToolCall(item, 'running');
+                        if (call && !toolCalls.has(call.id)) {
+                            toolCalls.set(call.id, call);
+                            ctx.emit({ type: 'tool', call });
                         }
                         break;
                     }
+                    case 'item/commandExecution/outputDelta':
+                    case 'item/fileChange/outputDelta': {
+                        const id = String(params?.itemId || '');
+                        const previous = toolCalls.get(id);
+                        if (!previous)
+                            break;
+                        const call = { ...previous, result: appendCodexToolOutput(previous.result, params?.delta) };
+                        toolCalls.set(id, call);
+                        ctx.emit({ type: 'tool', call });
+                        break;
+                    }
+                    case 'item/fileChange/patchUpdated': {
+                        const id = String(params?.itemId || '');
+                        const projected = codexToolCall({ type: 'fileChange', id, changes: params?.changes }, 'running');
+                        if (!projected)
+                            break;
+                        const previous = toolCalls.get(id);
+                        const call = previous ? { ...previous, ...projected, result: projected.result ?? previous.result } : projected;
+                        toolCalls.set(id, call);
+                        ctx.emit({ type: 'tool', call });
+                        break;
+                    }
                     case 'item/agentMessage/delta': {
                         if (!params?.delta)
                             break;
@@ -259,14 +385,26 @@ export class CodexDriver {
                             captureCodexAgentMessage(item, state, deltaItems, phases, ctx.emit);
                         else if (item.type === 'reasoning')
                             captureCodexReasoning(codexReasoningItemText(item), state, ctx.emit);
-                        const t = codexToolSummary(item);
-                        if (t) {
+                        const projected = codexToolCall(item, 'done');
+                        if (projected) {
                             // Prefer the completed item's summary when it is specific — webSearch carries its
                             // query only at completion (item/started may be query-less or absent entirely,
-                            // so no `toolSummaries.has` gate: a completed-only tool still gets its row).
-                            const summary = !CODEX_GENERIC_TOOL_SUMMARIES.has(t.summary) ? t.summary : (toolSummaries.get(t.id) || t.summary);
-                            toolSummaries.set(t.id, summary);
-                            ctx.emit({ type: 'tool', call: { id: t.id, name: t.name, summary, status: item.status === 'failed' ? 'failed' : 'done' } });
+                            // so a completed-only tool still gets its row).
+                            const previous = toolCalls.get(projected.id);
+                            const summary = !CODEX_GENERIC_TOOL_SUMMARIES.has(projected.summary)
+                                ? projected.summary
+                                : (previous?.summary || projected.summary);
+                            const call = {
+                                ...previous,
+                                ...projected,
+                                summary,
+                                input: projected.input ?? previous?.input ?? null,
+                                // Some app-server versions stream output deltas but omit aggregatedOutput on the
+                                // terminal item. Preserve the accumulated live result in that case.
+                                result: projected.result ?? previous?.result ?? null,
+                            };
+                            toolCalls.set(call.id, call);
+                            ctx.emit({ type: 'tool', call });
                         }
                         break;
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikiloom/kernel",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "description": "Heterogeneous coding agents (Claude / Codex / Gemini / ACP) -> an interaction-friendly, accumulating session snapshot + control handle, over pluggable surfaces (IM, Web, tunnel, TUI). The reusable core pikiloom itself is built on.",
   "type": "module",
   "license": "MIT",