@aragon-agent/cli 0.6.14 → 0.6.15

package/dist/ui/layout/budget.d.ts

@@ -1,29 +1,28 @@
-/** Fullscreen reserves three fixed rows; composer height is a footer layout input. */
-/** Below this many rows the composer's hint line is dropped to buy back a row. */
 export declare const HINT_MIN_ROWS = 20;
-export interface ChromeBudget {
-    /** Brand bar. Constant 1 in full-screen — this is what makes A-3 hold. */
-    header: number;
-    toast: number;
-    /**
-     * Round border (2) + the DRAFT's own rows, plus the hint row when it fits.
-     *
-     * The draft term used to be the constant 1 that the `3` / `4` below encode.
-     * That constant is what made a pasted 200-line draft draw the transcript 197
-     * rows shorter than every consumer of `viewportRows` believed -- the trap
-     * `BottomStatusRow.tsx:5-27` already documents at 1/200th the magnitude.
-     */
-    composer: number;
-    status: number;
+export interface FrameBudgetInput {
+    rows?: number;
+    cols?: number;
+    draftRows: number;
+    popupRows: number;
+    statusExpanded: boolean;
 }
-/**
- * The composer's draft rows, clamped to what this terminal height allows.
- *
- * Exported so the reporter and the budget clamp with ONE function: I-8 requires
- * the rendered row count and the number handed to `viewportRows` to be the same
- * number, and two clamps are how they stop being.
- */
+export interface FrameBudget {
+    rows: number;
+    cols: number;
+    inactive: boolean;
+    frameRows: number;
+    headerRows: number;
+    statusRows: 0 | 1 | 2;
+    composerRows: number;
+    composerSlotRows: number;
+    popupRows: number;
+    popupMaxHeight: number;
+    viewportRows: number;
+    composerCols: number;
+}
+/** Clamp the displayed draft, independently of any transcript or panel content. */
 export declare function clampDraftRows(rows: number, draftRows: number): number;
-export declare function chromeBudget(rows: number, draftRows?: number): ChromeBudget;
-/** Shared document height; the legacy draft argument remains source-compatible. */
-export declare function viewportRows(rows: number, _draftRows?: number): number;
+/** Total menu capacity, including its borders; reserve at least one message row. */
+export declare function popupCapacity(rows: number, draftRows: number, statusExpanded: boolean): number;
+/** Normalize terminal dimensions once and conserve every visible frame row. */
+export declare function buildFrameBudget(input: FrameBudgetInput): FrameBudget;

package/dist/ui/layout/budget.js

@@ -1,30 +1,37 @@
-/** Fullscreen reserves three fixed rows; composer height is a footer layout input. */
+/** One height budget for the transcript, fixed editor and status slots. */
 import { draftMaxRows } from '../composer-limits.js';
-import { frameHeight, MIN_FULLSCREEN_ROWS } from './frame.js';
-/** Below this many rows the composer's hint line is dropped to buy back a row. */
+import { MIN_FULLSCREEN_ROWS, MIN_FULLSCREEN_COLS } from './frame.js';
 export const HINT_MIN_ROWS = 20;
-/**
- * The composer's draft rows, clamped to what this terminal height allows.
- *
- * Exported so the reporter and the budget clamp with ONE function: I-8 requires
- * the rendered row count and the number handed to `viewportRows` to be the same
- * number, and two clamps are how they stop being.
- */
+const dimension = (value, fallback) => value !== undefined && Number.isFinite(value) && value >= 1 ? Math.floor(value) : fallback;
+/** Clamp the displayed draft, independently of any transcript or panel content. */
 export function clampDraftRows(rows, draftRows) {
     const wanted = Number.isFinite(draftRows) ? Math.floor(draftRows) : 1;
     return Math.max(1, Math.min(wanted, draftMaxRows(rows)));
 }
-export function chromeBudget(rows, draftRows = 1) {
-    return {
-        header: 1,
-        toast: 1,
-        composer: 2 + clampDraftRows(rows, draftRows),
-        status: 1,
-    };
+/** Total menu capacity, including its borders; reserve at least one message row. */
+export function popupCapacity(rows, draftRows, statusExpanded) {
+    return Math.max(0, rows - 1 - 1 - (statusExpanded ? 2 : 1)
+        - 2 - clampDraftRows(rows, draftRows) - 1);
 }
-/** Shared document height; the legacy draft argument remains source-compatible. */
-export function viewportRows(rows, _draftRows = 1) {
-    if (!Number.isFinite(rows) || rows < MIN_FULLSCREEN_ROWS)
-        return 0;
-    return Math.max(0, frameHeight(rows) - 3);
+/** Normalize terminal dimensions once and conserve every visible frame row. */
+export function buildFrameBudget(input) {
+    const rows = dimension(input.rows, 24);
+    const cols = dimension(input.cols, 80);
+    const frameRows = rows - 1;
+    const composerCols = Math.max(0, cols - 1);
+    const inactive = rows < MIN_FULLSCREEN_ROWS || cols < MIN_FULLSCREEN_COLS;
+    if (inactive)
+        return { rows, cols, inactive, frameRows, composerCols, headerRows: 0,
+            statusRows: 0, composerRows: 0, composerSlotRows: 0, popupRows: 0,
+            popupMaxHeight: 0, viewportRows: 0 };
+    const statusRows = input.statusExpanded ? 2 : 1;
+    const composerRows = 2 + clampDraftRows(rows, input.draftRows);
+    const popupMaxHeight = popupCapacity(rows, input.draftRows, input.statusExpanded);
+    const requested = Number.isFinite(input.popupRows) ? Math.floor(input.popupRows) : 0;
+    const candidate = Math.max(0, Math.min(requested, popupMaxHeight));
+    const popupRows = candidate >= 3 ? candidate : 0;
+    const composerSlotRows = composerRows + popupRows;
+    return { rows, cols, inactive, frameRows, composerCols, headerRows: 1, statusRows,
+        composerRows, composerSlotRows, popupRows, popupMaxHeight,
+        viewportRows: frameRows - 1 - statusRows - composerSlotRows };
 }

package/dist/ui/layout/document-layout.d.ts

@@ -1,5 +1,5 @@
 export interface DocumentLayoutInput {
-    rows: number;
+    viewportRows: number;
     bodyRows: number;
     footerRows: number;
 }
@@ -9,5 +9,5 @@ export interface DocumentLayout {
     contentRows: number;
     trailingContentRows: number;
 }
-/** Allocate the shared document, filling short sessions before the editor. */
+/** Allocate the shared document, filling short sessions before the panels. */
 export declare function buildDocumentLayout(input: DocumentLayoutInput): DocumentLayout;

package/dist/ui/layout/document-layout.js

@@ -1,8 +1,7 @@
-import { frameHeight } from './frame.js';
-/** Allocate the shared document, filling short sessions before the editor. */
+/** Allocate the shared document, filling short sessions before the panels. */
 export function buildDocumentLayout(input) {
     const count = (n) => Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
-    const viewportRows = count(input.rows) > 0 ? Math.max(0, frameHeight(count(input.rows)) - 3) : 0;
+    const viewportRows = count(input.viewportRows);
     const body = count(input.bodyRows);
     const footer = count(input.footerRows);
     const paddingRows = Math.max(0, viewportRows - body - footer);

package/dist/ui/layout/queue-layout.js

@@ -10,13 +10,13 @@ export function buildQueueLayout(input) {
     const items = input.pending.slice(0, shown).map((item, index) => {
         const prefix = `${index + 1}. `;
         const lines = item.text.split(/\r\n|[\r\n]/).length;
-        const suffix = lines > 1 ? ` (+${lines - 1}\u884c)` : '';
+        const suffix = lines > 1 ? ` (+${lines - 1} lines)` : '';
         return { queueId: item.queueId, label: prefix + truncateSummary(queueSummary(item.text), Math.max(0, input.columns - stringWidth(prefix + suffix)), '...') + suffix };
     });
     const hiddenCount = count - items.length;
-    const paused = input.paused ? ' \u5df2\u6682\u505c' : '';
-    const hidden = hiddenCount ? ` \u53e6${hiddenCount}\u6761` : '';
-    const title = `Queue: \u5f85\u5904\u7406 ${count}${paused}${hidden} /queue`;
+    const paused = input.paused ? ' paused' : '';
+    const hidden = hiddenCount ? ` +${hiddenCount} more` : '';
+    const title = `Queue: ${count} pending${paused}${hidden} /queue`;
     if (limit === 1)
         return { rows: 1,
             title: truncateSummary(`Queue ${count} /queue ${items[0].label}`, input.columns, '...'),

package/dist/ui/layout/status-detail-layout.d.ts

@@ -0,0 +1,9 @@
+import { type ActionHintInput } from '../interaction-hints.js';
+import { type StatusLinePlan, type StatusPrimaryInput } from './status-layout.js';
+export interface StatusDetailInput {
+    status: StatusPrimaryInput;
+    hints: ActionHintInput;
+    model: string;
+    provider: string;
+}
+export declare function planStatusDetail(input: StatusDetailInput): StatusLinePlan;

package/dist/ui/layout/status-detail-layout.js

@@ -0,0 +1,56 @@
+import { formatCost, formatTokens, promptTokensOf } from '../../agent/usage.js';
+import { actionCandidates, clipStatusText, escapeClause } from '../interaction-hints.js';
+import { statusField, statusLinePlan, validContext } from './status-layout.js';
+export function planStatusDetail(input) {
+    const { status, hints } = input;
+    const budget = Math.max(0, Math.floor(status.columns) - 1);
+    const escape = escapeClause({ ...hints, escapeAction: status.escapeAction });
+    const reserved = [...(escape ? [statusField('escape', escape, 'warning')] : []),
+        statusField('toggle', hints.overlay ? 'Details on' : '^G less')];
+    const fields = [];
+    const add = (candidate) => {
+        if (statusLinePlan([...fields, candidate, ...reserved]).cells <= budget)
+            fields.push(candidate);
+    };
+    if (status.feedback) {
+        const remaining = budget - statusLinePlan(reserved).cells - (reserved.length ? 3 : 0);
+        const text = clipStatusText(status.feedback.text, Math.max(0, remaining));
+        if (text)
+            add(statusField('feedback', text, status.feedback.level === 'error' ? 'error'
+                : status.feedback.level === 'warn' ? 'warning' : 'normal'));
+    }
+    for (const [index, action] of actionCandidates(hints).entries())
+        add(statusField('action-' + index, action));
+    if (status.pendingCount > 0)
+        add(statusField('queue', 'Q' + status.pendingCount));
+    if (status.servicesActive?.live)
+        add(statusField('services', 'Svc' + status.servicesActive.live));
+    if (status.mode || status.pendingMode)
+        add(statusField('mode', status.pendingMode
+            ? (status.mode ?? 'build') + '>' + status.pendingMode : status.mode));
+    if (validContext(status.context)) {
+        const approximate = status.context.source === 'estimate' || status.context.deltaTokens > 0 ? '~' : '';
+        add(statusField('context', 'Context ' + approximate + formatTokens(status.context.occupied)
+            + '/' + formatTokens(status.context.window) + ' tokens'));
+    }
+    else
+        add(statusField('context', 'Context ? /context'));
+    if (status.speedKnown)
+        add(statusField('average', 'Avg: main output / run time'));
+    add(statusField('usage', 'Session input ' + formatTokens(promptTokensOf(status.usageTotal))
+        + ' output ' + formatTokens(status.usageTotal.outputTokens)));
+    if (Number.isFinite(status.usageTotal.costUsd))
+        add(statusField('cost', 'Cost ' + formatCost(status.usageTotal.costUsd) + ' est'));
+    if (status.teamActive)
+        add(statusField('team', 'Team ' + status.teamActive.running + '/' + status.teamActive.total));
+    if (status.todoActive)
+        add(statusField('todo', 'Todo ' + status.todoActive.done + '/' + status.todoActive.total));
+    add(statusField('model', input.provider + ':' + input.model));
+    if (status.fastActive)
+        add(statusField('fast', 'Fast' + (status.fastActive.inFlight ? ' active' : '')));
+    if (status.ecoRung)
+        add(statusField('eco', 'Eco'));
+    if (hints.updateAvailable)
+        add(statusField('update', '/update'));
+    return statusLinePlan([...fields, ...reserved]);
+}

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

@@ -1,5 +1,6 @@
 import type { UsageTotal } from '../../agent/reducer.js';
 import type { ContextUsageSnapshot } from '../../compaction/types.js';
+import type { EscapeAction, StatusFeedback } from '../status-feedback.js';
 export type RunPhase = 'idle' | 'starting' | 'waiting' | 'thinking' | 'generating' | 'preparing-tool' | 'tool';
 export interface StatusLayoutInput {
     columns: number;
@@ -43,13 +44,29 @@ export interface StatusLayoutInput {
     };
     scrolledLines?: number;
 }
+export interface StatusPrimaryInput extends StatusLayoutInput {
+    feedback?: StatusFeedback;
+    escapeAction?: EscapeAction;
+    speedKnown: boolean;
+    interruptPhase?: 'ready' | 'armed' | 'stopping';
+}
 export interface StatusField {
     id: string;
     text: string;
     cells: number;
     tone: 'normal' | 'muted' | 'warning' | 'error';
 }
+export interface StatusLinePlan {
+    fields: readonly StatusField[];
+    separator: string;
+    separatorCells: number;
+    cells: number;
+}
 export declare function cleanStatusText(text: string): string;
+export declare function statusField(id: string, text: string, tone?: StatusField['tone']): StatusField;
+export declare function statusLinePlan(fields: readonly StatusField[], separator?: string): StatusLinePlan;
 export declare function phaseLabels(input: Pick<StatusLayoutInput, 'phase' | 'activeTool' | 'runOutcome' | 'waitingForConfirmation' | 'stopping' | 'compacting' | 'retryActive'>): readonly [string, string];
-/** Allocate complete fields before rendering; only the redraw carrier lives outside this budget. */
-export declare function planStatusFields(input: StatusLayoutInput): readonly StatusField[];
+export declare function validContext(context: ContextUsageSnapshot): boolean;
+export declare function shortDuration(ms: number): string;
+/** All five fields survive each width rung; only the redraw carrier is outside this plan. */
+export declare function planPrimaryStatusFields(input: StatusPrimaryInput): StatusLinePlan;

package/dist/ui/layout/status-layout.js

@@ -1,11 +1,20 @@
 import stringWidth from 'string-width';
 import stripAnsi from 'strip-ansi';
-import { formatCost, formatDuration, formatTokens, promptTokensOf } from '../../agent/usage.js';
+import { formatDuration } from '../../agent/usage.js';
 import { interactionCopy as copy } from '../interaction-copy.js';
 export function cleanStatusText(text) {
     // eslint-disable-next-line no-control-regex
     return stripAnsi(text).replace(/[\x00-\x1f\x7f-\x9f\u2028\u2029]/g, ' ').trim();
 }
+export function statusField(id, text, tone = 'muted') {
+    const clean = cleanStatusText(text);
+    return { id, text: clean, cells: stringWidth(clean), tone };
+}
+export function statusLinePlan(fields, separator = ' | ') {
+    const separatorCells = stringWidth(separator);
+    return { fields, separator, separatorCells,
+        cells: fields.reduce((sum, item) => sum + item.cells, 0) + Math.max(0, fields.length - 1) * separatorCells };
+}
 export function phaseLabels(input) {
     if (input.waitingForConfirmation)
         return copy.confirming;
@@ -14,97 +23,99 @@ export function phaseLabels(input) {
     if (input.compacting)
         return copy.compacting;
     if (input.retryActive)
-        return [copy.retrying[0], `${copy.retrying[1]} ${Math.max(0, Math.ceil(input.retryActive.secondsLeft))}s`];
-    if (input.activeTool) {
-        const name = input.activeTool.name;
-        if (name === 'read_file')
-            return copy.readFile;
-        if (name === 'write_file' || name === 'edit_file')
-            return copy.writeFile;
-        if (name === 'bash')
-            return copy.command;
-        return [copy.tool[0], `${copy.tool[1]} ${cleanStatusText(name)}`];
-    }
+        return copy.retrying;
+    if (input.activeTool)
+        return [copy.tool[0], copy.tool[1] + ' ' + cleanStatusText(input.activeTool.name)];
     if (input.phase === 'idle' && input.runOutcome && input.runOutcome !== 'none')
         return copy[input.runOutcome];
     if (input.phase === 'preparing-tool')
         return copy.preparingTool;
     return copy[input.phase];
 }
-const field = (id, text, tone = 'muted') => ({ id, text, cells: stringWidth(text), tone });
-const width = (fields) => fields.reduce((sum, item) => sum + item.cells, 0) + Math.max(0, fields.length - 1) * 3;
-const scientific = (value) => value.toExponential(1).replace(/\.0e/, 'e').replace('e+', 'e');
-const compactNumber = (value) => value >= 1e9 ? scientific(value) : formatTokens(value).replace(/\.0([kM])$/, '$1');
-function contextText(context, detail = false, exponent = false) {
-    if (![context.occupied, context.window, context.deltaTokens, context.pct].every(Number.isFinite)
-        || context.occupied < 0 || context.window <= 0)
-        return copy.contextUnknown;
-    const number = exponent ? scientific : detail ? formatTokens : compactNumber;
-    const approximate = context.source === 'estimate' || context.deltaTokens > 0 ? '~' : '';
-    const limit = context.windowKnown ? number(context.window) : '?';
-    return `${copy.context} ${approximate}${number(context.occupied)}/${limit} ${detail ? 'tokens' : 'tok'}`;
+export function validContext(context) {
+    return context.windowKnown && context.window > 0 &&
+        [context.occupied, context.window, context.pct, context.deltaTokens].every(n => Number.isFinite(n) && n >= 0);
 }
-function secondaryFields(input) {
-    const list = [];
-    if ((input.mode && input.mode !== 'build') || input.pendingMode)
-        list.push(field('mode', input.pendingMode ? `${input.mode ?? 'build'}>${input.pendingMode}` : input.mode, 'normal'));
-    if (input.servicesActive?.live)
-        list.push(field('services', `${copy.services} ${input.servicesActive.live}`, 'warning'));
-    if (Number.isFinite(input.usageTotal.costUsd))
-        list.push(field('cost', `${copy.estimatedCost} ${formatCost(input.usageTotal.costUsd).slice(1)}`));
-    if (input.phase !== 'idle') {
-        if (input.tokPerSec > 0 && Number.isFinite(input.tokPerSec))
-            list.push(field('speed', `${copy.speed} ${input.tokPerSec} tok/s`));
-        if (Number.isFinite(input.elapsedMs))
-            list.push(field('elapsed', `${copy.elapsed} ${formatDuration(input.elapsedMs)}`));
-    }
-    if (input.thinkingLevel !== 'off')
-        list.push(field('thinking', `think:${cleanStatusText(input.thinkingLevel)}`));
-    list.push(field('usage', `${copy.sessionInput} ${compactNumber(promptTokensOf(input.usageTotal))} ${copy.output} ${compactNumber(input.usageTotal.outputTokens)} tok`));
-    if (input.context.windowKnown && Number.isFinite(input.context.pct))
-        list.push(field('percentage', `${input.context.source === 'estimate' || input.context.deltaTokens > 0 || !input.context.windowKnown ? '~' : ''}${Math.round(input.context.pct)}%`));
-    if (input.ecoRung)
-        list.push(field('eco', 'eco'));
-    if (input.fastActive)
-        list.push(field('fast', `fast${input.fastActive.inFlight ? '*' : ''}`));
-    if (input.teamActive)
-        list.push(field('team', `agents ${input.teamActive.running}/${input.teamActive.total}`));
-    if (input.todoActive)
-        list.push(field('todo', `todo ${input.todoActive.done}/${input.todoActive.total}`));
-    if (input.scrolledLines)
-        list.push(field('scroll', `^${input.scrolledLines}`, 'warning'));
-    return list;
+function contextPercent(context) {
+    if (!validContext(context))
+        return '?';
+    const mark = context.source === 'estimate' || context.deltaTokens > 0 ? '~' : '';
+    return mark + (context.pct > 999 ? '>999' : Math.round(context.pct)) + '%';
 }
-/** Allocate complete fields before rendering; only the redraw carrier lives outside this budget. */
-export function planStatusFields(input) {
-    const budget = Math.max(0, Math.floor(input.columns) - 1);
-    const [short, long] = phaseLabels(input);
-    const prefix = input.spinner ? `${input.spinner} ` : '';
-    const phaseTone = input.runOutcome === 'failed' ? 'error' : 'normal';
-    const fields = [field('phase', prefix + short, phaseTone)];
-    if (input.pendingCount > 0)
-        fields.push(field('queue', `${copy.queue} ${input.pendingCount}`, 'warning'));
-    fields.push(field('context', contextText(input.context)));
-    const contextIndex = fields.length - 1;
-    if (width(fields) > budget)
-        fields[contextIndex] = field('context', contextText(input.context, false, true));
-    if (width(fields) > budget)
-        fields[contextIndex] = field('context', '/context');
-    if (width(fields) > budget && input.pendingCount > 0)
-        fields[1] = field('queue', '/queue', 'warning');
-    if (width(fields) > budget)
-        return fields.filter((_f, index) => width(fields.slice(0, index + 1)) <= budget);
-    for (const candidate of secondaryFields(input)) {
-        if (width([...fields, candidate]) <= budget)
-            fields.push(candidate);
+export function shortDuration(ms) {
+    if (!Number.isFinite(ms) || ms <= 0)
+        return '0s';
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return seconds + 's';
+    if (seconds < 3600)
+        return Math.floor(seconds / 60) + 'm' + String(seconds % 60).padStart(2, '0') + 's';
+    if (seconds < 86400)
+        return Math.floor(seconds / 3600) + 'h' + String(Math.floor(seconds / 60) % 60).padStart(2, '0') + 'm';
+    const days = Math.floor(seconds / 86400);
+    return days > 999 ? '>999d' : days + 'd';
+}
+function speedNumber(input) {
+    if (!input.speedKnown || input.phase === 'idle' || input.elapsedMs <= 500
+        || !Number.isFinite(input.tokPerSec) || input.tokPerSec < 0)
+        return '--';
+    const value = input.tokPerSec;
+    if (value > 99e6)
+        return '>99M';
+    if (value >= 999950)
+        return (value / 1e6).toFixed(1) + 'M';
+    if (value > 999)
+        return (value / 1000).toFixed(1) + 'k';
+    return String(Math.round(value));
+}
+function feedbackLabel(input, form) {
+    const feedback = input.feedback;
+    if (!feedback)
+        return undefined;
+    const error = feedback.kind === 'copy-error' || feedback.kind === 'copy-cleanup';
+    if (error && input.escapeAction === 'force-stop') {
+        return form === 'full' ? 'Copy err / Esc force' : form === 'tiny' ? 'E/F' : 'Err/EscF';
     }
-    const upgrades = [field('phase', prefix + long, phaseTone),
-        field('queue', `${copy.pending} ${input.pendingCount}`, 'warning'),
-        field('context', contextText(input.context, true))];
-    for (const upgrade of upgrades) {
-        const index = fields.findIndex((f) => f.id === upgrade.id);
-        if (index >= 0 && width(fields) - fields[index].cells + upgrade.cells <= budget)
-            fields[index] = upgrade;
+    if (error && input.escapeAction === 'confirm-stop' && input.interruptPhase === 'armed') {
+        return form === 'full' ? 'Copy err / Esc stop' : form === 'tiny' ? 'E/S' : 'Err/EscS';
     }
-    return fields;
+    const labels = {
+        confirm: ['Awaiting confirmation', 'Ask', 'Ask'], stopping: ['Esc stop', 'EscS', 'EscS'],
+        'force-stop': ['Esc force', 'EscF', 'EscF'], exit: ['^C exit', '^Cexit', '^C'],
+        copying: ['Copying', 'Copy', 'Copy'], copied: ['Copied', 'Copied', 'Copy'],
+        'copy-sent': ['Copy sent', 'Sent', 'Sent'], 'copy-cleanup': ['Copy cleanup', 'Err', 'Err'],
+        'copy-error': ['Copy err', 'Err', 'Err'], notice: ['Notice', 'Notice', 'Note'],
+    };
+    return labels[feedback.kind][form === 'full' ? 0 : form === 'short' ? 1 : 2];
+}
+const thinkingCodes = { off: 'O', minimal: 'N', low: 'L', medium: 'M', high: 'H', xhigh: 'X' };
+/** All five fields survive each width rung; only the redraw carrier is outside this plan. */
+export function planPrimaryStatusFields(input) {
+    const budget = Math.max(0, (Number.isFinite(input.columns) ? Math.floor(input.columns) : 80) - 1);
+    const labels = phaseLabels(input);
+    const glyphText = cleanStatusText(input.spinner ?? '-');
+    const glyph = stringWidth(glyphText) === 1 ? glyphText : '-';
+    const code = thinkingCodes[input.thinkingLevel] ?? '?';
+    const pct = contextPercent(input.context);
+    const speed = speedNumber(input);
+    const tone = input.feedback?.level === 'error' || input.runOutcome === 'failed'
+        ? 'error' : input.feedback?.level === 'warn' || input.waitingForConfirmation || input.stopping ? 'warning' : 'normal';
+    const build = (rung) => {
+        const full = rung === 0;
+        const label = feedbackLabel(input, full ? 'full' : rung >= 4 ? 'tiny' : 'short')
+            ?? (full ? labels[1] : rung >= 4 ? labels[0].slice(0, 4) : labels[0]);
+        return statusLinePlan([
+            statusField('phase', glyph + (rung >= 5 ? '' : ' ') + label, tone),
+            statusField('context', (full ? 'Context ' : 'C') + pct),
+            statusField('thinking', full ? 'Think ' + (thinkingCodes[input.thinkingLevel] ? input.thinkingLevel : '?')
+                : (rung >= 2 ? '' : 'Th:') + code),
+            statusField('speed', speed + (full ? ' tok/s' : rung >= 3 ? '/s' : 't/s')),
+            statusField('elapsed', full && Number.isFinite(input.elapsedMs) && input.elapsedMs > 0
+                ? formatDuration(input.elapsedMs) : shortDuration(input.elapsedMs)),
+        ], full ? ' | ' : ' ');
+    };
+    let plan = build(0);
+    for (let rung = 1; plan.cells > budget && rung <= 5; rung++)
+        plan = build(rung);
+    return plan;
 }

package/dist/ui/layout/wrap-rows.d.ts

@@ -18,6 +18,8 @@
  *
  * Prefers spaces; hard-breaks any single token longer than `width` (a URL or a
  * long path, which must not be dropped and cannot be wrapped politely).
+ * Width is measured in terminal cells and hard breaks preserve graphemes. A
+ * single grapheme wider than the limit stays intact on its own row.
  * Existing newlines are honoured as paragraph breaks. Returns `[]` for empty
  * input so callers can splice the result without an emptiness branch.
  */

package/dist/ui/layout/wrap-rows.js

@@ -1,3 +1,4 @@
+import { graphemes, graphemeWidth } from '../editor-navigation.js';
 /**
  * `wrapToRows` — the prose wrapper for `OverlayFrame`'s controlled (mode A)
  * content (plan-mode §6.6).
@@ -18,6 +19,8 @@
  *
  * Prefers spaces; hard-breaks any single token longer than `width` (a URL or a
  * long path, which must not be dropped and cannot be wrapped politely).
+ * Width is measured in terminal cells and hard breaks preserve graphemes. A
+ * single grapheme wider than the limit stays intact on its own row.
  * Existing newlines are honoured as paragraph breaks. Returns `[]` for empty
  * input so callers can splice the result without an emptiness branch.
  */
@@ -40,32 +43,43 @@ export function wrapToRows(text, width) {
 function wrapParagraph(paragraph, limit) {
     const rows = [];
     let current = '';
+    let currentWidth = 0;
     for (const word of paragraph.split(/\s+/).filter((w) => w.length > 0)) {
-        if (word.length > limit) {
+        const parts = graphemes(word);
+        const wordWidth = parts.reduce((sum, part) => sum + graphemeWidth(part.text), 0);
+        if (wordWidth > limit) {
             // Flush what we have, then chop the over-long token into full-width
             // pieces. Its tail becomes the new `current` so the next word can still
             // join it.
             if (current.length > 0) {
                 rows.push(current);
                 current = '';
+                currentWidth = 0;
             }
-            let rest = word;
-            while (rest.length > limit) {
-                rows.push(rest.slice(0, limit));
-                rest = rest.slice(limit);
+            for (const part of parts) {
+                const cells = graphemeWidth(part.text);
+                if (current && currentWidth + cells > limit) {
+                    rows.push(current);
+                    current = '';
+                    currentWidth = 0;
+                }
+                current += part.text;
+                currentWidth += cells;
             }
-            current = rest;
             continue;
         }
         if (current.length === 0) {
             current = word;
+            currentWidth = wordWidth;
         }
-        else if (current.length + 1 + word.length <= limit) {
+        else if (currentWidth + 1 + wordWidth <= limit) {
             current = `${current} ${word}`;
+            currentWidth += 1 + wordWidth;
         }
         else {
             rows.push(current);
             current = word;
+            currentWidth = wordWidth;
         }
     }
     if (current.length > 0)

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

@@ -12,6 +12,7 @@ export interface ConfirmState {
     resolve: (approved: boolean) => void;
 }
 interface ConfirmDialogProps {
+    isActive?: boolean;
     state: ConfirmState;
     maxRows: number;
     cols: number;
@@ -26,5 +27,5 @@ interface ConfirmDialogProps {
  * title and border match the other three overlays; the existing `useInput` is
  * untouched.
  */
-export declare function ConfirmDialog({ state, maxRows, cols, theme, caps, onClose, }: ConfirmDialogProps): React.ReactElement;
+export declare function ConfirmDialog({ state, isActive, maxRows, cols, theme, caps, onClose, }: ConfirmDialogProps): React.ReactElement;
 export {};

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)) }));
 }