pi-ui-extend 0.1.70 → 0.1.72

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

@@ -1,4 +1,4 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { mkdir, open as openFile, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, resolve } from "node:path";
@@ -13,6 +13,7 @@ const BACKGROUND_PREWARM_TAB_LIMIT = 2;
 const TAB_ATTENTION_BLINK_KEY = "tab-attention";
 const LOADING_TAB_TITLE_PATTERN = /^loading(?:…|\.\.\.)?$/iu;
 const DEFAULT_SESSION_TITLE_PATTERN = /^(?:session )?[0-9a-f]{8}$/iu;
+const SESSION_HEADER_SCAN_MAX_BYTES = 64 * 1024;
 const SESSION_TITLE_HEAD_SCAN_MAX_BYTES = 256 * 1024;
 const SESSION_TITLE_SCAN_MAX_BYTES = 2 * 1024 * 1024;
 export class AppTabsController {
@@ -29,9 +30,18 @@ export class AppTabsController {
     sessionViewsByTabId = new Map();
     scrollStatesByTabId = new Map();
     tabIdsNeedingHistoryReload = new Set();
+    historyInvalidationGenerationByTabId = new Map();
+    runtimeOwnershipGenerationByTabId = new Map();
+    orphanRuntimeDisposals = new WeakSet();
+    lifecycleMutationQueue = [];
     activeTabId;
     pendingActiveTabId;
     historyLoadGeneration = 0;
+    historyInvalidationGeneration = 0;
+    runtimeOwnershipGeneration = 0;
+    lifecycleGeneration = 0;
+    lifecycleMutationRunning = false;
+    saveTabsWriteTail = Promise.resolve();
     restored = false;
     retentionCleanupRunning = false;
     retentionCleanupScheduled = false;
@@ -40,6 +50,48 @@ export class AppTabsController {
     constructor(host) {
         this.host = host;
     }
+    runLifecycleMutation(operation) {
+        return new Promise((resolveOperation, rejectOperation) => {
+            const run = () => {
+                if (!this.host.isRunning()) {
+                    resolveOperation(undefined);
+                    const next = this.lifecycleMutationQueue.shift();
+                    if (next)
+                        queueMicrotask(next);
+                    return;
+                }
+                this.lifecycleMutationRunning = true;
+                const generation = ++this.lifecycleGeneration;
+                let result;
+                try {
+                    result = operation(generation);
+                }
+                catch (error) {
+                    result = Promise.reject(error);
+                }
+                void result.then(resolveOperation, rejectOperation).finally(() => {
+                    this.lifecycleMutationRunning = false;
+                    this.lifecycleMutationQueue.shift()?.();
+                });
+            };
+            if (this.lifecycleMutationRunning)
+                this.lifecycleMutationQueue.push(run);
+            else
+                run();
+        });
+    }
+    isLifecycleOwner(generation, runtime, session) {
+        return this.host.isRunning()
+            && generation === this.lifecycleGeneration
+            && this.host.runtime() === runtime
+            && runtime.session === session;
+    }
+    cancelPendingLifecycleWork() {
+        this.lifecycleGeneration += 1;
+        this.cancelHistoryLoad();
+        this.pendingActiveTabId = undefined;
+        this.clearRuntimeSubscriptions();
+    }
     tabs() {
         if (!this.pendingActiveTabId)
             this.syncActiveTabFromRuntime({ save: false });
@@ -122,6 +174,24 @@ export class AppTabsController {
         this.storeActiveDeferredUserMessages();
         void this.saveTabs();
     }
+    requeueAutoUserMessageForSession(session, message) {
+        if (this.host.runtime()?.session === session)
+            return;
+        const tab = this.findTabForSession(session);
+        if (!tab)
+            return;
+        const messages = this.autoUserMessagesByTabId.get(tab.id) ?? [];
+        messages.unshift(cloneSubmittedUserMessage(message));
+        this.autoUserMessagesByTabId.set(tab.id, messages);
+        void this.saveTabs();
+    }
+    inputTabOwnedByRuntime(tabId, runtime, session) {
+        if (runtime.session !== session)
+            return false;
+        if (tabId === undefined)
+            return this.host.runtime() === runtime;
+        return this.runtimesByTabId.get(tabId) === runtime;
+    }
     syncActiveTabFromRuntime(options = {}) {
         if (this.pendingActiveTabId && options.force !== true)
             return;
@@ -163,19 +233,27 @@ export class AppTabsController {
         if (options.save !== false)
             void this.saveTabs();
     }
-    async restoreAfterStartup() {
+    restoreAfterStartup() {
+        return this.runLifecycleMutation((generation) => this.restoreAfterStartupMutation(generation));
+    }
+    async restoreAfterStartupMutation(generation) {
         if (this.restored)
             return;
         this.restored = true;
         const runtime = this.host.runtime();
         if (!runtime)
             return;
+        const startupSession = runtime.session;
         this.syncActiveTabFromRuntime({ save: false });
         if (this.host.options.noSession) {
             this.clearStartupTabPlaceholders();
             return;
         }
         const saved = await this.loadTabs();
+        if (!this.isLifecycleOwner(generation, runtime, startupSession)) {
+            this.syncActiveTabFromRuntime({ save: false, force: true });
+            return;
+        }
         if (!saved || saved.tabs.length === 0) {
             this.clearStartupTabPlaceholders();
             await this.saveTabs();
@@ -183,6 +261,10 @@ export class AppTabsController {
         }
         const restoredSessionPaths = saved.tabs.map((tab) => tab.path);
         const forkedSessionPaths = await this.loadForkedSessionPaths(restoredSessionPaths);
+        if (!this.isLifecycleOwner(generation, runtime, startupSession)) {
+            this.syncActiveTabFromRuntime({ save: false, force: true });
+            return;
+        }
         const restoredTabs = this.restoredTabs(saved, new Map(), forkedSessionPaths);
         if (restoredTabs.length === 0) {
             this.clearStartupTabPlaceholders();
@@ -190,7 +272,7 @@ export class AppTabsController {
             this.scheduleProjectSessionRetention();
             return;
         }
-        const currentPath = runtime.session.sessionFile ? resolve(runtime.session.sessionFile) : undefined;
+        const currentPath = startupSession.sessionFile ? resolve(startupSession.sessionFile) : undefined;
         const explicitSessionPath = this.host.options.sessionPath ? resolve(this.host.options.sessionPath) : undefined;
         const savedActivePath = saved.activePath ? resolve(saved.activePath) : undefined;
         const desiredPath = explicitSessionPath && currentPath
@@ -202,11 +284,11 @@ export class AppTabsController {
         this.restorePersistedInputStates(saved);
         this.restorePersistedQueuedUserMessages(saved);
         if (explicitSessionPath && currentPath)
-            this.ensureCurrentSessionTab(runtime.session);
+            this.ensureCurrentSessionTab(startupSession);
         if (!desiredPath) {
             this.clearStartupTabPlaceholders();
             await this.saveTabs();
-            this.scheduleRestoredTabTitleRefresh(restoredSessionPaths);
+            this.scheduleRestoredTabTitleRefresh(restoredSessionPaths, generation);
             this.scheduleProjectSessionRetention();
             this.scheduleTabPrewarm();
             return;
@@ -215,22 +297,51 @@ export class AppTabsController {
         if (currentPath !== desiredPath) {
             this.host.setStatus("restoring tabs");
             this.host.render();
+            let candidateRuntime;
             try {
-                restoredRuntime = await this.host.createRuntimeForSession(desiredPath);
-                await this.host.activateRuntime(restoredRuntime, { awaitExtensions: false });
+                candidateRuntime = await this.host.createRuntimeForSession(desiredPath);
+                if (!this.isLifecycleOwner(generation, runtime, startupSession)) {
+                    await this.disposeRuntimeIfOrphan(candidateRuntime);
+                    this.syncActiveTabFromRuntime({ save: false, force: true });
+                    return;
+                }
+                const candidateSession = candidateRuntime.session;
+                await this.host.activateRuntime(candidateRuntime, { awaitExtensions: false });
+                if (this.host.runtime() !== candidateRuntime || candidateRuntime.session !== candidateSession) {
+                    await this.disposeRuntimeIfOrphan(candidateRuntime);
+                    this.syncActiveTabFromRuntime({ save: false, force: true });
+                    return;
+                }
+                restoredRuntime = candidateRuntime;
             }
             catch {
+                if (candidateRuntime && this.host.runtime() === candidateRuntime) {
+                    try {
+                        await this.host.activateRuntime(runtime, { awaitExtensions: false });
+                    }
+                    catch {
+                        // Keep the best available runtime below and avoid overwriting a newer owner.
+                    }
+                }
+                if (candidateRuntime)
+                    await this.disposeRuntimeIfOrphan(candidateRuntime);
+                if (this.host.runtime() !== runtime || runtime.session !== startupSession) {
+                    this.syncActiveTabFromRuntime({ save: false, force: true });
+                    return;
+                }
                 this.host.showToast("Could not restore the previous active tab", "warning");
-                this.replaceTabs([this.tabFromSession(runtime.session), ...restoredTabs], currentPath);
+                this.replaceTabs([this.tabFromSession(startupSession), ...restoredTabs], currentPath);
                 this.storeActiveRuntime(runtime);
                 this.clearStartupTabPlaceholders();
                 await this.saveTabs();
-                this.scheduleRestoredTabTitleRefresh(restoredSessionPaths);
+                this.scheduleRestoredTabTitleRefresh(restoredSessionPaths, generation);
                 this.scheduleProjectSessionRetention();
                 return;
             }
         }
         this.syncActiveTabFromRuntime({ save: false });
+        if (restoredRuntime !== runtime)
+            await this.disposeRuntimeIfOrphan(runtime);
         this.clearStartupTabPlaceholders();
         if (this.activeTabId)
             this.restoreInputState(this.activeTabId);
@@ -238,10 +349,13 @@ export class AppTabsController {
         await this.saveTabs();
         this.scheduleProjectSessionRetention();
         this.scheduleTabPrewarm();
-        await this.loadActiveSessionHistory(restoredRuntime);
-        this.scheduleRestoredTabTitleRefresh(restoredSessionPaths);
+        await this.loadActiveSessionHistory(restoredRuntime, generation);
+        this.scheduleRestoredTabTitleRefresh(restoredSessionPaths, generation);
+    }
+    openNewTab() {
+        return this.runLifecycleMutation((generation) => this.openNewTabMutation(generation));
     }
-    async openNewTab() {
+    async openNewTabMutation(generation) {
         if (this.pendingActiveTabId) {
             this.host.showToast("Wait for the tab to finish loading", "info");
             return;
@@ -258,6 +372,7 @@ export class AppTabsController {
         this.storeActiveDeferredUserMessages();
         const previousTabId = this.activeTabId;
         const previousRuntime = runtime;
+        const previousSession = runtime.session;
         const tab = {
             id: createId("tab"),
             title: "new",
@@ -297,6 +412,15 @@ export class AppTabsController {
             this.host.render();
             throw error;
         }
+        if (!this.isLifecycleOwner(generation, previousRuntime, previousSession)) {
+            if (this.pendingActiveTabId === tab.id)
+                this.pendingActiveTabId = undefined;
+            this.removeTab(tab.id);
+            this.activeTabId = previousTabId;
+            await this.disposeRuntimeIfOrphan(newRuntime);
+            this.syncActiveTabFromRuntime({ save: false, force: true });
+            return;
+        }
         const existingTab = this.findTabForSession(newRuntime.session);
         const targetTab = existingTab && existingTab.id !== tab.id ? existingTab : tab;
         if (targetTab !== tab)
@@ -305,7 +429,6 @@ export class AppTabsController {
         this.pendingActiveTabId = targetTab.id;
         this.clearTabAttention(targetTab);
         this.updateTabFromSession(targetTab, newRuntime.session);
-        this.setRuntimeForTab(targetTab.id, newRuntime);
         this.restoreInputState(targetTab.id);
         this.host.resetSessionView();
         this.restoreDeferredUserMessages(targetTab.id);
@@ -314,10 +437,42 @@ export class AppTabsController {
         try {
             await this.host.activateRuntime(newRuntime, { awaitExtensions: false });
         }
-        finally {
+        catch (error) {
             if (this.pendingActiveTabId === targetTab.id)
                 this.pendingActiveTabId = undefined;
+            if (targetTab === tab)
+                this.removeTab(tab.id);
+            this.activeTabId = previousTabId;
+            if (this.host.runtime() !== previousRuntime) {
+                try {
+                    await this.host.activateRuntime(previousRuntime, { awaitExtensions: false });
+                }
+                catch {
+                    // Keep the best available runtime and preserve the original activation error.
+                }
+            }
+            await this.disposeRuntimeIfOrphan(newRuntime);
+            if (this.adoptCurrentRuntimeAfterFailedRollback(targetTab, newRuntime)) {
+                this.host.setSessionStatus(newRuntime.session);
+                this.host.setSessionActivity(this.sessionActivity(newRuntime.session));
+                this.host.render();
+                throw error;
+            }
+            if (previousTabId)
+                this.restoreInputState(previousTabId);
+            this.host.closeMenusForTabSwitch?.();
+            this.host.resetSessionView();
+            if (previousTabId)
+                this.restoreDeferredUserMessages(previousTabId);
+            this.host.loadSessionHistory();
+            this.host.setSessionStatus(this.host.runtime()?.session);
+            this.host.setSessionActivity(this.sessionActivity(this.host.runtime()?.session));
+            this.host.render();
+            throw error;
         }
+        if (this.pendingActiveTabId === targetTab.id)
+            this.pendingActiveTabId = undefined;
+        this.setRuntimeForTab(targetTab.id, newRuntime);
         void this.saveTabs();
         this.scheduleProjectSessionRetention();
         this.host.resetSessionView();
@@ -333,7 +488,10 @@ export class AppTabsController {
         this.host.setSessionActivity(this.sessionActivity(newRuntime.session));
         this.host.render();
     }
-    async openSessionInNewTab(sessionPath) {
+    openSessionInNewTab(sessionPath) {
+        return this.runLifecycleMutation((generation) => this.openSessionInNewTabMutation(sessionPath, generation));
+    }
+    async openSessionInNewTabMutation(sessionPath, generation) {
         if (this.pendingActiveTabId) {
             this.host.showToast("Wait for the tab to finish loading", "info");
             return false;
@@ -349,7 +507,7 @@ export class AppTabsController {
         const resolvedSessionPath = resolve(runtime.cwd, sessionPath);
         const existingTab = this.findTabBySessionPath(resolvedSessionPath);
         if (existingTab) {
-            await this.switchToTab(existingTab.id);
+            await this.switchToTabMutation(existingTab.id, generation);
             return true;
         }
         this.cancelHistoryLoad();
@@ -358,6 +516,7 @@ export class AppTabsController {
         this.storeActiveDeferredUserMessages();
         const previousTabId = this.activeTabId;
         const previousRuntime = runtime;
+        const previousSession = runtime.session;
         this.host.setStatus("opening session tab");
         this.host.render();
         const tab = {
@@ -399,8 +558,16 @@ export class AppTabsController {
             this.host.render();
             return false;
         }
+        if (!this.isLifecycleOwner(generation, previousRuntime, previousSession)) {
+            if (this.pendingActiveTabId === tab.id)
+                this.pendingActiveTabId = undefined;
+            this.removeTab(tab.id);
+            this.activeTabId = previousTabId;
+            await this.disposeRuntimeIfOrphan(newRuntime);
+            this.syncActiveTabFromRuntime({ save: false, force: true });
+            return false;
+        }
         this.updateTabFromSession(tab, newRuntime.session);
-        this.setRuntimeForTab(tab.id, newRuntime);
         this.host.render();
         try {
             await this.host.activateRuntime(newRuntime, { awaitExtensions: false });
@@ -420,7 +587,14 @@ export class AppTabsController {
                     // Keep the best available runtime below and surface the switch failure.
                 }
             }
-            void this.host.disposeRuntime(newRuntime);
+            await this.disposeRuntimeIfOrphan(newRuntime);
+            if (this.adoptCurrentRuntimeAfterFailedRollback(tab, newRuntime)) {
+                this.host.showToast("Could not initialize session tab", "warning");
+                this.host.setSessionStatus(newRuntime.session);
+                this.host.setSessionActivity(this.sessionActivity(newRuntime.session));
+                this.host.render();
+                return false;
+            }
             this.host.showToast("Could not open session tab", "warning");
             this.host.resetSessionView();
             if (previousTabId)
@@ -440,10 +614,13 @@ export class AppTabsController {
         this.restoreInputState(tab.id);
         void this.saveTabs();
         this.scheduleTabPrewarm();
-        await this.loadActiveSessionHistory(newRuntime);
+        await this.loadActiveSessionHistory(newRuntime, generation);
         return true;
     }
-    async forkSessionEntryInNewTab(entryId) {
+    forkSessionEntryInNewTab(entryId) {
+        return this.runLifecycleMutation((generation) => this.forkSessionEntryInNewTabMutation(entryId, generation));
+    }
+    async forkSessionEntryInNewTabMutation(entryId, generation) {
         if (this.pendingActiveTabId) {
             this.host.showToast("Wait for the tab to finish loading", "info");
             return false;
@@ -467,6 +644,7 @@ export class AppTabsController {
         this.storeActiveDeferredUserMessages();
         const previousTabId = this.activeTabId;
         const previousRuntime = runtime;
+        const previousSession = runtime.session;
         this.host.setStatus("forking session tab");
         this.host.render();
         let forkRuntime;
@@ -484,22 +662,28 @@ export class AppTabsController {
             result = await forkRuntime.fork(entryId);
         }
         catch (error) {
-            void this.host.disposeRuntime(forkRuntime);
+            await this.disposeRuntimeIfOrphan(forkRuntime);
             throw error;
         }
         if (result.cancelled) {
-            void this.host.disposeRuntime(forkRuntime);
+            await this.disposeRuntimeIfOrphan(forkRuntime);
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Fork cancelled." });
             this.host.setSessionStatus(previousRuntime.session);
             this.host.render();
             return false;
         }
+        if (generation !== this.lifecycleGeneration
+            || this.host.runtime() !== previousRuntime
+            || (forkRuntime !== previousRuntime && previousRuntime.session !== previousSession)) {
+            await this.disposeRuntimeIfOrphan(forkRuntime);
+            return false;
+        }
         const existingTab = this.findTabForSession(forkRuntime.session);
         if (existingTab) {
             if (result.selectedText)
                 this.inputStatesByTabId.set(existingTab.id, this.inputStateFromText(result.selectedText));
-            void this.host.disposeRuntime(forkRuntime);
-            await this.switchToTab(existingTab.id);
+            await this.disposeRuntimeIfOrphan(forkRuntime);
+            await this.switchToTabMutation(existingTab.id, generation);
             this.host.showToast("Fork opened in existing tab", "success");
             return true;
         }
@@ -509,7 +693,6 @@ export class AppTabsController {
         this.pendingActiveTabId = tab.id;
         this.clearTabAttention(tab);
         this.updateTabFromSession(tab, forkRuntime.session);
-        this.setRuntimeForTab(tab.id, forkRuntime);
         if (result.selectedText)
             this.inputStatesByTabId.set(tab.id, this.inputStateFromText(result.selectedText));
         this.restoreInputState(tab.id);
@@ -536,7 +719,14 @@ export class AppTabsController {
                     // Keep the best available runtime below and surface the switch failure.
                 }
             }
-            void this.host.disposeRuntime(forkRuntime);
+            await this.disposeRuntimeIfOrphan(forkRuntime);
+            if (this.adoptCurrentRuntimeAfterFailedRollback(tab, forkRuntime)) {
+                this.host.showToast("Could not initialize fork tab", "warning");
+                this.host.setSessionStatus(forkRuntime.session);
+                this.host.setSessionActivity(this.sessionActivity(forkRuntime.session));
+                this.host.render();
+                return false;
+            }
             this.host.showToast("Could not open fork tab", "warning");
             this.host.resetSessionView();
             if (previousTabId)
@@ -556,14 +746,17 @@ export class AppTabsController {
         void this.saveTabs();
         this.scheduleProjectSessionRetention();
         this.scheduleTabPrewarm();
-        await this.loadActiveSessionHistory(forkRuntime);
+        await this.loadActiveSessionHistory(forkRuntime, generation);
         this.host.addEntry({ id: createId("system"), kind: "system", text: `Forked from entry ${entryId} in a new tab.` });
         this.host.setSessionStatus(forkRuntime.session);
         this.host.showToast("Fork opened in new tab", "success");
         this.host.render();
         return true;
     }
-    async switchToTab(tabId) {
+    switchToTab(tabId) {
+        return this.runLifecycleMutation((generation) => this.switchToTabMutation(tabId, generation));
+    }
+    async switchToTabMutation(tabId, generation) {
         if (this.pendingActiveTabId) {
             this.host.showToast("Wait for the tab to finish loading", "info");
             return;
@@ -584,6 +777,7 @@ export class AppTabsController {
         this.cancelHistoryLoad();
         const previousTabId = this.activeTabId;
         const previousRuntime = runtime;
+        const previousSession = runtime.session;
         const previousTargetActivity = target.activity;
         this.storeActiveRuntime(runtime);
         this.storeActiveSessionView();
@@ -603,6 +797,9 @@ export class AppTabsController {
             targetRuntime = await this.runtimeForTab(target);
             if (!targetRuntime)
                 throw new Error("Could not load tab runtime");
+            if (!this.isLifecycleOwner(generation, previousRuntime, previousSession)) {
+                throw new Error("Tab ownership changed while loading the runtime");
+            }
             await this.host.activateRuntime(targetRuntime, { awaitExtensions: false });
         }
         catch {
@@ -652,12 +849,19 @@ export class AppTabsController {
             this.host.render();
         }
         else {
-            await this.loadActiveSessionHistory(targetRuntime);
-            this.tabIdsNeedingHistoryReload.delete(target.id);
+            const invalidationGeneration = this.historyInvalidationGenerationByTabId.get(target.id);
+            const loaded = await this.loadActiveSessionHistory(targetRuntime, generation);
+            if (loaded && this.historyInvalidationGenerationByTabId.get(target.id) === invalidationGeneration) {
+                this.tabIdsNeedingHistoryReload.delete(target.id);
+                this.historyInvalidationGenerationByTabId.delete(target.id);
+            }
         }
-        this.scheduleDelayedHistoryReload(target.id, targetRuntime);
+        this.scheduleDelayedHistoryReload(target.id, targetRuntime, generation);
+    }
+    closeTab(tabId) {
+        return this.runLifecycleMutation((generation) => this.closeTabMutation(tabId, generation));
     }
-    async closeTab(tabId) {
+    async closeTabMutation(tabId, generation) {
         if (this.pendingActiveTabId) {
             this.host.showToast("Wait for the tab to finish loading", "info");
             return;
@@ -667,7 +871,7 @@ export class AppTabsController {
             return;
         this.cancelHistoryLoad();
         if (this.tabItems.length <= 1) {
-            await this.replaceLastTabWithNewSession(tabId);
+            await this.replaceLastTabWithNewSession(tabId, generation);
             return;
         }
         if (tabId !== this.activeTabId) {
@@ -685,7 +889,7 @@ export class AppTabsController {
             this.storeActiveDeferredUserMessages();
             this.stopAttentionBlinkIfIdle();
             if (tabRuntime)
-                void this.host.disposeRuntime(tabRuntime);
+                await this.disposeRuntimeIfOrphan(tabRuntime);
             void this.saveTabs();
             this.host.render();
             return;
@@ -700,10 +904,41 @@ export class AppTabsController {
         }
         this.host.setStatus("closing tab");
         this.host.render();
+        const session = runtime.session;
         const nextRuntime = await this.runtimeForTab(nextTab);
         if (!nextRuntime)
             return;
-        await this.host.activateRuntime(nextRuntime, { awaitExtensions: false });
+        if (!this.isLifecycleOwner(generation, runtime, session))
+            return;
+        this.pendingActiveTabId = nextTab.id;
+        try {
+            await this.host.activateRuntime(nextRuntime, { awaitExtensions: false });
+        }
+        catch {
+            if (this.pendingActiveTabId === nextTab.id)
+                this.pendingActiveTabId = undefined;
+            if (this.host.runtime() !== runtime) {
+                try {
+                    await this.host.activateRuntime(runtime, { awaitExtensions: false });
+                }
+                catch {
+                    // Keep the best available runtime below and surface the close failure.
+                }
+            }
+            if (this.host.runtime() === nextRuntime) {
+                this.activeTabId = nextTab.id;
+                this.clearTabAttention(nextTab);
+                this.setRuntimeForTab(nextTab.id, nextRuntime);
+                this.restoreInputState(nextTab.id);
+            }
+            this.host.showToast("Could not close tab", "warning");
+            this.host.setSessionStatus(this.host.runtime()?.session);
+            this.host.setSessionActivity(this.sessionActivity(this.host.runtime()?.session));
+            this.host.render();
+            return;
+        }
+        if (this.pendingActiveTabId === nextTab.id)
+            this.pendingActiveTabId = undefined;
         this.tabItems.splice(index, 1);
         this.deleteRuntimeForTab(tabId);
         this.inputStatesByTabId.delete(tabId);
@@ -716,23 +951,34 @@ export class AppTabsController {
         this.setRuntimeForTab(nextTab.id, nextRuntime);
         this.restoreInputState(nextTab.id);
         this.host.closeMenusForTabSwitch?.();
-        void this.host.disposeRuntime(runtime);
+        await this.disposeRuntimeIfOrphan(runtime);
         void this.saveTabs();
         this.scheduleTabPrewarm();
-        await this.loadActiveSessionHistory(nextRuntime);
+        await this.loadActiveSessionHistory(nextRuntime, generation);
     }
-    async replaceLastTabWithNewSession(tabId) {
+    async replaceLastTabWithNewSession(tabId, generation) {
         const tab = this.tabItems.find((item) => item.id === tabId);
         if (!tab)
             return;
         const runtime = this.idleRuntime("new");
         if (!runtime)
             return;
+        const session = runtime.session;
         this.activeTabId = tab.id;
+        this.pendingActiveTabId = tab.id;
         this.host.setStatus("starting new session");
         this.host.render();
-        await this.host.awaitCurrentSessionExtensions?.(runtime);
-        const result = await runtime.newSession();
+        let result;
+        try {
+            await this.host.awaitCurrentSessionExtensions?.(runtime);
+            if (!this.isLifecycleOwner(generation, runtime, session))
+                return;
+            result = await runtime.newSession();
+        }
+        finally {
+            if (this.pendingActiveTabId === tab.id)
+                this.pendingActiveTabId = undefined;
+        }
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "New session cancelled." });
             this.host.setSessionStatus(runtime.session);
@@ -764,12 +1010,25 @@ export class AppTabsController {
         this.scheduleProjectSessionRetention();
         this.host.render();
     }
-    async loadActiveSessionHistory(runtime) {
-        const generation = ++this.historyLoadGeneration;
-        const isCancelled = () => generation !== this.historyLoadGeneration || this.host.runtime() !== runtime;
+    async loadActiveSessionHistory(runtime, lifecycleGeneration) {
+        const tabId = this.activeTabId;
+        if (!tabId)
+            return false;
+        const session = runtime.session;
+        const ownershipGeneration = this.runtimeOwnershipGenerationByTabId.get(tabId);
+        const historyGeneration = ++this.historyLoadGeneration;
+        const isCancelled = () => ownershipGeneration === undefined
+            || !this.host.isRunning()
+            || historyGeneration !== this.historyLoadGeneration
+            || lifecycleGeneration !== this.lifecycleGeneration
+            || this.pendingActiveTabId !== undefined
+            || this.activeTabId !== tabId
+            || this.host.runtime() !== runtime
+            || !this.isRuntimeOwnedByTab(tabId, runtime, session, ownershipGeneration);
+        if (isCancelled())
+            return false;
         this.host.resetSessionView();
-        if (this.activeTabId)
-            this.restoreDeferredUserMessages(this.activeTabId);
+        this.restoreDeferredUserMessages(tabId);
         this.host.setStatus("loading session history");
         this.host.setSessionActivity("thinking");
         this.host.render();
@@ -782,12 +1041,15 @@ export class AppTabsController {
             lazyOlderHistory: true,
         });
         if (!completed || isCancelled())
-            return;
-        this.restoreStoredScrollState(this.activeTabId);
-        this.host.setSessionStatus(runtime.session);
+            return false;
+        this.restoreStoredScrollState(tabId);
+        this.host.setSessionStatus(session);
+        if (isCancelled())
+            return false;
         this.host.syncUserSessionEntryMetadata();
-        this.host.setSessionActivity(this.sessionActivity(runtime.session));
+        this.host.setSessionActivity(this.sessionActivity(session));
         this.host.render();
+        return true;
     }
     cancelHistoryLoad() {
         this.historyLoadGeneration += 1;
@@ -851,17 +1113,39 @@ export class AppTabsController {
         this.host.restoreScrollState(scrollState);
     }
     setRuntimeForTab(tabId, runtime) {
+        const session = runtime.session;
+        const existingRuntime = this.runtimesByTabId.get(tabId);
+        const existingSubscription = this.runtimeSubscriptionsByTabId.get(tabId);
+        if (existingRuntime === runtime && existingSubscription?.session === session)
+            return;
+        for (const [ownerTabId, ownedRuntime] of this.runtimesByTabId) {
+            if (ownerTabId === tabId || ownedRuntime !== runtime)
+                continue;
+            this.releaseRuntimeOwnership(ownerTabId);
+        }
+        if (existingRuntime && existingRuntime !== runtime)
+            this.queueOrphanRuntimeDisposal(existingRuntime);
+        this.clearRuntimeRefreshTimers(tabId);
+        this.clearHistoryReloadTimers(tabId);
+        existingSubscription?.unsubscribe();
+        this.runtimeSubscriptionsByTabId.delete(tabId);
         this.runtimesByTabId.set(tabId, runtime);
+        this.runtimeOwnershipGenerationByTabId.set(tabId, ++this.runtimeOwnershipGeneration);
         this.observeRuntimeForTab(tabId, runtime);
     }
     deleteRuntimeForTab(tabId) {
-        this.runtimesByTabId.delete(tabId);
+        this.releaseRuntimeOwnership(tabId);
         this.runtimeLoadsByTabId.delete(tabId);
         this.sessionViewsByTabId.delete(tabId);
         this.scrollStatesByTabId.delete(tabId);
+        this.tabIdsNeedingHistoryReload.delete(tabId);
+        this.historyInvalidationGenerationByTabId.delete(tabId);
+    }
+    releaseRuntimeOwnership(tabId) {
+        this.runtimesByTabId.delete(tabId);
+        this.runtimeOwnershipGenerationByTabId.delete(tabId);
         this.clearRuntimeRefreshTimers(tabId);
         this.clearHistoryReloadTimers(tabId);
-        this.tabIdsNeedingHistoryReload.delete(tabId);
         const subscription = this.runtimeSubscriptionsByTabId.get(tabId);
         subscription?.unsubscribe();
         this.runtimeSubscriptionsByTabId.delete(tabId);
@@ -877,24 +1161,64 @@ export class AppTabsController {
             subscription.unsubscribe();
         }
         this.runtimeSubscriptionsByTabId.clear();
+        this.runtimeOwnershipGenerationByTabId.clear();
     }
     observeRuntimeForTab(tabId, runtime) {
         const existing = this.runtimeSubscriptionsByTabId.get(tabId);
         if (existing?.runtime === runtime && existing.session === runtime.session)
             return;
         existing?.unsubscribe();
-        const unsubscribe = runtime.session.subscribe((event) => {
+        const session = runtime.session;
+        const ownershipGeneration = this.runtimeOwnershipGenerationByTabId.get(tabId);
+        if (ownershipGeneration === undefined)
+            return;
+        const unsubscribe = session.subscribe((event) => {
+            if (!this.isRuntimeOwnedByTab(tabId, runtime, session, ownershipGeneration))
+                return;
             if (this.shouldInvalidateCachedViewForRuntimeEvent(event)) {
                 this.tabIdsNeedingHistoryReload.add(tabId);
+                this.historyInvalidationGenerationByTabId.set(tabId, ++this.historyInvalidationGeneration);
             }
             if (this.shouldScheduleDelayedSyncForRuntimeEvent(event)) {
-                this.scheduleDelayedRuntimeSync(tabId, runtime);
+                this.scheduleDelayedRuntimeSync(tabId, runtime, session, ownershipGeneration);
             }
             if (!this.shouldSyncTabFromRuntimeEvent(event))
                 return;
-            this.syncTabFromObservedRuntime(tabId, runtime);
+            this.syncTabFromObservedRuntime(tabId, runtime, session, ownershipGeneration);
         });
-        this.runtimeSubscriptionsByTabId.set(tabId, { runtime, session: runtime.session, unsubscribe });
+        this.runtimeSubscriptionsByTabId.set(tabId, { runtime, session, unsubscribe });
+    }
+    isRuntimeOwnedByTab(tabId, runtime, session, ownershipGeneration) {
+        return this.runtimesByTabId.get(tabId) === runtime
+            && runtime.session === session
+            && this.runtimeOwnershipGenerationByTabId.get(tabId) === ownershipGeneration;
+    }
+    queueOrphanRuntimeDisposal(runtime) {
+        if (this.orphanRuntimeDisposals.has(runtime))
+            return;
+        this.orphanRuntimeDisposals.add(runtime);
+        queueMicrotask(() => {
+            void this.disposeRuntimeIfOrphan(runtime).finally(() => {
+                this.orphanRuntimeDisposals.delete(runtime);
+            });
+        });
+    }
+    async disposeRuntimeIfOrphan(runtime) {
+        if (this.host.runtime() === runtime || [...this.runtimesByTabId.values()].includes(runtime))
+            return;
+        await this.host.disposeRuntime(runtime).catch(() => undefined);
+    }
+    adoptCurrentRuntimeAfterFailedRollback(tab, runtime) {
+        if (this.host.runtime() !== runtime)
+            return false;
+        if (!this.tabItems.some((item) => item.id === tab.id))
+            this.tabItems.push(tab);
+        this.activeTabId = tab.id;
+        this.clearTabAttention(tab);
+        this.updateTabFromSession(tab, runtime.session);
+        this.setRuntimeForTab(tab.id, runtime);
+        this.restoreInputState(tab.id);
+        return true;
     }
     shouldSyncTabFromRuntimeEvent(event) {
         return event.type === "session_info_changed"
@@ -922,12 +1246,12 @@ export class AppTabsController {
             || event.type === "turn_end"
             || event.type === "compaction_end";
     }
-    scheduleDelayedRuntimeSync(tabId, runtime) {
+    scheduleDelayedRuntimeSync(tabId, runtime, session, ownershipGeneration) {
         this.clearRuntimeRefreshTimers(tabId);
         for (const delayMs of [0, 100, 500, 1500, 3000]) {
             const timer = setTimeout(() => {
                 this.runtimeRefreshTimersByTabId.get(tabId)?.delete(timer);
-                this.syncTabFromObservedRuntime(tabId, runtime);
+                this.syncTabFromObservedRuntime(tabId, runtime, session, ownershipGeneration);
             }, delayMs);
             timer.unref?.();
             let timers = this.runtimeRefreshTimersByTabId.get(tabId);
@@ -954,12 +1278,16 @@ export class AppTabsController {
             clearTimeout(timer);
         this.historyReloadTimersByTabId.delete(tabId);
     }
-    scheduleDelayedHistoryReload(tabId, runtime) {
+    scheduleDelayedHistoryReload(tabId, runtime, lifecycleGeneration) {
         if (!this.tabIdsNeedingHistoryReload.has(tabId))
             return;
         if (tabId !== this.activeTabId || this.pendingActiveTabId !== undefined)
             return;
-        if (this.sessionActivity(runtime.session) === "running") {
+        const session = runtime.session;
+        const ownershipGeneration = this.runtimeOwnershipGenerationByTabId.get(tabId);
+        if (ownershipGeneration === undefined || !this.isRuntimeOwnedByTab(tabId, runtime, session, ownershipGeneration))
+            return;
+        if (this.sessionActivity(session) === "running") {
             this.clearHistoryReloadTimers(tabId);
             return;
         }
@@ -967,7 +1295,7 @@ export class AppTabsController {
         for (const delayMs of [150, 1000, 3000]) {
             const timer = setTimeout(() => {
                 this.historyReloadTimersByTabId.get(tabId)?.delete(timer);
-                void this.reloadActiveTabHistoryIfNeeded(tabId, runtime);
+                void this.reloadActiveTabHistoryIfNeeded(tabId, runtime, session, ownershipGeneration, lifecycleGeneration);
             }, delayMs);
             timer.unref?.();
             let timers = this.historyReloadTimersByTabId.get(tabId);
@@ -978,19 +1306,29 @@ export class AppTabsController {
             timers.add(timer);
         }
     }
-    async reloadActiveTabHistoryIfNeeded(tabId, runtime) {
+    async reloadActiveTabHistoryIfNeeded(tabId, runtime, session, ownershipGeneration, lifecycleGeneration) {
+        if (lifecycleGeneration !== this.lifecycleGeneration)
+            return;
         if (tabId !== this.activeTabId || this.pendingActiveTabId !== undefined || this.host.runtime() !== runtime)
             return;
+        if (!this.isRuntimeOwnedByTab(tabId, runtime, session, ownershipGeneration))
+            return;
         if (!this.tabIdsNeedingHistoryReload.has(tabId))
             return;
-        if (this.sessionActivity(runtime.session) === "running")
+        if (this.sessionActivity(session) === "running")
             return;
-        await this.loadActiveSessionHistory(runtime);
-        if (tabId === this.activeTabId && this.host.runtime() === runtime) {
+        const invalidationGeneration = this.historyInvalidationGenerationByTabId.get(tabId);
+        const loaded = await this.loadActiveSessionHistory(runtime, lifecycleGeneration);
+        if (loaded
+            && this.isRuntimeOwnedByTab(tabId, runtime, session, ownershipGeneration)
+            && this.historyInvalidationGenerationByTabId.get(tabId) === invalidationGeneration) {
             this.tabIdsNeedingHistoryReload.delete(tabId);
+            this.historyInvalidationGenerationByTabId.delete(tabId);
         }
     }
-    syncTabFromObservedRuntime(tabId, runtime) {
+    syncTabFromObservedRuntime(tabId, runtime, session, ownershipGeneration) {
+        if (!this.isRuntimeOwnedByTab(tabId, runtime, session, ownershipGeneration))
+            return;
         const tab = this.tabItems.find((item) => item.id === tabId);
         if (!tab) {
             this.deleteRuntimeForTab(tabId);
@@ -999,7 +1337,7 @@ export class AppTabsController {
         const previousTitle = tab.title;
         const previousActivity = tab.activity;
         const previousSessionPath = tab.sessionPath;
-        this.updateTabFromSession(tab, runtime.session);
+        this.updateTabFromSession(tab, session);
         if (tab.title === previousTitle && tab.activity === previousActivity && tab.sessionPath === previousSessionPath)
             return;
         if (tab.title !== previousTitle || tab.sessionPath !== previousSessionPath)
@@ -1046,9 +1384,15 @@ export class AppTabsController {
         this.host.restoreDeferredUserMessages?.(this.deferredUserMessagesByTabId.get(tabId) ?? []);
     }
     async runtimeForTab(tab) {
+        if (!this.host.isRunning())
+            return undefined;
         const existing = this.runtimesByTabId.get(tab.id);
-        if (existing)
+        if (existing && tab.sessionPath && this.sessionPath(existing.session) === resolve(tab.sessionPath))
             return existing;
+        if (existing) {
+            this.releaseRuntimeOwnership(tab.id);
+            await this.disposeRuntimeIfOrphan(existing);
+        }
         const loading = this.runtimeLoadsByTabId.get(tab.id);
         if (loading)
             return await loading;
@@ -1059,9 +1403,13 @@ export class AppTabsController {
         const expectedPath = resolve(tab.sessionPath);
         const pending = (async () => {
             const runtime = await this.host.createRuntimeForSession(expectedPath);
+            if (!this.host.isRunning()) {
+                await this.disposeRuntimeIfOrphan(runtime);
+                return undefined;
+            }
             const liveTab = this.tabItems.find((item) => item.id === tab.id);
             if (!liveTab || !liveTab.sessionPath || resolve(liveTab.sessionPath) !== expectedPath) {
-                void this.host.disposeRuntime(runtime);
+                await this.disposeRuntimeIfOrphan(runtime);
                 return undefined;
             }
             this.setRuntimeForTab(tab.id, runtime);
@@ -1087,14 +1435,18 @@ export class AppTabsController {
             && resolve(tab.sessionPath) === normalizedPath));
     }
     replaceTabs(tabs, activeSessionPath) {
+        const displacedRuntimes = [...new Set(this.runtimesByTabId.values())];
         this.tabItems.length = 0;
         this.runtimesByTabId.clear();
+        this.runtimeLoadsByTabId.clear();
         this.clearRuntimeSubscriptions();
         this.inputStatesByTabId.clear();
         this.autoUserMessagesByTabId.clear();
         this.deferredUserMessagesByTabId.clear();
         this.sessionViewsByTabId.clear();
         this.scrollStatesByTabId.clear();
+        this.tabIdsNeedingHistoryReload.clear();
+        this.historyInvalidationGenerationByTabId.clear();
         const seen = new Set();
         for (const tab of tabs) {
             const sessionPath = tab.sessionPath ? resolve(tab.sessionPath) : undefined;
@@ -1117,6 +1469,8 @@ export class AppTabsController {
             ? this.tabItems.find((tab) => tab.sessionPath === activePath)?.id
             : this.tabItems[0]?.id;
         this.activeTabId ??= this.tabItems[0]?.id;
+        for (const runtime of displacedRuntimes)
+            this.queueOrphanRuntimeDisposal(runtime);
     }
     removeTab(tabId) {
         const index = this.tabItems.findIndex((tab) => tab.id === tabId);
@@ -1322,18 +1676,20 @@ export class AppTabsController {
         }));
         return new Set(entries.filter((entry) => entry !== undefined));
     }
-    scheduleRestoredTabTitleRefresh(sessionPaths) {
+    scheduleRestoredTabTitleRefresh(sessionPaths, lifecycleGeneration) {
         if (sessionPaths.length === 0)
             return;
         setTimeout(() => {
-            void this.refreshRestoredTabTitles(sessionPaths);
+            void this.refreshRestoredTabTitles(sessionPaths, lifecycleGeneration);
         }, 0).unref?.();
     }
-    async refreshRestoredTabTitles(sessionPaths) {
+    async refreshRestoredTabTitles(sessionPaths, lifecycleGeneration) {
         const [titles, forkedSessionPaths] = await Promise.all([
             this.loadSessionTitles(sessionPaths),
             this.loadForkedSessionPaths(sessionPaths),
         ]);
+        if (!this.host.isRunning() || lifecycleGeneration !== this.lifecycleGeneration)
+            return;
         if (titles.size === 0 && forkedSessionPaths.size === 0)
             return;
         let changed = false;
@@ -1439,9 +1795,9 @@ export class AppTabsController {
         }
         return messages;
     }
-    async saveTabs() {
+    saveTabs() {
         if (this.host.options.noSession)
-            return;
+            return Promise.resolve();
         try {
             const tabs = [];
             const seen = new Set();
@@ -1477,7 +1833,7 @@ export class AppTabsController {
                 tabs.push(persistedTab);
             }
             if (tabs.length === 0)
-                return;
+                return Promise.resolve();
             const activePath = this.activeTab()?.sessionPath;
             const payload = JSON.stringify({
                 version: TAB_STATE_VERSION,
@@ -1486,13 +1842,28 @@ export class AppTabsController {
                 ...(activePath ? { activePath: resolve(activePath) } : {}),
             }, null, 2);
             const filePath = this.filePath();
+            const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+            const write = this.saveTabsWriteTail.then(async () => {
+                await this.writeTabsSnapshot(filePath, tempPath, payload);
+            }).catch(() => {
+                // Tab state should never interrupt the terminal UI.
+            });
+            this.saveTabsWriteTail = write;
+            return write;
+        }
+        catch {
+            // Tab state should never interrupt the terminal UI.
+            return Promise.resolve();
+        }
+    }
+    async writeTabsSnapshot(filePath, tempPath, payload) {
+        try {
             await mkdir(dirname(filePath), { recursive: true });
-            const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
             await writeFile(tempPath, payload, "utf8");
             await rename(tempPath, filePath);
         }
-        catch {
-            // Tab state should never interrupt the terminal UI.
+        finally {
+            await unlink(tempPath).catch(() => undefined);
         }
     }
     filePath() {
@@ -1504,7 +1875,7 @@ export class AppTabsController {
         return join(getAgentDir(), "sessions", safePath);
     }
     scheduleProjectSessionRetention() {
-        if (this.host.options.noSession || this.maxProjectSessions() <= 0 || this.retentionCleanupScheduled || this.retentionCleanupRunning)
+        if (!this.host.isRunning() || this.host.options.noSession || this.maxProjectSessions() <= 0 || this.retentionCleanupScheduled || this.retentionCleanupRunning)
             return;
         this.retentionCleanupScheduled = true;
         setTimeout(() => {
@@ -1513,7 +1884,7 @@ export class AppTabsController {
         }, 0);
     }
     scheduleTabPrewarm() {
-        if (this.host.options.noSession || this.prewarmScheduled || this.prewarmRunning)
+        if (!this.host.isRunning() || this.host.options.noSession || this.prewarmScheduled || this.prewarmRunning)
             return;
         this.prewarmScheduled = true;
         setTimeout(() => {
@@ -1528,6 +1899,8 @@ export class AppTabsController {
         try {
             let warmed = 0;
             for (const tab of this.tabItems) {
+                if (!this.host.isRunning())
+                    break;
                 if (warmed >= BACKGROUND_PREWARM_TAB_LIMIT)
                     break;
                 if (tab.id === this.activeTabId || !tab.sessionPath)
@@ -1599,17 +1972,9 @@ export class AppTabsController {
      */
     async unlinkSessionAndDcpSidecar(sessionPath) {
         let sidecarPath;
-        try {
-            const firstLine = (await readFile(sessionPath, "utf8")).split("\n", 1)[0]?.trim();
-            if (firstLine) {
-                const parsed = JSON.parse(firstLine);
-                if (parsed.type === "session" && typeof parsed.id === "string" && parsed.id) {
-                    sidecarPath = join(dirname(sessionPath), "dcp-state", parsed.id.replace(/[^a-zA-Z0-9._-]/g, "_") + ".json");
-                }
-            }
-        }
-        catch {
-            // Reading the session id is best-effort; proceed to unlink the file.
+        const header = await readSessionHeader(sessionPath);
+        if (header?.type === "session" && typeof header.id === "string" && header.id) {
+            sidecarPath = join(dirname(sessionPath), "dcp-state", header.id.replace(/[^a-zA-Z0-9._-]/g, "_") + ".json");
         }
         try {
             await unlink(sessionPath);
@@ -1726,21 +2091,29 @@ async function readSessionTitleChunk(file, position, byteCount, options = {}) {
     return undefined;
 }
 async function readSessionHasParent(sessionPath) {
+    const header = await readSessionHeader(sessionPath);
+    return header?.type === "session" && typeof header.parentSession === "string";
+}
+async function readSessionHeader(sessionPath) {
     let file;
     try {
         file = await openFile(sessionPath, "r");
-        const buffer = Buffer.alloc(4096);
+        const buffer = Buffer.alloc(SESSION_HEADER_SCAN_MAX_BYTES);
         const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
         if (bytesRead <= 0)
-            return false;
-        const firstLine = buffer.subarray(0, bytesRead).toString("utf8").split("\n", 1)[0]?.trim();
+            return undefined;
+        const content = buffer.subarray(0, bytesRead);
+        const newlineIndex = content.indexOf(0x0a);
+        if (newlineIndex < 0 && bytesRead === buffer.length)
+            return undefined;
+        const firstLine = content.subarray(0, newlineIndex >= 0 ? newlineIndex : bytesRead).toString("utf8").trim();
         if (!firstLine)
-            return false;
+            return undefined;
         const parsed = JSON.parse(firstLine);
-        return isRecord(parsed) && parsed.type === "session" && typeof parsed.parentSession === "string";
+        return isRecord(parsed) ? parsed : undefined;
     }
     catch {
-        return false;
+        return undefined;
     }
     finally {
         await file?.close();