@deepseek-harness-tui/dsh-tui 0.12.0 → 0.14.0

package/lib/types/screens/sessionSupervisor/useSessionSupervisor.js

@@ -13,12 +13,13 @@
  */
 import React, { useCallback, useMemo, useRef, useState } from 'react';
 import { basename } from 'node:path';
+import { formatSessionRef } from '../../agent/refs.js';
 import { t } from '../../i18n.js';
 import { normalizeWorkspaceCwd } from '../../sessions/view.js';
-import { readSessionPins, setSessionPinned } from '../../sessionPins.js';
+import { readSessionPins, sessionPinsDir, setSessionPinned } from '../../sessionPins.js';
 import { readSessionOwners } from '../../sessionMounts.js';
 import { resumeFailureText } from '../../sessions/resumeFailure.js';
-import { RAIL_CHROME_ROWS, WORKSPACE_ROW_LINES, RAIL_MIN_TOTAL_COLUMNS, RAIL_WIDTH_MIN, RAIL_WIDTH_MAX, SESSION_ROW_LINES, SESSION_PANE_CHROME_ROWS, noticeLines, MENU_ACTIONS, UNREGISTERED_RAIL_ID, message, samePath, sessionMatchesQuery } from './model.js';
+import { RAIL_CHROME_ROWS, WORKSPACE_ROW_LINES, RAIL_MIN_TOTAL_COLUMNS, RAIL_WIDTH_MIN, RAIL_WIDTH_MAX, SESSION_ROW_LINES, SESSION_PANE_CHROME_ROWS, noticeLines, menuActionsFor, UNREGISTERED_RAIL_ID, message, samePath, sessionMatchesQuery } from './model.js';
 const listingSnapshots = new WeakMap();
 /**
  * The snapshot slot for one channel, created on first use.
@@ -40,6 +41,20 @@ function snapshotSlot(channel) {
  */
 export function useSessionSupervisor(input) {
     const { channel, home, onOpenSession, onNewSession, onStopSession, liveStateOf, columns, rows } = input;
+    /**
+     * The bound backend: the screen lists ITS sessions. A DSH
+     * channel (or a partial headless one without a snapshot) keeps today's
+     * screen exactly; another backend has no workspace ledger (`/workspace` is
+     * a DSH command), keeps its pins in its own file, and its rows are
+     * renamed / deleted through its catalog.
+     */
+    // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: headless hosts pass partial channels
+    const backendId = channel.backendCapabilities?.backendId ?? 'dsh';
+    // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: headless hosts pass partial channels
+    const workspaceLedger = channel.backendCapabilities?.commands.includes('workspace') ?? true;
+    const dshBackend = backendId === 'dsh';
+    const archiveSessions = channel.backendCapabilities?.deleteAction === 'archive';
+    const pinsDir = sessionPinsDir(backendId);
     const [entries, setEntries] = useState([]);
     // Lazy so a non-empty snapshot from this channel's previous mount paints as
     // the first frame, including after restart; undefined alone means unknown.
@@ -84,9 +99,11 @@ export function useSessionSupervisor(input) {
         occupancyRef.current = readSessionOwners();
     }
     const holderOf = useCallback((sessionId) => {
-        const owner = occupancyRef.current.get(sessionId);
+        // The ledger keys a non-DSH session by its backend-qualified reference
+        // (`claude:<id>`); DSH ids stay bare.
+        const owner = occupancyRef.current.get(formatSessionRef({ backendId, sessionId }));
         return owner === undefined || owner.pid === process.pid ? undefined : owner.pid;
-    }, []);
+    }, [backendId]);
     /**
      * Sessions eligible for this screen, computed ONCE per listing so the rail's
      * per-workspace counts and the pane's rows always agree.
@@ -175,12 +192,14 @@ export function useSessionSupervisor(input) {
     const countOf = useCallback((entry) => (groupedEntries.get(entry.path) ?? []).length, [groupedEntries]);
     const [railFocus, setRailFocus] = useState(0);
     /**
-     * A rail entry the user picked by hand that is NOT registered — the fallback
-     * group for unregistered sessions. It exists only for this screen's lifetime:
-     * selecting a group is a way to SEE those sessions, never a way to register a
-     * directory, so it must not create a ledger record.
+     * The id of the fallback-group row the user picked by hand — unregistered
+     * groups are identified by their own id, never by "some group": a backend
+     * without the workspace ledger has ONE such group per directory, and a pick
+     * that forgot WHICH one kept resolving to the first. It exists only for this
+     * screen's lifetime: selecting a group is a way to SEE those sessions, never
+     * a way to register a directory, so it must not create a ledger record.
      */
