@earendil-works/pi-coding-agent 0.80.3 → 0.80.5

package/dist/modes/interactive/interactive-mode.js

@@ -13,6 +13,7 @@ import { spawn, spawnSync } from "child_process";
 import { APP_NAME, APP_TITLE, CONFIG_DIR_NAME, getAgentDir, getAuthPath, getDebugLogPath, getDocsPath, getShareViewerUrl, VERSION, } from "../../config.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
 import { SessionImportFileNotFoundError } from "../../core/agent-session-runtime.js";
+import { CACHE_TTL_MS, collectCacheMisses, computeCacheWaste, detectCacheMiss, } from "../../core/cache-stats.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { configureHttpDispatcher, formatHttpIdleTimeoutMs } from "../../core/http-dispatcher.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
@@ -21,7 +22,7 @@ import { defaultModelPerProvider, findExactModelReferenceMatch, resolveModelScop
 import { DefaultPackageManager } from "../../core/package-manager.js";
 import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "../../core/provider-display-names.js";
 import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../core/session-cwd.js";
-import { SessionManager } from "../../core/session-manager.js";
+import { SessionManager, sessionEntryToContextMessages } from "../../core/session-manager.js";
 import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
 import { isInstallTelemetryEnabled } from "../../core/telemetry.js";
 import { hasTrustRequiringProjectResources, ProjectTrustStore } from "../../core/trust-manager.js";
@@ -41,6 +42,7 @@ import { BorderedLoader } from "./components/bordered-loader.js";
 import { BranchSummaryMessageComponent } from "./components/branch-summary-message.js";
 import { CompactionSummaryMessageComponent } from "./components/compaction-summary-message.js";
 import { CustomEditor } from "./components/custom-editor.js";
+import { CustomEntryComponent } from "./components/custom-entry.js";
 import { CustomMessageComponent } from "./components/custom-message.js";
 import { DaxnutsComponent } from "./components/daxnuts.js";
 import { DynamicBorder } from "./components/dynamic-border.js";
@@ -48,11 +50,11 @@ import { EarendilAnnouncementComponent } from "./components/earendil-announcemen
 import { ExtensionEditorComponent } from "./components/extension-editor.js";
 import { ExtensionInputComponent } from "./components/extension-input.js";
 import { ExtensionSelectorComponent } from "./components/extension-selector.js";
-import { FooterComponent } from "./components/footer.js";
+import { FooterComponent, formatTokens } from "./components/footer.js";
 import { formatKeyText, keyDisplayText, keyHint, keyText, rawKeyHint } from "./components/keybinding-hints.js";
 import { LoginDialogComponent } from "./components/login-dialog.js";
 import { ModelSelectorComponent } from "./components/model-selector.js";
-import { OAuthSelectorComponent } from "./components/oauth-selector.js";
+import { formatAuthSelectorProviderType, OAuthSelectorComponent, } from "./components/oauth-selector.js";
 import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
 import { SessionSelectorComponent } from "./components/session-selector.js";
 import { SettingsSelectorComponent } from "./components/settings-selector.js";
@@ -81,6 +83,9 @@ class ExpandableText extends Text {
         this.setText(expanded ? this.getExpandedText() : this.getCollapsedText());
     }
 }
