@itookit/dsht 0.3.3 → 0.3.4

package/dist/controller/perf-measures.js

@@ -0,0 +1,78 @@
+/** Drop the render measurements React's development build appends to the global performance timeline.
+ *
+ * `react-reconciler` emits one `performance.measure()` entry per rendered component when it resolves
+ * to its development build, and Node keeps every entry for the life of the process because
+ * `performance.clearMeasures()` is the only way to release them. Each entry also carries a
+ * `detail.devtools.properties` payload describing the component's props, which is where the memory
+ * actually goes: roughly 1.2 KB per render once the duplicated property names are counted.
+ *
+ * The production build emits no measurements at all, so `src/cli/index.ts` selects it and this
+ * module is a safety net for `DSHT_REACT_DEV=1`, where the development build is deliberate.
+ */
+/** Zero-width space React prefixes to a component's own measure name; see `ReactFiberPerformanceTrack` in react-reconciler. */
+const COMPONENT_PREFIX = '\u200b';
+/** Measure names React passes as an explicit update trigger, or as the label for an errored or recovered boundary. */
+const REACT_NAMES = [
+    'Update', 'Cascading Update', 'Update Blocked', 'Update Suspended', 'Mount', 'Unmount',
+    'Reconnect', 'Disconnect', 'Recovered', 'Errored',
+];
+/** Constructors `performance` uses for invalid input, which a measurement library cannot survive. */
+const PROGRAMMING_ERRORS = ['TypeError', 'RangeError', 'SyntaxError'];
+/** The global performance timeline, when the runtime exposes one.
+ * @returns The timeline, or undefined on a runtime without `performance` or `getEntriesByType`.
+ */
+function timeline() {
+    const candidate = globalThis.performance;
+    return typeof candidate?.getEntriesByType === 'function' ? candidate : undefined;
+}
+/** Measure names the current timeline holds that React created.
+ *
+ * A name only counts when it is exactly one of `REACT_NAMES` or carries React's zero-width prefix,
+ * so entries an application or a library created under its own name are never selected.
+ * @param performance - Timeline to read.
+ * @returns Names React created, without duplicates.
+ */
+export function reactMeasureNames(performance) {
+    const names = new Set();
+    for (const entry of performance.getEntriesByType('measure')) {
+        const name = entry.name;
+        if (name.startsWith(COMPONENT_PREFIX))
+            names.add(name);
+        else if (REACT_NAMES.includes(name))
+            names.add(name);
+    }
+    return [...names];
+}
+/** Remove React's render measurements, and only those, from the global performance timeline.
+ *
+ * Intended to run on the memory-sampling interval: the development build keeps appending, so one
+ * pass only bounds the total instead of ending it. A failure is not worth propagating, because this
+ * is a bounded diagnostic and a measurement library that rejects input should not stop the client.
+ * @returns How many distinct measure names were cleared.
+ */
+export function clearReactMeasures() {
+    const performance = timeline();
+    if (performance === undefined)
+        return 0;
+    const names = reactMeasureNames(performance);
+    for (const name of names) {
+        try {
+            performance.clearMeasures(name);
+        }
+        catch (error) {
+            if (!PROGRAMMING_ERRORS.includes(error?.name ?? ''))
+                throw error;
+        }
+    }
+    return names.length;
+}
+/** How many measure entries the timeline currently holds.
+ *
+ * Recorded next to the heap counters so a memory log shows whether retained growth tracks the
+ * render count. Entries cleared by `clearReactMeasures` leave the count at zero.
+ * @returns Entry count, or undefined on a runtime without a readable timeline.
+ */
+export function measureCount() {
+    const performance = timeline();
+    return performance?.getEntriesByType('measure').length;
+}

package/dist/session/controller.d.ts

