pi-ui-extend 0.1.33 → 0.1.35

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);

package/dist/app/rendering/editor-panels.js

@@ -71,30 +71,45 @@ export function renderTodoPanel(details, expanded, width, colors) {
 export function renderSubagentsPanel(state, expanded, width, colors) {
     if (!state)
         return [];
-    const activeAgents = activeSubagentStates(state.agents);
+    const runs = state.runs?.length
+        ? state.runs
+        : [{ runDir: state.runDir, agents: state.agents, ...(state.tasks === undefined ? {} : { tasks: state.tasks }) }];
+    const activeRuns = runs
+        .map((run) => ({ ...run, activeAgents: activeSubagentStates(run.agents) }))
+        .filter((run) => run.activeAgents.length > 0);
+    const activeAgents = activeRuns.flatMap((run) => run.activeAgents);
     if (activeAgents.length === 0)
         return [];
     const target = { kind: "subagents-panel" };
-    const previewById = taskPreviewMap(state.tasks);
-    const runName = subagentRunName(state.runDir);
     const titleSuffix = state.live ? "" : " (snapshot)";
     const stats = formatSubagentsPanelStats(activeAgents);
     const headerText = `subagents ${expanded ? "▾" : "▸"}${stats ? ` ${stats}` : ""}${titleSuffix}`;
     const contentWidth = Math.max(1, width);
     if (!expanded) {
-        const collapsedText = `${headerText} — ${runName}`;
+        const runSummary = activeRuns.length === 1 ? subagentRunName(activeRuns[0]?.runDir ?? state.runDir) : `${activeRuns.length} runs`;
+        const collapsedText = `${headerText} — ${runSummary}`;
         return [{ text: padOrTrimPlain(ellipsizeDisplay(collapsedText, contentWidth), width), colorOverride: colors.accent, target }];
     }
     const lines = [];
-    const visibleAgents = activeAgents.slice(0, SUBAGENTS_WIDGET_MAX_ROWS);
+    const flattenedRuns = activeRuns.flatMap((run) => {
+        const previewById = taskPreviewMap(run.tasks);
+        return run.activeAgents.map((agent, index) => ({
+            runDir: run.runDir,
+            agent,
+            preview: previewById.get(agent.id),
+            showRunLabel: activeRuns.length > 1 && index === 0,
+        }));
+    });
+    const visibleAgents = flattenedRuns.slice(0, SUBAGENTS_WIDGET_MAX_ROWS);
     const rowWidth = contentWidth;
     const now = Date.now();
-    for (const agent of visibleAgents) {
-        const preview = previewById.get(agent.id);
+    for (const visibleRun of visibleAgents) {
+        const { agent, preview } = visibleRun;
         const model = subagentModelThinkingLabel(preview);
         const task = preview?.task?.trim() || preview?.scope?.trim() || "task unavailable";
         const icon = subagentStatusIcon(agent.status);
-        const prefix = `${icon} ${agent.id} ${model} `;
+        const runLabel = visibleRun.showRunLabel ? `${subagentRunName(visibleRun.runDir)} ` : "";
+        const prefix = `${runLabel}${icon} ${agent.id} ${model} `;
         const suffix = ` ${formatElapsedSince(agent.startedAt, now)}`;
         const taskWidth = Math.max(8, rowWidth - stringDisplayWidth(prefix) - stringDisplayWidth(suffix));
         const taskText = ellipsizeDisplay(task, taskWidth);
@@ -102,22 +117,24 @@ export function renderSubagentsPanel(state, expanded, width, colors) {
         lines.push({
             text: padOrTrimPlain(text, width),
             colorOverride: colors.muted,
-            segments: subagentPanelLineSegments({ text, icon, agentId: agent.id, model, taskText, prefix, status: agent.status }, colors),
+            segments: subagentPanelLineSegments({ text, icon, agentId: agent.id, model, taskText, prefix, runLabel, status: agent.status }, colors),
             target,
         });
     }
-    const hidden = activeAgents.length - visibleAgents.length;
+    const hidden = flattenedRuns.length - visibleAgents.length;
     if (hidden > 0)
         lines.push({ text: padOrTrimPlain(`+${hidden} more`, width), variant: "muted", target });
     return lines;
 }
 function subagentPanelLineSegments(input, colors) {
     const iconStart = input.text.indexOf(input.icon);
+    const runLabelStart = input.runLabel ? input.text.indexOf(input.runLabel) : -1;
     const nameStart = input.text.indexOf(input.agentId, iconStart + input.icon.length);
     const modelStart = input.text.indexOf(input.model, nameStart + input.agentId.length);
     const taskStart = input.prefix.length;
     const suffixStart = taskStart + input.taskText.length;
     return [
+        ...(runLabelStart >= 0 ? [{ start: runLabelStart, end: runLabelStart + input.runLabel.length, foreground: colors.warning }] : []),
         { start: iconStart, end: iconStart + input.icon.length, foreground: subagentStatusColor(input.status, colors), bold: true },
         { start: nameStart, end: nameStart + input.agentId.length, foreground: colors.accent, bold: true },
         { start: modelStart, end: modelStart + input.model.length, foreground: colors.info },

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

@@ -71,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

@@ -491,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/runtime.d.ts

@@ -38,6 +38,7 @@ export declare function prioritizeBundledQuestionExtension(base: LoadExtensionsR
 export type CreatePixRuntimeOptions = {
     eventBus?: EventBus;
     config?: PixConfig;
+    reuseServicesFrom?: AgentSessionRuntime;
 };
 type RuntimeSessionManagerModelState = Pick<SessionManager, "getEntries" | "getBranch">;
 export declare function resolvePixRuntimeModelRef(options: Pick<AppOptions, "modelRef">, sessionManager: RuntimeSessionManagerModelState, config?: PixConfig): string | undefined;

package/dist/app/runtime.js

@@ -220,26 +220,20 @@ export function resolveSessionModelRefFromTail(entries) {
 }
 export async function createPixRuntime(options, runtimeOptions = {}) {
     const agentDir = getAgentDir();
+    const reusableServices = reusableRuntimeServices(runtimeOptions.reuseServicesFrom, options.cwd, agentDir);
     const createRuntime = async ({ cwd, sessionManager, sessionStartEvent }) => {
         const config = runtimeOptions.config ?? loadPixConfig(cwd);
         const effectiveModelRef = resolvePixRuntimeModelRef(options, sessionManager, config);
         const parsedModel = effectiveModelRef ? parseModelRef(effectiveModelRef) : undefined;
         const initialThinkingLevel = resolvePixRuntimeInitialThinkingLevel(options, sessionManager, config);
-        await ensureBundledSkillsInstalledOnce();
-        await ensurePiToolsSuiteExtensionInstalledOnce({ agentDir });
-        const bundledExtensionPaths = await getBundledExtensionPathsAsync();
-        const services = await createAgentSessionServices({
-            cwd,
-            agentDir,
-            resourceLoaderOptions: {
-                ...(config.ignoreContextFiles ? { noContextFiles: true } : {}),
+        const services = reusableServices && sameRuntimeServiceTarget(reusableServices, cwd, agentDir)
+            ? reusableServices
+            : await createPixRuntimeServices({
+                cwd,
+                agentDir,
+                config,
                 ...(runtimeOptions.eventBus === undefined ? {} : { eventBus: runtimeOptions.eventBus }),
-                ...(bundledExtensionPaths.length === 0 ? {} : {
-                    additionalExtensionPaths: bundledExtensionPaths,
-                    extensionsOverride: prioritizeBundledQuestionExtension,
-                }),
-            },
-        });
+            });
         services.modelRegistry.refresh();
         const model = parsedModel ? services.modelRegistry.find(parsedModel.provider, parsedModel.modelId) : undefined;
         if (parsedModel && !model) {
@@ -285,3 +279,28 @@ export async function createPixRuntime(options, runtimeOptions = {}) {
                 : SessionManager.create(options.cwd),
     });
 }
+async function createPixRuntimeServices(options) {
+    await ensureBundledSkillsInstalledOnce();
+    await ensurePiToolsSuiteExtensionInstalledOnce({ agentDir: options.agentDir });
+    const bundledExtensionPaths = await getBundledExtensionPathsAsync();
+    return await createAgentSessionServices({
+        cwd: options.cwd,
+        agentDir: options.agentDir,
+        resourceLoaderOptions: {
+            ...(options.config.ignoreContextFiles ? { noContextFiles: true } : {}),
+            ...(options.eventBus === undefined ? {} : { eventBus: options.eventBus }),
+            ...(bundledExtensionPaths.length === 0 ? {} : {
+                additionalExtensionPaths: bundledExtensionPaths,
+                extensionsOverride: prioritizeBundledQuestionExtension,
+            }),
+        },
+    });
+}
+function reusableRuntimeServices(runtime, cwd, agentDir) {
+    const services = runtime?.services;
+    return services && sameRuntimeServiceTarget(services, cwd, agentDir) ? services : undefined;
+}
+function sameRuntimeServiceTarget(services, cwd, agentDir) {
+    return normalizePathForCompare(services.cwd) === normalizePathForCompare(cwd)
+        && normalizePathForCompare(services.agentDir) === normalizePathForCompare(agentDir);
+}

package/dist/app/session/session-event-controller.d.ts

@@ -19,6 +19,7 @@ export type AppSessionEventControllerState = {
     currentAssistantTextBlockContentIndex: number | undefined;
     assistantTextBlocksByContentIndex: Map<number, string>;
     currentThinkingEntryId: string | undefined;
+    currentThinkingEntryStartedAt: number | undefined;
     assistantMessageClosed: boolean;
     assistantTextBuffer: string;
     entryRenderVersions: Map<string, number>;
@@ -74,6 +75,8 @@ export declare class AppSessionEventController {
     private historyEntries;
     private historyWindowStart;
     private currentThinkingEntryId;
+    private currentThinkingEntryStartedAt;
+    private thinkingElapsedRenderTimer;
     private assistantMessageClosed;
     private assistantTextBuffer;
     constructor(host: AppSessionEventControllerHost);
@@ -133,7 +136,11 @@ export declare class AppSessionEventController {
     private appendThinkingText;
     private finishCurrentThinkingEntry;
     private reconcileThinkingText;
+    private syncThinkingElapsedRenderTimer;
+    private startThinkingElapsedRenderTimer;
+    private stopThinkingElapsedRenderTimer;
     private currentThinkingLevel;
+    private reconcileAssistantTextFromFinalMessage;
     private renderAssistantToolCallsFromMessage;
     private upsertPendingToolCall;
     private upsertToolEntry;

package/dist/app/session/session-event-controller.js

@@ -26,6 +26,8 @@ export class AppSessionEventController {
     historyEntries = [];
     historyWindowStart = 0;
     currentThinkingEntryId;
+    currentThinkingEntryStartedAt;
+    thinkingElapsedRenderTimer;
     assistantMessageClosed = false;
     assistantTextBuffer = "";
     constructor(host) {
@@ -44,6 +46,7 @@ export class AppSessionEventController {
             currentAssistantTextBlockContentIndex: this.currentAssistantTextBlockContentIndex,
             assistantTextBlocksByContentIndex: new Map(this.assistantTextBlocksByContentIndex),
             currentThinkingEntryId: this.currentThinkingEntryId,
+            currentThinkingEntryStartedAt: this.currentThinkingEntryStartedAt,
             assistantMessageClosed: this.assistantMessageClosed,
             assistantTextBuffer: this.assistantTextBuffer,
             entryRenderVersions: new Map(this.entryRenderVersions),
@@ -71,6 +74,8 @@ export class AppSessionEventController {
         for (const [key, value] of state.assistantTextBlocksByContentIndex)
             this.assistantTextBlocksByContentIndex.set(key, value);
         this.currentThinkingEntryId = state.currentThinkingEntryId;
+        this.currentThinkingEntryStartedAt = state.currentThinkingEntryStartedAt;
+        this.syncThinkingElapsedRenderTimer();
         this.assistantMessageClosed = state.assistantMessageClosed;
         this.assistantTextBuffer = state.assistantTextBuffer;
         this.entryRenderVersions.clear();
@@ -94,6 +99,8 @@ export class AppSessionEventController {
         this.assistantTextBlocksByContentIndex.clear();
         this.finalizedToolCallContentIndexes.clear();
         this.currentThinkingEntryId = undefined;
+        this.currentThinkingEntryStartedAt = undefined;
+        this.stopThinkingElapsedRenderTimer();
         this.assistantMessageClosed = false;
         this.assistantTextBuffer = "";
         this.olderHistoryLoader = undefined;
@@ -195,7 +202,7 @@ export class AppSessionEventController {
                 this.host.updateQueuedMessageStatus();
                 break;
             case "message_update":
-                this.handleMessageUpdate(event.assistantMessageEvent);
+                this.handleMessageUpdate(event);
                 break;
             case "tool_execution_start":
                 this.finishCurrentThinkingEntry();
@@ -506,7 +513,8 @@ export class AppSessionEventController {
             return;
         this.host.recordWorkspaceMutationForUserEntry(prepared.userEntryId, mutation);
     }
-    handleMessageUpdate(assistantEvent) {
+    handleMessageUpdate(event) {
+        const assistantEvent = event.assistantMessageEvent;
         if (this.assistantMessageClosed && assistantEvent.type !== "done")
             return;
         this.assistantMessageClosed = false;
@@ -522,7 +530,13 @@ export class AppSessionEventController {
             case "text_delta":
                 this.finishCurrentThinkingEntry();
                 this.host.setSessionActivity("running");
-                this.appendAssistantText(assistantEvent.delta, assistantEvent.contentIndex);
+                {
+                    const snapshotText = assistantTextSnapshotForContentIndex(event.message, assistantEvent.partial, assistantEvent.contentIndex);
+                    if (snapshotText === undefined)
+                        this.appendAssistantText(assistantEvent.delta, assistantEvent.contentIndex);
+                    else
+                        this.reconcileAssistantTextBlock(snapshotText, assistantEvent.contentIndex, { keepOpen: true });
+                }
                 break;
             case "text_end":
                 this.finishCurrentThinkingEntry();
@@ -556,6 +570,7 @@ export class AppSessionEventController {
                 this.handleToolCallStreamUpdate(assistantEvent.contentIndex, assistantEvent.partial, assistantEvent.toolCall);
                 break;
             case "done":
+                this.reconcileAssistantTextFromFinalMessage(assistantEvent.message);
                 this.renderAssistantToolCallsFromMessage(assistantEvent.message);
                 this.finishCurrentThinkingEntry();
                 this.flushAssistantTextBuffer(true);
@@ -616,7 +631,7 @@ export class AppSessionEventController {
         entry.text += visibleText;
         this.touchEntry(entry);
     }
-    reconcileAssistantTextBlock(content, contentIndex) {
+    reconcileAssistantTextBlock(content, contentIndex, options = {}) {
         this.flushAssistantTextBuffer(true);
         const hasVisibleTextBeforeBlock = this.hasVisibleTextBeforeCurrentAssistantBlock();
         // C.11: normalise CRLF in the final block content (see appendAssistantText).
@@ -667,9 +682,16 @@ export class AppSessionEventController {
         this.currentAssistantEntryId = entry.id;
         if (contentIndex !== undefined)
             this.assistantTextBlocksByContentIndex.set(contentIndex, visibleText);
-        this.currentAssistantTextBlockEntryId = undefined;
-        this.currentAssistantTextBlockStartLength = undefined;
-        this.currentAssistantTextBlockContentIndex = undefined;
+        if (options.keepOpen) {
+            this.currentAssistantTextBlockEntryId = entry.id;
+            this.currentAssistantTextBlockStartLength = startLength;
+            this.currentAssistantTextBlockContentIndex = contentIndex;
+        }
+        else {
+            this.currentAssistantTextBlockEntryId = undefined;
+            this.currentAssistantTextBlockStartLength = undefined;
+            this.currentAssistantTextBlockContentIndex = undefined;
+        }
         this.assistantTextBuffer = "";
     }
     ensureAssistantTextBlockStarted(entry) {
@@ -740,12 +762,15 @@ export class AppSessionEventController {
             : undefined;
         if (!entry || entry.kind !== "thinking") {
             const level = this.currentThinkingLevel();
+            const startedAt = this.currentThinkingEntryStartedAt ?? Date.now();
+            this.currentThinkingEntryStartedAt = startedAt;
             entry = {
                 id: createId("thinking"),
                 kind: "thinking",
                 text: "",
                 expanded: this.host.toolDefaultExpanded(THINKING_TOOL_NAME),
                 ...(level === undefined ? {} : { level }),
+                startedAt,
                 status: "running",
             };
             this.addEntry(entry);
@@ -756,17 +781,24 @@ export class AppSessionEventController {
             delete entry.level;
         else
             entry.level = level;
+        entry.startedAt ??= this.currentThinkingEntryStartedAt ?? Date.now();
+        this.currentThinkingEntryStartedAt = entry.startedAt;
+        delete entry.finishedAt;
         entry.status = "running";
         entry.text += delta;
+        this.startThinkingElapsedRenderTimer();
         this.touchEntry(entry);
     }
     finishCurrentThinkingEntry() {
         const entry = this.currentThinkingEntryId ? this.findEntry(this.currentThinkingEntryId) : undefined;
         if (entry?.kind === "thinking" && entry.status !== "done") {
             entry.status = "done";
+            entry.finishedAt ??= Date.now();
             this.touchEntry(entry);
         }
         this.currentThinkingEntryId = undefined;
+        this.currentThinkingEntryStartedAt = undefined;
+        this.stopThinkingElapsedRenderTimer();
     }
     reconcileThinkingText(content) {
         let entry = this.currentThinkingEntryId
@@ -774,12 +806,15 @@ export class AppSessionEventController {
             : undefined;
         if (!entry || entry.kind !== "thinking") {
             const level = this.currentThinkingLevel();
+            const startedAt = this.currentThinkingEntryStartedAt ?? Date.now();
+            this.currentThinkingEntryStartedAt = startedAt;
             entry = {
                 id: createId("thinking"),
                 kind: "thinking",
                 text: "",
                 expanded: this.host.toolDefaultExpanded(THINKING_TOOL_NAME),
                 ...(level === undefined ? {} : { level }),
+                startedAt,
                 status: "running",
             };
             this.addEntry(entry);
@@ -792,13 +827,63 @@ export class AppSessionEventController {
                 delete entry.level;
             else
                 entry.level = level;
+            entry.startedAt ??= this.currentThinkingEntryStartedAt ?? Date.now();
+            this.currentThinkingEntryStartedAt = entry.startedAt;
+            delete entry.finishedAt;
             entry.status = "running";
+            this.startThinkingElapsedRenderTimer();
             this.touchEntry(entry);
         }
     }
+    syncThinkingElapsedRenderTimer() {
+        const entry = this.currentThinkingEntryId ? this.findEntry(this.currentThinkingEntryId) : undefined;
+        if (entry?.kind === "thinking" && entry.status === "running" && entry.startedAt !== undefined) {
+            this.startThinkingElapsedRenderTimer();
+            return;
+        }
+        this.stopThinkingElapsedRenderTimer();
+    }
+    startThinkingElapsedRenderTimer() {
+        if (this.thinkingElapsedRenderTimer)
+            return;
+        this.thinkingElapsedRenderTimer = setInterval(() => {
+            if (!this.host.isRunning()) {
+                this.stopThinkingElapsedRenderTimer();
+                return;
+            }
+            this.host.scheduleRender();
+        }, 1000);
+        this.thinkingElapsedRenderTimer.unref?.();
+    }
+    stopThinkingElapsedRenderTimer() {
+        if (!this.thinkingElapsedRenderTimer)
+            return;
+        clearInterval(this.thinkingElapsedRenderTimer);
+        this.thinkingElapsedRenderTimer = undefined;
+    }
     currentThinkingLevel() {
         return this.host.runtime()?.session.thinkingLevel;
     }
+    reconcileAssistantTextFromFinalMessage(message) {
+        const openContentIndex = this.currentAssistantTextBlockContentIndex;
+        if (openContentIndex !== undefined) {
+            const content = assistantTextContentAt(message, openContentIndex);
+            if (content !== undefined)
+                this.reconcileAssistantTextBlock(content, openContentIndex);
+            return;
+        }
+        const textBlocks = assistantTextContents(message);
+        if (textBlocks.length !== 1)
+            return;
+        const entry = this.currentAssistantEntryId ? this.findEntry(this.currentAssistantEntryId) : undefined;
+        if (entry?.kind !== "assistant")
+            return;
+        const visibleText = assistantStreamVisibleTextForCompleteBlock(textBlocks[0] ?? "", false);
+        if (!visibleText || entry.text === visibleText)
+            return;
+        entry.text = visibleText;
+        this.touchEntry(entry);
+    }
     renderAssistantToolCallsFromMessage(message) {
         if (!isRecord(message) || !Array.isArray(message.content))
             return;
@@ -879,6 +964,8 @@ export class AppSessionEventController {
         this.currentAssistantTextBlockStartLength = undefined;
         this.currentAssistantTextBlockContentIndex = undefined;
         this.currentThinkingEntryId = undefined;
+        this.currentThinkingEntryStartedAt = undefined;
+        this.stopThinkingElapsedRenderTimer();
         this.assistantTextBuffer = "";
         this.assistantTextBlocksByContentIndex.clear();
         this.finalizedToolCallContentIndexes.clear();
@@ -891,6 +978,22 @@ function partialToolCallAt(partial, contentIndex) {
     const block = partial.content[contentIndex];
     return isRecord(block) && block.type === "toolCall" ? block : undefined;
 }
+function assistantTextSnapshotForContentIndex(message, partial, contentIndex) {
+    if (contentIndex === undefined)
+        return undefined;
+    return assistantTextContentAt(message, contentIndex) ?? assistantTextContentAt(partial, contentIndex);
+}
+function assistantTextContentAt(value, contentIndex) {
+    if (!isRecord(value) || !Array.isArray(value.content))
+        return undefined;
+    const block = value.content[contentIndex];
+    return isRecord(block) && block.type === "text" && typeof block.text === "string" ? block.text : undefined;
+}
+function assistantTextContents(value) {
+    if (!isRecord(value) || !Array.isArray(value.content))
+        return [];
+    return value.content.flatMap((block) => (isRecord(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []));
+}
 function assistantStreamVisibleTextForCompleteBlock(text, hasVisibleTextBeforeBlock) {
     let buffer = text;
     let visibleText = "";

package/dist/app/session/tabs-controller.js

@@ -641,7 +641,9 @@ export class AppTabsController {
         void this.saveTabs();
         this.scheduleTabPrewarm();
         const cachedView = this.sessionViewsByTabId.get(target.id);
-        if (cachedView && this.host.restoreSessionView) {
+        const cachedViewNeedsHistoryReload = this.tabIdsNeedingHistoryReload.has(target.id)
+            && this.sessionActivity(targetRuntime.session) !== "running";
+        if (cachedView && this.host.restoreSessionView && !cachedViewNeedsHistoryReload) {
             this.host.restoreSessionView(cachedView);
             this.restoreDeferredUserMessages(target.id);
             this.host.setSessionStatus(targetRuntime.session);

package/dist/app/subagents/subagents-widget-controller.d.ts

@@ -13,7 +13,9 @@ export declare class AppSubagentsWidgetController {
     private pollTimer;
     private pollInFlight;
     private currentRunDir;
+    private currentRunDirs;
     private state;
+    private readonly runFreshnessByRunDir;
     private readonly taskPreviewsByRunDir;
     private readonly snapshotByRunDir;
     private refreshGeneration;
@@ -32,10 +34,16 @@ export declare class AppSubagentsWidgetController {
     private schedulePoll;
     private poll;
     private refreshFromFiles;
-    private findActiveRegistryRunDirForCurrentSession;
+    private findActiveRegistryRunDirsForCurrentSession;
     private registryRunDirsNewestFirst;
-    private clearMissingRunAndMaybeSelectReplacement;
     private clearCachedRun;
+    private buildStateFromRuns;
+    private orderRuns;
+    private orderRunDirs;
+    private rememberRunFreshness;
+    private runFreshness;
+    private runFreshnessFromAgents;
+    private parseRunTimestamp;
     private updateState;
     private isCurrentGeneration;
     private shouldContinuePolling;