@askdkc/dsh-cli 0.11.3

package/lib/types/components/questions/PlanReviewPanel.js

@@ -0,0 +1,351 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * The plan-review panel — exit-plan-mode decision card
+ * for the DSH user-interaction seam. plan-mode's `exit_plan_mode` tool asks
+ * through `ctx.userQuestions` with `intent: { kind: 'plan-review',
+ * approve }`: the plan markdown arrives in `detail`, the approve/decline
+ * choices in `options` (labels verbatim — the protocol answers with the
+ * asker's own labels).
+ *
+ * Protocol-exact answer mapping (dsh-plan-mode):
+ * - Approve: `{ selected: [intent.approve] }` — custom MUST be absent, or
+ *   plan-mode treats it as keep-planning-with-feedback.
+ * - Keep planning / feedback: `{ selected: [declineLabel], custom? }` where
+ *   declineLabel is the first option that is not the approve label.
+ * - Esc / Ctrl+C: the store rejects with ASK_CANCELLED, which plan-mode
+ *   reads as "the user dismissed the review to speak instead".
+ *
+ * Paste works on the feedback row like the composer: Ctrl+V/Alt+V (the
+ * keymap `paste` binding) reads the system clipboard, and a bracketed
+ * paste inserts its chunk — newlines/control chars flatten to spaces, and
+ * pasted content NEVER picks an option or approves (a pasted digit or a
+ * chunk of line breaks is text, not a quick-pick or an Enter). Editing
+ * state (value + caret) lives in refs mutated synchronously per event —
+ * one stdin chunk is one React batch, and the clipboard read resolves
+ * asynchronously — with the caret counting code points so an emoji can
+ * never be split by ←/→/⌫/Del (same contract as the plugin InputDialog).
+ */
+import React from 'react';
+import { t } from '../../i18n.js';
+import { Box, Text, useInput, ScrollBox, useTerminalSize } from '../../ui.js';
+import { useDeclaredCursor } from '../../ink/hooks/use-declared-cursor.js';
+import { Divider } from '../design-system/Divider.js';
+import { Markdown } from '../Markdown.js';
+import { POINTER } from '../../terminal-utils/figures.js';
+import { isPlainReturnInput } from '../../utils/modifiers.js';
+import { actionMatches } from '../../utils/keymap.js';
+import { flattenPasteInline } from '../../dsh-adapter/sanitize.js';
+import { readClipboard } from '../../utils/clipboard.js';
+const PENCIL = '✎';
+/**
+ * Paste cap for the feedback field, in code points — twin constant of
+ * AskUserQuestionPanel's ANSWER_PASTE_MAX_POINTS (same input contract):
+ * typing is naturally bounded, but a stray Ctrl+V of a file/log must not
+ * inflate the feedback row or ship a megabyte `custom`. Generous on
+ * purpose; the inline error names the bound.
+ */
+const ANSWER_PASTE_MAX_POINTS = 8000;
+export function PlanReviewPanel({ question, onAnswer, onCancel, readClipboardOverride, }) {
+    const options = question.options ?? [];
+    const approveLabel = question.intent?.approve ?? options[0]?.label;
+    const declineLabel = options.find(option => option.label !== approveLabel)?.label;
+    /** Rows: the asker's options plus the feedback input row at the tail. */
+    const rowCount = options.length + 1;
+    const [focusIndex, setFocusIndex] = React.useState(0);
+    const [feedback, setFeedback] = React.useState('');
+    const [cursor, setCursor] = React.useState(0);
+    const [error, setError] = React.useState(null);
+    // Synchronous source of truth for the handlers (see the module header):
+    // one stdin chunk is one React batch, and the clipboard read resolves
+    // asynchronously — the state mirrors exist only to re-render.
+    const textRef = React.useRef('');
+    const cursorRef = React.useRef(0);
+    /** Single choke point for every text/caret mutation: refs first, then the
+     *  state mirrors so the render sees the committed value. */
+    const applyFeedback = (nextText, nextCursor) => {
+        textRef.current = nextText;
+        cursorRef.current = nextCursor;
+        setFeedback(nextText);
+        setCursor(nextCursor);
+    };
+    /** True while the component is mounted (async clipboard continuation
+     *  guard: the panel can unmount when the user answers first). */
+    const mountedRef = React.useRef(true);
+    React.useEffect(() => () => { mountedRef.current = false; }, []);
+    /** True while a clipboard read is in flight (ignore repeat Ctrl+V). */
+    const pasteBusyRef = React.useRef(false);
+    const clipboardReader = readClipboardOverride ?? readClipboard;
+    const { rows: terminalRows } = useTerminalSize();
+    // Chat chrome (status line) + panel scaffolding (divider, question,
+    // spacings, hint) consume twelve rows before the plan body — same
+    // constant as AskUserQuestionPanel. Option/feedback/error rows are
+    // charged on top so a long markdown detail cannot push them off-screen.
+    // A definite `height` (not just maxHeight) is required: otherwise the
+    // ScrollBox grows with the markdown and scrollBy is a no-op.
+    const optionRows = options.reduce((sum, option) => sum + (option.description === undefined ? 1 : 2), 0) + 1 /* extra gap on the focused option */ + 1; /* feedback row */
+    const reservedRows = 12 + optionRows + (error === null ? 0 : 2);
+    // Floor at zero, not four: on a short terminal the decision rows fill the
+    // budget and no plan-body rows remain. Forcing four here would re-inflate
+    // the panel past the viewport and push the controls off-screen again — the
+    // exact regression this panel exists to prevent. When nothing remains, the
+    // body viewport is omitted entirely (a zero-height ScrollBox is neither
+    // readable nor a useful wheel target).
+    const detailMax = Math.max(0, terminalRows - reservedRows);
+    const detailScrollRef = React.useRef(null);
+    const inputFocused = focusIndex === options.length;
+    // Park the native terminal cursor on the feedback caret so IME preedit
+    // (pinyin) renders inline at the input instead of the screen's bottom row
+    // (same mechanism as AskUserQuestionPanel / PromptInput). Always active —
+    // typing on an option row also lands in the feedback buffer. The ref rides
+    // on the caret Text itself (all visual variants): its nodeCache rect IS
+    // the caret cell, so (0, 0) stays exact under wrapping without a
+    // layout-affecting wrapper Box.
+    const caretRef = useDeclaredCursor({ line: 0, column: 0, active: true });
+    const moveFocus = (delta) => {
+        setFocusIndex(index => (index + delta + rowCount) % rowCount);
+        setError(null);
+    };
+    /** Typing anywhere appends to the feedback buffer and focuses the input
+     *  row — plan review has no "attach" semantics: approve must be clean. */
+    const appendFeedback = (text) => {
+        applyFeedback(textRef.current + text, cursorRef.current + [...text].length);
+        setFocusIndex(options.length);
+        setError(null);
+    };
+    const backspaceFeedback = () => {
+        const points = [...textRef.current];
+        const at = cursorRef.current;
+        if (at <= 0)
+            return;
+        points.splice(at - 1, 1);
+        applyFeedback(points.join(''), at - 1);
+    };
+    /**
+     * Paste-path entry shared by both transports (bracketed-paste chunk and
+     * the async clipboard read). Newlines/control chars flatten to spaces; a
+     * chunk with nothing visible inserts nothing, and one past the cap is
+     * refused (never truncated). Where the text lands mirrors plain typing:
+     * at the caret while the feedback row is focused, otherwise appended at
+     * the tail with the input row focused (typing on an option row behaves
+     * exactly that way). NEVER a quick-pick or submit.
+     * @returns 'ok' | 'empty' (nothing visible to insert) | 'too-long'
+     */
+    const insertPastedFeedback = (raw, atCaret) => {
+        const text = flattenPasteInline(raw);
+        if (text.trim() === '')
+            return 'empty';
+        if ([...text].length > ANSWER_PASTE_MAX_POINTS)
+            return 'too-long';
+        const points = [...textRef.current];
+        const at = atCaret ? cursorRef.current : points.length;
+        points.splice(at, 0, ...text);
+        applyFeedback(points.join(''), at + [...text].length);
+        if (!atCaret)
+            setFocusIndex(options.length);
+        return 'ok';
+    };
+    /** Inline error for an over-cap paste (shared by both transports). */
+    const pasteTooLongError = () => t('question-paste-too-long', { n: ANSWER_PASTE_MAX_POINTS });
+    /** Ctrl+V/Alt+V arm: read the system clipboard and insert its text. */
+    const pasteFromClipboard = () => {
+        if (pasteBusyRef.current)
+            return;
+        pasteBusyRef.current = true;
+        // Capture which landing the keypress asked for (typing on an option
+        // row appends + focuses); the read resolves later, after the user may
+        // have moved focus or typed (the refs make either safe).
+        const atCaret = inputFocused;
+        void clipboardReader()
+            .then(content => {
+            if (!mountedRef.current)
+                return;
+            if (content === null || content.kind === 'unavailable') {
+                setError(t(content === null ? 'input-clipboard-empty' : 'input-clipboard-unavailable'));
+                return;
+            }
+            if (content.kind !== 'text') {
+                // File/image offers have no text form in a feedback field.
+                setError(t('question-paste-not-text'));
+                return;
+            }
+            if (content.text === '') {
+                setError(t('input-clipboard-empty'));
+                return;
+            }
+            const result = insertPastedFeedback(content.text, atCaret);
+            setError(result === 'too-long' ? pasteTooLongError() : null);
+        })
+            .catch(() => {
+            if (mountedRef.current)
+                setError(t('input-clipboard-read-failed'));
+        })
+            .finally(() => {
+            pasteBusyRef.current = false;
+        });
+    };
+    /** The decline answer: the other option's label when the asker named one,
+     *  else an empty selection (plan-mode reads any non-approve as decline). */
+    const declineSelected = () => declineLabel !== undefined ? [declineLabel] : [];
+    /** Enter on an option row. Approve with feedback in the buffer is an
+     *  error — the protocol would silently read it as keep-planning. */
+    const submitOption = (index) => {
+        const label = options[index]?.label;
+        if (label === undefined)
+            return;
+        const text = textRef.current.trim();
+        if (label === approveLabel && text !== '') {
+            setError(t('plan-review-approve-needs-empty'));
+            return;
+        }
+        if (label === approveLabel) {
+            onAnswer({ selected: [label] });
+            return;
+        }
+        onAnswer({ selected: [label], ...(text !== '' ? { custom: text } : {}) });
+    };
+    /** Enter on the feedback row: text routes to keep-planning-with-feedback;
+     *  empty is a plain keep-planning. */
+    const submitFeedback = () => {
+        const text = textRef.current.trim();
+        onAnswer({ selected: declineSelected(), ...(text !== '' ? { custom: text } : {}) });
+    };
+    useInput((input, key, event) => {
+        // Steal the wheel while this panel is mounted so Chat's fallback cannot
+        // scroll the transcript. Position-first already hits the ScrollBox when
+        // the pointer is over it; this covers the option/hint rows and any
+        // dispatchWheelAt miss. Up/Down stay on the decision rows.
+        if (key.wheelUp || key.wheelDown) {
+            detailScrollRef.current?.scrollBy(key.wheelUp ? -3 : 3);
+            event.stopImmediatePropagation();
+            return;
+        }
+        if (key.escape || (key.ctrl && input === 'c')) {
+            onCancel();
+            return;
+        }
+        // ── Paste ─────────────────────────────────────────────────────────
+        // A bracketed paste arrives as ONE chunk flagged isPasted. Where it
+        // lands mirrors plain typing: at the caret on the feedback row, else
+        // appended at the tail with the feedback row focused. It NEVER picks
+        // an option — a pasted digit or an all-line-breaks chunk is text, not
+        // a quick-pick or an Enter press (isPlainReturnInput refuses pastes).
+        if (key.isPasted === true) {
+            if (input !== '') {
+                const result = insertPastedFeedback(input, inputFocused);
+                setError(result === 'too-long' ? pasteTooLongError() : null);
+            }
+            return;
+        }
+        // Clipboard paste (default Ctrl+V / Alt+V — the keymap `paste`
+        // binding, remappable in /settings): raw mode hands the key to the
+        // app, so the clipboard is read here (mirrors the composer's arm).
+        if (actionMatches('paste', input, key)) {
+            pasteFromClipboard();
+            return;
+        }
+        if (inputFocused) {
+            if (key.upArrow) {
+                moveFocus(-1);
+                return;
+            }
+            if (key.downArrow) {
+                moveFocus(1);
+                return;
+            }
+            if (isPlainReturnInput(input, key)) {
+                submitFeedback();
+                return;
+            }
+            if (key.backspace) {
+                backspaceFeedback();
+                return;
+            }
+            if (key.delete) {
+                const points = [...textRef.current];
+                const at = cursorRef.current;
+                if (at < points.length) {
+                    points.splice(at, 1);
+                    applyFeedback(points.join(''), at);
+                }
+                return;
+            }
+            if (key.leftArrow) {
+                applyFeedback(textRef.current, Math.max(0, cursorRef.current - 1));
+                return;
+            }
+            if (key.rightArrow) {
+                applyFeedback(textRef.current, Math.min([...textRef.current].length, cursorRef.current + 1));
+                return;
+            }
+            if (key.home) {
+                applyFeedback(textRef.current, 0);
+                return;
+            }
+            if (key.end) {
+                applyFeedback(textRef.current, [...textRef.current].length);
+                return;
+            }
+            if (!key.ctrl && !key.meta && input) {
+                // Ordinary typing at the live caret (a text run may carry several
+                // characters in one event — e.g. an unbracketed terminal paste).
+                const points = [...textRef.current];
+                const at = cursorRef.current;
+                points.splice(at, 0, ...input);
+                applyFeedback(points.join(''), at + [...input].length);
+                setError(null);
+            }
+            return;
+        }
+        // An option row.
+        if (key.upArrow) {
+            moveFocus(-1);
+            return;
+        }
+        if (key.downArrow) {
+            moveFocus(1);
+            return;
+        }
+        if (isPlainReturnInput(input, key)) {
+            submitOption(focusIndex);
+            return;
+        }
+        if (key.backspace) {
+            if (textRef.current !== '')
+                backspaceFeedback();
+            return;
+        }
+        if (!key.ctrl && !key.meta && input) {
+            // Number quick-pick submits the option outright — but only with an
+            // empty buffer; with feedback pending, digits are feedback chars.
+            const digit = /^[1-9]$/.test(input) ? Number(input) : 0;
+            if (textRef.current === '' && digit >= 1 && digit <= options.length) {
+                submitOption(digit - 1);
+                return;
+            }
+            appendFeedback(input);
+        }
+    }, { isActive: true });
+    // The caret counts code points (see the module header), so the caret
+    // char and the visual split index into the point array — never raw
+    // UTF-16 offsets, which could land inside a surrogate pair.
+    const feedbackPoints = [...feedback];
+    const cursorChar = cursor < feedbackPoints.length ? feedbackPoints[cursor] : ' ';
+    /** Mouse: click a decision row = focus it + submit (same as Enter). */
+    const [hoverIndex, setHoverIndex] = React.useState(-1);
+    const clickOption = (index) => {
+        setFocusIndex(index);
+        submitOption(index);
+    };
+    /** Mouse: click the feedback row to focus it. */
+    const focusFeedbackRow = () => {
+        setFocusIndex(options.length);
+        setError(null);
+    };
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingLeft: 2, paddingRight: 2, width: "100%", children: [_jsx(Divider, { color: "permission", title: ` ${question.header ?? t('plan-review-fallback-header')} ` }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, wrap: "wrap", children: question.question }), question.detail !== undefined && detailMax > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, height: detailMax, flexShrink: 0, children: _jsx(ScrollBox, { ref: detailScrollRef, flexDirection: "column", flexGrow: 1, height: detailMax, children: _jsx(Markdown, { children: question.detail }) }) }))] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [options.map((option, index) => {
+                        const focused = index === focusIndex;
+                        const isApprove = option.label === approveLabel;
+                        return (_jsxs(Box, { flexDirection: "row", marginTop: focused ? 1 : 0, onClick: () => clickOption(index), onMouseEnter: () => setHoverIndex(index), onMouseLeave: () => setHoverIndex(current => (current === index ? -1 : current)), backgroundColor: hoverIndex === index && !focused ? 'userMessageBackgroundHover' : undefined, children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { color: focused ? 'accent' : undefined, bold: focused, children: focused ? POINTER : ' ' }) }), _jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [_jsxs(Text, { bold: focused, color: focused || isApprove ? 'accent' : undefined, wrap: "wrap", children: [index + 1, ". ", option.label] }), option.description !== undefined && (_jsx(Text, { dimColor: true, wrap: "wrap", children: option.description }))] })] }, option.label));
+                    }), _jsxs(Box, { flexDirection: "row", marginTop: inputFocused ? 1 : 0, onClick: focusFeedbackRow, onMouseEnter: () => setHoverIndex(options.length), onMouseLeave: () => setHoverIndex(current => (current === options.length ? -1 : current)), backgroundColor: hoverIndex === options.length && !inputFocused ? 'userMessageBackgroundHover' : undefined, children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { color: inputFocused ? 'accent' : undefined, bold: inputFocused, children: inputFocused ? POINTER : ' ' }) }), _jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { color: inputFocused ? 'accent' : 'suggestion', children: PENCIL }) }), _jsx(Box, { flexDirection: "row", marginLeft: 1, children: feedback === '' && !inputFocused ? (_jsx(Text, { ref: caretRef, dimColor: true, children: t('plan-review-feedback-placeholder') })) : (_jsxs(_Fragment, { children: [_jsx(Text, { wrap: "wrap", children: feedbackPoints.slice(0, cursor).join('') }), inputFocused
+                                            ? _jsx(Text, { ref: caretRef, inverse: true, children: cursorChar })
+                                            : _jsx(Text, { ref: caretRef, color: "suggestion", children: "\u258F" }), _jsx(Text, { wrap: "wrap", children: feedbackPoints.slice(inputFocused ? cursor + 1 : cursor).join('') })] })) })] })] }), error !== null && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "error", children: error }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: t('plan-review-hint') }) })] }));
+}

