@aragon-agent/cli 0.6.13 → 0.6.15

package/dist/ui/overlays/ConfirmDialog.js

@@ -1,6 +1,14 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Confirm dialog — Yes/No gate for `confirmTools` mode. Resolves the pending
+ * tool-execution promise (spec §3.6). `y` = approve; `n`/Enter/Esc = reject
+ * (Enter follows the safe default shown by the capital N in the "(y/N)" prompt,
+ * since this gates mutating tools like write_file/edit_file/bash).
+ */
+import { useState } from 'react';
 import { Text, useInput } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
+import { wrapToRows } from '../layout/wrap-rows.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
 /**
  * Self-managed (mode B) and deliberately without a position indicator: five
@@ -9,9 +17,20 @@ import { OverlayFrame } from '../layout/OverlayFrame.js';
  * title and border match the other three overlays; the existing `useInput` is
  * untouched.
  */
-export function ConfirmDialog({ state, maxRows, cols, theme, caps, onClose, }) {
+export function ConfirmDialog({ state, isActive = true, maxRows, cols, theme, caps, onClose, }) {
     const glyphs = pickGlyphs(caps);
+    const [offset, setOffset] = useState(0);
     useInput((input, key) => {
+        if (!isActive)
+            return;
+        if (key.pageUp || key.upArrow) {
+            setOffset(n => Math.max(0, n - 1));
+            return;
+        }
+        if (key.pageDown || key.downArrow) {
+            setOffset(n => n + 1);
+            return;
+        }
         if (input === 'y' || input === 'Y') {
             state.resolve(true);
             onClose();
@@ -21,5 +40,5 @@ export function ConfirmDialog({ state, maxRows, cols, theme, caps, onClose, }) {
             onClose();
         }
     });
-    return (_jsxs(OverlayFrame, { title: "Confirm action", hint: `y approve ${glyphs.midDot} n / Enter / Esc reject`, maxRows: maxRows, cols: cols, theme: theme, caps: caps, children: [_jsx(Text, { color: theme.assistant, children: state.summary }), _jsx(Text, { color: theme.muted, children: "Proceed? (y/N)" })] }));
+    return (_jsx(OverlayFrame, { title: "Confirm action", hint: "y approve | n/Enter/Esc reject | PgDn", maxRows: maxRows, cols: cols, theme: theme, caps: caps, scrollOffset: offset, onScrollClamp: setOffset, rows: wrapToRows(state.summary, Math.max(1, cols - 4)).map((line, index) => _jsx(Text, { wrap: "truncate", color: theme.assistant, children: line || ' ' }, index)) }));
 }

package/dist/ui/overlays/HelpOverlay.js

@@ -20,6 +20,7 @@ function keyRows(times) {
         [`Ctrl+C ${times}2`, 'Exit'],
         ['Ctrl+L', 'Redraw the frame'],
         ['Ctrl+T', 'Show/hide thinking (off by default)'],
+        ['Ctrl+G', 'Expand/collapse status details; disabled while an overlay is open'],
         ['PgUp / PgDn', 'Scroll a page (transcript, or this overlay)'],
         ['Shift+Up / Shift+Down', 'Scroll the transcript a line (full-screen mode)'],
         ['Wheel', 'Scroll the transcript (or the open overlay)'],
@@ -27,8 +28,14 @@ function keyRows(times) {
         // Drag-select is the one affordance here a user cannot discover by pressing
         // a key, so it has to be named somewhere they can look it up. The one-shot
         // startup notice is the other place, and it scrolls away.
-        ['Drag right edge', 'Scroll messages and input together; type to return'],
-        ['Bottom rows', 'Input, fixed action hints, then global runtime / queue / context status'],
+        ['Drag right edge', 'Scroll messages; input stays fixed; type to return to newest output'],
+        ['Bottom rows', 'Fixed input, one status row; Ctrl+G adds one detail row'],
+        ['C / Th / t/s', 'Context percent / thinking level / run-average output tokens per second'],
+        ['O/N/L/M/H/X', 'Thinking: off/minimal/low/medium/high/xhigh'],
+        ['~ / ? / --', 'Estimated context / unknown context / unavailable output speed'],
+        ['Output speed', 'Main Agent reported output tokens / total run time, including tools and waits'],
+        ['Copy / Sent / E / F', 'Copying / unconfirmed copy sent / copy error / Esc force-stop'],
+        ['^N', 'Transcript line offset from the bottom, not a new-message count'],
         ['Drag text (left button)', 'Select text on screen; the highlight waits'],
         ['Ctrl+C (with a selection)', 'Copy the pending selection - does not arm exit'],
         ['Native terminal selection', 'Copy-on-select is controlled by your terminal settings'],

package/dist/ui/overlays/ModelPicker.d.ts

@@ -3,19 +3,16 @@
  * providers only (R5) so it never offers a model whose provider would fail at
  * run with `Unknown LLM provider`. Lists each provider's builtin models.
  *
- * Uses `OverlayFrame`'s SELF-MANAGED mode (§4.4 / R-12). `ink-select-input`
- * windows itself via `limit` and registers its own `useInput` with `isFocused`
- * defaulting to true; Ink delivers every key to every mounted handler, so a
- * frame that also claimed the arrow keys would move the selection twice per
- * press. Slicing it by element would be worse still — it is one component, not
- * a list of rows. So the frame draws chrome only, and `App` registers no arrow
- * keys while this overlay is open.
+ * Selection belongs to a model ID, independently of the visible row window.
+ * Resizing or hiding the overlay never resets it. Each item occupies one row;
+ * this component owns navigation while App owns Escape.
  */
 import React from 'react';
 import type { ModelRegistry } from '@aragon-agent/core';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
 interface ModelPickerProps {
+    isActive?: boolean;
     registry: ModelRegistry;
     currentProvider: string;
     currentModel: string;
@@ -25,5 +22,5 @@ interface ModelPickerProps {
     caps: TermCapabilities;
     onSelect: (provider: string, model: string) => void;
 }
-export declare function ModelPicker({ registry, currentProvider, currentModel, maxRows, cols, theme, caps, onSelect, }: ModelPickerProps): React.ReactElement;
+export declare function ModelPicker({ isActive, registry, currentProvider, currentModel, maxRows, cols, theme, caps, onSelect, }: ModelPickerProps): React.ReactElement;
 export {};

package/dist/ui/overlays/ModelPicker.js

@@ -1,10 +1,19 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import SelectInput from 'ink-select-input';
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Model picker overlay. Sources its provider set from the adapter-backed
+ * providers only (R5) so it never offers a model whose provider would fail at
+ * run with `Unknown LLM provider`. Lists each provider's builtin models.
+ *
+ * Selection belongs to a model ID, independently of the visible row window.
+ * Resizing or hiding the overlay never resets it. Each item occupies one row;
+ * this component owns navigation while App owns Escape.
+ */
+import { useState } from 'react';
+import { Text, useInput } from 'ink';
 import { ADAPTER_PROVIDERS } from '../../config/schema.js';
 import { pickGlyphs } from '../glyphs.js';
-import { OverlayFrame } from '../layout/OverlayFrame.js';
-import { overlayListLimit } from '../layout/overlay-window.js';
-export function ModelPicker({ registry, currentProvider, currentModel, maxRows, cols, theme, caps, onSelect, }) {
+import { OverlayFrame, overlayBodyRows } from '../layout/OverlayFrame.js';
+export function ModelPicker({ isActive = true, registry, currentProvider, currentModel, maxRows, cols, theme, caps, onSelect, }) {
     const glyphs = pickGlyphs(caps);
     const items = [];
     const seen = new Set();
@@ -21,9 +30,34 @@ export function ModelPicker({ registry, currentProvider, currentModel, maxRows,
             });
         }
     }
-    const initialIndex = Math.max(0, items.findIndex((it) => it.value === `${currentProvider}:${currentModel}`));
-    return (_jsx(OverlayFrame, { title: "Select a model", hint: `Enter choose ${glyphs.midDot} Esc cancel`, maxRows: maxRows, cols: cols, theme: theme, caps: caps, children: _jsx(SelectInput, { items: items, limit: overlayListLimit(maxRows), initialIndex: initialIndex >= 0 ? initialIndex : 0, onSelect: (item) => {
-                const [provider, ...rest] = item.value.split(':');
-                onSelect(provider, rest.join(':'));
-            } }) }));
+    const [selectedValue, setSelectedValue] = useState(`${currentProvider}:${currentModel}`);
+    const selectedIndex = Math.max(0, items.findIndex(item => item.value === selectedValue));
+    const visibleRows = overlayBodyRows(maxRows, cols);
+    const offset = Math.max(0, Math.min(selectedIndex - visibleRows + 1, items.length - visibleRows));
+    const choose = (item) => {
+        if (!item)
+            return;
+        const [provider, ...rest] = item.value.split(':');
+        onSelect(provider, rest.join(':'));
+    };
+    useInput((input, key) => {
+        // Consume hidden input without changing selection, including when this is
+        // the only mounted input handler; otherwise buffered keys can replay later.
+        if (!isActive || !items.length)
+            return;
+        if (key.upArrow || input === 'k') {
+            setSelectedValue(items[(selectedIndex - 1 + items.length) % items.length].value);
+        }
+        else if (key.downArrow || input === 'j') {
+            setSelectedValue(items[(selectedIndex + 1) % items.length].value);
+        }
+        else if (key.return)
+            choose(items[selectedIndex]);
+        else if (/^[1-9]$/.test(input)) {
+            const visibleIndex = Number(input) - 1;
+            if (visibleIndex < visibleRows)
+                choose(items[offset + visibleIndex]);
+        }
+    });
+    return (_jsx(OverlayFrame, { title: "Select a model", hint: `Enter choose ${glyphs.midDot} Esc cancel`, maxRows: maxRows, cols: cols, theme: theme, caps: caps, scrollOffset: offset, rows: items.length ? items.map((item, index) => _jsxs(Text, { wrap: "truncate", color: index === selectedIndex ? theme.accent : theme.primary, children: [index === selectedIndex ? `${glyphs.caret} ` : '  ', item.label] }, item.value)) : [_jsx(Text, { wrap: "truncate", children: "No models available" }, "empty")] }));
 }

package/dist/ui/overlays/ModelProfileEditor.js

@@ -24,6 +24,8 @@ function useEditorInput(props, navigation) {
         dispatch({ type: 'merge-editor' });
     }
     useInput((input, key) => {
+        if (props.isActive === false)
+            return;
         if (key.escape) {
             dispatch({ type: 'cancel-editor' });
             return;

package/dist/ui/overlays/ModelProfilePicker.d.ts

@@ -3,6 +3,7 @@ import type { ModelProfile, ModelProfilesConfig, ModelRole } from '../../config/
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
 export interface ProfileFrameProps {
+    isActive?: boolean;
     theme: Theme;
     caps: TermCapabilities;
     cols: number;

package/dist/ui/overlays/ModelProfilePicker.js

@@ -3,7 +3,7 @@ import { useEffect, useState } from 'react';
 import { Text, useInput } from 'ink';
 import stringWidth from 'string-width';
 import { pickGlyphs } from '../glyphs.js';
-import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { OverlayFrame, overlayBodyRows } from '../layout/OverlayFrame.js';
 import { stripPasteFrames } from '../paste-frames.js';
 import { stripEnterFrames } from '../enter-frames.js';
 import { profileUsers } from './model-profile-state.js';
@@ -13,7 +13,7 @@ export function useProfileScroll(props, focus) {
     useEffect(() => { props.onScrollClamp?.(0); }, []);
     useEffect(() => { setOffset(props.scrollOffset); }, [props.scrollOffset]);
     useEffect(() => {
-        const height = Math.max(1, props.maxRows - (props.cols >= 48 ? 5 : 3));
+        const height = overlayBodyRows(props.maxRows, props.cols);
         const next = focus < offset ? focus : focus >= offset + height ? focus - height + 1 : offset;
         if (next !== offset) {
             setOffset(next);
@@ -98,6 +98,8 @@ function usePickerInput(props, state) {
             props.onDelete(selected.id);
     }
     useInput((input, key) => {
+        if (props.isActive === false)
+            return;
         if (key.escape) {
             if (searching)
                 setSearching(false);

package/dist/ui/overlays/PlanReviewOverlay.d.ts

@@ -30,6 +30,7 @@ export type PlanVerdict = {
     feedback: string;
 };
 interface PlanReviewOverlayProps {
+    isActive?: boolean;
     plan: NormalizedPlan;
     maxRows: number;
     cols: number;
@@ -39,7 +40,7 @@ interface PlanReviewOverlayProps {
     caps: TermCapabilities;
     onVerdict: (verdict: PlanVerdict) => void;
 }
-export declare function PlanReviewOverlay({ plan, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onVerdict, }: PlanReviewOverlayProps): React.ReactElement;
+export declare function PlanReviewOverlay({ isActive, plan, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onVerdict, }: PlanReviewOverlayProps): React.ReactElement;
 /**
  * Flatten the plan into one-row elements.
  *

package/dist/ui/overlays/PlanReviewOverlay.js

@@ -25,16 +25,18 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Text, useInput } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
-import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { OverlayFrame, overlayBodyRows } from '../layout/OverlayFrame.js';
 import { wrapToRows } from '../layout/wrap-rows.js';
 import { stripPasteFrames } from '../paste-frames.js';
 import { stripEnterFrames } from '../enter-frames.js';
 /** The frame's border plus its one-column padding on each side. */
 const FRAME_CHROME_COLS = 4;
-export function PlanReviewOverlay({ plan, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onVerdict, }) {
+export function PlanReviewOverlay({ isActive = true, plan, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onVerdict, }) {
     const glyphs = pickGlyphs(caps);
     const [feedback, setFeedback] = useState(null);
     useInput((input, key) => {
+        if (!isActive)
+            return;
         if (key.escape)
             return; // App owns dismiss.
         if (feedback !== null) {
@@ -84,9 +86,10 @@ export function PlanReviewOverlay({ plan, maxRows, cols, scrollOffset, onScrollC
         // whole review away from either sub-state. `<-` is the route back to the
         // card, which is why it is named here too.
         const feedbackHint = `${glyphs.enterKey} send ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc dismiss`;
-        return (_jsxs(OverlayFrame, { title: "What should change?", hint: feedbackHint, maxRows: maxRows, cols: cols, theme: theme, caps: caps, children: [_jsx(Text, { wrap: "truncate", color: theme.muted, children: "The agent revises the plan and submits it again." }), _jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { color: theme.primary, bold: true, children: [glyphs.caret, ' '] }), feedback.length > 0 ? (_jsx(Text, { children: feedback })) : (_jsx(Text, { color: theme.muted, children: "e.g. use the existing session store instead" })), _jsx(Text, { inverse: true, children: " " })] })] }));
+        return (_jsxs(OverlayFrame, { title: "What should change?", hint: feedbackHint, maxRows: maxRows, cols: cols, theme: theme, caps: caps, children: [overlayBodyRows(maxRows, cols) >= 2 && _jsx(Text, { wrap: "truncate", color: theme.muted, children: "The agent revises the plan and submits it again." }), _jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { color: theme.primary, bold: true, children: [glyphs.caret, ' '] }), feedback.length > 0 ? (_jsx(Text, { children: wrapToRows(feedback, Math.max(1, cols - FRAME_CHROME_COLS - 3)).at(-1) })) : (_jsx(Text, { color: theme.muted, children: "type feedback" })), _jsx(Text, { inverse: true, children: " " })] })] }));
     }
-    return (_jsx(OverlayFrame, { title: "Review plan", hint: `a approve ${glyphs.midDot} r revise ${glyphs.midDot} esc dismiss ${glyphs.midDot} ${glyphs.arrowUp}${glyphs.arrowDown} scroll`, maxRows: maxRows, cols: cols, rows: rows, scrollOffset: scrollOffset, onScrollClamp: onScrollClamp, theme: theme, caps: caps }));
+    return (_jsx(OverlayFrame, { title: "Review plan", hint: cols <= 48 ? "a approve r revise Esc cancel"
+            : `a approve ${glyphs.midDot} r revise ${glyphs.midDot} esc dismiss ${glyphs.midDot} ${glyphs.arrowUp}${glyphs.arrowDown} scroll`, maxRows: maxRows, cols: cols, rows: rows, scrollOffset: scrollOffset, onScrollClamp: onScrollClamp, theme: theme, caps: caps }));
 }
 /**
  * Flatten the plan into one-row elements.

package/dist/ui/overlays/QuestionOverlay.d.ts

@@ -19,6 +19,7 @@ import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
 import type { Answer, NormalizedQuestion } from '../../tools/human-input.js';
 interface QuestionOverlayProps {
+    isActive?: boolean;
     questions: NormalizedQuestion[];
     maxRows: number;
     cols: number;
@@ -26,5 +27,5 @@ interface QuestionOverlayProps {
     caps: TermCapabilities;
     onSubmit: (answers: Answer[]) => void;
 }
-export declare function QuestionOverlay({ questions, maxRows, cols, theme, caps, onSubmit, }: QuestionOverlayProps): React.ReactElement;
+export declare function QuestionOverlay({ isActive, questions, maxRows, cols, theme, caps, onSubmit, }: QuestionOverlayProps): React.ReactElement;
 export {};

package/dist/ui/overlays/QuestionOverlay.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * QuestionOverlay — the keyboard-driven multiple-choice wizard `ask_user`
  * renders (plan-mode §6.5).
@@ -15,10 +15,11 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * opposite — both it and `App` call `resolve` — which is harmless there only by
  * accident of promise semantics, and is not a pattern to copy (R-P12).
  */
-import { useState } from 'react';
-import { Box, Text, useInput } from 'ink';
+import { useState, useLayoutEffect } from 'react';
+import { Text, useInput } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
-import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { wrapToRows } from '../layout/wrap-rows.js';
+import { OverlayFrame, overlayBodyRows } from '../layout/OverlayFrame.js';
 import { stripPasteFrames } from '../paste-frames.js';
 import { stripEnterFrames } from '../enter-frames.js';
 /** Which option index each question starts on: the recommended one. */
@@ -31,7 +32,7 @@ function initialSelections(questions) {
         return new Set(recommended >= 0 ? [recommended] : [0]);
     });
 }
-export function QuestionOverlay({ questions, maxRows, cols, theme, caps, onSubmit, }) {
+export function QuestionOverlay({ isActive = true, questions, maxRows, cols, theme, caps, onSubmit, }) {
     const glyphs = pickGlyphs(caps);
     const [step, setStep] = useState(0);
     const [phase, setPhase] = useState('choosing');
@@ -39,6 +40,7 @@ export function QuestionOverlay({ questions, maxRows, cols, theme, caps, onSubmi
     const [selections, setSelections] = useState(() => initialSelections(questions));
     const [customs, setCustoms] = useState(() => questions.map(() => ''));
     const [draft, setDraft] = useState('');
+    const [offset, setOffset] = useState(0);
     const question = questions[Math.min(step, questions.length - 1)];
     const cursor = cursors[step] ?? 0;
     const setCursorAt = (index, value) => setCursors((prev) => prev.map((c, i) => (i === index ? value : c)));
@@ -80,6 +82,16 @@ export function QuestionOverlay({ questions, maxRows, cols, theme, caps, onSubmi
         setPhase('choosing');
     };
     useInput((input, key) => {
+        if (!isActive)
+            return;
+        if (key.pageUp) {
+            setOffset(n => Math.max(0, n - 1));
+            return;
+        }
+        if (key.pageDown) {
+            setOffset(n => n + 1);
+            return;
+        }
         // App owns Esc for both new overlays (R-P12). Swallow it here so the
         // free-text editor below cannot eat the raw escape byte as a character.
         if (key.escape)
@@ -172,31 +184,32 @@ export function QuestionOverlay({ questions, maxRows, cols, theme, caps, onSubmi
         : phase === 'review'
             ? `${glyphs.enterKey} submit ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`
             : `${glyphs.arrowUp}${glyphs.arrowDown} choose ${glyphs.midDot} ${glyphs.enterKey} next${question.allowMultiple ? ` ${glyphs.midDot} space toggle` : ''} ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`;
-    return (_jsx(OverlayFrame, { title: `${title}${position}`, hint: hint, maxRows: maxRows, cols: cols, theme: theme, caps: caps, children: phase === 'review' ? (_jsx(ReviewBody, { questions: questions, answers: buildAnswers(), theme: theme })) : (_jsx(QuestionBody, { question: question, cursor: cursor, selected: selections[step] ?? new Set(), typing: phase === 'typingOther', draft: draft, theme: theme, caps: caps })) }));
-}
-/**
- * ONE QUESTION PER SCREEN, not all of them at once. Three questions x four
- * options x a description line is 20+ rows against a ~15-row viewport on a
- * 24-row terminal.
- */
-function QuestionBody({ question, cursor, selected, typing, draft, theme, caps, }) {
-    const glyphs = pickGlyphs(caps);
-    const markOn = question.allowMultiple ? glyphs.boxChecked : glyphs.keyOn;
-    const markOff = question.allowMultiple ? glyphs.boxEmpty : glyphs.keyOff;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { wrap: "truncate", color: theme.accent, bold: true, children: question.header }), _jsx(Text, { wrap: "truncate", color: theme.assistant, children: question.question }), _jsx(Text, { children: " " }), question.options.map((option, i) => {
-                const active = i === cursor;
-                const on = selected.has(i);
-                return (_jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { color: active ? theme.primary : theme.muted, children: [active ? glyphs.caret : ' ', ' '] }), _jsxs(Text, { color: on ? theme.primary : theme.muted, children: [on ? markOn : markOff, " "] }), _jsx(Text, { color: active ? theme.assistant : undefined, bold: active, children: option.isOther ? `${option.label}${glyphs.ellipsis}` : option.label }), option.description.length > 0 && (_jsxs(Text, { color: theme.muted, children: ['  ', option.description] })), option.recommended && (_jsxs(Text, { backgroundColor: theme.chip.bg, color: theme.chip.fg, children: [' ', "RECOMMENDED", ' '] }))] }, `${question.id}-${i}`));
-            }), typing && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { color: theme.primary, bold: true, children: [glyphs.caret, ' '] }), draft.length > 0 ? (_jsx(Text, { children: draft })) : (_jsx(Text, { color: theme.muted, children: "type your own answer" })), _jsx(Text, { inverse: true, children: " " })] })] }))] }));
-}
-/**
- * The review step exists because a wizard that fires on the last `Enter` with no
- * confirmation makes a mis-keyed answer unrecoverable.
- */
-function ReviewBody({ questions, answers, theme, }) {
-    return (_jsx(Box, { flexDirection: "column", children: questions.map((q, i) => {
-            const answer = answers[i];
-            const value = answer?.custom ?? answer?.selected.join(', ') ?? '';
-            return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: theme.accent, children: q.header.padEnd(14) }), _jsx(Text, { color: theme.assistant, children: value })] }, q.id));
-        }) }));
+    const rowTexts = [];
+    const optionStarts = [];
+    const push = (text) => { rowTexts.push(...wrapToRows(text, Math.max(1, cols - 4))); };
+    if (phase === 'review') {
+        buildAnswers().forEach((answer, index) => push(`${questions[index].header}: ${answer.custom ?? answer.selected.join(', ')}`));
+    }
+    else {
+        push(question.header);
+        push(question.question);
+        question.options.forEach((option, index) => {
+            optionStarts.push(rowTexts.length);
+            const mark = (selections[step] ?? new Set()).has(index) ? '[x]' : '[ ]';
+            push(`${index === cursor ? glyphs.caret : ' '} ${mark} ${option.label}${option.recommended ? ' RECOMMENDED' : ''} ${option.description}`);
+        });
+        if (phase === 'typingOther')
+            push(`${glyphs.caret} ${draft || 'type your own answer'} `);
+    }
+    const focus = phase === 'review' ? 0 : phase === 'typingOther'
+        ? Math.max(0, rowTexts.length - 1) : optionStarts[cursor] ?? 0;
+    useLayoutEffect(() => {
+        const height = overlayBodyRows(maxRows, cols);
+        setOffset(previous => focus < previous ? focus : focus >= previous + height
+            ? focus - height + 1 : previous);
+    }, [focus, maxRows, cols, step, phase]);
+    const shortHint = phase === 'typingOther' ? 'Enter commit | Left back | Esc cancel'
+        : phase === 'review' ? 'Enter submit | Left back | Esc cancel'
+            : question.allowMultiple ? '^v choose Space toggle Enter next Esc' : 'Up/Down choose Enter next Esc cancel';
+    return _jsx(OverlayFrame, { title: `${title}${position}`, hint: cols <= 48 ? shortHint : hint, maxRows: maxRows, cols: cols, theme: theme, caps: caps, rows: rowTexts.map((line, index) => _jsx(Text, { wrap: "truncate", children: line || ' ' }, index)), scrollOffset: offset, onScrollClamp: setOffset });
 }

