jupyterlab_claude_code_extension 1.2.24 → 1.2.26

package/lib/widget.js

@@ -7,6 +7,10 @@ import { Menu, Widget } from '@lumino/widgets';
 import { requestAPI } from './request';
 import { addIcon, branchIcon, switchIcon, claudeIcon, filterIcon, refreshIcon, removeIcon, shieldIcon, starFilledIcon } from './icons';
 const POLL_INTERVAL_MS = 30000;
+// After a fork is requested, watch for its lazily-written JSONL at this fast
+// cadence (bounded) so a new branch surfaces in seconds, not on the slow poll.
+const BRANCH_WATCH_INTERVAL_MS = 2000;
+const BRANCH_WATCH_MAX_ATTEMPTS = 90; // ~3 minutes
 const DEFAULT_RECENT_LIMIT = 10;
 const EXPANDED_STORAGE_KEY = 'jupyterlab_claude_code_extension:expanded';
 const DEFAULT_PRESENTATION_MODE = 'folder';
@@ -72,7 +76,11 @@ export class ClaudeCodeSessionsWidget extends Widget {
         this._activeRowEl = null;
         this._pollHandle = null;
         this._removingPaths = new Set();
+        // Microcache of the most-recent terminal per project, tagged with the
+        // conversation it is running so reuse can tell a project's branches apart.
         this._terminalsByPath = new Map();
+        // In-flight launches, keyed per CONVERSATION (path + session id) so two
+        // different branches of one project can open independently and concurrently.
         this._pendingByPath = new Map();
         this._presentationMode = DEFAULT_PRESENTATION_MODE;
         this._recentLimit = DEFAULT_RECENT_LIMIT;
@@ -441,44 +449,75 @@ export class ClaudeCodeSessionsWidget extends Widget {
         }
     }
     // -------------------------------------------------------------- terminal