-    const [selectedUnregistered, setSelectedUnregistered] = useState(false);
+    const [selectedUnregisteredId, setSelectedUnregisteredId] = useState(undefined);
     const [selectedPath, setSelectedPath] = useState(undefined);
     /** True once the user picked a rail row by hand; see the selection effect. */
     const [selectionManual, setSelectionManual] = useState(false);
@@ -212,7 +231,10 @@ export function useSessionSupervisor(input) {
      * no answer, and ←/→ is how this screen answers it.
      */
     const [activePane, setActivePane] = useState('rail');
-    const [pins, setPins] = useState(() => readSessionPins());
+    const [pins, setPins] = useState(() => readSessionPins(pinsDir));
+    /** A stored session being renamed / confirmed for deletion (non-DSH rows). */
+    const [sessionRename, setSessionRename] = useState(undefined);
+    const [confirmDelete, setConfirmDelete] = useState(undefined);
     const [menu, setMenu] = useState(undefined);
     const [rename, setRename] = useState(undefined);
     const [confirmRemove, setConfirmRemove] = useState(undefined);
@@ -296,7 +318,7 @@ export function useSessionSupervisor(input) {
             })(),
             (async () => {
                 try {
-                    const registry = typeof channel.listWorkspaceRegistry === 'function'
+                    const registry = typeof channel.listWorkspaceRegistry === 'function' && workspaceLedger
                         ? await channel.listWorkspaceRegistry()
                         : [];
                     if (slot.requestGeneration !== generation)
@@ -316,7 +338,7 @@ export function useSessionSupervisor(input) {
             setLoading(false);
             setRefreshing(false);
         }
-    }, [channel]);
+    }, [channel, workspaceLedger]);
     React.useEffect(() => {
         void reload();
     }, [reload]);
@@ -352,13 +374,17 @@ export function useSessionSupervisor(input) {
         // A hand-picked fallback group stays picked while it is still on the rail.
         // Without this the group would be dropped on the very next listing pass and
         // the sessions it was showing would vanish again.
-        if (selectionManual && selectedUnregistered
-            && railEntries.some(entry => entry.from === 'unregistered'))
+        if (selectionManual && selectedUnregisteredId !== undefined
+            && railEntries.some(entry => entry.id === selectedUnregisteredId))
             return;
-        const here = railEntries.find(entry => entry.from === 'registry' && samePath(entry.path, channel.cwd));
+        // The terminal's own directory, registered OR a fallback group: a backend
+        // without the workspace ledger lists every directory as a group of its own,
+        // and its rail must open on the one this terminal is in just the same.
+        const here = railEntries.find(entry => entry.from === 'registry' && samePath(entry.path, channel.cwd))
+            ?? railEntries.find(entry => entry.from === 'unregistered' && samePath(entry.path, channel.cwd));
         const next = here ?? railEntries[0];
         setSelectedPath(next.from === 'registry' ? next.path : undefined);
-        setSelectedUnregistered(next.from === 'unregistered');
+        setSelectedUnregisteredId(next.from === 'unregistered' ? next.id : undefined);
         // The cursor travels with an automatic selection. It starts at 0, so
         // leaving it there while the selection lands elsewhere paints two green
         // rows — `❯` on the first record and the marker on the selected one — until
@@ -369,7 +395,7 @@ export function useSessionSupervisor(input) {
             const index = railEntries.findIndex(entry => entry.id === next.id);
             return index < 0 || current === index ? current : index;
         });
