jupyterlab_claude_code_extension 1.2.24 → 1.2.26

package/src/widget.ts

@@ -41,6 +41,10 @@ import {
 } from './types';
 
 const POLL_INTERVAL_MS = 30_000;
+// 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 = 2_000;
+const BRANCH_WATCH_MAX_ATTEMPTS = 90; // ~3 minutes
 const DEFAULT_RECENT_LIMIT = 10;
 const EXPANDED_STORAGE_KEY = 'jupyterlab_claude_code_extension:expanded';
 
@@ -97,6 +101,9 @@ interface ITerminalCwdResponse {
   terminal_name: string;
   cwds: string[];
   has_claude: boolean;
+  // Conversation id the running claude is resuming, or null for a fresh
+  // (non-resumed) session. Lets reuse tell branches of one project apart.
+  session_id?: string | null;
 }
 
 // Drop any pre-v0.6.18 localStorage entries from previous schemes - they
@@ -544,53 +551,90 @@ export class ClaudeCodeSessionsWidget extends Widget {
 
   private async _resumeInTerminal(
     session: ISession,
-    forceDangerous: boolean = false
+    forceDangerous: boolean = false,
+    strict: boolean = false
   ): Promise<void> {
-    // 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);
+    // 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${session.session_id ?? ''}`;
+    const inFlight = this._pendingByPath.get(key);
     if (inFlight) {
       return inFlight;
     }
-    const promise = this._doResumeInTerminal(session, forceDangerous).finally(
-      () => {
-        this._pendingByPath.delete(session.project_path);
-      }
-    );
-    this._pendingByPath.set(session.project_path, promise);
+    const promise = this._doResumeInTerminal(
+      session,
+      forceDangerous,
+      strict
+    ).finally(() => {
+      this._pendingByPath.delete(key);
+    });
+    this._pendingByPath.set(key, promise);
     return promise;
   }
 
+  /**
+   * 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.
+   */
   private async _doResumeInTerminal(
     session: ISession,
-    forceDangerous: boolean
+    forceDangerous: boolean,
+    strict: boolean
   ): Promise<void> {
     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: found.runningId ?? undefined
+        });
+        this._wireTerminalDisposal(session.project_path, found.widget);
         if (forceDangerous) {
           await this._showCloseExistingDialog();
         }
-        this._focusTerminal(found);
+        this._focusTerminal(found.widget);
         return;
       }
 
@@ -620,7 +664,10 @@ export class ClaudeCodeSessionsWidget extends Widget {
           name: launched.terminal_name
         });
         if (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);
         }
@@ -673,7 +720,12 @@ export class ClaudeCodeSessionsWidget extends Widget {
         name: launched.terminal_name
       });
       if (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);
       }
@@ -711,7 +763,11 @@ export class ClaudeCodeSessionsWidget extends Widget {
     });
   }
 
-  private async _findTerminalForCwd(projectPath: string): Promise<any | null> {
+  private async _findTerminalForCwd(
+    projectPath: string,
+    wantedSessionId: string | undefined,
+    strict: boolean
+  ): Promise<{ widget: any; runningId: string | null } | null> {
     if (!this._terminalTracker) {
       return null;
     }
@@ -738,10 +794,25 @@ export class ClaudeCodeSessionsWidget extends Widget {
         if (!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 = data.session_id ?? null;
+        const sameConversation = runningId === wantedSessionId;
+        const unknownConversation = runningId === null;
+        if (!(sameConversation || (!strict && unknownConversation))) {
+          continue;
+        }
         const cwds = Array.isArray(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 };
           }
         }
       } catch (_err) {
@@ -792,7 +863,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
       return;
     }
     widget.disposed.connect(() => {
-      if (this._terminalsByPath.get(projectPath) === widget) {
+      if (this._terminalsByPath.get(projectPath)?.widget === widget) {
         this._terminalsByPath.delete(projectPath);
       }
     });
@@ -1311,6 +1382,17 @@ export class ClaudeCodeSessionsWidget extends Widget {
       }
     });
 