package/dist/ui/overlays/QueueOverlay.js

@@ -74,6 +74,6 @@ export function QueueOverlay(props) {
             onScrollClamp(offset);
     }, [projected, offset, scrollOffset, onScrollClamp]);
     const rows = useMemo(() => projected.length ? projected.map((row, index) => _jsx(Text, { wrap: "truncate", color: theme.primary, children: row.text || ' ' }, `${row.queueId}:${index}`))
-        : [_jsx(Text, { children: '\u961f\u5217\u5df2\u5904\u7406\u5b8c\u6bd5' }, "empty")], [projected, theme]);
-    return _jsx(OverlayFrame, { ...props, title: `Queue: \u5f85\u5904\u7406 ${pending.length}`, hint: "PgUp/PgDn | Up/Down | Esc", rows: rows, scrollOffset: offset });
+        : [_jsx(Text, { children: "Queue is empty" }, "empty")], [projected, theme]);
+    return _jsx(OverlayFrame, { ...props, title: `Queue: ${pending.length} pending`, hint: "PgUp/PgDn | Up/Down | Esc", rows: rows, scrollOffset: offset });
 }

package/dist/ui/overlays/SettingsScreen.d.ts

@@ -87,6 +87,7 @@ export interface SettingsValues {
     compactionArchive: 'on' | 'off';
 }
 interface SettingsScreenProps {
+    isActive?: boolean;
     initial: SettingsValues;
     /** Resolved keys per provider so switching providers reloads the right key. */
     apiKeys: Record<string, string | undefined>;

package/dist/ui/overlays/SettingsScreen.js

@@ -247,11 +247,12 @@ export function SettingsScreen(props) {
     return props.draft ? _jsx(ProfileSettingsScreen, { ...props, draft: props.draft })
         : _jsx(LegacySettingsScreen, { ...props });
 }
-function LegacySettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onSave, retrySummary, }) {
+function LegacySettingsScreen({ isActive = true, initial, apiKeys, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onSave, retrySummary, }) {
     const [values, setValues] = useState(initial);
     const [index, setIndex] = useState(0);
     const glyphs = pickGlyphs(caps);
     const field = FIELDS[index];
+    const focusedOffset = useProfileScroll({ maxRows, cols, scrollOffset, onScrollClamp, theme, caps }, index);
     const cycle = (dir) => {
         if (field.kind !== 'enum' || !field.options)
             return;
@@ -271,6 +272,8 @@ function LegacySettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset, o
         });
     };
     useInput((input, key) => {
+        if (!isActive)
+            return;
         if (key.escape)
             return; // App closes the overlay.
         if (key.upArrow) {
@@ -380,7 +383,7 @@ function LegacySettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset, o
         rows.push(_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', 'API retries'.padEnd(18), retrySummary] }, "__retry"));
     }
     rows.push(_jsx(Text, { wrap: "truncate", color: theme.muted, children: "Enter saves. Keys persist to the config file (0600)." }, "__save"));
-    return (_jsx(OverlayFrame, { title: "Settings", hint: `${glyphs.arrowUp}${glyphs.arrowDown} field ${glyphs.midDot} ${glyphs.arrowLeft}${glyphs.arrowRight} change ${glyphs.midDot} Enter save ${glyphs.midDot} Esc close`, maxRows: maxRows, cols: cols, rows: rows, scrollOffset: scrollOffset, onScrollClamp: onScrollClamp, theme: theme, caps: caps }));
+    return (_jsx(OverlayFrame, { title: "Settings", hint: `${glyphs.arrowUp}${glyphs.arrowDown} field ${glyphs.midDot} ${glyphs.arrowLeft}${glyphs.arrowRight} change ${glyphs.midDot} Enter save ${glyphs.midDot} Esc close`, maxRows: maxRows, cols: cols, rows: rows, scrollOffset: focusedOffset, onScrollClamp: onScrollClamp, theme: theme, caps: caps }));
 }
 const PROFILE_FIELDS = FIELDS.filter((field) => ![
     'provider', 'model', 'baseUrl', 'apiKey', 'fastProvider', 'fastModel', 'fastEnabled',
@@ -592,6 +595,8 @@ function activateRootSetting(props, view) {
 function useRootSettingsInput(props, view) {
     const { index, count, field, readError, persisted, values, state, setIndex, setValues } = view;
     useInput((input, key) => {
+        if (props.isActive === false)
+            return;
         if (key.escape) {
             cancelProfileSettings(props, view);
             return;
@@ -635,6 +640,8 @@ function useRootSettingsInput(props, view) {
 function useSettingsConfirmationInput(props, view) {
     const { state, dispatch, confirmIndex, setConfirmIndex, reloadPending, confirming } = view;
     useInput((_input, key) => {
+        if (props.isActive === false)
+            return;
         if (key.escape) {
             dispatch({ type: 'page', page: state.page === 'delete-confirm'
                     ? 'manager' : 'root' });
@@ -664,7 +671,7 @@ function renderSettingsConfirmation(props, view) {
     const name = library.entries.find((entry) => entry.id === state.deleteId)?.name ?? '';
     const labels = deleting ? ['Cancel', 'Delete'] : ['Continue', 'Discard'];
     return _jsx(OverlayFrame, { ...props, title: deleting ? `Delete ${name}?` : 'Discard unsaved changes?', hint: "Enter choose | Esc continue", rows: labels
-            .map((label, at) => _jsxs(Text, { wrap: "truncate", color: props.theme.primary, children: [confirmIndex === at ? `${glyphs.caret} ` : '  ', label] }, label)), scrollOffset: 0 });
+            .map((label, at) => _jsxs(Text, { wrap: "truncate", color: props.theme.primary, children: [confirmIndex === at ? `${glyphs.caret} ` : '  ', label] }, label)), scrollOffset: confirmIndex });
 }
 function renderProfileSubpage(props, view) {
     const { state, library, dispatch, setConfirmIndex } = view;

package/dist/ui/render-cache.d.ts

@@ -12,7 +12,7 @@
  *   - `Markdown` re-split and re-regexed the whole answer into one React element
  *     per line on every render.
  *
- * Everything cached here is a function of its INPUT STRING ALONE. Theme and
+ * Cached text depends on its input and, for highlighting, the color level. Theme and
  * glyphs are applied at render time and are never cached, because a themed
  * React element in a cache makes `/theme` a no-op until the entry evicts (K-5) —
  * exactly the class of silent bug this package writes comments to avoid.
@@ -50,7 +50,7 @@ export interface RenderCacheStats {
     misses: number;
 }
 /**
- * Syntax-highlight `code`, memoised on `(lang, code)`.
+ * Syntax-highlight `code`, memoised on `(colorLevel, lang, code)`.
  *
  * `cli-highlight` emits chalk-level ANSI that does not depend on `theme.*`, so
  * unlike a rendered element this string IS safe to cache across a `/theme`

package/dist/ui/render-cache.js

@@ -12,7 +12,7 @@
  *   - `Markdown` re-split and re-regexed the whole answer into one React element
  *     per line on every render.
  *
- * Everything cached here is a function of its INPUT STRING ALONE. Theme and
+ * Cached text depends on its input and, for highlighting, the color level. Theme and
  * glyphs are applied at render time and are never cached, because a themed
  * React element in a cache makes `/theme` a no-op until the entry evicts (K-5) —
  * exactly the class of silent bug this package writes comments to avoid.
@@ -22,6 +22,7 @@
  * caches would miss precisely when a scroll brings an old entry back.
  */
 import { highlight } from 'cli-highlight';
+import { syntaxColorLevel } from './color-runtime.js';
 import { parseMarkdownBlocks } from './markdown-blocks.js';
 import { pickGlyphs } from './glyphs.js';
 export const RENDER_CACHE_LIMITS = {
@@ -113,7 +114,7 @@ const markdownCache = new LruCache(RENDER_CACHE_LIMITS.markdownEntries, RENDER_C
  */
 const lineCache = new LruCache(RENDER_CACHE_LIMITS.linesEntries, RENDER_CACHE_LIMITS.markdownBytes);
 /**
- * Syntax-highlight `code`, memoised on `(lang, code)`.
+ * Syntax-highlight `code`, memoised on `(colorLevel, lang, code)`.
  *
  * `cli-highlight` emits chalk-level ANSI that does not depend on `theme.*`, so
  * unlike a rendered element this string IS safe to cache across a `/theme`
@@ -129,7 +130,7 @@ export function highlightCached(code, lang) {
     // ripgrep, which silently hides every definition in it from the tool this
     // codebase navigates itself with. NUL rather than a space because a space
     // still lets ("a b", "ts") and ("b", "ts a") collide on one key.
-    const key = `${lang}\u0000${code}`;
+    const key = `${syntaxColorLevel()}\u0000${lang}\u0000${code}`;
     const hit = highlightCache.get(key);
     if (hit !== undefined)
         return hit;

package/dist/ui/run-metrics.d.ts

@@ -0,0 +1,23 @@
+/** UI-only metrics. Feed only the existing generation-guarded main subscription. */
+export interface RunMetrics {
+    runId: number;
+    startedAt: number | null;
+    endedAt: number | null;
+    outputTokens: number;
+    usageKnown: boolean;
+}
+export interface RunMetricsEvent {
+    type: string;
+    usage?: {
+        outputTokens?: number;
+    };
+}
+export interface RunMetricsProjection {
+    elapsedMs: number;
+    tokPerSec: number;
+    speedKnown: boolean;
+}
+export declare function createRunMetrics(): RunMetrics;
+export declare function freezeRunMetrics(state: RunMetrics, now: number): RunMetrics;
+export declare function updateRunMetrics(state: RunMetrics, event: RunMetricsEvent, now: number): RunMetrics;
+export declare function projectRunMetrics(state: RunMetrics, now: number): RunMetricsProjection;

package/dist/ui/run-metrics.js

@@ -0,0 +1,27 @@
+export function createRunMetrics() {
+    return { runId: 0, startedAt: null, endedAt: null, outputTokens: 0, usageKnown: false };
+}
+export function freezeRunMetrics(state, now) {
+    if (state.startedAt === null || state.endedAt !== null)
+        return state;
+    return { ...state, endedAt: Number.isFinite(now) ? Math.max(state.startedAt, now) : state.startedAt };
+}
+export function updateRunMetrics(state, event, now) {
+    if (event.type === 'agent_start')
+        return { ...createRunMetrics(), runId: state.runId + 1,
+            startedAt: Number.isFinite(now) ? now : 0 };
+    if (state.startedAt === null || state.endedAt !== null)
+        return state;
+    if (event.type === 'agent_end' || event.type === 'error')
+        return freezeRunMetrics(state, now);
+    const output = event.usage?.outputTokens;
+    if (event.type !== 'turn_end' || output === undefined || !Number.isFinite(output) || output < 0)
+        return state;
+    return { ...state, outputTokens: Math.min(Number.MAX_VALUE, state.outputTokens + output), usageKnown: true };
+}
+export function projectRunMetrics(state, now) {
+    const end = state.endedAt ?? (Number.isFinite(now) ? now : state.startedAt ?? 0);
+    const elapsedMs = state.startedAt === null ? 0 : Math.max(0, end - state.startedAt);
+    const speedKnown = state.startedAt !== null && state.endedAt === null && state.usageKnown && elapsedMs > 500;
+    return { elapsedMs, speedKnown, tokPerSec: speedKnown ? state.outputTokens / (elapsedMs / 1000) : 0 };
+}

package/dist/ui/status-feedback.d.ts

@@ -0,0 +1,33 @@
+/** Facts, never translated toast text, determine action ownership and feedback. */
+export interface StatusFeedback {
+    kind: 'confirm' | 'stopping' | 'force-stop' | 'exit' | 'copying' | 'copied' | 'copy-sent' | 'copy-cleanup' | 'copy-error' | 'notice';
+    text: string;
+    level: 'info' | 'warn' | 'error';
+}
+export type EscapeAction = 'menu' | 'cancel-start' | 'confirm-stop' | 'force-stop';
+export interface StatusFeedbackInput {
+    interactionPhase: 'idle' | 'starting' | 'running';
+    interruptPhase?: 'ready' | 'armed' | 'stopping';
+    completion?: 'none' | 'slash' | 'file';
+    overlay?: string | null;
+    copyState?: {
+        busy: boolean;
+        cleanupPending: boolean;
+    };
+    copyResult?: {
+        status: 'confirmed' | 'sent' | 'error';
+        text: string;
+    };
+    ctrlCArmed?: boolean;
+    selectionPending?: boolean;
+    liveServices?: number;
+    toast?: {
+        text: string;
+        level: 'info' | 'warn' | 'error';
+    };
+}
+export interface StatusFeedbackProjection {
+    feedback?: StatusFeedback;
+    escapeAction?: EscapeAction;
+}
+export declare function projectStatusFeedback(input: StatusFeedbackInput): StatusFeedbackProjection;