jupyterlab_ai_code_assistants_extension 1.2.282 → 1.2.294

package/README.md

@@ -10,7 +10,7 @@
 
 A full launcher and manager for every AI code assistant in JupyterLab - Claude Code, Codex, Kimi, Gemini and DeepSeek. Start, resume, fork, switch, and clean up CLI sessions from a side panel per assistant - one click lands you in the right terminal with the assistant already running, no duplicate tabs, no UUID hunting. One install replaces the separate `jupyterlab_claude_code_extension`, `jupyterlab_codex_extension` and `jupyterlab_kimi_code_extension` packages and migrates their settings and favourites automatically.
 
-![Claude Code Sessions panel](.resources/screenshot.png)
+![Claude Code panel](.resources/screenshot.png)
 
 ## Why this extension
 
@@ -36,6 +36,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **Conversation switcher** - a right-click "Switch and Manage Sessions" submenu lists a project's other conversations by name and short id. "Manage Sessions..." opens a searchable list with multi-select delete and copy-id
 - **Branch session** - fork the current conversation into a new named session from the right-click menu
 - **Rename session** - name a conversation from the right-click menu, and the panel shows the name the assistant itself kept
+- **Command line** - `jupyterlab-ai-code-assistants` lists, renames, moves, deletes, branches and switches the sessions of every assistant and refreshes the panels, from a terminal or an agent; every open panel shows the change at once
 - **Launch modes under each assistant's own name** - Claude's skip-permissions, Codex's approval bypass, Kimi's `--yolo` and Gemini's YOLO; unsafe variants carry a shield glyph
 - **Coloured terminal tabs** - each session's colour tints its terminal tab, and a branched session inherits its parent's colour. Claude's `/color` supplies a default and Kimi derives a stable one; Codex, Gemini and DeepSeek have no colour until you set one
 - **Your newest colour choice wins** - a colour set on a terminal tab is remembered for that conversation; a Kimi or DeepSeek conversation that has never been resumed, including one started with `+`, is the exception, because its id cannot be read yet. In Claude Code whichever of the tab colour and `/color` you used last wins, and Reset Tab Colour in the right-click menu hands back the colours you set by hand
@@ -76,6 +77,27 @@ pip install jupyterlab_ai_code_assistants_extension
 > [!WARNING]
 > `package.json` pins `webpack: 5.106.0` and `chalk: 4.1.2` in both `resolutions` and `overrides`. Do not remove these. webpack `>= 5.106.1` changed its module-federation share identifier format and crashes the unmaintained `license-webpack-plugin` (`split('=')[1].trim()`) that `@jupyterlab/builder` injects into every production build; the duplicate `chalk@2.4.2` pulled by `duplicate-package-checker-webpack-plugin` crashes on Node 24+ in the build-isolation install. Without the pins, `make publish` and CI fail on `python -m build`.
 
+## Command line
+
+The wheel installs `jupyterlab-ai-code-assistants`. It finds the running Jupyter server and its token, and changes sessions only through that server, so every open panel shows the change at once.
+
+```bash
+jupyterlab-ai-code-assistants                                   # the server and every assistant (status)
+jupyterlab-ai-code-assistants sessions list -a claude -p ~/project
+jupyterlab-ai-code-assistants sessions rename <id> "New name" -a kimi
+jupyterlab-ai-code-assistants sessions move <id> --to ~/other-project -a gemini
+jupyterlab-ai-code-assistants sessions delete <id> -a claude
+jupyterlab-ai-code-assistants sessions branch <id> -a claude --name "Experiment"
+jupyterlab-ai-code-assistants sessions switch <id> -a codex
+jupyterlab-ai-code-assistants refresh                           # after installing or removing an assistant CLI
+```
+
+- `--url` and `--json` go before the subcommand; `--url` chooses the server when several run
+- There is no token option: the token comes from `JUPYTERLAB_AI_CODE_ASSISTANTS_TOKEN`, else the server's runtime record, else `JUPYTERHUB_API_TOKEN`, `JPY_API_TOKEN` or `JUPYTER_TOKEN` for a loopback address
+- A session a running terminal holds is never moved or deleted, and a project's current session is never deleted
+- A Codex move forks the session into the target under a new id, which the command prints, and archives the source
+- `jupyterlab-ai-code-assistants --help` lists the exit codes; `--help` after a subcommand lists its options
+
 ## Agent skill
 
 The wheel ships a session-operations skill for coding agents at `share/jupyter/agents/skills/jupyterlab-ai-code-assistants-extension/SKILL.md`. It covers finding, moving, splitting, renaming and promoting sessions, copying a session into another project under a fresh id, the task-list environment variables, and running Claude Code against Kimi K3 or DeepSeek, with two references for the rest - `claude-operations.md` for how `claude -c` and `--resume` choose a session and how to repair, promote and pin one, and `cross-assistant-sessions.md` for reading, inventorying, taking over and resuming sessions of Claude Code, Codex, Kimi, Gemini and DeepSeek.

