@askdkc/dsh-cli 0.11.3

package/lib/types/sessions/resumeFailure.js

@@ -0,0 +1,58 @@
+/**
+ * One wording for "why a session could not be mounted".
+ *
+ * Four surfaces can refuse a mount — the supervisor, the session browser, the
+ * workspace home screen and the transcript itself — and each used to spell the
+ * same failures out on its own. That is how `/resume` and `/agentview` ended
+ * up telling the user different things about the same refusal, and it is why a
+ * newly added reason (the cross-process occupancy case) would have been
+ * silently mis-reported as a generic failure on whichever surface was missed.
+ *
+ * The mapping is pure and total: it takes the adapter's discriminated result
+ * and returns the sentence to show, or `undefined` for the outcomes that need
+ * no words. The `cancelled` case is deliberately silent — the user (or a rival
+ * switch) asked for it, so there is nothing to explain.
+ *
+ * @module dsh-cli/sessions/resumeFailure
+ */
+import { t } from '../i18n.js';
+/**
+ * The message for a failed mount, or undefined when it should stay silent.
+ * @param result - The adapter's mount outcome.
+ * @returns The user-facing sentence, or undefined for `cancelled`.
+ */
+export function resumeFailureText(result) {
+    if (result.ok)
+        return undefined;
+    switch (result.reason) {
+        case 'cancelled':
+            return undefined;
+        case 'working':
+            return t('resume-while-working');
+        case 'unavailable':
+            return t('resume-unavailable');
+        case 'occupied':
+            return t('resume-session-occupied', { pid: result.pid });
+        case 'failed':
+            return t('session-resume-failed', { err: result.error });
+    }
+}
+/**
+ * The sentence for a ledger refusal that did NOT find a holder.
+ *
+ * A refusal to CHECK is not a refusal by a peer, so it must not borrow the
+ * "another terminal holds it" wording — that would invent a terminal. The
+ * `occupied` case is here too because it is a {@link MountFailure} and its
+ * sentence already exists; {@link resumeFailureText} reaches the same key from
+ * the adapter's own result.
+ * @param failure - Why the session could not be claimed.
+ * @returns The user-facing sentence.
+ */
+export function mountFailureText(failure) {
+    if (failure.reason === 'occupied') {
+        return t('resume-session-occupied', { pid: failure.holders[0] ?? 0 });
+    }
+    return failure.reason === 'busy'
+        ? t('resume-mount-busy')
+        : t('resume-mount-unavailable', { detail: failure.detail });
+}

package/lib/types/sessions/view.d.ts