@@ -46,6 +46,15 @@ export declare class SessionController {
      * @returns Retained question and approval frames for that session.
      */
     pendingFor(state: State): ObjectValue[];
+    /** Unanswered interactions by session, so a list can show who is waiting without opening them.
+     *
+     * The host delivers approval and question waterfalls for every session on one stream, and this
+     * client already retains them to answer later, so the counts are a fact of this generation rather
+     * than a new subscription. They live only as long as the connection: a reconnect clears the map
+     * until the host replays the pending waterfalls.
+     * @returns One count per session holding at least one unanswered interaction.
+     */
+    pendingCounts(): ReadonlyMap<string, number>;
     /** Retain a recognized host waterfall; unknown events stay with the connection to delegate.
      * @param frame - One decoded waterfall frame.
      * @returns Whether this domain retained the frame for an answer.
@@ -168,6 +177,13 @@ export declare class SessionController {
      * @param allowed - Whether the request is approved once.
      */
     approve(allowed: boolean): Promise<void>;
+    /** Dismiss the whole selected-session question set without answering it.
+     *
+     * The Web client's close button settles the same waterfall the same way — reject with
+     * `ASK_CANCELLED` — so the host records a user cancellation rather than an answer. A question
+     * batch is answered as one request, so dismissals also discard partial local answers.
+     */
+    dismissQuestion(): Promise<void>;
     /** Add a page before the retained window using its fixed opening cut.
      * @param signal - Cancels local paging without interrupting the remote agent.
      * @param transcript - Transcript to extend; defaults to the live one.

package/dist/session/controller.js

@@ -95,6 +95,23 @@ export class SessionController {
     pendingFor(state) {
         return [...this.interactions.values()].filter(frame => frame.agentId === state.sessionId);
     }
+    /** Unanswered interactions by session, so a list can show who is waiting without opening them.
+     *
+     * The host delivers approval and question waterfalls for every session on one stream, and this
+     * client already retains them to answer later, so the counts are a fact of this generation rather
+     * than a new subscription. They live only as long as the connection: a reconnect clears the map
+     * until the host replays the pending waterfalls.
+     * @returns One count per session holding at least one unanswered interaction.
+     */
+    pendingCounts() {
+        const counts = new Map();
+        for (const frame of this.interactions.values()) {
+            if (typeof frame.agentId !== 'string')
+                continue;
+            counts.set(frame.agentId, (counts.get(frame.agentId) ?? 0) + 1);
+        }
+        return counts;
+    }
     /** Retain a recognized host waterfall; unknown events stay with the connection to delegate.
      * @param frame - One decoded waterfall frame.
      * @returns Whether this domain retained the frame for an answer.
@@ -459,6 +476,22 @@ export class SessionController {
             throw new Error('No pending approval');
         await this.answer(allowed ? 'allowed-once' : 'rejected');
     }
+    /** Dismiss the whole selected-session question set without answering it.
+     *
+     * The Web client's close button settles the same waterfall the same way — reject with
+     * `ASK_CANCELLED` — so the host records a user cancellation rather than an answer. A question
+     * batch is answered as one request, so dismissals also discard partial local answers.
+     */
+    async dismissQuestion() {
+        const pending = this.store.state.pending[0];
+        if (pending?.event !== 'user-questions/request')
+            throw new Error('No pending question');
+        await this.reply(pending, { kind: 'rejected', error: {
+                name: 'UserQuestionError', message: 'the user cancelled ask_user_question', code: 'ASK_CANCELLED',
+            } });
+        this.interactions.delete(string(pending.eventId));
+        this.store.update({});
+    }
     /** Add a page before the retained window using its fixed opening cut.
      * @param signal - Cancels local paging without interrupting the remote agent.
      * @param transcript - Transcript to extend; defaults to the live one.

package/dist/session/navigation.d.ts

@@ -9,15 +9,23 @@ export declare function navigationCommand(value: string): {
 export declare function sessionLabel(session: ObjectValue): string;
 /** Match an exact ID or name before a unique ID prefix; never choose an ambiguous target. */
 export declare function resolveTarget(items: ObjectValue[], query: string, id: string, names: (item: ObjectValue) => string[]): ObjectValue;
-/** Activity a session summary reports on its own, without loading that session's history. */
-export type SessionState = 'running' | 'idle' | 'blank';
+/** User-visible activity of one session, most actionable first.
+ *
+ * `needs` is the only state that asks the user to do something, and it outranks the host's running
+ * flag because a turn waiting on an answer is running only in the mechanical sense. `blank` stays a
+ * marker for a session that never sent a turn, but it is not a status and never enters a rollup.
+ */
+export type SessionState = 'needs' | 'running' | 'idle' | 'blank';
 /** Classify one session from the host's list summary; nothing is inferred from silence.
  * @param session - Session summary from `session/list`.
- * @returns Running while its agent works, blank before its first turn, otherwise idle.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
+ * @returns Needs-you while an answer is owed, running while its agent works, otherwise idle or blank.
  */
-export declare function sessionState(session: ObjectValue): SessionState;
-/** Leading marker per state: a working clock, a filled idle dot, and an empty unused circle. */
+export declare function sessionState(session: ObjectValue, pending?: boolean): SessionState;
+/** Leading marker per state: a question mark, a working clock, a filled dot, and an unused circle. */
 export declare const SESSION_MARKERS: Record<SessionState, string>;
+/** One word per state, so every screen names the same state the same way. */
+export declare const STATE_LABELS: Record<SessionState, string>;
 /** Coarse age of a session's last activity, so the column stays steady between list refreshes.
  * @param time - Epoch milliseconds of the last activity, when the summary reported one.
  * @param now - Current epoch milliseconds.
@@ -27,11 +35,57 @@ export declare function activityAge(time: number | undefined, now: number): stri
 /** Status cell for one session row: its state marker and the age of its last activity.
  * @param session - Session summary from `session/list`.
  * @param now - Current epoch milliseconds.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
  * @returns Marker with an optional age, without a trailing space when unknown.
  */
-export declare function sessionStatus(session: ObjectValue, now: number): string;
+export declare function sessionStatus(session: ObjectValue, now: number, pending?: boolean): string;
+/** States a workspace rollup reports, most actionable first. */
+export declare const ROLLUP_STATES: readonly ["needs", "running", "idle"];
+/** One state a workspace rollup reports. */
+export type RollupState = (typeof ROLLUP_STATES)[number];
+/** One counted state of a workspace rollup. */
+export interface RollupCount {
+    state: RollupState;
+    count: number;
+}
+/** How much room a rollup has for words. */
+export type RollupStyle = 'words' | 'badges';
 /** Count the sessions of one workspace by the state each reports.
+ *
+ * Blank sessions are counted by neither a badge nor a word: a session that never sent a turn is the
+ * absence of activity, and listing it beside real work only makes the rollup harder to read.
  * @param sessions - Sessions whose `sessionIds` belong to the workspace.
- * @returns One `marker count` cell per state that occurs, running first, or an empty string.
+ * @param pending - Session IDs this client holds an unanswered interaction for.
+ * @returns One count per state that occurs, most actionable first, or an empty list.
+ */
+export declare function workspaceCounts(sessions: readonly ObjectValue[], pending?: ReadonlySet<string>): RollupCount[];
+/** Render one rollup as separately coloured cells.
+ *
+ * Each cell after the first carries the separator that joins it to the previous one, so a caller can
+ * colour the cells independently without losing the text {@link workspaceStatus} would produce.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The cells in the order given, with their separators.
+ */
+export declare function workspaceSegments(counts: readonly RollupCount[], style?: RollupStyle): {
+    state: RollupState;
+    text: string;
+}[];
+/** Render one rollup as plain text, the same way every screen and test reads it.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The joined cell text, empty when nothing was counted.
+ */
+export declare function workspaceStatus(counts: readonly RollupCount[], style?: RollupStyle): string;
+/** Marker key for the compact rollup, which has no room for the words. */
+export declare const ROLLUP_LEGEND: string;
+/** Secondary path text for one workspace row.
+ *
+ * The title is usually the last path segment, so repeating it wastes the row; the parent directory
+ * is what distinguishes two checkouts. A title that does not name the last segment keeps the full
+ * path, because dropping it would hide where the workspace actually lives.
+ * @param path - Registered host directory.
+ * @param title - Workspace title as the row already shows it.
+ * @returns The path to show beside the row, or an empty string when nothing is left.
  */
-export declare function workspaceStatus(sessions: readonly ObjectValue[]): string;
+export declare function workspaceDetail(path: string, title: string): string;

package/dist/session/navigation.js

@@ -36,15 +36,20 @@ export function resolveTarget(items, query, id, names) {
 }
 /** Classify one session from the host's list summary; nothing is inferred from silence.
  * @param session - Session summary from `session/list`.
- * @returns Running while its agent works, blank before its first turn, otherwise idle.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
+ * @returns Needs-you while an answer is owed, running while its agent works, otherwise idle or blank.
  */
-export function sessionState(session) {
+export function sessionState(session, pending = false) {
+    if (pending)
+        return 'needs';
     if (session.running === true)
         return 'running';
     return session.blank === true ? 'blank' : 'idle';
 }
-/** Leading marker per state: a working clock, a filled idle dot, and an empty unused circle. */
-export const SESSION_MARKERS = { running: '◐', idle: '●', blank: '○' };
+/** Leading marker per state: a question mark, a working clock, a filled dot, and an unused circle. */
+export const SESSION_MARKERS = { needs: '?', running: '◐', idle: '●', blank: '○' };
+/** One word per state, so every screen names the same state the same way. */
+export const STATE_LABELS = { needs: 'needs you', running: 'working', idle: 'ready', blank: 'empty' };
 /** Coarse age of a session's last activity, so the column stays steady between list refreshes.
  * @param time - Epoch milliseconds of the last activity, when the summary reported one.
  * @param now - Current epoch milliseconds.
@@ -65,20 +70,74 @@ export function activityAge(time, now) {
 /** Status cell for one session row: its state marker and the age of its last activity.
  * @param session - Session summary from `session/list`.
  * @param now - Current epoch milliseconds.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
  * @returns Marker with an optional age, without a trailing space when unknown.
  */
-export function sessionStatus(session, now) {
+export function sessionStatus(session, now, pending = false) {
     const age = activityAge(typeof session.updatedAt === 'number' ? session.updatedAt : undefined, now);
-    return `${SESSION_MARKERS[sessionState(session)]}${age === '' ? '' : ` ${age}`}`;
+    return `${SESSION_MARKERS[sessionState(session, pending)]}${age === '' ? '' : ` ${age}`}`;
 }
+/** States a workspace rollup reports, most actionable first. */
+export const ROLLUP_STATES = ['needs', 'running', 'idle'];
 /** Count the sessions of one workspace by the state each reports.
+ *
+ * Blank sessions are counted by neither a badge nor a word: a session that never sent a turn is the
+ * absence of activity, and listing it beside real work only makes the rollup harder to read.
  * @param sessions - Sessions whose `sessionIds` belong to the workspace.
- * @returns One `marker count` cell per state that occurs, running first, or an empty string.
+ * @param pending - Session IDs this client holds an unanswered interaction for.
+ * @returns One count per state that occurs, most actionable first, or an empty list.
  */
-export function workspaceStatus(sessions) {
-    const counts = { running: 0, idle: 0, blank: 0 };
-    for (const session of sessions)
-        counts[sessionState(session)] += 1;
-    return ['running', 'idle', 'blank'].filter(state => counts[state] > 0)
-        .map(state => `${SESSION_MARKERS[state]} ${counts[state]}`).join('  ');
+export function workspaceCounts(sessions, pending = new Set()) {
+    const counts = { needs: 0, running: 0, idle: 0 };
+    for (const session of sessions) {
+        const id = session.sessionId;
+        const state = sessionState(session, typeof id === 'string' && pending.has(id));
+        if (state !== 'blank')
+            counts[state] += 1;
+    }
+    return ROLLUP_STATES.filter(state => counts[state] > 0).map(state => ({ state, count: counts[state] }));
+}
+/** Render one rollup as separately coloured cells.
+ *
+ * Each cell after the first carries the separator that joins it to the previous one, so a caller can
+ * colour the cells independently without losing the text {@link workspaceStatus} would produce.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The cells in the order given, with their separators.
+ */
+export function workspaceSegments(counts, style = 'words') {
+    const separator = style === 'words' ? ' · ' : ' ';
+    return counts.map(({ state, count }, index) => ({ state,
+        text: `${index === 0 ? '' : separator}${style === 'words' ? `${SESSION_MARKERS[state]} ${count} ${STATE_LABELS[state]}` : `${SESSION_MARKERS[state]}${count}`}` }));
+}
+/** Render one rollup as plain text, the same way every screen and test reads it.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The joined cell text, empty when nothing was counted.
+ */
+export function workspaceStatus(counts, style = 'words') {
+    return workspaceSegments(counts, style).map(segment => segment.text).join('');
+}
+/** Marker key for the compact rollup, which has no room for the words. */
+export const ROLLUP_LEGEND = `${SESSION_MARKERS.idle} ${STATE_LABELS.idle} · ${SESSION_MARKERS.running} ${STATE_LABELS.running} · ${SESSION_MARKERS.needs} ${STATE_LABELS.needs}`;
+/** Secondary path text for one workspace row.
+ *
+ * The title is usually the last path segment, so repeating it wastes the row; the parent directory
+ * is what distinguishes two checkouts. A title that does not name the last segment keeps the full
+ * path, because dropping it would hide where the workspace actually lives.
+ * @param path - Registered host directory.
+ * @param title - Workspace title as the row already shows it.
+ * @returns The path to show beside the row, or an empty string when nothing is left.
+ */
+export function workspaceDetail(path, title) {
+    if (!path)
+        return '';
+    const trimmed = path.replace(/\/+$/u, '');
+    const cut = trimmed.lastIndexOf('/');
+    const base = cut < 0 ? trimmed : trimmed.slice(cut + 1);
+    if (base !== title)
+        return path;
+    if (cut > 0)
+        return trimmed.slice(0, cut);
+    return cut === 0 ? '/' : '';
 }

package/dist/ui/app.js

@@ -19,7 +19,7 @@ import { CopyMode } from "./copy-mode.js";
 import { HelpPanel, HistoryDialog, ModelDialog, PickerScreen, QueueDialog, QueuedPreview, RemovalDialog, SearchResultsDialog, ThoughtsDialog } from "./dialogs/index.js";
 import { COMMAND_HINTS, completeCommand as completeDraft, suggestedCommands } from "./commands/registry.js";
 import { classifySubmission } from "./commands/parse.js";
-import { sessionLabel, sessionStatus, workspaceStatus } from "../session/navigation.js";
+import { ROLLUP_LEGEND, sessionLabel, sessionStatus, workspaceCounts, workspaceDetail, workspaceSegments, workspaceStatus } from "../session/navigation.js";
 import { array, errorText, object, safeText, string } from "../transport/wire.js";
 /** Transient notices expire; interactive panels remain open until dismissed. */
 const PANEL_LIFETIME_MS = 10_000;
@@ -266,7 +266,6 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
             if (key.ctrl && draft.current)
                 setInput('');
             if (key.escape) {
-                setOptionState({ ...choiceState, custom: false });
                 setApprovalSelection(undefined);
                 setRemoval(undefined);
                 setModels(undefined);
@@ -277,6 +276,18 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
                 setHelp(false);
                 setCostExpanded(false);
                 setStatusExpanded(false);
+                // A question batch is one request, so Esc leaves the whole set the way the Web client's
+                // close button does. The free-text row keeps its own step back: its first Esc returns to
+                // the options, and only the next one dismisses. Approval keeps every choice explicit.
+                if (pending?.event === 'user-questions/request' && !choiceState.custom) {
+                    if (controller.state.online && !controller.state.busy && controller.state.pending[0]?.eventId === eventId) {
+                        setOptionState(undefined);
+                        setAnswers(previous => { const rest = { ...previous }; delete rest[eventId]; return rest; });
+                        operate(() => controller.dismissQuestion());
+                    }
+                    return;
+                }
+                setOptionState({ ...choiceState, custom: false });
             }
             return;
         }
@@ -621,17 +632,44 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
         if (accepted)
             setInput('');
     };
+    const width = Math.max(10, (stdout.columns ?? 80) - 2);
+    // The composer never trades the conversation away for input. Its window grows with the body and
+    // is clamped so a few conversation rows always survive; width never buys height, so landscape and
+    // a wide desktop only wrap less instead of showing more input rows. The budget subtracts the one
+    // row the frame, the header, the status bar and a transient notice/suggestion line may each take.
+    const bodyRows = Math.max(4, (stdout.rows ?? 30) - 4 - statusBarRows);
+    const composerRows = Math.max(1, Math.min(Math.min(5, Math.max(2, Math.floor(bodyRows / 3))), bodyRows - 7));
+    const draftWidth = Math.max(1, width - 6);
     // Session activity is a list-level fact, so both pickers read it without loading any history.
     const listAge = Date.now();
+    // Unanswered interactions are held per session already; a list only has to read the counts.
+    const pendingCounts = controller.pendingCounts();
+    const isPending = (session) => (pendingCounts.get(string(session.sessionId)) ?? 0) > 0;
     const sessionsOf = (workspace) => {
         const ids = new Set(array(workspace.sessionIds).map(string));
         return state.sessions.filter(session => ids.has(string(session.sessionId)));
     };
+    // `width` counts only the frame's outer padding, so the list subtracts the composer border and
+    // padding it renders inside; measured against the wider value a long row would still wrap.
+    const pickerWidth = Math.max(16, width - 4);
+    // Words explain themselves. Badges fit a narrow terminal but need the marker key beside them.
+    const rollupStyle = pickerWidth >= 80 ? 'words' : 'badges';
+    // Needs-you is the one state that asks for action, so it outranks working; ready stays quiet.
+    const stateColor = { needs: theme.status.critical, running: theme.status.working, idle: theme.colors.muted };
     const choices = state.screen === 'workspaces' ? [
-        ...state.workspaces.map(workspace => ({ key: string(workspace.workspaceId),
-            label: `${[workspaceStatus(sessionsOf(workspace)), string(workspace.title), string(workspace.path)].filter(Boolean).join('  ')}`,
-            remove: () => setRemoval({ kind: 'workspace', id: string(workspace.workspaceId), name: string(workspace.title), path: string(workspace.path) }),
-            action: () => controller.pickWorkspace(string(workspace.workspaceId)) })),
+        ...state.workspaces.map(workspace => {
+            const counts = workspaceCounts(sessionsOf(workspace), new Set(pendingCounts.keys()));
+            const name = string(workspace.title);
+            const title = name || string(workspace.path);
+            // A path only earns a column when words are affordable and the title does not already say it.
+            const detail = rollupStyle === 'words' && name ? workspaceDetail(string(workspace.path), name) : '';
+            return { key: string(workspace.workspaceId),
+                label: [workspaceStatus(counts, rollupStyle), title].filter(Boolean).join('  '), title,
+                cells: workspaceSegments(counts, rollupStyle).map(segment => ({ text: segment.text, color: stateColor[segment.state] })),
+                ...(detail ? { detail } : {}),
+                remove: () => setRemoval({ kind: 'workspace', id: string(workspace.workspaceId), name: string(workspace.title), path: string(workspace.path) }),
+                action: () => controller.pickWorkspace(string(workspace.workspaceId)) };
+        }),
         { key: '@all', label: 'All sessions', action: () => operate(() => controller.switchSession('all')) },
         // The directory this client runs in is the one case where no path has to be typed, and offering
         // it only while the host has not registered it keeps the row from repeating itself.
@@ -642,12 +680,11 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
     ] : [
         ...(state.workspaceId && !state.showAllSessions ? [{ key: '@new', label: '+ New session', action: () => operate(() => controller.createSession()) }] : []),
         ...controller.visibleSessions.map(session => ({ key: string(session.sessionId),
-            label: `${sessionStatus(session, listAge)} ${sessionLabel(session)}  ${session.sessionId}`,
+            label: `${sessionStatus(session, listAge, isPending(session))} ${sessionLabel(session)}  ${session.sessionId}`,
             remove: () => operate(() => requestRemoval('session', string(session.sessionId))),
             action: () => { setScroll(0); operate(() => controller.selectSession(string(session.sessionId))); } })),
         { key: '@back', label: '← Workspaces', action: () => operate(() => controller.showPicker('workspaces')) },
     ];
-    const width = Math.max(10, (stdout.columns ?? 80) - 2);
     const layout = useMemo(() => historyLayout(displayTranscript, width, reasoning, reasoningOverrides, liveReasoning), [displayTranscript, displayTranscript.version, width, reasoning, reasoningOverrides, liveReasoning]);
     const { length, first } = layout;
     const statusNotice = !['Connected', 'Idle', 'Running…', 'Responding…'].includes(state.status);
@@ -783,8 +820,13 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
             : state.screen === 'chat' && position > 0 ? 'history'
                 : undefined;
     const statusFrozen = pauseReason !== undefined;
-    return _jsx(ThemeContext.Provider, { value: theme, children: _jsx(CopyMode.Provider, { value: copyMode, children: _jsx(Frozen, { frozen: copyMode, identity: `${width}:${stdout.rows}`, children: _jsxs(Box, { flexDirection: "column", paddingX: 1, height: Math.max(1, (stdout.rows ?? 30) - 1), overflowY: "hidden", children: [copyMode && _jsx(Text, { color: theme.accent, children: "Copy mode \u00B7 drag to select \u00B7 Esc / Ctrl+S resumes" }), _jsx(ChatHeader, { title: headerTitle, mode: controller.sessionMode, width: width, frozen: displayPaused, identity: `${width}:${state.sessionId}` }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 0, overflowY: "hidden", children: [historyLoading && _jsxs(Text, { dimColor: true, children: [historyLoading, " \u00B7 Esc / Ctrl+C cancel"] }), _jsx(Frozen, { frozen: statusPaused, identity: state.sessionId ?? "", children: statusNotice && _jsx(Text, { dimColor: true, wrap: "truncate-end", children: safeText(state.status) }) }), state.error && _jsx(Text, { color: theme.colors.error, children: state.error }), state.screen === 'chat' && _jsx(ChatViewport, { rows: visible, showHistoryHint: showHistoryHint, dialogOpen: dialogOpen, historyWindow: !!historyWindow, frozen: displayPaused, identity: `${width}:${state.sessionId}:${position}:${pageSize}`, boxRef: conversationBox })] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [notice && _jsx(Text, { dimColor: true, children: safeText(notice) }), _jsxs(Box, { borderStyle: "round", borderColor: pending ? theme.colors.context : state.online ? theme.accent : theme.border, paddingX: 1, flexDirection: "column", flexShrink: 1, minHeight: 3, children: [_jsx(Box, { flexDirection: "column", flexShrink: 1, minHeight: 0, overflowY: "hidden", children: queueOpen && !pending ? _jsx(QueueDialog, { queued: queued, rows: stdout.rows ?? 30, width: width, unavailable: !!state.controlError, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online && !controller.state.pending.length, onRemove: id => operate(() => controller.removeQueued(id)) }) : removal ? _jsx(RemovalDialog, { removal: removal, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online, onCancel: () => setRemoval(undefined), onConfirm: () => operate(async () => { await controller.removeTarget(removal); setRemoval(undefined); }) }) : models ? _jsx(ModelDialog, { models: models, rows: stdout.rows ?? 30, width: width, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online, onChoose: (provider, model, effort) => operate(async () => { await controller.selectModel(provider, model, effort); setModels(undefined); }), onOpen: (provider, model) => setModels({ catalog: models.catalog, provider, model }), onBack: () => setModels({ catalog: models.catalog }), onClose: () => setModels(undefined) }) : searchResults ? _jsx(SearchResultsDialog, { query: searchResults.query, items: searchResults.items, hasMore: searchResults.hasMore, width: width, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy, onOpen: sessionId => operate(() => openSearchSession(sessionId, searchResults.query)), onClose: () => setSearchResults(undefined) }) : state.screen === 'workspaces' || state.screen === 'sessions' ? _jsx(PickerScreen, { title: state.screen === 'workspaces' ? 'Choose workspace' : state.showAllSessions ? 'Choose session · All workspaces' : 'Choose session', identity: `${state.screen}:${state.workspaceId ?? ''}`, choices: choices, enabled: state.online && !state.busy && !input, canSelect: () => !draft.current && controller.state.online && !controller.state.busy }) : _jsxs(_Fragment, { children: [thoughtList && _jsx(ThoughtsDialog, { identity: `thoughts:${state.sessionId}`, options: thoughtOptions, empty: !thoughtEntries?.length && !liveThought, rows: stdout.rows ?? 30, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy }), state.screen === 'chat' && historyQuery !== undefined && _jsx(HistoryDialog, { identity: `history:${historyQuery}`, contentSearch: contentSearch, matches: historyMatches, query: historyQuery, messages: layout.messages, width: width, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy, onJump: seq => operate(() => jumpHistory(seq)), onClose: () => { setHistoryQuery(undefined); setHistoryMatches(undefined); } }), pending && _jsxs(Box, { flexShrink: 0, flexDirection: "column", children: [_jsx(Text, { bold: true, color: theme.colors.context, children: question ? `Question ${answered.length + 1}/${questions.length}${question.header ? ` · ${safeText(string(question.header))}` : ''}` : 'Approval required' }), _jsx(Text, { children: safeText(question ? string(question.question) : JSON.stringify(pending.request, null, 2)) }), question?.detail && _jsx(Text, { children: safeText(string(question.detail)) }), pending.event === 'approval/request' && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [['Allow once', 'Deny', 'Stop turn'].map((label, index) => _jsxs(Text, { color: approvalIndex === index ? theme.accent : undefined, children: [approvalIndex === index ? '❯ ' : '  ', index + 1, ". ", label] }, label)), _jsx(Text, { dimColor: true, children: "\u2191 \u2193 / 1\u20133 select \u00B7 Enter confirm" })] }), options.length > 0 && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [[...options, { label: 'Other answer — type below' }].map((option, index) => ({ option, index }))
+    return _jsx(ThemeContext.Provider, { value: theme, children: _jsx(CopyMode.Provider, { value: copyMode, children: _jsx(Frozen, { frozen: copyMode, identity: `${width}:${stdout.rows}`, children: _jsxs(Box, { flexDirection: "column", paddingX: 1, height: Math.max(1, (stdout.rows ?? 30) - 1), overflowY: "hidden", children: [copyMode && _jsx(Text, { color: theme.accent, children: "Copy mode \u00B7 drag to select \u00B7 Esc / Ctrl+S resumes" }), _jsx(ChatHeader, { title: headerTitle, mode: controller.sessionMode, width: width, frozen: displayPaused, identity: `${width}:${state.sessionId}` }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 0, overflowY: "hidden", children: [historyLoading && _jsxs(Text, { dimColor: true, children: [historyLoading, " \u00B7 Esc / Ctrl+C cancel"] }), _jsx(Frozen, { frozen: statusPaused, identity: state.sessionId ?? "", children: statusNotice && _jsx(Text, { dimColor: true, wrap: "truncate-end", children: safeText(state.status) }) }), state.error && _jsx(Text, { color: theme.colors.error, children: state.error }), state.screen === 'chat' && _jsx(ChatViewport, { rows: visible, showHistoryHint: showHistoryHint, dialogOpen: dialogOpen, historyWindow: !!historyWindow, frozen: displayPaused, identity: `${width}:${state.sessionId}:${position}:${pageSize}`, boxRef: conversationBox })] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [notice && _jsx(Text, { dimColor: true, children: safeText(notice) }), _jsxs(Box, { borderStyle: "round", borderColor: pending ? theme.colors.context : state.online ? theme.accent : theme.border, paddingX: 1, flexDirection: "column", flexShrink: 1, minHeight: 3, children: [_jsx(Box, { flexDirection: "column", flexShrink: 1, minHeight: 0, overflowY: "hidden", children: queueOpen && !pending ? _jsx(QueueDialog, { queued: queued, rows: stdout.rows ?? 30, width: width, unavailable: !!state.controlError, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online && !controller.state.pending.length, onRemove: id => operate(() => controller.removeQueued(id)) }) : removal ? _jsx(RemovalDialog, { removal: removal, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online, onCancel: () => setRemoval(undefined), onConfirm: () => operate(async () => { await controller.removeTarget(removal); setRemoval(undefined); }) }) : models ? _jsx(ModelDialog, { models: models, rows: stdout.rows ?? 30, width: width, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online, onChoose: (provider, model, effort) => operate(async () => { await controller.selectModel(provider, model, effort); setModels(undefined); }), onOpen: (provider, model) => setModels({ catalog: models.catalog, provider, model }), onBack: () => setModels({ catalog: models.catalog }), onClose: () => setModels(undefined) }) : searchResults ? _jsx(SearchResultsDialog, { query: searchResults.query, items: searchResults.items, hasMore: searchResults.hasMore, width: width, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy, onOpen: sessionId => operate(() => openSearchSession(sessionId, searchResults.query)), onClose: () => setSearchResults(undefined) }) : state.screen === 'workspaces' || state.screen === 'sessions' ? _jsx(PickerScreen, { title: state.screen === 'workspaces' ? 'Choose workspace' : state.showAllSessions ? 'Choose session · All workspaces' : 'Choose session', identity: `${state.screen}:${state.workspaceId ?? ''}`, choices: choices, width: pickerWidth, 
+                                                // A rollup of badges is read through the key beside it; spelled-out states need no key, and a
+                                                // terminal too narrow for the whole key gets the badges alone rather than half a legend.
+                                                legend: state.screen === 'workspaces' && rollupStyle === 'badges' && pickerWidth >= 40 ? ROLLUP_LEGEND : undefined, enabled: state.online && !state.busy && !input, canSelect: () => !draft.current && controller.state.online && !controller.state.busy }) : _jsxs(_Fragment, { children: [thoughtList && _jsx(ThoughtsDialog, { identity: `thoughts:${state.sessionId}`, options: thoughtOptions, empty: !thoughtEntries?.length && !liveThought, rows: stdout.rows ?? 30, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy }), state.screen === 'chat' && historyQuery !== undefined && _jsx(HistoryDialog, { identity: `history:${historyQuery}`, contentSearch: contentSearch, matches: historyMatches, query: historyQuery, messages: layout.messages, width: width, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy, onJump: seq => operate(() => jumpHistory(seq)), onClose: () => { setHistoryQuery(undefined); setHistoryMatches(undefined); } }), pending && _jsxs(Box, { flexShrink: 0, flexDirection: "column", children: [_jsx(Text, { bold: true, color: theme.colors.context, children: question ? `Question ${answered.length + 1}/${questions.length}${question.header ? ` · ${safeText(string(question.header))}` : ''}` : 'Approval required' }), _jsx(Text, { children: safeText(question ? string(question.question) : JSON.stringify(pending.request, null, 2)) }), question?.detail && _jsx(Text, { children: safeText(string(question.detail)) }), pending.event === 'approval/request' && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [['Allow once', 'Deny', 'Stop turn'].map((label, index) => _jsxs(Text, { color: approvalIndex === index ? theme.accent : undefined, children: [approvalIndex === index ? '❯ ' : '  ', index + 1, ". ", label] }, label)), _jsx(Text, { dimColor: true, children: "\u2191 \u2193 / 1\u20133 select \u00B7 Enter confirm" })] }), options.length > 0 && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [[...options, { label: 'Other answer — type below' }].map((option, index) => ({ option, index }))
                                                                         .slice(optionStart, optionStart + optionPageSize).map(({ option, index }) => _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsxs(Text, { color: index === optionCursor ? theme.accent : undefined, wrap: "truncate-end", children: [index === optionCursor ? '❯ ' : '  ', index + 1, ". ", question?.multiSelect === true && index < options.length ? choiceState.selected.includes(string(option.label)) ? '[x] ' : '[ ] ' : '', safeText(string(option.label))] }), option.description && _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ['     ', safeText(string(option.description))] })] }, index)), _jsx(Text, { dimColor: true, children: choiceState.custom ? 'Type your answer below · Esc returns to options' : question?.multiSelect === true
-                                                                            ? '↑ ↓ move · Space / 1–9 toggle · Enter confirm' : '↑ ↓ / 1–9 select · Enter confirm' })] }), _jsx(Text, { dimColor: true, children: question ? 'Choose "Other answer" to type · the draft is kept while this is open'
-                                                                    : 'Esc keeps this pending · the draft is kept while this is open' })] })] }) }), !queueOpen && !pending && state.screen === 'chat' && queued.length > 0 && _jsx(QueuedPreview, { queued: queued, width: width }), _jsxs(Box, { flexShrink: 0, children: [_jsx(Text, { color: answerPending ? theme.colors.muted : theme.accent, children: "\u276F " }), _jsx(TextInput, { value: input, onChange: setInput, onCursorChange: setCursor, onSubmit: () => { void submit(draft.current); }, reservedKeys: approvalKeysActive ? ['1', '2', '3'] : queueOpen && !pending ? ['d'] : questionKeysActive ? ['1', '2', '3', '4', '5', '6', '7', '8', '9', ...(question?.multiSelect === true ? [' '] : [])] : !removal && !models && !searchResults && (state.screen === 'workspaces' || state.screen === 'sessions') ? ['d'] : undefined, focus: state.online && !state.busy && !copyMode && !answerPending, placeholder: state.screen === 'path' ? 'Absolute directory path on host' : 'Message, @host-file, or /help' })] }), referenceOpen && _jsx(ReferenceMenu, { matches: matches, index: referenceIndex })] }), commandSuggestions && _jsx(Text, { dimColor: true, children: commandSuggestions.join('  ') }), help && _jsx(HelpPanel, { page: currentHelpPage, pages: helpPages, pageSize: helpPageSize }), costExpanded && _jsx(CostPanel, { controller: controller }), _jsx(Frozen, { frozen: statusFrozen, identity: `${width}:${state.sessionId}:${statusExpanded}:${statusScroll}:${pauseReason ?? ''}`, children: _jsx(StatusBar, { controller: controller, width: width, expanded: statusExpanded, scroll: statusScroll, pageSize: statusViewRows, onScroll: setStatusScroll, onOverflow: setStatusOverflow, onRows: setStatusBarRows, pauseReason: pauseReason, revision: state.version }) })] })] }) }) }) });
+                                                                            ? '↑ ↓ move · Space / 1–9 toggle · Enter confirm · Esc dismisses' : '↑ ↓ / 1–9 select · Enter confirm · Esc dismisses' })] }), _jsx(Text, { dimColor: true, children: question ? options.length > 0
+                                                                    ? 'Choose "Other answer" to type · the draft is kept while this is open'
+                                                                    : 'Esc dismisses the question · the draft is kept while this is open'
+                                                                    : 'Esc keeps this pending · the draft is kept while this is open' })] })] }) }), !queueOpen && !pending && state.screen === 'chat' && queued.length > 0 && _jsx(QueuedPreview, { queued: queued, width: width }), _jsx(TextInput, { value: input, onChange: setInput, onCursorChange: setCursor, onSubmit: () => { void submit(draft.current); }, reservedKeys: approvalKeysActive ? ['1', '2', '3'] : queueOpen && !pending ? ['d'] : questionKeysActive ? ['1', '2', '3', '4', '5', '6', '7', '8', '9', ...(question?.multiSelect === true ? [' '] : [])] : !removal && !models && !searchResults && (state.screen === 'workspaces' || state.screen === 'sessions') ? ['d'] : undefined, width: draftWidth, maxRows: composerRows, promptColor: answerPending ? theme.colors.muted : theme.accent, focus: state.online && !state.busy && !copyMode && !answerPending, placeholder: state.screen === 'path' ? 'Absolute directory path on host' : 'Message, @host-file, or /help' }), referenceOpen && _jsx(ReferenceMenu, { matches: matches, index: referenceIndex })] }), commandSuggestions && _jsx(Text, { dimColor: true, children: commandSuggestions.join('  ') }), help && _jsx(HelpPanel, { page: currentHelpPage, pages: helpPages, pageSize: helpPageSize }), costExpanded && _jsx(CostPanel, { controller: controller }), _jsx(Frozen, { frozen: statusFrozen, identity: `${width}:${state.sessionId}:${statusExpanded}:${statusScroll}:${pauseReason ?? ''}`, children: _jsx(StatusBar, { controller: controller, width: width, expanded: statusExpanded, scroll: statusScroll, pageSize: statusViewRows, onScroll: setStatusScroll, onOverflow: setStatusOverflow, onRows: setStatusBarRows, pauseReason: pauseReason, revision: state.version }) })] })] }) }) }) });
 }

