jupyterlab_claude_code_extension 1.2.26 → 1.2.34

package/lib/widget.d.ts

@@ -48,19 +48,18 @@ export declare class ClaudeCodeSessionsWidget extends Widget {
     private _cleanupParallel;
     private _resumeInTerminal;
     /**
-     * Reuse an open terminal only when it is running the conversation the
-     * caller wants; otherwise launch a fresh ``claude --resume <id>``.
+     * Reuse an open terminal only when it is POSITIVELY running the
+     * conversation the caller wants (its claude argv carries the same
+     * ``--resume``/``--session-id``); 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.
+     * A cwd-matching terminal whose conversation is UNKNOWN (claude started
+     * with ``-c``/``--continue`` or a bare ``claude``, so no id is in its argv)
+     * is never reused - it may be running a different conversation of this
+     * project, which is the switch-then-click bug. Every terminal the extension
+     * launches carries an explicit id (``--resume`` for a resume,
+     * ``--session-id`` for a new session or a fork), so an unknown terminal is
+     * necessarily one the extension did not start.
      */
     private _doResumeInTerminal;
     /** Absolute path of the file browser's current folder; falls back to the
@@ -147,11 +146,13 @@ export declare class ClaudeCodeSessionsWidget extends Widget {
      * the uuid is generated here so the forked JSONL is known up front, and
      * ``-n`` makes claude own the name: it writes the chosen name as a
      * custom-title record on its first turn and re-stamps it every turn, so
-     * it sticks even though the fork inherits the parent's title. The fork is
-     * the newest JSONL, so recency resolution makes it the row's current
-     * conversation without an explicit switch. claude writes the fork's JSONL
-     * lazily (on its first turn), so the branch appears on the next poll once
-     * it materialises - the panel cannot list a file that does not exist yet.
+     * it sticks even though the fork inherits the parent's title. The backend
+     * pins the fork as the project's current conversation at launch, so the fork
+     * becomes the row's primary the moment its JSONL lands - recency alone would
+     * not, since the actively-written parent it was branched from quickly
+     * overtakes the fork's mtime. claude writes the fork's JSONL lazily (on its
+     * first turn), so the branch appears on the next poll once it materialises -
+     * the panel cannot list a file that does not exist yet.
      */
     private _branchSession;
     /** Switch the active row's project to another conversation branch.
@@ -160,11 +161,12 @@ export declare class ClaudeCodeSessionsWidget extends Widget {
     private _switchBranch;
     /** 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. */
+     * Reuse only a terminal already running THIS conversation; otherwise launch
+     * a fresh ``claude --resume <id>``. So several branches of one project can
+     * be open independently and side by side - opening branch B never disturbs
+     * branch A's terminal, and never refocuses a terminal running a different
+     * conversation. Honours the global skip-permissions toggle like a normal
+     * resume. */
     private _openBranch;
     /** Poll fast for a freshly forked branch to materialise, then refresh.
      *

package/lib/widget.js

@@ -449,7 +449,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
         }
     }
     // -------------------------------------------------------------- terminal
-    async _resumeInTerminal(session, forceDangerous = false, strict = false) {
+    async _resumeInTerminal(session, forceDangerous = false) {
         var _a;
         // Coalesce concurrent clicks on the SAME conversation - subsequent clicks
         // attach to the in-flight promise instead of creating their own terminal.
@@ -460,28 +460,27 @@ export class ClaudeCodeSessionsWidget extends Widget {
         if (inFlight) {
             return inFlight;
         }
-        const promise = this._doResumeInTerminal(session, forceDangerous, strict).finally(() => {
+        const promise = this._doResumeInTerminal(session, forceDangerous).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>``.
+     * Reuse an open terminal only when it is POSITIVELY running the
+     * conversation the caller wants (its claude argv carries the same
+     * ``--resume``/``--session-id``); 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.
+     * A cwd-matching terminal whose conversation is UNKNOWN (claude started
+     * with ``-c``/``--continue`` or a bare ``claude``, so no id is in its argv)
+     * is never reused - it may be running a different conversation of this
+     * project, which is the switch-then-click bug. Every terminal the extension
+     * launches carries an explicit id (``--resume`` for a resume,
+     * ``--session-id`` for a new session or a fork), so an unknown terminal is
+     * necessarily one the extension did not start.
      */
-    async _doResumeInTerminal(session, forceDangerous, strict) {
+    async _doResumeInTerminal(session, forceDangerous) {
         var _a;
         try {
             // Always prefer reusing an open terminal for this conversation. The
@@ -490,25 +489,23 @@ export class ClaudeCodeSessionsWidget extends Widget {
             // 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 (most-recent terminal for this project).
+            // Reuse it only when it is running the wanted conversation.
             const cached = this._terminalsByPath.get(session.project_path);
-            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;
+            if (cached &&
+                !cached.widget.isDisposed &&
+                cached.sessionId === session.session_id) {
+                if (forceDangerous) {
+                    await this._showCloseExistingDialog();
                 }
+                this._focusTerminal(cached.widget);
+                return;
             }
             // 2. Walk every live terminal widget JL knows about.
-            const found = await this._findTerminalForCwd(session.project_path, session.session_id, strict);
+            const found = await this._findTerminalForCwd(session.project_path, session.session_id);
             if (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.
+                // Tag the cache with the OBSERVED conversation - here it equals the
+                // wanted id (the gate in _findTerminalForCwd), so a later reuse trusts
+                // a confirmed conversation rather than a wish.
                 this._terminalsByPath.set(session.project_path, {
                     widget: found.widget,
                     sessionId: (_a = found.runningId) !== null && _a !== void 0 ? _a : undefined
@@ -581,12 +578,18 @@ export class ClaudeCodeSessionsWidget extends Widget {
         if (!projectPath) {
             return;
         }
+        // Launch with a frontend-chosen session id (claude --session-id <uuid>
+        // starts a fresh session with that id) so the terminal's claude is
+        // identifiable from its argv. Reuse can then refocus this exact
+        // conversation later instead of guessing from an unknown terminal.
+        const newId = UUID.uuid4();
         const spinner = this._showLaunchSpinner();
         try {
             const launched = await requestAPI('launch-terminal', this._serverSettings, {
                 method: 'POST',
                 body: JSON.stringify({
                     project_path: projectPath,
+                    new_session_id: newId,
                     dangerously_skip_permissions: forceDangerous || this._dangerouslySkip
                 })
             });
@@ -594,11 +597,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 name: launched.terminal_name
             });
             if (widget === null || widget === void 0 ? void 0 : widget.id) {
-                // 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
+                    sessionId: newId
                 });
                 this._wireTerminalDisposal(projectPath, widget);
                 this._focusTerminal(widget);
@@ -639,7 +640,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
             }
         });
     }
-    async _findTerminalForCwd(projectPath, wantedSessionId, strict) {
+    async _findTerminalForCwd(projectPath, wantedSessionId) {
         var _a, _b, _c;
         if (!this._terminalTracker) {
             return null;
@@ -664,24 +665,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.
+                // Conversation gate: reuse ONLY a terminal we can positively confirm
+                // is running the wanted conversation. A terminal whose conversation
+                // is unknown (claude started with -c/--continue or a bare claude, so
+                // its argv carries no id) is never reused - it may be running a
+                // different conversation of this project (the switch-then-click bug).
+                // Extension launches always carry an explicit id, so an unknown
+                // terminal is necessarily foreign.
                 const runningId = (_c = data.session_id) !== null && _c !== void 0 ? _c : null;
-                const sameConversation = runningId === wantedSessionId;
-                const unknownConversation = runningId === null;
-                if (!(sameConversation || (!strict && unknownConversation))) {
+                // A missing wanted id (undefined) or an unknown running id (null) can
+                // never be a positive match - guard so neither side's "absent" value
+                // is mistaken for equality and an unknown terminal slips through.
+                if (!wantedSessionId || runningId !== wantedSessionId) {
                     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 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.
+                        // runningId equals the wanted id here (gated above), so the caller
+                        // tags its cache with a confirmed conversation id.
                         return { widget, runningId };
                     }
                 }
@@ -1449,9 +1451,10 @@ export class ClaudeCodeSessionsWidget extends Widget {
             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.
+        // Per-row "Open" launches that conversation in its own terminal (via
+        // _openBranch, reusing only a terminal already running it) 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';
@@ -1497,6 +1500,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
             const currentRow = document.createElement('div');
             currentRow.className = 'jp-ClaudeSessionsPanel-branchRow jp-mod-current';
             currentRow.title = `Session id: ${current}`;
+            // Expose the active state to assistive tech - the brand left-bar, tint
+            // and the plain "current" text are visual-only cues.
+            currentRow.setAttribute('aria-current', 'true');
             // Empty select cell keeps the name column aligned with branch rows.
             const currentSelect = document.createElement('span');
             currentSelect.className = 'jp-ClaudeSessionsPanel-branchSelectCell';
@@ -1744,11 +1750,13 @@ export class ClaudeCodeSessionsWidget extends Widget {
      * the uuid is generated here so the forked JSONL is known up front, and
      * ``-n`` makes claude own the name: it writes the chosen name as a
      * custom-title record on its first turn and re-stamps it every turn, so
-     * it sticks even though the fork inherits the parent's title. The fork is
-     * the newest JSONL, so recency resolution makes it the row's current
-     * conversation without an explicit switch. claude writes the fork's JSONL
-     * lazily (on its first turn), so the branch appears on the next poll once
-     * it materialises - the panel cannot list a file that does not exist yet.
+     * it sticks even though the fork inherits the parent's title. The backend
+     * pins the fork as the project's current conversation at launch, so the fork
+     * becomes the row's primary the moment its JSONL lands - recency alone would
+     * not, since the actively-written parent it was branched from quickly
+     * overtakes the fork's mtime. claude writes the fork's JSONL lazily (on its
+     * first turn), so the branch appears on the next poll once it materialises -
+     * the panel cannot list a file that does not exist yet.
      */
     async _branchSession(forceDangerous) {
         const session = this._activeSession;
@@ -1839,23 +1847,18 @@ 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. */
+     * Reuse only a terminal already running THIS conversation; otherwise launch
+     * a fresh ``claude --resume <id>``. So several branches of one project can
+     * be open independently and side by side - opening branch B never disturbs
+     * branch A's terminal, and never refocuses a terminal running a different
+     * conversation. 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);
+        await this._resumeInTerminal({ ...active, session_id: sessionId });
     }
     /** Poll fast for a freshly forked branch to materialise, then refresh.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_claude_code_extension",
-    "version": "1.2.26",
+    "version": "1.2.34",
     "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",

package/src/__tests__/jupyterlab_claude_code_extension.spec.ts

@@ -220,6 +220,17 @@ describe('launch spinner dismiss contract', () => {
       expect(checkboxIdx).toBeGreaterThan(currentIdx);
     });
 
+    it('current row exposes aria-current and a plain lowercase "current" label', () => {
+      const popup = (widgetSrc.match(
+        /private _showBranchPopup[\s\S]*?\n  \}/
+      ) ?? [''])[0];
+      // Programmatic active state for assistive tech (visual cues are the
+      // brand left-bar, tint and the plain word) - UX review finding.
+      expect(popup).toMatch(/setAttribute\('aria-current', 'true'\)/);
+      // The marker is plain text "current" - the boxed uppercase chip is gone.
+      expect(popup).toMatch(/badge\.textContent = 'current'/);
+    });
+
     it('checkbox is its own click zone and selection gates row switch', () => {
       const popup = (widgetSrc.match(
         /private _showBranchPopup[\s\S]*?\n  \}/
@@ -508,10 +519,11 @@ describe('launch spinner dismiss contract', () => {
 
   /**
    * Contract for conversation-aware terminal reuse and the Open Branched
-   * Conversation feature. The reuse path must refuse to focus a terminal
-   * running a DIFFERENT known conversation (the switch-then-click bug), and
-   * opening a specific branch must launch its own terminal (strict) so
-   * several branches stay open independently.
+   * Conversation feature. Reuse must refuse to focus a terminal running a
+   * DIFFERENT or UNKNOWN conversation (the switch-then-click bug, DEF-4): a
+   * terminal is reused only on a POSITIVE conversation-id match. Every
+   * extension launch carries an explicit id so its terminal is identifiable
+   * (resume -> --resume, new session / fork -> --session-id).
    */
   describe('conversation-aware reuse + open-branch contract', () => {
     const findTerm = (widgetSrc.match(
@@ -526,6 +538,9 @@ describe('launch spinner dismiss contract', () => {
     const openBranch = (widgetSrc.match(
       /private async _openBranch[\s\S]*?\n  \}/
     ) ?? [''])[0];
+    const newSession = (widgetSrc.match(
+      /private async _newSession[\s\S]*?\n  \}/
+    ) ?? [''])[0];
     const watch = (widgetSrc.match(/private _watchForBranch[\s\S]*?\n  \}/) ?? [
       ''
     ])[0];
@@ -537,32 +552,32 @@ describe('launch spinner dismiss contract', () => {
       expect(iface).toMatch(/session_id\?: string \| null/);
     });
 
-    it('_findTerminalForCwd takes the wanted id and a strict flag', () => {
+    it('_findTerminalForCwd takes the wanted id with no strict flag', () => {
       expect(findTerm).toMatch(
-        /_findTerminalForCwd\(\s*projectPath: string,\s*wantedSessionId: string \| undefined,\s*strict: boolean/
+        /_findTerminalForCwd\(\s*projectPath: string,\s*wantedSessionId: string \| undefined\s*\)/
       );
     });
 
-    it('reuse rejects a terminal running a known different conversation', () => {
-      // Same conversation, or unknown (fresh) only in lenient mode, may reuse.
+    it('reuse requires a positive conversation-id match (no lenient unknown reuse)', () => {
       expect(findTerm).toMatch(/const runningId = data\.session_id \?\? null/);
+      // The ONLY reuse condition: a truthy wanted id equal to the observed
+      // id. A missing wanted id or an unknown (null) running id never matches,
+      // so a -c/--continue or bare-claude terminal is never reused (DEF-4).
       expect(findTerm).toMatch(
-        /sameConversation = runningId === wantedSessionId/
-      );
-      expect(findTerm).toMatch(/unknownConversation = runningId === null/);
-      expect(findTerm).toMatch(
-        /if \(!\(sameConversation \|\| \(!strict && unknownConversation\)\)\) \{\s*continue;/
+        /if \(!wantedSessionId \|\| runningId !== wantedSessionId\) \{\s*continue;/
       );
+      // The old lenient/strict machinery is gone.
+      expect(findTerm).not.toMatch(/unknownConversation/);
+      expect(findTerm).not.toMatch(/strict/);
     });
 
-    it('microcache reuse is gated on the conversation id', () => {
+    it('microcache reuse is gated purely on the conversation id', () => {
       expect(doResume).toMatch(/cached\.sessionId === session\.session_id/);
-      expect(doResume).toMatch(/!strict && unknownConversation/);
+      expect(doResume).not.toMatch(/unknownConversation/);
+      expect(doResume).not.toMatch(/strict/);
     });
 
-    it('microcache is tagged with the OBSERVED running id, not the wanted one', () => {
-      // Storing the wanted id would let a later strict reuse trust a
-      // fabricated tag and focus the wrong conversation (review finding 1).
+    it('microcache is tagged with the OBSERVED running id', () => {
       expect(doResume).toMatch(
         /widget: found\.widget,\s*sessionId: found\.runningId \?\? undefined/
       );
@@ -576,16 +591,19 @@ describe('launch spinner dismiss contract', () => {
       expect(resume).toMatch(/this\._pendingByPath\.(get|set)\(key/);
     });
 
-    it('_openBranch is strict for a different branch, lenient for the current', () => {
-      // Strict on a non-current branch lands the user in THAT conversation;
-      // lenient on the current avoids a `claude --resume` "already in use"
-      // collision with a fresh terminal already running it (review finding 2).
-      expect(openBranch).toMatch(
-        /const strict = sessionId !== active\.session_id/
-      );
+    it('a new session launches with an explicit --session-id so it is identifiable', () => {
+      // DEF-4: a bare `claude` reports no id and would be wrongly reused;
+      // launching with a frontend id makes the terminal positively matchable.
+      expect(newSession).toMatch(/const newId = UUID\.uuid4\(\)/);
+      expect(newSession).toMatch(/new_session_id: newId/);
+      expect(newSession).toMatch(/sessionId: newId/);
+    });
+
+    it('_openBranch reuses only a terminal running that conversation', () => {
       expect(openBranch).toMatch(
-        /this\._resumeInTerminal\(\s*\{ \.\.\.active, session_id: sessionId \},\s*false,\s*strict\s*\)/
+        /this\._resumeInTerminal\(\{ \.\.\.active, session_id: sessionId \}\)/
       );
+      expect(openBranch).not.toMatch(/strict/);
     });
 
     it('open-branch command and submenu are wired up', () => {

package/src/widget.ts

@@ -551,8 +551,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
 
   private async _resumeInTerminal(
     session: ISession,
-    forceDangerous: boolean = false,
-    strict: boolean = false
+    forceDangerous: boolean = false
   ): Promise<void> {
     // Coalesce concurrent clicks on the SAME conversation - subsequent clicks
     // attach to the in-flight promise instead of creating their own terminal.
@@ -563,36 +562,32 @@ export class ClaudeCodeSessionsWidget extends Widget {
     if (inFlight) {
       return inFlight;
     }
-    const promise = this._doResumeInTerminal(
-      session,
-      forceDangerous,
-      strict
-    ).finally(() => {
-      this._pendingByPath.delete(key);
-    });
+    const promise = this._doResumeInTerminal(session, forceDangerous).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>``.
+   * Reuse an open terminal only when it is POSITIVELY running the
+   * conversation the caller wants (its claude argv carries the same
+   * ``--resume``/``--session-id``); 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.
+   * A cwd-matching terminal whose conversation is UNKNOWN (claude started
+   * with ``-c``/``--continue`` or a bare ``claude``, so no id is in its argv)
+   * is never reused - it may be running a different conversation of this
+   * project, which is the switch-then-click bug. Every terminal the extension
+   * launches carries an explicit id (``--resume`` for a resume,
+   * ``--session-id`` for a new session or a fork), so an unknown terminal is
+   * necessarily one the extension did not start.
    */
   private async _doResumeInTerminal(
     session: ISession,
-    forceDangerous: boolean,
-    strict: boolean
+    forceDangerous: boolean
   ): Promise<void> {
     try {
       // Always prefer reusing an open terminal for this conversation. The
@@ -602,30 +597,29 @@ export class ClaudeCodeSessionsWidget extends Widget {
       // first - we won't auto-close, won't silently reuse the wrong mode.
 
       // 1. In-memory microcache (most-recent terminal for this project).
+      // Reuse it only when it is running the wanted conversation.
       const cached = this._terminalsByPath.get(session.project_path);
-      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;
+      if (
+        cached &&
+        !cached.widget.isDisposed &&
+        cached.sessionId === session.session_id
+      ) {
+        if (forceDangerous) {
+          await this._showCloseExistingDialog();
         }
+        this._focusTerminal(cached.widget);
+        return;
       }
 
       // 2. Walk every live terminal widget JL knows about.
       const found = await this._findTerminalForCwd(
         session.project_path,
-        session.session_id,
-        strict
+        session.session_id
       );
       if (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.
+        // Tag the cache with the OBSERVED conversation - here it equals the
+        // wanted id (the gate in _findTerminalForCwd), so a later reuse trusts
+        // a confirmed conversation rather than a wish.
         this._terminalsByPath.set(session.project_path, {
           widget: found.widget,
           sessionId: found.runningId ?? undefined
@@ -702,6 +696,11 @@ export class ClaudeCodeSessionsWidget extends Widget {
     if (!projectPath) {
       return;
     }
+    // Launch with a frontend-chosen session id (claude --session-id <uuid>
+    // starts a fresh session with that id) so the terminal's claude is
+    // identifiable from its argv. Reuse can then refocus this exact
+    // conversation later instead of guessing from an unknown terminal.
+    const newId = UUID.uuid4();
     const spinner = this._showLaunchSpinner();
     try {
       const launched = await requestAPI<ILaunchTerminalResponse>(
@@ -711,6 +710,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
           method: 'POST',
           body: JSON.stringify({
             project_path: projectPath,
+            new_session_id: newId,
             dangerously_skip_permissions:
               forceDangerous || this._dangerouslySkip
           })
@@ -720,11 +720,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
         name: launched.terminal_name
       });
       if (widget?.id) {
-        // 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
+          sessionId: newId
         });
         this._wireTerminalDisposal(projectPath, widget);
         this._focusTerminal(widget);
@@ -765,8 +763,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
 
   private async _findTerminalForCwd(
     projectPath: string,
-    wantedSessionId: string | undefined,
-    strict: boolean
+    wantedSessionId: string | undefined
   ): Promise<{ widget: any; runningId: string | null } | null> {
     if (!this._terminalTracker) {
       return null;
@@ -794,24 +791,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.
+        // Conversation gate: reuse ONLY a terminal we can positively confirm
+        // is running the wanted conversation. A terminal whose conversation
+        // is unknown (claude started with -c/--continue or a bare claude, so
+        // its argv carries no id) is never reused - it may be running a
+        // different conversation of this project (the switch-then-click bug).
+        // Extension launches always carry an explicit id, so an unknown
+        // terminal is necessarily foreign.
         const runningId = data.session_id ?? null;
-        const sameConversation = runningId === wantedSessionId;
-        const unknownConversation = runningId === null;
-        if (!(sameConversation || (!strict && unknownConversation))) {
+        // A missing wanted id (undefined) or an unknown running id (null) can
+        // never be a positive match - guard so neither side's "absent" value
+        // is mistaken for equality and an unknown terminal slips through.
+        if (!wantedSessionId || runningId !== wantedSessionId) {
           continue;
         }
         const cwds = Array.isArray(data?.cwds) ? data.cwds : [];
         for (const cwd of cwds) {
           if ((cwd || '').replace(/\/+$/, '') === target) {
-            // 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.
+            // runningId equals the wanted id here (gated above), so the caller
+            // tags its cache with a confirmed conversation id.
             return { widget, runningId };
           }
         }
@@ -1671,9 +1669,10 @@ export class ClaudeCodeSessionsWidget extends Widget {
       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.
+    // Per-row "Open" launches that conversation in its own terminal (via
+    // _openBranch, reusing only a terminal already running it) 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';
@@ -1728,6 +1727,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
       const currentRow = document.createElement('div');
       currentRow.className = 'jp-ClaudeSessionsPanel-branchRow jp-mod-current';
       currentRow.title = `Session id: ${current}`;
+      // Expose the active state to assistive tech - the brand left-bar, tint
+      // and the plain "current" text are visual-only cues.
+      currentRow.setAttribute('aria-current', 'true');
       // Empty select cell keeps the name column aligned with branch rows.
       const currentSelect = document.createElement('span');
       currentSelect.className = 'jp-ClaudeSessionsPanel-branchSelectCell';
@@ -1992,11 +1994,13 @@ export class ClaudeCodeSessionsWidget extends Widget {
    * the uuid is generated here so the forked JSONL is known up front, and
    * ``-n`` makes claude own the name: it writes the chosen name as a
    * custom-title record on its first turn and re-stamps it every turn, so
-   * it sticks even though the fork inherits the parent's title. The fork is
-   * the newest JSONL, so recency resolution makes it the row's current
-   * conversation without an explicit switch. claude writes the fork's JSONL
-   * lazily (on its first turn), so the branch appears on the next poll once
-   * it materialises - the panel cannot list a file that does not exist yet.
+   * it sticks even though the fork inherits the parent's title. The backend
+   * pins the fork as the project's current conversation at launch, so the fork
+   * becomes the row's primary the moment its JSONL lands - recency alone would
+   * not, since the actively-written parent it was branched from quickly
+   * overtakes the fork's mtime. claude writes the fork's JSONL lazily (on its
+   * first turn), so the branch appears on the next poll once it materialises -
+   * the panel cannot list a file that does not exist yet.
    */
   private async _branchSession(forceDangerous: boolean): Promise<void> {
     const session = this._activeSession;
@@ -2101,27 +2105,18 @@ 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. */
+   * Reuse only a terminal already running THIS conversation; otherwise launch
+   * a fresh ``claude --resume <id>``. So several branches of one project can
+   * be open independently and side by side - opening branch B never disturbs
+   * branch A's terminal, and never refocuses a terminal running a different
+   * conversation. 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
-    );
+    await this._resumeInTerminal({ ...active, session_id: sessionId });
   }
 
   /** Poll fast for a freshly forked branch to materialise, then refresh.

package/style/base.css

@@ -522,14 +522,9 @@
 
 .jp-ClaudeSessionsPanel-branchCurrentBadge {
   flex: none;
-  padding: 0 6px;
-  border: 1px solid var(--jp-brand-color1);
-  border-radius: 8px;
-  color: var(--jp-brand-color1);
+  white-space: nowrap;
+  color: var(--jp-ui-font-color2);
   font-size: var(--jp-ui-font-size0);
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: 0.5px;
 }
 
 .jp-ClaudeSessionsPanel-branchSelectAll {