@@ -0,0 +1,162 @@
+/**
+ * The session browser's view model.
+ *
+ * Every decision about *which* sessions are on screen and in what order lives
+ * here, as one pure function from the full list plus the current filters to a
+ * flat list of rows. Two reasons it is shaped that way:
+ *
+ * - Filtering is where this feature's bugs were. Keeping it pure means the
+ *   truth table — a sub-agent run is hidden, an unrelated rewind fork is not,
+ *   a boot artifact is hidden but counted — is checkable without rendering
+ *   anything.
+ * - Rows are flattened rather than nested. A windowed list of variable-height
+ *   groups has to guess how much room each group needs; a flat list of
+ *   single-line rows is windowed by arithmetic, and the group headers simply
+ *   travel with their sessions.
+ *
+ * @module dsh-cli/sessions/view
+ */
+import type { SessionSummary } from '../dsh-adapter/sessions/index.js';
+/** What the browser is currently showing. */
+export interface BrowserFilters {
+    /** Free-text query; empty means no text filter. */
+    readonly query: string;
+    /** Show every project, not just the session's own working directory. */
+    readonly allProjects: boolean;
+    /** Show only sessions last used on the current git branch. */
+    readonly branchOnly: boolean;
+    /** Reveal delegated sub-agent runs, indented under their parents. */
+    readonly showSubagents: boolean;
+}
+/** The browser's default view: this project, conversations only. */
+export declare const DEFAULT_FILTERS: BrowserFilters;
+/** One line in the browser's list. */
+export type BrowserRow = {
+    readonly kind: 'project';
+    readonly project: string;
+    readonly count: number;
+}
+/** Header of the pinned group; always the first rows in the view. */
+ | {
+    readonly kind: 'pin';
+    readonly count: number;
+} | {
+    readonly kind: 'session';
+    readonly session: SessionSummary;
+    readonly depth: number;
+};
+/** The rendered list plus what it left out and why. */
+export interface BrowserView {
+    readonly rows: readonly BrowserRow[];
+    /** Sessions shown, excluding group headers. */
+    readonly shown: number;
+    /** Delegated runs folded away by the current filters. */
+    readonly hiddenSubagents: number;
+    /** Sessions with no conversation in them, never listed but worth counting. */
+    readonly emptyCount: number;
+    /** Ids of those empty sessions, for the cleanup action. */
+    readonly emptyIds: readonly string[];
+}
+/** Live-session facts shared by the directory index and session projection. */
+export interface BrowserContext {
+    readonly cwd: string;
+    readonly branch: string | undefined;
+    readonly currentId: string;
+    readonly sameProject: (a: string, b: string) => boolean;
+}
+/** One selectable working-directory bucket in the resume browser. */
+export interface WorkspaceGroup {
+    /** Stable within one listing; `current` is reserved for the live workspace. */
+    readonly id: string;
+    /** Representative cwd shown in the directory list and used as session scope. */
+    readonly cwd: string;
+    /** Resumable top-level conversations in this directory bucket. */
+    readonly count: number;
+    /** Most recent resumable conversation activity, or 0 for an empty current bucket. */
+    readonly updatedAt: number;
+    /** The compatibility bucket anchored at the live session's cwd. */
+    readonly current: boolean;
+}
+/** Normalize an exact historical cwd key without treating ancestors as equal. */
+export declare function normalizeWorkspaceCwd(cwd: string): string;
+/**
+ * Build the explicit working-directory menu.
+ *
+ * Only the live cwd gets the historical same-project compatibility rule: old
+ * versions recorded repository subdirectories, so those sessions still belong
+ * under the current workspace. Every remaining directory is grouped by its
+ * normalized exact cwd. Applying sameProject transitively to arbitrary history
+ * would merge sibling projects through a common ancestor and is deliberately
+ * avoided.
+ */
+export declare function buildWorkspaceGroups(sessions: readonly SessionSummary[], context: BrowserContext): readonly WorkspaceGroup[];
+/**
+ * Build the browser's rows.
+ *
+ * @param sessions - Every stored session, newest first, as the adapter listed
+ *   them. Nothing is pre-filtered.
+ * @param filters - The current view.
+ * @param context - The session doing the browsing: its working directory
+ *   anchors the default project filter, its branch the branch filter, and its
+ *   own id is never offered (a live session cannot be resumed into itself).
+ * @param pinned - Pinned session ids (from the persisted preference). A pin
+ *   on a session the current filters already exclude is invisible here — pins
+ *   float to the top OF the view, they do not widen it.
+ * @returns The flat row list and the counts behind what it hides.
+ */
+export declare function buildView(sessions: readonly SessionSummary[], filters: BrowserFilters, context: BrowserContext, pinned?: ReadonlySet<string>): BrowserView;
+/**
+ * Index of the first selectable row at or after `from`.
+ *
+ * Group headers are rows but not targets, so every movement resolves through
+ * here rather than each caller re-deriving "is this one selectable".
+ *
+ * @param rows - The view's rows.
+ * @param from - Where to start looking.
+ * @param step - +1 to search forward, -1 backward.
+ * @returns The index, or -1 when no selectable row lies that way.
+ */
+export declare function seekSelectable(rows: readonly BrowserRow[], from: number, step: 1 | -1): number;
+/**
+ * Move the selection by one selectable row, wrapping at both ends.
+ *
+ * @param rows - The view's rows.
+ * @param current - Current index.
+ * @param step - +1 for down, -1 for up.
+ * @returns The new index, or the current one when nothing is selectable.
+ */
+export declare function moveSelection(rows: readonly BrowserRow[], current: number, step: 1 | -1): number;
+/** The session under the cursor, when the cursor is on one. */
+export declare function sessionAt(rows: readonly BrowserRow[], index: number): SessionSummary | undefined;
+/** Lines one row occupies: a session shows a title and a metadata line. */
+export declare function rowHeight(row: BrowserRow): number;
+/**
+ * Where the visible window should start.
+ *
+ * Rows have different heights, so the window cannot be `focus ± n`: a slice
+ * that looks right by index can overflow the box by lines, and a fixed-height
+ * box whose content overflows renders its rows on top of each other. This
+ * resolves the window in LINES, which is the unit the box is measured in.
+ *
+ * The window is anchored rather than centred: it moves only as far as it must
+ * to keep the focused row fully visible, so scrolling a long list does not
+ * re-shuffle everything on screen under every keystroke.
+ *
+ * @param rows - The view's rows.
+ * @param focus - Index of the focused row.
+ * @param budget - Lines available to the list.
+ * @param previous - The previous window start, so a stationary focus keeps a
+ *   stationary window.
+ * @returns The new window start index.
+ */
+export declare function anchorTop(rows: readonly BrowserRow[], focus: number, budget: number, previous: number): number;
+/**
+ * How many rows starting at `top` fit in `budget` lines.
+ *
+ * @param rows - The view's rows.
+ * @param top - First visible row.
+ * @param budget - Lines available.
+ * @returns Exclusive end index of the visible slice.
+ */
+export declare function windowEnd(rows: readonly BrowserRow[], top: number, budget: number): number;
+//# sourceMappingURL=view.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../../src/sessions/view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AAEtE,6CAA6C;AAC7C,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,wEAAwE;IACxE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,qEAAqE;IACrE,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;CAChC;AAED,oEAAoE;AACpE,eAAO,MAAM,eAAe,EAAE,cAK7B,CAAA;AAED,sCAAsC;AACtC,MAAM,MAAM,UAAU,GAClB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AAChF,qEAAqE;GACnE;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE1F,uDAAuD;AACvD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,CAAA;IACpC,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,yDAAyD;IACzD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CACrC;AAED,+EAA+E;AAC/E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAA;CACxD;AAED,qEAAqE;AACrE,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,gFAAgF;IAChF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,qFAAqF;IACrF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIzD;AAmBD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,OAAO,EAAE,cAAc,GACtB,SAAS,cAAc,EAAE,CAsC3B;AAgBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,cAAc,EACvB,MAAM,GAAE,WAAW,CAAC,MAAM,CAAc,GACvC,WAAW,CAkJb;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAK9F;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAKhG;AAED,+DAA+D;AAC/D,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAGhG;AAED,2EAA2E;AAC3E,wBAAgB,SAAS,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAEjD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,CAoBR;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAU1F"}

