pi-ui-extend 0.1.34 → 0.1.36

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

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

package/dist/app/popup/popup-action-controller.d.ts

@@ -7,6 +7,7 @@ import type { Entry, SlashCommand, UserMessageJumpMenuValue } from "../types.js"
 import type { AppWorkspaceActionsController } from "../workspace/workspace-actions-controller.js";
 export type AppPopupActionControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
+    awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
     getBuiltinSlashCommands(): readonly SlashCommand[];
     isRunning(): boolean;
     setInput(value: string): void;

package/dist/app/popup/popup-action-controller.js

@@ -228,6 +228,7 @@ export class AppPopupActionController {
         this.host.setStatus("switching session");
         this.host.render();
         try {
+            await this.host.awaitCurrentSessionExtensions(runtime);
             const result = await runtime.switchSession(session.path);
             if (result.cancelled) {
                 this.host.addEntry({ id: createId("system"), kind: "system", text: "Resume cancelled." });

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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