jupyterlab_claude_code_extension 1.2.44 → 1.2.48

package/lib/widget.d.ts

@@ -114,7 +114,19 @@ export declare class ClaudeCodeSessionsWidget extends Widget {
      * matching path so a nested project wins over its parent. Returns null (clear)
      * when no row matches or the matched row has no colour. */
     private _colourForTerminal;
-    private _findTerminalForCwd;
+    /** Find an open terminal running the wanted conversation, or null.
+     *
+     * Matches on the conversation id ALONE. The backend reads each terminal's
+     * true session id from the running claude (`~/.claude/sessions/<pid>.json`),
+     * so a bare `claude` / `-c` the user opened is identified too, not only
+     * extension launches that carry an argv id. A session id is globally unique
+     * to one conversation, so a terminal running it IS the one to focus -
+     * regardless of its reported cwd (a claude that cd'd into a subdir, or whose
+     * project dir was recreated, must still be reused, not duplicated). Reuse
+     * stays strict on identity: a terminal whose running session cannot be read
+     * (no claude, or an unreadable id) reports null, which never equals a wanted
+     * id, so a DIFFERENT conversation is never focused by mistake (DEF-4). */
+    private _findTerminalForSession;
     private _showCloseExistingDialog;
     /** Show a modal with a spinner while the terminal is being launched. The
      * caller must dismiss it via ``.dispose()`` once the work is done - the

package/lib/widget.js

@@ -520,11 +520,11 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 return;
             }
             // 2. Walk every live terminal widget JL knows about.
-            const found = await this._findTerminalForCwd(session.project_path, session.session_id);
+            const found = await this._findTerminalForSession(session.session_id);
             if (found) {
                 // 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.
+                // wanted id (the gate in _findTerminalForSession), 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
@@ -758,9 +758,21 @@ export class ClaudeCodeSessionsWidget extends Widget {
         }
         return best ? ((_b = best.color) !== null && _b !== void 0 ? _b : null) : null;
     }
-    async _findTerminalForCwd(projectPath, wantedSessionId) {
+    /** Find an open terminal running the wanted conversation, or null.
+     *
+     * Matches on the conversation id ALONE. The backend reads each terminal's
+     * true session id from the running claude (`~/.claude/sessions/<pid>.json`),
+     * so a bare `claude` / `-c` the user opened is identified too, not only
+     * extension launches that carry an argv id. A session id is globally unique
+     * to one conversation, so a terminal running it IS the one to focus -
+     * regardless of its reported cwd (a claude that cd'd into a subdir, or whose
+     * project dir was recreated, must still be reused, not duplicated). Reuse
+     * stays strict on identity: a terminal whose running session cannot be read
+     * (no claude, or an unreadable id) reports null, which never equals a wanted
+     * id, so a DIFFERENT conversation is never focused by mistake (DEF-4). */
+    async _findTerminalForSession(wantedSessionId) {
         var _a, _b, _c;
-        if (!this._terminalTracker) {
+        if (!this._terminalTracker || !wantedSessionId) {
             return null;
         }
         const candidates = [];
@@ -769,7 +781,6 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 candidates.push(widget);
             }
         });