-    }, [railEntries, selectedPath, selectedUnregistered, selectionManual, channel.cwd]);
+    }, [railEntries, selectedPath, selectedUnregisteredId, selectionManual, channel.cwd]);
     // The cursor indexes the entry list directly (there is no `+` row in front of
     // it), so a shrinking ledger has to pull it back inside or the last row would
     // highlight nothing.
@@ -381,10 +407,10 @@ export function useSessionSupervisor(input) {
         const registered = railEntries.find(entry => entry.from === 'registry' && selectedPath !== undefined && samePath(entry.path, selectedPath));
         if (registered !== undefined)
             return registered;
-        if (selectedUnregistered)
-            return railEntries.find(entry => entry.from === 'unregistered');
+        if (selectedUnregisteredId !== undefined)
+            return railEntries.find(entry => entry.id === selectedUnregisteredId);
         return railEntries[0];
-    }, [railEntries, selectedPath, selectedUnregistered]);
+    }, [railEntries, selectedPath, selectedUnregisteredId]);
     /**
      * Sessions whose recorded cwd is the selected workspace, minus the search
      * filter. Live sessions in this workspace sort above stopped ones, then by
@@ -474,16 +500,57 @@ export function useSessionSupervisor(input) {
         setNotice({ text, tone });
     }, []);
     const persistPin = useCallback((id, pinned) => {
-        const result = setSessionPinned(id, pinned);
+        const result = setSessionPinned(id, pinned, pinsDir);
         if (!result.ok) {
             report(t('resume-pin-save-failed'), 'error');
             return;
         }
         setPins(result.pins);
-    }, [report]);
+    }, [report, pinsDir]);
+    /** Rename a stored session through the backend's catalog (non-DSH rows). */
+    const renameSession = useCallback((sessionId, title) => {
+        const next = title.trim();
+        if (next === '') {
+            report(t('home-rename-empty'), 'error');
+            return;
+        }
+        void channel.renameSessionTo(sessionId, next)
+            .then((ok) => {
+            if (ok)
+                return reload();
+            report(t('rename-failed', { err: '' }), 'error');
+            return undefined;
+        })
+            .catch(error => report(t('rename-failed', { err: message(error) }), 'error'));
+    }, [channel, reload, report]);
+    /**
+     * Delete a stored session through the backend's catalog (non-DSH rows):
+     * never the one this terminal is in, never one another terminal holds.
+     */
+    const deleteSession = useCallback((session) => {
+        if (liveStateOf(session.id)?.current === true) {
+            report(t(archiveSessions ? 'supervisor-archive-current' : 'supervisor-delete-current'), 'error');
+            return;
+        }
+        const holder = holderOf(session.id);
+        if (holder !== undefined) {
+            report(t('supervisor-occupied', { pid: holder }), 'error');
+            return;
+        }
+        void channel.deleteSession(session.id)
+            .then((ok) => {
+            if (!ok) {
+                report(t(archiveSessions ? 'supervisor-archive-failed' : 'supervisor-delete-failed', { name: session.title.text }), 'error');
+                return undefined;
+            }
+            report(t(archiveSessions ? 'supervisor-archived' : 'supervisor-deleted', { name: session.title.text }), 'info');
+            return reload();
+        })
+            .catch(error => report(t(archiveSessions ? 'session-archive-failed' : 'session-delete-failed', { err: message(error) }), 'error'));
+    }, [archiveSessions, channel, holderOf, liveStateOf, reload, report]);
     const selectEntry = useCallback((entry) => {
         setSelectedPath(entry.from === 'registry' ? entry.path : undefined);
-        setSelectedUnregistered(entry.from === 'unregistered');
+        setSelectedUnregisteredId(entry.from === 'unregistered' ? entry.id : undefined);
         setSelectionManual(true);
         setFocusSessionId(undefined);
     }, []);
