@pikiloom/kernel 0.2.8 → 0.2.10

package/dist/drivers/claude.d.ts

@@ -25,8 +25,10 @@ export interface ClaudeUsageState {
     cacheCreation?: number | null;
     contextWindow?: number | null;
     turnOutputTokensBase?: number | null;
+    thinkingEstTokens?: number | null;
 }
 export declare function claudeUsageOf(s: ClaudeUsageState): UniversalUsage;
+export declare function applyClaudeThinkingEstimate(s: any, ev: any): boolean;
 export declare function claudeContextWindowFromModel(model: unknown): number | null;
 export declare function claudeEffectiveContextWindow(advertised: number | null): number | null;
 export declare function handleClaudeEvent(ev: any, s: any, emit: (e: DriverEvent) => void): void;

package/dist/drivers/claude.js

@@ -60,7 +60,7 @@ export class ClaudeDriver {
             stopReason: null, error: null,
             input: null, output: null, cached: null,
             cacheCreation: null,
-            contextWindow: null, turnOutputTokensBase: 0,
+            contextWindow: null, turnOutputTokensBase: 0, thinkingEstTokens: 0,
             subAgents: new Map(),
             tools: new Map(),
             taskList: new Map(),
@@ -288,10 +288,16 @@ export class ClaudeDriver {
     }
 }
 export function claudeUsageOf(s) {
-    const used = (s.input ?? 0) + (s.cached ?? 0) + (s.cacheCreation ?? 0) + (s.output ?? 0);
+    // 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
+    // outputTokens) so the row ticks during silent extended thinking; the real per-message
+    // 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) + (s.output ?? 0);
+    const turnOutput = (s.turnOutputTokensBase ?? 0) + effOutput;
     return {
         inputTokens: s.input,
         outputTokens: s.output,
@@ -301,6 +307,19 @@ export function claudeUsageOf(s) {
         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) {
+    const prev = s.thinkingEstTokens ?? 0;
+    const delta = Number(ev?.estimated_tokens_delta);
+    const total = Number(ev?.estimated_tokens);
+    if (Number.isFinite(delta) && delta > 0)
+        s.thinkingEstTokens = prev + delta;
+    else if (Number.isFinite(total))
+        s.thinkingEstTokens = Math.max(prev, total);
+    return (s.thinkingEstTokens ?? 0) > prev;
+}
 // 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.
@@ -359,6 +378,13 @@ export function handleClaudeEvent(ev, s, emit) {
         }
         s.model = ev.model ?? s.model;
         s.contextWindow = claudeEffectiveContextWindow(claudeContextWindowFromModel(s.model)) ?? s.contextWindow;
+        // Live thinking progress (system/thinking_tokens, ~every 1.4s of sustained thinking): during
+        // extended thinking a subscription account streams no plaintext (signature_delta only) and no
+        // usage until the message settles, so without projecting these the terminal shows a dead
+        // spinner for the whole thinking phase.
+        if (ev.subtype === 'thinking_tokens' && applyClaudeThinkingEstimate(s, ev)) {
+            emit({ type: 'usage', usage: claudeUsageOf(s) });
+        }
         return;
     }
     if (t === 'stream_event') {
@@ -368,11 +394,17 @@ export function handleClaudeEvent(ev, s, emit) {
             // Claude emits one message per tool-use round within a single turn. Carry the prior
             // message's output into the per-turn base, then reset to the new message's prompt size
             // so contextUsedTokens tracks current occupancy while turnOutputTokens sums the turn.
-            s.turnOutputTokensBase = (s.turnOutputTokensBase ?? 0) + (s.output ?? 0);
+            // A message that never delivered real output_tokens keeps its thinking estimate as the carry.
+            s.turnOutputTokensBase = (s.turnOutputTokensBase ?? 0) + Math.max(s.output ?? 0, s.thinkingEstTokens ?? 0);
             s.input = u?.input_tokens ?? 0;
             s.cached = u?.cache_read_input_tokens ?? 0;
             s.cacheCreation = u?.cache_creation_input_tokens ?? 0;
             s.output = 0;
+            s.thinkingEstTokens = 0;
+            // The prompt-side counts are known the moment the model accepts the request — emit them so
+            // the context row appears right away instead of only after the first message settles
+            // (minutes into a long silent thinking phase, the "looks stuck" report).
+            emit({ type: 'usage', usage: claudeUsageOf(s) });
         }
         else if (inner.type === 'content_block_start') {
             // Claude emits multiple text/thinking blocks per turn (one set per tool-use round). Insert a
@@ -407,8 +439,11 @@ export function handleClaudeEvent(ev, s, emit) {
         else if (inner.type === 'message_delta') {
             const u = inner.usage;
             if (u) {
-                if (u.output_tokens != null)
+                // Real reported output supersedes the live thinking estimate for this message.
+                if (u.output_tokens != null) {
                     s.output = u.output_tokens;
+                    s.thinkingEstTokens = 0;
+                }
                 if (u.input_tokens != null)
                     s.input = u.input_tokens;
                 if (u.cache_read_input_tokens != null)
@@ -515,8 +550,13 @@ export function handleClaudeEvent(ev, s, emit) {
         for (const b of contents) {
             if (b?.type !== 'tool_result')
                 continue;
-            emitClaudeImages(b.content || [], s, emit);
             const id = String(b.tool_use_id || '').trim();
+            // A Read result is the agent inspecting a file, not a deliverable — surfacing those spammed
+            // the chat with every image the agent looked at (the legacy driver has the same exclusion).
+            // Images from generating tools (MCP image-gen, screenshots, …) still surface as photos.
+            const tool = id ? s.tools?.get(id) : undefined;
+            if (tool?.name !== 'Read')
+                emitClaudeImages(b.content || [], s, emit);
             // TaskCreate result: the assigned task id arrives here; register the task and emit the plan.
             if (id && s.pendingTaskCreates?.has(id)) {
                 const pending = s.pendingTaskCreates.get(id);
@@ -534,7 +574,6 @@ export function handleClaudeEvent(ev, s, emit) {
                 }
                 continue;
             }
-            const tool = id ? s.tools?.get(id) : undefined;
             if (!tool)
                 continue;
             const isError = !!b.is_error;

package/dist/drivers/codex.js

@@ -137,6 +137,9 @@ function codexFileChangeSummary(item) {
 // fallback to `item.type` wrongly turned every item (incl. agentMessage/reasoning) into a bogus
 // "tool" in the Activity card. Mirrors the legacy driver's isCodexToolCallItem whitelist.
 const CODEX_TOOL_CALL_TYPES = new Set(['dynamicToolCall', 'mcpToolCall', 'collabAgentToolCall']);
+// 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']);
 export function codexToolSummary(item) {
     const id = String(item?.id || '');
     if (!id)
@@ -147,6 +150,20 @@ export function codexToolSummary(item) {
     }
     if (item.type === 'fileChange' || item.type === 'patch')
         return { id, name: 'edit', summary: codexFileChangeSummary(item) };
+    if (item.type === 'webSearch') {
+        // v2 webSearch items carry the query at top level and (on newer servers) an action
+        // (search / openPage / findInPage, snake_case on older ones). The query is often only
+        // known at item/completed — item/started may arrive query-less.
+        const action = item.action || {};
+        const kind = String(action.type || '');
+        const url = codexCommandPreview(action.url);
+        if ((kind === 'openPage' || kind === 'open_page') && url)
+            return { id, name: 'web_search', summary: `Open ${url}` };
+        if ((kind === 'findInPage' || kind === 'find_in_page') && url)
+            return { id, name: 'web_search', summary: `Find in ${url}` };
+        const query = codexCommandPreview(typeof item.query === 'string' && item.query.trim() ? item.query : action.query);
+        return { id, name: 'web_search', summary: query ? `Search web: ${query}` : 'Search web' };
+    }
     if (CODEX_TOOL_CALL_TYPES.has(item.type)) {
         const raw = typeof item.tool === 'string' && item.tool.trim() ? item.tool.trim()
             : typeof item.name === 'string' && item.name.trim() ? item.name.trim() : '';
@@ -343,8 +360,14 @@ export class CodexDriver {
                         else if (item.type === 'reasoning')
                             captureCodexReasoning(codexReasoningItemText(item), state, ctx.emit);
                         const t = codexToolSummary(item);
-                        if (t && toolSummaries.has(t.id))
-                            ctx.emit({ type: 'tool', call: { id: t.id, name: t.name, summary: toolSummaries.get(t.id) || t.summary, status: item.status === 'failed' ? 'failed' : 'done' } });
+                        if (t) {
+                            // 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' } });
+                        }
                         break;
                     }
                     case 'rawResponseItem/completed': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikiloom/kernel",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "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",