pi-ui-extend 0.1.34 → 0.1.35

package/README.md

@@ -160,6 +160,26 @@ Before committing code changes, run:
 npm run check
 ```
 
+### Keeping the bundled extension's SDK pin in sync
+
+Pix bundles the `pi-tools-suite` extension (in `external/pi-tools-suite`), which
+runs inside the Pi host process. Its `@earendil-works/*` peerDependencies must
+match the host Pi SDK version exactly, or npm can resolve a stale copy in the
+suite's own `node_modules` and cause a double-load (e.g. `0.75.4` in the suite
+vs `0.79.4` in the host).
+
+When you bump the Pi SDK in the root `package.json`, re-pin the suite and
+reinstall it:
+
+```bash
+npm run sync:sdk-pin                                          # rewrite suite peerDeps to host version
+cd external/pi-tools-suite && npm install --ignore-scripts    # update suite lockfile/node_modules
+```
+
+`npm run check` runs `npm run sync:sdk-pin:check` first, so a stale pin fails
+the check fast. Use `npm run sync:sdk-pin:check` on its own for a drift-only
+report (non-zero exit on drift).
+
 ## Configuration
 
 Useful environment variables:

package/dist/app/app.js

@@ -166,7 +166,7 @@ export class PiUiExtendApp {
             maxProjectSessions: () => this.pixConfig.maxProjectSessions,
             blinkController: this.blinkController,
             runtime: () => this.runtime,
-            createRuntimeForNewSession: () => this.createRuntime(newTabRuntimeOptions(this.options)),
+            createRuntimeForNewSession: () => this.createRuntime(newTabRuntimeOptions(this.options), this.runtime === undefined ? {} : { reuseServicesFrom: this.runtime }),
             createRuntimeForSession: (sessionPath) => this.createRuntime({
                 ...this.options,
                 noSession: false,
@@ -334,6 +334,7 @@ export class PiUiExtendApp {
         });
         this.todoWidgetController = new AppTodoWidgetController({
             sessionFile: () => this.runtime?.session.sessionFile,
+            sessionId: () => this.runtime?.session.sessionId,
             isRunning: () => this.running,
             render: () => this.scheduleRender(),
         });
@@ -761,10 +762,11 @@ export class PiUiExtendApp {
         });
         this.slashCommands = this.commandController.slashCommands;
     }
-    createRuntime(options) {
+    createRuntime(options, runtimeOptions = {}) {
         return createPixRuntime(options, {
             eventBus: this.createExtensionEventBus(),
             config: this.pixConfig,
+            ...runtimeOptions,
         });
     }
     async loadStartupConfig() {

package/dist/app/constants.d.ts

@@ -19,7 +19,8 @@ export declare const REQUEST_HISTORY_VERSION = 1;
 export declare const REQUEST_HISTORY_MAX_ENTRIES = 200;
 export declare const REQUEST_HISTORY_MAX_BYTES: number;
 export declare const REQUEST_HISTORY_MAX_ENTRY_BYTES: number;
-export declare const ENABLE_TERMINAL_KEY_REPORTING = "\u001B[>7u\u001B[>4;2m";
+export declare const ENABLE_TERMINAL_KEY_REPORTING = "\u001B[>7u\u001B[?u\u001B[c";
+export declare const ENABLE_TERMINAL_MODIFY_OTHER_KEYS = "\u001B[>4;2m";
 export declare const DISABLE_TERMINAL_KEY_REPORTING = "\u001B[<u\u001B[>4;0m";
 export declare const ENABLE_BRACKETED_PASTE = "\u001B[?2004h";
 export declare const DISABLE_BRACKETED_PASTE = "\u001B[?2004l";

package/dist/app/constants.js

@@ -52,7 +52,12 @@ export const REQUEST_HISTORY_VERSION = 1;
 export const REQUEST_HISTORY_MAX_ENTRIES = 200;
 export const REQUEST_HISTORY_MAX_BYTES = 128 * 1024;
 export const REQUEST_HISTORY_MAX_ENTRY_BYTES = 16 * 1024;
-export const ENABLE_TERMINAL_KEY_REPORTING = "\x1b[>7u\x1b[>4;2m";
+// Match pi/@earendil-works/pi-tui keyboard setup: request Kitty keyboard
+// protocol flags, query the terminal response, and use xterm modifyOtherKeys
+// only as a response-driven fallback. Enabling both protocols blindly can make
+// terminals disagree about modified Enter reporting.
+export const ENABLE_TERMINAL_KEY_REPORTING = "\x1b[>7u\x1b[?u\x1b[c";
+export const ENABLE_TERMINAL_MODIFY_OTHER_KEYS = "\x1b[>4;2m";
 export const DISABLE_TERMINAL_KEY_REPORTING = "\x1b[<u\x1b[>4;0m";
 export const ENABLE_BRACKETED_PASTE = "\x1b[?2004h";
 export const DISABLE_BRACKETED_PASTE = "\x1b[?2004l";

package/dist/app/input/input-controller.d.ts

@@ -35,7 +35,7 @@ export declare class AppInputController {
     private readonly pasteHandler;
     constructor(host: InputControllerHost);
     handleChunk(chunk: Buffer): void;
-    private consumeSharedEditorShiftEnter;
+    private consumeSharedEditorInput;
     private drainInputBuffer;
     private consumeBracketedPastePayload;
     private getEscapeSequences;
@@ -45,6 +45,9 @@ export declare class AppInputController {
     private consumeCommandArrowPageSequence;
     private consumeCommandArrowPageMatch;
     private consumeTerminalEditShortcutSequence;
+    private consumeIgnoredModifiedKeySequence;
+    private consumeClipboardImagePasteSequence;
+    private consumeShiftEnterSequence;
     private consumeTerminalInterruptSequence;
     private handleArrowUp;
     private handleArrowDown;

package/dist/app/input/input-controller.js

@@ -1,6 +1,7 @@
 import { InputPasteHandler } from "./input-paste-handler.js";
 import { hasTerminalCommandModifier, isNativeCommandPressed, isNativeShiftPressed } from "./native-modifiers.js";
-import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, terminalEditShortcutForControlChar } from "./terminal-edit-shortcuts.js";
+import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, parseTerminalModifiedKeySequence, terminalEditShortcutForControlChar, terminalKeyIsClipboardImagePaste, terminalKeyIsShiftEnter, terminalKeyShouldIgnore, } from "./terminal-edit-shortcuts.js";
+const SHIFT_ENTER_ESCAPE_SEQUENCES = ["\x1b\r", "\x1b\n"];
 export class AppInputController {
     host;
     inputBuffer = "";
@@ -16,7 +17,7 @@ export class AppInputController {
             this.drainInputBuffer();
             return;
         }
-        if (this.consumeSharedEditorShiftEnter(data))
+        if (this.consumeSharedEditorInput(data))
             return;
         const extensionInput = this.host.handleExtensionTerminalInput(data);
         if (extensionInput.consume)
@@ -28,17 +29,41 @@ export class AppInputController {
         this.inputBuffer += data;
         this.drainInputBuffer();
     }
-    consumeSharedEditorShiftEnter(data) {
+    consumeSharedEditorInput(data) {
         if (this.host.extensionInputUsesEditor?.() !== true)
             return false;
         if (this.host.inputEditor.isInBracketedPaste)
             return false;
-        if (!this.isShiftPressed())
-            return false;
-        if (data !== "\r" && data !== "\n")
+        if (data === "\n") {
+            this.insertInputNewline();
+            return true;
+        }
+        if (data === "\r" && this.isShiftPressed()) {
+            this.insertInputNewline();
+            return true;
+        }
+        if (SHIFT_ENTER_ESCAPE_SEQUENCES.includes(data)) {
+            this.insertInputNewline();
+            return true;
+        }
+        if (data === "\x16") {
+            void this.pasteHandler.handleClipboardImagePaste();
+            return true;
+        }
+        const modifiedKey = parseTerminalModifiedKeySequence(data);
+        if (modifiedKey.kind !== "key")
             return false;
-        this.insertInputNewline();
-        return true;
+        if (terminalKeyShouldIgnore(modifiedKey.key))
+            return true;
+        if (terminalKeyIsShiftEnter(modifiedKey.key)) {
+            this.insertInputNewline();
+            return true;
+        }
+        if (terminalKeyIsClipboardImagePaste(modifiedKey.key)) {
+            void this.pasteHandler.handleClipboardImagePaste();
+            return true;
+        }
+        return false;
     }
     drainInputBuffer() {
         while (this.inputBuffer.length > 0) {
@@ -72,11 +97,26 @@ export class AppInputController {
                 continue;
             if (terminalInterruptSequence === "pending")
                 return;
+            const shiftEnterSequence = this.consumeShiftEnterSequence();
+            if (shiftEnterSequence === "consumed")
+                continue;
+            if (shiftEnterSequence === "pending")
+                return;
+            const clipboardImagePasteSequence = this.consumeClipboardImagePasteSequence();
+            if (clipboardImagePasteSequence === "consumed")
+                continue;
+            if (clipboardImagePasteSequence === "pending")
+                return;
             const terminalEditShortcutSequence = this.consumeTerminalEditShortcutSequence();
             if (terminalEditShortcutSequence === "consumed")
                 continue;
             if (terminalEditShortcutSequence === "pending")
                 return;
+            const ignoredModifiedKeySequence = this.consumeIgnoredModifiedKeySequence();
+            if (ignoredModifiedKeySequence === "consumed")
+                continue;
+            if (ignoredModifiedKeySequence === "pending")
+                return;
             if (this.consumeEscapeSequence())
                 continue;
             if (this.isPendingEscapeSequence())
@@ -106,13 +146,9 @@ export class AppInputController {
     }
     getEscapeSequences() {
         return [
-            ["\x1b[13;2u", () => this.insertInputNewline()],
-            ["\x1b[13;2~", () => this.insertInputNewline()],
-            ["\x1b[27;2;13~", () => this.insertInputNewline()],
+            ...SHIFT_ENTER_ESCAPE_SEQUENCES.map((sequence) => [sequence, () => this.insertInputNewline()]),
             ["\x1b[13u", () => this.host.handleEnter()],
             ["\x1b[13;1u", () => this.host.handleEnter()],
-            ["\x1b\r", () => this.insertInputNewline()],
-            ["\x1b\n", () => this.insertInputNewline()],
             ["\x1b[5~", () => this.host.scrollByPage(-1)],
             ["\x1b[6~", () => this.host.scrollByPage(1)],
             ["\x1b[A", () => this.handleArrowUp()],
@@ -139,8 +175,6 @@ export class AppInputController {
             ["\x1b[201~", () => this.pasteHandler.endBracketedPaste()],
             ["\x1b[1;2H", () => { this.host.inputEditor.moveToLineStartExtend(); this.host.render(); }],
             ["\x1b[1;2F", () => { this.host.inputEditor.moveToLineEndExtend(); this.host.render(); }],
-            ["\x1b[118;5u", () => { void this.pasteHandler.handleClipboardImagePaste(); }],
-            ["\x1b[27;5;118~", () => { void this.pasteHandler.handleClipboardImagePaste(); }],
             ["\x1b[122;9u", () => this.undoInput()],
             ["\x1b[27;9;122~", () => this.undoInput()],
             ["\x1b[90;10u", () => this.redoInput()],
@@ -232,6 +266,43 @@ export class AppInputController {
         }
         return "consumed";
     }
+    consumeIgnoredModifiedKeySequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        if (!terminalKeyShouldIgnore(result.key))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        return "consumed";
+    }
+    consumeClipboardImagePasteSequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        if (!terminalKeyIsClipboardImagePaste(result.key))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        if (!terminalKeyShouldIgnore(result.key))
+            void this.pasteHandler.handleClipboardImagePaste();
+        return "consumed";
+    }
+    consumeShiftEnterSequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        if (!terminalKeyIsShiftEnter(result.key))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        if (!terminalKeyShouldIgnore(result.key))
+            this.insertInputNewline();
+        return "consumed";
+    }
     consumeTerminalInterruptSequence() {
         const result = parseTerminalInterruptSequence(this.inputBuffer);
         if (result.kind === "pending")
@@ -401,7 +472,15 @@ export class AppInputController {
             this.host.toggleVoiceRecording();
             return;
         }
-        if (char === "\r" || char === "\n") {
+        if (char === "\n") {
+            if (this.host.inputEditor.isInBracketedPaste) {
+                this.pasteHandler.appendBracketedPasteText("\n");
+                return;
+            }
+            this.insertInputNewline();
+            return;
+        }
+        if (char === "\r") {
             if (this.host.inputEditor.isInBracketedPaste) {
                 this.pasteHandler.appendBracketedPasteText("\n");
                 return;

package/dist/app/input/input-paste-handler.js

@@ -92,8 +92,10 @@ export class InputPasteHandler {
         return false;
     }
     handlePasteEnd(text) {
-        if (!text)
+        if (!text) {
+            void this.handleClipboardImagePaste();
             return;
+        }
         const filePath = this.plainPasteFilePath(text);
         if (filePath) {
             if (isImagePath(filePath) && Date.now() < this.suppressImagePathPasteUntil) {

package/dist/app/input/terminal-edit-shortcuts.d.ts

@@ -1,4 +1,12 @@
 export type TerminalEditShortcut = "undo" | "redo";
+export type ParsedTerminalModifiedKeyResult = {
+    readonly kind: "key";
+    readonly key: ParsedModifiedKey;
+} | {
+    readonly kind: "pending";
+} | {
+    readonly kind: "none";
+};
 export type TerminalEditShortcutSequenceResult = {
     readonly kind: "shortcut";
     readonly shortcut: TerminalEditShortcut;
@@ -11,6 +19,14 @@ export type TerminalEditShortcutSequenceResult = {
 } | {
     readonly kind: "none";
 };
+interface ParsedModifiedKey {
+    readonly codepoint: number;
+    readonly baseLayoutKey: number | undefined;
+    readonly modifier: number;
+    readonly eventType: number | undefined;
+    readonly length: number;
+}
+export declare function parseTerminalModifiedKeySequence(input: string): ParsedTerminalModifiedKeyResult;
 export declare function parseTerminalEditShortcutSequence(input: string): TerminalEditShortcutSequenceResult;
 export declare function parseTerminalInterruptSequence(input: string): {
     readonly kind: "interrupt";
@@ -20,4 +36,8 @@ export declare function parseTerminalInterruptSequence(input: string): {
 } | {
     readonly kind: "none";
 };
+export declare function terminalKeyIsShiftEnter(key: ParsedModifiedKey): boolean;
+export declare function terminalKeyIsClipboardImagePaste(key: ParsedModifiedKey): boolean;
+export declare function terminalKeyShouldIgnore(key: ParsedModifiedKey): boolean;
 export declare function terminalEditShortcutForControlChar(char: string, shiftPressed: boolean): TerminalEditShortcut | undefined;
+export {};

package/dist/app/input/terminal-edit-shortcuts.js

@@ -3,34 +3,60 @@ const CONTROL_MODIFIER_FLAG = 4;
 const COMMAND_MODIFIER_FLAG = 8;
 const LOCK_MODIFIER_MASK = 64 + 128;
 const KEY_CODE_C = 99;
+const KEY_CODE_ENTER = 13;
+const KEY_CODE_V = 118;
 const KEY_CODE_Y = 121;
 const KEY_CODE_Z = 122;
 const CYRILLIC_SMALL_ES_CODE = 1089;
 const CYRILLIC_CAPITAL_ES_CODE = 1057;
+const CYRILLIC_SMALL_EM_CODE = 1084;
+const CYRILLIC_CAPITAL_EM_CODE = 1052;
 const KITTY_CSI_U_SEQUENCE = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\d+))?u/;
 const XTERM_MODIFY_OTHER_KEYS_SEQUENCE = /^\x1b\[27;(\d+);(\d+)~/;
-export function parseTerminalEditShortcutSequence(input) {
+export function parseTerminalModifiedKeySequence(input) {
     const kitty = parseKittyCsiUSequence(input);
     if (kitty)
-        return terminalEditShortcutResult(kitty);
+        return { kind: "key", key: kitty };
     const xterm = parseXtermModifyOtherKeysSequence(input);
     if (xterm)
-        return terminalEditShortcutResult(xterm);
-    if (isPotentialEditShortcutPrefix(input))
+        return { kind: "key", key: xterm };
+    if (isPotentialModifiedKeyPrefix(input))
         return { kind: "pending" };
     return { kind: "none" };
 }
+export function parseTerminalEditShortcutSequence(input) {
+    const result = parseTerminalModifiedKeySequence(input);
+    if (result.kind === "pending")
+        return { kind: "pending" };
+    if (result.kind === "none")
+        return { kind: "none" };
+    return terminalEditShortcutResult(result.key);
+}
 export function parseTerminalInterruptSequence(input) {
-    const kitty = parseKittyCsiUSequence(input);
-    if (kitty && terminalKeyIsControlC(kitty))
-        return { kind: "interrupt", length: kitty.length };
-    const xterm = parseXtermModifyOtherKeysSequence(input);
-    if (xterm && terminalKeyIsControlC(xterm))
-        return { kind: "interrupt", length: xterm.length };
-    if (isPotentialInterruptPrefix(input))
+    const result = parseTerminalModifiedKeySequence(input);
+    if (result.kind === "pending")
         return { kind: "pending" };
+    if (result.kind === "key" && terminalKeyIsControlC(result.key))
+        return { kind: "interrupt", length: result.key.length };
+    if (result.kind === "key" || isPotentialInterruptPrefix(input))
+        return { kind: "none" };
     return { kind: "none" };
 }
+export function terminalKeyIsShiftEnter(key) {
+    const effectiveModifier = key.modifier & ~LOCK_MODIFIER_MASK;
+    if ((effectiveModifier & SHIFT_MODIFIER_FLAG) === 0)
+        return false;
+    return terminalKeyMatchesCodepoint(key, KEY_CODE_ENTER);
+}
+export function terminalKeyIsClipboardImagePaste(key) {
+    const effectiveModifier = key.modifier & ~LOCK_MODIFIER_MASK;
+    if ((effectiveModifier & (CONTROL_MODIFIER_FLAG | COMMAND_MODIFIER_FLAG)) === 0)
+        return false;
+    return terminalKeyMatchesCodepoint(key, KEY_CODE_V, CYRILLIC_SMALL_EM_CODE, CYRILLIC_CAPITAL_EM_CODE);
+}
+export function terminalKeyShouldIgnore(key) {
+    return key.eventType === 3;
+}
 export function terminalEditShortcutForControlChar(char, shiftPressed) {
     if (char === "\u001a")
         return shiftPressed ? "redo" : "undo";
@@ -95,6 +121,17 @@ function interruptCodepointIsC(codepoint) {
     const normalized = normalizeLetterCodepoint(codepoint);
     return normalized === KEY_CODE_C || normalized === CYRILLIC_SMALL_ES_CODE || normalized === CYRILLIC_CAPITAL_ES_CODE;
 }
+function terminalKeyMatchesCodepoint(key, ...expectedCodepoints) {
+    return expectedCodepoints.some((codepoint) => keyMatchesCodepoint(key, codepoint));
+}
+function keyMatchesCodepoint(key, expectedCodepoint) {
+    const normalizedExpected = normalizeLetterCodepoint(expectedCodepoint);
+    const primary = normalizeLetterCodepoint(key.codepoint);
+    if (primary === normalizedExpected)
+        return true;
+    const baseLayout = key.baseLayoutKey;
+    return baseLayout !== undefined && normalizeLetterCodepoint(baseLayout) === normalizedExpected;
+}
 function terminalEditShortcutForKey(key, effectiveModifier) {
     const codepoint = editShortcutCodepoint(key);
     if (codepoint === KEY_CODE_Y)
@@ -114,16 +151,13 @@ function normalizeLetterCodepoint(codepoint) {
         return codepoint + 32;
     return codepoint;
 }
-function isPotentialEditShortcutPrefix(input) {
+function isPotentialModifiedKeyPrefix(input) {
     if (!input.startsWith("\x1b["))
         return false;
     if (input.includes("u") || input.includes("~"))
         return false;
     const body = input.slice(2);
-    if (!/^[\d:;]*$/.test(body))
-        return false;
-    const possibleStarts = ["122", "121", "90", "27;"];
-    return possibleStarts.some((start) => start.startsWith(body) || body.startsWith(start));
+    return /^[\d:;]*$/.test(body);
 }
 function isPotentialInterruptPrefix(input) {
     if (!input.startsWith("\x1b["))

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

@@ -14,6 +14,7 @@ export type ConversationEntryRenderOptions = {
     availableThinkingLevels?: readonly string[];
     superCompactTools?: boolean;
     allThinkingExpanded?: boolean;
+    currentTimeMs?: number;
     renderInlineUserMessageMenu: (entry: Extract<Entry, {
         kind: "user";
     }>, context: InlineUserMessageMenuContext) => RenderedLine[];

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

@@ -75,7 +75,7 @@ function renderAssistantLines(text, width, options) {
     if (!displayText)
         return [];
     const { left: contentLeft, contentWidth } = horizontalPaddingLayout(width);
-    const contentLines = renderMarkdownTextLines(displayText, contentWidth, contentLeft);
+    const contentLines = renderMarkdownTextLines(displayText, contentWidth, contentLeft, { preserveWrappedWordSeparator: true });
     if (contentLines.length === 0)
         return [];
     const lines = [];

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

@@ -8,6 +8,7 @@ export type ConversationToolRenderOptions = {
     availableThinkingLevels?: readonly string[];
     superCompactTools?: boolean;
     allThinkingExpanded?: boolean;
+    currentTimeMs?: number;
 };
 export declare function renderConversationToolEntry(entry: Extract<Entry, {
     kind: "tool";

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

@@ -56,9 +56,11 @@ export function renderThinkingEntry(entry, width, options) {
     const headerColorOverride = entry.level
         ? thinkingLevelThemeColor(entry.level, options.colors, options.availableThinkingLevels)
         : undefined;
+    const elapsed = thinkingElapsedText(entry, options.currentTimeMs ?? Date.now());
     return renderToolBlock({
         id: entry.id,
         toolName: THINKING_TOOL_NAME,
+        ...(elapsed === undefined ? {} : { headerArgs: elapsed }),
         expanded,
         status: entry.status,
         isError: false,
@@ -74,6 +76,25 @@ export function renderThinkingEntry(entry, width, options) {
         ...(headerColorOverride === undefined ? {} : { headerColorOverride }),
     });
 }
+function thinkingElapsedText(entry, currentTimeMs) {
+    if (entry.startedAt === undefined)
+        return undefined;
+    const endTimeMs = entry.finishedAt ?? currentTimeMs;
+    const elapsedMs = Math.max(0, endTimeMs - entry.startedAt);
+    return formatThinkingElapsed(elapsedMs);
+}
+function formatThinkingElapsed(elapsedMs) {
+    const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1000));
+    const seconds = totalSeconds % 60;
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    if (totalMinutes < 1)
+        return `${seconds}s`;
+    const minutes = totalMinutes % 60;
+    const hours = Math.floor(totalMinutes / 60);
+    if (hours < 1)
+        return `${minutes}m ${seconds.toString().padStart(2, "0")}s`;
+    return `${hours}h ${minutes.toString().padStart(2, "0")}m`;
+}
 function trimTrailingBlankLines(text) {
     return text.replace(/(?:\r?\n[ \t]*)+$/u, "");
 }

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

@@ -49,11 +49,14 @@ export declare class ConversationViewport {
     private blockCacheForWidth;
     private refreshDynamicLayoutEntries;
     private ensureEntryMeasured;
+    private hasDynamicConversationBlock;
+    private isDynamicConversationBlock;
     private refreshLayoutEntry;
     private measuredLineCountForEntry;
     private estimatedLineCountForEntry;
     private lineCountWithGap;
     private estimatedBlockLineCountForEntry;
+    private estimatedToolEntryLineCount;
     private nextVisibleEntry;
     private nextEstimatedVisibleEntry;
     private gapAfterEntry;

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

@@ -1,4 +1,5 @@
 import { resolveToolRule } from "../../config.js";
+import { renderToolDisplay } from "../../tool-renderers/index.js";
 import { stringDisplayWidth } from "../../terminal-width.js";
 import { renderConversationEntry as renderConversationEntryLines } from "./conversation-entry-renderer.js";
 import { horizontalPaddingLayout } from "./render-text.js";
@@ -70,7 +71,7 @@ export class ConversationViewport {
             + (this.host.superCompactTools ? 1_000_000_000 : 0)
             + (this.host.allThinkingExpanded ? 2_000_000_000 : 0);
         const cached = blockCache.get(entry.id);
-        const dynamic = this.host.isDynamicConversationBlock(entry);
+        const dynamic = this.isDynamicConversationBlock(entry);
         if (!dynamic && cached?.version === version)
             return cached;
         const availableThinkingLevels = this.host.availableThinkingLevels?.();
@@ -82,6 +83,7 @@ export class ConversationViewport {
             ...(availableThinkingLevels ? { availableThinkingLevels } : {}),
             superCompactTools: Boolean(this.host.superCompactTools),
             allThinkingExpanded: Boolean(this.host.allThinkingExpanded),
+            currentTimeMs: Date.now(),
             renderInlineUserMessageMenu: (userEntry, context) => this.host.renderInlineUserMessageMenu(userEntry, context),
         });
         const block = {
@@ -156,7 +158,7 @@ export class ConversationViewport {
             }
         }
         this.refreshDirtyLayoutEntries(layout, width);
-        if (this.host.hasDynamicConversationBlock?.()) {
+        if (this.hasDynamicConversationBlock(layout.entries)) {
             this.refreshDynamicLayoutEntries(layout, width);
         }
         return layout;
@@ -278,7 +280,7 @@ export class ConversationViewport {
     }
     refreshDynamicLayoutEntries(layout, width) {
         for (let index = 0; index < layout.entries.length; index += 1) {
-            if (this.host.isDynamicConversationBlock(layout.entries[index]))
+            if (this.isDynamicConversationBlock(layout.entries[index]))
                 this.refreshLayoutEntry(layout, width, index, true);
         }
     }
@@ -286,10 +288,17 @@ export class ConversationViewport {
         const entry = layout.entries[index];
         if (!entry)
             return false;
-        if (layout.measuredLineCounts[index] === true && !this.host.isDynamicConversationBlock(entry))
+        if (layout.measuredLineCounts[index] === true && !this.isDynamicConversationBlock(entry))
             return false;
         return this.refreshLayoutEntry(layout, width, index, true);
     }
+    hasDynamicConversationBlock(entries) {
+        return this.host.hasDynamicConversationBlock?.() === true || entries.some((entry) => this.isDynamicConversationBlock(entry));
+    }
+    isDynamicConversationBlock(entry) {
+        return (entry.kind === "thinking" && entry.status === "running" && entry.startedAt !== undefined)
+            || this.host.isDynamicConversationBlock(entry);
+    }
     refreshLayoutEntry(layout, width, index, measure) {
         const entry = layout.entries[index];
         if (!entry)
@@ -348,11 +357,38 @@ export class ConversationViewport {
             case "shell":
                 return estimateToolLikeLineCount("shell", entry.expanded, `${entry.output}\n${entry.status}`, width, this.host.pixConfig, this.host.superCompactTools === true, true);
             case "tool":
-                return estimateToolLikeLineCount(entry.toolName, entry.expanded, entry.output, width, this.host.pixConfig, this.host.superCompactTools === true, false);
+                return this.estimatedToolEntryLineCount(entry, width);
             default:
                 return 1;
         }
     }
+    estimatedToolEntryLineCount(entry, width) {
+        const display = renderToolDisplay({
+            toolName: entry.toolName,
+            argsText: entry.argsText,
+            output: entry.output,
+            details: entry.details,
+            isError: entry.isError,
+            status: entry.status,
+            cwd: this.host.cwd,
+            colors: this.host.colors,
+        });
+        const toolName = display.toolName ?? entry.toolName;
+        const rule = resolveToolRule(toolName, this.host.pixConfig.toolRenderer);
+        if (rule.hidden)
+            return 0;
+        const bodyWidth = Math.max(1, width - 2);
+        if (entry.expanded)
+            return 1 + estimateWrappedLineCount(display.expandedText, bodyWidth);
+        if (rule.compactHidden || (rule.defaultExpanded === true && this.host.superCompactTools !== true))
+            return 1;
+        const body = display.collapsedBody.trimEnd();
+        if (!body || rule.previewLines === 0)
+            return 1;
+        const bodyLineCount = estimateWrappedLineCount(body, bodyWidth);
+        const previewLineCount = Math.min(rule.previewLines, bodyLineCount);
+        return this.host.superCompactTools === true ? 1 : 1 + previewLineCount;
+    }
     nextVisibleEntry(entries, index, width) {
         for (let nextIndex = index + 1; nextIndex < entries.length; nextIndex += 1) {
             const nextEntry = entries[nextIndex];

package/dist/app/rendering/editor-layout-renderer.js

@@ -1,4 +1,4 @@
-import { ABOVE_EDITOR_WIDGET_KEY_GROUPS, BUILT_IN_SUBAGENTS_WIDGET_KEYS, INPUT_MAX_ROWS, LEGACY_TODO_WIDGET_KEYS, } from "../constants.js";
+import { ABOVE_EDITOR_WIDGET_KEY_GROUPS, BUILT_IN_SUBAGENTS_WIDGET_KEYS, LEGACY_TODO_WIDGET_KEYS, } from "../constants.js";
 import { renderSubagentsPanel, renderTodoPanel } from "./editor-panels.js";
 import { ellipsizeDisplay, horizontalPaddingLayout, padHorizontalText, sanitizeText, wrapText } from "./render-text.js";
 import { APP_ICONS } from "../icons.js";
@@ -9,7 +9,8 @@ export class EditorLayoutRenderer {
     }
     computeLayout(width, rows) {
         const maxAvailableInputRows = Math.max(1, rows - 4);
-        const renderedInput = this.renderInput(width, Math.min(INPUT_MAX_ROWS, maxAvailableInputRows), maxAvailableInputRows);
+        const maxComposerRows = Math.max(1, Math.min(maxAvailableInputRows, Math.floor(rows * 0.7)));
+        const renderedInput = this.renderInput(width, maxComposerRows, maxComposerRows);
         const maxEntityRows = Math.max(0, rows - renderedInput.lines.length - 4);
         const editorEntityWidth = inputFrameContentWidth(width);
         const aboveEditorEntities = this.renderAboveEditorEntities(editorEntityWidth);