pi-ui-extend 0.1.32 → 0.1.33

package/README.md

@@ -212,7 +212,7 @@ Type `/` in the prompt to open the command picker. Commands that accept argument
 | `/import` | `<path.jsonl>` | Import and resume a session from a JSONL file. |
 | `/share` | — | Share the session as a private GitHub gist (requires `gh` CLI). |
 | `/copy` | — | Copy the last agent message to the clipboard. |
-| `/name` | `[name]` | Show or set the session display name. |
+| `/name` | `[name]` | Set the session display name. Without arguments, generate one automatically using the session-title logic. |
 | `/session` | — | Show session info: message counts, token usage, and cost. |
 | `/usage` | — | Show local account quota usage and context window utilization. |
 | `/changelog` | — | Show the Pi package changelog. |

package/dist/app/app.d.ts

@@ -109,6 +109,8 @@ export declare class PiUiExtendApp {
     private render;
     private scheduleRender;
     private syncScrollAfterInputEditorChange;
+    private conversationQuickScrollDirections;
+    private scrollConversationQuick;
     private renderStatusLine;
     private terminalColumns;
     private terminalRows;

package/dist/app/app.js

@@ -183,10 +183,13 @@ export class PiUiExtendApp {
             loadSessionHistoryAsync: (options) => this.loadSessionHistoryAsync(options),
             captureSessionView: () => this.captureSessionView(),
             restoreSessionView: (view) => this.restoreSessionView(view),
+            restoreScrollState: (state) => this.scrollController.restoreState(state),
             syncUserSessionEntryMetadata: () => this.workspaceActions.syncUserSessionEntryMetadata(),
             captureInputState: () => this.inputEditor.draftState,
             restoreInputState: (state) => this.restoreTabInputState(state),
             closeMenusForTabSwitch: () => this.popupMenus.closeMenusForTabSwitch(),
+            captureAutoUserMessages: () => this.queuedMessages.captureAutoUserMessages(),
+            restoreAutoUserMessages: (messages) => this.queuedMessages.restoreAutoUserMessages(messages),
             captureDeferredUserMessages: () => this.queuedMessages.captureDeferredUserMessages(),
             restoreDeferredUserMessages: (messages) => this.queuedMessages.restoreDeferredUserMessages(messages),
             addEntry: (entry) => this.addEntry(entry),
@@ -283,6 +286,7 @@ export class PiUiExtendApp {
             terminalBellSoundStatusWidgetEnabled: () => this.terminalBellSoundController.isEnabled(),
             voiceStatusWidgetText: () => this.voiceController.statusWidgetText(),
             voiceStatusWidgetActive: () => this.voiceController.statusWidgetActive(),
+            conversationQuickScrollDirections: () => this.conversationQuickScrollDirections(),
             queueableInputActive: () => this.inputEditor.promptText.trimEnd().length > 0 || this.inputEditor.images.length > 0,
             userMessageJumpMenuActive: () => this.popupMenus.directMenu === "user-message-jump",
             allThinkingExpandedActive: () => this.allThinkingExpanded,
@@ -364,6 +368,7 @@ export class PiUiExtendApp {
             setSessionStatus: (session) => this.setSessionStatus(session),
             setSessionActivity: (activity) => this.setSessionActivity(activity),
             updateQueuedMessageStatus: () => this.queuedMessages.updateQueuedMessageStatus(),
+            flushAutoUserMessages: () => { void this.queuedMessages.flushAutoUserMessages(); },
             prepareWorkspaceMutation: (toolName, args) => this.workspaceActions.prepareWorkspaceMutation(toolName, args),
             workspaceMutationFromToolExecution: (input) => this.workspaceActions.workspaceMutationFromToolExecution(input),
             recordWorkspaceMutationForUserEntry: (entryId, mutation) => this.workspaceActions.recordWorkspaceMutationForUserEntry(entryId, mutation),
@@ -420,6 +425,7 @@ export class PiUiExtendApp {
             colors: this.theme.colors,
             pixConfig: this.pixConfig,
             outputFilters: this.outputFilters,
+            availableThinkingLevels: () => this.runtime?.session.getAvailableThinkingLevels(),
             hasDynamicConversationBlock: () => this.popupMenus.hasDynamicConversationBlock(),
             isDynamicConversationBlock: (entry) => this.popupMenus.isDynamicConversationBlock(entry),
             renderInlineUserMessageMenu: (entry, context) => this.popupMenus.renderInlineUserMessageMenu(entry, context),
@@ -433,6 +439,9 @@ export class PiUiExtendApp {
             hasOlderSessionHistory: () => this.sessionEvents.hasOlderSessionHistory(),
             isLoadingOlderSessionHistory: () => this.sessionEvents.isLoadingOlderSessionHistory(),
             loadOlderSessionHistory: (options) => this.sessionEvents.loadOlderSessionHistory(options),
+            hasNewerSessionHistory: () => this.sessionEvents.hasNewerSessionHistory(),
+            isLoadingNewerSessionHistory: () => this.sessionEvents.isLoadingNewerSessionHistory(),
+            loadNewerSessionHistory: (options) => this.sessionEvents.loadNewerSessionHistory(options),
             render: () => this.render(),
         });
         this.commandController = new AppCommandController({
@@ -564,6 +573,7 @@ export class PiUiExtendApp {
                     this.render();
                 });
             },
+            scrollConversationQuick: (direction) => this.scrollConversationQuick(direction),
             toggleAllThinkingExpanded: () => {
                 this.allThinkingExpanded = !this.allThinkingExpanded;
                 this.render();
@@ -904,12 +914,14 @@ export class PiUiExtendApp {
         return {
             entries: [...this.entries],
             eventState: this.sessionEvents.snapshotState(),
+            scrollState: this.scrollController.captureState(),
         };
     }
     restoreSessionView(view) {
         this.entries.splice(0, this.entries.length, ...view.entries);
         this.sessionEvents.restoreState(view.eventState);
         this.conversationViewport.clear();
+        this.scrollController.restoreState(view.scrollState);
         this.workspaceActions.syncUserSessionEntryMetadata();
     }
     loadSessionHistory() {
@@ -1109,6 +1121,22 @@ export class PiUiExtendApp {
         this.lastInputEditorContentVersion = contentVersion;
         this.scrollController.scrollToBottom();
     }
+    conversationQuickScrollDirections() {
+        const columns = this.terminalColumns();
+        const terminalRows = this.terminalRows();
+        const rows = Math.max(1, terminalRows - this.tabLineRenderer.panelRows(terminalRows));
+        const { bodyHeight } = this.editorLayoutRenderer.computeLayout(columns, rows);
+        if (bodyHeight <= 0)
+            return { up: false, down: false };
+        return this.scrollController.quickScrollDirections(columns, bodyHeight);
+    }
+    async scrollConversationQuick(direction) {
+        const changed = direction === "up"
+            ? await this.scrollController.scrollToAbsoluteTop()
+            : await this.scrollController.scrollToAbsoluteBottom();
+        if (changed)
+            this.render();
+    }
     renderStatusLine() {
         this.renderController.renderStatusLine();
     }

package/dist/app/commands/command-session-actions.js

@@ -10,6 +10,8 @@ import { copyTextToClipboard } from "../screen/clipboard.js";
 import { formatAccountUsageReport, queryAccountUsageReport } from "../model/model-usage-status.js";
 import { checkPixUpdate, formatPixUpdateCheck, parsePixUpdateArgs, pixUpdateUsage } from "../cli/update.js";
 import { createStartupInfoMessage } from "../cli/startup-info.js";
+import { loadSessionTitleConfig } from "../../bundled-extensions/session-title/config.js";
+import { fallbackSessionTitleFromInput, firstUserMessageText, generateSessionTitle, sessionTitleModelRefs, } from "../../bundled-extensions/session-title/title-generation.js";
 export class SessionCommandActions {
     host;
     constructor(host) {
@@ -100,8 +102,34 @@ export class SessionCommandActions {
             return;
         const name = argumentsText.trim();
         if (!name) {
-            this.host.addEntry({ id: createId("system"), kind: "system", text: `Session name: ${runtime.session.sessionName ?? "(none)"}` });
+            const branch = runtime.session.sessionManager.getBranch();
+            const firstPrompt = firstUserMessageText(branch);
+            if (!firstPrompt)
+                throw new Error("Cannot auto-name this session yet: no user messages found.");
+            const config = loadSessionTitleConfig(runtime.cwd);
+            const fallbackTitle = fallbackSessionTitleFromInput(firstPrompt, config.maxTitleChars);
+            const modelRefs = sessionTitleModelRefs(config);
+            let generatedName;
+            this.host.setStatus("generating session name");
+            this.host.render();
+            if (config.enabled) {
+                for (const modelRef of modelRefs) {
+                    for (let attempt = 0; attempt < config.generationAttempts; attempt++) {
+                        generatedName = await generateSessionTitle(firstPrompt.slice(0, config.maxInputChars).trim(), runtime.services.modelRegistry, config, modelRef, AbortSignal.timeout(config.timeoutMs));
+                        if (generatedName)
+                            break;
+                    }
+                    if (generatedName)
+                        break;
+                }
+            }
+            const nextName = generatedName ?? fallbackTitle;
+            if (!nextName)
+                throw new Error("Could not generate a session name for this session.");
+            runtime.session.setSessionName(nextName);
+            this.host.addEntry({ id: createId("system"), kind: "system", text: `Session name set: ${nextName}` });
             this.host.setSessionStatus(runtime.session);
+            this.host.render();
             return;
         }
         runtime.session.setSessionName(name);

package/dist/app/constants.d.ts

@@ -1,7 +1,7 @@
 import type { ResolvedToolRule } from "../config.js";
 export declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh"];
 export declare const THINKING_MENU_MAX_ROWS: number;
-export declare const PI_FAVORITE_MODEL_REFS: readonly ["amazon-bedrock/us.anthropic.claude-opus-4-6-v1", "anthropic/claude-opus-4-8", "openai/gpt-5.4", "azure-openai-responses/gpt-5.4", "openai-codex/gpt-5.5", "deepseek/deepseek-v4-pro", "google/gemini-3.1-pro-preview", "google-vertex/gemini-3.1-pro-preview", "github-copilot/gpt-5.4", "openrouter/moonshotai/kimi-k2.6", "vercel-ai-gateway/zai/glm-5.1", "xai/grok-4.20-0309-reasoning", "groq/openai/gpt-oss-120b", "cerebras/zai-glm-4.7", "zai/glm-5.1", "mistral/devstral-medium-latest", "minimax/MiniMax-M2.7", "minimax-cn/MiniMax-M2.7", "moonshotai/kimi-k2.6", "moonshotai-cn/kimi-k2.6", "huggingface/moonshotai/Kimi-K2.6", "fireworks/accounts/fireworks/models/kimi-k2p6", "together/moonshotai/Kimi-K2.6", "opencode/kimi-k2.6", "opencode-go/kimi-k2.6", "kimi-coding/kimi-for-coding", "cloudflare-workers-ai/@cf/moonshotai/kimi-k2.6", "cloudflare-ai-gateway/workers-ai/@cf/moonshotai/kimi-k2.6", "xiaomi/mimo-v2.5-pro", "xiaomi-token-plan-cn/mimo-v2.5-pro", "xiaomi-token-plan-ams/mimo-v2.5-pro", "xiaomi-token-plan-sgp/mimo-v2.5-pro"];
+export declare const PI_FAVORITE_MODEL_REFS: readonly ["amazon-bedrock/us.anthropic.claude-opus-4-6-v1", "anthropic/claude-opus-4-8", "openai/gpt-5.4", "azure-openai-responses/gpt-5.4", "openai-codex/gpt-5.5", "deepseek/deepseek-v4-pro", "google/gemini-3.1-pro-preview", "google-vertex/gemini-3.1-pro-preview", "github-copilot/gpt-5.4", "openrouter/moonshotai/kimi-k2.6", "vercel-ai-gateway/zai/glm-5.2", "xai/grok-4.20-0309-reasoning", "groq/openai/gpt-oss-120b", "cerebras/zai-glm-4.7", "zai/glm-5.2", "mistral/devstral-medium-latest", "minimax/MiniMax-M2.7", "minimax-cn/MiniMax-M2.7", "moonshotai/kimi-k2.6", "moonshotai-cn/kimi-k2.6", "huggingface/moonshotai/Kimi-K2.6", "fireworks/accounts/fireworks/models/kimi-k2p6", "together/moonshotai/Kimi-K2.6", "opencode/kimi-k2.6", "opencode-go/kimi-k2.6", "kimi-coding/kimi-for-coding", "cloudflare-workers-ai/@cf/moonshotai/kimi-k2.6", "cloudflare-ai-gateway/workers-ai/@cf/moonshotai/kimi-k2.6", "xiaomi/mimo-v2.5-pro", "xiaomi-token-plan-cn/mimo-v2.5-pro", "xiaomi-token-plan-ams/mimo-v2.5-pro", "xiaomi-token-plan-sgp/mimo-v2.5-pro"];
 export declare const SLASH_COMMAND_MENU_MAX_ROWS = 6;
 export declare const RESUME_MENU_MAX_ROWS = 20;
 export declare const RESUME_MENU_INITIAL_SESSION_ROWS = 30;

package/dist/app/constants.js

@@ -12,11 +12,11 @@ export const PI_FAVORITE_MODEL_REFS = [
     "google-vertex/gemini-3.1-pro-preview",
     "github-copilot/gpt-5.4",
     "openrouter/moonshotai/kimi-k2.6",
-    "vercel-ai-gateway/zai/glm-5.1",
+    "vercel-ai-gateway/zai/glm-5.2",
     "xai/grok-4.20-0309-reasoning",
     "groq/openai/gpt-oss-120b",
     "cerebras/zai-glm-4.7",
-    "zai/glm-5.1",
+    "zai/glm-5.2",
     "mistral/devstral-medium-latest",
     "minimax/MiniMax-M2.7",
     "minimax-cn/MiniMax-M2.7",

package/dist/app/icons.d.ts

@@ -1,5 +1,5 @@
-export declare const PIX_ICON_THEME_ENV = "PIX_ICON_THEME";
-export declare const PIX_USE_FALLBACK_ICONS_ENV = "PIX_USE_FALLBACK_ICONS";
+import { type AppIconThemeName } from "../icon-theme.js";
+export { appIconThemeFromFallbackFlag, appIconThemeOverrideFromEnv, parseAppIconThemeName, resolveAppIconThemeNameFromEnv, PIX_ICON_THEME_ENV, PIX_USE_FALLBACK_ICONS_ENV, type AppIconThemeName, } from "../icon-theme.js";
 declare const NERD_FONT_ICONS: {
     readonly alert: "󰀦";
     readonly autoFix: "󰁨";
@@ -28,17 +28,12 @@ declare const NERD_FONT_ICONS: {
     readonly toolBodyEnd: "└";
     readonly toolBodyGutter: "│";
     readonly toolPreviewTruncated: "⊞";
-    readonly down: "󰁅";
+    readonly up: "↑";
+    readonly down: "↓";
 };
 export type AppIconName = keyof typeof NERD_FONT_ICONS;
 export type AppIconMap = Record<AppIconName, string>;
-export type AppIconThemeName = "nerdFont" | "fallback";
 export declare const APP_ICON_THEMES: Record<AppIconThemeName, AppIconMap>;
 export declare const APP_ICONS: AppIconMap;
 export declare function currentAppIconTheme(): AppIconThemeName;
-export declare function parseAppIconThemeName(value: unknown): AppIconThemeName | undefined;
-export declare function appIconThemeFromFallbackFlag(value: unknown): AppIconThemeName | undefined;
-export declare function resolveAppIconThemeNameFromEnv(env?: NodeJS.ProcessEnv): AppIconThemeName;
-export declare function appIconThemeOverrideFromEnv(env?: NodeJS.ProcessEnv): AppIconThemeName | undefined;
 export declare function setAppIconTheme(themeName: AppIconThemeName): void;
-export {};

package/dist/app/icons.js

@@ -4,8 +4,13 @@
 //
 // Use codepoint escapes for private-use characters so editors cannot silently
 // substitute visually similar glyphs.
-export const PIX_ICON_THEME_ENV = "PIX_ICON_THEME";
-export const PIX_USE_FALLBACK_ICONS_ENV = "PIX_USE_FALLBACK_ICONS";
+//
+// Theme-name parsing/resolution lives in the dependency-free src/icon-theme.ts so
+// configuration loading can resolve the theme without importing this app/ module
+// (breaks the src/config.ts <-> src/app/icons.ts import cycle).
+import { resolveAppIconThemeNameFromEnv, } from "../icon-theme.js";
+// Re-exported for existing importers; the canonical home is src/icon-theme.ts.
+export { appIconThemeFromFallbackFlag, appIconThemeOverrideFromEnv, parseAppIconThemeName, resolveAppIconThemeNameFromEnv, PIX_ICON_THEME_ENV, PIX_USE_FALLBACK_ICONS_ENV, } from "../icon-theme.js";
 const NERD_FONT_ICONS = {
     alert: "\u{f0026}",
     autoFix: "\u{f0068}",
@@ -34,7 +39,8 @@ const NERD_FONT_ICONS = {
     toolBodyEnd: "└",
     toolBodyGutter: "│",
     toolPreviewTruncated: "⊞",
-    down: "\u{f0045}",
+    up: "↑",
+    down: "↓",
 };
 const FALLBACK_ICONS = {
     alert: "!",
@@ -64,7 +70,8 @@ const FALLBACK_ICONS = {
     toolBodyEnd: "`",
     toolBodyGutter: "|",
     toolPreviewTruncated: "+",
-    down: "v",
+    up: "↑",
+    down: "↓",
 };
 export const APP_ICON_THEMES = {
     nerdFont: NERD_FONT_ICONS,
@@ -75,36 +82,6 @@ export const APP_ICONS = { ...APP_ICON_THEMES[currentAppIconThemeName] };
 export function currentAppIconTheme() {
     return currentAppIconThemeName;
 }
-export function parseAppIconThemeName(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const normalized = value.trim().toLowerCase().replace(/[\s_-]+/gu, "");
-    if (normalized === "fallback" || normalized === "plain" || normalized === "ascii")
-        return "fallback";
-    if (normalized === "nerdfont" || normalized === "font" || normalized === "icons")
-        return "nerdFont";
-    return undefined;
-}
-export function appIconThemeFromFallbackFlag(value) {
-    if (typeof value === "boolean")
-        return value ? "fallback" : "nerdFont";
-    if (typeof value !== "string")
-        return undefined;
-    const normalized = value.trim().toLowerCase();
-    if (["1", "true", "yes", "on", "fallback"].includes(normalized))
-        return "fallback";
-    if (["0", "false", "no", "off", "nerdfont", "nerd-font"].includes(normalized))
-        return "nerdFont";
-    return undefined;
-}
-export function resolveAppIconThemeNameFromEnv(env = process.env) {
-    return appIconThemeOverrideFromEnv(env) ?? "nerdFont";
-}
-export function appIconThemeOverrideFromEnv(env = process.env) {
-    return appIconThemeFromFallbackFlag(env[PIX_USE_FALLBACK_ICONS_ENV])
-        ?? parseAppIconThemeName(env[PIX_ICON_THEME_ENV])
-        ?? undefined;
-}
 export function setAppIconTheme(themeName) {
     currentAppIconThemeName = themeName;
     Object.assign(APP_ICONS, APP_ICON_THEMES[themeName]);

package/dist/app/rendering/conversation-entry-renderer.d.ts

@@ -11,6 +11,7 @@ export type ConversationEntryRenderOptions = {
     colors: Theme["colors"];
     pixConfig: PixConfig;
     outputFilters: readonly RegExp[];
+    availableThinkingLevels?: readonly string[];
     superCompactTools?: boolean;
     allThinkingExpanded?: boolean;
     renderInlineUserMessageMenu: (entry: Extract<Entry, {

package/dist/app/rendering/conversation-tool-renderer.d.ts

@@ -5,6 +5,7 @@ export type ConversationToolRenderOptions = {
     cwd: string;
     pixConfig: PixConfig;
     colors: Theme["colors"];
+    availableThinkingLevels?: readonly string[];
     superCompactTools?: boolean;
     allThinkingExpanded?: boolean;
 };

package/dist/app/rendering/conversation-tool-renderer.js

@@ -1,12 +1,13 @@
 import { resolveColor, resolveToolRule } from "../../config.js";
 import { formatMarkdownTables, markdownSyntaxHighlightsForText } from "../../markdown-format.js";
 import { renderToolDisplay } from "../../tool-renderers/index.js";
-import { DEFAULT_THINKING_TOOL_RULE, SUBAGENT_STATUSES, THINKING_TOOL_NAME, TODO_TOOL_NAME } from "../constants.js";
+import { SUBAGENT_STATUSES, THINKING_TOOL_NAME, TODO_TOOL_NAME } from "../constants.js";
 import { attachImageClickTargets } from "../screen/image-click-targets.js";
 import { formatStructuredText } from "./message-content.js";
 import { formatSubagentTimestamp, isSubagentRunRenderDetails, isSubagentsToolName, subagentRunName, subagentStatusIcon, taskPreviewMap, } from "../subagents/subagents-model.js";
 import { formatTodoTaskLine, isTodoDetails, visibleTodoTasks } from "../todo/todo-model.js";
 import { renderToolBlock } from "./tool-block-renderer.js";
+import { thinkingLevelThemeColor } from "./status-line-renderer.js";
 export function renderConversationToolEntry(entry, width, options) {
     const todoLines = renderTodoToolEntry(entry, width, options);
     if (todoLines)
@@ -46,12 +47,15 @@ export function renderConversationToolEntry(entry, width, options) {
     return attachImageClickTargets(lines, entry.id, entry.images, { foreground: options.colors.info, underline: true });
 }
 export function renderThinkingEntry(entry, width, options) {
-    const rule = resolveThinkingToolRule(options.pixConfig);
+    const rule = resolveToolRule(THINKING_TOOL_NAME, options.pixConfig.toolRenderer);
     const markdownText = entry.text ? formatMarkdownTables(entry.text, Math.max(1, width - 2)) : "";
     const expandedText = trimTrailingBlankLines(markdownText);
     const forceExpanded = Boolean(options.allThinkingExpanded);
     const compactExpandedText = options.superCompactTools && forceExpanded ? removeBlankLines(expandedText) : expandedText;
     const expanded = forceExpanded || (entry.expanded && expandedText.trim().length > 0);
+    const headerColorOverride = entry.level
+        ? thinkingLevelThemeColor(entry.level, options.colors, options.availableThinkingLevels)
+        : undefined;
     return renderToolBlock({
         id: entry.id,
         toolName: THINKING_TOOL_NAME,
@@ -63,7 +67,12 @@ export function renderThinkingEntry(entry, width, options) {
         expandedText: compactExpandedText || "(empty)",
         bodyWrap: "word",
         syntaxHighlight: compactExpandedText ? markdownSyntaxHighlightsForText(compactExpandedText) : undefined,
-    }, rule, width, options.colors, { superCompact: Boolean(options.superCompactTools && !forceExpanded), backgroundOverride: options.colors.thinkingMessageBackground, skipHeaderBackground: true, showGutter: false });
+    }, rule, width, options.colors, {
+        superCompact: Boolean(options.superCompactTools && !forceExpanded),
+        backgroundOverride: options.colors.thinkingMessageBackground,
+        showGutter: true,
+        ...(headerColorOverride === undefined ? {} : { headerColorOverride }),
+    });
 }
 function trimTrailingBlankLines(text) {
     return text.replace(/(?:\r?\n[ \t]*)+$/u, "");
@@ -199,18 +208,3 @@ function formatSubagentToolLine(agent, preview) {
         parts.push(`retry:${agent.retryCount}`);
     return parts.join(" ");
 }
-function resolveThinkingToolRule(pixConfig) {
-    const configured = pixConfig.toolRenderer.tools[THINKING_TOOL_NAME];
-    if (!configured)
-        return DEFAULT_THINKING_TOOL_RULE;
-    const rule = {
-        previewLines: configured.previewLines ?? DEFAULT_THINKING_TOOL_RULE.previewLines,
-        direction: configured.direction ?? DEFAULT_THINKING_TOOL_RULE.direction,
-        color: configured.color ?? DEFAULT_THINKING_TOOL_RULE.color,
-    };
-    if (configured.compactHidden != null)
-        rule.compactHidden = configured.compactHidden;
-    if (configured.hidden != null)
-        rule.hidden = configured.hidden;
-    return rule;
-}

package/dist/app/rendering/conversation-viewport.d.ts

@@ -9,6 +9,7 @@ export type ConversationViewportHost = {
     readonly colors: Theme["colors"];
     readonly pixConfig: PixConfig;
     readonly outputFilters: readonly RegExp[];
+    availableThinkingLevels?(): readonly string[] | undefined;
     readonly superCompactTools?: boolean;
     readonly allThinkingExpanded?: boolean;
     hasDynamicConversationBlock?(): boolean;
@@ -36,11 +37,14 @@ export declare class ConversationViewport {
     entries(): Entry[];
     blockForEntry(entry: Entry, width: number): ConversationBlockCache;
     entryBlockPositions(width: number): ConversationEntryBlockPosition[];
+    entryBlockPositionById(width: number, entryId: string): ConversationEntryBlockPosition | undefined;
     measuredLineCountForEntries(width: number, entryIds: readonly string[]): number;
     private layoutForWidth;
     private buildLayout;
     private previousMeasuredLineCount;
     private layoutStructureChanged;
+    private syncLayoutStructure;
+    private rebuildOffsets;
     private refreshDirtyLayoutEntries;
     private blockCacheForWidth;
     private refreshDynamicLayoutEntries;

package/dist/app/rendering/conversation-viewport.js

@@ -73,11 +73,13 @@ export class ConversationViewport {
         const dynamic = this.host.isDynamicConversationBlock(entry);
         if (!dynamic && cached?.version === version)
             return cached;
+        const availableThinkingLevels = this.host.availableThinkingLevels?.();
         const lines = renderConversationEntryLines(entry, width, {
             cwd: this.host.cwd,
             colors: this.host.colors,
             pixConfig: this.host.pixConfig,
             outputFilters: this.host.outputFilters,
+            ...(availableThinkingLevels ? { availableThinkingLevels } : {}),
             superCompactTools: Boolean(this.host.superCompactTools),
             allThinkingExpanded: Boolean(this.host.allThinkingExpanded),
             renderInlineUserMessageMenu: (userEntry, context) => this.host.renderInlineUserMessageMenu(userEntry, context),
@@ -102,6 +104,23 @@ export class ConversationViewport {
             block: this.blockForEntry(entry, width),
         }));
     }
+    entryBlockPositionById(width, entryId) {
+        const layout = this.layoutForWidth(width);
+        const targetIndex = layout.positions.get(entryId);
+        if (targetIndex === undefined)
+            return undefined;
+        for (let index = 0; index <= targetIndex; index += 1)
+            this.ensureEntryMeasured(layout, width, index);
+        const entry = layout.entries[targetIndex];
+        if (!entry)
+            return undefined;
+        return {
+            entry,
+            offset: layout.offsets[targetIndex] ?? 0,
+            lineCount: layout.lineCounts[targetIndex] ?? 0,
+            block: this.blockForEntry(entry, width),
+        };
+    }
     measuredLineCountForEntries(width, entryIds) {
         if (entryIds.length === 0)
             return 0;
@@ -122,16 +141,21 @@ export class ConversationViewport {
         const superCompactTools = Boolean(this.host.superCompactTools);
         const allThinkingExpanded = Boolean(this.host.allThinkingExpanded);
         let layout = this.layoutCachesByWidth.get(width);
-        if (!layout || this.layoutStructureChanged(layout, entries, superCompactTools, allThinkingExpanded)) {
-            const previousLayout = layout && layout.superCompactTools === superCompactTools && layout.allThinkingExpanded === allThinkingExpanded
-                ? layout
-                : undefined;
-            layout = this.buildLayout(entries, width, superCompactTools, allThinkingExpanded, previousLayout);
+        if (!layout) {
+            layout = this.buildLayout(entries, width, superCompactTools, allThinkingExpanded);
             this.layoutCachesByWidth.set(width, layout);
         }
-        else {
-            this.refreshDirtyLayoutEntries(layout, width);
+        else if (this.layoutStructureChanged(layout, entries, superCompactTools, allThinkingExpanded)) {
+            const synced = this.syncLayoutStructure(layout, entries, width, superCompactTools, allThinkingExpanded);
+            if (!synced) {
+                const previousLayout = layout.superCompactTools === superCompactTools && layout.allThinkingExpanded === allThinkingExpanded
+                    ? layout
+                    : undefined;
+                layout = this.buildLayout(entries, width, superCompactTools, allThinkingExpanded, previousLayout);
+                this.layoutCachesByWidth.set(width, layout);
+            }
         }
+        this.refreshDirtyLayoutEntries(layout, width);
         if (this.host.hasDynamicConversationBlock?.()) {
             this.refreshDynamicLayoutEntries(layout, width);
         }
@@ -173,12 +197,61 @@ export class ConversationViewport {
         return previousLayout.lineCounts[previousIndex];
     }
     layoutStructureChanged(layout, entries, superCompactTools, allThinkingExpanded) {
-        if (layout.entries.length !== entries.length || layout.superCompactTools !== superCompactTools || layout.allThinkingExpanded !== allThinkingExpanded)
+        if (layout.entryIds.length !== entries.length || layout.superCompactTools !== superCompactTools || layout.allThinkingExpanded !== allThinkingExpanded)
             return true;
-        if (layout.entries.length === 0)
+        if (layout.entryIds.length === 0)
             return false;
         return layout.entryIds[0] !== entries[0]?.id || layout.entryIds[layout.entryIds.length - 1] !== entries[entries.length - 1]?.id;
     }
+    syncLayoutStructure(layout, entries, width, superCompactTools, allThinkingExpanded) {
+        if (layout.superCompactTools !== superCompactTools || layout.allThinkingExpanded !== allThinkingExpanded)
+            return false;
+        const currentEntryIds = entries.map((entry) => entry.id);
+        const overlap = layoutOverlap(layout.entryIds, currentEntryIds);
+        if (!overlap)
+            return false;
+        const estimatedBlockLineCounts = entries.map((entry) => this.estimatedBlockLineCountForEntry(entry, width));
+        const lineCounts = [];
+        const measuredLineCounts = [];
+        const positions = new Map();
+        for (let index = 0; index < entries.length; index += 1) {
+            const entry = entries[index];
+            positions.set(entry.id, index);
+            const oldIndex = index >= overlap.currentStart && index < overlap.currentStart + overlap.length
+                ? overlap.previousStart + index - overlap.currentStart
+                : undefined;
+            if (oldIndex !== undefined) {
+                lineCounts.push(layout.lineCounts[oldIndex] ?? 0);
+                measuredLineCounts.push(layout.measuredLineCounts[oldIndex] === true);
+                continue;
+            }
+            lineCounts.push(this.estimatedLineCountForEntry(entry, entries, index, estimatedBlockLineCounts));
+            measuredLineCounts.push(false);
+        }
+        layout.entries = entries;
+        layout.entryIds = currentEntryIds;
+        layout.lineCounts = lineCounts;
+        layout.measuredLineCounts = measuredLineCounts;
+        layout.positions = positions;
+        this.rebuildOffsets(layout);
+        const changedNextIndexes = new Set([overlap.currentStart - 1, overlap.currentStart + overlap.length - 1]);
+        for (const index of changedNextIndexes) {
+            if (index >= 0 && index < entries.length)
+                this.refreshLayoutEntry(layout, width, index, layout.measuredLineCounts[index] === true);
+        }
+        return true;
+    }
+    rebuildOffsets(layout) {
+        const offsets = [];
+        let totalLineCount = 0;
+        for (const lineCount of layout.lineCounts) {
+            offsets.push(totalLineCount);
+            totalLineCount += lineCount;
+        }
+        offsets.push(totalLineCount);
+        layout.offsets = offsets;
+        layout.totalLineCount = totalLineCount;
+    }
     refreshDirtyLayoutEntries(layout, width) {
         if (layout.dirtyEntryIds.size === 0)
             return;
@@ -224,7 +297,7 @@ export class ConversationViewport {
         const previousLineCount = layout.lineCounts[index] ?? 0;
         const nextLineCount = measure
             ? this.measuredLineCountForEntry(entry, layout.entries, index, width)
-            : this.estimatedLineCountForEntry(entry, layout.entries, index, width);
+            : this.estimatedLineCountForEntry(entry, layout.entries, index, layout.entries.map((candidate) => this.estimatedBlockLineCountForEntry(candidate, width)));
         layout.measuredLineCounts[index] = measure;
         if (previousLineCount === nextLineCount)
             return false;
@@ -240,9 +313,8 @@ export class ConversationViewport {
         const block = this.blockForEntry(entry, width);
         return this.lineCountWithGap(entry, block.lineCount, this.nextVisibleEntry(entries, index, width));
     }
-    estimatedLineCountForEntry(entry, entries, index, width) {
-        const blockLineCount = this.estimatedBlockLineCountForEntry(entry, width);
-        const blockLineCounts = entries.map((candidate) => this.estimatedBlockLineCountForEntry(candidate, width));
+    estimatedLineCountForEntry(entry, entries, index, blockLineCounts) {
+        const blockLineCount = blockLineCounts[index] ?? 0;
         return this.lineCountWithGap(entry, blockLineCount, this.nextEstimatedVisibleEntry(entries, blockLineCounts, index));
     }
     lineCountWithGap(entry, blockLineCount, nextEntry) {
@@ -339,6 +411,65 @@ function estimateWrappedLineCount(text, width) {
     }
     return count;
 }
+function layoutOverlap(previousIds, currentIds) {
+    if (currentIds.length === 0 || previousIds.length === 0)
+        return { previousStart: 0, currentStart: 0, length: 0 };
+    const candidates = [];
+    const prefixLength = commonPrefixLength(previousIds, currentIds);
+    if (prefixLength > 0)
+        candidates.push({ previousStart: 0, currentStart: 0, length: prefixLength });
+    const suffixLength = commonSuffixLength(previousIds, currentIds);
+    if (suffixLength > 0)
+        candidates.push({
+            previousStart: previousIds.length - suffixLength,
+            currentStart: currentIds.length - suffixLength,
+            length: suffixLength,
+        });
+    const suffixPrefixLength = maxSuffixPrefixOverlap(previousIds, currentIds);
+    if (suffixPrefixLength > 0)
+        candidates.push({
+            previousStart: previousIds.length - suffixPrefixLength,
+            currentStart: 0,
+            length: suffixPrefixLength,
+        });
+    const prefixSuffixLength = maxSuffixPrefixOverlap(currentIds, previousIds);
+    if (prefixSuffixLength > 0)
+        candidates.push({
+            previousStart: 0,
+            currentStart: currentIds.length - prefixSuffixLength,
+            length: prefixSuffixLength,
+        });
+    return candidates.sort((left, right) => right.length - left.length)[0];
+}
+function commonPrefixLength(left, right) {
+    const maxLength = Math.min(left.length, right.length);
+    let length = 0;
+    while (length < maxLength && left[length] === right[length])
+        length += 1;
+    return length;
+}
+function commonSuffixLength(left, right) {
+    const maxLength = Math.min(left.length, right.length);
+    let length = 0;
+    while (length < maxLength && left[left.length - length - 1] === right[right.length - length - 1])
+        length += 1;
+    return length;
+}
+function maxSuffixPrefixOverlap(left, right) {
+    const maxLength = Math.min(left.length, right.length);
+    for (let length = maxLength; length > 0; length -= 1) {
+        let matches = true;
+        for (let offset = 0; offset < length; offset += 1) {
+            if (left[left.length - length + offset] !== right[offset]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return length;
+    }
+    return 0;
+}
 function estimateToolLikeLineCount(toolName, expanded, output, width, pixConfig, superCompactTools, includeStatusLine) {
     const rule = resolveToolRule(toolName, pixConfig.toolRenderer);
     if (rule.hidden)