package/lib/types/sessions/view.js

@@ -0,0 +1,350 @@
+/** The browser's default view: this project, conversations only. */
+export const DEFAULT_FILTERS = {
+    query: '',
+    allProjects: false,
+    branchOnly: false,
+    showSubagents: false,
+};
+/** Normalize an exact historical cwd key without treating ancestors as equal. */
+export function normalizeWorkspaceCwd(cwd) {
+    const slashed = cwd.replace(/\\/g, '/');
+    const normalized = /^\/+$/u.test(slashed) ? '/' : slashed.replace(/\/+$/, '');
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+/** Current session plus the fork ancestors that continuing it superseded. */
+function hiddenLineageIds(sessions, currentId) {
+    const byId = new Map(sessions.map(session => [session.id, session]));
+    const hidden = new Set([currentId]);
+    let cursor = byId.get(currentId);
+    while (cursor?.kind.kind === 'fork') {
+        const parent = cursor.kind.parent;
+        if (hidden.has(parent))
+            break;
+        hidden.add(parent);
+        cursor = byId.get(parent);
+    }
+    return hidden;
+}
+/** Shared empty pin set: `buildView` without pins allocates nothing. */
+const EMPTY_PINS = new Set();
+/**
+ * Build the explicit working-directory menu.
+ *
+ * Only the live cwd gets the historical same-project compatibility rule: old
+ * versions recorded repository subdirectories, so those sessions still belong
+ * under the current workspace. Every remaining directory is grouped by its
+ * normalized exact cwd. Applying sameProject transitively to arbitrary history
+ * would merge sibling projects through a common ancestor and is deliberately
+ * avoided.
+ */
+export function buildWorkspaceGroups(sessions, context) {
+    const hidden = hiddenLineageIds(sessions, context.currentId);
+    const conversations = sessions.filter(session => session.hasPrompt && session.kind.kind !== 'subagent' && !hidden.has(session.id));
+    const currentSessions = conversations.filter(session => context.sameProject(context.cwd, session.cwd));
+    const currentIds = new Set(currentSessions.map(session => session.id));
+    const current = {
+        id: 'current',
+        cwd: context.cwd,
+        count: currentSessions.length,
+        updatedAt: currentSessions.reduce((latest, session) => Math.max(latest, session.updatedAt), 0),
+        current: true,
+    };
+    const foreign = new Map();
+    for (const session of conversations) {
+        if (currentIds.has(session.id))
+            continue;
+        const key = normalizeWorkspaceCwd(session.cwd);
+        const existing = foreign.get(key);
+        if (existing === undefined) {
+            foreign.set(key, { cwd: session.cwd, count: 1, updatedAt: session.updatedAt });
+        }
+        else {
+            existing.count += 1;
+            existing.updatedAt = Math.max(existing.updatedAt, session.updatedAt);
+        }
+    }
+    const others = [...foreign.entries()]
+        .map(([key, group]) => ({
+        id: `cwd:${key || '<unknown>'}`,
+        cwd: group.cwd,
+        count: group.count,
+        updatedAt: group.updatedAt,
+        current: false,
+    }))
+        .sort((left, right) => right.updatedAt - left.updatedAt || left.id.localeCompare(right.id));
+    return [current, ...others];
+}
+/** Case-insensitive substring test over the fields a reader would search by. */
+function matches(session, needle) {
+    if (needle.length === 0)
+        return true;
+    const haystack = [
+        session.title.text,
+        session.cwd,
+        session.branch ?? '',
+        session.model ?? '',
+        session.label ?? '',
+        session.agentPreset ?? '',
+    ];
+    return haystack.some(field => field.toLowerCase().includes(needle));
+}
+/**
+ * Build the browser's rows.
+ *
+ * @param sessions - Every stored session, newest first, as the adapter listed
+ *   them. Nothing is pre-filtered.
+ * @param filters - The current view.
+ * @param context - The session doing the browsing: its working directory
+ *   anchors the default project filter, its branch the branch filter, and its
+ *   own id is never offered (a live session cannot be resumed into itself).
+ * @param pinned - Pinned session ids (from the persisted preference). A pin
+ *   on a session the current filters already exclude is invisible here — pins
+ *   float to the top OF the view, they do not widen it.
+ * @returns The flat row list and the counts behind what it hides.
+ */
+export function buildView(sessions, filters, context, pinned = EMPTY_PINS) {
+    const needle = filters.query.trim().toLowerCase();
+    // `/model` and `/rewind` continue the live conversation in a fork. Offering
+    // that fork's ancestors in `/resume` makes one conversation look like many,
+    // and selecting one silently jumps back before the fork. Only the live
+    // lineage is excluded: unrelated forks remain recoverable. Treat malformed
+    // cycles as a closed chain rather than looping forever over foreign data.
+    const hiddenLineage = hiddenLineageIds(sessions, context.currentId);
+    const inScope = (session) => !hiddenLineage.has(session.id) &&
+        (filters.allProjects || context.sameProject(context.cwd, session.cwd));
+    // Empty sessions never reach a view, but they are counted — and the count
+    // feeds a DESTRUCTIVE action, so it is scoped exactly as the list is.
+    // Counting them across every project while showing one project's rows would
+    // put "clean up 15 sessions" on screen next to six, and deleting another
+    // project's history from a view that never mentioned it is not a surprise
+    // anyone should get. The search query deliberately does NOT narrow it:
+    // typing a filter is about finding one session, not about redefining what
+    // "empty" means.
+    const emptyIds = [];
+    for (const session of sessions) {
+        if (!session.hasPrompt && inScope(session))
+            emptyIds.push(session.id);
+    }
+    const empty = new Set(emptyIds);
+    const eligible = sessions.filter(session => inScope(session) &&
+        !empty.has(session.id) &&
+        (!filters.branchOnly || (context.branch !== undefined && session.branch === context.branch)));
+    const conversations = eligible.filter(session => session.kind.kind !== 'subagent');
+    const runs = eligible.filter(session => session.kind.kind === 'subagent');
+    // A run is shown under its parent; one whose parent is not in this view
+    // (filtered out, or never listed) would otherwise be unreachable, so it is
+    // offered at the top level instead of silently dropped.
+    const byParent = new Map();
+    const orphans = [];
+    const visibleIds = new Set(conversations.map(session => session.id));
+    for (const run of runs) {
+        const parent = run.kind.kind === 'subagent' ? run.kind.parent : undefined;
+        if (parent !== undefined && visibleIds.has(parent)) {
+            const siblings = byParent.get(parent);
+            if (siblings === undefined)
+                byParent.set(parent, [run]);
+            else
+                siblings.push(run);
+        }
+        else {
+            orphans.push(run);
+        }
+    }
+    const top = filters.showSubagents ? [...conversations, ...orphans] : conversations;
+    const visible = top.filter(session => {
+        if (matches(session, needle))
+            return true;
+        // A parent whose own text does not match is still shown when one of its
+        // runs does — hiding it would strand the match under a row that is gone.
+        if (!filters.showSubagents)
+            return false;
+        return (byParent.get(session.id) ?? []).some(run => matches(run, needle));
+    });
+    const rows = [];
+    let shown = 0;
+    let lastProjectKey;
+    const visibleChildren = (session) => filters.showSubagents
+        ? (byParent.get(session.id) ?? []).filter(child => matches(child, needle) || matches(session, needle))
+        : [];
+    // Pinned sessions leave the ordinary flow entirely and form one group above
+    // every other row. Attached sub-agent rows participate too when the runs
+    // filter is on: pinning a visible child must not paint a star that stays
+    // buried under its parent. The child is promoted once and removed from the
+    // parent's ordinary children; orphan runs already live in `visible`.
+    const pinnedChildren = pinned.size > 0 && filters.showSubagents
+        ? visible.flatMap(session => visibleChildren(session).filter(child => pinned.has(child.id)))
+        : [];
+    const pinnedRows = pinned.size > 0
+        ? [
+            ...visible.filter(session => pinned.has(session.id)),
+            ...pinnedChildren,
+        ].sort((left, right) => right.updatedAt - left.updatedAt)
+        : [];
+    const pinnedRowIds = new Set(pinnedRows.map(session => session.id));
+    const emit = (session) => {
+        rows.push({ kind: 'session', session, depth: 0 });
+        shown += 1;
+        for (const run of visibleChildren(session)) {
+            if (pinnedRowIds.has(run.id))
+                continue;
+            rows.push({ kind: 'session', session: run, depth: 1 });
+            shown += 1;
+        }
+    };
+    const ordered = pinnedRows.length > 0
+        ? visible.filter(session => !pinnedRowIds.has(session.id))
+        : visible;
+    if (pinnedRows.length > 0) {
+        rows.push({ kind: 'pin', count: pinnedRows.length });
+        for (const session of pinnedRows)
+            emit(session);
+    }
+    ordered.sort((left, right) => right.updatedAt - left.updatedAt);
+    const projectKey = (session) => context.sameProject(context.cwd, session.cwd)
+        ? 'current'
+        : `cwd:${normalizeWorkspaceCwd(session.cwd) || '<unknown>'}`;
+    const projectDisplay = new Map();
+    const projectCounts = new Map();
+    if (filters.allProjects) {
+        // Use the SAME buckets as the directory menu: current-workspace legacy
+        // subdirectories coalesce, while foreign separator/case aliases share one
+        // exact normalized key. This keeps the rail and "all" view consistent.
+        const projectOrder = new Map();
+        for (const session of ordered) {
+            const key = projectKey(session);
+            if (!projectOrder.has(key))
+                projectOrder.set(key, projectOrder.size);
+            projectDisplay.set(key, key === 'current' ? context.cwd : projectDisplay.get(key) ?? session.cwd);
+            projectCounts.set(key, (projectCounts.get(key) ?? 0) + 1);
+        }
+        ordered.sort((left, right) => projectOrder.get(projectKey(left)) - projectOrder.get(projectKey(right)) || right.updatedAt - left.updatedAt);
+    }
+    for (const session of ordered) {
+        // Group headers only earn their line when more than one project is in
+        // play; inside a single project they would repeat the same path forever.
+        const key = projectKey(session);
+        if (filters.allProjects && key !== lastProjectKey) {
+            lastProjectKey = key;
+            rows.push({
+                kind: 'project',
+                project: projectDisplay.get(key) ?? session.cwd,
+                count: projectCounts.get(key) ?? 0,
+            });
+        }
+        emit(session);
+    }
+    return {
+        rows,
+        shown,
+        hiddenSubagents: filters.showSubagents ? 0 : runs.length,
+        emptyCount: emptyIds.length,
+        emptyIds,
+    };
+}
+/**
+ * Index of the first selectable row at or after `from`.
+ *
+ * Group headers are rows but not targets, so every movement resolves through
+ * here rather than each caller re-deriving "is this one selectable".
+ *
+ * @param rows - The view's rows.
+ * @param from - Where to start looking.
+ * @param step - +1 to search forward, -1 backward.
+ * @returns The index, or -1 when no selectable row lies that way.
+ */
+export function seekSelectable(rows, from, step) {
+    for (let at = from; at >= 0 && at < rows.length; at += step) {
+        if (rows[at]?.kind === 'session')
+            return at;
+    }
+    return -1;
+}
+/**
+ * Move the selection by one selectable row, wrapping at both ends.
+ *
+ * @param rows - The view's rows.
+ * @param current - Current index.
+ * @param step - +1 for down, -1 for up.
+ * @returns The new index, or the current one when nothing is selectable.
+ */
+export function moveSelection(rows, current, step) {
+    const next = seekSelectable(rows, current + step, step);
+    if (next >= 0)
+        return next;
+    const wrapped = seekSelectable(rows, step === 1 ? 0 : rows.length - 1, step);
+    return wrapped >= 0 ? wrapped : current;
+}
+/** The session under the cursor, when the cursor is on one. */
+export function sessionAt(rows, index) {
+    const row = rows[index];
+    return row?.kind === 'session' ? row.session : undefined;
+}
+/** Lines one row occupies: a session shows a title and a metadata line. */
+export function rowHeight(row) {
+    return row.kind === 'session' ? 2 : 1;
+}
+/**
+ * Where the visible window should start.
+ *
+ * Rows have different heights, so the window cannot be `focus ± n`: a slice
+ * that looks right by index can overflow the box by lines, and a fixed-height
+ * box whose content overflows renders its rows on top of each other. This
+ * resolves the window in LINES, which is the unit the box is measured in.
+ *
+ * The window is anchored rather than centred: it moves only as far as it must
+ * to keep the focused row fully visible, so scrolling a long list does not
+ * re-shuffle everything on screen under every keystroke.
+ *
+ * @param rows - The view's rows.
+ * @param focus - Index of the focused row.
+ * @param budget - Lines available to the list.
+ * @param previous - The previous window start, so a stationary focus keeps a
+ *   stationary window.
+ * @returns The new window start index.
+ */
+export function anchorTop(rows, focus, budget, previous) {
+    if (rows.length === 0 || budget <= 0)
+        return 0;
+    let top = Math.min(Math.max(0, previous), Math.max(0, rows.length - 1));
+    if (focus < top)
+        top = focus;
+    // Scroll down only until the focused row's last line fits.
+    for (;;) {
+        let used = 0;
+        for (let at = top; at <= focus; at++)
+            used += rowHeight(rows[at]);
+        if (used <= budget || top >= focus)
+            break;
+        top += 1;
+    }
+    // A window that has slack below the last row wastes it; pull the start back
+    // up so the final screenful is full rather than ragged.
+    let total = 0;
+    for (let at = top; at < rows.length; at++)
+        total += rowHeight(rows[at]);
+    while (top > 0 && total + rowHeight(rows[top - 1]) <= budget) {
+        top -= 1;
+        total += rowHeight(rows[top]);
+    }
+    return top;
+}
+/**
+ * How many rows starting at `top` fit in `budget` lines.
+ *
+ * @param rows - The view's rows.
+ * @param top - First visible row.
+ * @param budget - Lines available.
+ * @returns Exclusive end index of the visible slice.
+ */
+export function windowEnd(rows, top, budget) {
+    let used = 0;
+    let at = top;
+    while (at < rows.length) {
+        const next = used + rowHeight(rows[at]);
+        if (next > budget)
+            break;
+        used = next;
+        at += 1;
+    }
+    return at;
+}

package/lib/types/settings-sections.d.ts

@@ -0,0 +1,4 @@
+export { name, TuiSettingsSectionsRuntime } from './dsh-adapter/settings-sections.js';
+export type { TuiSettingsFieldKind, TuiSettingsFieldOption, TuiSettingsGroup, TuiSettingsFieldWrite, TuiSettingsField, TuiSettingsSection, } from './dsh-adapter/settings-sections.js';
+export { default } from './dsh-adapter/settings-sections.js';
+//# sourceMappingURL=settings-sections.d.ts.map

package/lib/types/settings-sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-sections.d.ts","sourceRoot":"","sources":["../../src/settings-sections.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAA;AACrF,YAAY,EACV,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAA"}

package/lib/types/settings-sections.js

@@ -0,0 +1,4 @@
+// Re-export shim: the Cordis-backed implementation lives behind the adapter
+// boundary so UI consumers never import official @deepseek-ai/* packages.
+export { name, TuiSettingsSectionsRuntime } from './dsh-adapter/settings-sections.js';
+export { default } from './dsh-adapter/settings-sections.js';

package/lib/types/terminal-utils/cliHighlight.d.ts

@@ -0,0 +1,20 @@
+/** The cli-highlight surface dsh-tui consumes: the syntax highlighter and the language support check. */
+export type CliHighlight = {
+    highlight: typeof import('cli-highlight').highlight;
+    supportsLanguage: typeof import('cli-highlight').supportsLanguage;
+};
+/**
+ * Return the shared cli-highlight load promise, starting the lazy load on first call.
+ * @returns A promise of the loaded cli-highlight surface, or null when the dynamic import fails.
+ */
+export declare function getCliHighlightPromise(): Promise<CliHighlight | null>;
+/**
+ * eg. "foo/bar.ts" → "TypeScript". Awaits the shared cli-highlight load,
+ * then reads highlight.js's language registry. All callers are telemetry
+ * (OTel counter attributes, permission-dialog unary events) — none block
+ * on this, they fire-and-forget or the consumer already handles Promise<string>.
+ * @param file_path - Source file path whose extension names the language.
+ * @returns The language display name, or 'unknown' when the extension is empty or unregistered.
+ */
+export declare function getLanguageName(file_path: string): Promise<string>;
+//# sourceMappingURL=cliHighlight.d.ts.map

package/lib/types/terminal-utils/cliHighlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cliHighlight.d.ts","sourceRoot":"","sources":["../../../src/terminal-utils/cliHighlight.ts"],"names":[],"mappings":"AASA,yGAAyG;AACzG,MAAM,MAAM,YAAY,GAAG;IACzB,SAAS,EAAE,cAAc,eAAe,EAAE,SAAS,CAAA;IACnD,gBAAgB,EAAE,cAAc,eAAe,EAAE,gBAAgB,CAAA;CAClE,CAAA;AA2BD;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAGrE;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAKxE"}

package/lib/types/terminal-utils/cliHighlight.js

@@ -0,0 +1,53 @@
+// highlight.js's type defs carry `/// <reference lib="dom" />`. SSETransport,
+// mcp/client, ssh, dumpPrompts use DOM types (TextDecodeOptions, RequestInfo)
+// that only typecheck because this file's `typeof import('highlight.js')` pulls
+// lib.dom in. tsconfig has lib: ["ESNext"] only — fixing the actual DOM-type
+// deps is a separate sweep; this ref preserves the status quo.
+/// <reference lib="dom" />
+import { extname } from 'path';
+// One promise shared by Fallback.tsx, markdown.ts, events.ts, getLanguageName.
+// The highlight.js import piggybacks: cli-highlight has already pulled it into
+// the module cache, so the second import() is a cache hit — no extra bytes
+// faulted in.
+let cliHighlightPromise;
+// highlight.js types vary by version; the language registry lookup is only
+// used by optional telemetry paths, so keep a loose signature.
+let loadedGetLanguage;
+async function loadCliHighlight() {
+    try {
+        const cliHighlight = await import('cli-highlight');
+        // cache hit — cli-highlight already loaded highlight.js
+        const highlightJs = await import('highlight.js');
+        loadedGetLanguage = highlightJs.getLanguage;
+        return {
+            highlight: cliHighlight.highlight,
+            supportsLanguage: cliHighlight.supportsLanguage,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Return the shared cli-highlight load promise, starting the lazy load on first call.
+ * @returns A promise of the loaded cli-highlight surface, or null when the dynamic import fails.
+ */
+export function getCliHighlightPromise() {
+    cliHighlightPromise ??= loadCliHighlight();
+    return cliHighlightPromise;
+}
+/**
+ * eg. "foo/bar.ts" → "TypeScript". Awaits the shared cli-highlight load,
+ * then reads highlight.js's language registry. All callers are telemetry
+ * (OTel counter attributes, permission-dialog unary events) — none block
+ * on this, they fire-and-forget or the consumer already handles Promise<string>.
+ * @param file_path - Source file path whose extension names the language.
+ * @returns The language display name, or 'unknown' when the extension is empty or unregistered.
+ */
+export async function getLanguageName(file_path) {
+    await getCliHighlightPromise();
+    const ext = extname(file_path).slice(1);
+    if (!ext)
+        return 'unknown';
+    return loadedGetLanguage?.(ext)?.name ?? 'unknown';
+}