-        const target = projectPath.replace(/\/+$/, '');
         for (const widget of candidates) {
             const sessName = (_b = (_a = widget === null || widget === void 0 ? void 0 : widget.content) === null || _a === void 0 ? void 0 : _a.session) === null || _b === void 0 ? void 0 : _b.name;
             if (typeof sessName !== 'string' || !sessName) {
@@ -777,33 +788,13 @@ export class ClaudeCodeSessionsWidget extends Widget {
             }
             try {
                 const data = await requestAPI(`terminal-cwd/${encodeURIComponent(sessName)}`, this._serverSettings);
-                // Only reuse terminals that actually have claude running. Otherwise
-                // a plain bash opened at the project cwd would be matched and
-                // activated, swallowing the resume click without spawning claude.
-                if (!(data === null || data === void 0 ? void 0 : data.has_claude)) {
-                    continue;
-                }
-                // 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;
-                // 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) {
-                        // runningId equals the wanted id here (gated above), so the caller
-                        // tags its cache with a confirmed conversation id.
-                        return { widget, runningId };
-                    }
+                // Positive identity match on the running conversation. The backend
+                // reports a session id only for a live claude, so a match implies
+                // has_claude - the id alone is the gate, and the terminal's cwd is
+                // irrelevant once its conversation is positively known.
+                const runningId = (_c = data === null || data === void 0 ? void 0 : data.session_id) !== null && _c !== void 0 ? _c : null;
+                if (runningId === wantedSessionId) {
+                    return { widget, runningId };
                 }
             }
             catch (_err) {

package/package.json

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

@@ -522,13 +522,15 @@ describe('launch spinner dismiss contract', () => {
    * Contract for conversation-aware terminal reuse and the Open Branched
    * 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).
+   * terminal is reused only on a POSITIVE conversation-id match. The backend
+   * reads each terminal's true session id from the running claude's own
+   * `~/.claude/sessions/<pid>.json`, so a terminal the user opened with a bare
+   * `claude` / `-c` is identifiable too - reuse is not limited to extension
+   * launches that carry an id in argv.
    */
   describe('conversation-aware reuse + open-branch contract', () => {
     const findTerm = (widgetSrc.match(
-      /private async _findTerminalForCwd[\s\S]*?\n  \}/
+      /private async _findTerminalForSession[\s\S]*?\n  \}/
     ) ?? [''])[0];
     const doResume = (widgetSrc.match(
       /private async _doResumeInTerminal[\s\S]*?\n  \}/
@@ -553,19 +555,30 @@ describe('launch spinner dismiss contract', () => {
       expect(iface).toMatch(/session_id\?: string \| null/);
     });
 
-    it('_findTerminalForCwd takes the wanted id with no strict flag', () => {
+    it('_findTerminalForSession keys on the session id alone (no cwd param)', () => {
       expect(findTerm).toMatch(
-        /_findTerminalForCwd\(\s*projectPath: string,\s*wantedSessionId: string \| undefined\s*\)/
+        /_findTerminalForSession\(\s*wantedSessionId: string \| undefined\s*\)/
       );
+      // A missing wanted id short-circuits so null never matches null.
+      expect(findTerm).toMatch(
+        /if \(!this\._terminalTracker \|\| !wantedSessionId\)/
+      );
+      // Reuse is identity-only now - it must NOT gate on the terminal's cwd
+      // (a claude cd'd into a subdir, or a recreated project dir, must still
+      // be reused once its conversation is positively known).
+      expect(findTerm).not.toMatch(/cwds/);
+      expect(findTerm).not.toMatch(/=== target/);
     });
 
     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(
-        /if \(!wantedSessionId \|\| runningId !== wantedSessionId\) \{\s*continue;/
+        /const runningId = data\?\.session_id \?\? null/
+      );
+      // The ONLY reuse condition: the observed running id equals the wanted
+      // id. An unknown (null) running id never equals a truthy wanted id, so a
+      // terminal whose conversation cannot be read is never reused (DEF-4).
+      expect(findTerm).toMatch(
+        /if \(runningId === wantedSessionId\) \{\s*return \{ widget, runningId \};/
       );
       // The old lenient/strict machinery is gone.
       expect(findTerm).not.toMatch(/unknownConversation/);

package/src/widget.ts

@@ -635,14 +635,11 @@ export class ClaudeCodeSessionsWidget extends Widget {
       }
 
       // 2. Walk every live terminal widget JL knows about.
-      const found = await this._findTerminalForCwd(
-        session.project_path,
-        session.session_id
-      );
+      const found = await this._findTerminalForSession(session.session_id);
       if (found) {
         // 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.
+        // wanted id (the gate in _findTerminalForSession), 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
@@ -901,11 +898,22 @@ export class ClaudeCodeSessionsWidget extends Widget {
     return best ? (best.color ?? null) : null;
   }
 
-  private async _findTerminalForCwd(
-    projectPath: string,
+  /** Find an open terminal running the wanted conversation, or null.
+   *
+   * Matches on the conversation id ALONE. The backend reads each terminal's
+   * true session id from the running claude (`~/.claude/sessions/<pid>.json`),
+   * so a bare `claude` / `-c` the user opened is identified too, not only
+   * extension launches that carry an argv id. A session id is globally unique
+   * to one conversation, so a terminal running it IS the one to focus -
+   * regardless of its reported cwd (a claude that cd'd into a subdir, or whose
+   * project dir was recreated, must still be reused, not duplicated). Reuse
+   * stays strict on identity: a terminal whose running session cannot be read
+   * (no claude, or an unreadable id) reports null, which never equals a wanted
+   * id, so a DIFFERENT conversation is never focused by mistake (DEF-4). */
+  private async _findTerminalForSession(
     wantedSessionId: string | undefined
   ): Promise<{ widget: any; runningId: string | null } | null> {
-    if (!this._terminalTracker) {
+    if (!this._terminalTracker || !wantedSessionId) {
       return null;
     }
     const candidates: any[] = [];
@@ -914,7 +922,6 @@ export class ClaudeCodeSessionsWidget extends Widget {
         candidates.push(widget);
       }
     });
-    const target = projectPath.replace(/\/+$/, '');
     for (const widget of candidates) {
       const sessName: string | undefined = widget?.content?.session?.name;
       if (typeof sessName !== 'string' || !sessName) {
@@ -925,33 +932,13 @@ export class ClaudeCodeSessionsWidget extends Widget {
           `terminal-cwd/${encodeURIComponent(sessName)}`,
           this._serverSettings
         );
-        // Only reuse terminals that actually have claude running. Otherwise
-        // a plain bash opened at the project cwd would be matched and
-        // activated, swallowing the resume click without spawning claude.
-        if (!data?.has_claude) {
-          continue;
-        }
-        // 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;
-        // 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) {
-            // runningId equals the wanted id here (gated above), so the caller
-            // tags its cache with a confirmed conversation id.
-            return { widget, runningId };
-          }
+        // Positive identity match on the running conversation. The backend
+        // reports a session id only for a live claude, so a match implies
+        // has_claude - the id alone is the gate, and the terminal's cwd is
+        // irrelevant once its conversation is positively known.
+        const runningId = data?.session_id ?? null;
+        if (runningId === wantedSessionId) {
+          return { widget, runningId };
         }
       } catch (_err) {
         // Backend may report 404 for terminals that disappeared between