+    this._commands.addCommand('claude-code-sessions:open-branch', {
+      label: args => String(args.label ?? ''),
+      icon: terminalIcon,
+      execute: args => {
+        const sessionId = String(args.session_id ?? '');
+        if (sessionId) {
+          void this._openBranch(sessionId);
+        }
+      }
+    });
+
     this._commands.addCommand('claude-code-sessions:branch-session', {
       label: 'Normal',
       execute: () => void this._branchSession(false)
@@ -1362,6 +1444,14 @@ export class ClaudeCodeSessionsWidget extends Widget {
     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');
@@ -1411,6 +1501,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
@@ -1462,6 +1556,25 @@ 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 {
         hasBranches = false;
@@ -1496,6 +1609,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
     // Local working copy so deletions can refresh the list in place.
     let items = [...branches];
     const selected = new Set<string>();
+    let deleting = false; // guards the async delete against double-invocation
 
     const body = document.createElement('div');
     body.className = 'jp-ClaudeSessionsPanel-branchPopup';
@@ -1506,32 +1620,74 @@ export class ClaudeCodeSessionsWidget extends Widget {
     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: string): HTMLButtonElement => {
+      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 = (): IBranch[] => {
       const needle = search.value.trim().toLowerCase();
       return items.filter(
@@ -1543,9 +1699,18 @@ export class ClaudeCodeSessionsWidget extends Widget {
     };
 
     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;
@@ -1563,6 +1728,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
@@ -1574,6 +1743,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);
 
@@ -1592,12 +1762,24 @@ export class ClaudeCodeSessionsWidget extends Widget {
         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);
           } else {
@@ -1605,7 +1787,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';
@@ -1617,6 +1808,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
         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', () => {
@@ -1640,6 +1832,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) {
@@ -1651,35 +1846,104 @@ export class ClaudeCodeSessionsWidget extends Widget {
       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: boolean) => {
+      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) {
-          return;
-        }
-        void this._deleteBranches([...selected]).then(deleted => {
+      // 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;
+          }
+          // 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<IBranchesResponse>(
+              `sessions/branches?encoded_path=${encodeURIComponent(session.encoded_path)}`,
+              this._serverSettings,
+              { cache: 'no-store' }
+            );
+            items = fresh.branches;
+          } catch {
+            // 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));
+          }
+          // 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;
           }
-          items = items.filter(b => !selected.has(b.session_id));
+          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();
     });
@@ -1770,7 +2034,12 @@ export class ClaudeCodeSessionsWidget extends Widget {
         name: launched.terminal_name
       });
       if (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);
       }
@@ -1781,8 +2050,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.
@@ -1828,6 +2099,70 @@ export class ClaudeCodeSessionsWidget extends Widget {
     }
   }
 
+  /** 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. */
+  private async _openBranch(sessionId: string): Promise<void> {
+    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. */
+  private _watchForBranch(encodedPath: string, forkId: string): void {
+    let attempts = 0;
+    const tick = async (): Promise<void> => {
+      if (this.isDisposed) {
+        return;
+      }
+      attempts += 1;
+      try {
+        const data = await requestAPI<IBranchesResponse>(
+          `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 {
+        // 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
 
   private _startPolling(): void {
@@ -1862,6 +2197,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
   private _commands!: CommandRegistry;
   private _contextMenu!: Menu;
   private _branchSubmenu!: Menu;
+  private _openBranchSubmenu!: Menu;
   private _branchSessionMenu!: Menu;
   private _lastBranches: IBranch[] = [];
   private _lastBranchesCurrent = '';
@@ -1872,7 +2208,14 @@ export class ClaudeCodeSessionsWidget extends Widget {
   private readonly _removingPaths: Set<string> = new Set();
   private readonly _terminalTracker: ITerminalTracker | null;
   private readonly _fileBrowser: IDefaultFileBrowser | null;
-  private readonly _terminalsByPath: Map<string, any> = new Map();
+  // Microcache of the most-recent terminal per project, tagged with the
+  // conversation it is running so reuse can tell a project's branches apart.
+  private readonly _terminalsByPath: Map<
+    string,
+    { widget: any; sessionId?: string }
+  > = new Map();
+  // In-flight launches, keyed per CONVERSATION (path + session id) so two
+  // different branches of one project can open independently and concurrently.
   private readonly _pendingByPath: Map<string, Promise<void>> = new Map();
   private readonly _rootDir: string;
   private _presentationMode: PresentationMode = DEFAULT_PRESENTATION_MODE;