@ai-agent-forge/agent-forge 0.88.2 → 0.88.3

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

@@ -0,0 +1,704 @@
+import { Spacer, Text } from "@agent-forge/tui";
+import { parseSkillBlock } from "../../core/agent-session.js";
+import { CACHE_TTL_MS, collectCacheMisses, detectCacheMiss } from "../../core/cache-stats.js";
+import { t } from "../../core/i18n/index.js";
+import { createCompactionSummaryMessage } from "../../core/messages.js";
+import { sessionEntryToContextMessages } from "../../core/session-manager.js";
+import { theme } from "../../theme/theme.js";
+import { AssistantMessageComponent } from "./components/assistant-message.js";
+import { BashExecutionComponent } from "./components/bash-execution.js";
+import { BranchSummaryMessageComponent } from "./components/branch-summary-message.js";
+import { CompactionSummaryMessageComponent } from "./components/compaction-summary-message.js";
+import { CustomMessageComponent } from "./components/custom-message.js";
+import { formatTokens } from "./components/footer.js";
+import { SkillInvocationMessageComponent } from "./components/skill-invocation-message.js";
+import { BranchSummaryStatusIndicator, CompactionStatusIndicator, RetryStatusIndicator, } from "./components/status-indicator.js";
+import { ToolExecutionComponent } from "./components/tool-execution.js";
+import { ToolRunGroupComponent } from "./components/tool-run-group.js";
+import { UserMessageComponent } from "./components/user-message.js";
+function isCustomSessionEntry(item) {
+    return "type" in item && item.type === "custom";
+}
+function isCompactionCostNotice(item) {
+    return "type" in item && item.type === "compaction_cost";
+}
+export function subscribeToAgent(host) {
+    host.unsubscribe = host.facade.subscribe(async (event) => {
+        await host.handleEvent(event);
+    });
+}
+export async function handleEvent(host, event) {
+    if (!host.isInitialized) {
+        await host.init();
+    }
+    host.footer.invalidate();
+    // Failover snapshots land as entry_appended events; the ticker decides here
+    // whether the per-second countdown re-render is needed (§4.7 Phase 3).
+    host.failoverTicker?.refresh();
+    switch (event.type) {
+        case "agent_start":
+            host.pendingTools.clear();
+            // Restore main escape handler if retry handler is still active
+            // (retry success event fires later, but we need main handler now)
+            if (host.retryEscapeHandler) {
+                host.defaultEditor.onEscape = host.retryEscapeHandler;
+                host.retryEscapeHandler = undefined;
+            }
+            break;
+        case "turn_start":
+            if (host.settingsManager.getShowTerminalProgress()) {
+                host.ui.terminal.setProgress(true);
+            }
+            if (host.workingVisible) {
+                if (host.activeStatusIndicator?.kind !== "working") {
+                    host.showWorkingStatusIndicator();
+                }
+            }
+            else {
+                host.clearStatusIndicator();
+            }
+            host.ui.requestRender();
+            break;
+        case "queue_update":
+            host.updatePendingMessagesDisplay();
+            host.ui.requestRender();
+            break;
+        case "entry_appended":
+            // Custom entries have no renderer source since the legacy extension
+            // surface was removed; nothing to append to the chat.
+            break;
+        case "session_info_changed":
+            host.updateTerminalTitle();
+            host.footer.invalidate();
+            host.ui.requestRender();
+            break;
+        case "thinking_level_changed":
+            host.footer.invalidate();
+            host.updateEditorBorderColor();
+            break;
+        case "message_start":
+            if (event.message.role === "custom") {
+                host.addMessageToChat(event.message);
+                host.ui.requestRender();
+            }
+            else if (event.message.role === "user") {
+                host.addMessageToChat(event.message);
+                host.updatePendingMessagesDisplay();
+                host.ui.requestRender();
+            }
+            else if (event.message.role === "assistant") {
+                // D-083: a new assistant turn closes the previous turn's
+                // tool-run group (tools executed between the turns) and
+                // starts a fresh one on its first toolCall.
+                host.activeToolRunGroup?.markRunComplete();
+                host.activeToolRunGroup = undefined;
+                host.streamingComponent = new AssistantMessageComponent(undefined, host.hideThinkingBlock, host.getMarkdownThemeWithSettings(), host.hiddenThinkingLabel, host.outputPad, host.getMarkdownTransformers());
+                // D-083: components created after a ctrl+o toggle inherit the
+                // current expansion so detail mode holds across turns.
+                if (host.toolOutputExpanded) {
+                    host.streamingComponent.setExpanded(true);
+                }
+                host.streamingMessage = event.message;
+                host.chatContainer.addChild(host.streamingComponent);
+                host.streamingComponent.updateContent(host.streamingMessage, true);
+                host.ui.requestRender();
+            }
+            break;
+        case "message_update":
+            if (host.streamingComponent && event.message.role === "assistant") {
+                host.streamingMessage = event.message;
+                host.streamingComponent.updateContent(host.streamingMessage, true);
+                for (const content of host.streamingMessage.content) {
+                    if (content.type === "toolCall") {
+                        if (!host.pendingTools.has(content.id)) {
+                            const component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
+                                showImages: host.settingsManager.getShowImages(),
+                                imageWidthCells: host.settingsManager.getImageWidthCells(),
+                            }, host.getRegisteredToolDefinition(content.name), host.ui, host.facade.getCwd());
+                            component.setExpanded(host.toolOutputExpanded);
+                            host.addToolToRunGroup(component);
+                            host.pendingTools.set(content.id, component);
+                        }
+                        else {
+                            const component = host.pendingTools.get(content.id);
+                            // v8 ignore next -- has() 已确认键存在，get() 恒返回组件
+                            if (component) {
+                                component.updateArgs(content.arguments);
+                            }
+                        }
+                    }
+                }
+                host.ui.requestRender();
+            }
+            break;
+        case "message_end":
+            if (event.message.role === "user")
+                break;
+            if (host.streamingComponent && event.message.role === "assistant") {
+                host.streamingMessage = event.message;
+                let errorMessage;
+                if (host.streamingMessage.stopReason === "aborted") {
+                    const retryAttempt = host.facade.getRetryAttempt();
+                    errorMessage =
+                        retryAttempt > 0
+                            ? retryAttempt === 1
+                                ? t("Aborted after {count} retry attempt", { count: retryAttempt })
+                                : t("Aborted after {count} retry attempts", { count: retryAttempt })
+                            : t("Operation aborted");
+                    host.streamingMessage.errorMessage = errorMessage;
+                }
+                host.streamingComponent.updateContent(host.streamingMessage, false);
+                if (host.streamingMessage.stopReason === "aborted" || host.streamingMessage.stopReason === "error") {
+                    if (!errorMessage) {
+                        errorMessage = host.streamingMessage.errorMessage || t("Error");
+                    }
+                    for (const [, component] of host.pendingTools.entries()) {
+                        component.updateResult({
+                            content: [{ type: "text", text: errorMessage }],
+                            isError: true,
+                        });
+                        host.activeToolRunGroup?.noteResult(true);
+                    }
+                    // No tool execution follows an aborted/errored message:
+                    // finalize the group marker here.
+                    host.activeToolRunGroup?.markRunComplete();
+                    host.pendingTools.clear();
+                }
+                else {
+                    // Args are now complete - trigger diff computation for edit tools
+                    for (const [, component] of host.pendingTools.entries()) {
+                        component.setArgsComplete();
+                    }
+                    host.maybeShowThinkingDropNotice(host.streamingMessage);
+                    host.maybeShowCacheMissNotice(host.streamingMessage);
+                }
+                host.streamingComponent = undefined;
+                host.streamingMessage = undefined;
+                // D-083: a toolUse stop reason is followed by tool execution
+                // events (start/end arrive after message_end — the session
+                // executes tools once the streamed message completes), so the
+                // group stays open for setActiveTool/noteResult here and is
+                // finalized at agent_end / the next message_start.
+                host.footer.invalidate();
+            }
+            host.ui.requestRender();
+            break;
+        case "bash_execution_update":
+            // The bash execution callback handles TUI output rendering.
+            break;
+        case "tool_execution_start": {
+            let component = host.pendingTools.get(event.toolCallId);
+            if (!component) {
+                component = new ToolExecutionComponent(event.toolName, event.toolCallId, event.args, {
+                    showImages: host.settingsManager.getShowImages(),
+                    imageWidthCells: host.settingsManager.getImageWidthCells(),
+                }, host.getRegisteredToolDefinition(event.toolName), host.ui, host.facade.getCwd());
+                component.setExpanded(host.toolOutputExpanded);
+                host.addToolToRunGroup(component);
+                host.pendingTools.set(event.toolCallId, component);
+            }
+            component.markExecutionStarted();
+            host.activeToolRunGroup?.setActiveTool(event.toolName);
+            host.ui.requestRender();
+            break;
+        }
+        case "tool_execution_update": {
+            const component = host.pendingTools.get(event.toolCallId);
+            if (component) {
+                component.updateResult({ ...event.partialResult, isError: false }, true);
+                host.ui.requestRender();
+            }
+            break;
+        }
+        case "tool_execution_end": {
+            const component = host.pendingTools.get(event.toolCallId);
+            if (component) {
+                component.updateResult({ ...event.result, isError: event.isError });
+                host.activeToolRunGroup?.noteResult(event.isError);
+                host.pendingTools.delete(event.toolCallId);
+                host.ui.requestRender();
+            }
+            break;
+        }
+        case "capability_command_result": {
+            const links = event.result.links?.map((link) => `${link.label}: ${link.url}`) ?? [];
+            const message = [event.result.message, ...links].filter(Boolean).join("\n");
+            if (event.result.status === "error")
+                host.showError(message);
+            else
+                host.showStatus(message);
+            host.ui.requestRender();
+            break;
+        }
+        case "agent_end":
+            if (host.settingsManager.getShowTerminalProgress()) {
+                host.ui.terminal.setProgress(false);
+            }
+            host.clearStatusIndicator("working");
+            if (host.streamingComponent) {
+                host.chatContainer.removeChild(host.streamingComponent);
+                host.streamingComponent = undefined;
+                host.streamingMessage = undefined;
+            }
+            host.pendingTools.clear();
+            // D-083: the whole agent turn (messages + tool executions) is
+            // over — finalize the last group's marker (count/sole-tool name
+            // + failure count). Completed groups stay in the transcript.
+            host.activeToolRunGroup?.markRunComplete();
+            host.activeToolRunGroup = undefined;
+            host.ui.requestRender();
+            break;
+        case "agent_settled":
+            await host.checkShutdownRequested();
+            break;
+        case "compaction_start": {
+            if (host.settingsManager.getShowTerminalProgress()) {
+                host.ui.terminal.setProgress(true);
+            }
+            // Keep editor active; submissions are queued during compaction.
+            host.autoCompactionEscapeHandler = host.defaultEditor.onEscape;
+            host.defaultEditor.onEscape = () => {
+                host.facade.abortCompaction();
+            };
+            host.showStatusIndicator(new CompactionStatusIndicator(host.ui, event.reason));
+            host.ui.requestRender();
+            break;
+        }
+        case "compaction_end": {
+            if (host.settingsManager.getShowTerminalProgress()) {
+                host.ui.terminal.setProgress(false);
+            }
+            if (host.autoCompactionEscapeHandler) {
+                host.defaultEditor.onEscape = host.autoCompactionEscapeHandler;
+                host.autoCompactionEscapeHandler = undefined;
+            }
+            host.clearStatusIndicator("compaction");
+            if (event.aborted) {
+                if (event.reason === "manual") {
+                    host.showError(t("Compaction cancelled"));
+                }
+                else {
+                    host.showStatus(t("Auto-compaction cancelled"));
+                }
+            }
+            else if (event.result) {
+                const entries = host.facade.getContextEntries();
+                if (entries[0]?.type !== "compaction") {
+                    throw new Error(t("Completed compaction is missing from the session context"));
+                }
+                host.chatContainer.clear();
+                // The latest compaction is prepended for model context; append it below at its chronological position.
+                host.renderSessionEntries(entries.slice(1));
+                host.addMessageToChat(createCompactionSummaryMessage(event.result.summary, event.result.tokensBefore, new Date().toISOString()));
+                if (event.result.usage) {
+                    host.addCompactionCostNotice({
+                        type: "compaction_cost",
+                        kind: "compaction",
+                        usage: event.result.usage,
+                    });
+                }
+                host.footer.invalidate();
+            }
+            else if (event.errorMessage) {
+                if (event.reason === "manual") {
+                    host.showError(event.errorMessage);
+                }
+                else {
+                    host.chatContainer.addChild(new Spacer(1));
+                    host.chatContainer.addChild(new Text(theme.fg("error", event.errorMessage), 1, 0));
+                }
+            }
+            void host.flushCompactionQueue({ willRetry: event.willRetry });
+            host.ui.requestRender();
+            break;
+        }
+        case "compaction_skipped": {
+            host.showStatus(t("Auto-compaction skipped: nothing to compact"));
+            host.ui.requestRender();
+            break;
+        }
+        case "auto_retry_start": {
+            // Set up escape to abort retry
+            host.retryEscapeHandler = host.defaultEditor.onEscape;
+            host.defaultEditor.onEscape = () => {
+                host.facade.abortRetry();
+            };
+            host.showStatusIndicator(new RetryStatusIndicator(host.ui, event.attempt, event.maxAttempts, event.delayMs));
+            host.ui.requestRender();
+            break;
+        }
+        case "auto_retry_end": {
+            // Restore escape handler
+            if (host.retryEscapeHandler) {
+                host.defaultEditor.onEscape = host.retryEscapeHandler;
+                host.retryEscapeHandler = undefined;
+            }
+            host.clearStatusIndicator("retry");
+            // Show error only on final failure (success shows normal response)
+            if (!event.success) {
+                host.showError(t("Retry failed after {count} attempts: {error}", {
+                    count: event.attempt,
+                    error: event.finalError || t("Unknown error"),
+                }));
+            }
+            host.ui.requestRender();
+            break;
+        }
+        case "summarization_retry_scheduled": {
+            host.showError(event.errorMessage);
+            host.showStatusIndicator(new RetryStatusIndicator(host.ui, event.attempt, event.maxAttempts, event.delayMs));
+            host.ui.requestRender();
+            break;
+        }
+        case "summarization_retry_attempt_start": {
+            host.clearStatusIndicator("retry");
+            if (event.source === "branchSummary") {
+                host.showStatusIndicator(new BranchSummaryStatusIndicator(host.ui));
+            }
+            else {
+                host.showStatusIndicator(new CompactionStatusIndicator(host.ui, event.reason));
+            }
+            host.ui.requestRender();
+            break;
+        }
+        case "summarization_retry_finished": {
+            host.clearStatusIndicator("retry");
+            host.ui.requestRender();
+            break;
+        }
+    }
+}
+/** Extract text content from a user message */
+export function getUserMessageText(message) {
+    if (message.role !== "user")
+        return "";
+    const textBlocks = typeof message.content === "string"
+        ? [{ type: "text", text: message.content }]
+        : message.content.filter((c) => c.type === "text");
+    return textBlocks.map((c) => c.text).join("");
+}
+export function addMessageToChat(host, message, options) {
+    switch (message.role) {
+        case "bashExecution": {
+            const component = new BashExecutionComponent(message.command, host.ui, message.excludeFromContext);
+            if (message.output) {
+                component.appendOutput(message.output);
+            }
+            component.setComplete(message.exitCode, message.cancelled, message.truncated ? { truncated: true } : undefined, message.fullOutputPath);
+            host.chatContainer.addChild(component);
+            break;
+        }
+        case "custom": {
+            if (message.display) {
+                const renderer = undefined;
+                const component = new CustomMessageComponent(message, renderer, host.getMarkdownThemeWithSettings(), host.outputPad);
+                component.setExpanded(host.toolOutputExpanded);
+                host.chatContainer.addChild(component);
+            }
+            break;
+        }
+        case "compactionSummary": {
+            host.chatContainer.addChild(new Spacer(1));
+            const component = new CompactionSummaryMessageComponent(message, host.getMarkdownThemeWithSettings());
+            component.setExpanded(host.toolOutputExpanded);
+            host.chatContainer.addChild(component);
+            break;
+        }
+        case "branchSummary": {
+            host.chatContainer.addChild(new Spacer(1));
+            const component = new BranchSummaryMessageComponent(message, host.getMarkdownThemeWithSettings());
+            component.setExpanded(host.toolOutputExpanded);
+            host.chatContainer.addChild(component);
+            break;
+        }
+        case "user": {
+            const textContent = host.getUserMessageText(message);
+            if (textContent) {
+                if (host.chatContainer.children.length > 0) {
+                    host.chatContainer.addChild(new Spacer(1));
+                }
+                const skillBlock = parseSkillBlock(textContent);
+                if (skillBlock) {
+                    // Render skill block (collapsible)
+                    const component = new SkillInvocationMessageComponent(skillBlock, host.getMarkdownThemeWithSettings());
+                    component.setExpanded(host.toolOutputExpanded);
+                    host.chatContainer.addChild(component);
+                    // Render user message separately if present
+                    if (skillBlock.userMessage) {
+                        host.chatContainer.addChild(new Spacer(1));
+                        const userComponent = new UserMessageComponent(skillBlock.userMessage, host.getMarkdownThemeWithSettings(), host.outputPad, host.getMarkdownTransformers());
+                        host.chatContainer.addChild(userComponent);
+                    }
+                }
+                else {
+                    const userComponent = new UserMessageComponent(textContent, host.getMarkdownThemeWithSettings(), host.outputPad, host.getMarkdownTransformers());
+                    host.chatContainer.addChild(userComponent);
+                }
+                if (options?.populateHistory) {
+                    host.editor.addToHistory?.(textContent);
+                }
+            }
+            break;
+        }
+        case "assistant": {
+            const assistantComponent = new AssistantMessageComponent(message, host.hideThinkingBlock, host.getMarkdownThemeWithSettings(), host.hiddenThinkingLabel, host.outputPad, host.getMarkdownTransformers());
+            // D-083: restored/finished-turn thinking must follow detail mode
+            // (ctrl+o) — the setToolsExpanded loop only reaches children on
+            // toggle, not components created while already expanded.
+            if (host.toolOutputExpanded) {
+                assistantComponent.setExpanded(true);
+            }
+            host.chatContainer.addChild(assistantComponent);
+            break;
+        }
+        case "toolResult": {
+            // Tool results are rendered inline with tool calls, handled separately
+            break;
+        }
+        default: {
+            // v8 ignore next -- exhaustive over AgentMessage roles
+            const _exhaustive = message;
+        }
+    }
+}
+export function renderSessionItems(host, items, options = {}) {
+    host.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 = host.settingsManager.getShowCacheMissNotices()
+        ? collectCacheMisses(host.facade.getEntries(), host.facade.getModelPriceSource())
+        : new Map();
+    if (options.updateFooter) {
+        host.footer.invalidate();
+        host.updateEditorBorderColor();
+    }
+    for (const item of items) {
+        if (isCustomSessionEntry(item)) {
+            // No entry renderer source since the legacy extension surface was
+            // removed; previously renderer-less entries were skipped as well.
+            continue;
+        }
+        if (isCompactionCostNotice(item)) {
+            host.addCompactionCostNotice(item);
+            continue;
+        }
+        const message = item;
+        // Assistant messages need special handling for tool calls
+        if (message.role === "assistant") {
+            host.addMessageToChat(message);
+            // No message_start on the restore path: reset the group pointer
+            // so each assistant message forms its own tool-run group (D-083).
+            host.activeToolRunGroup = undefined;
+            // Render tool call components
+            for (const content of message.content) {
+                if (content.type === "toolCall") {
+                    const component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
+                        showImages: host.settingsManager.getShowImages(),
+                        imageWidthCells: host.settingsManager.getImageWidthCells(),
+                    }, host.getRegisteredToolDefinition(content.name), host.ui, host.facade.getCwd());
+                    component.setExpanded(host.toolOutputExpanded);
+                    host.addToolToRunGroup(component);
+                    if (message.stopReason === "aborted" || message.stopReason === "error") {
+                        let errorMessage;
+                        if (message.stopReason === "aborted") {
+                            const retryAttempt = host.facade.getRetryAttempt();
+                            errorMessage =
+                                retryAttempt > 0
+                                    ? retryAttempt === 1
+                                        ? t("Aborted after {count} retry attempt", { count: retryAttempt })
+                                        : t("Aborted after {count} retry attempts", { count: retryAttempt })
+                                    : t("Operation aborted");
+                        }
+                        else {
+                            errorMessage = message.errorMessage || t("Error");
+                        }
+                        component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
+                        host.noteResultInActiveToolRunGroup(true);
+                    }
+                    else {
+                        renderedPendingTools.set(content.id, component);
+                    }
+                }
+            }
+            host.markActiveToolRunGroupComplete();
+            if (message.stopReason !== "aborted" && message.stopReason !== "error") {
+                const miss = cacheMisses.get(message);
+                if (miss)
+                    host.addCacheMissNotice(miss);
+            }
+        }
+        else if (message.role === "toolResult") {
+            // Match tool results to pending tool components
+            const component = renderedPendingTools.get(message.toolCallId);
+            if (component) {
+                component.updateResult(message);
+                // Failure never goes silent (D-083): count it on the group
+                // the restored tool call belongs to.
+                host.noteResultInActiveToolRunGroup(message.isError);
+                renderedPendingTools.delete(message.toolCallId);
+            }
+        }
+        else {
+            // All other messages use standard rendering
+            host.addMessageToChat(message, options);
+        }
+    }
+    for (const [toolCallId, component] of renderedPendingTools) {
+        host.pendingTools.set(toolCallId, component);
+    }
+    // Groups stay in the transcript; reset the pointer so a live turn
+    // starts a fresh group (D-083).
+    host.activeToolRunGroup = undefined;
+    host.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
+ */
+export function renderSessionEntries(host, entries, options = {}) {
+    const items = entries.flatMap((entry) => {
+        if (entry.type === "custom") {
+            return [entry];
+        }
+        const messages = sessionEntryToContextMessages(entry);
+        if ((entry.type === "compaction" || entry.type === "branch_summary") && entry.usage && messages.length > 0) {
+            return [...messages, { type: "compaction_cost", kind: entry.type, usage: entry.usage }];
+        }
+        return messages;
+    });
+    host.renderSessionItems(items, options);
+}
+/**
+ * Render billing usage for a compaction or branch summary. The notice is derived
+ * from persisted summary usage and is not stored as a separate session entry.
+ */
+export function addCompactionCostNotice(host, notice) {
+    if (!host.settingsManager.getShowCacheMissNotices())
+        return;
+    const { usage } = notice;
+    const tokens = usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+    const cost = usage.cost.total >= 0.01 ? ` (~$${usage.cost.total.toFixed(2)})` : "";
+    const label = notice.kind === "compaction" ? t("Compaction") : t("Branch summary");
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Text(theme.fg("warning", `${label}: ${t("{tokens} tokens billed{cost}", { tokens: formatTokens(tokens), cost })}`), 1, 0));
+}
+function countDroppedThinkingBlocks(message) {
+    let count = 0;
+    for (const diagnostic of message.diagnostics ?? []) {
+        if (diagnostic.type !== "anthropic_input_transformations")
+            continue;
+        const transformations = diagnostic.details?.transformations;
+        if (!Array.isArray(transformations))
+            continue;
+        count += transformations.filter((transformation) => typeof transformation === "object" &&
+            transformation !== null &&
+            transformation.type === "thinking_dropped").length;
+    }
+    return count;
+}
+export function maybeShowThinkingDropNotice(host, message) {
+    if (!host.settingsManager.getShowCacheMissNotices())
+        return;
+    const droppedCount = countDroppedThinkingBlocks(message);
+    if (droppedCount === 0)
+        return;
+    let previousDroppedCount = 0;
+    // message_end reaches the UI before the current message is persisted,
+    // so the branch's last assistant message is the previous response.
+    const entries = host.facade.getEntries();
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.type === "message" && entry.message.role === "assistant") {
+            previousDroppedCount = countDroppedThinkingBlocks(entry.message);
+            break;
+        }
+    }
+    if (droppedCount <= previousDroppedCount)
+        return;
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Text(theme.fg("warning", t("Anthropic dropped {count} thinking blocks (details in session)", { count: droppedCount })), 1, 0));
+}
+/**
+ * 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.
+ */
+export function maybeShowCacheMissNotice(host, message) {
+    if (!host.settingsManager.getShowCacheMissNotices())
+        return;
+    // Entries don't contain `message` yet: message_end fires before persistence.
+    const miss = detectCacheMiss(host.facade.getEntries(), message, host.facade.getModelPriceSource());
+    if (miss)
+        host.addCacheMissNotice(miss);
+}
+export function addCacheMissNotice(host, miss) {
+    if (miss.missedTokens < 20_000 && miss.missedCost < 0.1)
+        return;
+    const cost = miss.missedCost >= 0.01 ? ` (~$${miss.missedCost.toFixed(2)})` : "";
+    const reBilled = t("{tokens} tokens re-billed{cost}", { tokens: formatTokens(miss.missedTokens), cost });
+    let label = t("Cache miss");
+    if (miss.modelChanged) {
+        label = t("Cache miss after model switch");
+    }
+    else if (miss.idleMs >= CACHE_TTL_MS) {
+        label = t("Cache miss after {minutes}m idle", { minutes: Math.round(miss.idleMs / 60_000) });
+    }
+    const text = theme.fg("warning", `${label}: ${reBilled}`);
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Text(text, 1, 0));
+}
+export function renderInitialMessages(host) {
+    const entries = host.facade.getContextEntries();
+    host.renderSessionEntries(entries, {
+        updateFooter: true,
+        populateHistory: true,
+    });
+    // Show compaction info if session was compacted
+    const allEntries = host.facade.getEntries();
+    const compactionCount = allEntries.filter((e) => e.type === "compaction").length;
+    if (compactionCount > 0) {
+        host.showStatus(compactionCount === 1
+            ? t("Session compacted {count} time", { count: compactionCount })
+            : t("Session compacted {count} times", { count: compactionCount }));
+    }
+}
+export function rebuildChatFromMessages(host) {
+    host.chatContainer.clear();
+    host.renderSessionEntries(host.facade.getContextEntries());
+}
+export function getRegisteredToolDefinition(host, toolName) {
+    return host.facade.getToolDefinition(toolName);
+}
+export function getMarkdownTransformers(host) {
+    return [host.mermaidMarkdownTransformer];
+}
+/**
+ * D-083 quiet transcript: mount a tool component into the current
+ * assistant turn's tool-run group (creating the group on first tool of
+ * the turn) instead of the chat container directly. Collapsed groups
+ * render one dim marker line for the whole turn.
+ */
+export function addToolToRunGroup(host, component) {
+    if (!host.activeToolRunGroup) {
+        host.activeToolRunGroup = new ToolRunGroupComponent();
+        host.activeToolRunGroup.setExpanded(host.toolOutputExpanded);
+        host.chatContainer.addChild(host.activeToolRunGroup);
+    }
+    host.activeToolRunGroup.addTool(component);
+}
+/**
+ * Narrowing-safe faces for the active group inside renderSessionItems:
+ * addToolToRunGroup may (re)assign host.activeToolRunGroup behind the
+ * compiler's back, so group reads go through methods instead of the
+ * narrowed property reference.
+ */
+export function noteResultInActiveToolRunGroup(host, isError) {
+    host.activeToolRunGroup?.noteResult(isError);
+}
+export function markActiveToolRunGroupComplete(host) {
+    host.activeToolRunGroup?.markRunComplete();
+}
+//# sourceMappingURL=interactive-events.js.map