@pikiloom/kernel 0.2.8 → 0.2.9

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/package.json

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