package/lib/types/components/questions/QuestionMinimizedBar.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export type QuestionMinimizedBarProps = {
+    /** Progress title, same text as the expanded panel's Divider header
+     *  (e.g. ` 📋 提问 · 第 2/5 题 · 还剩 3 题 `). */
+    readonly progress: string;
+    /** First line of the question body, truncated by the layout. */
+    readonly questionText: string;
+    /** Expand back to the full panel (Ctrl+K / Esc / click). */
+    readonly onExpand: () => void;
+};
+export declare function QuestionMinimizedBar({ progress, questionText, onExpand, }: QuestionMinimizedBarProps): React.ReactNode;
+//# sourceMappingURL=QuestionMinimizedBar.d.ts.map

package/lib/types/components/questions/QuestionMinimizedBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuestionMinimizedBar.d.ts","sourceRoot":"","sources":["../../../../src/components/questions/QuestionMinimizedBar.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AA0BzB,MAAM,MAAM,yBAAyB,GAAG;IACtC;+CAC2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,gEAAgE;IAChE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAA;CAC9B,CAAA;AAED,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACR,YAAY,EACZ,QAAQ,GACT,EAAE,yBAAyB,GAAG,KAAK,CAAC,SAAS,CAwC7C"}

package/lib/types/components/questions/QuestionMinimizedBar.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from '../../ui.js';
+import { t } from '../../i18n.js';
+import { effectiveComboDisplay } from '../../utils/keymap.js';
+/**
+ * 提问面板挂起条 — the two-line stand-in for a folded questionnaire
+ * (manual collapse; the ask stays parked and the panel stays mounted, so
+ * drafts survive).
+ *
+ * Line 1 mirrors the GoalTodoPanel fold-header language: a dim `▸` (folded
+ * state), the same progress title as the expanded header, then the first
+ * line of the question truncated to whatever width remains. The whole row
+ * is clickable (fullscreen mouse) and hover-highlighted to expand.
+ *
+ * Line 2 is the permanent "answer pending" affordance — a blinking pause
+ * glyph (`⏸` toggled dim/bright on a local interval that lives only while
+ * the bar is mounted) plus the waiting text and the fold key hint. The key
+ * label follows keymap remaps via effectiveComboString, like the /settings
+ * shortcut rows.
+ *
+ * The component is deliberately dumb: the parent formats the strings, so
+ * the bar owns only its local hover/blink state.
+ */
+const BLINK_MS = 500;
+export function QuestionMinimizedBar({ progress, questionText, onExpand, }) {
+    const [blinkOn, setBlinkOn] = React.useState(true);
+    const [hovered, setHovered] = React.useState(false);
+    // The pause glyph blinks by APPEARING and DISAPPEARING (a visible→gone
+    // beat reads as a true blink; dim↔normal is too subtle). The off phase
+    // must occupy exactly the glyph's width or the waiting text shifts left
+    // and right every beat: '⏸ ' measures 2 columns (⏸ is a narrow 1-col
+    // glyph here), so it is replaced by two spaces. Blink only while the
+    // bar exists; unmounting clears the interval.
+    React.useEffect(() => {
+        const id = setInterval(() => setBlinkOn(previous => !previous), BLINK_MS);
+        return () => clearInterval(id);
+    }, []);
+    const waiting = `${t('question-fold-waiting')} — ${t('question-fold-expand', {
+        combo: effectiveComboDisplay('questionFold'),
+    })}`;
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingLeft: 2, paddingRight: 2, width: "100%", children: [_jsxs(Box, { flexDirection: "row", height: 1, onClick: onExpand, onMouseEnter: () => setHovered(true), onMouseLeave: () => setHovered(false), backgroundColor: hovered ? 'userMessageBackgroundHover' : undefined, children: [_jsx(Text, { dimColor: true, children: '▸ ' }), _jsx(Text, { dimColor: true, children: progress }), _jsx(Box, { flexGrow: 1, flexShrink: 1, marginLeft: 1, children: _jsx(Text, { wrap: "truncate", children: questionText }) })] }), _jsxs(Box, { flexDirection: "row", height: 1, children: [_jsx(Text, { children: blinkOn ? '⏸ ' : '  ' }), _jsx(Text, { dimColor: true, wrap: "truncate", children: waiting })] })] }));
+}

