pi-ui-extend 0.1.1

package/dist/app/tabs-controller.js

@@ -0,0 +1,885 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { getAgentDir, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { isRecord } from "./guards.js";
+import { createId } from "./id.js";
+import { createStartupInfoMessage, isEmptyStartupSession } from "./startup-info.js";
+import { tabPanelRows } from "./tab-line-renderer.js";
+const TAB_STATE_VERSION = 2;
+const MAX_RESTORED_TABS = 8;
+const TAB_ATTENTION_BLINK_KEY = "tab-attention";
+export class AppTabsController {
+    host;
+    tabItems = [];
+    runtimesByTabId = new Map();
+    runtimeSubscriptionsByTabId = new Map();
+    inputStatesByTabId = new Map();
+    activeTabId;
+    pendingActiveTabId;
+    historyLoadGeneration = 0;
+    restored = false;
+    constructor(host) {
+        this.host = host;
+    }
+    tabs() {
+        if (!this.pendingActiveTabId)
+            this.syncActiveTabFromRuntime({ save: false });
+        const activeTabId = this.pendingActiveTabId ?? this.activeTabId;
+        return this.tabItems.map((tab) => ({
+            ...tab,
+            status: tab.id === activeTabId ? "active" : "waiting",
+            activity: this.tabActivity(tab),
+            ...(tab.attention === undefined ? {} : { attention: tab.attention }),
+            ...(tab.attention === undefined ? {} : { attentionVisible: this.host.blinkController.visible(TAB_ATTENTION_BLINK_KEY, true) }),
+        }));
+    }
+    isSwitching() {
+        return this.pendingActiveTabId !== undefined;
+    }
+    markTerminalBellAttention(sessionPath) {
+        if (!sessionPath)
+            return;
+        const tab = this.findTabBySessionPath(sessionPath);
+        if (!tab || tab.id === this.activeTabId)
+            return;
+        tab.attention = "terminal-bell";
+        this.startAttentionBlink();
+        this.host.render();
+    }
+    tabPanelRows(terminalRows) {
+        if (!this.pendingActiveTabId)
+            this.syncActiveTabFromRuntime({ save: false });
+        return tabPanelRows(true, terminalRows, this.tabItems.length);
+    }
+    activeInputTabId() {
+        if (!this.pendingActiveTabId)
+            this.syncActiveTabFromRuntime({ save: false });
+        return this.activeTabId;
+    }
+    inputStateForTab(tabId) {
+        if (!tabId)
+            return this.host.captureInputState();
+        if (tabId === this.activeTabId && this.pendingActiveTabId === undefined)
+            return this.host.captureInputState();
+        return this.inputStatesByTabId.get(tabId);
+    }
+    async setInputStateForTab(tabId, state) {
+        const nextState = {
+            text: state.text,
+            cursor: Math.max(0, Math.min(state.text.length, Math.trunc(state.cursor))),
+        };
+        const targetTabId = tabId ?? this.activeTabId;
+        if (targetTabId) {
+            if (nextState.text.length > 0)
+                this.inputStatesByTabId.set(targetTabId, nextState);
+            else
+                this.inputStatesByTabId.delete(targetTabId);
+        }
+        if (!tabId || (tabId === this.activeTabId && this.pendingActiveTabId === undefined)) {
+            this.host.restoreInputState(nextState);
+        }
+        await this.saveTabs();
+    }
+    async disposeInactiveRuntimes(disposeRuntime = this.host.disposeRuntime) {
+        await this.saveInputStateForQuit();
+        const activeRuntime = this.host.runtime();
+        const disposed = new Set();
+        for (const runtime of this.runtimesByTabId.values()) {
+            if (runtime === activeRuntime || disposed.has(runtime))
+                continue;
+            disposed.add(runtime);
+            await disposeRuntime(runtime);
+        }
+    }
+    async saveInputStateForQuit() {
+        this.syncActiveTabFromRuntime({ save: false });
+        this.storeActiveInputState();
+        await this.saveTabs();
+    }
+    syncActiveTabFromRuntime(options = {}) {
+        if (this.pendingActiveTabId && options.force !== true)
+            return;
+        const session = this.host.runtime()?.session;
+        if (!session)
+            return;
+        const sessionPath = this.sessionPath(session);
+        const active = this.activeTab();
+        const existing = sessionPath ? this.findTabBySessionPath(sessionPath, active ? { excludeTabId: active.id } : {}) : undefined;
+        if (existing) {
+            if (active)
+                this.storeActiveInputState();
+            this.activeTabId = existing.id;
+            this.clearTabAttention(existing);
+            this.updateTabFromSession(existing, session);
+            if (active)
+                this.deleteRuntimeForTab(active.id);
+            this.storeActiveRuntime();
+            if (options.save !== false)
+                void this.saveTabs();
+            return;
+        }
+        if (!active) {
+            const tab = this.tabFromSession(session, { titlePlaceholder: this.restored ? "new" : "loading" });
+            this.tabItems.push(tab);
+            this.activeTabId = tab.id;
+            this.clearTabAttention(tab);
+            this.storeActiveRuntime();
+            if (options.save !== false)
+                void this.saveTabs();
+            return;
+        }
+        this.updateTabFromSession(active, session);
+        this.clearTabAttention(active);
+        this.storeActiveRuntime();
+        if (options.save !== false)
+            void this.saveTabs();
+    }
+    async restoreAfterStartup() {
+        if (this.restored)
+            return;
+        this.restored = true;
+        const runtime = this.host.runtime();
+        if (!runtime)
+            return;
+        this.syncActiveTabFromRuntime({ save: false });
+        if (this.host.options.noSession)
+            return;
+        const saved = await this.loadTabs();
+        if (!saved || saved.tabs.length === 0) {
+            await this.saveTabs();
+            return;
+        }
+        const sessionTitles = await this.loadSessionTitles();
+        const restoredTabs = this.restoredTabs(saved, sessionTitles);
+        if (restoredTabs.length === 0) {
+            await this.saveTabs();
+            return;
+        }
+        const currentPath = runtime.session.sessionFile ? resolve(runtime.session.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
+            ? currentPath
+            : savedActivePath && restoredTabs.some((tab) => tab.sessionPath === savedActivePath)
+                ? savedActivePath
+                : restoredTabs[0]?.sessionPath;
+        this.replaceTabs(restoredTabs, desiredPath);
+        this.restorePersistedInputStates(saved);
+        if (explicitSessionPath && currentPath)
+            this.ensureCurrentSessionTab(runtime.session);
+        if (!desiredPath) {
+            await this.saveTabs();
+            return;
+        }
+        if (currentPath !== desiredPath) {
+            this.host.setStatus("restoring tabs");
+            this.host.render();
+            try {
+                const result = await runtime.switchSession(desiredPath);
+                if (result.cancelled)
+                    throw new Error("restore cancelled");
+            }
+            catch {
+                this.host.showToast("Could not restore the previous active tab", "warning");
+                this.replaceTabs([this.tabFromSession(runtime.session), ...restoredTabs], currentPath);
+                this.storeActiveRuntime(runtime);
+                await this.saveTabs();
+                return;
+            }
+        }
+        this.syncActiveTabFromRuntime({ save: false });
+        this.host.resetSessionView();
+        this.host.loadSessionHistory();
+        this.host.setSessionStatus(runtime.session);
+        this.host.setSessionActivity(this.sessionActivity(runtime.session));
+        if (this.activeTabId)
+            this.restoreInputState(this.activeTabId);
+        await this.saveTabs();
+    }
+    async openNewTab() {
+        if (this.pendingActiveTabId) {
+            this.host.showToast("Wait for the tab to finish loading", "info");
+            return;
+        }
+        const runtime = this.runtimeForCommand("new_tab");
+        if (!runtime)
+            return;
+        if (!this.tabsAvailable(runtime))
+            return;
+        this.cancelHistoryLoad();
+        this.syncActiveTabFromRuntime();
+        this.storeActiveInputState();
+        this.host.setStatus("starting new tab");
+        this.host.render();
+        const newRuntime = await this.host.createRuntimeForNewSession();
+        const existingTab = this.findTabForSession(newRuntime.session);
+        const tab = existingTab ?? this.tabFromSession(newRuntime.session, { titlePlaceholder: "new" });
+        if (!existingTab)
+            this.tabItems.push(tab);
+        this.activeTabId = tab.id;
+        this.pendingActiveTabId = tab.id;
+        this.clearTabAttention(tab);
+        this.updateTabFromSession(tab, newRuntime.session);
+        this.setRuntimeForTab(tab.id, newRuntime);
+        this.restoreInputState(tab.id);
+        try {
+            await this.host.activateRuntime(newRuntime);
+        }
+        finally {
+            if (this.pendingActiveTabId === tab.id)
+                this.pendingActiveTabId = undefined;
+        }
+        void this.saveTabs();
+        this.host.resetSessionView();
+        if (isEmptyStartupSession(newRuntime)) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: createStartupInfoMessage(newRuntime) });
+        }
+        else {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: `Opened a new tab. cwd=${newRuntime.cwd}` });
+        }
+        if (newRuntime.modelFallbackMessage)
+            this.host.addEntry({ id: createId("system"), kind: "system", text: newRuntime.modelFallbackMessage });
+        for (const diag of newRuntime.diagnostics ?? []) {
+            const kind = diag.type === "error" ? "error" : "system";
+            this.host.addEntry({ id: createId("system"), kind, text: `[${diag.type}] ${diag.message}` });
+        }
+        this.host.setSessionStatus(newRuntime.session);
+        this.host.setSessionActivity(this.sessionActivity(newRuntime.session));
+        this.host.render();
+    }
+    async openSessionInNewTab(sessionPath) {
+        if (this.pendingActiveTabId) {
+            this.host.showToast("Wait for the tab to finish loading", "info");
+            return false;
+        }
+        const runtime = this.runtimeForCommand("search");
+        if (!runtime)
+            return false;
+        if (this.host.options.noSession) {
+            this.host.showToast("/search is unavailable with --no-session", "warning");
+            return false;
+        }
+        this.syncActiveTabFromRuntime({ save: false });
+        const resolvedSessionPath = resolve(runtime.cwd, sessionPath);
+        const existingTab = this.findTabBySessionPath(resolvedSessionPath);
+        if (existingTab) {
+            await this.switchToTab(existingTab.id);
+            return true;
+        }
+        this.cancelHistoryLoad();
+        this.storeActiveInputState();
+        const previousTabId = this.activeTabId;
+        const previousRuntime = runtime;
+        this.host.setStatus("opening session tab");
+        this.host.render();
+        let newRuntime;
+        try {
+            newRuntime = await this.host.createRuntimeForSession(resolvedSessionPath);
+        }
+        catch {
+            this.host.showToast("Could not open session tab", "warning");
+            this.host.setSessionStatus(previousRuntime.session);
+            this.host.render();
+            return false;
+        }
+        const tab = this.tabFromSession(newRuntime.session, { titlePlaceholder: "loading" });
+        this.tabItems.push(tab);
+        this.activeTabId = tab.id;
+        this.pendingActiveTabId = tab.id;
+        this.clearTabAttention(tab);
+        this.updateTabFromSession(tab, newRuntime.session);
+        this.setRuntimeForTab(tab.id, newRuntime);
+        this.restoreInputState(tab.id);
+        try {
+            await this.host.activateRuntime(newRuntime);
+        }
+        catch {
+            this.pendingActiveTabId = undefined;
+            this.removeTab(tab.id);
+            this.activeTabId = previousTabId;
+            if (previousTabId)
+                this.restoreInputState(previousTabId);
+            if (this.host.runtime() !== previousRuntime) {
+                try {
+                    await this.host.activateRuntime(previousRuntime);
+                }
+                catch {
+                    // Keep the best available runtime below and surface the switch failure.
+                }
+            }
+            void this.host.disposeRuntime(newRuntime);
+            this.host.showToast("Could not open session tab", "warning");
+            this.host.resetSessionView();
+            this.host.loadSessionHistory();
+            this.host.setSessionStatus(this.host.runtime()?.session);
+            this.host.setSessionActivity(this.sessionActivity(this.host.runtime()?.session));
+            this.host.render();
+            return false;
+        }
+        if (this.pendingActiveTabId === tab.id)
+            this.pendingActiveTabId = undefined;
+        this.activeTabId = tab.id;
+        this.clearTabAttention(tab);
+        this.updateTabFromSession(tab, newRuntime.session);
+        this.setRuntimeForTab(tab.id, newRuntime);
+        this.restoreInputState(tab.id);
+        void this.saveTabs();
+        await this.loadActiveSessionHistory(newRuntime);
+        return true;
+    }
+    async switchToTab(tabId) {
+        if (this.pendingActiveTabId) {
+            this.host.showToast("Wait for the tab to finish loading", "info");
+            return;
+        }
+        if (tabId === this.activeTabId)
+            return;
+        const runtime = this.runtimeForCommand("tab switch");
+        if (!runtime)
+            return;
+        this.syncActiveTabFromRuntime({ save: false });
+        const target = this.tabItems.find((tab) => tab.id === tabId);
+        if (!target)
+            return;
+        if (!target.sessionPath) {
+            this.host.showToast("Tab has no persisted session path", "warning");
+            return;
+        }
+        this.cancelHistoryLoad();
+        const previousTabId = this.activeTabId;
+        const previousRuntime = runtime;
+        const previousTargetActivity = target.activity;
+        this.storeActiveRuntime(runtime);
+        this.storeActiveInputState();
+        this.activeTabId = target.id;
+        this.pendingActiveTabId = target.id;
+        target.activity = "thinking";
+        this.clearTabAttention(target);
+        this.restoreInputState(target.id);
+        this.host.resetSessionView();
+        this.host.setStatus("switching tab");
+        this.host.setSessionActivity("thinking");
+        this.host.render();
+        let targetRuntime;
+        try {
+            targetRuntime = await this.runtimeForTab(target);
+            if (!targetRuntime)
+                throw new Error("Could not load tab runtime");
+            await this.host.activateRuntime(targetRuntime);
+        }
+        catch {
+            this.pendingActiveTabId = undefined;
+            if (previousTargetActivity === undefined)
+                delete target.activity;
+            else
+                target.activity = previousTargetActivity;
+            this.activeTabId = previousTabId;
+            if (previousTabId)
+                this.restoreInputState(previousTabId);
+            if (this.host.runtime() !== previousRuntime) {
+                try {
+                    await this.host.activateRuntime(previousRuntime);
+                }
+                catch {
+                    // Keep the best available runtime below and surface the switch failure.
+                }
+            }
+            this.host.showToast("Could not switch tab", "warning");
+            this.host.resetSessionView();
+            this.host.loadSessionHistory();
+            const activeSession = this.host.runtime()?.session;
+            this.host.setSessionStatus(activeSession);
+            this.host.setSessionActivity(this.sessionActivity(activeSession));
+            this.host.render();
+            return;
+        }
+        this.pendingActiveTabId = undefined;
+        this.activeTabId = target.id;
+        this.clearTabAttention(target);
+        this.updateTabFromSession(target, targetRuntime.session);
+        this.setRuntimeForTab(target.id, targetRuntime);
+        this.restoreInputState(target.id);
+        void this.saveTabs();
+        await this.loadActiveSessionHistory(targetRuntime);
+    }
+    async closeTab(tabId) {
+        if (this.pendingActiveTabId) {
+            this.host.showToast("Wait for the tab to finish loading", "info");
+            return;
+        }
+        const index = this.tabItems.findIndex((tab) => tab.id === tabId);
+        if (index < 0)
+            return;
+        this.cancelHistoryLoad();
+        if (this.tabItems.length <= 1) {
+            await this.replaceLastTabWithNewSession(tabId);
+            return;
+        }
+        if (tabId !== this.activeTabId) {
+            const tabRuntime = this.runtimesByTabId.get(tabId);
+            if (tabRuntime?.session.isStreaming || tabRuntime?.session.isCompacting) {
+                this.host.showToast("Cannot close a running tab", "warning");
+                return;
+            }
+            this.tabItems.splice(index, 1);
+            this.deleteRuntimeForTab(tabId);
+            this.inputStatesByTabId.delete(tabId);
+            this.storeActiveInputState();
+            this.stopAttentionBlinkIfIdle();
+            if (tabRuntime)
+                void this.host.disposeRuntime(tabRuntime);
+            void this.saveTabs();
+            this.host.render();
+            return;
+        }
+        const runtime = this.idleRuntime("tab close");
+        if (!runtime)
+            return;
+        const nextTab = this.tabItems[index + 1] ?? this.tabItems[index - 1];
+        if (!nextTab?.sessionPath) {
+            this.host.showToast("No persisted session path for the next tab", "warning");
+            return;
+        }
+        this.host.setStatus("closing tab");
+        this.host.render();
+        const nextRuntime = await this.runtimeForTab(nextTab);
+        if (!nextRuntime)
+            return;
+        await this.host.activateRuntime(nextRuntime);
+        this.tabItems.splice(index, 1);
+        this.deleteRuntimeForTab(tabId);
+        this.inputStatesByTabId.delete(tabId);
+        this.stopAttentionBlinkIfIdle();
+        this.activeTabId = nextTab.id;
+        this.clearTabAttention(nextTab);
+        this.updateTabFromSession(nextTab, nextRuntime.session);
+        this.setRuntimeForTab(nextTab.id, nextRuntime);
+        this.restoreInputState(nextTab.id);
+        void this.host.disposeRuntime(runtime);
+        void this.saveTabs();
+        await this.loadActiveSessionHistory(nextRuntime);
+    }
+    async replaceLastTabWithNewSession(tabId) {
+        const tab = this.tabItems.find((item) => item.id === tabId);
+        if (!tab)
+            return;
+        const runtime = this.idleRuntime("new");
+        if (!runtime)
+            return;
+        this.activeTabId = tab.id;
+        this.host.setStatus("starting new session");
+        this.host.render();
+        const result = await runtime.newSession();
+        if (result.cancelled) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "New session cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            this.host.setSessionActivity(this.sessionActivity(runtime.session));
+            this.host.render();
+            return;
+        }
+        this.clearTabAttention(tab);
+        this.updateTabFromSession(tab, runtime.session);
+        this.setRuntimeForTab(tab.id, runtime);
+        this.inputStatesByTabId.delete(tab.id);
+        this.restoreInputState(tab.id);
+        this.stopAttentionBlinkIfIdle();
+        this.host.resetSessionView();
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Started a new session. cwd=${runtime.cwd}` });
+        if (runtime.modelFallbackMessage)
+            this.host.addEntry({ id: createId("system"), kind: "system", text: runtime.modelFallbackMessage });
+        for (const diag of runtime.diagnostics ?? []) {
+            const kind = diag.type === "error" ? "error" : "system";
+            this.host.addEntry({ id: createId("system"), kind, text: `[${diag.type}] ${diag.message}` });
+        }
+        this.host.setSessionStatus(runtime.session);
+        this.host.setSessionActivity(this.sessionActivity(runtime.session));
+        void this.saveTabs();
+        this.host.render();
+    }
+    async loadActiveSessionHistory(runtime) {
+        const generation = ++this.historyLoadGeneration;
+        const isCancelled = () => generation !== this.historyLoadGeneration || this.host.runtime() !== runtime;
+        this.host.resetSessionView();
+        this.host.setStatus("loading session history");
+        this.host.setSessionActivity("thinking");
+        this.host.render();
+        const completed = await this.host.loadSessionHistoryAsync({
+            isCancelled,
+            render: () => {
+                if (!isCancelled())
+                    this.host.render();
+            },
+        });
+        if (!completed || isCancelled())
+            return;
+        this.host.setSessionStatus(runtime.session);
+        this.host.syncUserSessionEntryMetadata();
+        this.host.setSessionActivity(this.sessionActivity(runtime.session));
+        this.host.render();
+    }
+    cancelHistoryLoad() {
+        this.historyLoadGeneration += 1;
+    }
+    tabsAvailable(runtime) {
+        if (this.host.options.noSession) {
+            this.host.showToast("/new_tab is unavailable with --no-session", "warning");
+            return false;
+        }
+        if (!runtime.session.sessionFile) {
+            this.host.showToast("/new_tab requires a persisted session", "warning");
+            return false;
+        }
+        return true;
+    }
+    runtimeForCommand(commandName) {
+        const runtime = this.host.runtime();
+        if (!runtime) {
+            this.host.showToast(`/${commandName} unavailable`, "error");
+            this.host.addEntry({ id: createId("error"), kind: "error", text: "Runtime is not initialized" });
+            return undefined;
+        }
+        return runtime;
+    }
+    idleRuntime(commandName) {
+        const runtime = this.runtimeForCommand(commandName);
+        if (!runtime)
+            return undefined;
+        if (runtime.session.isStreaming || runtime.session.isCompacting) {
+            this.host.showToast(`/${commandName} is unavailable while the agent is running`, "warning");
+            return undefined;
+        }
+        return runtime;
+    }
+    activeTab() {
+        return this.activeTabId ? this.tabItems.find((tab) => tab.id === this.activeTabId) : undefined;
+    }
+    storeActiveRuntime(runtime = this.host.runtime()) {
+        if (!this.activeTabId || !runtime)
+            return;
+        this.setRuntimeForTab(this.activeTabId, runtime);
+    }
+    setRuntimeForTab(tabId, runtime) {
+        this.runtimesByTabId.set(tabId, runtime);
+        this.observeRuntimeForTab(tabId, runtime);
+    }
+    deleteRuntimeForTab(tabId) {
+        this.runtimesByTabId.delete(tabId);
+        const subscription = this.runtimeSubscriptionsByTabId.get(tabId);
+        subscription?.unsubscribe();
+        this.runtimeSubscriptionsByTabId.delete(tabId);
+    }
+    clearRuntimeSubscriptions() {
+        for (const subscription of this.runtimeSubscriptionsByTabId.values()) {
+            subscription.unsubscribe();
+        }
+        this.runtimeSubscriptionsByTabId.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) => {
+            if (!this.shouldSyncTabFromRuntimeEvent(event))
+                return;
+            this.syncTabFromObservedRuntime(tabId, runtime);
+        });
+        this.runtimeSubscriptionsByTabId.set(tabId, { runtime, session: runtime.session, unsubscribe });
+    }
+    shouldSyncTabFromRuntimeEvent(event) {
+        return event.type === "session_info_changed"
+            || event.type === "agent_start"
+            || event.type === "agent_end"
+            || event.type === "compaction_start"
+            || event.type === "compaction_end";
+    }
+    syncTabFromObservedRuntime(tabId, runtime) {
+        const tab = this.tabItems.find((item) => item.id === tabId);
+        if (!tab) {
+            this.deleteRuntimeForTab(tabId);
+            return;
+        }
+        const previousTitle = tab.title;
+        const previousActivity = tab.activity;
+        const previousSessionPath = tab.sessionPath;
+        this.updateTabFromSession(tab, runtime.session);
+        if (tab.title === previousTitle && tab.activity === previousActivity && tab.sessionPath === previousSessionPath)
+            return;
+        if (tab.title !== previousTitle || tab.sessionPath !== previousSessionPath)
+            void this.saveTabs();
+        this.host.render();
+    }
+    storeActiveInputState() {
+        if (!this.activeTabId)
+            return;
+        const state = this.host.captureInputState();
+        this.inputStatesByTabId.set(this.activeTabId, {
+            text: state.text,
+            cursor: state.cursor,
+        });
+    }
+    restoreInputState(tabId) {
+        this.host.restoreInputState(this.inputStatesByTabId.get(tabId) ?? { text: "", cursor: 0 });
+    }
+    async runtimeForTab(tab) {
+        const existing = this.runtimesByTabId.get(tab.id);
+        if (existing)
+            return existing;
+        if (!tab.sessionPath) {
+            this.host.showToast("Tab has no persisted session path", "warning");
+            return undefined;
+        }
+        const runtime = await this.host.createRuntimeForSession(tab.sessionPath);
+        this.setRuntimeForTab(tab.id, runtime);
+        return runtime;
+    }
+    findTabForSession(session, options = {}) {
+        const sessionPath = this.sessionPath(session);
+        return sessionPath ? this.findTabBySessionPath(sessionPath, options) : undefined;
+    }
+    findTabBySessionPath(sessionPath, options = {}) {
+        const normalizedPath = resolve(sessionPath);
+        return this.tabItems.find((tab) => (tab.id !== options.excludeTabId
+            && tab.sessionPath !== undefined
+            && resolve(tab.sessionPath) === normalizedPath));
+    }
+    replaceTabs(tabs, activeSessionPath) {
+        this.tabItems.length = 0;
+        this.runtimesByTabId.clear();
+        this.clearRuntimeSubscriptions();
+        this.inputStatesByTabId.clear();
+        const seen = new Set();
+        for (const tab of tabs) {
+            const sessionPath = tab.sessionPath ? resolve(tab.sessionPath) : undefined;
+            if (sessionPath) {
+                if (seen.has(sessionPath))
+                    continue;
+                seen.add(sessionPath);
+            }
+            this.tabItems.push({
+                id: tab.id,
+                title: tab.title,
+                status: "waiting",
+                activity: tab.activity ?? "idle",
+                ...(sessionPath ? { sessionPath } : {}),
+            });
+        }
+        const activePath = activeSessionPath ? resolve(activeSessionPath) : undefined;
+        this.activeTabId = activePath
+            ? this.tabItems.find((tab) => tab.sessionPath === activePath)?.id
+            : this.tabItems[0]?.id;
+        this.activeTabId ??= this.tabItems[0]?.id;
+    }
+    removeTab(tabId) {
+        const index = this.tabItems.findIndex((tab) => tab.id === tabId);
+        if (index >= 0)
+            this.tabItems.splice(index, 1);
+        this.deleteRuntimeForTab(tabId);
+        this.inputStatesByTabId.delete(tabId);
+    }
+    restorePersistedInputStates(saved) {
+        const inputsByPath = new Map();
+        for (const tab of saved.tabs) {
+            if (!tab.input)
+                continue;
+            inputsByPath.set(resolve(tab.path), tab.input);
+        }
+        for (const tab of this.tabItems) {
+            if (!tab.sessionPath)
+                continue;
+            const input = inputsByPath.get(resolve(tab.sessionPath));
+            if (!input)
+                continue;
+            this.inputStatesByTabId.set(tab.id, input);
+        }
+    }
+    ensureCurrentSessionTab(session) {
+        const currentPath = session.sessionFile ? resolve(session.sessionFile) : undefined;
+        if (!currentPath)
+            return;
+        const existing = this.tabItems.find((tab) => tab.sessionPath === currentPath);
+        if (existing) {
+            this.activeTabId = existing.id;
+            this.clearTabAttention(existing);
+            this.updateTabFromSession(existing, session);
+            return;
+        }
+        const tab = this.tabFromSession(session);
+        this.tabItems.unshift(tab);
+        this.activeTabId = tab.id;
+    }
+    tabFromSession(session, options = {}) {
+        const sessionPath = this.sessionPath(session);
+        return {
+            id: createId("tab"),
+            title: this.sessionTitle(session),
+            ...(options.titlePlaceholder ? { titlePlaceholder: options.titlePlaceholder } : {}),
+            status: "active",
+            activity: this.sessionActivity(session),
+            ...(sessionPath ? { sessionPath } : {}),
+        };
+    }
+    updateTabFromSession(tab, session) {
+        tab.title = this.sessionTitle(session);
+        tab.activity = this.sessionActivity(session);
+        const sessionPath = this.sessionPath(session);
+        if (sessionPath)
+            tab.sessionPath = sessionPath;
+    }
+    sessionPath(session) {
+        return session.sessionFile ? resolve(session.sessionFile) : undefined;
+    }
+    sessionTitle(session) {
+        const name = session.sessionName?.trim();
+        return name ? name : `session ${session.sessionId.slice(0, 8)}`;
+    }
+    sessionActivity(session) {
+        return session?.isStreaming || session?.isCompacting ? "running" : "idle";
+    }
+    tabActivity(tab) {
+        if (tab.id === this.pendingActiveTabId)
+            return "thinking";
+        const runtime = this.runtimesByTabId.get(tab.id);
+        return runtime ? this.sessionActivity(runtime.session) : tab.activity ?? "idle";
+    }
+    clearTabAttention(tab) {
+        if (tab.attention === undefined && tab.attentionVisible === undefined)
+            return;
+        delete tab.attention;
+        delete tab.attentionVisible;
+        this.stopAttentionBlinkIfIdle();
+    }
+    startAttentionBlink() {
+        this.host.blinkController.setActive(TAB_ATTENTION_BLINK_KEY, true, {
+            scope: "full",
+            initialVisible: true,
+        });
+    }
+    stopAttentionBlinkIfIdle() {
+        if (this.tabItems.some((tab) => tab.attention !== undefined))
+            return;
+        this.host.blinkController.setActive(TAB_ATTENTION_BLINK_KEY, false, {
+            scope: "full",
+            initialVisible: true,
+        });
+    }
+    async loadSessionTitles() {
+        try {
+            const sessions = await SessionManager.list(this.host.options.cwd);
+            return new Map(sessions.map((session) => [
+                resolve(session.path),
+                (session.name?.trim() || `session ${session.id.slice(0, 8)}`),
+            ]));
+        }
+        catch {
+            return new Map();
+        }
+    }
+    restoredTabs(saved, titles) {
+        const tabs = [];
+        const seen = new Set();
+        for (const tab of saved.tabs) {
+            const sessionPath = resolve(tab.path);
+            const hasDraftInput = (tab.input?.text.length ?? 0) > 0;
+            if (seen.has(sessionPath) || (!existsSync(sessionPath) && !hasDraftInput))
+                continue;
+            seen.add(sessionPath);
+            const title = titles.get(sessionPath) ?? tab.title?.trim();
+            tabs.push({
+                id: createId("tab"),
+                title: title || "session",
+                status: "waiting",
+                sessionPath,
+            });
+            if (tabs.length >= MAX_RESTORED_TABS)
+                break;
+        }
+        return tabs;
+    }
+    async loadTabs() {
+        try {
+            const raw = await readFile(this.filePath(), "utf8");
+            const parsed = JSON.parse(raw);
+            if (!isRecord(parsed) || (parsed.version !== 1 && parsed.version !== TAB_STATE_VERSION) || !Array.isArray(parsed.tabs))
+                return undefined;
+            const tabs = [];
+            for (const value of parsed.tabs) {
+                if (!isRecord(value) || typeof value.path !== "string")
+                    continue;
+                const input = this.parsePersistedInputState(value.input);
+                tabs.push({
+                    path: value.path,
+                    ...(typeof value.title === "string" ? { title: value.title } : {}),
+                    ...(input ? { input } : {}),
+                });
+            }
+            return {
+                version: parsed.version === 1 ? 1 : TAB_STATE_VERSION,
+                cwd: typeof parsed.cwd === "string" ? parsed.cwd : this.host.options.cwd,
+                tabs,
+                ...(typeof parsed.activePath === "string" ? { activePath: parsed.activePath } : {}),
+            };
+        }
+        catch (error) {
+            if (isRecord(error) && error.code === "ENOENT")
+                return undefined;
+            return undefined;
+        }
+    }
+    parsePersistedInputState(value) {
+        if (!isRecord(value) || typeof value.text !== "string")
+            return undefined;
+        const cursor = typeof value.cursor === "number" && Number.isFinite(value.cursor)
+            ? Math.max(0, Math.min(value.text.length, Math.trunc(value.cursor)))
+            : value.text.length;
+        return { text: value.text, cursor };
+    }
+    async saveTabs() {
+        if (this.host.options.noSession)
+            return;
+        try {
+            const tabs = [];
+            const seen = new Set();
+            for (const tab of this.tabItems) {
+                if (!tab.sessionPath)
+                    continue;
+                const sessionPath = resolve(tab.sessionPath);
+                if (seen.has(sessionPath))
+                    continue;
+                seen.add(sessionPath);
+                const persistedTab = { path: sessionPath, title: tab.title };
+                const input = this.inputStatesByTabId.get(tab.id);
+                if (input?.text.length) {
+                    persistedTab.input = {
+                        text: input.text,
+                        cursor: Math.max(0, Math.min(input.text.length, Math.trunc(input.cursor))),
+                    };
+                }
+                tabs.push(persistedTab);
+            }
+            if (tabs.length === 0)
+                return;
+            const activePath = this.activeTab()?.sessionPath;
+            const payload = JSON.stringify({
+                version: TAB_STATE_VERSION,
+                cwd: this.host.options.cwd,
+                tabs,
+                ...(activePath ? { activePath: resolve(activePath) } : {}),
+            }, null, 2);
+            const filePath = this.filePath();
+            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.
+        }
+    }
+    filePath() {
+        const key = createHash("sha256").update(resolve(this.host.options.cwd)).digest("hex").slice(0, 24);
+        return join(getAgentDir(), "pix", "tabs", `${key}.json`);
+    }
+}