-    async _resumeInTerminal(session, forceDangerous = false) {
-        // Coalesce concurrent clicks on the same row - subsequent clicks attach
-        // to the in-flight promise instead of creating their own terminal.
-        const inFlight = this._pendingByPath.get(session.project_path);
+    async _resumeInTerminal(session, forceDangerous = false, strict = false) {
+        var _a;
+        // Coalesce concurrent clicks on the SAME conversation - subsequent clicks
+        // attach to the in-flight promise instead of creating their own terminal.
+        // The key is per-conversation, so opening a different branch of the same
+        // project launches independently rather than coalescing onto this one.
+        const key = `${session.project_path}\n${(_a = session.session_id) !== null && _a !== void 0 ? _a : ''}`;
+        const inFlight = this._pendingByPath.get(key);
         if (inFlight) {
             return inFlight;
         }
-        const promise = this._doResumeInTerminal(session, forceDangerous).finally(() => {
-            this._pendingByPath.delete(session.project_path);
+        const promise = this._doResumeInTerminal(session, forceDangerous, strict).finally(() => {
+            this._pendingByPath.delete(key);
         });
-        this._pendingByPath.set(session.project_path, promise);
+        this._pendingByPath.set(key, promise);
         return promise;
     }
-    async _doResumeInTerminal(session, forceDangerous) {
+    /**
+     * Reuse an open terminal only when it is running the conversation the
+     * caller wants; otherwise launch a fresh ``claude --resume <id>``.
+     *
+     * ``strict`` selects how a cwd-matching claude terminal whose conversation
+     * is UNKNOWN (started fresh, no ``--resume`` in its argv) is treated:
+     * - lenient (row resume): reuse it. A fresh session's id is not in its
+     *   argv, so this is the only way to refocus a just-started session, and
+     *   it avoids ``claude --resume`` erroring with "already in use".
+     * - strict (Open Branched Conversation): never reuse an unknown terminal -
+     *   the user picked a specific branch and must land in THAT conversation,
+     *   so a fresh/foreign terminal is left alone and a new one is launched.
+     * A terminal whose resume id is KNOWN and differs is never reused in
+     * either mode - that is the switch-then-click bug this fixes.
+     */
+    async _doResumeInTerminal(session, forceDangerous, strict) {
+        var _a;
         try {
-            // Always prefer reusing an open terminal for this project. The
+            // Always prefer reusing an open terminal for this conversation. The
             // skip-permissions flag can only be applied to a fresh pty, never
             // retroactively. So if the user wants dangerous mode but an open
             // terminal already exists, show a modal asking them to close it
             // first - we won't auto-close, won't silently reuse the wrong mode.
-            // 1. In-memory microcache.
+            // 1. In-memory microcache (most-recent terminal for this project).
             const cached = this._terminalsByPath.get(session.project_path);
-            if (cached && !cached.isDisposed) {
-                if (forceDangerous) {
-                    await this._showCloseExistingDialog();
+            if (cached && !cached.widget.isDisposed) {
+                const sameConversation = cached.sessionId === session.session_id;
+                const unknownConversation = !cached.sessionId;
+                if (sameConversation || (!strict && unknownConversation)) {
+                    if (forceDangerous) {
+                        await this._showCloseExistingDialog();
+                    }
+                    this._focusTerminal(cached.widget);
+                    return;
                 }
-                this._focusTerminal(cached);
-                return;
             }
             // 2. Walk every live terminal widget JL knows about.
-            const found = await this._findTerminalForCwd(session.project_path);
+            const found = await this._findTerminalForCwd(session.project_path, session.session_id, strict);
             if (found) {
-                this._terminalsByPath.set(session.project_path, found);
-                this._wireTerminalDisposal(session.project_path, found);
+                // Tag the cache with the OBSERVED conversation (null when the reused
+                // terminal is a fresh no-resume one), not the wanted id - otherwise a
+                // later strict reuse would trust a fabricated tag and focus the wrong
+                // conversation.
+                this._terminalsByPath.set(session.project_path, {
+                    widget: found.widget,
+                    sessionId: (_a = found.runningId) !== null && _a !== void 0 ? _a : undefined
+                });
+                this._wireTerminalDisposal(session.project_path, found.widget);
                 if (forceDangerous) {
                     await this._showCloseExistingDialog();
                 }
-                this._focusTerminal(found);
+                this._focusTerminal(found.widget);
                 return;
             }
             // 3. No matching terminal - spawn a new one with `claude --resume <id>`
@@ -502,7 +541,10 @@ export class ClaudeCodeSessionsWidget extends Widget {
                     name: launched.terminal_name
                 });
                 if (widget === null || widget === void 0 ? void 0 : widget.id) {
-                    this._terminalsByPath.set(session.project_path, widget);
+                    this._terminalsByPath.set(session.project_path, {
+                        widget,
+                        sessionId: session.session_id
+                    });
                     this._wireTerminalDisposal(session.project_path, widget);
                     this._focusTerminal(widget);
                 }
@@ -552,7 +594,12 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 name: launched.terminal_name
             });
             if (widget === null || widget === void 0 ? void 0 : widget.id) {
-                this._terminalsByPath.set(projectPath, widget);
+                // A fresh session's conversation id is not in its argv, so leave
+                // sessionId undefined - reuse treats it as the project's current.
+                this._terminalsByPath.set(projectPath, {
+                    widget,
+                    sessionId: undefined
+                });
                 this._wireTerminalDisposal(projectPath, widget);
                 this._focusTerminal(widget);
             }
@@ -592,8 +639,8 @@ export class ClaudeCodeSessionsWidget extends Widget {
             }
         });
     }
-    async _findTerminalForCwd(projectPath) {
-        var _a, _b;
+    async _findTerminalForCwd(projectPath, wantedSessionId, strict) {
+        var _a, _b, _c;
         if (!this._terminalTracker) {
             return null;
         }
@@ -617,10 +664,25 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 if (!(data === null || data === void 0 ? void 0 : data.has_claude)) {
                     continue;
                 }
+                // Conversation gate: reuse only a terminal running the wanted
+                // conversation. A known, different resume id is never reused (the
+                // switch-then-click bug). An unknown id (fresh session, no --resume)
+                // is reused in lenient mode but skipped in strict mode, where the
+                // user picked a specific branch to open.
+                const runningId = (_c = data.session_id) !== null && _c !== void 0 ? _c : null;
+                const sameConversation = runningId === wantedSessionId;
+                const unknownConversation = runningId === null;
+                if (!(sameConversation || (!strict && unknownConversation))) {
+                    continue;
+                }
                 const cwds = Array.isArray(data === null || data === void 0 ? void 0 : data.cwds) ? data.cwds : [];
                 for (const cwd of cwds) {
                     if ((cwd || '').replace(/\/+$/, '') === target) {
-                        return widget;
+                        // Return the OBSERVED running id (may be null for a fresh
+                        // terminal), never the wanted id - the caller tags its cache
+                        // with this so a later strict reuse trusts the process, not a
+                        // wish.
+                        return { widget, runningId };
                     }
                 }
             }
@@ -667,7 +729,8 @@ export class ClaudeCodeSessionsWidget extends Widget {
             return;
         }
         widget.disposed.connect(() => {
-            if (this._terminalsByPath.get(projectPath) === widget) {
+            var _a;
+            if (((_a = this._terminalsByPath.get(projectPath)) === null || _a === void 0 ? void 0 : _a.widget) === widget) {
                 this._terminalsByPath.delete(projectPath);
             }
         });
@@ -1127,6 +1190,17 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 void this._showBranchPopup(this._lastBranches, this._lastBranchesCurrent);
             }
         });
+        this._commands.addCommand('claude-code-sessions:open-branch', {
+            label: args => { var _a; return String((_a = args.label) !== null && _a !== void 0 ? _a : ''); },
+            icon: terminalIcon,
+            execute: args => {
+                var _a;
+                const sessionId = String((_a = args.session_id) !== null && _a !== void 0 ? _a : '');
+                if (sessionId) {
+                    void this._openBranch(sessionId);
+                }
+            }
+        });
         this._commands.addCommand('claude-code-sessions:branch-session', {
             label: 'Normal',
             execute: () => void this._branchSession(false)
@@ -1171,6 +1245,13 @@ export class ClaudeCodeSessionsWidget extends Widget {
         this._branchSubmenu.addClass('jp-ClaudeSessionsContextMenu');
         this._branchSubmenu.title.label = 'Switch and Manage Sessions';
         this._branchSubmenu.title.icon = switchIcon;
+        // Submenu that OPENS a conversation directly in its own terminal (vs the
+        // switch submenu, which only changes which branch the row points at).
+        // Several branches can be open at once, independently.
+        this._openBranchSubmenu = new Menu({ commands: this._commands });
+        this._openBranchSubmenu.addClass('jp-ClaudeSessionsContextMenu');
+        this._openBranchSubmenu.title.label = 'Open Branched Conversation';
+        this._openBranchSubmenu.title.icon = terminalIcon;
         // Submenu grouping the two branch-session launch modes.
         this._branchSessionMenu = new Menu({ commands: this._commands });
         this._branchSessionMenu.addClass('jp-ClaudeSessionsContextMenu');
@@ -1217,6 +1298,10 @@ export class ClaudeCodeSessionsWidget extends Widget {
         });
         this._contextMenu.addItem({ type: 'separator' });
         if (withBranches) {
+            this._contextMenu.addItem({
+                type: 'submenu',
+                submenu: this._openBranchSubmenu
+            });
             this._contextMenu.addItem({
                 type: 'submenu',
                 submenu: this._branchSubmenu
@@ -1259,6 +1344,24 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 this._branchSubmenu.addItem({
                     command: 'claude-code-sessions:switch-branch-more'
                 });
+                // Open submenu: same top-5 branches, but each launches its own
+                // terminal directly. Falls through to the Manage Sessions popup for
+                // the full list (from which any conversation can also be opened).
+                this._openBranchSubmenu.clearItems();
+                this._openBranchSubmenu.title.label = `Open Branched Conversation (${data.branches.length})`;
+                for (const b of data.branches.slice(0, 5)) {
+                    this._openBranchSubmenu.addItem({
+                        command: 'claude-code-sessions:open-branch',
+                        args: {
+                            session_id: b.session_id,
+                            label: `${this._branchDisplayName(b)} - ${this._formatRelativeTime(b.file_mtime)}`
+                        }
+                    });
+                }
+                this._openBranchSubmenu.addItem({ type: 'separator' });
+                this._openBranchSubmenu.addItem({
+                    command: 'claude-code-sessions:switch-branch-more'
+                });
                 hasBranches = data.branches.length > 0;
             }
             catch (_a) {
@@ -1292,6 +1395,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
         // Local working copy so deletions can refresh the list in place.
         let items = [...branches];
         const selected = new Set();
+        let deleting = false; // guards the async delete against double-invocation
         const body = document.createElement('div');
         body.className = 'jp-ClaudeSessionsPanel-branchPopup';
         const search = document.createElement('input');
@@ -1299,28 +1403,68 @@ export class ClaudeCodeSessionsWidget extends Widget {
         search.placeholder = 'Filter sessions...';
         search.className = 'jp-ClaudeSessionsPanel-branchSearch';
         body.appendChild(search);
+        // Table header strip: select-all on the left, conversation count right.
+        const header = document.createElement('div');
+        header.className = 'jp-ClaudeSessionsPanel-branchHeader';
         const selectAllBar = document.createElement('label');
         selectAllBar.className = 'jp-ClaudeSessionsPanel-branchSelectAll';
         const selectAll = document.createElement('input');
         selectAll.type = 'checkbox';
         selectAllBar.appendChild(selectAll);
         selectAllBar.appendChild(document.createTextNode('Select all'));
-        body.appendChild(selectAllBar);
+        header.appendChild(selectAllBar);
+        const countEl = document.createElement('span');
+        countEl.className = 'jp-ClaudeSessionsPanel-branchHeaderCount';
+        header.appendChild(countEl);
+        body.appendChild(header);
         const list = document.createElement('div');
         list.className = 'jp-ClaudeSessionsPanel-branchList';
+        // role=group makes the aria-label apply to the conversation list region.
+        list.setAttribute('role', 'group');
+        list.setAttribute('aria-label', 'Conversations');
         body.appendChild(list);
         const footer = document.createElement('div');
         footer.className = 'jp-ClaudeSessionsPanel-branchFooter';
+        // Plain visual counter (selection or last action). The screen-reader
+        // announcement lives in a separate live region (srLive) so per-checkbox
+        // ticks are not announced on top of the native checkbox.
+        const selCount = document.createElement('span');
+        selCount.className = 'jp-ClaudeSessionsPanel-branchSelCount';
+        footer.appendChild(selCount);
         const deleteBtn = document.createElement('button');
+        deleteBtn.type = 'button';
         deleteBtn.className = 'jp-ClaudeSessionsPanel-branchDelete';
+        deleteBtn.title = 'Deleted conversations move to the trash (recoverable)';
         footer.appendChild(deleteBtn);
         body.appendChild(footer);
+        // Visually-hidden polite live region, announced only on delete.
+        const srLive = document.createElement('div');
+        srLive.className = 'jp-ClaudeSessionsPanel-srOnly';
+        srLive.setAttribute('role', 'status');
+        srLive.setAttribute('aria-live', 'polite');
+        body.appendChild(srLive);
         const bodyWidget = new Widget({ node: body });
         const dialog = new Dialog({
-            title: 'Switch and Manage Sessions',
+            title: 'Manage Sessions',
             body: bodyWidget,
             buttons: [Dialog.cancelButton()]
         });
+        // Per-row "Open" launches that conversation in its own terminal (strict
+        // reuse via _openBranch) and closes the popup. stopPropagation keeps the
+        // click from toggling selection or switching the row.
+        const openButton = (sessionId) => {
+            const btn = document.createElement('button');
+            btn.type = 'button';
+            btn.className = 'jp-ClaudeSessionsPanel-branchOpen';
+            btn.textContent = 'Open';
+            btn.title = 'Open this conversation in its own terminal';
+            btn.addEventListener('click', e => {
+                e.stopPropagation();
+                dialog.dispose();
+                void this._openBranch(sessionId);
+            });
+            return btn;
+        };
         const visibleMatches = () => {
             const needle = search.value.trim().toLowerCase();
             return items.filter(b => !needle ||
@@ -1328,9 +1472,18 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 b.session_id.toLowerCase().includes(needle));
         };
         const updateControls = () => {
-            deleteBtn.disabled = selected.size === 0;
-            deleteBtn.textContent = `Delete (${selected.size})`;
+            deleteBtn.disabled = deleting || selected.size === 0;
+            deleteBtn.textContent = deleting
+                ? 'Deleting...'
+                : `Delete (${selected.size})`;
+            selCount.textContent = selected.size ? `${selected.size} selected` : '';
+            selCount.classList.remove('jp-mod-deleted');
             const visible = visibleMatches();
+            const total = items.length + 1; // + the pinned current conversation
+            const shown = visible.length + 1; // the current row is always shown
+            countEl.textContent = search.value.trim()
+                ? `${shown} of ${total}`
+                : `${total} conversation${total === 1 ? '' : 's'}`;
             const visibleSelected = visible.filter(b => selected.has(b.session_id)).length;
             selectAll.checked =
                 visible.length > 0 && visibleSelected === visible.length;
@@ -1344,6 +1497,10 @@ export class ClaudeCodeSessionsWidget extends Widget {
             const currentRow = document.createElement('div');
             currentRow.className = 'jp-ClaudeSessionsPanel-branchRow jp-mod-current';
             currentRow.title = `Session id: ${current}`;
+            // Empty select cell keeps the name column aligned with branch rows.
+            const currentSelect = document.createElement('span');
+            currentSelect.className = 'jp-ClaudeSessionsPanel-branchSelectCell';
+            currentRow.appendChild(currentSelect);
             const currentLabel = document.createElement('span');
             currentLabel.className = 'jp-ClaudeSessionsPanel-branchLabel';
             const currentName = this._activeSession
@@ -1355,6 +1512,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
             badge.className = 'jp-ClaudeSessionsPanel-branchCurrentBadge';
             badge.textContent = 'current';
             currentRow.appendChild(badge);
+            currentRow.appendChild(openButton(current));
             currentRow.appendChild(this._branchCopyButton(current));
             list.appendChild(currentRow);
             const matches = visibleMatches();
@@ -1371,12 +1529,21 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 const row = document.createElement('div');
                 row.className = 'jp-ClaudeSessionsPanel-branchRow';
                 row.title = `Session id: ${b.session_id}`;
+                const selectCell = document.createElement('span');
+                selectCell.className = 'jp-ClaudeSessionsPanel-branchSelectCell';
                 const check = document.createElement('input');
                 check.type = 'checkbox';
                 check.checked = selected.has(b.session_id);
+                check.setAttribute('aria-label', `Select ${this._branchDisplayName(b)}`);
                 // The checkbox is its own click zone - ticking must not switch.
                 check.addEventListener('click', e => {
                     e.stopPropagation();
+                    if (deleting) {
+                        // Keyboard Space isn't blocked by the busy scrim's pointer-events;
+                        // re-sync the native toggle on the next render.
+                        check.checked = selected.has(b.session_id);
+                        return;
+                    }
                     if (check.checked) {
                         selected.add(b.session_id);
                     }
@@ -1385,7 +1552,16 @@ export class ClaudeCodeSessionsWidget extends Widget {
                     }
                     updateControls();
                 });
-                row.appendChild(check);
+                selectCell.appendChild(check);
+                // The whole cell is a select target (>=24px), not just the checkbox;
+                // clicking the padding toggles via the checkbox's own handler.
+                selectCell.addEventListener('click', e => {
+                    if (e.target !== check) {
+                        e.stopPropagation();
+                        check.click();
+                    }
+                });
+                row.appendChild(selectCell);
                 const label = document.createElement('span');
                 label.className = 'jp-ClaudeSessionsPanel-branchLabel';
                 label.textContent = this._branchDisplayName(b);
@@ -1394,6 +1570,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 time.className = 'jp-ClaudeSessionsPanel-branchTime';
                 time.textContent = this._formatRelativeTime(b.file_mtime);
                 row.appendChild(time);
+                row.appendChild(openButton(b.session_id));
                 row.appendChild(this._branchCopyButton(b.session_id));
                 row.addEventListener('click', () => {
                     // Selection mode: while anything is ticked, row clicks toggle
@@ -1416,6 +1593,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
             }
         };
         selectAll.addEventListener('change', () => {
+            if (deleting) {
+                return;
+            }
             // Select-all acts on the visible (filtered) rows only.
             const visible = visibleMatches();
             if (selectAll.checked) {
@@ -1427,33 +1607,100 @@ export class ClaudeCodeSessionsWidget extends Widget {
             render();
             updateControls();
         });
+        // Busy-lock the whole body (button + list) during the async delete so a
+        // slow backend cannot be double-clicked into deleting the same set twice
+        // and a mid-flight selection cannot be silently discarded.
+        const setDeleting = (on) => {
+            deleting = on;
+            // Scrim the whole popup body (search, select-all, list) so nothing can
+            // be re-ticked or re-triggered mid-flight; the Dialog's Cancel button
+            // sits outside the body and stays usable. aria-busy goes on the live
+            // list region, not the (disabled, unannounced) button.
+            body.classList.toggle('jp-mod-busy', on);
+            if (on) {
+                list.setAttribute('aria-busy', 'true');
+            }
+            else {
+                list.removeAttribute('aria-busy');
+            }
+        };
         deleteBtn.addEventListener('click', () => {
-            if (selected.size === 0) {
+            if (deleting || selected.size === 0) {
                 return;
             }
-            const n = selected.size;
-            void showDialog({
-                title: 'Delete Sessions',
-                body: `Delete ${n} session${n === 1 ? '' : 's'} from "${this._activeSession ? this._lookupName(this._activeSession) : ''}"? ` +
-                    'They are moved to trash. This cannot be undone.',
-                buttons: [Dialog.cancelButton(), Dialog.warnButton({ label: 'Delete' })]
-            }).then(confirm => {
-                if (!confirm.button.accept) {
+            // No confirmation here: deletions move to trash (recoverable), and a
+            // second Lumino dialog stacked on this popup renders detached. The only
+            // confirmed destructive actions are Clean Up Parallel Sessions and
+            // Remove from Claude (whole-project / bulk). Feedback is given instead
+            // of a prompt: a live "N moved to trash" status (a failure still toasts
+            // via _deleteBranches).
+            setDeleting(true);
+            updateControls();
+            void this._deleteBranches([...selected])
+                .then(async (deleted) => {
+                if (deleted === null) {
+                    setDeleting(false);
+                    updateControls(); // re-enable; selection unchanged
                     return;
                 }
-                void this._deleteBranches([...selected]).then(deleted => {
-                    if (deleted === null) {
-                        return;
+                // Re-sync from disk truth, not an optimistic splice: a branch the
+                // backend skipped (it became the resolved-current, or was already
+                // gone) must not vanish from the list while it still exists.
+                const session = this._activeSession;
+                try {
+                    if (!session) {
+                        throw new Error('no active session');
                     }
+                    const fresh = await requestAPI(`sessions/branches?encoded_path=${encodeURIComponent(session.encoded_path)}`, this._serverSettings, { cache: 'no-store' });
+                    items = fresh.branches;
+                }
+                catch (_a) {
+                    // Refetch failed (rare): optimistic removal. The announced count
+                    // may then differ from rows removed if the backend skipped one;
+                    // the panel's own _fetch (in _deleteBranches) reconciles on disk.
                     items = items.filter(b => !selected.has(b.session_id));
-                    selected.clear();
-                    this._lastBranches = items;
-                    render();
+                }
+                // The user may have closed the popup during the refetch await - don't
+                // touch shared state or a detached DOM in that case.
+                if (!bodyWidget.isAttached) {
+                    return;
+                }
+                setDeleting(false);
+                selected.clear();
+                this._lastBranches = items;
+                render();
+                updateControls();
+                // Feedback (no prompt): a perceivable counter + a polite SR
+                // announcement of the actual number the backend moved to trash.
+                const moved = `${deleted} moved to trash`;
+                selCount.textContent = moved;
+                selCount.classList.add('jp-mod-deleted');
+                // Clear then re-set on the next tick so an identical count (two
+                // single deletes in a row) is still re-announced by aria-live.
+                srLive.textContent = '';
+                window.setTimeout(() => {
+                    srLive.textContent = moved;
+                }, 60);
+                // Keep focus inside the dialog (render() destroyed the focused row).
+                // Focus the select-all checkbox (a real control with a reliable
+                // keyboard ring), unless the user is still typing in the search box.
+                if (document.activeElement !== search) {
+                    selectAll.focus();
+                }
+            })
+                .catch(() => {
+                // Defensive: never leave the button stuck disabled if the chain
+                // rejects unexpectedly.
+                if (bodyWidget.isAttached) {
+                    setDeleting(false);
                     updateControls();
-                });
+                }
             });
         });
         search.addEventListener('input', () => {
+            if (deleting) {
+                return;
+            }
             render();
             updateControls();
         });
@@ -1534,7 +1781,12 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 name: launched.terminal_name
             });
             if (widget === null || widget === void 0 ? void 0 : widget.id) {
-                this._terminalsByPath.set(session.project_path, widget);
+                // The terminal runs the FORK (forkId), so tag it with that id - a
+                // later click on the now-current forked row reuses this terminal.
+                this._terminalsByPath.set(session.project_path, {
+                    widget,
+                    sessionId: forkId
+                });
                 this._wireTerminalDisposal(session.project_path, widget);
                 this._focusTerminal(widget);
             }
@@ -1547,8 +1799,10 @@ export class ClaudeCodeSessionsWidget extends Widget {
             spinner.dispose();
         }
         // No post-hoc title write: claude owns the name via ``-n`` and stamps it
-        // on the fork's first turn. The branch surfaces on the next poll once
-        // claude materialises its JSONL.
+        // on the fork's first turn. claude materialises the fork's JSONL lazily,
+        // so watch for it at a fast cadence and refresh the moment it appears -
+        // the branch surfaces in seconds instead of on the next slow poll.
+        this._watchForBranch(session.encoded_path, forkId);
     }
     /** Switch the active row's project to another conversation branch.
      * The backend touches the branch JSONL's mtime; a refresh then shows
@@ -1583,6 +1837,60 @@ export class ClaudeCodeSessionsWidget extends Widget {
             await this._fetch();
         }
     }
+    /** Open a specific conversation branch in its own terminal.
+     *
+     * Strict reuse: only a terminal already running THIS conversation is
+     * refocused; otherwise a fresh ``claude --resume <id>`` is launched. So
+     * several branches of one project can be open independently and side by
+     * side - opening branch B never disturbs branch A's terminal. Honours the
+     * global skip-permissions toggle like a normal resume. */
+    async _openBranch(sessionId) {
+        const active = this._activeSession;
+        if (!active || !sessionId) {
+            return;
+        }
+        // Opening the row's CURRENT conversation behaves like a normal row resume
+        // (lenient): a fresh terminal already running it is reused, avoiding a
+        // `claude --resume` "already in use" collision. Opening a DIFFERENT branch
+        // is strict so the user lands in that specific conversation, even if some
+        // other (fresh) terminal sits at the same cwd.
+        const strict = sessionId !== active.session_id;
+        await this._resumeInTerminal({ ...active, session_id: sessionId }, false, strict);
+    }
+    /** Poll fast for a freshly forked branch to materialise, then refresh.
+     *
+     * claude writes a forked session's JSONL lazily (on its first turn), so a
+     * just-requested branch does not exist at launch and would otherwise only
+     * surface on the next 30s poll. This watches the project's branch list
+     * every ``BRANCH_WATCH_INTERVAL_MS`` until ``forkId`` appears (as current
+     * or in the list) - then does one full refresh and stops - or until a
+     * bounded number of attempts elapses. The panel is never updated before
+     * the branch genuinely exists. */
+    _watchForBranch(encodedPath, forkId) {
+        let attempts = 0;
+        const tick = async () => {
+            if (this.isDisposed) {
+                return;
+            }
+            attempts += 1;
+            try {
+                const data = await requestAPI(`sessions/branches?encoded_path=${encodeURIComponent(encodedPath)}`, this._serverSettings, { cache: 'no-store' });
+                const appeared = data.current === forkId ||
+                    data.branches.some(b => b.session_id === forkId);
+                if (appeared) {
+                    await this._fetch();
+                    return;
+                }
+            }
+            catch (_a) {
+                // Transient failure - keep watching until the attempt budget runs out.
+            }
+            if (attempts < BRANCH_WATCH_MAX_ATTEMPTS) {
+                window.setTimeout(() => void tick(), BRANCH_WATCH_INTERVAL_MS);
+            }
+        };
+        window.setTimeout(() => void tick(), BRANCH_WATCH_INTERVAL_MS);
+    }
     // --------------------------------------------------------------- polling
     _startPolling() {
         if (this._pollHandle !== null) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_claude_code_extension",
-    "version": "1.2.24",
+    "version": "1.2.26",
     "description": "Browse, resume, and manage your Claude Code CLI sessions from a JupyterLab side panel. One click reactivates the right terminal - no duplicate tabs, live remote-control indicator, and favourites for the projects you keep coming back to.",
     "keywords": [
         "jupyter",