pi-ui-extend 0.1.70 → 0.1.72

package/dist/app/app.d.ts

@@ -62,6 +62,7 @@ export declare class PiUiExtendApp {
     private subagentsPanelExpanded;
     private allThinkingExpanded;
     private superCompactTools;
+    private internalClipboardText;
     private voicePartialText;
     private resumeSessions;
     private resumeLoading;
@@ -86,6 +87,7 @@ export declare class PiUiExtendApp {
     private restoreTabInputState;
     private clearPersistedInputDraft;
     private insertVoiceTranscript;
+    private pasteInternalClipboard;
     private setVoicePartialTranscript;
     private addVoiceSystemMessage;
     private resetSessionView;

package/dist/app/app.js

@@ -132,6 +132,7 @@ export class PiUiExtendApp {
     subagentsPanelExpanded = true;
     allThinkingExpanded = false;
     superCompactTools = false;
+    internalClipboardText;
     voicePartialText;
     resumeSessions = [];
     resumeLoading = false;
@@ -221,6 +222,7 @@ export class PiUiExtendApp {
             runtime: () => this.runtime,
             inputEditor: () => this.inputEditor,
             activeInputTabId: () => this.tabsController.activeInputTabId(),
+            isInputTabOwnedByRuntime: (tabId, runtime, session) => this.tabsController.inputTabOwnedByRuntime(tabId, runtime, session),
             inputStateForTab: (tabId) => this.tabsController.inputStateForTab(tabId),
             setInputStateForTab: (tabId, state) => this.tabsController.setInputStateForTab(tabId, state),
             promptEnhancerConfig: () => this.pixConfig.promptEnhancer,
@@ -239,6 +241,7 @@ export class PiUiExtendApp {
             render: () => this.render(),
         });
         this.voiceController = new AppVoiceController({
+            activeInputScope: () => this.tabsController.activeInputTabId(),
             insertTranscript: (text) => this.insertVoiceTranscript(text),
             setPartialTranscript: (text) => this.setVoicePartialTranscript(text),
             addSystemMessage: (message) => this.addVoiceSystemMessage(message),
@@ -308,6 +311,7 @@ export class PiUiExtendApp {
             voiceStatusWidgetActive: () => this.voiceController.statusWidgetActive(),
             conversationQuickScrollDirections: () => this.conversationQuickScrollDirections(),
             queueableInputActive: () => this.inputEditor.promptText.trimEnd().length > 0 || this.inputEditor.images.length > 0,
+            internalClipboardActive: () => Boolean(this.internalClipboardText),
             userMessageJumpMenuActive: () => this.popupMenus.directMenu === "user-message-jump",
             allThinkingExpandedActive: () => this.allThinkingExpanded,
             superCompactToolsActive: () => this.superCompactTools,
@@ -320,6 +324,7 @@ export class PiUiExtendApp {
         this.extensionUiController = new ExtensionUiController({
             theme: this.theme,
             activeExtensionUiScope: () => this.activeExtensionUiScope(),
+            isExtensionUiScopeActive: (scopeKey) => !this.tabsController.isSwitching() && this.activeExtensionUiScope() === scopeKey,
             isRunning: () => this.running,
             render: () => this.render(),
             showToast: (message, kind, options) => this.showToast(message, kind, options),
@@ -335,6 +340,7 @@ export class PiUiExtendApp {
         });
         this.extensionActions = new AppExtensionActionsController({
             isRunning: () => this.running,
+            runtime: () => this.runtime,
             getInput: () => this.input,
             setInput: (value) => this.setInput(value),
             awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
@@ -430,6 +436,7 @@ export class PiUiExtendApp {
             setInput: (value) => this.inputEditor.setText(value),
             insertInput: (value) => this.inputEditor.insert(value),
             attachImage: (data, mimeType) => this.inputEditor.attachImage(data, mimeType),
+            requeueAutoUserMessageForSession: (session, message) => this.tabsController.requeueAutoUserMessageForSession(session, message),
             onDeferredUserMessagesChanged: () => this.tabsController.persistActiveDeferredUserMessages(),
         });
         this.editorLayoutRenderer = new EditorLayoutRenderer({
@@ -608,6 +615,10 @@ export class PiUiExtendApp {
                     this.render();
                 });
             },
+            pasteInternalClipboard: () => this.pasteInternalClipboard(),
+            setInternalClipboardText: (text) => {
+                this.internalClipboardText = text;
+            },
             scrollConversationQuick: (direction) => this.scrollConversationQuick(direction),
             toggleAllThinkingExpanded: () => {
                 this.allThinkingExpanded = !this.allThinkingExpanded;
@@ -648,6 +659,7 @@ export class PiUiExtendApp {
         this.shellController = new AppShellController({
             cwd: this.options.cwd,
             isRunning: () => this.running,
+            activeScopeKey: () => this.tabsController.activeInputTabId(),
             addEntry: (entry) => this.addEntry(entry),
             touchEntry: (entry) => this.touchEntry(entry),
             setStatus: (status) => this.setStatus(status),
@@ -658,6 +670,7 @@ export class PiUiExtendApp {
         });
         this.inputActions = new AppInputActionController({
             runtime: () => this.runtime,
+            inputScopeKey: () => this.tabsController.activeInputTabId(),
             isRunning: () => this.running,
             isSessionSwitching: () => this.tabsController.isSwitching(),
             inputEditor: () => this.inputEditor,
@@ -688,6 +701,7 @@ export class PiUiExtendApp {
         this.inputController = new AppInputController({
             inputEditor: this.inputEditor,
             cwd: this.options.cwd,
+            inputScopeKey: () => this.tabsController.activeInputTabId(),
             handleExtensionTerminalInput: (data) => this.extensionUiController.handleTerminalInput(data),
             extensionInputUsesEditor: () => this.extensionUiController.activeCustomUiUsesEditor(),
             getInput: () => this.input,
@@ -718,6 +732,7 @@ export class PiUiExtendApp {
             setRunning: (running) => {
                 this.running = running;
             },
+            cancelPendingTabLifecycle: () => this.tabsController.cancelPendingLifecycleWork(),
             runtime: () => this.runtime,
             saveInputStateForQuit: () => this.tabsController.saveInputStateForQuit(),
             disposeInactiveRuntimesForQuit: () => this.tabsController.disposeInactiveRuntimes((runtime) => this.terminalController.disposeRuntimeForQuit(runtime)),
@@ -783,6 +798,7 @@ export class PiUiExtendApp {
                 this.mouseController.statusContextTarget = undefined;
                 this.mouseController.statusModelUsageTarget = undefined;
                 this.mouseController.statusDraftQueueTarget = undefined;
+                this.mouseController.statusInternalClipboardTarget = undefined;
                 this.mouseController.statusUserJumpTarget = undefined;
                 this.mouseController.statusThinkingExpandTarget = undefined;
                 this.mouseController.statusCompactToolsTarget = undefined;
@@ -874,11 +890,17 @@ export class PiUiExtendApp {
         await this.sessionLifecycle.awaitCurrentSessionExtensions(runtime);
     }
     async activateRuntime(runtime, options) {
+        this.extensionUiController.cancelCustomUi(this.activeExtensionUiScope());
+        void this.voiceController.stopRecording();
         this.runtime = runtime;
         runtime.setRebindSession(async () => {
+            if (!this.running || this.runtime !== runtime)
+                return;
             await this.bindCurrentSession({ awaitExtensions: false });
         });
         runtime.setBeforeSessionInvalidate(() => {
+            if (!this.running || this.runtime !== runtime)
+                return;
             this.extensionUiController.clearWidgets(this.activeExtensionUiScope());
         });
         await this.bindCurrentSession(options);
@@ -929,7 +951,7 @@ export class PiUiExtendApp {
     restoreTabInputState(state) {
         this.requestHistory.resetNavigation();
         this.popupMenus.resetInputMenuDismissals();
-        this.inputEditor.setDraftState(state);
+        this.inputEditor.restoreDraftState(state);
         this.autocompleteController.dispose();
     }
     async clearPersistedInputDraft() {
@@ -951,6 +973,16 @@ export class PiUiExtendApp {
         this.inputEditor.insert(`${prefix}${transcript}${suffix}`);
         this.render();
     }
+    pasteInternalClipboard() {
+        if (!this.internalClipboardText) {
+            this.showToast("Nothing has been copied inside Pix yet.", "info");
+            return;
+        }
+        this.requestHistory.resetNavigation();
+        this.popupMenus.resetInputMenuDismissals();
+        this.inputEditor.attachPastedText(this.internalClipboardText);
+        this.render();
+    }
     setVoicePartialTranscript(text) {
         if (this.voicePartialText === text)
             return;
@@ -1130,6 +1162,8 @@ export class PiUiExtendApp {
         });
     }
     showToast(message, kind = "info", options) {
+        if (!this.running)
+            return;
         this.toastController.showToast(message, kind, options);
     }
     toastNotifierForScope(scopeKey) {
@@ -1154,6 +1188,8 @@ export class PiUiExtendApp {
             clearTimeout(this.scheduledRenderTimer);
             this.scheduledRenderTimer = undefined;
         }
+        if (!this.running)
+            return;
         this.autocompleteController.observeInput();
         this.syncScrollAfterInputEditorChange();
         this.renderController.render();
@@ -1163,6 +1199,8 @@ export class PiUiExtendApp {
             return;
         this.scheduledRenderTimer = setTimeout(() => {
             this.scheduledRenderTimer = undefined;
+            if (!this.running)
+                return;
             this.syncScrollAfterInputEditorChange();
             this.renderController.render();
         }, COALESCED_RENDER_DELAY_MS);

package/dist/app/commands/command-host.d.ts

@@ -52,3 +52,10 @@ export type CommandControllerHost = {
     openNewTab(): Promise<void>;
     openSearchResultInNewTab(result: SessionSearchResult): Promise<void>;
 };
+export type CommandScope = {
+    readonly runtime: AgentSessionRuntime | undefined;
+    readonly session: AgentSession | undefined;
+};
+export declare function captureCommandScope(host: CommandControllerHost): CommandScope;
+export declare function isCommandRuntimeActive(host: CommandControllerHost, runtime: AgentSessionRuntime): boolean;
+export declare function isCommandScopeActive(host: CommandControllerHost, scope: CommandScope): boolean;

package/dist/app/commands/command-host.js

@@ -1 +1,10 @@
-export {};
+export function captureCommandScope(host) {
+    const runtime = host.runtime();
+    return { runtime, session: runtime?.session };
+}
+export function isCommandRuntimeActive(host, runtime) {
+    return host.isRunning() && host.runtime() === runtime;
+}
+export function isCommandScopeActive(host, scope) {
+    return host.isRunning() && host.runtime() === scope.runtime && scope.runtime?.session === scope.session;
+}

package/dist/app/commands/command-model-actions.d.ts

@@ -1,4 +1,4 @@
-import type { CommandControllerHost } from "./command-host.js";
+import { type CommandControllerHost } from "./command-host.js";
 import type { SessionModel, ThinkingLevel } from "../types.js";
 export declare class ModelCommandActions {
     private readonly host;

package/dist/app/commands/command-model-actions.js

@@ -1,4 +1,5 @@
 import { getIdleRuntime, getRuntime } from "./command-runtime.js";
+import { captureCommandScope, isCommandScopeActive, } from "./command-host.js";
 import { getProjectPixConfigPath, savePixAutocompleteModel, savePixDefaultModel, savePixDefaultThinking, saveProjectPixIgnoreContextFiles } from "../../config.js";
 import { createId } from "../id.js";
 import { isThinkingLevel, parseScopedModelRef } from "../model/model-ref.js";
@@ -41,6 +42,7 @@ export class ModelCommandActions {
         this.host.setSessionStatus(runtime.session);
     }
     async runModelSlashCommand(argumentsText) {
+        const scope = captureCommandScope(this.host);
         const modelRef = argumentsText.trim();
         if (!modelRef) {
             const selected = await this.host.showMenu(this.host.getModelMenuItems(""), {
@@ -48,6 +50,8 @@ export class ModelCommandActions {
                 placeholder: "Search models",
                 emptyText: "No matching models",
             });
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             if (!selected) {
                 this.host.setSessionStatus(this.host.runtime()?.session);
                 this.host.render();
@@ -64,10 +68,14 @@ export class ModelCommandActions {
         if (!parsed)
             throw new Error("Model must use provider/model[:thinking] format");
         await runtime.services.modelRuntime.reloadConfig();
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         const model = runtime.services.modelRuntime.getModel(parsed.provider, parsed.modelId);
         if (!model)
             throw new Error(`Model not found: ${parsed.provider}/${parsed.modelId}`);
         await this.runModelCommand(model);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         if (parsed.thinkingLevel !== undefined) {
             runtime.session.setThinkingLevel(parsed.thinkingLevel);
             this.addPersistentSystemEntry(runtime.session, `Selected thinking level ${runtime.session.thinkingLevel}`);
@@ -75,6 +83,7 @@ export class ModelCommandActions {
         }
     }
     async runDefaultModelSlashCommand(argumentsText) {
+        const scope = captureCommandScope(this.host);
         const modelRef = argumentsText.trim();
         if (!modelRef) {
             const selected = await this.host.showMenu(this.host.getModelMenuItems(""), {
@@ -82,6 +91,8 @@ export class ModelCommandActions {
                 placeholder: "Search models",
                 emptyText: "No matching models",
             });
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             if (!selected) {
                 this.host.setSessionStatus(this.host.runtime()?.session);
                 this.host.render();
@@ -98,6 +109,8 @@ export class ModelCommandActions {
         if (!parsed)
             throw new Error("Model must use provider/model[:thinking] format");
         await runtime.services.modelRuntime.reloadConfig();
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         const model = runtime.services.modelRuntime.getModel(parsed.provider, parsed.modelId);
         if (!model)
             throw new Error(`Model not found: ${parsed.provider}/${parsed.modelId}`);
@@ -105,6 +118,7 @@ export class ModelCommandActions {
         this.host.setSessionStatus(runtime.session);
     }
     async runAutocompleteSlashCommand(argumentsText) {
+        const scope = captureCommandScope(this.host);
         const modelRef = argumentsText.trim();
         if (!modelRef) {
             const saved = savePixAutocompleteModel("");
@@ -119,6 +133,8 @@ export class ModelCommandActions {
         if (!parsed)
             throw new Error("Model must use provider/model[:thinking] format, or run /autocomplete with no arguments to disable");
         await runtime.services.modelRuntime.reloadConfig();
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         const model = runtime.services.modelRuntime.getModel(parsed.provider, parsed.modelId);
         if (!model)
             throw new Error(`Model not found: ${parsed.provider}/${parsed.modelId}`);
@@ -161,6 +177,7 @@ export class ModelCommandActions {
         const runtime = getIdleRuntime(this.host, "scoped-models");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         const value = argumentsText.trim();
         if (!value) {
             const enabledModels = runtime.services.settingsManager.getEnabledModels();
@@ -200,6 +217,8 @@ export class ModelCommandActions {
         const scopedModels = [];
         const invalidRefs = [];
         await runtime.services.modelRuntime.reloadConfig();
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         for (const ref of refs) {
             const parsed = parseScopedModelRef(ref);
             const model = parsed ? runtime.services.modelRuntime.getModel(parsed.provider, parsed.modelId) : undefined;
@@ -219,6 +238,7 @@ export class ModelCommandActions {
         this.host.setSessionStatus(runtime.session);
     }
     async runThinkingSlashCommand(argumentsText) {
+        const scope = captureCommandScope(this.host);
         const level = argumentsText.trim();
         if (!level) {
             const selected = await this.host.showMenu(this.host.getThinkingMenuItems(""), {
@@ -226,6 +246,8 @@ export class ModelCommandActions {
                 placeholder: "Search thinking levels",
                 emptyText: "No matching thinking levels",
             });
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             if (!selected) {
                 this.host.setSessionStatus(this.host.runtime()?.session);
                 this.host.render();
@@ -240,6 +262,7 @@ export class ModelCommandActions {
         await this.runThinkingCommand(level);
     }
     async runDefaultThinkingSlashCommand(argumentsText) {
+        const scope = captureCommandScope(this.host);
         const level = argumentsText.trim();
         if (!level) {
             const selected = await this.host.showMenu(this.host.getThinkingMenuItems(""), {
@@ -247,6 +270,8 @@ export class ModelCommandActions {
                 placeholder: "Search thinking levels",
                 emptyText: "No matching thinking levels",
             });
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             if (!selected) {
                 this.host.setSessionStatus(this.host.runtime()?.session);
                 this.host.render();
@@ -264,10 +289,13 @@ export class ModelCommandActions {
         const runtime = getRuntime(this.host, "model");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         const ref = this.host.modelRef(model);
         this.host.setStatus(`selecting model ${ref}`);
         this.host.render();
         await runtime.session.setModel(model);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         this.host.addEntry({ id: createId("system"), kind: "system", text: `Selected model ${ref}` });
         if (runtime.session.isStreaming) {
             this.host.addEntry({
@@ -279,7 +307,9 @@ export class ModelCommandActions {
             this.host.setSessionStatus(runtime.session);
             return;
         }
-        await this.reloadAfterModelChange(runtime.session, ref);
+        await this.reloadAfterModelChange(runtime.session, ref, scope);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         this.host.setSessionStatus(runtime.session);
     }
     async runThinkingCommand(level) {
@@ -296,11 +326,13 @@ export class ModelCommandActions {
         appendPixSystemDisplayEntry(session, text);
         this.host.addEntry({ id: createId("system"), kind: "system", text });
     }
-    async reloadAfterModelChange(session, ref) {
+    async reloadAfterModelChange(session, ref, scope) {
         this.host.setStatus(`reloading resources for ${ref}`);
         this.host.render();
         try {
             await session.reload();
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             this.host.addEntry({
                 id: createId("system"),
                 kind: "system",
@@ -309,6 +341,8 @@ export class ModelCommandActions {
             this.host.toast.success("Model changed and resources reloaded");
         }
         catch (error) {
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             this.host.addEntry({
                 id: createId("error"),
                 kind: "error",

package/dist/app/commands/command-navigation-actions.d.ts

@@ -1,5 +1,5 @@
 import type { SessionInfo } from "@earendil-works/pi-coding-agent";
-import type { CommandControllerHost } from "./command-host.js";
+import { type CommandControllerHost } from "./command-host.js";
 import { type ResumeSessionLoaderOptions } from "../session/resume-session-loader.js";
 import type { PopupMenuPlacement } from "../types.js";
 export declare function formatHistoryMenuLabel(text: string): string;

package/dist/app/commands/command-navigation-actions.js

@@ -1,4 +1,5 @@
 import { resolve } from "node:path";
+import { captureCommandScope, isCommandRuntimeActive, isCommandScopeActive, } from "./command-host.js";
 import { getIdleRuntime, getRuntime } from "./command-runtime.js";
 import { createId } from "../id.js";
 import { isRecord } from "../guards.js";
@@ -51,7 +52,11 @@ export class NavigationCommandActions {
         this.host.setStatus("forking session");
         this.host.render();
         await this.host.awaitCurrentSessionExtensions(runtime);
+        if (!isCommandRuntimeActive(this.host, runtime))
+            return;
         const result = await runtime.fork(entryId);
+        if (!isCommandRuntimeActive(this.host, runtime))
+            return;
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Fork cancelled." });
             this.host.setSessionStatus(runtime.session);
@@ -76,7 +81,11 @@ export class NavigationCommandActions {
         this.host.setStatus("cloning session");
         this.host.render();
         await this.host.awaitCurrentSessionExtensions(runtime);
+        if (!isCommandRuntimeActive(this.host, runtime))
+            return;
         const result = await runtime.fork(leafId, { position: "at" });
+        if (!isCommandRuntimeActive(this.host, runtime))
+            return;
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Clone cancelled." });
             this.host.setSessionStatus(runtime.session);
@@ -96,7 +105,10 @@ export class NavigationCommandActions {
         }
         this.host.setStatus("navigating tree");
         this.host.render();
+        const scope = captureCommandScope(this.host);
         const result = await runtime.session.navigateTree(targetId);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         if (result.aborted) {
             this.host.toast.info("Tree navigation cancelled");
             this.host.setSessionStatus(runtime.session);
@@ -118,6 +130,7 @@ export class NavigationCommandActions {
         const runtime = getRuntime(this.host, "jump");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         this.host.openDirectPopupMenu("user-message-jump", { preserveStatus: true });
         this.host.setDirectPopupMenuQuery(argumentsText.trim());
         this.host.render();
@@ -125,13 +138,17 @@ export class NavigationCommandActions {
             await this.host.refreshUserMessageJumpMenuItems();
         }
         catch (error) {
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             this.host.toast.error(`Could not load jump messages: ${error instanceof Error ? error.message : String(error)}`);
         }
         finally {
-            this.host.render();
+            if (isCommandScopeActive(this.host, scope))
+                this.host.render();
         }
     }
     async runHistoryCommand(argumentsText) {
+        const scope = captureCommandScope(this.host);
         const query = argumentsText.trim();
         const matches = this.host.requestHistory().searchMatches(query, 100);
         if (matches.length === 0) {
@@ -157,6 +174,8 @@ export class NavigationCommandActions {
             minScorePerCharacter: 8,
             preferKeyboardLayoutMatches: true,
         });
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         if (!selected) {
             this.host.setSessionStatus(this.host.runtime()?.session);
             return;
@@ -170,6 +189,7 @@ export class NavigationCommandActions {
         const runtime = getIdleRuntime(this.host, "search");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         const query = argumentsText.trim();
         if (!query) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Usage: /search <text>" });
@@ -184,6 +204,8 @@ export class NavigationCommandActions {
             const results = await searchSessions(query, {
                 cwd: this.host.options.cwd,
                 onProgress: (loaded, total) => {
+                    if (!isCommandScopeActive(this.host, scope))
+                        return;
                     const progressText = total > 0 ? `searching sessions… ${loaded}/${total}` : "searching sessions…";
                     if (progressText === lastProgressText)
                         return;
@@ -192,6 +214,8 @@ export class NavigationCommandActions {
                     this.host.render();
                 },
             });
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             if (results.length === 0) {
                 this.host.addEntry({ id: createId("system"), kind: "system", text: `No sessions found for: ${query}` });
                 this.host.toast.info("No matching sessions");
@@ -205,6 +229,8 @@ export class NavigationCommandActions {
                 emptyText: "No matching search results",
                 searchable: true,
             });
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             if (!selected) {
                 this.host.setSessionStatus(runtime.session);
                 return;
@@ -212,6 +238,8 @@ export class NavigationCommandActions {
             await this.host.openSearchResultInNewTab(selected);
         }
         catch (error) {
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             this.host.addEntry({ id: createId("error"), kind: "error", text: `Session search failed: ${error instanceof Error ? error.message : String(error)}` });
             this.host.toast.error("Session search failed");
             this.host.setSessionStatus(runtime.session);
@@ -231,7 +259,11 @@ export class NavigationCommandActions {
         this.host.setStatus("switching session");
         this.host.render();
         await this.host.awaitCurrentSessionExtensions(runtime);
+        if (!isCommandRuntimeActive(this.host, runtime))
+            return;
         const result = await runtime.switchSession(resolvedSessionPath);
+        if (!isCommandRuntimeActive(this.host, runtime))
+            return;
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Resume cancelled." });
             this.host.setSessionStatus(runtime.session);
@@ -275,28 +307,30 @@ export class NavigationCommandActions {
         }
         this.host.render();
         const loadId = ++this.resumeLoadId;
-        void this.loadResumeSessionsInBackground({ loadId, preserveStatus, session: runtime.session });
+        void this.loadResumeSessionsInBackground({ loadId, preserveStatus, scope: captureCommandScope(this.host) });
     }
     async loadResumeSessionsInBackground(options) {
         try {
             await nextTick();
+            if (!isCommandScopeActive(this.host, options.scope))
+                return;
             await this.resumeSessionLoader({
                 cwd: this.host.options.cwd,
                 onChunk: (sessions, progress) => {
-                    if (options.loadId !== this.resumeLoadId)
+                    if (options.loadId !== this.resumeLoadId || !isCommandScopeActive(this.host, options.scope))
                         return;
                     this.host.setResumeSessions([...sessions]);
                     if (progress.done) {
                         this.host.setResumeLoading(false);
                         if (!options.preserveStatus)
-                            this.host.setSessionStatus(options.session);
+                            this.host.setSessionStatus(options.scope.session);
                     }
                     this.host.render();
                 },
             });
         }
         catch (error) {
-            if (options.loadId !== this.resumeLoadId)
+            if (options.loadId !== this.resumeLoadId || !isCommandScopeActive(this.host, options.scope))
                 return;
             this.host.setResumeLoading(false);
             this.host.setDirectPopupMenu(undefined);
@@ -307,7 +341,7 @@ export class NavigationCommandActions {
             if (!options.preserveStatus)
                 this.host.toast.error("Failed to load sessions");
             if (!options.preserveStatus)
-                this.host.setSessionStatus(options.session);
+                this.host.setSessionStatus(options.scope.session);
             this.host.render();
         }
     }

package/dist/app/commands/command-session-actions.d.ts

@@ -1,4 +1,4 @@
-import type { CommandControllerHost } from "./command-host.js";
+import { type CommandControllerHost } from "./command-host.js";
 export declare class SessionCommandActions {
     private readonly host;
     constructor(host: CommandControllerHost);