tabminal 3.0.8 → 3.0.9

package/public/app.js

@@ -375,6 +375,11 @@ function persistRuntimeBootId(bootId) {
     }
 }
 
+function getLoadedRuntimeAssetKey() {
+    const assetKey = window.__tabminalRuntimeAssetKey;
+    return typeof assetKey === 'string' ? assetKey : '';
+}
+
 function handlePrimaryRuntimeVersion(data) {
     const runtime = data?.runtime;
     const bootIdRaw = runtime?.bootId;
@@ -382,16 +387,20 @@ function handlePrimaryRuntimeVersion(data) {
     const bootId = String(bootIdRaw);
     if (!bootId) return;
     const storedBootId = readRuntimeBootId();
+    const loadedAssetKey = getLoadedRuntimeAssetKey();
+    const needsShellReload = loadedAssetKey !== bootId;
 
     if (!primaryServerBootId) {
         primaryServerBootId = bootId;
-        if (storedBootId === bootId) {
+        if (storedBootId === bootId && !needsShellReload) {
             return;
         }
         const persisted = persistRuntimeBootId(bootId);
-        if (storedBootId && persisted && !runtimeReloadScheduled) {
+        if (persisted && needsShellReload && !runtimeReloadScheduled) {
             runtimeReloadScheduled = true;
-            console.info('[Runtime] Syncing app shell cache key with server boot id.');
+            console.info(
+                '[Runtime] Syncing app shell cache key with server boot id.'
+            );
             window.location.reload();
         }
         return;
@@ -400,6 +409,13 @@ function handlePrimaryRuntimeVersion(data) {
         if (storedBootId !== bootId) {
             persistRuntimeBootId(bootId);
         }
+        if (needsShellReload && !runtimeReloadScheduled) {
+            runtimeReloadScheduled = true;
+            console.info(
+                '[Runtime] Reloading app shell to match server boot id.'
+            );
+            window.location.reload();
+        }
         return;
     }
     if (runtimeReloadScheduled) return;
@@ -703,6 +719,8 @@ class EditorManager {
         this.agentCommandMenu = null;
         this.agentCommandSuggestions = [];
         this.agentCommandIndex = 0;
+        this.agentCommandMenuStateKey = '';
+        this.agentCommandMenuToken = 0;
         this.isApplyingAgentPromptState = false;
         this.suppressAgentCommandMenu = false;
         this.agentEmbeddedEditors = [];
@@ -1106,6 +1124,14 @@ class EditorManager {
         });
         this.agentPrompt.addEventListener('blur', () => {
             setTimeout(() => {
+                if (
+                    document.activeElement?.classList?.contains(
+                        'xterm-helper-textarea'
+                    )
+                    && this.agentCommandSuggestions.length > 0
+                ) {
+                    return;
+                }
                 this.hideAgentCommandMenu();
             }, 120);
         });
@@ -1134,14 +1160,24 @@ class EditorManager {
                 ? state.agentTabs.get(activeTabKey)
                 : null;
 
+            if (
+                agentTab
+                && this.agentCommandSuggestions.length > 0
+                && Number.isInteger(agentTab.promptHistoryIndex)
+            ) {
+                this.exitAgentPromptHistoryBrowsing(agentTab);
+            }
+
             if (this.agentCommandSuggestions.length > 0) {
                 if (event.key === 'ArrowDown') {
                     event.preventDefault();
+                    event.stopImmediatePropagation();
                     this.moveAgentCommandSelection(1);
                     return;
                 }
                 if (event.key === 'ArrowUp') {
                     event.preventDefault();
+                    event.stopImmediatePropagation();
                     this.moveAgentCommandSelection(-1);
                     return;
                 }
@@ -1156,11 +1192,13 @@ class EditorManager {
                     )
                 ) {
                     event.preventDefault();
-                    this.applyAgentCommandSuggestion();
+                    event.stopImmediatePropagation();
+                    void this.applyAgentCommandSuggestion();
                     return;
                 }
                 if (event.key === 'Escape') {
                     event.preventDefault();
+                    event.stopImmediatePropagation();
                     this.hideAgentCommandMenu();
                     return;
                 }
@@ -1556,9 +1594,7 @@ class EditorManager {
         const hasAgentTabs = getAgentTabsForSession(this.currentSession).length > 0;
         const compact = this.hasCompactWorkspaceTabs(this.currentSession);
         const hasTabs = compact || hasOpenFiles || hasAgentTabs;
-        const shouldShow = compact
-            ? true
-            : state.isVisible || hasOpenFiles || hasAgentTabs;
+        const shouldShow = hasTabs;
 
         this.tabsContainer.style.display = hasTabs ? 'flex' : 'none';
         this.pane.style.display = shouldShow ? 'flex' : 'none';
@@ -1644,8 +1680,7 @@ class EditorManager {
         const state = session.editorState;
 
         // Only render tabs and content, file tree is persistent in sidebar
-        const shouldShowWorkspace = state.isVisible
-            || this.hasVisibleWorkspaceTabs(session);
+        const shouldShowWorkspace = this.hasVisibleWorkspaceTabs(session);
         if (shouldShowWorkspace) {
             if (state.isVisible) {
                 this.refreshSessionTree(session);
@@ -1654,8 +1689,6 @@ class EditorManager {
             const activeKey = this.getActiveWorkspaceTabKey(session);
             if (activeKey) {
                 this.activateWorkspaceTab(activeKey, true);
-            } else {
-                this.showEmptyState();
             }
         }
         
@@ -3155,6 +3188,17 @@ class EditorManager {
         const attachments = Array.isArray(agentTab.pendingAttachments)
             ? [...agentTab.pendingAttachments]
             : [];
+        const promptIntent = getAgentPromptIntent(
+            agentTab,
+            this.agentPrompt.value || ''
+        );
+        if (promptIntent.kind === 'resume') {
+            alert('Select a previous session from the /resume menu.', {
+                type: 'warning',
+                title: getAgentBaseName(agentTab)
+            });
+            return;
+        }
         if (!text && attachments.length === 0) {
             if (canAutostartQueuedAgentPrompt(agentTab)) {
                 await drainQueuedAgentPrompt(agentTab);
@@ -3329,7 +3373,21 @@ class EditorManager {
         if (this.suppressAgentCommandMenu) {
             this.hideAgentCommandMenu();
         } else {
-            this.renderAgentCommandMenu(activeAgentTab);
+            const promptValue = this.agentPrompt?.value || '';
+            const promptIntent = getAgentPromptIntent(
+                activeAgentTab,
+                promptValue
+            );
+            const nextMenuStateKey = [
+                activeAgentTab?.key || '',
+                promptIntent.kind,
+                promptValue
+            ].join('::');
+            const menuVisible = this.agentCommandMenu
+                && this.agentCommandMenu.style.display !== 'none';
+            if (!menuVisible || this.agentCommandMenuStateKey !== nextMenuStateKey) {
+                this.renderAgentCommandMenu(activeAgentTab);
+            }
         }
         if (
             activeAgentTab
@@ -3500,12 +3558,7 @@ class EditorManager {
         this.agentScrollBottomButton.style.display = shouldShow ? '' : 'none';
     }
 
-    renderAgentCommandMenu(agentTab = null) {
-        if (!this.agentCommandMenu) return;
-        const suggestions = getAgentCommandSuggestions(
-            agentTab,
-            this.agentPrompt?.value || ''
-        );
+    #renderAgentCommandSuggestions(suggestions) {
         this.agentCommandSuggestions = suggestions;
         if (suggestions.length === 0) {
             this.hideAgentCommandMenu();
@@ -3527,7 +3580,11 @@ class EditorManager {
             }
             const name = document.createElement('span');
             name.className = 'agent-command-option-name';
-            name.textContent = `/${command.name}`;
+            name.textContent = command.kind === 'resume_session'
+                ? command.displayName || command.title || command.sessionId
+                : command.kind === 'info'
+                    ? command.label || ''
+                    : `/${command.name}`;
             button.appendChild(name);
             if (command.description) {
                 const meta = document.createElement('span');
@@ -3535,12 +3592,16 @@ class EditorManager {
                 meta.textContent = command.description;
                 button.appendChild(meta);
             }
+            if (command.kind === 'info') {
+                button.disabled = true;
+            }
             button.addEventListener('mousedown', (event) => {
                 event.preventDefault();
             });
             button.addEventListener('click', () => {
+                if (command.kind === 'info') return;
                 this.agentCommandIndex = index;
-                this.applyAgentCommandSuggestion();
+                void this.applyAgentCommandSuggestion();
             });
             this.agentCommandMenu.appendChild(button);
         }
@@ -3554,10 +3615,95 @@ class EditorManager {
         }
     }
 
+    async renderAgentCommandMenu(agentTab = null) {
+        if (!this.agentCommandMenu) return;
+        const promptValue = this.agentPrompt?.value || '';
+        const token = this.agentCommandMenuToken + 1;
+        this.agentCommandMenuToken = token;
+        const intent = getAgentPromptIntent(agentTab, promptValue);
+        const menuStateKey = [
+            agentTab?.key || '',
+            intent.kind,
+            promptValue
+        ].join('::');
+
+        if (!agentTab || intent.kind === 'none' || intent.kind === 'other') {
+            this.hideAgentCommandMenu();
+            return;
+        }
+
+        if (Number.isInteger(agentTab.promptHistoryIndex)) {
+            this.exitAgentPromptHistoryBrowsing(agentTab);
+        }
+
+        if (intent.kind === 'resume') {
+            const hasLoadedResumeSuggestions = (
+                this.agentCommandMenuStateKey === menuStateKey
+                && this.agentCommandSuggestions.length > 0
+                && !(
+                    this.agentCommandSuggestions.length === 1
+                    && this.agentCommandSuggestions[0]?.kind === 'info'
+                    && /loading previous sessions/i.test(
+                        this.agentCommandSuggestions[0]?.label || ''
+                    )
+                )
+            );
+            if (hasLoadedResumeSuggestions) {
+                this.#renderAgentCommandSuggestions(
+                    this.agentCommandSuggestions
+                );
+                return;
+            }
+            this.agentCommandMenuStateKey = menuStateKey;
+            this.#renderAgentCommandSuggestions([{
+                kind: 'info',
+                label: 'Loading previous sessions…',
+                description: ''
+            }]);
+            try {
+                const sessions = await agentTab.listResumeSessions();
+                if (this.agentCommandMenuToken !== token) {
+                    return;
+                }
+                const suggestions = getAgentResumeSuggestions(
+                    agentTab,
+                    promptValue,
+                    sessions
+                );
+                if (suggestions.length === 0) {
+                    this.#renderAgentCommandSuggestions([{
+                        kind: 'info',
+                        label: 'No previous sessions found',
+                        description: ''
+                    }]);
+                    return;
+                }
+                this.#renderAgentCommandSuggestions(suggestions);
+            } catch (error) {
+                if (this.agentCommandMenuToken !== token) {
+                    return;
+                }
+                this.#renderAgentCommandSuggestions([{
+                    kind: 'info',
+                    label: 'Unable to load previous sessions',
+                    description: error?.message || ''
+                }]);
+            }
+            return;
+        }
+
+        this.agentCommandMenuStateKey = menuStateKey;
+        this.#renderAgentCommandSuggestions(
+            getAgentCommandSuggestions(agentTab, promptValue)
+        );
+    }
+
     hideAgentCommandMenu() {
         if (!this.agentCommandMenu) return;
+        this.agentCommandMenuToken += 1;
         this.agentCommandSuggestions = [];
         this.agentCommandIndex = 0;
+        this.agentCommandMenuStateKey = '';
         this.agentCommandMenu.style.display = 'none';
         this.agentCommandMenu.innerHTML = '';
     }
@@ -3568,7 +3714,7 @@ class EditorManager {
         this.agentCommandIndex = nextIndex < 0
             ? this.agentCommandSuggestions.length - 1
             : nextIndex % this.agentCommandSuggestions.length;
-        this.renderAgentCommandMenu(getActiveAgentTab());
+        this.#renderAgentCommandSuggestions(this.agentCommandSuggestions);
     }
 
     setAgentPromptValue(value, agentTab = null, options = {}) {
@@ -3739,9 +3885,40 @@ class EditorManager {
         agentTab.promptDraft = this.agentPrompt?.value || '';
     }
 
-    applyAgentCommandSuggestion() {
+    async applyAgentCommandSuggestion() {
         const command = this.agentCommandSuggestions[this.agentCommandIndex];
         if (!command) return;
+        if (command.kind === 'info') {
+            return;
+        }
+        if (command.kind === 'resume_session') {
+            const agentTab = getActiveAgentTab();
+            if (!agentTab) return;
+            const session = agentTab.getLinkedSession();
+            if (!session) return;
+            try {
+                if (command.openTabKey) {
+                    const existingTab = state.agentTabs.get(command.openTabKey);
+                    const existingSession = existingTab?.getLinkedSession() || null;
+                    if (existingTab && existingSession) {
+                        await activateAgentTab(existingSession, existingTab, {
+                            switchSession: true
+                        });
+                    } else {
+                        await resumeAgentTabFromHistory(session, agentTab, command);
+                    }
+                } else {
+                    await resumeAgentTabFromHistory(session, agentTab, command);
+                }
+                this.hideAgentCommandMenu();
+            } catch (error) {
+                alert(error.message, {
+                    type: 'error',
+                    title: getAgentBaseName(agentTab)
+                });
+            }
+            return;
+        }
         const suffix = command.inputHint
             ? ` ${command.inputHint}`
             : ' ';
@@ -5205,6 +5382,9 @@ class AgentTab {
         this.scrollToBottomOnNextRender = true;
         this.busySyncTimer = null;
         this.planHistory = [];
+        this.resumeSessions = [];
+        this.resumeSessionsLoadedAt = 0;
+        this.resumeSessionsPromise = null;
         this.update(data);
         this.connect();
     }
@@ -5224,6 +5404,7 @@ class AgentTab {
     }
 
     update(data) {
+        const previousResumeCacheKey = `${this.agentId || ''}:${this.cwd || ''}`;
         this.runtimeId = data.runtimeId || '';
         this.runtimeKey = data.runtimeKey || '';
         this.acpSessionId = data.acpSessionId || '';
@@ -5244,9 +5425,17 @@ class AgentTab {
         this.availableCommands = Array.isArray(data.availableCommands)
             ? data.availableCommands
             : [];
+        this.sessionCapabilities = normalizeAgentSessionCapabilities(
+            data.sessionCapabilities || this.sessionCapabilities
+        );
         this.configOptions = Array.isArray(data.configOptions)
             ? data.configOptions
             : [];
+        const nextResumeCacheKey = `${this.agentId || ''}:${this.cwd || ''}`;
+        if (previousResumeCacheKey !== nextResumeCacheKey) {
+            this.resumeSessions = [];
+            this.resumeSessionsLoadedAt = 0;
+        }
         const nextPlan = Array.isArray(data.plan)
             ? data.plan.map((entry) => this.#normalizePlanEntry(entry))
             : [];
@@ -5314,6 +5503,49 @@ class AgentTab {
         this.#syncBusyWatchdog();
     }
 
+    async listResumeSessions({ force = false } = {}) {
+        if (!supportsAgentResumeCommand(this)) {
+            return [];
+        }
+        if (
+            !force
+            && this.resumeSessionsLoadedAt > 0
+            && (Date.now() - this.resumeSessionsLoadedAt) < 30 * 1000
+        ) {
+            return this.resumeSessions;
+        }
+        if (this.resumeSessionsPromise) {
+            return this.resumeSessionsPromise;
+        }
+
+        this.resumeSessionsPromise = (async () => {
+            const cwd = this.cwd || this.getLinkedSession()?.cwd || '';
+            const params = new URLSearchParams({
+                agentId: this.agentId,
+                cwd
+            });
+            const response = await this.server.fetch(
+                `/api/agents/sessions?${params.toString()}`
+            );
+            if (!response.ok) {
+                await throwResponseError(
+                    response,
+                    'Failed to load previous sessions'
+                );
+            }
+            const data = await response.json();
+            this.resumeSessions = normalizeListedAgentSessions(data.sessions);
+            this.resumeSessionsLoadedAt = Date.now();
+            return this.resumeSessions;
+        })();
+
+        try {
+            return await this.resumeSessionsPromise;
+        } finally {
+            this.resumeSessionsPromise = null;
+        }
+    }
+
     connect() {
         if (!this.server.isAuthenticated) return;
         if (
@@ -5887,6 +6119,23 @@ class AgentTab {
 
     applyInventory(data) {
         const previousSession = this.getLinkedSession();
+        const previousSnapshot = JSON.stringify({
+            runtimeId: this.runtimeId || '',
+            runtimeKey: this.runtimeKey || '',
+            acpSessionId: this.acpSessionId || '',
+            agentId: this.agentId || '',
+            agentLabel: this.agentLabel || '',
+            title: this.title || '',
+            commandLabel: this.commandLabel || '',
+            terminalSessionId: this.terminalSessionId || '',
+            cwd: this.cwd || '',
+            createdAt: this.createdAt || '',
+            status: this.status || 'ready',
+            busy: !!this.busy,
+            errorMessage: this.errorMessage || '',
+            currentModeId: this.currentModeId || '',
+            sessionCapabilities: this.sessionCapabilities || null
+        });
         this.runtimeId = data.runtimeId || this.runtimeId || '';
         this.runtimeKey = data.runtimeKey || this.runtimeKey || '';
         this.acpSessionId = data.acpSessionId || this.acpSessionId || '';
@@ -5901,7 +6150,32 @@ class AgentTab {
         this.busy = typeof data.busy === 'boolean' ? data.busy : this.busy;
         this.errorMessage = data.errorMessage || this.errorMessage || '';
         this.currentModeId = data.currentModeId || this.currentModeId || '';
+        this.sessionCapabilities = normalizeAgentSessionCapabilities(
+            data.sessionCapabilities || this.sessionCapabilities
+        );
         const nextSession = this.getLinkedSession();
+        const nextSnapshot = JSON.stringify({
+            runtimeId: this.runtimeId || '',
+            runtimeKey: this.runtimeKey || '',
+            acpSessionId: this.acpSessionId || '',
+            agentId: this.agentId || '',
+            agentLabel: this.agentLabel || '',
+            title: this.title || '',
+            commandLabel: this.commandLabel || '',
+            terminalSessionId: this.terminalSessionId || '',
+            cwd: this.cwd || '',
+            createdAt: this.createdAt || '',
+            status: this.status || 'ready',
+            busy: !!this.busy,
+            errorMessage: this.errorMessage || '',
+            currentModeId: this.currentModeId || '',
+            sessionCapabilities: this.sessionCapabilities || null
+        });
+        const changed = previousSnapshot !== nextSnapshot
+            || previousSession?.key !== nextSession?.key;
+        if (!changed) {
+            return false;
+        }
         previousSession?.updateTabUI();
         if (nextSession && nextSession !== previousSession) {
             nextSession.updateTabUI();
@@ -5909,6 +6183,7 @@ class AgentTab {
         if (nextSession) {
             refreshWorkspaceIfSessionActive(nextSession);
         }
+        return true;
     }
 
     async #waitForSettled(timeoutMs = 5000) {
@@ -6455,6 +6730,27 @@ function normalizeAgentConfigOptionOptions(options) {
     return flattened;
 }
 
+function normalizeAgentSessionCapabilities(sessionCapabilities) {
+    const source = (
+        sessionCapabilities && typeof sessionCapabilities === 'object'
+    )
+        ? sessionCapabilities
+        : {};
+    return {
+        load: !!source.load,
+        list: !!source.list,
+        resume: !!source.resume,
+        fork: !!source.fork
+    };
+}
+
+function supportsAgentResumeCommand(agentTab) {
+    const capabilities = normalizeAgentSessionCapabilities(
+        agentTab?.sessionCapabilities
+    );
+    return !!(capabilities.load && capabilities.list);
+}
+
 function getAgentConfigOptionById(agentTab, configId) {
     return normalizeAgentConfigOptions(agentTab?.configOptions).find(
         (option) => option.id === configId
@@ -6555,6 +6851,7 @@ function normalizeAgentCommands(commands) {
                 : '';
             if (!name) return null;
             return {
+                kind: 'command',
                 name,
                 description: command?.description || '',
                 inputHint: command?.input?.hint || ''
@@ -6563,6 +6860,107 @@ function normalizeAgentCommands(commands) {
         .filter(Boolean);
 }
 
+function normalizeListedAgentSessions(sessions) {
+    if (!Array.isArray(sessions)) return [];
+    const normalized = sessions
+        .map((session, index) => {
+            const sessionId = String(session?.sessionId || '').trim();
+            const cwd = String(session?.cwd || '').trim();
+            if (!sessionId || !cwd) return null;
+            return {
+                kind: 'resume_session',
+                sortIndex: index,
+                sessionId,
+                cwd,
+                title: typeof session?.title === 'string'
+                    ? session.title
+                    : '',
+                updatedAt: typeof session?.updatedAt === 'string'
+                    ? session.updatedAt
+                    : '',
+                relativeUpdatedAt: typeof session?.relativeUpdatedAt === 'string'
+                    ? session.relativeUpdatedAt
+                    : ''
+            };
+        })
+        .filter(Boolean);
+    normalized.sort((left, right) => {
+        const leftTime = Date.parse(left.updatedAt || '') || 0;
+        const rightTime = Date.parse(right.updatedAt || '') || 0;
+        if (leftTime !== rightTime) {
+            return rightTime - leftTime;
+        }
+        return left.sortIndex - right.sortIndex;
+    });
+    return normalized;
+}
+
+function getOpenAgentSessionsForServer(serverId, agentId = '') {
+    const entries = Array.from(state.agentTabs.values())
+        .filter((tab) => (
+            tab.serverId === serverId
+            && (!agentId || tab.agentId === agentId)
+        ))
+        .map((tab) => [String(tab.acpSessionId || '').trim(), tab])
+        .filter(([sessionId]) => !!sessionId);
+    return new Map(entries);
+}
+
+function buildAgentResumeSessionMeta(sessionInfo) {
+    const parts = [];
+    const relativeUpdatedAt = String(
+        sessionInfo?.relativeUpdatedAt || ''
+    ).trim();
+    if (relativeUpdatedAt) {
+        parts.push(relativeUpdatedAt);
+    }
+    const timeLabel = getAgentMessageTimeLabel({
+        createdAt: sessionInfo?.updatedAt || ''
+    });
+    if (timeLabel && !relativeUpdatedAt) {
+        parts.push(timeLabel);
+    }
+    const cwd = String(sessionInfo?.cwd || '').trim();
+    if (cwd) {
+        parts.push(shortenPath(cwd, 48));
+    }
+    return parts.join(' · ');
+}
+
+function getAgentPromptIntent(agentTab, promptValue) {
+    const source = String(promptValue || '').replace(/^\s+/, '');
+    const firstLine = source.split('\n', 1)[0] || '';
+    if (!firstLine.startsWith('/')) {
+        return { kind: 'none', query: '', commandName: '' };
+    }
+    const body = firstLine.slice(1);
+    const [commandNameRaw = '', ...restParts] = body.split(/\s+/);
+    const commandName = commandNameRaw.toLowerCase();
+    const query = restParts.join(' ').trim();
+    if (!commandName) {
+        return { kind: 'commands', query: '', commandName: '' };
+    }
+    if (commandName === 'resume' && supportsAgentResumeCommand(agentTab)) {
+        return {
+            kind: 'resume',
+            query,
+            commandName
+        };
+    }
+    if (!/\s/.test(body)) {
+        return {
+            kind: 'commands',
+            query: commandName,
+            commandName
+        };
+    }
+    return {
+        kind: 'other',
+        query,
+        commandName
+    };
+}
+
 function bindSingleTapActivation(element, onActivate, options = {}) {
     if (!element || typeof onActivate !== 'function') {
         return;
@@ -6724,17 +7122,19 @@ function selectAgentMessageText(previousText, nextText) {
 }
 
 function getAgentCommandSuggestions(agentTab, promptValue) {
-    if (!agentTab?.availableCommands) return [];
-    const source = String(promptValue || '');
-    const trimmed = source.replace(/^\s+/, '');
-    const firstLine = trimmed.split('\n', 1)[0] || '';
-    if (!firstLine.startsWith('/')) return [];
-
-    const commandToken = firstLine.slice(1);
-    if (/\s/.test(commandToken)) return [];
-
-    const query = commandToken.toLowerCase();
-    const commands = normalizeAgentCommands(agentTab.availableCommands);
+    const intent = getAgentPromptIntent(agentTab, promptValue);
+    if (intent.kind !== 'commands') return [];
+
+    const commands = normalizeAgentCommands(agentTab?.availableCommands);
+    if (supportsAgentResumeCommand(agentTab)) {
+        commands.unshift({
+            kind: 'command',
+            name: 'resume',
+            description: 'Continue from a previous session',
+            inputHint: ''
+        });
+    }
+    const query = String(intent.query || '').toLowerCase();
     const ranked = commands.filter((command) => {
         const name = command.name.toLowerCase();
         return !query || name.startsWith(query) || name.includes(query);
@@ -6752,6 +7152,52 @@ function getAgentCommandSuggestions(agentTab, promptValue) {
     return ranked.slice(0, 8);
 }
 
+function getAgentResumeSuggestions(agentTab, promptValue, sessions = []) {
+    const intent = getAgentPromptIntent(agentTab, promptValue);
+    if (intent.kind !== 'resume') return [];
+    const query = String(intent.query || '').toLowerCase();
+    const openSessions = getOpenAgentSessionsForServer(
+        agentTab?.serverId,
+        agentTab?.agentId
+    );
+    const currentSessionId = String(agentTab?.acpSessionId || '').trim();
+    return normalizeListedAgentSessions(sessions)
+        .filter((session) => session.sessionId !== currentSessionId)
+        .map((session, index) => {
+            const displayName = String(
+                session.title || shortenPath(session.cwd, 36)
+            ).toLowerCase();
+            const cwd = String(session.cwd || '').toLowerCase();
+            const sessionId = String(session.sessionId || '').toLowerCase();
+            const titleMatch = !query || displayName.includes(query);
+            const otherMatch = !query || cwd.includes(query) || sessionId.includes(query);
+            return {
+                session,
+                index,
+                titleMatch,
+                matched: titleMatch || otherMatch
+            };
+        })
+        .filter(({ matched }) => matched)
+        .sort((left, right) => {
+            if (left.titleMatch !== right.titleMatch) {
+                return left.titleMatch ? -1 : 1;
+            }
+            return left.index - right.index;
+        })
+        .map(({ session }) => session)
+        .slice(0, 12)
+        .map((session) => ({
+            ...session,
+            openTabKey: openSessions.get(session.sessionId)?.key || '',
+            displayName: session.title || shortenPath(session.cwd, 36),
+            description: [
+                buildAgentResumeSessionMeta(session) || session.sessionId,
+                openSessions.has(session.sessionId) ? 'Already open' : ''
+            ].filter(Boolean).join(' · ')
+        }));
+}
+
 function getCurrentAgentModeLabel(agentTab) {
     const currentModeId = agentTab?.currentModeId || '';
     if (!currentModeId) return '';
@@ -9100,13 +9546,19 @@ function upsertAgentInventoryTab(server, data) {
     const key = makeAgentTabKey(server.id, data.id);
     const existing = state.agentTabs.get(key);
     if (existing) {
-        existing.applyInventory(data);
+        const changed = existing.applyInventory(data);
         existing.connect();
-        return existing;
+        return {
+            agentTab: existing,
+            changed
+        };
     }
     const agentTab = new AgentTab(data, server);
     state.agentTabs.set(key, agentTab);
-    return agentTab;
+    return {
+        agentTab,
+        changed: true
+    };
 }
 
 function reconcileAgentInventory(server, inventory) {
@@ -9118,8 +9570,11 @@ function reconcileAgentInventory(server, inventory) {
     const touchedSessions = new Set();
 
     for (const tabData of Array.isArray(inventory.tabs) ? inventory.tabs : []) {
-        const agentTab = upsertAgentInventoryTab(server, tabData);
+        const { agentTab, changed } = upsertAgentInventoryTab(server, tabData);
         seenKeys.add(agentTab.key);
+        if (!changed) {
+            continue;
+        }
         const session = agentTab.getLinkedSession();
         if (session) {
             touchedSessions.add(session.key);
@@ -9331,16 +9786,23 @@ async function createAgentTab(session, agentId, options = {}) {
         await throwResponseError(response, 'Failed to create agent tab');
     }
     const data = await response.json();
-    const agentTab = upsertAgentTab(session.server, data);
+    return await activateAgentTab(
+        session,
+        upsertAgentTab(session.server, data)
+    );
+}
+
+async function activateAgentTab(session, agentTab, options = {}) {
+    if (!session || !agentTab) return null;
+    const shouldSwitchSession = !!options.switchSession;
+    if (shouldSwitchSession && state.activeSessionKey !== session.key) {
+        await switchToSession(session.key, { scrollTabIntoView: true });
+    }
     session.workspaceState.activeTabKey = agentTab.key;
     noteRecentAgentTab(session, agentTab.key);
     session.saveState();
     if (state.activeSessionKey === session.key) {
-        if (editorManager.currentSession?.key !== session.key) {
-            editorManager.switchTo(session);
-        }
-        editorManager.activateAgentTab(agentTab.key);
-        editorManager.updateEditorPaneVisibility();
+        restoreWorkspaceForSession(session);
         requestAnimationFrame(() => {
             editorManager.agentPrompt?.focus();
         });
@@ -9350,6 +9812,29 @@ async function createAgentTab(session, agentId, options = {}) {
     return agentTab;
 }
 
+async function resumeAgentTabFromHistory(session, agentTab, historySession) {
+    if (!session || !agentTab || !historySession?.sessionId) return null;
+    const response = await session.server.fetch('/api/agents/tabs/resume', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            agentId: agentTab.agentId,
+            cwd: agentTab.cwd || session.cwd || session.initialCwd || '/',
+            terminalSessionId: session.id,
+            sessionId: historySession.sessionId,
+            title: historySession.title || ''
+        })
+    });
+    if (!response.ok) {
+        await throwResponseError(response, 'Failed to resume agent session');
+    }
+    const data = await response.json();
+    return await activateAgentTab(
+        session,
+        upsertAgentTab(session.server, data)
+    );
+}
+
 function getServerEndpointKey(server) {
     if (!server) return '';
     return getServerEndpointKeyFromUrl(server.baseUrl);
@@ -11686,6 +12171,52 @@ if (shortcutsModal) {
     });
 }
 
+function handleAgentCommandMenuShortcut(event) {
+    const agentCommandMenuOpen = !!(
+        editorManager?.agentCommandMenu
+        && editorManager.agentCommandMenu.style.display !== 'none'
+        && editorManager.agentCommandSuggestions.length > 0
+    );
+    const eventFromAgentPrompt = editorManager?.agentPrompt
+        && event.target === editorManager.agentPrompt;
+    if (
+        !agentCommandMenuOpen
+        || eventFromAgentPrompt
+        || event.ctrlKey
+        || event.metaKey
+        || event.altKey
+    ) {
+        return false;
+    }
+    if (event.key === 'Escape') {
+        event.preventDefault();
+        editorManager.hideAgentCommandMenu();
+        return true;
+    }
+    if (event.key === 'ArrowDown') {
+        event.preventDefault();
+        editorManager.moveAgentCommandSelection(1);
+        return true;
+    }
+    if (event.key === 'ArrowUp') {
+        event.preventDefault();
+        editorManager.moveAgentCommandSelection(-1);
+        return true;
+    }
+    if (event.key === 'Tab' || event.key === 'Enter') {
+        event.preventDefault();
+        void editorManager.applyAgentCommandSuggestion();
+        return true;
+    }
+    return false;
+}
+
+document.addEventListener('keydown', (e) => {
+    if (handleAgentCommandMenuShortcut(e)) {
+        e.stopImmediatePropagation();
+    }
+}, true);
+
 // Keyboard Shortcuts
 document.addEventListener('keydown', (e) => {
     if (