pi-ui-extend 0.1.34 → 0.1.35

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;

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;
@@ -563,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);
@@ -754,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);
@@ -770,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
@@ -788,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);
@@ -806,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;
@@ -893,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();
@@ -916,6 +989,11 @@ function assistantTextContentAt(value, contentIndex) {
     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;