pi-ui-extend 0.1.69 → 0.1.71

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

@@ -38,6 +38,7 @@ export class AppPopupActionController {
         return false;
     }
     async submitSlashCommand(text) {
+        const scope = this.captureScope();
         const parsed = this.menuItems.parseSlashInput(text);
         if (!parsed)
             return;
@@ -67,7 +68,7 @@ export class AppPopupActionController {
         this.host.render();
         try {
             if (command.kind === "resource") {
-                await this.executeResourceSlashCommand(command, parsed.arguments);
+                await this.executeResourceSlashCommand(command, parsed.arguments, scope.session);
             }
             else {
                 if (!command.run)
@@ -76,11 +77,13 @@ export class AppPopupActionController {
             }
         }
         catch (error) {
+            if (!this.isScopeActive(scope))
+                return;
             this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
             this.host.showToast(`/${command.name} failed`, "error");
             this.host.setSessionStatus(this.host.runtime()?.session);
         }
-        if (this.host.isRunning())
+        if (this.isScopeActive(scope))
             this.host.render();
     }
     async submitSelectedSlashCommand() {
@@ -97,6 +100,7 @@ export class AppPopupActionController {
         return true;
     }
     async submitSelectedModel() {
+        const scope = this.captureScope();
         const selected = this.popupMenus.selectedModel();
         if (!selected)
             return false;
@@ -110,15 +114,18 @@ export class AppPopupActionController {
             await this.commandController.runModelCommand(selected.value.model);
         }
         catch (error) {
+            if (!this.isScopeActive(scope))
+                return true;
             this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
             this.host.showToast("/model failed", "error");
             this.host.setSessionStatus(this.host.runtime()?.session);
         }
-        if (this.host.isRunning())
+        if (this.isScopeActive(scope))
             this.host.render();
         return true;
     }
     async submitSelectedThinking() {
+        const scope = this.captureScope();
         const selected = this.popupMenus.selectedThinking();
         if (!selected)
             return false;
@@ -132,15 +139,18 @@ export class AppPopupActionController {
             await this.commandController.runThinkingCommand(selected.value.level);
         }
         catch (error) {
+            if (!this.isScopeActive(scope))
+                return true;
             this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
             this.host.showToast("/thinking failed", "error");
             this.host.setSessionStatus(this.host.runtime()?.session);
         }
-        if (this.host.isRunning())
+        if (this.isScopeActive(scope))
             this.host.render();
         return true;
     }
     async submitSelectedUserMessageAction() {
+        const scope = this.captureScope();
         const selected = this.popupMenus.selectedUserMessageAction();
         if (!selected)
             return false;
@@ -163,6 +173,8 @@ export class AppPopupActionController {
             return true;
         }
         catch (error) {
+            if (!this.isScopeActive(scope))
+                return true;
             this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
             this.host.showToast(`${selected.label} failed`, "error");
             this.host.setSessionStatus(this.host.runtime()?.session);
@@ -170,11 +182,15 @@ export class AppPopupActionController {
         }
     }
     async submitSelectedUserMessageJump() {
+        const scope = this.captureScope();
         const selected = this.popupMenus.selectedUserMessageJump();
         if (!selected)
             return false;
         this.popupMenus.closeUserMessageJumpMenu();
-        if (!await this.host.scrollToUserMessageJumpTarget(selected)) {
+        const found = await this.host.scrollToUserMessageJumpTarget(selected);
+        if (!this.isScopeActive(scope))
+            return true;
+        if (!found) {
             this.host.showToast("User message not found", "error");
             this.host.setSessionStatus(this.host.runtime()?.session);
             return true;
@@ -184,6 +200,7 @@ export class AppPopupActionController {
         return true;
     }
     async submitSelectedQueueMessageAction() {
+        const scope = this.captureScope();
         const selected = this.popupMenus.selectedQueueMessageAction();
         if (!selected)
             return false;
@@ -202,6 +219,8 @@ export class AppPopupActionController {
             return true;
         }
         catch (error) {
+            if (!this.isScopeActive(scope))
+                return true;
             this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
             this.host.showToast(`${selected.label} failed`, "error");
             this.host.setSessionStatus(this.host.runtime()?.session);
@@ -229,7 +248,11 @@ export class AppPopupActionController {
         this.host.render();
         try {
             await this.host.awaitCurrentSessionExtensions(runtime);
+            if (!this.isRuntimeActive(runtime))
+                return true;
             const result = await runtime.switchSession(session.path);
+            if (!this.isRuntimeActive(runtime))
+                return true;
             if (result.cancelled) {
                 this.host.addEntry({ id: createId("system"), kind: "system", text: "Resume cancelled." });
                 this.host.setSessionStatus(runtime.session);
@@ -240,21 +263,33 @@ export class AppPopupActionController {
             this.host.afterSessionReplacement(`Resumed session "${name}"`);
         }
         catch (error) {
+            if (!this.isRuntimeActive(runtime))
+                return true;
             this.host.addEntry({ id: createId("error"), kind: "error", text: `Resume failed: ${error instanceof Error ? error.message : String(error)}` });
             this.host.showToast("Failed to resume session", "error");
             this.host.setSessionStatus(runtime.session);
         }
-        if (this.host.isRunning())
+        if (this.isRuntimeActive(runtime))
             this.host.render();
         return true;
     }
     formatSlashCommandLine(name, argumentsText) {
         return `/${name}${argumentsText ? ` ${argumentsText}` : ""}`;
     }
-    async executeResourceSlashCommand(command, argumentsText) {
+    async executeResourceSlashCommand(command, argumentsText, session) {
         const promptText = this.formatSlashCommandLine(command.name, argumentsText);
         this.host.setStatus(`running /${command.name}`);
-        await this.queuedMessages.submitUserMessage(this.queuedMessages.createSubmittedUserMessage(promptText, promptText, []));
+        await this.queuedMessages.submitUserMessage(this.queuedMessages.createSubmittedUserMessage(promptText, promptText, []), session);
+    }
+    captureScope() {
+        const runtime = this.host.runtime();
+        return { runtime, session: runtime?.session };
+    }
+    isScopeActive(scope) {
+        return this.host.isRunning() && this.host.runtime() === scope.runtime && scope.runtime?.session === scope.session;
+    }
+    isRuntimeActive(runtime) {
+        return this.host.isRunning() && this.host.runtime() === runtime;
     }
     getRuntime(commandName) {
         const runtime = this.host.runtime();

package/dist/app/session/queued-message-controller.d.ts

@@ -19,13 +19,14 @@ export type AppQueuedMessageControllerHost = {
     setInput(value: string): void;
     insertInput(value: string): void;
     attachImage(data: string, mimeType: string): void;
+    requeueAutoUserMessageForSession?(session: AgentSession, message: SubmittedUserMessage): void;
     onDeferredUserMessagesChanged?(): void;
 };
 export declare class AppQueuedMessageController {
     private readonly host;
     readonly autoUserMessages: SubmittedUserMessage[];
     readonly deferredUserMessages: SubmittedUserMessage[];
-    private promptSubmissionInFlightSession;
+    private readonly promptSubmissionsInFlight;
     private immediateSendInProgress;
     constructor(host: AppQueuedMessageControllerHost);
     reset(): void;
@@ -34,11 +35,11 @@ export declare class AppQueuedMessageController {
     captureDeferredUserMessages(): SubmittedUserMessage[];
     restoreDeferredUserMessages(messages: readonly SubmittedUserMessage[]): void;
     createSubmittedUserMessage(promptText: string, displayText: string, images: ImageContent[]): SubmittedUserMessage;
-    submitUserMessage(message: SubmittedUserMessage): Promise<void>;
+    submitUserMessage(message: SubmittedUserMessage, session?: AgentSession): Promise<void>;
     sendUserMessageToSession(message: SubmittedUserMessage, options?: {
         streamingBehavior?: "steer" | "followUp";
-    }): Promise<void>;
-    flushAutoUserMessages(): Promise<void>;
+    }, session?: AgentSession): Promise<void>;
+    flushAutoUserMessages(expectedSession?: AgentSession): Promise<void>;
     queuedMessageCounts(): {
         steering: number;
         followUp: number;

package/dist/app/session/queued-message-controller.js

@@ -5,7 +5,7 @@ export class AppQueuedMessageController {
     host;
     autoUserMessages = [];
     deferredUserMessages = [];
-    promptSubmissionInFlightSession;
+    promptSubmissionsInFlight = new Set();
     immediateSendInProgress = false;
     constructor(host) {
         this.host = host;
@@ -13,7 +13,7 @@ export class AppQueuedMessageController {
     reset() {
         this.autoUserMessages.length = 0;
         this.deferredUserMessages.length = 0;
-        this.promptSubmissionInFlightSession = undefined;
+        this.promptSubmissionsInFlight.clear();
     }
     captureAutoUserMessages() {
         return this.autoUserMessages.map(cloneSubmittedUserMessage);
@@ -40,51 +40,52 @@ export class AppQueuedMessageController {
             images,
         };
     }
-    async submitUserMessage(message) {
-        const session = this.host.requireRuntime().session;
-        if (session.isStreaming) {
-            await this.sendUserMessageToSession(message, { streamingBehavior: "steer" });
+    async submitUserMessage(message, session) {
+        const targetSession = session ?? this.host.requireRuntime().session;
+        if (targetSession.isStreaming) {
+            await this.sendUserMessageToSession(message, { streamingBehavior: "steer" }, targetSession);
             return;
         }
-        if (this.shouldQueueUserMessageAsSteering(session)) {
+        if (this.shouldQueueUserMessageAsSteering(targetSession)) {
             await this.queueUserMessageAsSteering(message);
             return;
         }
-        await this.sendUserMessageToSession(message);
+        await this.sendUserMessageToSession(message, {}, targetSession);
     }
-    async sendUserMessageToSession(message, options = {}) {
-        const session = this.host.requireRuntime().session;
-        const markInFlight = !session.isStreaming;
+    async sendUserMessageToSession(message, options = {}, session) {
+        const targetSession = session ?? this.host.requireRuntime().session;
+        const markInFlight = !targetSession.isStreaming;
         if (markInFlight)
-            this.promptSubmissionInFlightSession = session;
+            this.promptSubmissionsInFlight.add(targetSession);
         this.host.setSessionActivity("running");
         try {
             const opts = {};
-            if (session.isStreaming)
+            if (targetSession.isStreaming)
                 opts.streamingBehavior = options.streamingBehavior ?? "steer";
             if (message.images.length > 0)
                 opts.images = message.images;
-            await session.prompt(message.promptText, Object.keys(opts).length > 0 ? opts : undefined);
+            await targetSession.prompt(message.promptText, Object.keys(opts).length > 0 ? opts : undefined);
         }
         finally {
-            if (markInFlight && this.promptSubmissionInFlightSession === session)
-                this.promptSubmissionInFlightSession = undefined;
+            if (markInFlight)
+                this.promptSubmissionsInFlight.delete(targetSession);
             const runtime = this.host.runtime();
-            if (runtime) {
-                const activeSession = runtime.session;
-                this.host.setSessionStatus(activeSession);
-                this.host.setSessionActivity(activeSession.isStreaming || activeSession.isCompacting ? "running" : "idle");
-            }
+            if (runtime?.session !== targetSession)
+                return;
+            this.host.setSessionStatus(targetSession);
+            this.host.setSessionActivity(targetSession.isStreaming || targetSession.isCompacting ? "running" : "idle");
             if (this.totalQueuedMessageCount() > 0)
                 this.updateQueuedMessageStatus();
-            void this.flushAutoUserMessages();
+            void this.flushAutoUserMessages(targetSession);
         }
     }
-    async flushAutoUserMessages() {
+    async flushAutoUserMessages(expectedSession) {
         if (this.immediateSendInProgress || this.autoUserMessages.length === 0)
             return;
         const session = this.host.runtime()?.session;
-        if (!session || session.isStreaming || session.isCompacting || this.promptSubmissionInFlightSession === session)
+        if (expectedSession && session !== expectedSession)
+            return;
+        if (!session || session.isStreaming || session.isCompacting || this.promptSubmissionsInFlight.has(session))
             return;
         const message = this.autoUserMessages.shift();
         if (!message)
@@ -94,9 +95,13 @@ export class AppQueuedMessageController {
         if (this.host.isRunning())
             this.host.render();
         try {
-            await this.sendUserMessageToSession(message);
+            await this.sendUserMessageToSession(message, {}, session);
         }
         catch (error) {
+            if (this.host.runtime()?.session !== session) {
+                this.host.requeueAutoUserMessageForSession?.(session, message);
+                return;
+            }
             this.autoUserMessages.unshift(message);
             this.notifyAutoUserMessagesChanged();
             this.updateQueuedMessageStatus();
@@ -201,7 +206,7 @@ export class AppQueuedMessageController {
             const message = typeof taken.removed === "string"
                 ? this.createSubmittedUserMessage(taken.removed, taken.removed, [])
                 : taken.removed;
-            await this.sendUserMessageToSession(message, { streamingBehavior: "steer" });
+            await this.sendUserMessageToSession(message, { streamingBehavior: "steer" }, session);
             this.host.setSessionStatus(this.host.runtime()?.session);
             this.host.showToast("Queued message sent", "success");
         }
@@ -237,7 +242,7 @@ export class AppQueuedMessageController {
         return deferredQueuedMessageEntries(this.deferredUserMessages);
     }
     shouldQueueUserMessageAsSteering(session) {
-        return session.isCompacting || this.promptSubmissionInFlightSession === session;
+        return session.isCompacting || this.promptSubmissionsInFlight.has(session);
     }
     async queueUserMessageAsSteering(message) {
         this.autoUserMessages.push(message);

package/dist/app/session/request-history.d.ts

@@ -12,6 +12,8 @@ export declare class AppRequestHistory {
     private entries;
     private cursor;
     private draft;
+    private saveChain;
+    private saveSequence;
     constructor(host: RequestHistoryHost);
     load(): Promise<void>;
     add(text: string): void;

package/dist/app/session/request-history.js

@@ -9,12 +9,14 @@ export class AppRequestHistory {
     entries = [];
     cursor;
     draft = "";
+    saveChain = Promise.resolve();
+    saveSequence = 0;
     constructor(host) {
         this.host = host;
     }
     async load() {
         if (this.host.noSession)
-            return;
+            return Promise.resolve();
         try {
             const raw = await readFile(this.filePath(), "utf8");
             const parsed = JSON.parse(raw);
@@ -93,21 +95,26 @@ export class AppRequestHistory {
         this.replaceInput(entry);
         return true;
     }
-    async save() {
+    save() {
         if (this.host.noSession)
-            return;
-        try {
-            this.entries = this.limited(this.entries);
-            const filePath = this.filePath();
-            const payload = this.payload(this.entries);
-            await mkdir(dirname(filePath), { recursive: true });
-            const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-            await writeFile(tempPath, payload, "utf8");
-            await rename(tempPath, filePath);
-        }
-        catch {
-            // Request history is a convenience feature; never interrupt the UI on disk errors.
-        }
+            return Promise.resolve();
+        this.entries = this.limited(this.entries);
+        const payload = this.payload(this.entries);
+        const sequence = ++this.saveSequence;
+        const writeSnapshot = async () => {
+            try {
+                const filePath = this.filePath();
+                await mkdir(dirname(filePath), { recursive: true });
+                const tempPath = `${filePath}.${process.pid}.${sequence}.tmp`;
+                await writeFile(tempPath, payload, "utf8");
+                await rename(tempPath, filePath);
+            }
+            catch {
+                // Request history is a convenience feature; never interrupt the UI on disk errors.
+            }
+        };
+        this.saveChain = this.saveChain.then(writeSnapshot, writeSnapshot);
+        return this.saveChain;
     }
     replaceInput(value) {
         if (value !== this.host.getInput()) {

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

@@ -1,7 +1,7 @@
 import { createId } from "../id.js";
 import { extractImageContents, renderContent, renderUserMessageContent, stringifyUnknown } from "../rendering/message-content.js";
 import { customMessageEntry, extensionSessionEntry, loadSessionHistoryEntries, loadSessionHistoryEntriesAsync } from "./session-history.js";
-import { sessionHistoryDisplayMessages, sessionHistoryDisplayMessagesFromEntries, sessionHistoryFullBranchEntries } from "./pix-system-message.js";
+import { sessionHistoryDisplayMessages, sessionHistoryDisplayMessagesFromEntries, sessionHistoryFullBranchEntries, sessionHistoryOlderMessagesReader } from "./pix-system-message.js";
 import { THINKING_TOOL_NAME } from "../constants.js";
 import { isRecord } from "../guards.js";
 /**
@@ -132,24 +132,44 @@ export class AppSessionEventController {
         this.olderHistoryLoader = undefined;
         this.historyEntries = [];
         this.historyWindowStart = 0;
-        const branchEntries = await sessionHistoryFullBranchEntries(runtime.session);
+        const lazyOlderHistory = options.lazyOlderHistory === true;
+        const historyEntries = lazyOlderHistory ? undefined : [];
+        const messages = lazyOlderHistory
+            ? sessionHistoryDisplayMessages(runtime.session)
+            : sessionHistoryDisplayMessagesFromEntries(await sessionHistoryFullBranchEntries(runtime.session));
         if (options.isCancelled())
             return false;
-        const historyEntries = [];
         const loaded = await loadSessionHistoryEntriesAsync({
-            messages: sessionHistoryDisplayMessagesFromEntries(branchEntries),
-            addEntry: (entry) => historyEntries.push(entry),
-            prependEntries: (entries) => historyEntries.unshift(...entries),
+            messages,
+            addEntry: (entry) => {
+                if (historyEntries)
+                    historyEntries.push(entry);
+                else
+                    this.addEntry(entry);
+            },
+            prependEntries: (entries) => {
+                if (historyEntries)
+                    historyEntries.unshift(...entries);
+                else
+                    this.prependEntries(entries);
+            },
             setToolEntryId: (toolCallId, entryId) => this.toolEntryIdsByCallId.set(toolCallId, entryId),
             toolDefaultExpanded: (toolName) => this.host.toolDefaultExpanded(toolName),
             observeSubagentsToolResult: (toolName, details, options) => this.host.observeSubagentsToolResult(toolName, details, options),
             observeTodoToolResult: (toolName, details, isError) => this.host.observeTodoToolResult(toolName, details, isError),
             isCancelled: options.isCancelled,
-            render: () => { },
-            lazyOlderHistory: false,
+            render: lazyOlderHistory ? options.render : () => { },
+            lazyOlderHistory,
+            olderMessagesReader: lazyOlderHistory ? sessionHistoryOlderMessagesReader(runtime.session) : undefined,
+            onOlderLoaderReady: (loader) => {
+                if (!options.isCancelled())
+                    this.olderHistoryLoader = loader;
+            },
         });
         if (!loaded)
             return false;
+        if (!historyEntries)
+            return !options.isCancelled();
         this.historyEntries = historyEntries;
         this.setHistoryWindowStart(this.maxHistoryWindowStart());
         options.render();

package/dist/app/session/session-history.js

@@ -112,11 +112,17 @@ async function externalOlderMessagesBatch(olderMessagesReader, chunkSize) {
 }
 function expandedTailStart(messages, initialStart) {
     let start = initialStart;
+    const firstMessage = messages[start];
+    if (!isRecord(firstMessage) || (firstMessage.role !== "assistant" && firstMessage.role !== "toolResult"))
+        return start;
+    // A fixed-size tail can otherwise begin inside a long assistant/tool turn,
+    // hiding the user prompt that owns the first visible response. Keep that turn
+    // atomic so reaching the top never stops at an orphaned assistant block.
     while (start > 0) {
+        start -= 1;
         const message = messages[start];
-        if (!isRecord(message) || message.role !== "toolResult")
+        if (isRecord(message) && message.role === "user")
             break;
-        start -= 1;
     }
     return start;
 }

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

@@ -55,9 +55,15 @@ export type BindCurrentSessionOptions = {
 export declare class AppSessionLifecycleController {
     private readonly host;
     private unsubscribe;
+    private ownershipRuntime;
+    private ownershipSession;
+    private ownershipGeneration;
+    private subscriptionGeneration;
+    private replacementHistoryGeneration;
     private extensionBindPromise;
     private extensionBindRuntime;
     private extensionBindSession;
+    private extensionBindOwnershipGeneration;
     constructor(host: AppSessionLifecycleHost);
     start(): Promise<void>;
     bindCurrentSession(options?: BindCurrentSessionOptions): Promise<void>;
@@ -70,6 +76,7 @@ export declare class AppSessionLifecycleController {
     requireRuntime(): AgentSessionRuntime;
     private bindSessionExtensions;
     private collectAvailabilityIssues;
+    private advanceOwnership;
     private isCurrentRuntimeSession;
     private extensionUiScope;
 }