@@ -550,8 +617,10 @@ export function useSessionSupervisor(input) {
     const removeEntry = useCallback((path) => {
         void channel.removeWorkspace(path)
             .then((ok) => {
-            if (ok)
+            if (ok) {
+                report(t('supervisor-workspace-removed'), 'info');
                 return reload();
+            }
             report(t('workspace-remove-unknown', { target: path }), 'error');
             return undefined;
         })
@@ -578,7 +647,9 @@ export function useSessionSupervisor(input) {
     }, []);
     const activateMenu = useCallback((entry, item) => {
         closeMenu();
-        const action = MENU_ACTIONS[item] ?? 'edit';
+        const action = menuActionsFor(entry)[item];
+        if (action === undefined)
+            return;
         if (action === 'edit')
             selectEntry(entry);
         else if (action === 'new')
@@ -619,6 +690,14 @@ export function useSessionSupervisor(input) {
     /** The session under the cursor, or undefined while the card (row 0) holds it. */
     const focusedSession = sessionAt(sessionIndex);
     return {
+        dshBackend,
+        archiveSessions,
+        sessionRename,
+        setSessionRename,
+        confirmDelete,
+        setConfirmDelete,
+        renameSession,
+        deleteSession,
         entries,
         sessions,
         loading,

package/lib/types/sessionHistory.d.ts

@@ -20,7 +20,24 @@ export declare function readResumeTarget(): string | undefined;
  * @param argv - the app arguments from cmdlineArgs, after the host's own options.
  * @returns The requested session id, or undefined when none was given.
  */
-export declare function resumeTargetFromArgv(argv: readonly string[]): string | undefined;
+export declare function resumeTargetFromArgv(argv: readonly string[], 
+/** What a bare flag resumes: DSH's exit-time marker by default; another
+ *  backend passes its own (a Claude id never lives in `resume.txt`). */
+readFallback?: () => string | undefined): string | undefined;
+/**
+ * Drop the resume flags {@link resumeTargetFromArgv} recognizes (the same
+ * grammar, through the same helpers).
+ *
+ * A kernel switch respawns the process onto the OTHER backend: this
+ * kernel's session id means nothing there, and an inherited `--resume
+ * <id>` in argv would send the replacement looking for a session that
+ * belongs to the kernel it just left (DSH's `resume.txt` marker is
+ * already deleted by restartTui for the same reason). `--` still ends
+ * option parsing.
+ * @param argv - App arguments, exactly as passed to the replacement.
+ * @returns A copy without those flags (and without the id they consumed).
+ */
+export declare function stripResumeArgs(argv: readonly string[]): string[];
 /**
  * Session-id → last-used epoch ms map for MRU ordering.
  * @returns The parsed map; best effort, an unreadable file yields {}.

package/lib/types/sessionHistory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessionHistory.d.ts","sourceRoot":"","sources":["../../src/sessionHistory.ts"],"names":[],"mappings":"AAyCA;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAGzD;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,IAAI,IAAI,CAMxC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAOrD;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAgBhF;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAyB/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAUpD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAYrD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiBxE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQ7D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAU9D"}
+{"version":3,"file":"sessionHistory.d.ts","sourceRoot":"","sources":["../../src/sessionHistory.ts"],"names":[],"mappings":"AAyCA;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAGzD;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,IAAI,IAAI,CAMxC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAOrD;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,MAAM,EAAE;AACvB;wEACwE;AACxE,YAAY,GAAE,MAAM,MAAM,GAAG,SAA4B,GACxD,MAAM,GAAG,SAAS,CAgBpB;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAejE;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAyB/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAUpD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAYrD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiBxE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQ7D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAU9D"}

package/lib/types/sessionHistory.js

@@ -76,27 +76,69 @@ export function readResumeTarget() {
  * @param argv - the app arguments from cmdlineArgs, after the host's own options.
  * @returns The requested session id, or undefined when none was given.
  */
-export function resumeTargetFromArgv(argv) {
+export function resumeTargetFromArgv(argv, 
+/** What a bare flag resumes: DSH's exit-time marker by default; another
+ *  backend passes its own (a Claude id never lives in `resume.txt`). */
+readFallback = readResumeTarget) {
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
         if (a === '--')
             break;
-        if (a === '--resume' || a === '-c' || a === '--continue' || a.startsWith('--resume=')) {
+        if (isResumeFlag(a)) {
             let sessionId = '';
             if (a.startsWith('--resume=')) {
                 sessionId = a.slice('--resume='.length).trim();
             }
-            else if (a === '--resume' && argv[i + 1] !== undefined && !argv[i + 1].startsWith('-')) {
+            else if (resumeTakesNextArg(argv, i)) {
                 sessionId = argv[++i].trim();
             }
             if (!sessionId)
-                sessionId = readResumeTarget() ?? '';
+                sessionId = readFallback() ?? '';
             if (sessionId)
                 return sessionId;
         }
     }
     return undefined;
 }
+/** A resume flag of the app argv grammar shared by the two functions here. */
+function isResumeFlag(arg) {
+    return arg === '--resume' || arg === '-c' || arg === '--continue' || arg.startsWith('--resume=');
+}
+/** `--resume <id>`: the bare flag consumes the next argument unless it is an option. */
+function resumeTakesNextArg(argv, index) {
+    const next = argv[index + 1];
+    return argv[index] === '--resume' && next !== undefined && !next.startsWith('-');
+}
+/**
+ * Drop the resume flags {@link resumeTargetFromArgv} recognizes (the same
+ * grammar, through the same helpers).
+ *
+ * A kernel switch respawns the process onto the OTHER backend: this
+ * kernel's session id means nothing there, and an inherited `--resume
+ * <id>` in argv would send the replacement looking for a session that
+ * belongs to the kernel it just left (DSH's `resume.txt` marker is
+ * already deleted by restartTui for the same reason). `--` still ends
+ * option parsing.
+ * @param argv - App arguments, exactly as passed to the replacement.
+ * @returns A copy without those flags (and without the id they consumed).
+ */
+export function stripResumeArgs(argv) {
+    const out = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--') {
+            out.push(...argv.slice(i));
+            break;
+        }
+        if (isResumeFlag(a)) {
+            if (resumeTakesNextArg(argv, i))
+                i++;
+            continue;
+        }
+        out.push(a);
+    }
+    return out;
+}
 /**
  * Session-id → last-used epoch ms map for MRU ordering.
  * @returns The parsed map; best effort, an unreadable file yields {}.

package/lib/types/sessionPins.d.ts

@@ -7,6 +7,13 @@
  * header): stable across log revisions. Missing sessions are tolerated — the
  * browser filters pins against the live listing instead of rewriting them.
  */
+/**
+ * Where one backend's pins live: DSH's at the data directory root (unchanged),
+ * any other backend's under `backends/<id>/` — a Claude session id pinned in
+ * the Claude browser never reorders the DSH one.
+ * @param backendId - The browser's backend (`dsh` when absent).
+ */
+export declare function sessionPinsDir(backendId: string | undefined, dir?: string): string;
 /**
  * The persisted pin set, or empty when unset or unreadable.
  * @param dir - Prefs directory (injectable for tests).

package/lib/types/sessionPins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessionPins.d.ts","sourceRoot":"","sources":["../../src/sessionPins.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAwHH;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,GAAE,MAAiB,GAAG,WAAW,CAAC,MAAM,CAAC,CAM3E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,GAAG,GAAE,MAAiB,GAAG,OAAO,CAQvF;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACnC,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,OAAO,EACf,GAAG,GAAE,MAAiB,GACrB,wBAAwB,CAmB1B"}
+{"version":3,"file":"sessionPins.d.ts","sourceRoot":"","sources":["../../src/sessionPins.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAwHH;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,GAAE,MAAiB,GAAG,MAAM,CAE5F;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,GAAE,MAAiB,GAAG,WAAW,CAAC,MAAM,CAAC,CAM3E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,GAAG,GAAE,MAAiB,GAAG,OAAO,CAQvF;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACnC,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,OAAO,EACf,GAAG,GAAE,MAAiB,GACrB,wBAAwB,CAmB1B"}

package/lib/types/sessionPins.js

@@ -119,6 +119,15 @@ function releasePinsLock(fd, dir) {
         // A stale lock is recoverable on the next mutation.
     }
 }
+/**
+ * Where one backend's pins live: DSH's at the data directory root (unchanged),
+ * any other backend's under `backends/<id>/` — a Claude session id pinned in
+ * the Claude browser never reorders the DSH one.
+ * @param backendId - The browser's backend (`dsh` when absent).
+ */
+export function sessionPinsDir(backendId, dir = DATA_DIR) {
+    return backendId === undefined || backendId === 'dsh' ? dir : join(dir, 'backends', backendId.replace(/[^A-Za-z0-9._-]/gu, '_'));
+}
 /**
  * The persisted pin set, or empty when unset or unreadable.
  * @param dir - Prefs directory (injectable for tests).

package/lib/types/sessions/resumeFailure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resumeFailure.d.ts","sourceRoot":"","sources":["../../../src/sessions/resumeFailure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAGvD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAc1E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAO9D"}
+{"version":3,"file":"resumeFailure.d.ts","sourceRoot":"","sources":["../../../src/sessions/resumeFailure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAIvD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAc1E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAO9D"}

package/lib/types/sessions/resumeFailure.js

@@ -16,6 +16,7 @@
  * @module @deepseek-harness-tui/dsh-tui/sessions/resumeFailure
  */
 import { t } from '../i18n.js';
+import { WORKING_GATE_NOTICES } from '../commands.js';
 /**
  * The message for a failed mount, or undefined when it should stay silent.
  * @param result - The adapter's mount outcome.
@@ -28,7 +29,7 @@ export function resumeFailureText(result) {
         case 'cancelled':
             return undefined;
         case 'working':
-            return t('resume-while-working');
+            return t(WORKING_GATE_NOTICES.resume);
         case 'unavailable':
             return t('resume-unavailable');
         case 'occupied':

package/lib/types/settings/definitions.d.ts

@@ -13,6 +13,87 @@ import type { TuiSettingsField } from '../adapter/ports/channel-settings.js';
 import type { ShortcutActionId } from '../utils/keymap.js';
 export type SettingDefinition = Pick<TuiSettingsField, 'label' | 'descriptions' | 'hint' | 'hintDescriptions' | 'kind' | 'group' | 'options'>;
 export declare const SETTING_DEFINITIONS: {
+    brand: {
+        label: string;
+        descriptions: {
+            zh: string;
+        };
+        group: string;
+        hint: string;
+        hintDescriptions: {
+            zh: string;
+        };
+        kind: "select";
+        options: readonly {
+            readonly value: import("../branding.js").BrandSetting;
+            readonly label: string;
+            readonly descriptions: {
+                readonly zh: string;
+            };
+        }[];
+    };
+    'btw.contextBudget': {
+        label: string;
+        descriptions: {
+            zh: string;
+        };
+        group: string;
+        hint: string;
+        hintDescriptions: {
+            zh: string;
+        };
+        kind: "number";
+    };
+    'btw.contextTurns': {
+        label: string;
+        descriptions: {
+            zh: string;
+        };
+        group: string;
+        hint: string;
+        hintDescriptions: {
+            zh: string;
+        };
+        kind: "number";
+    };
+    codeFrameStyle: {
+        label: string;
+        descriptions: {
+            zh: string;
+        };
+        group: string;
+        hint: string;
+        hintDescriptions: {
+            zh: string;
+        };
+        kind: "select";
+        options: {
+            value: string;
+            label: string;
+            descriptions: {
+                zh: string;
+            };
+        }[];
+    };
+    'companion.skin': {
+        label: string;
+        descriptions: {
+            zh: string;
+        };
+        group: string;
+        hint: string;
+        hintDescriptions: {
+            zh: string;
+        };
+        kind: "select";
+        options: {
+            value: string;
+            label: string;
+            descriptions: {
+                zh: string;
+            };
+        }[];
+    };
     diffLayout: {
         label: string;
         descriptions: {
@@ -106,6 +187,25 @@ export declare const SETTING_DEFINITIONS: {
             };
         }[];
     };
+    jobGroupFold: {
+        label: string;
+        descriptions: {
+            zh: string;
+        };
+        group: string;
+        hint: string;
+        hintDescriptions: {
+            zh: string;
+        };
+        kind: "select";
+        options: {
+            value: string;
+            label: string;
+            descriptions: {
+                zh: string;
+            };
+        }[];
+    };
     lang: {
         label: string;
         descriptions: {
@@ -268,6 +368,54 @@ export declare const SETTING_DEFINITIONS: {
             };
         }[];
     };
+    'sidePanel.open': {
+        label: string;
+        descriptions: {
+            zh: string;
+        };
+        group: string;
+        hint: string;
+        hintDescriptions: {
+            zh: string;
+        };
+        kind: "boolean";
+    };
+    'sidePanel.panels': {
+        label: string;
+        descriptions: {
+            zh: string;
+        };
+        group: string;
+        hint: string;
+        hintDescriptions: {
+            zh: string;
+        };
+        kind: "text";
+    };
+    'sidePanel.ratio': {
+        label: string;
+        descriptions: {
+            zh: string;
+        };
+        group: string;
+        hint: string;
+        hintDescriptions: {
+            zh: string;
+        };
+        kind: "number";
+    };
+    'sidePanel.splitEnabled': {
+        label: string;
+        descriptions: {
+            zh: string;
+        };
+        group: string;
+        hint: string;
+        hintDescriptions: {
+            zh: string;
+        };
+        kind: "boolean";
+    };
     smoothStreaming: {
         label: string;
         descriptions: {
@@ -559,6 +707,18 @@ export declare const SETTING_DEFINITIONS: {
             };
         }[];
     };
+    turnUsageRow: {
+        label: string;
+        descriptions: {
+            zh: string;
+        };
+        group: string;
+        hint: string;
+        hintDescriptions: {
+            zh: string;
+        };
+        kind: "boolean";
+    };
     whale: {
         label: string;
         descriptions: {
@@ -649,6 +809,13 @@ export declare const SETTING_GROUPS: readonly [{
     readonly descriptions: {
         readonly zh: "底栏设置";
     };
+}, {
+    readonly id: "side-panel";
+    readonly mode: "page";
+    readonly title: "Side panel";
+    readonly descriptions: {
+        readonly zh: "侧栏";
+    };
 }, {
     readonly id: "shortcuts";
     readonly mode: "page";

package/lib/types/settings/definitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../../src/settings/definitions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAA;AAE5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE1D,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,EAAE,OAAO,GAAG,cAAc,GAAG,MAAM,GAAG,kBAAkB,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAAA;AAE7I,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyYa,CAAA;AAE7C,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,mBAAmB,CAAA;AAEzD;;;;;;;;;yCASyC;AACzC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQjB,CAAA;AAEV;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAEjD,CAAA;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,GAAG,EAAE,UAAU,GAAG,iBAAiB,GAAG;IAAE,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAE7F;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,gBAAgB,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;CAAE,CA+EnK,CAAA"}
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../../src/settings/definitions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAA;AAG5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE1D,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,EAAE,OAAO,GAAG,cAAc,GAAG,MAAM,GAAG,kBAAkB,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAAA;AAE7I,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgfa,CAAA;AAE7C,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,mBAAmB,CAAA;AAEzD;;;;;;;;;yCASyC;AACzC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASjB,CAAA;AAEV;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAEjD,CAAA;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,GAAG,EAAE,UAAU,GAAG,iBAAiB,GAAG;IAAE,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAE7F;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,gBAAgB,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;CAAE,CAuGnK,CAAA"}