@deepseek-harness-tui/dsh-tui 0.7.0 → 0.7.2

package/lib/types/sessions/format.js

@@ -0,0 +1,244 @@
+/**
+ * Session browser formatting.
+ *
+ * Presentation only, and deliberately outside the adapter: these are choices
+ * about a terminal's width and a reader's eye, not about what a session log
+ * means.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/sessions/format
+ */
+import { t } from '../i18n.js';
+import { stringWidth } from '../ink/stringWidth.js';
+/**
+ * Truncate to a terminal DISPLAY width, CJK-aware (a wide character costs two
+ * columns).
+ *
+ * Used wherever the cut has to be exact: Ink's own `wrap="truncate"` appends
+ * its ellipsis as soon as content is as wide as its box rather than wider,
+ * which silently eats the last character of a row laid out at its natural
+ * width — and a row that then reflows pushes every row below it down.
+ *
+ * @param text - Plain text, no ANSI.
+ * @param maxWidth - Column budget, ellipsis included.
+ * @returns `text` when it fits, otherwise a cut ending in `…`.
+ */
+export function truncateWidth(text, maxWidth) {
+    if (maxWidth <= 0)
+        return '';
+    if (stringWidth(text) <= maxWidth)
+        return text;
+    let width = 0;
+    let out = '';
+    for (const char of text) {
+        const charWidth = stringWidth(char);
+        if (width + charWidth > maxWidth - 1)
+            break;
+        width += charWidth;
+        out += char;
+    }
+    return `${out}…`;
+}
+/**
+ * Lay out one row with its two ends pushed apart.
+ *
+ * Measured in COLUMNS, which is the whole reason this is a function rather
+ * than three expressions at the call site. Every string it receives is
+ * localized, and in Chinese a character is two columns wide — arithmetic on
+ * `.length` overstates the gap by the width of the text itself, so the row
+ * overflows and the terminal either wraps it (shifting every region below it
+ * down a line) or clips it (silently eating the right-hand segment). Both
+ * failures are invisible to an English-only test.
+ *
+ * The invariant, which the regression checks exhaustively: the assembled row
+ * is never wider than `columns`.
+ *
+ * @param left - Text pinned to the start of the row.
+ * @param right - Text pinned to the end, truncated when it will not fit.
+ * @param columns - Total width available.
+ */
+export function spreadRow(left, right, columns) {
+    if (columns <= 0)
+        return { left: '', gap: 0, right: '' };
+    // One column of separation is always reserved, so the two segments can never
+    // run together into an unreadable single word — which means the left segment
+    // yields too when the row is narrower than it is.
+    const fittedLeft = truncateWidth(left, Math.max(0, columns - 1));
+    const leftWidth = stringWidth(fittedLeft);
+    const fittedRight = truncateWidth(right, Math.max(0, columns - leftWidth - 1));
+    return {
+        left: fittedLeft,
+        gap: Math.max(1, columns - leftWidth - stringWidth(fittedRight)),
+        right: fittedRight,
+    };
+}
+/**
+ * Keep the END of a string within a display width, CJK-aware.
+ *
+ * What a single-line editor does: the caret lives at the end, so that is the
+ * part worth showing. Used where text the user is typing has to stay on ONE
+ * row — a wrapped input row steals a line from the list and can push the row
+ * below it off the bottom of the screen.
+ *
+ * @param text - Plain text, no ANSI.
+ * @param maxWidth - Column budget, leading ellipsis included.
+ * @returns `text` when it fits, otherwise `…` followed by its tail.
+ */
+export function tailWidth(text, maxWidth) {
+    if (maxWidth <= 0)
+        return '';
+    if (stringWidth(text) <= maxWidth)
+        return text;
+    const characters = [...text];
+    let width = 0;
+    let out = '';
+    for (let at = characters.length - 1; at >= 0; at--) {
+        const character = characters[at];
+        const characterWidth = stringWidth(character);
+        if (width + characterWidth > maxWidth - 1)
+            break;
+        width += characterWidth;
+        out = character + out;
+    }
+    return `…${out}`;
+}
+/**
+ * Elapsed time as a person would say it: `just now`, `9 hours ago`, and an
+ * absolute date once "ago" stops being useful.
+ *
+ * The cut to an absolute date is at a week rather than a month because that is
+ * roughly where a relative offset stops locating anything — "23 days ago" is a
+ * number to be decoded, `Mar 3` is a memory.
+ *
+ * @param at - Epoch ms of the moment being described.
+ * @param now - Epoch ms of the present, injectable so the formatter is a pure
+ *   function and its regression does not depend on a clock.
+ */
+export function formatWhen(at, now) {
+    const seconds = Math.max(0, Math.round((now - at) / 1000));
+    if (seconds < 45)
+        return t('session-when-now');
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return t('session-when-minutes', { n: minutes });
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return t('session-when-hours', { n: hours });
+    const days = Math.round(hours / 24);
+    if (days <= 7)
+        return t('session-when-days', { n: days });
+    const date = new Date(at);
+    return t('session-when-date', {
+        month: String(date.getMonth() + 1),
+        day: String(date.getDate()),
+    });
+}
+/**
+ * Byte size at the precision the number is worth: `812 B`, `142.9 KB`,
+ * `4.2 MB`. One decimal from kilobytes up, because the digit distinguishes a
+ * short exchange from a long one and a second would not.
+ */
+export function formatBytes(bytes) {
+    if (bytes === undefined || !Number.isFinite(bytes) || bytes < 0)
+        return undefined;
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+ * Marker for a row's kind, or undefined for an ordinary conversation.
+ *
+ * Only the exceptional kinds are marked. A badge on every row would cost a
+ * column of width and teach nothing — what a reader needs to see at a glance
+ * is which rows are *not* the thing they came for.
+ */
+export function kindMark(kind) {
+    if (kind.kind === 'subagent')
+        return { glyph: '⑂', color: 'autoAccept' };
+    if (kind.kind === 'fork')
+        return { glyph: '⑃', color: 'planMode' };
+    return undefined;
+}
+/**
+ * Wrap to a display width, CJK-aware.
+ *
+ * Greedy, breaking on a space when one is available in the line just filled
+ * and mid-character when it is not — which is the correct behaviour for CJK,
+ * where there are no spaces to break on and a word-only wrapper would emit one
+ * enormous unbreakable line. Newlines in the input are honoured.
+ *
+ * @param text - Plain text, no ANSI.
+ * @param width - Column budget per line.
+ * @returns The wrapped lines, never empty for non-empty input.
+ */
+export function wrapWidth(text, width) {
+    if (width <= 0)
+        return [];
+    const lines = [];
+    for (const paragraph of text.split('\n')) {
+        let line = '';
+        let used = 0;
+        for (const char of paragraph) {
+            const charWidth = stringWidth(char);
+            if (used + charWidth > width) {
+                // Prefer a word boundary, but only when it does not throw away most
+                // of the line — a single long token must still make progress.
+                const breakAt = line.lastIndexOf(' ');
+                if (breakAt > width / 2) {
+                    lines.push(line.slice(0, breakAt));
+                    line = line.slice(breakAt + 1);
+                    used = stringWidth(line);
+                }
+                else {
+                    lines.push(line);
+                    line = '';
+                    used = 0;
+                }
+            }
+            line += char;
+            used += charWidth;
+        }
+        lines.push(line);
+    }
+    return lines;
+}
+/** Human name of a session kind, for the preview pane's header. */
+export function kindLabel(kind) {
+    if (kind.kind === 'subagent')
+        return t('session-kind-subagent');
+    if (kind.kind === 'fork')
+        return t('session-kind-fork');
+    return t('session-kind-root');
+}
+/**
+ * Colour for a title, by how much is actually known about it.
+ *
+ * A title the user chose is stated plainly; one a model generated reads the
+ * same, because it is a real title; a first-prompt excerpt is dimmer, because
+ * it is the session speaking rather than a name; a directory basename is
+ * dimmest of all, because it says only "nothing here was readable".
+ */
+export function titleColor(source, focused) {
+    if (focused)
+        return 'suggestion';
+    if (source === 'fallback')
+        return 'subtle';
+    if (source === 'prompt')
+        return 'inactive';
+    return 'text';
+}
+/**
+ * Project label for a group header: the working directory, with `$HOME`
+ * collapsed to `~` so the eye lands on the part that differs.
+ */
+export function formatProject(cwd, home) {
+    if (cwd.length === 0)
+        return t('session-project-unknown');
+    const normalized = cwd.replace(/\\/g, '/');
+    const base = home.replace(/\\/g, '/').replace(/\/$/, '');
+    if (base.length > 0 && (normalized === base || normalized.startsWith(`${base}/`))) {
+        return `~${normalized.slice(base.length)}`;
+    }
+    return normalized;
+}

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

@@ -0,0 +1,125 @@
+/**
+ * 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, a 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 @deepseek-harness-tui/dsh-tui/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;
+} | {
+    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[];
+}
+/**
+ * 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).
+ * @returns The flat row list and the counts behind what it hides.
+ */
+export declare function buildView(sessions: readonly SessionSummary[], filters: BrowserFilters, context: {
+    cwd: string;
+    branch: string | undefined;
+    currentId: string;
+    sameProject: (a: string, b: string) => boolean;
+}): 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;;;;;;;;;;;;;;;;GAgBG;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,GAC9E;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;AAgBD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,GACtH,WAAW,CAuFb;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,222 @@
+/** The browser's default view: this project, conversations only. */
+export const DEFAULT_FILTERS = {
+    query: '',
+    allProjects: false,
+    branchOnly: false,
+    showSubagents: false,
+};
+/** 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).
+ * @returns The flat row list and the counts behind what it hides.
+ */
+export function buildView(sessions, filters, context) {
+    const needle = filters.query.trim().toLowerCase();
+    const inScope = (session) => session.id !== context.currentId &&
+        (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 lastProject;
+    for (const session of visible.sort((left, right) => right.updatedAt - left.updatedAt)) {
+        // 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.
+        if (filters.allProjects && session.cwd !== lastProject) {
+            lastProject = session.cwd;
+            rows.push({
+                kind: 'project',
+                project: session.cwd,
+                count: visible.filter(other => other.cwd === session.cwd).length,
+            });
+        }
+        rows.push({ kind: 'session', session, depth: 0 });
+        shown += 1;
+        if (!filters.showSubagents)
+            continue;
+        for (const run of (byParent.get(session.id) ?? []).filter(child => matches(child, needle) || matches(session, needle))) {
+            rows.push({ kind: 'session', session: run, depth: 1 });
+            shown += 1;
+        }
+    }
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepseek-harness-tui/dsh-tui",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Claude Code style interactive TUI front door for DeepSeek Harness agents, built on the ported Ink core.",
   "license": "MIT",
   "repository": {
@@ -39,17 +39,17 @@
     },
     "./invariant": {
       "types": "./lib/types/dsh-adapter/invariant.d.ts",
-      "default": "./lib/invariant.js"
+      "default": "./lib/types/dsh-adapter/invariant.js"
     },
     "./cordis.patch.yml": "./cordis.patch.yml",
-    "./package.json": "./package.json",
-    "./src/*": "./src/*"
+    "./package.json": "./package.json"
   },
   "files": [
     "bin",
     "lib",
     "cordis.patch.yml",
     "cordis.yml",
+    "presets",
     "skills"
   ],
   "engines": {
@@ -149,12 +149,19 @@
     }
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && node --import tsx/esm scripts/verify-adapter-boundary.ts && node --import tsx/esm scripts/verify-upstream-contract.ts && node --import tsx/esm scripts/verify-patch-surface.ts",
+    "clean": "node scripts/clean-lib.mjs",
+    "compile": "npm run clean && tsc -p tsconfig.json",
+    "build": "npm run compile && npm run verify:build",
     "tui": "node --import tsx/esm scripts/run.ts",
     "smoke": "node --import tsx/esm scripts/smoke.tsx",
+    "verify:build": "npm run verify:boundary && npm run verify:contract && npm run verify:patch-surface && npm run verify:packaged-presets && npm run verify:minimal-preset-tools && npm run verify:liangshen-bootstrap",
     "verify:boundary": "node --import tsx/esm scripts/verify-adapter-boundary.ts",
     "verify:contract": "node --import tsx/esm scripts/verify-upstream-contract.ts",
     "verify:patch-surface": "node --import tsx/esm scripts/verify-patch-surface.ts",
+    "verify:packaged-presets": "node scripts/verify-packaged-presets.mjs",
+    "verify:minimal-preset-tools": "node scripts/verify-minimal-preset-tools.mjs",
+    "verify:liangshen-bootstrap": "node scripts/verify-liangshen-bootstrap.mjs",
+    "verify:package": "npm pack --dry-run --json --ignore-scripts | node scripts/verify-package.mjs",
     "verify:clipboard-image": "node --import tsx/esm scripts/verify-clipboard-image.ts"
   }
 }

package/presets/liangshen/.dsh-tui-managed.json

@@ -0,0 +1,5 @@
+{
+  "owner": "@deepseek-harness-tui/dsh-tui",
+  "preset": "liangshen",
+  "revision": "liangshen-toolcall-full-catalog-subagents-v3"
+}