jupyterlab_ai_code_assistants_extension 1.2.71 → 1.2.83

package/README.md

@@ -29,16 +29,16 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **Provider registry** - assistant-specific behaviour lives in one module per assistant behind capability flags; no core file names an assistant, and adding one touches no core file
 - **Joint settings page** - one settings section covering all assistants, with a per-assistant toggle (all on by default); toggling takes effect live, no JupyterLab reload, and a change reaches the other JupyterLab windows of the same browser
 - **Three-section side panel** - Favorites, Recent, and All projects, each scrolling independently
-- **One-click resume** - click a row to jump back into that session in a terminal; an open terminal for the project is reused instead of duplicated. Exception: a Codex or Kimi conversation started with `+`, and a Codex fork, run without an id until the CLI writes one, so a click on that row meanwhile opens a second terminal
+- **One-click resume** - click a row to jump back into that session in a terminal; an open terminal for the project is reused instead of duplicated. Exception: a Kimi or DeepSeek conversation started with `+` runs under an id that never reaches its process command line, so a click on that row while its terminal stays open opens a second terminal. Codex mints the id for a conversation started with `+` and for a fork through its own app-server before the terminal opens, so a click on a Codex row reuses the open terminal instead of opening a second one
 - **File browser follows the opened session** - opening a session moves the JupyterLab file browser to that session's project folder (a setting, on by default); a right-click on a panel header toggles this and moves the panels between the left and right sidebars
 - **Launcher tiles** - every enabled assistant has a tile in an "AI Assistants" section of the JupyterLab Launcher (after Other, under the extension's own robot-head icon); a click opens the assistant in the file browser's current folder, resuming the folder's conversation when one exists and starting a new one otherwise, through the companion `jupyterlab_basic_terminal_extension` (installed automatically). Disable an assistant and its tile goes; disable them all and the section goes with them
 - **Your terminal's `claude -c` follows the panel** (Claude) - switching to a conversation makes plain `claude -c` in that project resume that same conversation, including one that has been compacted, which Claude Code otherwise refuses to continue. Launching repairs a compacted conversation the same way, but only switching moves what `claude -c` picks
 - **Conversation switcher** - a right-click "Switch and Manage Sessions" submenu lists a project's other conversations by name and short id with last-activity time; "Manage Sessions..." opens a searchable popup over the full list with multi-select delete and per-row open and copy-id buttons
-- **Branch session** - fork the current conversation into a new named session via the right-click menu; each assistant forks its own way (Claude's native `--fork-session`, Codex's `codex fork`, server-side copies for Kimi, Gemini and DeepSeek) behind the same menu item
-- **Rename session** - name a conversation from the right-click menu, and the name is written where the assistant itself reads it back: Claude gets the record its own `/rename` writes, Kimi a custom title, Gemini the chat's summary, DeepSeek its title event. The panel shows the name the assistant actually kept. Codex keeps its names in a database this extension only reads, and its CLI has no rename verb, so the item is absent there rather than failing
+- **Branch session** - fork the current conversation into a new named session via the right-click menu; each assistant forks its own way (Claude's native `--fork-session`, Codex's app-server `thread/fork`, server-side copies for Kimi, Gemini and DeepSeek) behind the same menu item
+- **Rename session** - name a conversation from the right-click menu, and the name is written where the assistant itself reads it back: Claude gets the record its own `/rename` writes, Kimi a custom title, Gemini the chat's summary, DeepSeek its title event. The panel shows the name the assistant actually kept. Codex's name is set through Codex's own app-server, so its CLI lists the same name the panel shows
 - **Launch modes under each assistant's own name** - Claude's skip-permissions, Codex's approval bypass, Kimi's `--yolo`, Gemini's YOLO; unsafe variants carry a shield glyph in the launch menus
 - **Coloured terminal tabs** - each session's colour tints its terminal tab via the companion `jupyterlab_colourful_tab_extension` (installed automatically). Claude's own `/color` supplies its default, Kimi derives a stable colour from the conversation id; Codex, Gemini and DeepSeek have no colour of their own until you set one, and a branched session inherits its parent's colour, which it keeps even if the parent's colour later changes or is reset. Tinting needs the companion release that reports the colours you pick and lets another extension own a tab - against an older one this extension tints no tabs at all and says so once, and the companion's own right-click colours keep working as they always did
-- **Your own tab colour wins** - set a colour on a terminal tab and the extension remembers it for that conversation, overriding whatever the assistant chose. `Reset Tab Colour (n)` in the session's right-click menu hands back every colour you set by hand on that project's conversations, and appears once there is one to hand back. Clearing the colour on the tab itself releases it too, for the conversation that terminal is running; `Reset Tab Colour` is the way back for a conversation with no tab open. A Codex or Kimi conversation that has never been resumed cannot be tracked yet, so a colour set on its tab is not kept
+- **Your newest colour choice wins** - set a colour on a terminal tab and the extension remembers it for that conversation, so the tab shows it again when you reopen the conversation. In Claude Code, `/color` is the second way to choose, and whichever you used last wins: a colour picked on the tab after `/color` stays, and running `/color` after a pick takes over again, including `/color` with the same colour or a `/color` reset. `Reset Tab Colour (n)` in the session's right-click menu hands back every colour you set by hand on that project's conversations, and appears once there is one to hand back. Clearing the colour on the tab itself releases it too, for the conversation that terminal is running; `Reset Tab Colour` is the way back for a conversation with no tab open. A Kimi or DeepSeek conversation that has never been resumed cannot be tracked yet, so a colour set on its tab is not kept
 - **Favorites** - star projects you keep coming back to via the right-click menu; favourites from the standalone extensions are migrated on first run
 - **Remove and clean up** - drop a project's history or a project's extra parallel sessions from the right-click menu, confirmation dialog first; removed files honour JupyterLab's "move files to trash" setting
 - **Activity at a glance** - each row shows its last activity in an aligned column; rows active within the last minute light up, rows idle for over a week dim, and rows with parallel conversations show a branch icon with the count
@@ -46,7 +46,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **Search** - fuzzy filter per panel, toggled by the funnel button
 - **Presentation modes** - label rows by session name or by path relative to the JupyterLab root
 - **Conflict-safe upgrade** - if a retired standalone extension is still installed, its panel wins and this extension stands down for that assistant instead of showing a duplicate
-- **DeepSeek in the browser** - the DeepSeek Harness has no terminal chat; its panel lists the projects under `~/.dsh/sessions` (or `$DSH_HOME`) and `Open Web UI` starts `dsh --profile web --no-open --port 0` in the project's terminal, which prints the URL to open. The conversation is then chosen in the harness's own browser UI; branching and deleting work from the panel as for every other assistant. The URL is on the machine running JupyterLab, so a remote server needs a port forward to reach it
+- **DeepSeek in the terminal** - the DeepSeek Harness ships no terminal chat of its own, so its panel runs the community TUI bundle (`@deepseek-harness-tui/dsh-tui`, mounted as the `tui` profile with `dsh plugin --profile tui add @deepseek-harness-tui/dsh-tui`). Without that profile, a launch is refused before a terminal opens, naming the bundle and the mount command - `dsh tui` itself would instead die in a stack trace that prints that command with a literal `<package>` where the package name goes, and never the bundle's name. The panel lists the projects under `~/.dsh/sessions` (or `$DSH_HOME`), and a click resumes that row's conversation with `dsh tui --resume <id>` in a terminal; a launch with no conversation named starts a new one, whose id the TUI mints itself. Branching and deleting work from the panel as for every other assistant
 - **Auto-disabled when absent** - an assistant whose CLI is not on `PATH` does not show a panel
 - **Open Callback** - when an assistant's login sends your browser to an `http://127.0.0.1:...` link that fails to load, because the login is waiting on the machine running JupyterLab, run `Open Callback` from the command palette and paste the link; the Jupyter server requests it for you, and the popup says whether the login accepted it, then closes by itself 3 seconds later. Only `http` links to that machine's own loopback are accepted
 
@@ -55,6 +55,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - JupyterLab >= 4.6.0
 - Python >= 3.10
 - At least one assistant CLI on `PATH`: `claude`, `codex`, `kimi`, `gemini`, or `dsh` (the DeepSeek Harness)
+- For DeepSeek: the community TUI bundle mounted as the `tui` profile, `dsh plugin --profile tui add @deepseek-harness-tui/dsh-tui` - a DeepSeek launch without it is refused with these words before any terminal opens
 
 ## Install
 
@@ -77,7 +78,7 @@ pip install jupyterlab_ai_code_assistants_extension
 
 ## Migrating from the standalone extensions
 
-This package supersedes `jupyterlab_claude_code_extension`, `jupyterlab_codex_extension` and `jupyterlab_kimi_code_extension`. On first run it carries their settings and favourites over automatically; uninstall the standalones once you are ready:
+This package supersedes `jupyterlab_claude_code_extension`, `jupyterlab_codex_extension` and `jupyterlab_kimi_code_extension`. On first run it carries their settings and favourites over automatically, and it never replaces a setting you have already saved in this extension; uninstall the standalones once you are ready:
 
 ```bash
 pip uninstall jupyterlab_claude_code_extension jupyterlab_codex_extension jupyterlab_kimi_code_extension

package/lib/core/colour.d.ts

@@ -95,8 +95,7 @@ export declare class ColourStore {
      * times it, not it.
      *
      * An op must never call `load`, `set` or `forget` - it would wait on a chain
-     * that is waiting on it. `inherit` delegates to `set` from OUTSIDE the queue,
-     * which is why it is not itself queued. */
+     * that is waiting on it. */
     private _run;
     /** Open a write against one or more ids. Counted, not flagged: two writes to
      * one id can be queued at once, and a flag would let the first to settle
@@ -106,8 +105,6 @@ export declare class ColourStore {
     private _closeWrite;
     /** Record a colour as this conversation's own. Passing null drops the entry,
      * which is also how a deleted conversation leaves no orphan key behind.
-     * `handSet` false marks it inherited - written on a fork's behalf rather
-     * than chosen on its tab.
      *
      * Answers whether the store now HOLDS the colour, which is what the capture
      * of a colour picked on a tab gates its repaint on - see `_captureColour`.
@@ -121,17 +118,12 @@ export declare class ColourStore {
      * "Did not throw" is not the test - the answer carries the whole store, so
      * it is checked for the value that was just written. A server that accepted
      * the request and then failed to persist it would otherwise be believed. */
-    set(sessionId: string, colour: string | null, handSet?: boolean): Promise<boolean>;
+    set(sessionId: string, colour: string | null): Promise<boolean>;
     /** Drop stored colours - conversations that no longer exist, or overrides
      * the user released. One request for the whole list, so a release is never
      * left half applied. Same contract as `set`: the answer is checked for the
      * absence of every id, and the cache is touched only once it agrees. */
     forget(sessionIds: string[]): Promise<boolean>;
-    /** Copy the parent's EFFECTIVE colour onto a fresh branch, so a branch of a
-     * branch inherits whatever its immediate parent actually shows, user-set
-     * override included. Called at the fork sites, once the new id is known.
-     */
-    inherit(parentColour: string | null, childId: string): Promise<void>;
     private readonly _providerId;
     private readonly _serverSettings;
     private _colours;

package/lib/core/colour.js

@@ -1,7 +1,10 @@
 // Terminal tab tint per conversation.
 //
 // Effective colour, highest wins:
-//   1. user-set     - the write-back store this module keeps, per provider
+//   1. user-set     - the write-back store this module keeps, per provider.
+//                     Only entries the server still holds: it releases a pick
+//                     that the assistant's own later colour command overtook,
+//                     because the newer of the two channels wins (DEF-COLO-306)
 //   2. native       - the conversation's own colour, when the assistant has one
 //   3. derived      - a stable hash of the conversation id
 //   4. none         - no tint
@@ -186,8 +189,7 @@ export class ColourStore {
      * times it, not it.
      *
      * An op must never call `load`, `set` or `forget` - it would wait on a chain
-     * that is waiting on it. `inherit` delegates to `set` from OUTSIDE the queue,
-     * which is why it is not itself queued. */
+     * that is waiting on it. */
     _run(op) {
         const result = this._chain.then(op);
         const settled = () => undefined;
@@ -218,8 +220,6 @@ export class ColourStore {
     }
     /** Record a colour as this conversation's own. Passing null drops the entry,
      * which is also how a deleted conversation leaves no orphan key behind.
-     * `handSet` false marks it inherited - written on a fork's behalf rather
-     * than chosen on its tab.
      *
      * Answers whether the store now HOLDS the colour, which is what the capture
      * of a colour picked on a tab gates its repaint on - see `_captureColour`.
@@ -233,7 +233,7 @@ export class ColourStore {
      * "Did not throw" is not the test - the answer carries the whole store, so
      * it is checked for the value that was just written. A server that accepted
      * the request and then failed to persist it would otherwise be believed. */
-    async set(sessionId, colour, handSet = true) {
+    async set(sessionId, colour) {
         if (!sessionId) {
             return false;
         }
@@ -249,7 +249,7 @@ export class ColourStore {
                     body: JSON.stringify({
                         session_id: sessionId,
                         colour,
-                        hand_set: handSet
+                        hand_set: true
                     })
                 });
                 if (((_a = data.colours) !== null && _a !== void 0 ? _a : {})[sessionId] !== (colour !== null && colour !== void 0 ? colour : undefined)) {
@@ -265,7 +265,7 @@ export class ColourStore {
                     this._colours.delete(sessionId);
                 }
                 this._overrides.delete(sessionId);
-                if (colour && handSet) {
+                if (colour) {
                     this._overrides.add(sessionId);
                 }
                 return true;
@@ -316,14 +316,4 @@ export class ColourStore {
             }
         });
     }
-    /** Copy the parent's EFFECTIVE colour onto a fresh branch, so a branch of a
-     * branch inherits whatever its immediate parent actually shows, user-set
-     * override included. Called at the fork sites, once the new id is known.
-     */
-    async inherit(parentColour, childId) {
-        if (!parentColour || !childId) {
-            return;
-        }
-        await this.set(childId, parentColour, false);
-    }
 }

package/lib/core/modes.d.ts

@@ -15,7 +15,7 @@ export interface IResolvedLaunchMode {
  * do. Otherwise the first switch that is on fires. Every mode is a boolean
  * skip-approval switch, so "on" always means the same thing.
  */
-export declare function resolveLaunchMode(launchModes: ILaunchMode[], values: Record<string, boolean | string>, force?: string): string | undefined;
+export declare function resolveLaunchMode(launchModes: ILaunchMode[], values: Record<string, boolean>, force?: string): string | undefined;
 /**
  * The mode a PLAIN launch would carry right now, as a descriptor entry.
  *
@@ -26,4 +26,4 @@ export declare function resolveLaunchMode(launchModes: ILaunchMode[], values: Re
  * unmarked. Answers the entry rather than the token so the caller can use the
  * assistant's own wording.
  */
-export declare function resolvedLaunchModeEntry(launchModes: ILaunchMode[], values: Record<string, boolean | string>): IResolvedLaunchMode | null;
+export declare function resolvedLaunchModeEntry(launchModes: ILaunchMode[], values: Record<string, boolean>): IResolvedLaunchMode | null;

package/lib/core/panel.d.ts

@@ -37,7 +37,7 @@ export declare class AssistantSessionsPanel extends Widget {
     setRecentLimit(n: number): void;
     /** Current values of this provider's launch modes, read from settings. Each
      * key is an `ILaunchMode.id` in the assistant's own terminology. */
-    setModes(modes: Record<string, boolean | string>): void;
+    setModes(modes: Record<string, boolean>): void;
     setColouredTabs(on: boolean): void;
     /** Whether opening a session moves the file browser to its project folder. */
     setSyncFileBrowser(on: boolean): void;
@@ -143,26 +143,13 @@ export declare class AssistantSessionsPanel extends Widget {
     launchHere(cwd?: string): Promise<any>;
     /** Start a brand-new conversation in the file browser's current folder. */
     private _newSession;
-    /**
-     * Branch the active row's current conversation, by the descriptor's
-     * `forkStrategy`.
-     *
-     * The three strategies differ only in who mints the new id and when it
-     * becomes knowable - so the shared part (ask for a name, launch a terminal
-     * on the fork, inherit the parent's tint, surface the branch) lives here
-     * once, and the strategy decides the payload and the discovery.
-     */
+    /** Branch the active row's current conversation. Every `forkStrategy` has
+     * the server mint the fork, so this is the one path. */
     private _branchSession;
-    /** The CLI forks from a flag pair and takes the new id from us, so the fork
-     * is known before it exists. Its store entry is written lazily, on the first
-     * turn, so the branch is watched for rather than expected at once. */
-    private _branchByNativeFlag;
-    /** The CLI owns both the fork verb and the id, so the id has to be
-     * discovered: snapshot the branch ids first, then diff after launch. */
-    private _branchByNativeCommand;
-    /** The assistant has no fork at all: the server copies the store entry and
-     * answers with the new id, so the branch exists before the terminal opens
-     * and one refresh surfaces it - no watcher needed. */
+    /** The server mints the new id and answers with it before the terminal
+     * opens - `server-copy` copies the store entry, `server-native` drives the
+     * assistant's own non-interactive fork path - so one refresh surfaces the
+     * branch. */
     private _branchByServerCopy;
     /** Drop the hand-set colours of this project's conversations and re-tint
      * from the defaults at once, so nothing keeps showing a released colour
@@ -178,26 +165,6 @@ export declare class AssistantSessionsPanel extends Widget {
      * the conversation - but only for a conversation whose terminal is open and
      * probes as this assistant's, which is why this path exists as well. */
     private _resetColours;
-    /** Copy the parent's tint onto a fresh branch.
-     *
-     * A native-colour assistant hands every conversation its own colour, so a
-     * fork already arrives correctly tinted: only what this extension's own
-     * store holds for the parent is inherited there - an entry the parent itself
-     * inherited counts, which is what makes a branch of a branch take what its
-     * parent actually shows. Copying the parent's native tint instead would pin
-     * the fork to it and shadow the fork's own `/color` for good.
-     * Every other assistant inherits the parent's effective colour, which is the
-     * only tint it has. */
-    private _inheritColour;
-    /** Poll fast for a fork whose id we already know, then refresh once. The
-     * panel is never updated before the branch genuinely exists - it cannot list
-     * a store entry that has not been written. */
-    private _watchForBranch;
-    /** Poll fast for a fork whose id the CLI minted: whichever conversation the
-     * snapshot did not hold is the fork. It is then pinned as current (recency
-     * alone would not - the actively written parent overtakes it) and inherits
-     * the parent's tint. */
-    private _watchForNewBranch;
     /** Name the row's current conversation, in the assistant's own store.
      *
      * Only ever offered where the descriptor says the assistant keeps a name
@@ -273,9 +240,7 @@ export declare class AssistantSessionsPanel extends Widget {
     private _variantSuffix;
     /** Whether a forced variant would build the launch the plain item already
      * builds - a mode left on in settings makes the plain item carry it, so the
-     * variant beside it would be a second entry for one outcome. Only a boolean
-     * variant can match: a forced token is the bare mode id, so an enum sitting
-     * on a widening value is a launch no variant duplicates. */
+     * variant beside it would be a second entry for one outcome. */
     private _buildsSameLaunch;
     /** The glyph, only where the mode WIDENS what runs without asking. */
     private _variantIcon;

package/lib/core/panel.js

@@ -32,10 +32,6 @@ const MENU_STATE_BUDGET_MS = 800;
  * without a floor the spinner shows for a frame and the click reads as
  * "nothing happened". */
 const REFRESH_SPIN_FLOOR_MS = 500;
-// After a fork is requested, watch for its lazily-written store entry at this
-// faster cadence (bounded) so a new branch surfaces in seconds.
-const BRANCH_WATCH_INTERVAL_MS = 2000;
-const BRANCH_WATCH_MAX_ATTEMPTS = 90; // ~3 minutes
 /** Conversations listed inline in a branch submenu before the popup takes over. */
 const INLINE_BRANCH_LIMIT = 5;
 /** Command id of the sibling extension that spawns a shell-less terminal on a
@@ -898,7 +894,7 @@ export class AssistantSessionsPanel extends Widget {
             if (row) {
                 // A terminal already holding that conversation IS the answer: a second
                 // process on one history is never what the click meant (ACC-LNCH-152).
-                const found = await this._terminals.findForSession(row.session_id, folder);
+                const found = await this._terminals.findForSession(row.session_id);
                 if (found) {
                     this._terminals.focus(found.widget);
                     return found.widget;
@@ -982,126 +978,47 @@ export class AssistantSessionsPanel extends Widget {
             void this._fetch().catch(() => undefined);
         }
     }
-    /**
-     * Branch the active row's current conversation, by the descriptor's
-     * `forkStrategy`.
-     *
-     * The three strategies differ only in who mints the new id and when it
-     * becomes knowable - so the shared part (ask for a name, launch a terminal
-     * on the fork, inherit the parent's tint, surface the branch) lives here
-     * once, and the strategy decides the payload and the discovery.
-     */
+    /** Branch the active row's current conversation. Every `forkStrategy` has
+     * the server mint the fork, so this is the one path. */
     async _branchSession(force) {
-        var _a;
         const session = this._activeSession;
         if (!session) {
             return;
         }
-        const parentColour = this._terminals.colourFor(session);
-        let name;
-        if (this._descriptor.promptsForBranchName) {
-            const named = await InputDialog.getText({
-                title: 'Branch Session',
-                label: 'Name for the new session',
-                placeholder: this._lookupName(session)
-            });
-            if (!named.button.accept) {
-                return;
-            }
-            name = ((_a = named.value) !== null && _a !== void 0 ? _a : '').trim();
-            if (!name) {
-                // Reported, not swallowed. The placeholder shows the parent's name,
-                // which reads as the "press Ok for the default" idiom, so Ok on an
-                // empty field was a closed dialog with no POST and no word (DEF-43).
-                // A notification rather than a disabled Ok because that is how this
-                // panel refuses everywhere else - Open Terminal and Show in File
-                // Browser on a folder outside the root - and `InputDialog.getText`
-                // offers no hook to disable Ok while the field is empty; getting one
-                // means replacing the dialog with a hand-built body widget.
-                Notification.warning('Enter a name for the new session - nothing was branched.', { autoClose: 4000 });
-                return;
-            }
-        }
-        if (this._descriptor.forkStrategy === 'server-copy') {
-            await this._branchByServerCopy(session, name, force);
-            return;
-        }
-        if (this._descriptor.forkStrategy === 'native-command') {
-            await this._branchByNativeCommand(session, force, parentColour);
-            return;
-        }
-        await this._branchByNativeFlag(session, name, force, parentColour);
-    }
-    /** The CLI forks from a flag pair and takes the new id from us, so the fork
-     * is known before it exists. Its store entry is written lazily, on the first
-     * turn, so the branch is watched for rather than expected at once. */
-    async _branchByNativeFlag(session, name, force, parentColour) {
-        const forkId = UUID.uuid4();
-        const request = {
-            project_path: session.project_path,
-            // Arms the server's fork pin - without it the fork never becomes the
-            // row's current conversation and recency drags the row back (DEF-9).
-            encoded_path: session.encoded_path,
-            session_id: session.session_id,
-            fork_session_id: forkId,
-            name,
-            mode: this._launchMode(force)
-        };
-        try {
-            await this._terminals.launch(request, forkId);
-        }
-        catch (err) {
-            this._showActionError('Could not branch this session - try again.', err);
-            return;
-        }
-        await this._inheritColour(parentColour, forkId, session.session_id);
-        this._watchForBranch(session.encoded_path, forkId);
-    }
-    /** The CLI owns both the fork verb and the id, so the id has to be
-     * discovered: snapshot the branch ids first, then diff after launch. */
-    async _branchByNativeCommand(session, force, parentColour) {
-        var _a, _b;
-        const known = new Set((_b = (_a = (await this._fetchBranches(session).catch(() => null))) === null || _a === void 0 ? void 0 : _a.branches.map(b => b.session_id)) !== null && _b !== void 0 ? _b : []);
-        known.add(session.session_id);
-        try {
-            await this._terminals.launch({
-                project_path: session.project_path,
-                fork_from: session.session_id,
-                mode: this._launchMode(force)
-            });
-        }
-        catch (err) {
-            this._showActionError('Could not branch this session - try again.', err);
-            return;
-        }
-        this._watchForNewBranch(session, known, parentColour);
-        void this._fetch().catch(() => undefined);
+        await this._branchByServerCopy(session, undefined, force);
     }
-    /** The assistant has no fork at all: the server copies the store entry and
-     * answers with the new id, so the branch exists before the terminal opens
-     * and one refresh surfaces it - no watcher needed. */
+    /** The server mints the new id and answers with it before the terminal
+     * opens - `server-copy` copies the store entry, `server-native` drives the
+     * assistant's own non-interactive fork path - so one refresh surfaces the
+     * branch. */
     async _branchByServerCopy(session, name, force) {
         // Let the parent's colour settle before the server reads it (DEF-74). The
         // server copies the store entry while minting the fork, so a colour picked
         // on the parent's tab moments earlier - still queued in this store's
         // request chain, unsent - is not in the server's store yet and the branch
-        // is born wearing the PREVIOUS tint. Same gate as `_inheritColour`
-        // (DEF-31): a reload is a queued request like every other of this store's
-        // (DEF-30), so it is not sent until the capture ahead of it has been
-        // answered, and awaiting it is what makes the server's read fresh. Only
-        // inside the capture window, so an ordinary fork still costs no request.
+        // is born wearing the PREVIOUS tint. A reload is a queued request like
+        // every other of this store's (DEF-30), so it is not sent until the
+        // capture ahead of it has been answered, and awaiting it is what makes the
+        // server's read fresh. Only inside the capture window, so an ordinary fork
+        // still costs no request.
         if (this._colours.isPending(session.session_id)) {
             await this._colours.load();
         }
+        // Whether the POST below returned the minted fork. Past that point the
+        // branch exists server-side - row, pin and colour - and only the launch
+        // of its terminal can still fail, which is a different thing to report.
+        let minted = false;
         try {
             const fork = await requestProvider(this._descriptor.id, 'branch', this._serverSettings, {
                 method: 'POST',
                 body: JSON.stringify({
                     encoded_path: session.encoded_path,
                     session_id: session.session_id,
-                    name
+                    name,
+                    base_name: session.name
                 })
             });
+            minted = true;
             // No colour write here. `BranchHandler` already inherited it while
             // minting this fork, from a read taken server-side at request time -
             // strictly fresher than the click-time read this would repeat, and the
@@ -1117,6 +1034,19 @@ export class AssistantSessionsPanel extends Widget {
             if (isResponseStatus(err, 400)) {
                 Notification.error(`${this._descriptor.label} cannot branch this conversation.`, { autoClose: 4000 });
             }
+            else if (minted) {
+                // The branch was created and only its terminal was refused - the
+                // launch preflight's 409 carries words for the user. "Could not
+                // branch this session" would be false, and the early return would
+                // skip the refresh that surfaces the new row, so the refusal keeps
+                // its own message and the list is re-read all the same.
+                // Kept to 41 characters for the TOAST, not for taste: ": " plus the
+                // longest message a store may raise (97, the DeepSeek refusal's
+                // bound in tests/test_provider_stores.py) is 41 + 2 + 97 = 140 -
+                // exactly the window before JupyterLab clips the rest.
+                this._notifyLaunchError('Branch created; its terminal did not open', err);
+                await this._fetch().catch(() => undefined);
+            }
             else {
                 this._showActionError('Could not branch this session - try again.', err);
             }
@@ -1149,108 +1079,6 @@ export class AssistantSessionsPanel extends Widget {
         await this._terminals.reconcileColours();
         await this._fetch().catch(() => undefined);
     }
-    /** Copy the parent's tint onto a fresh branch.
-     *
-     * A native-colour assistant hands every conversation its own colour, so a
-     * fork already arrives correctly tinted: only what this extension's own
-     * store holds for the parent is inherited there - an entry the parent itself
-     * inherited counts, which is what makes a branch of a branch take what its
-     * parent actually shows. Copying the parent's native tint instead would pin
-     * the fork to it and shadow the fork's own `/color` for good.
-     * Every other assistant inherits the parent's effective colour, which is the
-     * only tint it has. */
-    async _inheritColour(parentColour, childId, parentId) {
-        // The project gained a conversation, so a listing kept from before it is
-        // short by one.
-        this._branchCache = null;
-        // Let the parent's colour settle before copying it (DEF-31). The store
-        // holds only server-confirmed values, so a colour picked on the parent's
-        // tab moments earlier is not in it yet, and a fork started in that window
-        // was born wearing the PREVIOUS tint - stored as inherited, so never
-        // offered for release and corrected by no later pass.
-        //
-        // A reload is a queued request like every other of this store's (DEF-30):
-        // it is not sent until the capture ahead of it has been answered, which is
-        // what makes the re-read below current. It runs only inside the capture
-        // window, so an ordinary fork still costs no request, and the wait is
-        // bounded - every request is capped at REQUEST_TIMEOUT_MS (DEF-72). A
-        // reload that fails keeps the cache, which by then holds whatever the
-        // capture confirmed, so the re-read is current either way.
-        if (this._colours.isPending(parentId)) {
-            await this._colours.load();
-        }
-        // Re-read rather than trust `parentColour`, which was taken at click time -
-        // before the name dialog. A capture in flight at click time may well have
-        // landed while that dialog was open, which leaves nothing pending and the
-        // snapshot stale all the same. It stays as the fallback everywhere but a
-        // `native` provider - it is the only value here in which the derived hash
-        // is resolved, so a parent this store holds no colour for still hands its
-        // fork the tint it actually shows. `native` takes no fallback at all, for
-        // the reason above.
-        const stored = this._colours.get(parentId);
-        const inherited = this._descriptor.colourSource === 'native'
-            ? stored
-            : (stored !== null && stored !== void 0 ? stored : parentColour);
-        await this._colours.inherit(inherited, childId);
-    }
-    /** Poll fast for a fork whose id we already know, then refresh once. The
-     * panel is never updated before the branch genuinely exists - it cannot list
-     * a store entry that has not been written. */
-    _watchForBranch(encodedPath, forkId) {
-        let attempts = 0;
-        const tick = async () => {
-            // dispose() can land between an await and this callback; the widget must
-            // not keep polling off a dead object.
-            if (this.isDisposed) {
-                return;
-            }
-            attempts += 1;
-            try {
-                const data = await requestProvider(this._descriptor.id, withQuery('branches', { encoded_path: encodedPath }), this._serverSettings, { cache: 'no-store' });
-                if (data.current === forkId ||
-                    data.branches.some(b => b.session_id === forkId)) {
-                    await this._fetch();
-                    return;
-                }
-            }
-            catch (_a) {
-                // Transient - 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);
-    }
-    /** Poll fast for a fork whose id the CLI minted: whichever conversation the
-     * snapshot did not hold is the fork. It is then pinned as current (recency
-     * alone would not - the actively written parent overtakes it) and inherits
-     * the parent's tint. */
-    _watchForNewBranch(session, known, parentColour) {
-        let attempts = 0;
-        const tick = async () => {
-            if (this.isDisposed) {
-                return;
-            }
-            attempts += 1;
-            try {
-                const data = await this._fetchBranches(session);
-                const fresh = data.branches.find(b => !known.has(b.session_id));
-                if (fresh) {
-                    await this._inheritColour(parentColour, fresh.session_id, session.session_id);
-                    await this._switchBranch(session, fresh.session_id);
-                    return;
-                }
-            }
-            catch (_a) {
-                // Transient - keep watching.
-            }
-            if (attempts < BRANCH_WATCH_MAX_ATTEMPTS) {
-                window.setTimeout(() => void tick(), BRANCH_WATCH_INTERVAL_MS);
-            }
-        };
-        window.setTimeout(() => void tick(), BRANCH_WATCH_INTERVAL_MS);
-    }
     /** Name the row's current conversation, in the assistant's own store.
      *
      * Only ever offered where the descriptor says the assistant keeps a name
@@ -1273,9 +1101,8 @@ export class AssistantSessionsPanel extends Widget {
         }
         const name = ((_a = named.value) !== null && _a !== void 0 ? _a : '').trim();
         if (!name) {
-            // Refused the way Branch Session refuses an empty name (DEF-43): the
-            // placeholder shows the current name, which reads as "press Ok for the
-            // default", so an empty Ok has to say that nothing happened.
+            // The placeholder shows the current name, which reads as "press Ok for
+            // the default", so an empty Ok has to say that nothing happened.
             Notification.warning('Enter a name - nothing was renamed.', {
                 autoClose: 4000
             });
@@ -1945,9 +1772,7 @@ export class AssistantSessionsPanel extends Widget {
     }
     /** Whether a forced variant would build the launch the plain item already
      * builds - a mode left on in settings makes the plain item carry it, so the
-     * variant beside it would be a second entry for one outcome. Only a boolean
-     * variant can match: a forced token is the bare mode id, so an enum sitting
-     * on a widening value is a launch no variant duplicates. */
+     * variant beside it would be a second entry for one outcome. */
     _buildsSameLaunch(mode) {
         const forced = resolveLaunchMode(this._descriptor.launchModes, this._modes, mode.id);
         return !!forced && forced === this._launchMode();
@@ -2093,8 +1918,8 @@ export class AssistantSessionsPanel extends Widget {
         // colourful-tab extension as a choice with no colour and does drop the
         // override, but only for the conversation that terminal is running - so
         // without this item an override on a branch with no tab open would be
-        // permanent, and on a native assistant that means `/color` silently never
-        // showing again.
+        // permanent on an assistant with no colour command, and on a native one
+        // would hold until the next `/color` run in that conversation.
         //
         // It covers every conversation of the row, not just the current one: a
         // terminal opened on a branch files its colour under THAT branch, and this
@@ -2325,14 +2150,10 @@ export class AssistantSessionsPanel extends Widget {
         add('reset-colour');
         this._contextMenu.addItem({ type: 'separator' });
         if (withBranches) {
-            // A project-scoped assistant has one terminal for every conversation,
-            // so opening a branch in its own terminal is not an action it has.
-            if (this._descriptor.terminalScope === 'conversation') {
-                this._contextMenu.addItem({
-                    type: 'submenu',
-                    submenu: this._openBranchSubmenu
-                });
-            }
+            this._contextMenu.addItem({
+                type: 'submenu',
+                submenu: this._openBranchSubmenu
+            });
             this._contextMenu.addItem({
                 type: 'submenu',
                 submenu: this._switchSubmenu
@@ -2501,7 +2322,7 @@ export class AssistantSessionsPanel extends Widget {
             branchName: b => this._branchDisplayName(b),
             formatTime: ms => this._formatRelativeTime(ms),
             branchBadge: b => this._bgBadgeFor(b),
-            openTitle: () => this._openBranchTitle(session),
+            openTitle: () => this._openBranchTitle(),
             onSwitch: id => void this._switchBranch(session, id),
             onOpen: id => void this._openSession(session, undefined, id),
             onDelete: ids => this._deleteBranches(session, ids),
@@ -2514,13 +2335,7 @@ export class AssistantSessionsPanel extends Widget {
     /** Tooltip for one Open button in the Manage Sessions popup. Same rule as the
      * Open Branched Conversation submenu: the button launches a terminal, so it
      * names the mode that launch carries. */
-    _openBranchTitle(session) {
-        var _a, _b, _c;
-        // One terminal serves a project-scoped assistant, so the button focuses
-        // or starts it, under the provider's own verb for that.
-        if (this._descriptor.terminalScope === 'project') {
-            return ((_c = (_b = (_a = this._hooks).resumeLabel) === null || _b === void 0 ? void 0 : _b.call(_a, session)) !== null && _c !== void 0 ? _c : "Open the project's terminal");
-        }
+    _openBranchTitle() {
         const base = 'Open this conversation in its own terminal';
         const variant = this._resolvedVariant();
         return variant ? `${base} (${variant.label})` : base;