pi-ui-extend 0.1.32 → 0.1.34

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)

package/dist/app/rendering/dcp-stats.js

@@ -1,8 +1,11 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { normalizeToolName, parseArgsText } from "../../tool-renderers/utils.js";
 const NUDGE_TYPES = ["turn", "iteration", "context-soft", "context-strong"];
 export function formatDcpStatsToast(session) {
-    const stats = collectDcpSessionStats(session);
-    const nudgeStats = collectDcpNudgeStats(session);
+    const latestState = resolveLatestDcpState(session);
+    const stats = collectDcpSessionStats(session, latestState);
+    const nudgeStats = collectDcpNudgeStats(session, latestState?.data);
     const activeBlocks = stats.activeBlocks ?? 0;
     const totalBlocks = stats.totalBlocks ?? stats.activeBlocks ?? 0;
     const totalNudgeEvents = nudgeStats.emitted + nudgeStats.upgraded;
@@ -12,7 +15,8 @@ export function formatDcpStatsToast(session) {
         `  Tokens saved (estimated): ${fmt(stats.tokensSaved)}`,
         `  Total pruning operations: ${fmt(stats.totalPruneCount)}`,
         `  Compression blocks active: ${activeBlocks} / ${totalBlocks} total`,
-        "  Manual mode: off",
+        `  Manual mode: ${stats.manualMode === true ? "on" : stats.manualMode === false ? "off" : "unknown"}`,
+        `  State source: ${formatStateSource(stats.stateSource)}`,
         "",
         "Nudge telemetry:",
         `  Sent: ${fmt(nudgeStats.emitted)} emitted, ${fmt(nudgeStats.upgraded)} upgraded`,
@@ -28,7 +32,7 @@ export function formatDcpStatsToast(session) {
     ];
     return lines.join("\n");
 }
-function collectDcpSessionStats(session) {
+function collectDcpSessionStats(session, latestState) {
     const usage = session.getContextUsage();
     const stats = {
         runs: 0,
@@ -37,14 +41,14 @@ function collectDcpSessionStats(session) {
         items: 0,
         summaryTokens: 0,
         prunedTools: 0,
+        stateSource: latestState?.source ?? "tool-results",
         ...(usage?.tokens != null ? { contextTokens: usage.tokens } : {}),
         ...(usage?.contextWindow != null ? { contextWindow: usage.contextWindow } : {}),
         ...(usage?.percent != null ? { contextPercent: usage.percent } : {}),
     };
     const branch = session.sessionManager.getBranch();
-    const latestState = latestCustomEntryData(branch, "dcp-state");
     if (latestState)
-        applyDcpStateStats(stats, latestState);
+        applyDcpStateStats(stats, latestState.data);
     for (const entry of branch) {
         if (entry.type !== "message")
             continue;
@@ -94,8 +98,10 @@ function applyDcpStateStats(stats, data) {
     }
     if (Array.isArray(data.prunedToolIds))
         stats.prunedTools = data.prunedToolIds.length;
+    if (typeof data.manualMode === "boolean")
+        stats.manualMode = data.manualMode;
 }
-function collectDcpNudgeStats(session) {
+function collectDcpNudgeStats(session, latestState) {
     const stats = {
         emitted: 0,
         upgraded: 0,
@@ -105,7 +111,6 @@ function collectDcpNudgeStats(session) {
         activeByType: { "turn": 0, "iteration": 0, "context-soft": 0, "context-strong": 0 },
     };
     const branch = session.sessionManager.getBranch();
-    const latestState = latestCustomEntryData(branch, "dcp-state");
     if (latestState)
         applyActiveAnchorStats(stats, latestState);
     for (const entry of branch) {
@@ -156,19 +161,40 @@ function applyActiveAnchorStats(stats, data) {
         };
     }
 }
+function resolveLatestDcpState(session) {
+    const sidecar = loadSidecarDcpState(session);
+    if (sidecar)
+        return { data: sidecar, source: "sidecar" };
+    return undefined;
+}
+function loadSidecarDcpState(session) {
+    const sessionManager = session.sessionManager;
+    const sessionDir = sessionManager.getSessionDir?.();
+    const sessionId = sessionManager.getSessionId?.();
+    if (!sessionDir || !sessionId)
+        return undefined;
+    try {
+        const statePath = join(sessionDir, "dcp-state", safeSessionFileName(sessionId));
+        const parsed = JSON.parse(readFileSync(statePath, "utf8"));
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function safeSessionFileName(sessionId) {
+    return `${sessionId.replace(/[^a-zA-Z0-9._-]/g, "_")}.json`;
+}
+function formatStateSource(source) {
+    if (source === "sidecar")
+        return "dcp-state sidecar";
+    return "compress tool results";
+}
 function customEntryData(entry, customType) {
     if (!isRecord(entry) || entry.type !== "custom" || entry.customType !== customType)
         return undefined;
     return isRecord(entry.data) ? entry.data : undefined;
 }
-function latestCustomEntryData(entries, customType) {
-    for (let i = entries.length - 1; i >= 0; i--) {
-        const data = customEntryData(entries[i], customType);
-        if (data)
-            return data;
-    }
-    return undefined;
-}
 function parseToolResultText(content) {
     const parsed = parseArgsText(textContent(content));
     return isRecord(parsed) ? parsed : undefined;

package/dist/app/rendering/render-controller.js

@@ -67,6 +67,8 @@ export class AppRenderController {
         this.deps.mouseController.statusUserJumpTarget = undefined;
         this.deps.mouseController.statusThinkingExpandTarget = undefined;
         this.deps.mouseController.statusCompactToolsTarget = undefined;
+        this.deps.mouseController.statusQuickScrollUpTarget = undefined;
+        this.deps.mouseController.statusQuickScrollDownTarget = undefined;
         this.deps.mouseController.statusTerminalBellSoundTarget = undefined;
         this.deps.mouseController.statusSessionTarget = undefined;
         this.deps.mouseController.statusPromptEnhancerTarget = undefined;
@@ -289,6 +291,8 @@ export class AppRenderController {
             this.deps.mouseController.statusUserJumpTarget = this.deps.statusLineRenderer.userJumpTarget?.(widgetLayout, widgetRow);
             this.deps.mouseController.statusThinkingExpandTarget = this.deps.statusLineRenderer.thinkingExpandTarget?.(widgetLayout, widgetRow);
             this.deps.mouseController.statusCompactToolsTarget = this.deps.statusLineRenderer.compactToolsTarget?.(widgetLayout, widgetRow);
+            this.deps.mouseController.statusQuickScrollUpTarget = this.deps.statusLineRenderer.quickScrollUpTarget?.(widgetLayout, widgetRow);
+            this.deps.mouseController.statusQuickScrollDownTarget = this.deps.statusLineRenderer.quickScrollDownTarget?.(widgetLayout, widgetRow);
             this.deps.mouseController.statusTerminalBellSoundTarget = this.deps.statusLineRenderer.terminalBellSoundTarget?.(widgetLayout, widgetRow);
         }
         this.deps.mouseController.statusSessionTarget = this.deps.statusLineRenderer.sessionTarget(statusLayout.text, statusRow, statusLayout.sessionLabel, statusLayout.workspaceLabel);

package/dist/app/rendering/status-line-renderer.d.ts

@@ -1,6 +1,6 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
 import type { Theme } from "../../theme.js";
-import type { SessionActivity, StatusCompactToolsTarget, StatusContextTarget, StatusDraftQueueTarget, StatusLineLayout, StatusModelTarget, StatusModelUsageTarget, StatusPromptEnhancerTarget, StatusSessionTarget, StatusTerminalBellSoundTarget, StatusThinkingExpandTarget, StatusThinkingTarget, StatusUserJumpTarget, StatusVoiceLanguageTarget, StatusVoiceMicTarget } from "../types.js";
+import type { SessionActivity, StatusCompactToolsTarget, StatusContextTarget, StatusDraftQueueTarget, StatusLineLayout, StatusModelTarget, StatusModelUsageTarget, StatusPromptEnhancerTarget, StatusQuickScrollTarget, StatusSessionTarget, StatusTerminalBellSoundTarget, StatusThinkingExpandTarget, StatusThinkingTarget, StatusUserJumpTarget, StatusVoiceLanguageTarget, StatusVoiceMicTarget } from "../types.js";
 import type { ScreenStyler } from "../screen/screen-styler.js";
 import { type ModelColorsConfig } from "../../config.js";
 export type StatusLineRendererHost = {
@@ -26,6 +26,10 @@ export type StatusLineRendererHost = {
     terminalBellSoundStatusWidgetEnabled(): boolean;
     voiceStatusWidgetText(): string;
     voiceStatusWidgetActive(): boolean;
+    conversationQuickScrollDirections?(): {
+        up: boolean;
+        down: boolean;
+    };
     queueableInputActive?(): boolean;
     userMessageJumpMenuActive?(): boolean;
     allThinkingExpandedActive?(): boolean;
@@ -50,6 +54,8 @@ export declare class StatusLineRenderer {
     draftQueueTarget(layout: StatusLineLayout, row: number): StatusDraftQueueTarget | undefined;
     thinkingExpandTarget(layout: StatusLineLayout, row: number): StatusThinkingExpandTarget | undefined;
     compactToolsTarget(layout: StatusLineLayout, row: number): StatusCompactToolsTarget | undefined;
+    quickScrollUpTarget(layout: StatusLineLayout, row: number): StatusQuickScrollTarget | undefined;
+    quickScrollDownTarget(layout: StatusLineLayout, row: number): StatusQuickScrollTarget | undefined;
     terminalBellSoundTarget(layout: StatusLineLayout, row: number): StatusTerminalBellSoundTarget | undefined;
     sessionTarget(statusText: string, row: number, label: string, workspaceLabel: string): StatusSessionTarget | undefined;
     private segments;
@@ -65,6 +71,7 @@ export declare class StatusLineRenderer {
     private pushVoiceWidgetSegment;
     private pushWorkspaceSegments;
     private pushModelUsageSegments;
+    private modelUsageHasWarning;
     private modelUsageResetLength;
     private pushSegment;
     private pushContextBarSegments;

package/dist/app/rendering/status-line-renderer.js

@@ -58,6 +58,7 @@ export class StatusLineRenderer {
             widgets.push({ text, assign });
             hasParts = true;
         };
+        const quickScrollDirections = this.host.conversationQuickScrollDirections?.() ?? { up: false, down: false };
         const draftQueueButton = this.draftQueueWidgetText();
         appendWidget(draftQueueButton ? this.iconButtonText(draftQueueButton) : "", (column, text) => {
             layout.draftQueueWidget = this.widgetLayout(column, text);
@@ -79,6 +80,12 @@ export class StatusLineRenderer {
         appendWidget(this.iconButtonText(APP_ICONS.compactTools), (column, text) => {
             layout.compactToolsWidget = this.widgetLayout(column, text);
         });
+        appendWidget(quickScrollDirections.up ? this.iconButtonText(APP_ICONS.up) : "", (column, text) => {
+            layout.quickScrollUpWidget = this.widgetLayout(column, text);
+        });
+        appendWidget(quickScrollDirections.down ? this.iconButtonText(APP_ICONS.down) : "", (column, text) => {
+            layout.quickScrollDownWidget = this.widgetLayout(column, text);
+        });
         const voiceWidgetText = this.host.voiceStatusWidgetText();
         appendWidget(this.voiceBorderWidgetText(voiceWidgetText), (column, text) => {
             layout.voiceWidget = this.voiceWidgetLayout(column, voiceWidgetText, text);
@@ -137,6 +144,8 @@ export class StatusLineRenderer {
             : this.host.promptEnhancerStatusWidgetEnabled()
                 ? colors.info
                 : colors.muted);
+        pushWidgetSegment(layout.quickScrollUpWidget, colors.info);
+        pushWidgetSegment(layout.quickScrollDownWidget, colors.info);
         pushWidgetSegment(layout.userJumpWidget, this.host.userMessageJumpMenuActive?.() ? colors.info : colors.muted);
         pushWidgetSegment(layout.terminalBellSoundWidget, this.host.terminalBellSoundStatusWidgetEnabled() ? colors.info : colors.muted);
         pushWidgetSegment(layout.thinkingExpandWidget, this.host.allThinkingExpandedActive?.() ? colors.info : colors.muted);
@@ -252,6 +261,18 @@ export class StatusLineRenderer {
             return undefined;
         return { row, startColumn: widget.startColumn, endColumn: widget.endColumn };
     }
+    quickScrollUpTarget(layout, row) {
+        const widget = layout.quickScrollUpWidget;
+        if (!widget)
+            return undefined;
+        return { row, startColumn: widget.startColumn, endColumn: widget.endColumn, direction: "up" };
+    }
+    quickScrollDownTarget(layout, row) {
+        const widget = layout.quickScrollDownWidget;
+        if (!widget)
+            return undefined;
+        return { row, startColumn: widget.startColumn, endColumn: widget.endColumn, direction: "down" };
+    }
     terminalBellSoundTarget(layout, row) {
         const widget = layout.terminalBellSoundWidget;
         if (!widget)
@@ -470,11 +491,25 @@ export class StatusLineRenderer {
                 fill: color,
                 track: this.host.theme.colors.statusDotBase,
             }, MODEL_USAGE_PROGRESS_BAR_WIDTH));
-            const resetStart = barStart + MODEL_USAGE_PROGRESS_BAR_WIDTH + 1;
+            const defaultResetStart = barStart + MODEL_USAGE_PROGRESS_BAR_WIDTH + 1;
+            const warningStart = this.modelUsageHasWarning(modelUsageLabel, defaultResetStart - labelStart)
+                ? defaultResetStart
+                : undefined;
+            const resetStart = warningStart === undefined
+                ? defaultResetStart
+                : warningStart + APP_ICONS.alert.length + 1;
+            if (warningStart !== undefined) {
+                this.pushSegment(segments, warningStart, APP_ICONS.alert.length, this.host.theme.colors.warning);
+            }
             const resetLength = this.modelUsageResetLength(modelUsageLabel, resetStart - labelStart);
             this.pushSegment(segments, resetStart, resetLength, this.host.theme.colors.muted);
         }
     }
+    modelUsageHasWarning(modelUsageLabel, localStart) {
+        if (localStart < 0 || localStart >= modelUsageLabel.length)
+            return false;
+        return modelUsageLabel.startsWith(APP_ICONS.alert, localStart);
+    }
     modelUsageResetLength(modelUsageLabel, localStart) {
         if (localStart < 0 || localStart >= modelUsageLabel.length)
             return 0;

package/dist/app/rendering/tab-line-renderer.js

@@ -197,9 +197,9 @@ export class TabLineRenderer {
             return { foreground: this.host.theme.colors.error, bold: true };
         }
         if (tab.activity === "running" || tab.activity === "thinking") {
-            return { foreground: this.host.theme.colors.success, bold: true };
+            return { foreground: this.host.theme.colors.warning, bold: true };
         }
-        return { foreground: this.host.theme.colors.statusDotBase };
+        return { foreground: this.host.theme.colors.success };
     }
     statusIndicatorIcon(tab) {
         if (tab.status !== "active" && tab.attention === "terminal-bell" && tab.attentionVisible !== false) {

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

@@ -26,5 +26,6 @@ export type ToolBlockRenderOptions = {
     backgroundOverride?: string;
     skipHeaderBackground?: boolean;
     showGutter?: boolean;
+    headerColorOverride?: string;
 };
 export declare function renderToolBlock(entry: ToolBlockEntry, rule: ResolvedToolRule, width: number, colors: Theme["colors"], options?: ToolBlockRenderOptions): RenderedLine[];

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

@@ -18,7 +18,7 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     const hasLspDiagnostics = hasToolLspDiagnosticsAfterMutation(entry);
     const expanded = entry.expanded;
     const stateIcon = toolStatusIcon(entry);
-    const toolColor = resolveColor(rule.color, colors);
+    const toolColor = options.headerColorOverride ?? resolveColor(rule.color, colors);
     const toolOutputColor = colors.statusForeground;
     const headerLabel = (entry.headerLabel ?? entry.toolName).toLowerCase();
     const bg = options.backgroundOverride;
@@ -87,18 +87,42 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     return headerLines;
 }
 function renderCollapsedPreviewLines(entry, body, rule, width, target, color, colors, hasLspDiagnostics, showGutter) {
-    const allLines = renderToolBodyLines(body, width, target, color, entry.bodyStyle, colors, undefined, entry.bodyWrap, hasLspDiagnostics, entry.bodyLineStyles, entry.preserveAnsi, showGutter);
-    if (rule.previewLines >= allLines.length)
-        return allLines;
-    const previewLines = rule.direction === "tail" ? allLines.slice(-rule.previewLines) : allLines.slice(0, rule.previewLines);
+    const preview = previewBodyText(body, rule.direction, rule.previewLines);
+    const allPreviewLines = renderToolBodyLines(preview.text, width, target, color, entry.bodyStyle, colors, undefined, entry.bodyWrap, hasLspDiagnostics, entry.bodyLineStyles, entry.preserveAnsi, showGutter, { rawLineOffset: preview.rawLineOffset, bodyEndsAfterText: !preview.omittedAfter });
+    const overflow = preview.omittedBefore || preview.omittedAfter || allPreviewLines.length > rule.previewLines;
+    if (!overflow)
+        return allPreviewLines;
+    const previewLines = rule.direction === "tail" ? allPreviewLines.slice(-rule.previewLines) : allPreviewLines.slice(0, rule.previewLines);
     return markTruncatedPreviewLine(previewLines, rule.direction, colors.statusDotBase);
 }
 function collapsedInlinePreview(text, rule, preserveAnsi = false) {
-    const rawLines = sanitizeToolBodyText(text, preserveAnsi).split("\n").map((line) => stripAnsi(line).trim()).filter(Boolean);
+    const preview = previewBodyText(text, rule.direction, rule.previewLines);
+    const rawLines = sanitizeToolBodyText(preview.text, preserveAnsi).split("\n").map((line) => stripAnsi(line).trim()).filter(Boolean);
     if (rawLines.length === 0)
         return { text: "", overflow: false };
     const selectedLines = rule.direction === "tail" ? rawLines.slice(-rule.previewLines) : rawLines.slice(0, rule.previewLines);
-    return { text: selectedLines.join(" "), overflow: rawLines.length > rule.previewLines };
+    return { text: selectedLines.join(" "), overflow: preview.omittedBefore || preview.omittedAfter || rawLines.length > rule.previewLines };
+}
+function previewBodyText(text, direction, previewLines) {
+    const rawLines = text.split("\n");
+    const previewRawLines = Math.max(1, previewLines + 1);
+    if (rawLines.length <= previewRawLines)
+        return { text, rawLineOffset: 0, omittedBefore: false, omittedAfter: false };
+    if (direction === "tail") {
+        const start = Math.max(0, rawLines.length - previewRawLines);
+        return {
+            text: rawLines.slice(start).join("\n"),
+            rawLineOffset: start,
+            omittedBefore: start > 0,
+            omittedAfter: false,
+        };
+    }
+    return {
+        text: rawLines.slice(0, previewRawLines).join("\n"),
+        rawLineOffset: 0,
+        omittedBefore: false,
+        omittedAfter: rawLines.length > previewRawLines,
+    };
 }
 function markTruncatedPreviewLine(lines, direction, markerColor) {
     if (lines.length === 0)
@@ -122,7 +146,7 @@ function markTruncatedPreviewLine(lines, direction, markerColor) {
         };
     });
 }
-function renderToolBodyLines(text, width, target, color, style, colors, syntaxHighlight, bodyWrap = "char", hasLspDiagnostics = false, bodyLineStyles, preserveAnsi = false, showGutter = false) {
+function renderToolBodyLines(text, width, target, color, style, colors, syntaxHighlight, bodyWrap = "char", hasLspDiagnostics = false, bodyLineStyles, preserveAnsi = false, showGutter = false, options = {}) {
     const displayPrefix = showGutter ? toolBodyGutterPrefix() : TOOL_BODY_PREFIX;
     const prefixWidth = stringDisplayWidth(displayPrefix);
     const bodyWidth = Math.max(1, width - prefixWidth);
@@ -131,13 +155,15 @@ function renderToolBodyLines(text, width, target, color, style, colors, syntaxHi
     const gutterSegment = showGutter
         ? { start: 0, end: 1, foreground: colors.statusDotBase }
         : undefined;
+    const rawLineOffset = options.rawLineOffset ?? 0;
     for (const [rawLineIndex, rawLine] of sanitizeToolBodyText(text, preserveAnsi).split("\n").entries()) {
+        const absoluteRawLineIndex = rawLineOffset + rawLineIndex;
         const ansiLine = preserveAnsi ? ansiStyledLine(rawLine) : undefined;
         const displayLine = ansiLine?.text ?? rawLine;
         const diffStyle = style === "diff" ? diffLineStyle(displayLine, colors) : undefined;
         const lspDiagnosticStyle = hasLspDiagnostics ? lspDiagnosticLineStyle(displayLine, colors) : undefined;
-        const bodyLineStyle = bodyLineStyleForLine(bodyLineStyles, rawLineIndex, colors);
-        const lineSyntaxHighlight = syntaxHighlightForLine(syntaxHighlight, rawLineIndex);
+        const bodyLineStyle = bodyLineStyleForLine(bodyLineStyles, absoluteRawLineIndex, colors);
+        const lineSyntaxHighlight = syntaxHighlightForLine(syntaxHighlight, absoluteRawLineIndex);
         const wrappedLines = ansiLine && !diffStyle && !lspDiagnosticStyle && !bodyLineStyle && !lineSyntaxHighlight
             ? wrapAnsiStyledDisplayLine(ansiLine, bodyWidth)
             : wrapBodyLine(displayLine, bodyWidth).map((wrapped) => ({ text: wrapped, segments: [] }));
@@ -195,7 +221,7 @@ function renderToolBodyLines(text, width, target, color, style, colors, syntaxHi
             lines.push(line);
         }
     }
-    if (showGutter && lines.length > 0) {
+    if (showGutter && lines.length > 0 && options.bodyEndsAfterText !== false) {
         const lastLine = lines.at(-1);
         if (!lastLine)
             return lines;

package/dist/app/runtime.js

@@ -10,7 +10,7 @@ import { isThinkingLevel, parseModelRef, parseScopedModelRef } from "./model/mod
 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");
+const BUNDLED_EXTENSIONS_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "bundled-extensions");
 const BUNDLED_QUESTION_EXTENSION_DIR = resolve(BUNDLED_EXTENSIONS_DIR, BUNDLED_QUESTION_EXTENSION_NAME);
 const BUNDLED_SESSION_TITLE_EXTENSION_DIR = resolve(BUNDLED_EXTENSIONS_DIR, "session-title");
 const BUNDLED_TERMINAL_BELL_EXTENSION_DIR = resolve(BUNDLED_EXTENSIONS_DIR, "terminal-bell");

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

@@ -6,7 +6,7 @@ import type { ToastEntry, ToastVariant } from "../../ui.js";
 import type { AppPopupActionController } from "../popup/popup-action-controller.js";
 import type { AppPopupMenuController } from "../popup/popup-menu-controller.js";
 import type { AppScrollController } from "./scroll-controller.js";
-import type { Entry, ImageClickTarget, MouseEvent, MouseSelection, StatusContextTarget, StatusCompactToolsTarget, StatusDraftQueueTarget, StatusModelTarget, StatusModelUsageTarget, StatusPromptEnhancerTarget, StatusSessionTarget, StatusTerminalBellSoundTarget, TabLineMouseTarget, StatusThinkingExpandTarget, StatusThinkingTarget, StatusUserJumpTarget, StatusVoiceLanguageTarget, StatusVoiceMicTarget } from "../types.js";
+import type { Entry, ImageClickTarget, MouseEvent, MouseSelection, StatusContextTarget, StatusCompactToolsTarget, StatusDraftQueueTarget, StatusModelTarget, StatusModelUsageTarget, StatusPromptEnhancerTarget, StatusQuickScrollTarget, StatusSessionTarget, StatusTerminalBellSoundTarget, TabLineMouseTarget, StatusThinkingExpandTarget, StatusThinkingTarget, StatusUserJumpTarget, StatusVoiceLanguageTarget, StatusVoiceMicTarget } from "../types.js";
 import { type RenderedLink } from "./file-links.js";
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
 type ClickFlash = {
@@ -56,6 +56,7 @@ export type AppMouseControllerHost = {
     refreshModelUsageStatus(): void | Promise<void>;
     refreshUserMessageJumpMenuItems?(): Promise<void>;
     queueInputFromStatus?(): void | Promise<void>;
+    scrollConversationQuick(direction: "up" | "down"): void | Promise<void>;
     toggleAllThinkingExpanded?(): void;
     toggleSuperCompactTools?(): void;
     toggleTerminalBellSound?(): void;
@@ -103,6 +104,8 @@ export declare class AppMouseController {
     statusDraftQueueTarget: StatusDraftQueueTarget | undefined;
     statusThinkingExpandTarget: StatusThinkingExpandTarget | undefined;
     statusCompactToolsTarget: StatusCompactToolsTarget | undefined;
+    statusQuickScrollUpTarget: StatusQuickScrollTarget | undefined;
+    statusQuickScrollDownTarget: StatusQuickScrollTarget | undefined;
     statusTerminalBellSoundTarget: StatusTerminalBellSoundTarget | undefined;
     statusSessionTarget: StatusSessionTarget | undefined;
     statusPromptEnhancerTarget: StatusPromptEnhancerTarget | undefined;
@@ -165,6 +168,7 @@ export declare class AppMouseController {
     private handleStatusPromptEnhancerClick;
     private handleStatusVoiceMicClick;
     private handleStatusVoiceLanguageClick;
+    private handleStatusQuickScrollClick;
     private handleInputClick;
     private handleExtensionInputClick;
     private openUserMessageMenu;