package/lib/core/panel.d.ts

@@ -87,13 +87,9 @@ export declare class AssistantSessionsPanel extends Widget {
      * the launch REACHED the server and was refused, and nothing retries it. */
     private _notifyLaunchError;
     private _logError;
+    /** `keepSame`: an answer equal to what is drawn leaves the rows in place. */
     private _fetch;
     private _toggleFavourite;
-    /** The warning a deletion earns: with the trash setting on, a refused move
-     * may remove the conversations permanently or leave them in place, so
-     * neither the verb nor the note may promise one outcome. */
-    private get _irreversibleNote();
-    private get _disposalVerb();
     private _removeProject;
     private _cleanupParallel;
     /** This provider's launch-mode token for one action - see
@@ -316,6 +312,13 @@ export declare class AssistantSessionsPanel extends Widget {
      * all. Returning null lets the popup fall back to its fork marker. */
     private _bgBadgeFor;
     private _startPolling;
+    /** The server says this assistant's sessions changed (ACC-CLI-227): read
+     * them through the poll's single-flight fetch. Unlike a poll tick it is
+     * never dropped. It waits for an open row context menu to close, and one
+     * that lands while a read is in flight reads once more after it, because
+     * that read may have been answered before the change. */
+    sessionsChanged(): void;
+    private _poll;
     private _stopPolling;
     private readonly _app;
     private readonly _descriptor;
@@ -375,9 +378,13 @@ export declare class AssistantSessionsPanel extends Widget {
     private _activeSession;
     private _activeRowEl;
     private _pollHandle;
-    /** The poll's own in-flight tick. Only the poll reads it - an explicit
-     * Refresh must always issue, however long the last poll is taking. */
+    /** The poll's own in-flight tick. Only the poll and a pushed change read it
+     * - an explicit Refresh must always issue, however long the last poll is
+     * taking. */
     private _polling;
+    /** A pushed change waits for the context menu to close or for the read in
+     * flight to answer - see `sessionsChanged`. */
+    private _changeWaits;
     /** Listing requests sent, and the number of the newest one drawn - see
      * `_fetch`. */
     private _fetchSent;

package/lib/core/panel.js

@@ -1,4 +1,4 @@
-import { Clipboard, Dialog, InputDialog, Notification, showDialog } from '@jupyterlab/apputils';
+import { Clipboard, Dialog, InputDialog, Notification } from '@jupyterlab/apputils';
 import { MenuSvg, closeIcon, copyIcon, editIcon, folderIcon, terminalIcon } from '@jupyterlab/ui-components';
 import { nullTranslator } from '@jupyterlab/translation';
 import { CommandRegistry } from '@lumino/commands';
@@ -40,6 +40,18 @@ const INLINE_BRANCH_LIMIT = 5;
  * exports no token, so its absence is something to ask the command registry
  * about at click time rather than a build-time dependency (ACC-LNCH-155). */
 const BASIC_TERMINAL_LAUNCH = 'basic-terminal:launch';
+/** What a delete says about the conversations the server kept because a live
+ * terminal runs them (ACC-SESS-57); empty when it kept none. */
+function keptCopy(liveIds) {
+    var _a;
+    const kept = (_a = liveIds === null || liveIds === void 0 ? void 0 : liveIds.length) !== null && _a !== void 0 ? _a : 0;
+    if (kept === 0) {
+        return '';
+    }
+    return kept === 1
+        ? 'One conversation was kept, because a live terminal runs it.'
+        : `${kept} conversations were kept, because live terminals run them.`;
+}
 export const DEFAULT_PRESENTATION_MODE = 'name';
 const SECTION_LABELS = {
     favourites: 'Favorites',
@@ -173,9 +185,13 @@ export class AssistantSessionsPanel extends Widget {
         this._activeSession = null;
         this._activeRowEl = null;
         this._pollHandle = null;
-        /** The poll's own in-flight tick. Only the poll reads it - an explicit
-         * Refresh must always issue, however long the last poll is taking. */
+        /** The poll's own in-flight tick. Only the poll and a pushed change read it
+         * - an explicit Refresh must always issue, however long the last poll is
+         * taking. */
         this._polling = null;
+        /** A pushed change waits for the context menu to close or for the read in
+         * flight to answer - see `sessionsChanged`. */
+        this._changeWaits = false;
         /** Listing requests sent, and the number of the newest one drawn - see
          * `_fetch`. */
         this._fetchSent = 0;
@@ -633,7 +649,8 @@ export class AssistantSessionsPanel extends Widget {
         console.error(`${LOG_PREFIX}[${this._descriptor.id}]`, message);
     }
     // ------------------------------------------------------------------- data
-    async _fetch() {
+    /** `keepSame`: an answer equal to what is drawn leaves the rows in place. */
+    async _fetch(keepSame = false) {
         var _a;
         // This request's place in the order. Requests answer in any order, and an
         // answer older than the one already drawn is dropped (DEF-PANE-344).
@@ -647,10 +664,16 @@ export class AssistantSessionsPanel extends Widget {
         this._fetchDrawn = request;
         // A project removed at or after this listing was sent must not be drawn
         // back from the answer (DEF-PANE-351-WRITE-ORDER).
-        this._sessions = ((_a = data.sessions) !== null && _a !== void 0 ? _a : []).filter(s => { var _a; return ((_a = this._removedAt.get(s.encoded_path)) !== null && _a !== void 0 ? _a : 0) < request; });
+        const sessions = ((_a = data.sessions) !== null && _a !== void 0 ? _a : []).filter(s => { var _a; return ((_a = this._removedAt.get(s.encoded_path)) !== null && _a !== void 0 ? _a : 0) < request; });
         this._setInlineError(null);
-        this._terminals.setSessions(this._sessions);
-        this._render();
+        // A redraw replaces every row, and the row a click is on with it
+        // (DEF-PANE-370-OWN-PUSH).
+        if (!keepSame ||
+            JSON.stringify(sessions) !== JSON.stringify(this._sessions)) {
+            this._sessions = sessions;
+            this._terminals.setSessions(this._sessions);
+            this._render();
+        }
         // Best-effort tinting; never let a colour failure break the fetch.
         void this._colours.load().then(() => this._terminals.reconcileColours());
     }
@@ -668,8 +691,9 @@ export class AssistantSessionsPanel extends Widget {
             });
             // A listing sent before the write may still be drawn, and a poll may
             // have replaced the row this wrote; this one is answered after the write
-            // (DEF-PANE-351).
-            void this._fetch().catch(() => undefined);
+            // (DEF-PANE-351). When it answers what the star above drew, the rows
+            // stay: the star is redrawn once.
+            void this._fetch(true).catch(() => undefined);
         }
         catch (err) {
             session.favourite = !next; // roll back
@@ -677,27 +701,33 @@ export class AssistantSessionsPanel extends Widget {
             this._showActionError('Could not toggle favorite - try again.', err);
         }
     }
-    /** The warning a deletion earns: with the trash setting on, a refused move
-     * may remove the conversations permanently or leave them in place, so
-     * neither the verb nor the note may promise one outcome. */
-    get _irreversibleNote() {
-        return this._deleteToTrash
-            ? ' A permanent removal cannot be undone.'
-            : ' This cannot be undone.';
-    }
-    get _disposalVerb() {
-        return this._deleteToTrash
-            ? 'moved to the trash when the system accepts them; a refused move may remove them permanently or leave them in place'
-            : 'deleted permanently';
-    }
     async _removeProject(session) {
         var _a;
         const name = this._lookupName(session);
-        const confirm = await showDialog({
-            title: `Remove from ${this._descriptor.label}`,
-            body: `Remove "${name}" from ${this._descriptor.label}? This drops the ` +
-                `entire project history and every conversation it holds - ` +
-                `${this._disposalVerb}.${this._irreversibleNote}`,
+        const title = `Remove from ${this._descriptor.label}`;
+        // The consequence only, in two lines: the question and the outcome, then
+        // the permanent-deletion refusal on its own caution line
+        // (DEF-PANE-371-DIALOG-TEXT).
+        const outcome = this._deleteToTrash
+            ? `Remove "${name}"? Every conversation in it goes to the trash.`
+            : `Remove "${name}"? Every conversation in it is deleted permanently.`;
+        const caution = this._deleteToTrash
+            ? 'A refused move deletes permanently.'
+            : '';
+        const body = new Widget();
+        body.node.className = 'jp-AiAssistantsPanel-removeConfirm';
+        const question = document.createElement('p');
+        question.textContent = outcome;
+        body.node.appendChild(question);
+        if (caution) {
+            const line = document.createElement('p');
+            line.className = 'jp-AiAssistantsPanel-removeCaution';
+            line.textContent = caution;
+            body.node.appendChild(line);
+        }
+        const dialog = new Dialog({
+            title,
+            body,
             buttons: [
                 Dialog.cancelButton(),
                 Dialog.warnButton({ label: this._trans.__('Remove') })
@@ -710,6 +740,9 @@ export class AssistantSessionsPanel extends Widget {
             defaultButton: 0,
             renderer: dialogRenderer
         });
+        // A Widget body leaves the Dialog no string to name itself from.
+        dialog.node.setAttribute('aria-label', [title, outcome, caution].filter(part => part).join(' '));
+        const confirm = await dialog.launch();
         if (!confirm.button.accept) {
             return;
         }
@@ -768,7 +801,7 @@ export class AssistantSessionsPanel extends Widget {
         caution.className = 'jp-AiAssistantsPanel-cleanupCaution';
         caution.textContent = this._deleteToTrash
             ? 'A refused trash move deletes permanently and cannot be undone.'
-            : this._irreversibleNote.trim();
+            : 'This cannot be undone.';
         confirmBody.node.appendChild(caution);
         const title = this._trans.__('Clean Up Parallel Sessions');
         let warning = null;
@@ -783,9 +816,11 @@ export class AssistantSessionsPanel extends Widget {
             defaultButton: 0,
             renderer: dialogRenderer
         });
-        // showDialog names a dialog only when its body is a string, and this body
-        // is a Widget: name it here, and again when the question is restated and
-        // the warning joins it.
+        // Scopes the armed style in base.css to this one dialog.
+        confirmDialog.addClass('jp-AiAssistantsPanel-cleanupDialog');
+        // The Dialog names itself only when its body is a string, and this body is
+        // a Widget: name it here, and again when the question is restated and the
+        // warning joins it.
         const nameDialog = () => {
             var _a, _b, _c, _d;
             confirmDialog.node.setAttribute('aria-label', [
@@ -799,6 +834,105 @@ export class AssistantSessionsPanel extends Widget {
                 .join(' '));
         };
         nameDialog();
+        // The house two-step destructive action (design-language.md, "Two-step
+        // destructive action"; the branch popup's Delete is the shipped form):
+        // while the newer state is unknown or newer, the accept button arms on the
+        // first activation and removes on the second, the arm lapsing after 4 s.
+        // It starts required: the branch fetch that decides whether a removal is
+        // safe is still out when the dialog opens.
+        let armRequired = true;
+        let armed = false;
+        let armTimer = 0;
+        // The arming activation's event.timeStamp, which the confirming one is
+        // measured against.
+        let armedAt = 0;
+        /** Find and relabel the accept button. The Dialog keeps its button nodes
+         * private and puts the label in a child whose aria-label overrides its
+         * text, so both are set. */
+        const updateAccept = () => {
+            const button = confirmDialog.node.querySelector('.jp-mod-accept');
+            const label = button === null || button === void 0 ? void 0 : button.querySelector('.jp-Dialog-buttonLabel');
+            if (!button || !label) {
+                return;
+            }
+            const text = armed
+                ? this._trans.__('Confirm remove %1', extra)
+                : armRequired
+                    ? this._trans.__('Remove (%1)', extra)
+                    : this._trans.__('Remove');
+            label.textContent = text;
+            label.setAttribute('aria-label', text);
+            button.classList.toggle('jp-mod-armed', armed);
+        };
+        const disarm = () => {
+            armed = false;
+            window.clearTimeout(armTimer);
+        };
+        /** Consume one accept activation. True means it only armed, or was the
+         * ignored half of a double-click, and the Dialog must not resolve; false
+         * lets the Dialog's own handler resolve it. */
+        const activate = (event) => {
+            if (!armRequired) {
+                return false;
+            }
+            // The second click of a double-click is not a confirmation (DEF-PANE-336):
+            // a multi-click within 600 ms of arming is ignored. A later click
+            // confirms whatever its detail, since the OS double-click interval can
+            // be longer than the user's pause (DEF-PANE-338).
+            if (armed && event.detail > 1 && event.timeStamp - armedAt < 600) {
+                return true;
+            }
+            if (!armed) {
+                armed = true;
+                armedAt = event.timeStamp;
+                window.clearTimeout(armTimer);
+                armTimer = window.setTimeout(() => {
+                    disarm();
+                    updateAccept();
+                }, 4000);
+                updateAccept();
+                return true;
+            }
+            disarm();
+            return false;
+        };
+        // Registered before launch(): the Dialog attaches its own capture
+        // listeners on this same node when launch() attaches it, so these run
+        // first and can swallow an activation that must only arm. Space arrives
+        // as a click; Enter arrives as a keydown the Dialog would otherwise
+        // resolve from, so both are intercepted here.
+        confirmDialog.node.addEventListener('click', event => {
+            const button = confirmDialog.node.querySelector('.jp-mod-accept');
+            if (!button || !button.contains(event.target)) {
+                return;
+            }
+            if (activate(event)) {
+                event.stopImmediatePropagation();
+                event.preventDefault();
+            }
+        }, true);
+        confirmDialog.node.addEventListener('keydown', event => {
+            if (event.key !== 'Enter') {
+                return;
+            }
+            const accept = confirmDialog.node.querySelector('.jp-mod-accept');
+            if (!accept || document.activeElement !== accept) {
+                return;
+            }
+            // A held key's auto-repeat is not a second press (DEF-PANE-347): it
+            // must neither confirm nor arm, and consuming it stops the Dialog's
+            // own Enter handler from resolving the accept.
+            if (event.repeat) {
+                event.stopImmediatePropagation();
+                event.preventDefault();
+                return;
+            }
+            if (activate(event)) {
+                event.stopImmediatePropagation();
+                event.preventDefault();
+            }
+        }, true);
+        updateAccept();
         // Alongside the question, never in front of it: the request layer allows
         // 60 s, and the confirmation must open at once. When the list lands the
         // question states its length and a conversation newer than the kept one
@@ -830,6 +964,13 @@ export class AssistantSessionsPanel extends Widget {
                             'active after the one kept.';
                     confirmBody.node.appendChild(warning);
                 }
+                // The list just decided what the button acts on: an arm given while
+                // it was pending could confirm a different set, so drop it and
+                // restate the label with the fetched count. With no newer branch the
+                // button returns to the one-click Remove.
+                disarm();
+                armRequired = newer > 0;
+                updateAccept();
                 nameDialog();
             }
             return fetched;
@@ -899,7 +1040,12 @@ export class AssistantSessionsPanel extends Widget {
             // The kept listing names conversations that may have just gone.
             this._branchCache = null;
             bar.value = 1;
-            message.textContent = `Removed ${data.removed_count} parallel session${data.removed_count === 1 ? '' : 's'}.`;
+            message.textContent = [
+                `Removed ${data.removed_count} parallel session${data.removed_count === 1 ? '' : 's'}.`,
+                keptCopy(data.live_ids)
+            ]
+                .filter(part => part)
+                .join(' ');
             // Refresh so the row's conversation count and menu label update.
             await this._fetch();
         }
@@ -1502,6 +1648,10 @@ export class AssistantSessionsPanel extends Widget {
             await this._colours.forget((_a = result.removed_ids) !== null && _a !== void 0 ? _a : sessionIds);
             // The kept listing names conversations that may have just gone.
             this._branchCache = null;
+            const kept = keptCopy(result.live_ids);
+            if (kept) {
+                Notification.info(kept, { autoClose: 4000 });
+            }
             return result.removed_count;
         }
         catch (err) {
@@ -2420,6 +2570,11 @@ export class AssistantSessionsPanel extends Widget {
             // callback still needs to read it. The field is overwritten on the next
             // contextmenu open.
             this._setActiveRow(null);
+            // A change pushed while the menu was open reads now. A microtask later,
+            // because the menu is still attached while this signal fires.
+            if (this._changeWaits) {
+                queueMicrotask(() => this.sessionsChanged());
+            }
         });
     }
     _menu(commands = this._commands) {
@@ -2698,13 +2853,36 @@ export class AssistantSessionsPanel extends Widget {
             if (this._polling !== null) {
                 return;
             }
-            this._polling = this._fetch()
-                .catch(err => this._showError(err))
-                .finally(() => {
-                this._polling = null;
-            });
+            this._poll();
         }, POLL_INTERVAL_MS);
     }
+    /** The server says this assistant's sessions changed (ACC-CLI-227): read
+     * them through the poll's single-flight fetch. Unlike a poll tick it is
+     * never dropped. It waits for an open row context menu to close, and one
+     * that lands while a read is in flight reads once more after it, because
+     * that read may have been answered before the change. */
+    sessionsChanged() {
+        if (this.isDisposed) {
+            return;
+        }
+        if (this._contextMenu.isAttached || this._polling !== null) {
+            this._changeWaits = true;
+            return;
+        }
+        this._poll();
+    }
+    _poll() {
+        // A read sent now answers every change pushed before it.
+        this._changeWaits = false;
+        this._polling = this._fetch()
+            .catch(err => this._showError(err))
+            .finally(() => {
+            this._polling = null;
+            if (this._changeWaits) {
+                this.sessionsChanged();
+            }
+        });
+    }
     _stopPolling() {
         if (this._pollHandle !== null) {
             window.clearInterval(this._pollHandle);

package/lib/core/popup.js

@@ -91,7 +91,7 @@ export function showManageSessionsPopup(options) {
     deleteBtn.type = 'button';
     deleteBtn.className = 'jp-AiAssistantsPanel-branchDelete';
     deleteBtn.title = options.deleteToTrash
-        ? 'Deleted conversations move to the trash when the system accepts them; a refused move may remove them permanently or leave them in place'
+        ? 'Deleted conversations go to the trash; a refused move deletes permanently.'
         : 'Deleted conversations are removed permanently';
     footer.appendChild(deleteBtn);
     // Plain visual counter (selection, or the last action), beside the button

package/lib/core/request.d.ts

@@ -1,6 +1,11 @@
 import { ServerConnection } from '@jupyterlab/services';
 /** The server extension's API namespace. Every route lives under it. */
 export declare const API_NAMESPACE = "jupyterlab-ai-code-assistants-extension";
+/** This window's name, sent with every request in {@link WINDOW_HEADER}. The
+ * server names it in the push a change causes, and this window skips that
+ * push: its panel re-reads after every write it makes (DEF-PANE-370-OWN-PUSH). */
+export declare const WINDOW_ID: string;
+export declare const WINDOW_HEADER = "X-AI-Assistants-Window";
 /**
  * DEF-72: how long a single server call may run before the client gives up.
  *

package/lib/core/request.js

@@ -1,8 +1,14 @@
 import { URLExt } from '@jupyterlab/coreutils';
 import { ServerConnection } from '@jupyterlab/services';
+import { UUID } from '@lumino/coreutils';
 import { LOG_PREFIX } from './registry';
 /** The server extension's API namespace. Every route lives under it. */
 export const API_NAMESPACE = 'jupyterlab-ai-code-assistants-extension';
+/** This window's name, sent with every request in {@link WINDOW_HEADER}. The
+ * server names it in the push a change causes, and this window skips that
+ * push: its panel re-reads after every write it makes (DEF-PANE-370-OWN-PUSH). */
+export const WINDOW_ID = UUID.uuid4();
+export const WINDOW_HEADER = 'X-AI-Assistants-Window';
 /**
  * DEF-72: how long a single server call may run before the client gives up.
  *
@@ -68,6 +74,15 @@ export function isRequestTimeout(err) {
 export async function requestAPI(endPoint, serverSettings, init = {}) {
     var _a, _b;
     const requestUrl = URLExt.join(serverSettings.baseUrl, API_NAMESPACE, endPoint);
+    // shortcut: a `Headers` instance in `init.headers` would be dropped here; no
+    // caller passes one.
+    init = {
+        ...init,
+        headers: {
+            ...init.headers,
+            [WINDOW_HEADER]: WINDOW_ID
+        }
+    };
     // DEF-72: `ServerConnection.makeRequest` sets no deadline of its own, so
     // without this a wedged server holds the call for as long as the browser
     // will hold the socket. Hand-rolled rather than `AbortSignal.timeout`, which

package/lib/core/types.d.ts

@@ -163,8 +163,12 @@ export interface IDisposalReport {
     removed_ids: string[];
 }
 export type IRemoveResponse = IDisposalReport;
-export type ICleanupResponse = IDisposalReport;
-export type IDeleteSessionsResponse = IDisposalReport;
+/** A delete of chosen conversations also names the ones it kept because a
+ * live terminal runs them (ACC-SESS-57). */
+export interface IDeleteSessionsResponse extends IDisposalReport {
+    live_ids: string[];
+}
+export type ICleanupResponse = IDeleteSessionsResponse;
 export interface IBranch {
     session_id: string;
     file_mtime: number;