pikiloom 0.4.48 → 0.4.50

package/dist/agent/drivers/claude.js

@@ -195,10 +195,25 @@ function recomputeClaudeContextUsed(s) {
         input: s.inputTokens,
         cached: s.cachedInputTokens,
         cacheCreation: s.cacheCreationInputTokens,
-        output: s.outputTokens,
+        // While a message is still streaming, the CLI's live thinking estimate is often the only
+        // output signal (subscription accounts stream no plaintext thinking and no usage until the
+        // message settles); the real output_tokens supersedes it at message_delta.
+        output: Math.max(s.outputTokens ?? 0, s.thinkingEstTokens ?? 0),
     });
     s.contextUsedTokens = total > 0 ? total : null;
 }
+// Accumulate the CLI's live thinking-token estimate (system/thinking_tokens events). 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.
+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);
+}
 const CLAUDE_FILE_READING_TOOLS = new Set(['Read']);
 function isClaudeFileReadingTool(toolName) {
     return !!toolName && CLAUDE_FILE_READING_TOOLS.has(toolName);
@@ -410,16 +425,25 @@ export function claudeParse(ev, s) {
             const advertised = claudeContextWindowFromModel(s.model);
             s.contextWindow = claudeEffectiveContextWindow(advertised) ?? s.contextWindow;
         }
+        // Live thinking progress: during extended thinking a subscription account streams no
+        // plaintext (signature_delta only) and no usage until the message settles — these estimates
+        // are the only sign the model is working.
+        if (ev.subtype === 'thinking_tokens') {
+            applyClaudeThinkingEstimate(s, ev);
+            recomputeClaudeContextUsed(s);
+        }
     }
     if (t === 'stream_event') {
         const inner = ev.event || {};
         if (inner.type === 'message_start') {
             const u = inner.message?.usage;
-            s.turnOutputTokensBase = (s.turnOutputTokensBase ?? 0) + (s.outputTokens ?? 0);
+            // A message that never delivered real output_tokens keeps its thinking estimate as the carry.
+            s.turnOutputTokensBase = (s.turnOutputTokensBase ?? 0) + Math.max(s.outputTokens ?? 0, s.thinkingEstTokens ?? 0);
             s.inputTokens = u?.input_tokens ?? 0;
             s.cachedInputTokens = u?.cache_read_input_tokens ?? 0;
             s.cacheCreationInputTokens = u?.cache_creation_input_tokens ?? 0;
             s.outputTokens = 0;
+            s.thinkingEstTokens = 0;
             recomputeClaudeContextUsed(s);
         }
         if (inner.type === 'content_block_start') {
@@ -449,8 +473,11 @@ export function claudeParse(ev, s) {
                     s.cachedInputTokens = u.cache_read_input_tokens;
                 if (u.cache_creation_input_tokens != null)
                     s.cacheCreationInputTokens = u.cache_creation_input_tokens;
-                if (u.output_tokens != null)
+                // Real reported output supersedes the live thinking estimate for this message.
+                if (u.output_tokens != null) {
                     s.outputTokens = u.output_tokens;
+                    s.thinkingEstTokens = 0;
+                }
                 recomputeClaudeContextUsed(s);
             }
         }
@@ -684,6 +711,7 @@ export function createClaudeStreamState(opts) {
         cachedInputTokens: null,
         cacheCreationInputTokens: null,
         turnOutputTokensBase: 0,
+        thinkingEstTokens: 0,
         turnUsageMsgId: null,
         contextWindow: byokWindow,
         byokContextWindow: byokWindow,
@@ -719,6 +747,7 @@ function resetClaudeTurnState(s, note) {
     s.inputTokens = null;
     s.outputTokens = null;
     s.turnOutputTokensBase = 0;
+    s.thinkingEstTokens = 0;
     s.turnUsageMsgId = null;
     s.cachedInputTokens = null;
     s.cacheCreationInputTokens = null;
@@ -1758,7 +1787,7 @@ function hydrateSubAgentBlocksFromSidecar(richMsgs, subAgentsDir) {
 const CLAUDE_MODELS = [
     { id: 'claude-fable-5', alias: 'fable' },
     { id: 'claude-opus-4-8', alias: 'opus' },
-    { id: 'claude-sonnet-4-6', alias: 'sonnet' },
+    { id: 'claude-sonnet-5', alias: 'sonnet' },
     { id: 'claude-haiku-4-5-20251001', alias: 'haiku' },
 ];
 const CLAUDE_USAGE_QUERY_TTL_MS = 5 * 60_000;
@@ -1856,6 +1885,42 @@ async function fetchClaudeUsageFromOAuth(tokenOverride) {
         clearTimeout(timer);
     }
 }
+// Single read channel for the native / default-login quota (`/api/oauth/usage` with the keychain
+// token). The read costs no inference tokens but the endpoint RATE-LIMITS aggressive polling
+// (observed: `rate_limit_error` payloads, which parse to null) — so `fresh` re-reads only after
+// 15s, and a failed read backs off 60s serving the last good result. Concurrent callers share
+// one request.
+const NATIVE_USAGE_FRESH_TTL_MS = 15_000;
+const NATIVE_USAGE_RETRY_TTL_MS = 60_000;
+const claudeNativeUsageLive = { at: 0, failedAt: 0, inflight: null };
+export function claudeNativeUsage(opts) {
+    const maxAge = opts?.fresh ? NATIVE_USAGE_FRESH_TTL_MS : CLAUDE_USAGE_QUERY_TTL_MS;
+    const now = Date.now();
+    if (claudeUsageCache.lastGood && now - claudeNativeUsageLive.at < maxAge) {
+        return Promise.resolve(claudeUsageCache.lastGood);
+    }
+    if (now - claudeNativeUsageLive.failedAt < NATIVE_USAGE_RETRY_TTL_MS) {
+        return Promise.resolve(claudeUsageCache.lastGood);
+    }
+    if (claudeNativeUsageLive.inflight)
+        return claudeNativeUsageLive.inflight;
+    const p = fetchClaudeUsageFromOAuth()
+        .then(fresh => {
+        if (fresh) {
+            claudeUsageCache.lastGood = fresh;
+            claudeUsageCache.lastAttemptAt = Date.now();
+            claudeNativeUsageLive.at = Date.now();
+            claudeNativeUsageLive.failedAt = 0;
+        }
+        else {
+            claudeNativeUsageLive.failedAt = Date.now();
+        }
+        return fresh ?? claudeUsageCache.lastGood;
+    })
+        .finally(() => { claudeNativeUsageLive.inflight = null; });
+    claudeNativeUsageLive.inflight = p;
+    return p;
+}
 // Per-account usage for a specific account's `claude setup-token`.
 //
 // IMPORTANT: setup-tokens are minted with the `user:inference` scope only — they do NOT carry
@@ -1864,10 +1929,15 @@ async function fetchClaudeUsageFromOAuth(tokenOverride) {
 // there because it's a full login. So for account tokens we read the limit state from the
 // `anthropic-ratelimit-unified-*` *response headers* of a tiny inference call instead — those
 // headers come back on every `/v1/messages` response regardless of scope, and are exactly what
-// Claude Code itself uses to learn 5h / 7d limits. Cost is ~1 output token per probe, cached
-// for 5min per token (60s back-off on failure), with in-flight de-dup so concurrent surfaces
-// (cards + header + IM) share one probe.
+// Claude Code itself uses to learn 5h / 7d limits. Cost is ~1 output token per probe, so reads
+// are tiered by how fresh the caller needs to be:
+//   default -> 5min TTL (background warmers, non-interactive surfaces)
+//   fresh   -> 20s min re-probe interval (user is actively looking at the numbers)
+//   force   -> bypass everything (identity just changed, e.g. account switch)
+// Failures back off 60s on the default/fresh tiers (force still retries), and in-flight de-dup
+// makes concurrent surfaces (cards + header + IM) share one probe.
 const TOKEN_USAGE_OK_TTL_MS = CLAUDE_USAGE_QUERY_TTL_MS;
+const TOKEN_USAGE_FRESH_TTL_MS = 20_000;
 const TOKEN_USAGE_RETRY_TTL_MS = 60_000;
 const CLAUDE_USAGE_PROBE_MODEL = 'claude-haiku-4-5-20251001';
 const claudeTokenUsageCache = new Map();
@@ -1939,7 +2009,9 @@ export function claudeUsageForToken(token, opts) {
     const now = Date.now();
     const cached = claudeTokenUsageCache.get(t);
     if (cached && !opts?.force) {
-        const ttl = cached.ok ? TOKEN_USAGE_OK_TTL_MS : TOKEN_USAGE_RETRY_TTL_MS;
+        const ttl = cached.ok
+            ? (opts?.fresh ? TOKEN_USAGE_FRESH_TTL_MS : TOKEN_USAGE_OK_TTL_MS)
+            : TOKEN_USAGE_RETRY_TTL_MS;
         if (now - cached.at < ttl)
             return Promise.resolve(cached.value);
     }
@@ -2230,21 +2302,16 @@ class ClaudeDriver {
         }
         return claudeUsageCache.lastGood ?? telemetry();
     }
-    // Live usage for the agent-status surface. Unlike getUsage it ignores the 5-min query TTL and
-    // always re-probes, so a freshly-switched login (the keychain default-login token changed) is
-    // reflected promptly instead of serving the previous account's frozen `lastGood`. Bounded by
-    // the caller's usage timeout, with the cached value as fallback.
+    // Live usage for the agent-status surface. Unlike getUsage it ignores the 5-min query TTL
+    // (modulo the short fresh window that coalesces bursts), so a freshly-switched login (the
+    // keychain default-login token changed) is reflected promptly instead of serving the previous
+    // account's frozen `lastGood`. Bounded by the caller's usage timeout, cached value as fallback.
     async getUsageLive(opts) {
         const home = getHome();
         if (!home)
             return emptyUsage('claude', 'HOME is not set.');
-        const fresh = await fetchClaudeUsageFromOAuth();
-        if (fresh) {
-            claudeUsageCache.lastGood = fresh;
-            claudeUsageCache.lastAttemptAt = Date.now();
-            return fresh;
-        }
-        return claudeUsageCache.lastGood
+        const fresh = await claudeNativeUsage({ fresh: true });
+        return fresh
             ?? getClaudeUsageFromTelemetry(home, opts.model)
             ?? emptyUsage('claude', 'No recent Claude usage data found.');
     }

package/dist/agent/kernel-bridge.js

@@ -125,6 +125,21 @@ export function toPikiloomPlan(plan) {
         .filter((st) => st.step.trim());
     return steps.length ? { explanation: typeof plan.explanation === 'string' ? plan.explanation : null, steps } : null;
 }
+// Final-result token projection (kernel UniversalUsage -> StreamResult fields). contextPercent
+// must flow through: the IM final footer (feishu/telegram formatFinalFooter) reads
+// result.contextPercent, so nulling it here showed the % on the live footer (preview meta carries
+// it) but dropped it from the finished message. Pure + exported for regression testing.
+export function kernelUsageToResultFields(u) {
+    return {
+        inputTokens: u?.inputTokens ?? null,
+        outputTokens: u?.outputTokens ?? null,
+        cachedInputTokens: u?.cachedInputTokens ?? null,
+        cacheCreationInputTokens: null,
+        contextWindow: null,
+        contextUsedTokens: u?.contextUsedTokens ?? null,
+        contextPercent: u?.contextPercent ?? null,
+    };
+}
 let _kernel = null;
 export async function loadKernel() {
     if (_kernel)
@@ -240,7 +255,7 @@ export async function kernelStream(opts) {
     const finalError = (opts.agent === 'codex' && result.error)
         ? (humanizeCodexError(result.error) ?? result.error)
         : (result.error ?? null);
-    const u = result.usage || snapshot.usage || {};
+    const usageFields = kernelUsageToResultFields(result.usage || snapshot.usage || {});
     return {
         ok: !!result.ok,
         // Empty-text fallback (mirrors the legacy driver): a clean turn with no prose reads
@@ -261,13 +276,7 @@ export async function kernelStream(opts) {
         model: input.model ?? null,
         thinkingEffort: opts.thinkingEffort,
         elapsedS: (Date.now() - start) / 1000,
-        inputTokens: u.inputTokens ?? null,
-        outputTokens: u.outputTokens ?? null,
-        cachedInputTokens: u.cachedInputTokens ?? null,
-        cacheCreationInputTokens: null,
-        contextWindow: null,
-        contextUsedTokens: u.contextUsedTokens ?? null,
-        contextPercent: null,
+        ...usageFields,
         codexCumulative: null,
         error: finalError,
         stopReason: result.stopReason ?? null,

package/dist/agent/utils.js

@@ -218,7 +218,9 @@ export function buildStreamPreviewMeta(s) {
         cachedInputTokens: s.cachedInputTokens,
         contextUsedTokens: ctx.contextUsedTokens, contextPercent: ctx.contextPercent,
     };
-    const turnOutput = (s.turnOutputTokensBase ?? 0) + (s.outputTokens ?? 0);
+    // The live thinking estimate stands in for output while a message is still streaming
+    // (silent extended thinking); the real output_tokens supersedes it once reported.
+    const turnOutput = (s.turnOutputTokensBase ?? 0) + Math.max(s.outputTokens ?? 0, s.thinkingEstTokens ?? 0);
     if (turnOutput > 0)
         meta.turnOutputTokens = turnOutput;
     if (s.byokProviderName)

package/dist/bot/commands.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import { fmtTokens, fmtUptime, fmtBytes } from './bot.js';
 import { getProjectSkillPaths, normalizeClaudeModelId, sessionListDisplayTitle, listAllMcpExtensions, listSkills as listAllSkills, } from '../agent/index.js';
 import { getDriver } from '../agent/driver.js';
-import { accountAgentSupported, listAccounts, getActiveAccountId, probeAccountUsage, getCachedAccountUsage, } from '../agent/accounts.js';
+import { accountAgentSupported, listAccounts, getActiveAccountId, getCachedAccountUsage, getAccountsUsageSnapshot, } from '../agent/accounts.js';
 import { withTimeoutFallback } from '../core/utils.js';
 import { effortOptionsFor } from '../core/config/runtime-config.js';
 import { getActiveProfile, getProvider } from '../model/index.js';
@@ -445,12 +445,18 @@ export async function getUsageOverview(bot, chatId) {
         if (accountAgentSupported(agent)) {
             const recs = listAccounts(agent);
             if (recs.length) {
-                const activeId = getActiveAccountId(agent);
-                const usages = await Promise.all(recs.map(rec => withTimeoutFallback(probeAccountUsage(agent, rec.id).catch(() => getCachedAccountUsage(agent, rec.id)), USAGE_PROBE_TIMEOUT_MS, getCachedAccountUsage(agent, rec.id))));
-                recs.forEach((rec, i) => accounts.push({
-                    id: rec.id, label: rec.label, active: rec.id === activeId, usage: usages[i],
-                }));
-                accounts.push({ id: null, label: 'Default login', active: activeId === null, usage });
+                // Same unified pass as the dashboard popover (fresh tier, debounced in the driver
+                // caches); on timeout fall back to whatever each account last probed.
+                const snap = await withTimeoutFallback(getAccountsUsageSnapshot(agent, { fresh: true }).catch(() => null), USAGE_PROBE_TIMEOUT_MS, null);
+                const activeId = snap?.activeAccountId ?? getActiveAccountId(agent);
+                for (const rec of recs) {
+                    const row = snap?.accounts.find(a => a.id === rec.id);
+                    accounts.push({
+                        id: rec.id, label: rec.label, active: rec.id === activeId,
+                        usage: row?.usage ?? getCachedAccountUsage(agent, rec.id),
+                    });
+                }
+                accounts.push({ id: null, label: 'Default login', active: activeId === null, usage: snap?.native ?? usage });
             }
         }
         return { agent, label: agentDisplayLabel(agent), isCurrent: agent === currentAgent, usage, accounts };

package/dist/dashboard/routes/accounts.js

@@ -1,6 +1,6 @@
 import { Hono } from 'hono';
 import { allDriverIds } from '../../agent/index.js';
-import { accountAgentSupported, listAccounts, getAccount, addAccount, updateAccount, removeAccount, getActiveAccountId, setActiveAccount, probeAccountUsage, MAX_ACCOUNTS_PER_AGENT, } from '../../agent/accounts.js';
+import { accountAgentSupported, getAccount, addAccount, updateAccount, removeAccount, getActiveAccountId, setActiveAccount, probeAccountUsage, getAccountsUsageSnapshot, MAX_ACCOUNTS_PER_AGENT, } from '../../agent/accounts.js';
 import { invalidateAgentStatus } from './agents.js';
 const app = new Hono();
 function agentError(agent) {
@@ -26,11 +26,20 @@ app.get('/api/agents/:agent/accounts', async (c) => {
     if (!allDriverIds().includes(agent))
         return c.json({ ok: false, error: `Unknown agent: ${agent}` }, 400);
     if (!accountAgentSupported(agent)) {
-        return c.json({ ok: true, agent, supported: false, accounts: [], activeAccountId: null, max: MAX_ACCOUNTS_PER_AGENT });
+        return c.json({ ok: true, agent, supported: false, accounts: [], activeAccountId: null, nativeUsage: null, max: MAX_ACCOUNTS_PER_AGENT });
     }
-    const activeId = getActiveAccountId(agent);
-    const accounts = await Promise.all(listAccounts(agent).map(r => publicAccount(agent, r, activeId)));
-    return c.json({ ok: true, agent, supported: true, accounts, activeAccountId: activeId, max: MAX_ACCOUNTS_PER_AGENT });
+    // `fresh=1` = the user is actively looking (popover open / panel refresh): re-probe past the
+    // short fresh window. The min-interval debounce lives in the driver caches, so this is safe to
+    // send on every hover. Account rows and the default-login quota come from the same pass.
+    const fresh = c.req.query('fresh') === '1';
+    const snap = await getAccountsUsageSnapshot(agent, { fresh });
+    return c.json({
+        ok: true, agent, supported: true,
+        accounts: snap.accounts,
+        activeAccountId: snap.activeAccountId,
+        nativeUsage: snap.native,
+        max: MAX_ACCOUNTS_PER_AGENT,
+    });
 });
 app.post('/api/agents/:agent/accounts', async (c) => {
     const agent = c.req.param('agent');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.48",
+  "version": "0.4.50",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {

package/packages/kernel/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/packages/kernel/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/packages/kernel/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': {