package/dist/ui/chat/status.js

@@ -264,14 +264,17 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
             : phase.kind === 'tool' ? `${phase.name ?? 'tool'} ${phaseText(now - phase.startedAt)}`
                 : `${phase.kind === 'thinking' ? 'think' : 'write'} ${phaseText(now - phase.startedAt)}`;
         // The state token reports a fact and never guesses: a paused clock is named, offline and errors
-        // take the token over, and an unknown phase simply leaves the phase group empty.
+        // take the token over, and an unknown phase simply leaves the phase group empty. An answer this
+        // client still owes outranks the paused reason, because that reason is only why the clock stopped.
         const stateToken = !state.online
             ? { text: '! Offline', color: theme.status.offline }
             : state.controlError || state.modelError
                 ? { text: '⚠ Error', color: theme.status.warning }
-                : pauseReason !== undefined
-                    ? { text: `⏸ ${pauseReason}${clock}`, color: theme.colors.muted }
-                    : running ? { text: `◐${clock}`, color: theme.status.working } : { text: '● Ready', color: theme.status.ready };
+                : state.pending.length > 0
+                    ? { text: '? Needs you', color: theme.status.critical }
+                    : pauseReason !== undefined
+                        ? { text: `⏸ ${pauseReason}${clock}`, color: theme.colors.muted }
+                        : running ? { text: `◐${clock}`, color: theme.status.working } : { text: '● Ready', color: theme.status.ready };
         // One marker covers both scopes, because either an unpriceable record or a scan that has not
         // covered every session makes the pair inexact as a reading.
         const inexact = coverage !== 'complete';