package/lib/types/components/sessions/SessionListRow.d.ts

@@ -0,0 +1,58 @@
+import React from 'react';
+import type { ClickEvent } from '../../ink/events/click-event.js';
+import type { ContextMenuEvent } from '../../ink/events/context-menu-event.js';
+import type { SessionSummary } from '../../dsh-adapter/sessions/index.js';
+import type { AgentViewStatus } from '../../adapter/ports/channel-view.js';
+/**
+ * One session in the browser's list: a title line and a metadata line.
+ *
+ * Two lines rather than one because the two carry different jobs. The title
+ * answers "is this the conversation I mean"; the metadata answers "which of
+ * the three that look alike is it" — when it was, on what branch, how big,
+ * under which model. Folding both onto one line makes the title compete with
+ * facts nobody reads first, and on a narrow terminal the title is what loses.
+ *
+ * Widths are resolved here rather than delegated to flexbox: the row must
+ * stay exactly two lines at every terminal width, and a row that wraps
+ * destroys the alignment that lets the eye scan a list at all.
+ */
+export declare function SessionListRow({ session, width, depth, focused, pinned, now, onClick, onContextMenu, onTogglePin, liveStatus, current, occupiedPid, spinner, }: {
+    session: SessionSummary;
+    /** Columns available to the row, indentation included. */
+    width: number;
+    /** 0 for a conversation, 1 for a sub-agent run under its parent. */
+    depth: number;
+    focused: boolean;
+    /** Whether the user pinned this session to the top of the browser. */
+    pinned: boolean;
+    /** Epoch ms used for every relative time in this render pass. */
+    now: number;
+    /** 鼠标点击行（fullscreen）：恢复该会话（与 Enter 同路径）。 */
+    onClick?(event: ClickEvent): void;
+    /** 鼠标右键（fullscreen）：在该行弹出操作菜单（打开/固定/重命名/删除）。 */
+    onContextMenu?(event: ContextMenuEvent): void;
+    /** 点击行内 ★/☆（fullscreen）：切换固定状态，不冒泡成"打开会话"。 */
+    onTogglePin?(): void;
+    /**
+     * Live status of an agent THIS terminal is running, when there is one.
+     * `working` animates instead of holding a static glyph, so a busy session
+     * is legible at a glance — the same vocabulary the session overview uses,
+     * which is what lets the two surfaces read as one feature.
+     */
+    liveStatus?: AgentViewStatus;
+    /** True when this is the session the terminal is attached to. */
+    current?: boolean;
+    /**
+     * The pid of ANOTHER TUI terminal holding this session, when one does. The
+     * row turns red and says so: the session stays visible but cannot be
+     * entered, which is the honest presentation of a claim this process must
+     * not break. Undefined means free, or already ours.
+     */
+    occupiedPid?: number;
+    /** Shared animation clock for the working glyph. */
+    spinner?: {
+        frame: number;
+        time: number;
+    };
+}): React.ReactNode;
+//# sourceMappingURL=SessionListRow.d.ts.map

