pi-ui-extend 0.1.13 → 0.1.17

package/dist/app/runtime.js

@@ -7,6 +7,7 @@ import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentS
 import { loadPixConfig, resolveDefaultModelRef } from "../config.js";
 import { PI_FAVORITE_MODEL_REFS } from "./constants.js";
 import { isThinkingLevel, parseModelRef, parseScopedModelRef } from "./model/model-ref.js";
+import { openLazySessionManager } from "./session/lazy-session-manager.js";
 const BUNDLED_QUESTION_EXTENSION_NAME = "question";
 const PI_TOOLS_SUITE_EXTENSION_NAME = "pi-tools-suite";
 const BUNDLED_EXTENSIONS_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../..", "extensions");
@@ -140,6 +141,11 @@ export function resolvePixRuntimeModelRef(options, sessionManager, config = load
         return resolveSessionModelRefFromTail(sessionManager.getBranch());
     return resolveDefaultModelRef(config);
 }
+export function resolvePixRuntimeInitialThinkingLevel(options, sessionManager, config) {
+    const effectiveModelRef = resolvePixRuntimeModelRef(options, sessionManager, config);
+    const parsedModel = effectiveModelRef ? parseModelRef(effectiveModelRef) : undefined;
+    return parsedModel?.thinkingLevel;
+}
 export function resolveSessionModelRefFromTail(entries) {
     let modelRef;
     let thinkingLevel;
@@ -166,8 +172,10 @@ export function resolveSessionModelRefFromTail(entries) {
 export async function createPixRuntime(options, runtimeOptions = {}) {
     const agentDir = getAgentDir();
     const createRuntime = async ({ cwd, sessionManager, sessionStartEvent }) => {
-        const effectiveModelRef = resolvePixRuntimeModelRef(options, sessionManager);
+        const config = loadPixConfig(cwd);
+        const effectiveModelRef = resolvePixRuntimeModelRef(options, sessionManager, config);
         const parsedModel = effectiveModelRef ? parseModelRef(effectiveModelRef) : undefined;
+        const initialThinkingLevel = resolvePixRuntimeInitialThinkingLevel(options, sessionManager, config);
         await ensureBundledSkillsInstalled();
         await ensurePiToolsSuiteExtensionInstalled({ agentDir });
         const bundledExtensionPaths = getBundledExtensionPaths();
@@ -175,6 +183,7 @@ export async function createPixRuntime(options, runtimeOptions = {}) {
             cwd,
             agentDir,
             resourceLoaderOptions: {
+                ...(config.ignoreContextFiles ? { noContextFiles: true } : {}),
                 ...(runtimeOptions.eventBus === undefined ? {} : { eventBus: runtimeOptions.eventBus }),
                 ...(bundledExtensionPaths.length === 0 ? {} : {
                     additionalExtensionPaths: bundledExtensionPaths,
@@ -203,15 +212,16 @@ export async function createPixRuntime(options, runtimeOptions = {}) {
                 },
             ];
         });
+        const created = await createAgentSessionFromServices({
+            services,
+            sessionManager,
+            ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
+            ...(model === undefined ? {} : { model }),
+            ...(initialThinkingLevel === undefined ? {} : { thinkingLevel: initialThinkingLevel }),
+            ...(scopedModels.length === 0 ? {} : { scopedModels }),
+        });
         return {
-            ...(await createAgentSessionFromServices({
-                services,
-                sessionManager,
-                ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
-                ...(model === undefined ? {} : { model }),
-                ...(parsedModel?.thinkingLevel === undefined ? {} : { thinkingLevel: parsedModel.thinkingLevel }),
-                ...(scopedModels.length === 0 ? {} : { scopedModels }),
-            })),
+            ...created,
             services,
             diagnostics: services.diagnostics,
         };
@@ -222,7 +232,7 @@ export async function createPixRuntime(options, runtimeOptions = {}) {
         sessionManager: options.noSession
             ? SessionManager.inMemory(options.cwd)
             : options.sessionPath
-                ? SessionManager.open(options.sessionPath, undefined, options.cwd)
+                ? openLazySessionManager(options.sessionPath, { cwdOverride: options.cwd })
                 : SessionManager.create(options.cwd),
     });
 }

package/dist/app/screen/mouse-controller.d.ts

@@ -56,6 +56,7 @@ export type AppMouseControllerHost = {
     }): void;
     dismissToast(toastId: number): void;
     refreshModelUsageStatus(): void | Promise<void>;
+    refreshUserMessageJumpMenuItems?(): Promise<void>;
     queueInputFromStatus?(): void | Promise<void>;
     toggleAllThinkingExpanded?(): void;
     toggleSuperCompactTools?(): void;
@@ -111,7 +112,6 @@ export declare class AppMouseController {
     statusVoiceLanguageTarget: StatusVoiceLanguageTarget | undefined;
     readonly tabLineTargets: TabLineMouseTarget[];
     mouseSelection: MouseSelection | undefined;
-    private scrollBarDragActive;
     private inputScrollBarDragActive;
     private autoScrollTimer;
     private autoScrollDirection;
@@ -142,7 +142,6 @@ export declare class AppMouseController {
     private statusTargetAt;
     private handleImageClick;
     private handleFileLinkClick;
-    private handleConversationScrollBar;
     private handleInputScrollBar;
     private finishInputScrollBarDrag;
     private handleInputWheel;
@@ -155,6 +154,7 @@ export declare class AppMouseController {
     private handleStatusContextClick;
     private handleStatusModelUsageClick;
     private handleStatusUserJumpClick;
+    private openStatusUserJumpMenu;
     private handleStatusDraftQueueClick;
     private handleStatusThinkingExpandClick;
     private handleStatusCompactToolsClick;

package/dist/app/screen/mouse-controller.js

@@ -3,7 +3,7 @@ import { stringifyUnknown } from "../rendering/message-content.js";
 import { horizontalPaddingLayout } from "../rendering/render-text.js";
 import { orderedSelection, samePoint } from "./screen-selection.js";
 import { openImageContent as openSystemImageContent } from "./image-opener.js";
-import { stringDisplayWidth } from "../../terminal-width.js";
+import { sliceByDisplayColumns, stringDisplayWidth } from "../../terminal-width.js";
 import { formatDcpStatsToast } from "../rendering/dcp-stats.js";
 import { detectFileLinks } from "./file-links.js";
 import { openFileLink as openDetectedFileLink } from "./file-link-opener.js";
@@ -34,7 +34,6 @@ export class AppMouseController {
     statusVoiceLanguageTarget;
     tabLineTargets = [];
     mouseSelection;
-    scrollBarDragActive = false;
     inputScrollBarDragActive = false;
     autoScrollTimer;
     autoScrollDirection;
@@ -57,8 +56,6 @@ export class AppMouseController {
     handleMouse(event) {
         if (this.handleInputScrollBar(event))
             return;
-        if (this.handleConversationScrollBar(event))
-            return;
         this.showClickFlashOnPress(event);
         if (this.handleMouseSelection(event))
             return;
@@ -339,39 +336,6 @@ export class AppMouseController {
             this.host.showToast("Could not open file link. Install the Zed CLI or set ZED_CLI.", "warning");
         return true;
     }
-    handleConversationScrollBar(event) {
-        if (!this.scrollBarDragActive && this.tabLineTargetAt(event))
-            return false;
-        const columns = this.host.terminalColumns();
-        const terminalRows = this.host.terminalRows();
-        const tabPanelRows = this.host.tabPanelRows(terminalRows);
-        const rows = editorLayoutRows(terminalRows, tabPanelRows);
-        const topOffset = editorLayoutTopOffset(tabPanelRows);
-        if (columns <= 0 || rows <= 0)
-            return false;
-        const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
-        const localY = event.y - topOffset;
-        const insideBody = localY >= 1 && localY <= bodyHeight;
-        const onScrollBar = insideBody && event.x === columns && !!this.scrollController.scrollBarMetrics(columns, bodyHeight);
-        const baseButton = event.button & 3;
-        const draggingLeftButton = (event.button & 32) !== 0 && baseButton === 0;
-        if (event.released) {
-            if (!this.scrollBarDragActive)
-                return false;
-            this.scrollBarDragActive = false;
-            return true;
-        }
-        if (event.button === 0 && onScrollBar) {
-            this.scrollBarDragActive = true;
-            this.scrollController.scrollToScrollbarPosition(localY - 1);
-            return true;
-        }
-        if (!draggingLeftButton || !this.scrollBarDragActive)
-            return false;
-        const bodyRow = Math.max(0, Math.min(Math.max(0, bodyHeight - 1), localY - 1));
-        this.scrollController.scrollToScrollbarPosition(bodyRow);
-        return true;
-    }
     handleInputScrollBar(event) {
         if (!this.inputScrollBarDragActive && this.tabLineTargetAt(event))
             return false;
@@ -509,10 +473,24 @@ export class AppMouseController {
             return false;
         if (event.y !== target.row || event.x < target.startColumn || event.x >= target.endColumn)
             return false;
-        this.popupMenus.openDirectPopupMenu("user-message-jump", { preserveStatus: true });
-        this.host.render();
+        void this.openStatusUserJumpMenu();
         return true;
     }
+    async openStatusUserJumpMenu() {
+        try {
+            const refreshPromise = this.host.refreshUserMessageJumpMenuItems?.();
+            this.popupMenus.openDirectPopupMenu("user-message-jump", { preserveStatus: true });
+            this.host.render();
+            if (this.host.refreshUserMessageJumpMenuItems) {
+                await refreshPromise;
+                this.host.render();
+            }
+        }
+        catch (error) {
+            this.host.showToast(`Could not load jump messages: ${error instanceof Error ? error.message : stringifyUnknown(error)}`, "error");
+            this.host.render();
+        }
+    }
     handleStatusDraftQueueClick(event) {
         const target = this.statusDraftQueueTarget;
         if (!target)
@@ -829,9 +807,7 @@ export class AppMouseController {
             const line = range.start.line + index;
             const startColumn = line === range.start.line ? range.start.x : 1;
             const endColumn = line === range.end.line ? range.end.x : text.length + 1;
-            const startIndex = Math.max(0, Math.min(text.length, startColumn - 1));
-            const endIndex = Math.max(startIndex, Math.min(text.length, endColumn - 1));
-            lines.push(text.slice(startIndex, endIndex).trimEnd());
+            lines.push(sliceByDisplayColumns(text, startColumn, endColumn).trimEnd());
         }
         return lines.join("\n").replace(/\s+$/u, "");
     }
@@ -839,10 +815,10 @@ export class AppMouseController {
         const area = this.conversationArea();
         if (!area || area.bodyHeight <= 0)
             return undefined;
-        if (!clampToViewport && (event.y < area.topRow || event.y > area.bottomRow || event.x === this.host.terminalColumns()))
+        if (!clampToViewport && (event.y < area.topRow || event.y > area.bottomRow))
             return undefined;
         const screenY = Math.max(area.topRow, Math.min(area.bottomRow, event.y));
-        const screenX = Math.max(1, Math.min(area.viewportColumns + 1, event.x));
+        const screenX = viewportSelectionColumn(event.x, area.viewportColumns);
         return {
             conversation: {
                 line: area.metrics.start + (screenY - area.topRow),
@@ -945,7 +921,7 @@ export class AppMouseController {
         if (!area)
             return;
         const screenY = this.autoScrollDirection < 0 ? area.topRow : area.bottomRow;
-        const screenX = Math.max(1, Math.min(area.viewportColumns + 1, this.autoScrollCursorX));
+        const screenX = viewportSelectionColumn(this.autoScrollCursorX, area.viewportColumns);
         selection.current = { x: screenX, y: screenY };
         selection.conversationCurrent = {
             line: area.metrics.start + (screenY - area.topRow),
@@ -971,13 +947,16 @@ export function screenSelectionLineText(row, text, startColumn, endColumn, input
         copyStartColumn = Math.max(copyStartColumn, inputFrame.contentStartColumn);
         copyEndColumn = Math.min(copyEndColumn, inputFrame.contentEndColumn);
     }
-    const startIndex = Math.max(0, Math.min(text.length, copyStartColumn - 1));
-    const endIndex = Math.max(startIndex, Math.min(text.length, copyEndColumn - 1));
-    return text.slice(startIndex, endIndex);
+    return sliceByDisplayColumns(text, copyStartColumn, copyEndColumn);
 }
 function sameConversationPoint(left, right) {
     return !!left && left.line === right.line && left.x === right.x;
 }
+function viewportSelectionColumn(mouseX, viewportColumns) {
+    if (mouseX >= viewportColumns)
+        return viewportColumns + 1;
+    return Math.max(1, Math.min(viewportColumns + 1, mouseX));
+}
 function toastTargetContainsEvent(target, event) {
     if (target.startColumn === undefined || target.endColumn === undefined)
         return true;

package/dist/app/screen/screen-styler.d.ts

@@ -29,7 +29,7 @@ export declare class ScreenStyler {
         end: number;
     }[] | undefined, width: number, tagColor: string, suggestionColor: string, frameColor?: string): string;
     private styleAnsiLine;
-    selectionRangeForRow(row: number, width: number): {
+    selectionRangeForRow(row: number, width: number, text?: string): {
         startIndex: number;
         endIndex: number;
     } | undefined;

package/dist/app/screen/screen-styler.js

@@ -1,6 +1,7 @@
 import { ANSI_RESET, colorize } from "../../theme.js";
 import { renderMarkdownLine } from "../../markdown-format.js";
 import { syntaxHighlightSegmentsForLine } from "../../syntax-highlight.js";
+import { displayIndexForColumn } from "../../terminal-width.js";
 import { padOrTrimPlain } from "../rendering/render-text.js";
 import { orderedSelection } from "./screen-selection.js";
 export class ScreenStyler {
@@ -19,7 +20,7 @@ export class ScreenStyler {
             ? renderMarkdownDisplayLine(line.text, width, line.syntaxHighlight.start)
             : undefined;
         const text = markdownLine?.text ?? line?.text ?? "";
-        if (line?.syntaxHighlight && !this.selectionRangeForRow(row, width)) {
+        if (line?.syntaxHighlight && !this.selectionRangeForRow(row, width, text)) {
             const syntaxHighlight = markdownLine ? { ...line.syntaxHighlight, start: Math.min(line.syntaxHighlight.start, markdownLine.text.length) } : line.syntaxHighlight;
             const segments = [
                 ...syntaxHighlightSegmentsForLine(text, syntaxHighlight, colors),
@@ -35,7 +36,7 @@ export class ScreenStyler {
         return this.styleLine(row, text, width, options);
     }
     styleLineSegments(row, text, width, baseOptions, segments) {
-        if (this.selectionRangeForRow(row, width))
+        if (this.selectionRangeForRow(row, width, text))
             return this.styleLine(row, text, width, baseOptions);
         const plain = padOrTrimPlain(text, width);
         const chunks = [];
@@ -56,7 +57,7 @@ export class ScreenStyler {
     }
     styleLine(row, text, width, options) {
         const plain = padOrTrimPlain(text, width);
-        const range = this.selectionRangeForRow(row, width);
+        const range = this.selectionRangeForRow(row, width, plain);
         if (!range)
             return colorize(plain, options);
         const before = plain.slice(0, range.startIndex);
@@ -75,7 +76,7 @@ export class ScreenStyler {
     styleInputLine(row, text, tagSpans, suggestionSpans, width, tagColor, suggestionColor, frameColor) {
         const colors = this.host.theme.colors;
         const baseOptions = { foreground: colors.inputForeground };
-        if (this.selectionRangeForRow(row, width))
+        if (this.selectionRangeForRow(row, width, text))
             return this.styleLine(row, text, width, baseOptions);
         const plain = padOrTrimPlain(text, width);
         const frameSpans = inputFrameSpans(plain, width, frameColor);
@@ -109,7 +110,7 @@ export class ScreenStyler {
             return text;
         return `${prefix}${text.replaceAll(ANSI_RESET, `${ANSI_RESET}${prefix}`)}${ANSI_RESET}`;
     }
-    selectionRangeForRow(row, width) {
+    selectionRangeForRow(row, width, text) {
         if (!this.host.mouseSelection)
             return undefined;
         const anchor = this.host.mouseSelection.screenAnchor ?? this.host.mouseSelection.anchor;
@@ -119,8 +120,9 @@ export class ScreenStyler {
             return undefined;
         const startColumn = row === start.y ? start.x : 1;
         const endColumn = row === end.y ? end.x : width + 1;
-        const startIndex = Math.max(0, Math.min(width, startColumn - 1));
-        const endIndex = Math.max(startIndex, Math.min(width, endColumn - 1));
+        const plain = text ?? " ".repeat(Math.max(0, width));
+        const startIndex = Math.max(0, Math.min(plain.length, displayIndexForColumn(plain, startColumn)));
+        const endIndex = Math.max(startIndex, Math.min(plain.length, displayIndexForColumn(plain, endColumn)));
         return endIndex > startIndex ? { startIndex, endIndex } : undefined;
     }
     baseLineForeground(variant) {

package/dist/app/screen/scroll-controller.d.ts

@@ -1,6 +1,6 @@
 import type { ConversationViewport } from "../rendering/conversation-viewport.js";
 import type { EditorLayoutRenderer } from "../rendering/editor-layout-renderer.js";
-import type { RenderedLine } from "../types.js";
+import type { Entry, RenderedLine } from "../types.js";
 export type AppScrollMetrics = {
     bodyHeight: number;
     viewportColumns: number;
@@ -8,10 +8,6 @@ export type AppScrollMetrics = {
     maxScroll: number;
     start: number;
 };
-export type AppScrollBarMetrics = {
-    thumbStartRow: number;
-    thumbEndRow: number;
-};
 export type ConversationTextScrollTarget = {
     entryId?: string;
     needles: readonly string[];
@@ -22,30 +18,37 @@ export type AppScrollControllerHost = {
     terminalColumns(): number;
     terminalRows(): number;
     tabPanelRows(terminalRows: number): number;
+    hasOlderSessionHistory?(): boolean;
+    isLoadingOlderSessionHistory?(): boolean;
+    loadOlderSessionHistory?(options?: {
+        render?: boolean;
+        onPrependedEntries?: (entries: readonly Entry[]) => void;
+    }): Promise<boolean>;
     render(): void;
 };
 export declare class AppScrollController {
     private readonly host;
     private scrollFromBottom;
     private detachedScrollStart;
+    private readonly olderHistoryThresholdLines;
     constructor(host: AppScrollControllerHost);
     reset(): void;
+    scrollToBottom(): boolean;
     conversationView(columns: number, bodyHeight: number): {
         lines: RenderedLine[];
         metrics: AppScrollMetrics;
     };
     visibleConversationLines(columns: number, bodyHeight: number): RenderedLine[];
     scrollMetrics(columns: number, bodyHeight: number): AppScrollMetrics;
-    scrollBarForMetrics(metrics: AppScrollMetrics): AppScrollBarMetrics | undefined;
-    scrollBarMetrics(columns: number, bodyHeight: number): AppScrollBarMetrics | undefined;
     scrollByPage(direction: -1 | 1): void;
     scrollByLines(delta: number, options?: {
         render?: boolean;
     }): boolean;
-    scrollToScrollbarPosition(bodyRow: number): boolean;
+    private shouldLoadOlderHistory;
+    private loadOlderHistoryAnchored;
+    adjustForHistoryWindowPrune(edge: "top" | "bottom", lineCount: number): void;
     scrollToConversationEntry(entryId: string): boolean;
     scrollToConversationText(target: ConversationTextScrollTarget): boolean;
-    private scrollToStart;
     private setScrollStart;
     private viewportColumns;
 }

package/dist/app/screen/scroll-controller.js

@@ -3,6 +3,7 @@ export class AppScrollController {
     host;
     scrollFromBottom = 0;
     detachedScrollStart;
+    olderHistoryThresholdLines = 8;
     constructor(host) {
         this.host = host;
     }
@@ -10,6 +11,12 @@ export class AppScrollController {
         this.scrollFromBottom = 0;
         this.detachedScrollStart = undefined;
     }
+    scrollToBottom() {
+        const changed = this.scrollFromBottom !== 0 || this.detachedScrollStart !== undefined;
+        this.scrollFromBottom = 0;
+        this.detachedScrollStart = undefined;
+        return changed;
+    }
     conversationView(columns, bodyHeight) {
         const metrics = this.scrollMetrics(columns, bodyHeight);
         return {
@@ -37,20 +44,6 @@ export class AppScrollController {
         }
         return { bodyHeight, viewportColumns, conversationLineCount, maxScroll, start };
     }
-    scrollBarForMetrics(metrics) {
-        if (metrics.bodyHeight <= 0 || metrics.maxScroll <= 0 || metrics.conversationLineCount <= metrics.bodyHeight)
-            return undefined;
-        const thumbSize = Math.max(1, Math.min(metrics.bodyHeight, Math.round((metrics.bodyHeight * metrics.bodyHeight) / metrics.conversationLineCount)));
-        const travel = Math.max(0, metrics.bodyHeight - thumbSize);
-        const thumbOffset = travel === 0 ? 0 : Math.round((metrics.start / metrics.maxScroll) * travel);
-        return {
-            thumbStartRow: thumbOffset + 1,
-            thumbEndRow: thumbOffset + thumbSize,
-        };
-    }
-    scrollBarMetrics(columns, bodyHeight) {
-        return this.scrollBarForMetrics(this.scrollMetrics(columns, bodyHeight));
-    }
     scrollByPage(direction) {
         const rows = this.host.terminalRows();
         this.scrollByLines(direction * Math.max(1, editorLayoutRows(rows, this.host.tabPanelRows(rows)) - 4));
@@ -62,37 +55,64 @@ export class AppScrollController {
         const rows = editorLayoutRows(terminalRows, this.host.tabPanelRows(terminalRows));
         const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
         const metrics = this.scrollMetrics(columns, bodyHeight);
+        const shouldLoadOlderHistory = this.shouldLoadOlderHistory(delta, metrics);
         const { conversationLineCount, maxScroll } = metrics;
         const nextScrollFromBottom = Math.max(0, Math.min(maxScroll, this.scrollFromBottom + -delta));
+        let changed = false;
         if (nextScrollFromBottom === this.scrollFromBottom) {
             if (nextScrollFromBottom === 0 && this.detachedScrollStart !== undefined && delta > 0) {
                 this.detachedScrollStart = undefined;
-                if (shouldRender)
-                    this.host.render();
-                return true;
+                changed = true;
+            }
+            else if (!shouldLoadOlderHistory) {
+                return false;
             }
-            return false;
         }
-        this.scrollFromBottom = nextScrollFromBottom;
-        this.detachedScrollStart = nextScrollFromBottom === 0
-            ? undefined
-            : Math.max(0, conversationLineCount - bodyHeight - nextScrollFromBottom);
+        else {
+            this.scrollFromBottom = nextScrollFromBottom;
+            this.detachedScrollStart = nextScrollFromBottom === 0
+                ? undefined
+                : Math.max(0, conversationLineCount - bodyHeight - nextScrollFromBottom);
+            changed = true;
+        }
+        if (shouldLoadOlderHistory)
+            this.loadOlderHistoryAnchored(metrics, { render: shouldRender });
         if (shouldRender)
             this.host.render();
-        return true;
+        return changed || shouldLoadOlderHistory;
     }
-    scrollToScrollbarPosition(bodyRow) {
-        const columns = this.host.terminalColumns();
-        const terminalRows = this.host.terminalRows();
-        const rows = editorLayoutRows(terminalRows, this.host.tabPanelRows(terminalRows));
-        const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
-        const metrics = this.scrollMetrics(columns, bodyHeight);
-        if (!this.scrollBarForMetrics(metrics))
+    shouldLoadOlderHistory(delta, metrics) {
+        if (delta >= 0)
+            return false;
+        if (metrics.start > this.olderHistoryThresholdLines)
+            return false;
+        if (this.host.hasOlderSessionHistory?.() !== true)
             return false;
-        const clampedRow = Math.max(0, Math.min(Math.max(0, bodyHeight - 1), bodyRow));
-        const ratio = bodyHeight <= 1 ? 0 : clampedRow / (bodyHeight - 1);
-        const start = Math.round(metrics.maxScroll * ratio);
-        return this.scrollToStart(start, metrics);
+        if (this.host.isLoadingOlderSessionHistory?.() === true)
+            return false;
+        return true;
+    }
+    loadOlderHistoryAnchored(metrics, options) {
+        void this.host.loadOlderSessionHistory?.({
+            render: false,
+            onPrependedEntries: (entries) => {
+                const prependedLineCount = this.host.conversationViewport().measuredLineCountForEntries(metrics.viewportColumns, entries.map((entry) => entry.id));
+                if (prependedLineCount > 0 && this.detachedScrollStart !== undefined)
+                    this.detachedScrollStart += prependedLineCount;
+            },
+        }).then((loaded) => {
+            if (loaded && options.render)
+                this.host.render();
+        });
+    }
+    adjustForHistoryWindowPrune(edge, lineCount) {
+        if (lineCount <= 0)
+            return;
+        if (edge !== "top")
+            return;
+        if (this.detachedScrollStart === undefined)
+            return;
+        this.detachedScrollStart = Math.max(0, this.detachedScrollStart - lineCount);
     }
     scrollToConversationEntry(entryId) {
         const columns = this.host.terminalColumns();
@@ -143,12 +163,6 @@ export class AppScrollController {
         }
         return false;
     }
-    scrollToStart(start, metrics) {
-        if (!this.setScrollStart(start, metrics))
-            return false;
-        this.host.render();
-        return true;
-    }
     setScrollStart(start, metrics) {
         const nextStart = Math.max(0, Math.min(metrics.maxScroll, start));
         const nextScrollFromBottom = Math.max(0, metrics.conversationLineCount - metrics.bodyHeight - nextStart);
@@ -158,12 +172,9 @@ export class AppScrollController {
         this.detachedScrollStart = nextDetachedScrollStart;
         return changed;
     }
-    viewportColumns(columns, bodyHeight) {
+    viewportColumns(columns, _bodyHeight) {
         const safeColumns = Math.max(1, columns);
-        if (safeColumns <= 1 || bodyHeight <= 0)
-            return safeColumns;
-        const lineCountWithoutScrollbar = this.host.conversationViewport().lineCount(safeColumns);
-        return lineCountWithoutScrollbar > bodyHeight ? safeColumns - 1 : safeColumns;
+        return safeColumns;
     }
 }
 function editorLayoutRows(terminalRows, tabPanelRows) {

package/dist/app/screen/status-controller.js

@@ -1,6 +1,7 @@
 import { basename } from "node:path";
 import { GIT_BRANCH_CACHE_MS } from "../constants.js";
 import { runProcess } from "../process.js";
+import { APP_ICONS } from "../icons.js";
 const STATUS_DOT_BLINK_KEY = "status-dot";
 export class AppStatusController {
     host;
@@ -47,7 +48,7 @@ export class AppStatusController {
         });
     }
     formatSessionStatus(session) {
-        return `${this.statusModelLabel(session)} ${this.statusThinkingLabel(session)} ${this.formatContextUsagePercent(session)}`;
+        return `${this.statusModelLabel(session)} ${APP_ICONS.lightbulb} ${this.statusThinkingLabel(session)} ${this.formatContextUsagePercent(session)}`;
     }
     statusModelLabel(session) {
         return session.model ? `${session.model.provider}/${session.model.id}` : "no model";

package/dist/app/session/lazy-session-manager.d.ts

@@ -0,0 +1,11 @@
+import { SessionManager, type SessionEntry } from "@earendil-works/pi-coding-agent";
+export type LazySessionManagerOptions = {
+    cwdOverride?: string;
+    sessionDir?: string;
+    tailEntryCount?: number;
+};
+export type LazySessionHistoryReader = {
+    hasOlder(): boolean;
+    readOlder(limit: number): Promise<SessionEntry[]>;
+};
+export declare function openLazySessionManager(sessionPath: string, options?: LazySessionManagerOptions): SessionManager;