@@ -334,9 +337,11 @@ const StatusDetails = memo(function StatusDetails({ controller, theme, width, no
     const turns = count(numeric(record(view.values.sessionStats).turns));
     const duration = since === undefined ? 'unknown duration' : elapsedTime(now - since);
     const detail = [
-        { key: 'activity', color: running ? theme.colors.context : theme.colors.muted, text: running
-                ? `◐ Working · ${duration}${state.transcript.activeTurnStartedAt === undefined ? ' (observed)' : ''} · Ctrl+C Stop`
-                : '● Ready · Ctrl+C exit' },
+        { key: 'activity', color: state.pending.length > 0 ? theme.status.critical : running ? theme.colors.context : theme.colors.muted, text: state.pending.length > 0
+                ? '? Needs you · answer the request above to continue'
+                : running
+                    ? `◐ Working · ${duration}${state.transcript.activeTurnStartedAt === undefined ? ' (observed)' : ''} · Ctrl+C Stop`
+                    : '● Ready · Ctrl+C exit' },
         { key: 'host', text: `${safeText(controller.base)} · ${safeText(state.status)}${!state.online ? ' · offline, last known status' : ''}` },
         ...state.sessionId
             ? [{ key: 'session', text: `Session ${safeText(state.sessionId)}${controller.sessionMode ? ` · ${safeText(controller.sessionMode)}` : ''}` }] : [],

package/dist/ui/dialogs/index.d.ts

@@ -63,15 +63,19 @@ export declare function SearchResultsDialog({ query, items, hasMore, width, enab
     onClose(): void;
 }): import("react").JSX.Element;
 /** Title, current selection and confirm action for a picker screen.
- * @param props - Screen title, list identity and navigation state.
+ * @param props - Screen title, list identity, navigation state, usable width and marker key.
  * @returns The picker screen.
  */
-export declare function PickerScreen({ title, identity, choices, enabled, canSelect }: {
+export declare function PickerScreen({ title, identity, choices, enabled, canSelect, width, legend }: {
     title: string;
     identity: string;
     choices: Choice[];
     enabled: boolean;
     canSelect(): boolean;
+    /** Columns the list may occupy inside the composer frame. */
+    width?: number;
+    /** Marker key shown above the list, for a rollup too compact to spell its states out. */
+    legend?: string;
 }): import("react").JSX.Element;
 /** Newest-first reasoning summaries with the preceding user prompt.
  * @param props - Loaded entries and lazy paging action.

package/dist/ui/dialogs/index.js

@@ -64,11 +64,11 @@ export function SearchResultsDialog({ query, items, hasMore, width, enabled, can
                         action: () => onOpen(string(item.sessionId)) })), { key: 'close', label: '← Back', action: onClose }], enabled: enabled, canSelect: canSelect })] });
 }
 /** Title, current selection and confirm action for a picker screen.
- * @param props - Screen title, list identity and navigation state.
+ * @param props - Screen title, list identity, navigation state, usable width and marker key.
  * @returns The picker screen.
  */
-export function PickerScreen({ title, identity, choices, enabled, canSelect }) {
-    return _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { bold: true, children: title }), _jsx(Picker, { choices: choices, enabled: enabled, canSelect: canSelect }, identity)] });
+export function PickerScreen({ title, identity, choices, enabled, canSelect, width, legend }) {
+    return _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { bold: true, children: title }), legend !== undefined && _jsx(Text, { dimColor: true, wrap: "truncate-end", children: legend }), _jsx(Picker, { choices: choices, enabled: enabled, canSelect: canSelect, width: width }, identity)] });
 }
 /** Newest-first reasoning summaries with the preceding user prompt.
  * @param props - Loaded entries and lazy paging action.