package/lib/types/components/sessions/SessionListRow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionListRow.d.ts","sourceRoot":"","sources":["../../../../src/components/sessions/SessionListRow.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAA;AAGvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAA;AAY9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAA;AA0B1E;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,MAAM,EACN,GAAG,EACH,OAAO,EACP,aAAa,EACb,WAAW,EACX,UAAU,EACV,OAAO,EACP,WAAW,EACX,OAAO,GACR,EAAE;IACD,OAAO,EAAE,cAAc,CAAA;IACvB,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAA;IACb,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,OAAO,CAAA;IAChB,sEAAsE;IACtE,MAAM,EAAE,OAAO,CAAA;IACf,iEAAiE;IACjE,GAAG,EAAE,MAAM,CAAA;IACX,4CAA4C;IAC5C,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAA;IACjC,gDAAgD;IAChD,aAAa,CAAC,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAA;IAC7C,8CAA8C;IAC9C,WAAW,CAAC,IAAI,IAAI,CAAA;IACpB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,eAAe,CAAA;IAC5B,iEAAiE;IACjE,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,oDAAoD;IACpD,OAAO,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAC1C,GAAG,KAAK,CAAC,SAAS,CA6HlB"}

package/lib/types/components/sessions/SessionListRow.js

@@ -0,0 +1,108 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text } from '../../ui.js';
+import { t } from '../../i18n.js';
+import { useTooltip } from '../Tooltip.js';
+import { SpinnerGlyph } from '../Spinner/SpinnerGlyph.js';
+import { stringWidth } from '../../ink/stringWidth.js';
+import { formatAbsolute, formatBytes, formatWhen, kindMark, titleColor, truncateWidth, } from '../../sessions/format.js';
+/**
+ * State presentation for a session this terminal is running: one glyph and one
+ * theme colour per status, matching the session overview's own vocabulary so
+ * the same session never looks like two different things on two screens.
+ * `stopped` is the "not running here" spelling and draws dim.
+ */
+const LIVE_STATUS_GLYPH = {
+    'needs-input': '✻',
+    working: '✽',
+    completed: '✓',
+    failed: '✕',
+    idle: '∙',
+    stopped: '∙',
+};
+const LIVE_STATUS_COLOR = {
+    'needs-input': 'warning',
+    working: 'suggestion',
+    completed: 'success',
+    failed: 'error',
+    idle: undefined,
+    stopped: undefined,
+};
+/**
+ * One session in the browser's list: a title line and a metadata line.
+ *
+ * Two lines rather than one because the two carry different jobs. The title
+ * answers "is this the conversation I mean"; the metadata answers "which of
+ * the three that look alike is it" — when it was, on what branch, how big,
+ * under which model. Folding both onto one line makes the title compete with
+ * facts nobody reads first, and on a narrow terminal the title is what loses.
+ *
+ * Widths are resolved here rather than delegated to flexbox: the row must
+ * stay exactly two lines at every terminal width, and a row that wraps
+ * destroys the alignment that lets the eye scan a list at all.
+ */
+export function SessionListRow({ session, width, depth, focused, pinned, now, onClick, onContextMenu, onTogglePin, liveStatus, current, occupiedPid, spinner, }) {
+    const indent = depth * 2;
+    // Two cells for the focus marker, plus the indent for a nested run.
+    const body = Math.max(8, width - 2 - indent);
+    const mark = kindMark(session.kind);
+    const [hovered, setHovered] = useState(false);
+    const pinTooltip = useTooltip(t(pinned ? 'resume-menu-unpin' : 'resume-menu-pin'));
+    // Title hover tooltip: the row truncates a long title mid-word; when it
+    // does, the float leads with the full title. The absolute timestamp and
+    // cwd ride along in every case — the facts line shows only relative time
+    // and never the working directory, so that pair is always new information
+    // for telling look-alike sessions apart.
+    const titleText = session.label ?? session.title.text;
+    /**
+     * The state cell holds EXACTLY two columns on every row, occupied or not,
+     * for the same reason the pin slot does: a column that appears only when a
+     * session is busy would shift every title on screen each time one starts or
+     * stops working.
+     */
+    const occupied = occupiedPid !== undefined;
+    const stateGlyph = occupied ? '⊘' : LIVE_STATUS_GLYPH[liveStatus ?? 'stopped'];
+    const stateColor = occupied
+        ? 'error'
+        : liveStatus === undefined
+            ? undefined
+            : LIVE_STATUS_COLOR[liveStatus];
+    const occupiedText = occupied ? ` ${t('supervisor-occupied-badge', { pid: occupiedPid })}` : '';
+    const currentText = current === true ? ` ${t('supervisor-current')}` : '';
+    const titleBudget = body - 2 - (mark === undefined ? 0 : 2) - 2
+        - stringWidth(occupiedText) - stringWidth(currentText);
+    const shownTitle = truncateWidth(titleText, Math.max(4, titleBudget));
+    const titleTooltip = useTooltip(() => {
+        const parts = [];
+        if (occupied)
+            parts.push(t('session-mount-occupied-short', { pid: occupiedPid }));
+        if (shownTitle !== titleText)
+            parts.push(titleText);
+        parts.push(formatAbsolute(session.updatedAt));
+        if (session.cwd !== '')
+            parts.push(session.cwd);
+        return parts.join('\n');
+    });
+    const facts = [formatWhen(session.updatedAt, now)];
+    if (session.branch !== undefined)
+        facts.push(session.branch);
+    const size = formatBytes(session.bytes);
+    if (size !== undefined)
+        facts.push(size);
+    if (session.model !== undefined)
+        facts.push(session.model);
+    if (session.childCount > 0 && depth === 0) {
+        facts.push(t('session-children', { n: session.childCount }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, onClick: onClick, onContextMenu: onContextMenu, onMouseEnter: onClick !== undefined || onContextMenu !== undefined ? () => setHovered(true) : undefined, onMouseLeave: onClick !== undefined || onContextMenu !== undefined ? () => setHovered(false) : undefined, 
+        // Hover is the BLUE prompt — pointer feedback and nothing else. Selection
+        // is green and never blue: a row the keyboard cursor is on must not look
+        // like a row the mouse happens to be over, so the two never share a
+        // background and a selected row keeps its own colour while hovered.
+        backgroundColor: hovered && !focused ? 'userMessageBackgroundHover' : undefined, children: [_jsxs(Box, { children: [_jsx(Text, { color: focused ? 'success' : 'subtle', children: `${' '.repeat(indent)}${focused ? '❯ ' : '  '}` }), _jsx(Box, { ...pinTooltip, onClick: onTogglePin === undefined ? undefined : (event) => {
+                            // The star is a control on the row, not the row: a click here
+                            // toggles the pin and must never fall through to resume.
+                            event.stopImmediatePropagation();
+                            onTogglePin();
+                        }, children: _jsx(Text, { color: pinned ? 'remember' : undefined, dimColor: !pinned, children: pinned ? '★ ' : '☆ ' }) }), _jsx(Box, { children: liveStatus === 'working' && !occupied && spinner !== undefined ? (_jsx(SpinnerGlyph, { frame: spinner.frame, messageColor: "suggestion", reducedMotion: false, time: spinner.time })) : (_jsx(Text, { color: stateColor, dimColor: liveStatus === undefined && !occupied, children: `${stateGlyph} ` })) }), mark !== undefined && _jsx(Text, { color: mark.color, children: `${mark.glyph} ` }), _jsx(Box, { ...titleTooltip, children: _jsx(Text, { color: occupied ? 'error' : titleColor(session.title.source, focused), bold: focused, children: shownTitle }) }), occupiedText !== '' && _jsx(Text, { color: "error", children: occupiedText }), currentText !== '' && _jsx(Text, { color: "success", children: currentText })] }), _jsx(Box, { children: _jsx(Text, { color: focused ? 'success' : undefined, dimColor: !focused, children: `${' '.repeat(indent + 2)}${truncateWidth(facts.join(' · '), body)}` }) })] }));
+}