+function isCustomSessionEntry(item) {
+    return "type" in item && item.type === "custom";
+}
 const DEAD_TERMINAL_ERROR_CODES = new Set(["EIO", "EPIPE", "ENOTCONN"]);
 function isDeadTerminalError(error) {
     if (!error || typeof error !== "object" || !("code" in error)) {
@@ -131,6 +136,42 @@ export function isApiKeyLoginProvider(providerId, oauthProviderIds, builtInProvi
     }
     return !oauthProviderIds.has(providerId);
 }
+const AUTH_TYPE_ORDER = { oauth: 0, api_key: 1 };
+function createFuzzyAutocompleteItems(items, prefix, getSearchText, toAutocompleteItem) {
+    const filtered = fuzzyFilter(items, prefix, getSearchText);
+    if (filtered.length === 0)
+        return null;
+    return filtered.map(toAutocompleteItem);
+}
+function getLoginProviderCompletionOptions(providerOptions) {
+    const byId = new Map();
+    for (const provider of providerOptions) {
+        const existing = byId.get(provider.id);
+        if (existing) {
+            if (!existing.authTypes.includes(provider.authType)) {
+                existing.authTypes.push(provider.authType);
+                existing.authTypes.sort((a, b) => AUTH_TYPE_ORDER[a] - AUTH_TYPE_ORDER[b]);
+            }
+            continue;
+        }
+        byId.set(provider.id, {
+            id: provider.id,
+            name: provider.name,
+            authTypes: [provider.authType],
+        });
+    }
+    return Array.from(byId.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function getLoginProviderSearchText(provider) {
+    const authTypes = provider.authTypes
+        .map((authType) => `${authType} ${formatAuthSelectorProviderType(authType)}`)
+        .join(" ");
+    return `${provider.id} ${provider.name} ${authTypes}`;
+}
+function formatLoginProviderCompletionDescription(provider) {
+    const authTypes = provider.authTypes.map(formatAuthSelectorProviderType).join("/");
+    return provider.name === provider.id ? authTypes : `${provider.name} · ${authTypes}`;
+}
 export class InteractiveMode {
     runtimeHost;
     ui;
@@ -317,6 +358,7 @@ export class InteractiveMode {
         const slashCommands = BUILTIN_SLASH_COMMANDS.map((command) => ({
             name: command.name,
             description: command.description,
+            ...(command.argumentHint && { argumentHint: command.argumentHint }),
         }));
         const modelCommand = slashCommands.find((command) => command.name === "model");
         if (modelCommand) {
@@ -334,17 +376,24 @@ export class InteractiveMode {
                     name: m.name,
                     label: `${m.provider}/${m.id}`,
                 }));
-                // Fuzzy filter by model ID + provider in either order.
-                const filtered = fuzzyFilter(items, prefix, getModelSearchText);
-                if (filtered.length === 0)
-                    return null;
-                return filtered.map((item) => ({
+                return createFuzzyAutocompleteItems(items, prefix, getModelSearchText, (item) => ({
                     value: item.label,
                     label: item.id,
                     description: item.provider,
                 }));
             };
         }
+        const loginCommand = slashCommands.find((command) => command.name === "login");
+        if (loginCommand) {
+            loginCommand.getArgumentCompletions = (prefix) => {
+                const providers = getLoginProviderCompletionOptions(this.getLoginProviderOptions());
+                return createFuzzyAutocompleteItems(providers, prefix, getLoginProviderSearchText, (provider) => ({
+                    value: provider.id,
+                    label: provider.id,
+                    description: formatLoginProviderCompletionDescription(provider),
+                }));
+            };
+        }
         // Convert prompt templates to SlashCommand format for autocomplete
         const templateCommands = this.session.promptTemplates.map((cmd) => ({
             name: cmd.name,
@@ -1155,7 +1204,7 @@ export class InteractiveMode {
                 this.restoreQueuedMessagesToEditor({ abort: true });
             },
             commandContextActions: {
-                waitForIdle: () => this.session.agent.waitForIdle(),
+                waitForIdle: () => this.session.waitForIdle(),
                 newSession: async (options) => {
                     this.clearStatusIndicator();
                     try {
@@ -1206,7 +1255,7 @@ export class InteractiveMode {
             },
             shutdownHandler: () => {
                 this.shutdownRequested = true;
-                if (!this.session.isStreaming) {
+                if (this.session.isIdle) {
                     void this.shutdown();
                 }
             },
@@ -1299,7 +1348,7 @@ export class InteractiveMode {
             sessionManager: this.sessionManager,
             modelRegistry: this.session.modelRegistry,
             model: this.session.model,
-            isIdle: () => !this.session.isStreaming,
+            isIdle: () => this.session.isIdle,
             isProjectTrusted: () => this.settingsManager.isProjectTrusted(),
             signal: this.session.agent.signal,
             abort: () => {
@@ -2105,9 +2154,10 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
-            if (text === "/login") {
-                this.showOAuthSelector("login");
+            if (text === "/login" || text.startsWith("/login ")) {
+                const providerRef = text.startsWith("/login ") ? text.slice(7).trim() : undefined;
                 this.editor.setText("");
+                await this.handleLoginCommand(providerRef);
                 return;
             }
             if (text === "/logout") {
@@ -2241,6 +2291,12 @@ export class InteractiveMode {
                 this.updatePendingMessagesDisplay();
                 this.ui.requestRender();
                 break;
+            case "entry_appended":
+                if (event.entry.type === "custom") {
+                    this.addCustomEntryToChat(event.entry);
+                    this.ui.requestRender();
+                }
+                break;
             case "session_info_changed":
                 this.updateTerminalTitle();
                 this.footer.invalidate();
@@ -2326,6 +2382,7 @@ export class InteractiveMode {
                         for (const [, component] of this.pendingTools.entries()) {
                             component.setArgsComplete();
                         }
+                        this.maybeShowCacheMissNotice(this.streamingMessage);
                     }
                     this.streamingComponent = undefined;
                     this.streamingMessage = undefined;
@@ -2376,9 +2433,11 @@ export class InteractiveMode {
                     this.streamingMessage = undefined;
                 }
                 this.pendingTools.clear();
-                await this.checkShutdownRequested();
                 this.ui.requestRender();
                 break;
+            case "agent_settled":
+                await this.checkShutdownRequested();
+                break;
             case "compaction_start": {
                 if (this.settingsManager.getShowTerminalProgress()) {
                     this.ui.terminal.setProgress(true);
@@ -2486,6 +2545,25 @@ export class InteractiveMode {
         this.lastStatusText = text;
         this.ui.requestRender();
     }
+    addCustomEntryToChat(entry) {
+        const renderer = this.session.extensionRunner.getEntryRenderer(entry.customType);
+        if (!renderer) {
+            return;
+        }
+        const component = new CustomEntryComponent(entry, renderer);
+        component.setExpanded(this.toolOutputExpanded);
+        if (!component.hasContent()) {
+            return;
+        }
+        if (this.streamingComponent) {
+            const streamingIndex = this.chatContainer.children.indexOf(this.streamingComponent);
+            if (streamingIndex >= 0) {
+                this.chatContainer.children.splice(streamingIndex, 0, component);
+                return;
+            }
+        }
+        this.chatContainer.addChild(component);
+    }
     addMessageToChat(message, options) {
         switch (message.role) {
             case "bashExecution": {
@@ -2563,20 +2641,24 @@ export class InteractiveMode {
             }
         }
     }
-    /**
-     * Render session context to chat. Used for initial load and rebuild after compaction.
-     * @param sessionContext Session context to render
-     * @param options.updateFooter Update footer state
-     * @param options.populateHistory Add user messages to editor history
-     */
-    renderSessionContext(sessionContext, options = {}) {
+    renderSessionItems(items, options = {}) {
         this.pendingTools.clear();
         const renderedPendingTools = new Map();
+        // Cache-miss notices are not persisted; re-derive them from the full entry
+        // list and re-inject them after the assistant messages that paid for them.
+        const cacheMisses = this.settingsManager.getShowCacheMissNotices()
+            ? collectCacheMisses(this.sessionManager.getEntries(), this.session.modelRegistry)
+            : new Map();
         if (options.updateFooter) {
             this.footer.invalidate();
             this.updateEditorBorderColor();
         }
-        for (const message of sessionContext.messages) {
+        for (const item of items) {
+            if (isCustomSessionEntry(item)) {
+                this.addCustomEntryToChat(item);
+                continue;
+            }
+            const message = item;
             // Assistant messages need special handling for tool calls
             if (message.role === "assistant") {
                 this.addMessageToChat(message);
@@ -2608,6 +2690,11 @@ export class InteractiveMode {
                         }
                     }
                 }
+                if (message.stopReason !== "aborted" && message.stopReason !== "error") {
+                    const miss = cacheMisses.get(message);
+                    if (miss)
+                        this.addCacheMissNotice(miss);
+                }
             }
             else if (message.role === "toolResult") {
                 // Match tool results to pending tool components
@@ -2627,10 +2714,53 @@ export class InteractiveMode {
         }
         this.ui.requestRender();
     }
+    /**
+     * Render session entries to chat. Used for initial load and rebuild after compaction.
+     * @param entries Compaction-aware session entries to render
+     * @param options.updateFooter Update footer state
+     * @param options.populateHistory Add user messages to editor history
+     */
+    renderSessionEntries(entries, options = {}) {
+        const items = entries.flatMap((entry) => {
+            if (entry.type === "custom") {
+                return [entry];
+            }
+            return sessionEntryToContextMessages(entry);
+        });
+        this.renderSessionItems(items, options);
+    }
+    /**
+     * Show a transcript notice when a completed assistant message paid for a
+     * significant cache miss. Only states observable facts: the miss itself,
+     * a model switch, or an idle gap past the cache TTL.
+     */
+    maybeShowCacheMissNotice(message) {
+        if (!this.settingsManager.getShowCacheMissNotices())
+            return;
+        // Entries don't contain `message` yet: message_end fires before persistence.
+        const miss = detectCacheMiss(this.sessionManager.getEntries(), message, this.session.modelRegistry);
+        if (miss)
+            this.addCacheMissNotice(miss);
+    }
+    addCacheMissNotice(miss) {
+        if (miss.missedTokens < 20_000 && miss.missedCost < 0.1)
+            return;
+        const cost = miss.missedCost >= 0.01 ? ` (~$${miss.missedCost.toFixed(2)})` : "";
+        const reBilled = `${formatTokens(miss.missedTokens)} tokens re-billed${cost}`;
+        let label = "Cache miss";
+        if (miss.modelChanged) {
+            label = "Cache miss after model switch";
+        }
+        else if (miss.idleMs >= CACHE_TTL_MS) {
+            label = `Cache miss after ${Math.round(miss.idleMs / 60_000)}m idle`;
+        }
+        const text = theme.fg("warning", `${label}: ${reBilled}`);
+        this.chatContainer.addChild(new Spacer(1));
+        this.chatContainer.addChild(new Text(text, 1, 0));
+    }
     renderInitialMessages() {
-        // Get aligned messages and entries from session context
-        const context = this.sessionManager.buildSessionContext();
-        this.renderSessionContext(context, {
+        const entries = this.sessionManager.buildContextEntries();
+        this.renderSessionEntries(entries, {
             updateFooter: true,
             populateHistory: true,
         });
@@ -2666,8 +2796,7 @@ export class InteractiveMode {
     }
     rebuildChatFromMessages() {
         this.chatContainer.clear();
-        const context = this.sessionManager.buildSessionContext();
-        this.renderSessionContext(context);
+        this.renderSessionEntries(this.sessionManager.buildContextEntries());
     }
     // =========================================================================
     // Key handlers
@@ -3266,6 +3395,7 @@ export class InteractiveMode {
                 doubleEscapeAction: this.settingsManager.getDoubleEscapeAction(),
                 treeFilterMode: this.settingsManager.getTreeFilterMode(),
                 showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
+                showCacheMissNotices: this.settingsManager.getShowCacheMissNotices(),
                 defaultProjectTrust: this.settingsManager.getDefaultProjectTrust(),
                 editorPaddingX: this.settingsManager.getEditorPaddingX(),
                 outputPad: this.settingsManager.getOutputPad(),
@@ -3341,6 +3471,10 @@ export class InteractiveMode {
                     this.chatContainer.clear();
                     this.rebuildChatFromMessages();
                 },
+                onShowCacheMissNoticesChange: (shown) => {
+                    this.settingsManager.setShowCacheMissNotices(shown);
+                    this.rebuildChatFromMessages();
+                },
                 onCollapseChangelogChange: (collapsed) => {
                     this.settingsManager.setCollapseChangelog(collapsed);
                 },
@@ -3630,19 +3764,17 @@ export class InteractiveMode {
         const initialSelectedId = userMessages[userMessages.length - 1]?.entryId;
         this.showSelector((done) => {
             const selector = new UserMessageSelectorComponent(userMessages.map((m) => ({ id: m.entryId, text: m.text })), async (entryId) => {
+                done();
                 try {
                     const result = await this.runtimeHost.fork(entryId);
                     if (result.cancelled) {
-                        done();
                         this.ui.requestRender();
                         return;
                     }
                     this.editor.setText(result.selectedText ?? "");
-                    done();
                     this.showStatus("Forked to new session");
                 }
                 catch (error) {
-                    done();
                     this.showError(error instanceof Error ? error.message : String(error));
                 }
             }, () => {
@@ -3871,13 +4003,82 @@ export class InteractiveMode {
         }
         return options.sort((a, b) => a.name.localeCompare(b.name));
     }
-    showLoginAuthTypeSelector() {
+    findLoginProviderOptions(providerRef) {
+        const normalizedProviderRef = providerRef.trim().toLowerCase();
+        if (!normalizedProviderRef) {
+            return [];
+        }
+        return this.getLoginProviderOptions().filter((provider) => provider.id.toLowerCase() === normalizedProviderRef ||
+            provider.name.toLowerCase() === normalizedProviderRef);
+    }
+    async handleLoginCommand(providerRef) {
+        if (!providerRef) {
+            this.showLoginAuthTypeSelector();
+            return;
+        }
+        const providerOptions = this.findLoginProviderOptions(providerRef);
+        if (providerOptions.length === 1) {
+            await this.startProviderLogin(providerOptions[0]);
+            return;
+        }
+        if (providerOptions.length > 1) {
+            const providerIds = new Set(providerOptions.map((provider) => provider.id));
+            if (providerIds.size === 1) {
+                this.showLoginAuthTypeSelector(providerOptions);
+                return;
+            }
+        }
+        this.showLoginProviderSelector(undefined, providerRef);
+    }
+    async startProviderLogin(providerOption) {
+        if (providerOption.authType === "oauth") {
+            await this.showLoginDialog(providerOption.id, providerOption.name);
+        }
+        else if (providerOption.id === BEDROCK_PROVIDER_ID) {
+            this.showBedrockSetupDialog(providerOption.id, providerOption.name);
+        }
+        else {
+            await this.showApiKeyLoginDialog(providerOption.id, providerOption.name);
+        }
+    }
+    showLoginAuthTypeSelector(providerOptions) {
         const subscriptionLabel = "Use a subscription";
         const apiKeyLabel = "Use an API key";
+        const availableAuthTypes = providerOptions
+            ? new Set(providerOptions.map((provider) => provider.authType))
+            : new Set(["oauth", "api_key"]);
+        const options = [];
+        if (availableAuthTypes.has("oauth")) {
+            options.push(subscriptionLabel);
+        }
+        if (availableAuthTypes.has("api_key")) {
+            options.push(apiKeyLabel);
+        }
+        if (options.length === 0) {
+            this.showStatus("No login methods available.");
+            return;
+        }
+        if (providerOptions && options.length === 1) {
+            const providerOption = providerOptions[0];
+            if (providerOption) {
+                void this.startProviderLogin(providerOption);
+            }
+            return;
+        }
+        const title = providerOptions?.[0]
+            ? `Select authentication method for ${providerOptions[0].name}:`
+            : "Select authentication method:";
         this.showSelector((done) => {
-            const selector = new ExtensionSelectorComponent("Select authentication method:", [subscriptionLabel, apiKeyLabel], (option) => {
+            const selector = new ExtensionSelectorComponent(title, options, (option) => {
                 done();
                 const authType = option === subscriptionLabel ? "oauth" : "api_key";
+                if (providerOptions) {
+                    const providerOption = providerOptions.find((provider) => provider.authType === authType);
+                    if (providerOption) {
+                        void this.startProviderLogin(providerOption);
+                    }
+                    return;
+                }
                 this.showLoginProviderSelector(authType);
             }, () => {
                 done();
@@ -3886,32 +4087,34 @@ export class InteractiveMode {
             return { component: selector, focus: selector };
         });
     }
-    showLoginProviderSelector(authType) {
+    showLoginProviderSelector(authType, initialSearchInput) {
         const providerOptions = this.getLoginProviderOptions(authType);
         if (providerOptions.length === 0) {
-            this.showStatus(authType === "oauth" ? "No subscription providers available." : "No API key providers available.");
+            const message = authType === "oauth"
+                ? "No subscription providers available."
+                : authType === "api_key"
+                    ? "No API key providers available."
+                    : "No login providers available.";
+            this.showStatus(message);
             return;
         }
         this.showSelector((done) => {
-            const selector = new OAuthSelectorComponent("login", this.session.modelRegistry.authStorage, providerOptions, async (providerId) => {
+            const selector = new OAuthSelectorComponent("login", this.session.modelRegistry.authStorage, providerOptions, async (providerId, selectedAuthType) => {
                 done();
-                const providerOption = providerOptions.find((provider) => provider.id === providerId);
+                const providerOption = providerOptions.find((provider) => provider.id === providerId && provider.authType === selectedAuthType);
                 if (!providerOption) {
                     return;
                 }
-                if (providerOption.authType === "oauth") {
-                    await this.showLoginDialog(providerOption.id, providerOption.name);
-                }
-                else if (providerOption.id === BEDROCK_PROVIDER_ID) {
-                    this.showBedrockSetupDialog(providerOption.id, providerOption.name);
+                await this.startProviderLogin(providerOption);
+            }, () => {
+                done();
+                if (authType) {
+                    this.showLoginAuthTypeSelector();
                 }
                 else {
-                    await this.showApiKeyLoginDialog(providerOption.id, providerOption.name);
+                    this.ui.requestRender();
                 }
-            }, () => {
-                done();
-                this.showLoginAuthTypeSelector();
-            }, (providerId) => this.session.modelRegistry.getProviderAuthStatus(providerId));
+            }, (providerId) => this.session.modelRegistry.getProviderAuthStatus(providerId), initialSearchInput);
             return { component: selector, focus: selector };
         });
     }
@@ -4170,7 +4373,7 @@ export class InteractiveMode {
         const borderColor = (s) => theme.fg("border", s);
         reloadBox.addChild(new DynamicBorder(borderColor));
         reloadBox.addChild(new Spacer(1));
-        reloadBox.addChild(new Text(theme.fg("muted", "Reloading keybindings, extensions, skills, prompts, themes..."), 1, 0));
+        reloadBox.addChild(new Text(theme.fg("muted", "Reloading keybindings, extensions, skills, prompts, themes, and context files..."), 1, 0));
         reloadBox.addChild(new Spacer(1));
         reloadBox.addChild(new DynamicBorder(borderColor));
         const previousEditor = this.editor;
@@ -4234,8 +4437,8 @@ export class InteractiveMode {
                 this.showError(`models.json error: ${modelsJsonError}`);
             }
             this.showStatus(savedImplicitProjectTrust
-                ? "Reloaded keybindings, extensions, skills, prompts, themes; saved project trust"
-                : "Reloaded keybindings, extensions, skills, prompts, themes");
+                ? "Reloaded keybindings, extensions, skills, prompts, themes, and context files; saved project trust"
+                : "Reloaded keybindings, extensions, skills, prompts, themes, and context files");
             dismissReloadBox(this.editor);
             reloadBoxDismissed = true;
         }
@@ -4456,6 +4659,26 @@ export class InteractiveMode {
     handleSessionCommand() {
         const stats = this.session.getSessionStats();
         const sessionName = this.sessionManager.getSessionName();
+        const entries = this.sessionManager.getEntries();
+        const cacheWaste = computeCacheWaste(entries, this.session.modelRegistry);
+        // Cost/token totals per provider/model actually used (e.g. OpenRouter `auto`
+        // resolves to a concrete responseModel), sorted by cost descending.
+        const perModelMap = new Map();
+        for (const entry of entries) {
+            if (entry.type !== "message" || entry.message.role !== "assistant")
+                continue;
+            const message = entry.message;
+            const usage = message.usage;
+            const key = `${message.provider}/${message.responseModel ?? message.model}`;
+            let bucket = perModelMap.get(key);
+            if (!bucket) {
+                bucket = { key, cost: 0, tokens: 0 };
+                perModelMap.set(key, bucket);
+            }
+            bucket.cost += usage.cost.total;
+            bucket.tokens += usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+        }
+        const perModel = Array.from(perModelMap.values()).sort((a, b) => b.cost - a.cost);
         let info = `${theme.bold("Session Info")}\n\n`;
         if (sessionName) {
             info += `${theme.fg("dim", "Name:")} ${sessionName}\n`;
@@ -4463,24 +4686,42 @@ export class InteractiveMode {
         info += `${theme.fg("dim", "File:")} ${stats.sessionFile ?? "In-memory"}\n`;
         info += `${theme.fg("dim", "ID:")} ${stats.sessionId}\n\n`;
         info += `${theme.bold("Messages")}\n`;
+        info += `${theme.fg("dim", "Total:")} ${stats.totalMessages}\n`;
         info += `${theme.fg("dim", "User:")} ${stats.userMessages}\n`;
         info += `${theme.fg("dim", "Assistant:")} ${stats.assistantMessages}\n`;
-        info += `${theme.fg("dim", "Tool Calls:")} ${stats.toolCalls}\n`;
-        info += `${theme.fg("dim", "Tool Results:")} ${stats.toolResults}\n`;
-        info += `${theme.fg("dim", "Total:")} ${stats.totalMessages}\n\n`;
+        info += `${theme.fg("dim", "Tools:")} ${stats.toolCalls} calls, ${stats.toolResults} results\n\n`;
         info += `${theme.bold("Tokens")}\n`;
-        info += `${theme.fg("dim", "Input:")} ${stats.tokens.input.toLocaleString()}\n`;
-        info += `${theme.fg("dim", "Output:")} ${stats.tokens.output.toLocaleString()}\n`;
-        if (stats.tokens.cacheRead > 0) {
-            info += `${theme.fg("dim", "Cache Read:")} ${stats.tokens.cacheRead.toLocaleString()}\n`;
-        }
-        if (stats.tokens.cacheWrite > 0) {
-            info += `${theme.fg("dim", "Cache Write:")} ${stats.tokens.cacheWrite.toLocaleString()}\n`;
+        // "Input" is the full prompt volume. With cache activity, split it into
+        // cached (served from cache) vs uncached (everything else) - the only
+        // provider-independent split. Cache writes, where reported, are a detail
+        // of the uncached portion.
+        const { input, cacheRead, cacheWrite } = stats.tokens;
+        const promptTokens = input + cacheRead + cacheWrite;
+        info += `${theme.fg("dim", "Input:")} ${promptTokens.toLocaleString()}\n`;
+        if (promptTokens > 0 && (cacheRead > 0 || cacheWrite > 0)) {
+            const hitRate = theme.fg("dim", `(${((cacheRead / promptTokens) * 100).toFixed(1)}%)`);
+            info += `  ${theme.fg("dim", "Cached:")} ${cacheRead.toLocaleString()} ${hitRate}\n`;
+            const written = cacheWrite > 0 ? ` ${theme.fg("dim", `(${cacheWrite.toLocaleString()} written to cache)`)}` : "";
+            info += `  ${theme.fg("dim", "Uncached:")} ${(input + cacheWrite).toLocaleString()}${written}\n`;
         }
+        info += `${theme.fg("dim", "Output:")} ${stats.tokens.output.toLocaleString()}\n`;
         info += `${theme.fg("dim", "Total:")} ${stats.tokens.total.toLocaleString()}\n`;
-        if (stats.cost > 0) {
+        if (stats.cost > 0 || cacheWaste.missedTokens > 0) {
             info += `\n${theme.bold("Cost")}\n`;
-            info += `${theme.fg("dim", "Total:")} ${stats.cost.toFixed(4)}`;
+            info += `${theme.fg("dim", "Total:")} $${stats.cost.toFixed(3)}`;
+            if (perModel.length > 1) {
+                for (const entry of perModel) {
+                    info += `\n  ${theme.fg("dim", `${entry.key}:`)} $${entry.cost.toFixed(3)} ${theme.fg("dim", `(${formatTokens(entry.tokens)} tokens)`)}`;
+                }
+            }
+            if (cacheWaste.missedTokens > 0) {
+                const missLabel = cacheWaste.missCount === 1 ? "1 miss" : `${cacheWaste.missCount} misses`;
+                const detail = `${cacheWaste.missedTokens.toLocaleString()} tokens, ${missLabel}`;
+                info +=
+                    cacheWaste.missedCost >= 0.0001
+                        ? `\n${theme.fg("dim", "Cache Re-billed:")} $${cacheWaste.missedCost.toFixed(3)} ${theme.fg("dim", `(${detail})`)}`
+                        : `\n${theme.fg("dim", "Cache Re-billed:")} ${detail}`;
+            }
         }
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Text(info, 1, 0));