package/lib/types/components/sessions/SessionPreview.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { PreviewEntry, SessionSummary } from '../../dsh-adapter/sessions/index.js';
+/**
+ * The preview pane: what this session actually says.
+ *
+ * It shows the END of the conversation, not the beginning, for two reasons.
+ * The title already carries the beginning — it is usually the first prompt —
+ * so repeating it would spend the pane on something the list already said. And
+ * the question a person asks at this moment is "is this the one I was in the
+ * middle of", which only the last exchange answers.
+ *
+ * It is also the reason the pane costs nothing: the tail of a log is exactly
+ * what a bounded read already has in hand, so opening the preview on a 4 MB
+ * session is the same amount of work as on a 40 KB one.
+ */
+export declare function SessionPreview({ session, entries, loading, width, height, home, now, }: {
+    session: SessionSummary;
+    entries: readonly PreviewEntry[];
+    loading: boolean;
+    width: number;
+    height: number;
+    home: string;
+    now: number;
+}): React.ReactNode;
+//# sourceMappingURL=SessionPreview.d.ts.map

package/lib/types/components/sessions/SessionPreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionPreview.d.ts","sourceRoot":"","sources":["../../../../src/components/sessions/SessionPreview.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAA;AAQvF;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,OAAO,EACP,OAAO,EACP,KAAK,EACL,MAAM,EACN,IAAI,EACJ,GAAG,GACJ,EAAE;IACD,OAAO,EAAE,cAAc,CAAA;IACvB,OAAO,EAAE,SAAS,YAAY,EAAE,CAAA;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ,GAAG,KAAK,CAAC,SAAS,CA2ElB"}