@aragon-agent/cli 0.6.38 → 0.6.40

package/dist/ui/Header.js

@@ -2,24 +2,26 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { basename } from 'node:path';
 import { Box, Text } from 'ink';
 import { Logo } from './Logo.js';
-import { planHeaderHints, HEADER_HINT_LIMITS } from './layout/header-hints.js';
-export function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns = 80, statusExpanded = false, scrolledLines = 0, overlayOpen = false, kitHint = true, promptsHint = true }) {
-    // The right-hand hints are planned, not assembled (tui-branch-terminal-shortcut
-    // 3.9 / D-11). `plan.text` is exactly `plan.cells` wide and already carries the
-    // scroll chip's own trailing spacing, so this component can no longer clip a
-    // hint by guessing one cell short - and the ladder that decides which hints
-    // survive a narrow terminal lives in a pure function with its own tests.
-    //
-    // `kitHint` is the `^K switch kit` clause (agent-model-kits §4.7): `App`
-    // passes `true` always, because the requirement is that `ctrl+G` reveals the
-    // key - and the user with no kits needs that hint most.
-    const plan = planHeaderHints({
-        columns, statusExpanded, overlayOpen, scrolledLines, kitHint, promptsHint,
+import { pickGlyphs } from './glyphs.js';
+import { planHeaderHints, HEADER_HINT_LIMITS, } from './layout/header-hints.js';
+import { planHeaderLeft } from './layout/header-left.js';
+export function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns = 80, panel = 'none', scrolledLines = 0, taskSummary = null, summaryEnabled = true, }) {
+    const glyphs = pickGlyphs(caps);
+    // THE RIGHT COLUMN FIRST: it is the only clause that may never be dropped, so
+    // the left half is planned against what is left after it (defect 12).
+    const plan = planHeaderHints({ columns, panel, scrolledLines });
+    const leftCells = Math.max(0, columns - plan.cells - HEADER_HINT_LIMITS.separatorCells);
+    const left = planHeaderLeft({
+        leftCells,
+        provider,
+        model,
+        cwd: basename(cwd) || cwd,
+        hasKey,
+        summary: taskSummary,
+        summaryEnabled,
+        ellipsis: glyphs.ellipsis,
     });
-    // THE TWO HALVES ARE SEPARATED BY CELLS, NOT BY LUCK (defect 12). The left half
-    // is `wrap="truncate"`, which draws its ellipsis in the LAST cell it owns; with
-    // the right half starting in the very next cell a narrow terminal read
-    // `aragon...Details off` as one string. The blank column comes out of the left
-    // half's width, so the row still spans exactly `columns`.
-    return _jsxs(Box, { flexDirection: "row", height: 1, width: columns, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { width: Math.max(0, columns - plan.cells - HEADER_HINT_LIMITS.separatorCells), flexShrink: 0, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", children: [_jsx(Logo, { variant: variant === 'mini' ? 'mini' : 'bar', theme: theme, caps: caps }), variant !== 'mini' && _jsxs(_Fragment, { children: [_jsxs(Text, { color: theme.accent, children: ['  ', provider, ":", model] }), _jsxs(Text, { color: theme.muted, children: ['  ', basename(cwd) || cwd] }), _jsxs(Text, { color: hasKey ? theme.toolDone : theme.toolRunning, children: ['  ', hasKey ? theme.symbols.keyOn : theme.symbols.keyOff] })] })] }) }), _jsx(Box, { width: HEADER_HINT_LIMITS.separatorCells, flexShrink: 0 }), _jsx(Box, { width: plan.cells, flexShrink: 0, justifyContent: "flex-end", children: _jsx(Text, { color: theme.muted, wrap: "truncate", children: plan.text }) })] });
+    return _jsxs(Box, { flexDirection: "row", height: 1, width: columns, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { width: leftCells, flexShrink: 0, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", children: [_jsx(Logo, { variant: variant === 'mini' ? 'mini' : 'bar', theme: theme, caps: caps }), variant !== 'mini' && _jsxs(_Fragment, { children: [left.text.model && _jsxs(Text, { color: theme.accent, children: ['  ', left.text.model] }), left.text.cwd && _jsxs(Text, { color: theme.muted, children: ['  ', left.text.cwd] }), left.text.summary && _jsxs(Text, { color: theme.muted, children: ['  ', glyphs.midDot, ' '] }), left.text.summary && (taskSummary?.tone === 'fallback'
+                                    ? _jsx(Text, { color: theme.muted, dimColor: true, children: left.text.summary })
+                                    : _jsx(Text, { color: theme.primary, children: left.text.summary })), _jsxs(Text, { color: hasKey ? theme.toolDone : theme.toolRunning, children: ['  ', hasKey ? theme.symbols.keyOn : theme.symbols.keyOff] })] })] }) }), _jsx(Box, { width: HEADER_HINT_LIMITS.separatorCells, flexShrink: 0 }), _jsx(Box, { width: plan.cells, flexShrink: 0, justifyContent: "flex-end", children: _jsx(Text, { color: theme.muted, wrap: "truncate", children: plan.text }) })] });
 }

package/dist/ui/StatusBar.d.ts

@@ -92,6 +92,7 @@ export interface StatusBarProps {
     };
     compactionActive?: {
         inFlight: boolean;
+        selfDisabled?: boolean;
     };
     gaugeMarks?: {
         warn: number;

package/dist/ui/StatusBar.js

@@ -39,6 +39,7 @@ export function StatusBar(props) {
         interruptPhase: props.interruptPhase,
         waitingForConfirmation: props.waitingForConfirmation, stopping: props.stopping,
         compacting: props.compactionActive?.inFlight, retryActive: props.retryActive,
+        compactionPaused: props.compactionActive?.selfDisabled === true,
         mode: props.agentMode, pendingMode: props.pendingAgentMode, servicesActive: props.servicesActive,
         teamActive: props.teamActive, todoActive: props.todoActive,
         ...(props.acceptanceActive ? { acceptanceActive: props.acceptanceActive } : {}),

package/dist/ui/Transcript.js

@@ -137,7 +137,7 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
         case 'fast':
             return frame(entry.status === 'failed' ? glyphs.toolError : glyphs.teamAgent, fastCardColor(entry.status, theme), _jsx(FastCard, { reviewIndex: entry.reviewIndex, model: entry.model, status: entry.status, text: entry.text, detail: entry.detail, turn: entry.turn, durationMs: entry.durationMs, live: entry.live, reducedMotion: reducedMotion, theme: theme, caps: caps }));
         case 'compaction':
-            return frame(entry.applied || entry.live ? glyphs.compaction : glyphs.toolError, compactionCardColor(entry, theme), _jsx(CompactionCard, { index: entry.index, decision: entry.decision, memoryVersion: entry.memoryVersion, trigger: entry.trigger, mode: entry.mode, applied: entry.applied, reason: entry.reason, messagesBefore: entry.messagesBefore, messagesAfter: entry.messagesAfter, tokensBefore: entry.tokensBefore, tokensAfter: entry.tokensAfter, summary: entry.summary, model: entry.model, durationMs: entry.durationMs, tailRelief: entry.tailRelief, 
+            return frame(entry.applied || entry.live ? glyphs.compaction : glyphs.toolError, compactionCardColor(entry, theme), _jsx(CompactionCard, { index: entry.index, decision: entry.decision, memoryVersion: entry.memoryVersion, trigger: entry.trigger, mode: entry.mode, applied: entry.applied, reason: entry.reason, messagesBefore: entry.messagesBefore, messagesAfter: entry.messagesAfter, tokensBefore: entry.tokensBefore, tokensAfter: entry.tokensAfter, summary: entry.summary, model: entry.model, durationMs: entry.durationMs, tailRelief: entry.tailRelief, phase: entry.phase, keepRelaxed: entry.keepRelaxed, retainedTurns: entry.retainedTurns, retainedMessages: entry.retainedMessages, keepRecentTurnsUsed: entry.keepRecentTurnsUsed, elidedMessages: entry.elidedMessages, 
                 // ONLY WHILE LIVE, and only when the clock has ticked at least once:
                 // `nowSec` is `undefined` until then, and a settled card must keep
                 // rendering `durationMs` rather than a figure that would drift.

package/dist/ui/entries/CompactionCard.d.ts

@@ -23,7 +23,7 @@
 import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
-import type { CompactionDecision, CompactionMode, CompactionUiTrigger } from '../../compaction/types.js';
+import type { CompactionDecision, CompactionMode, CompactionPhase, CompactionUiTrigger } from '../../compaction/types.js';
 export interface CompactionCardProps {
     decision?: CompactionDecision;
     memoryVersion?: 2;
@@ -39,6 +39,16 @@ export interface CompactionCardProps {
     summary?: string;
     model: string;
     durationMs?: number;
+    /** The live card's stage, so "compacting" also says WHAT (never-fires C). */
+    phase?: CompactionPhase;
+    /** Set when this cut existed only because `keepRecentTurns` was relaxed (B). */
+    keepRelaxed?: boolean;
+    retainedTurns?: number;
+    /** Messages the relaxed cut left verbatim, which is not the same as turns. */
+    retainedMessages?: number;
+    keepRecentTurnsUsed?: number;
+    /** Messages the digest left out and therefore cannot be quoted (A1). */
+    elidedMessages?: number;
     /**
      * Wall-clock since the card opened, LIVE ONLY
      * (context-auto-compaction-hardening §3.6 / W5).

package/dist/ui/entries/CompactionCard.js

@@ -28,6 +28,7 @@ import { pickGlyphs } from '../glyphs.js';
 import { railBorderProps } from '../layout/Gutter.js';
 import { formatDuration, formatTokens } from '../../agent/usage.js';
 import { COMPACTION_LIMITS } from '../../compaction/limits.js';
+import { compactionPhaseLabel, compactionReasonLine } from '../../compaction/reason-text.js';
 /**
  * The card's colour.
  *
@@ -56,12 +57,19 @@ function headline(props, arrow, dot) {
         // second 45 this was the only changing information on the card, and there was
         // none.
         const elapsed = props.elapsedMs === undefined ? '' : `${dot}${formatDuration(props.elapsedMs)}`;
+        // THE STAGE, NOT JUST "COMPACTING" (never-fires C). Planning and digesting run
+        // before any model call, and a user watching a card for twenty seconds cannot
+        // tell "thinking hard" from "stuck in a gate" without it.
+        const stage = props.phase === undefined ? '' : `${dot}${compactionPhaseLabel(props.phase)}`;
         return props.model
-            ? `compacting context #${index}${dot}${props.model}${elapsed}`
-            : `compacting context #${index}${elapsed}`;
+            ? `compacting context #${index}${dot}${props.model}${stage}${elapsed}`
+            : `compacting context #${index}${stage}${elapsed}`;
     }
     if (!props.applied || props.tokensAfter >= props.tokensBefore) {
-        const why = props.reason ? `: ${props.reason}` : '';
+        // THE REASON IN WORDS (never-fires C). `digest_budget_exceeded: $.digest` was
+        // a code the user could not act on; `compactionReasonLine` renders the same
+        // fact as a clause plus, where there is one, the remedy.
+        const why = props.reason ? `: ${compactionReasonLine(props.reason)}` : '';
         return `context not compacted #${index}${why}`;
     }
     const messages = `${props.messagesBefore} ${arrow} ${props.messagesAfter} messages`;
@@ -87,8 +95,15 @@ function headline(props, arrow, dot) {
  */
 function detailLine(props) {
     if (props.live) {
+        // THE ESCAPE, NOT THE STAGE (never-fires C, as corrected in review): the live
+        // headline already carries the stage, and a two-line card that names it twice
+        // is the one-fact-one-surface rule this file keeps having to restore. With no
+        // model resolved there is no call to cancel, so the whole line goes - the same
+        // rule the settled branch applies.
         if (!props.model)
             return '';
+        if (props.phase !== undefined)
+            return 'esc to cancel';
         return `summarizing with ${props.model} - esc to cancel`;
     }
     if (!props.applied || props.tokensAfter >= props.tokensBefore)
@@ -104,6 +119,50 @@ function detailLine(props) {
     const via = props.trigger === 'overflow' ? ' after a context overflow' : '';
     return `summarized ${dropped} messages with ${props.model}${via}`;
 }
+/**
+ * The relaxation disclosure (never-fires B).
+ *
+ * `planCompaction`'s second pass trades "the last N user turns are verbatim" for
+ * "a cut exists at all". That trade must be readable, because the difference
+ * between the two compactions is exactly what the user asked for: the tail is the
+ * part they care most about keeping word for word.
+ */
+function relaxedLine(props) {
+    if (props.live || !props.applied || props.keepRelaxed !== true)
+        return '';
+    const turns = props.retainedTurns ?? 0;
+    const wanted = props.keepRecentTurnsUsed;
+    const messages = props.retainedMessages;
+    // THE TAIL IS MESSAGES, NOT TURNS (review). The dominant relaxed shape is one
+    // prompt plus a hundred tool calls, so `retainedTurns` is 0 while forty messages
+    // were kept verbatim: a line reading "kept 0 recent turns" would report a total
+    // loss that did not happen. Whenever the count is available it leads, and the
+    // turn arithmetic follows as the explanation rather than as the headline.
+    if (messages !== undefined && wanted !== undefined) {
+        return `kept the last ${messages} messages - ${turns} of the ${wanted} requested turns, ` +
+            'since this run had too few user turns';
+    }
+    if (messages !== undefined)
+        return `kept the last ${messages} messages verbatim`;
+    return wanted === undefined
+        ? `kept the last ${turns} turns - this run had too few user turns to keep more`
+        : `kept ${turns} of the ${wanted} requested turns - this run had too few user turns`;
+}
+/**
+ * The digest-elision disclosure (never-fires A1).
+ *
+ * The digest never rejects for length any more; it keeps the first and last
+ * entries verbatim and elides the middle. The elided messages cannot be quoted by
+ * the summarizer, so the card says so rather than presenting a summary as if it
+ * had seen everything.
+ */
+function elidedLine(props) {
+    const n = props.elidedMessages ?? 0;
+    if (props.live || n <= 0)
+        return '';
+    return `elided ${n} ${n === 1 ? 'message' : 'messages'} from the summary input - ` +
+        'the middle is summarized without them';
+}
 /**
  * The relief disclosure, on a settled card that ALSO summarized.
  *
@@ -139,6 +198,8 @@ function CompactionCardImpl(props) {
     const head = headline(props, glyphs.arrowRight, dot);
     const detail = detailLine(props);
     const relief = reliefLine(props);
+    const relaxed = relaxedLine(props);
+    const elided = elidedLine(props);
     const showMemory = props.memoryVersion !== 2 || expanded === true;
     const rows = summary && showMemory ? summaryRows(summary, expanded === true) : [];
     const totalRows = summary ? summary.split('\n').filter((l) => l.trim().length > 0).length : 0;
@@ -150,7 +211,7 @@ function CompactionCardImpl(props) {
     // the whole run, losing the status colour along with the motion.
     const animate = live && reducedMotion !== true && caps.unicode;
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.accent, bold: true, children: props.trigger === 'manual' ? 'Manual compaction' : props.trigger === 'overflow'
-                            ? 'Overflow: threshold reached' : 'Automatic: threshold reached' }), _jsxs(Text, { color: live ? color : theme.muted, wrap: caps.unicode ? 'truncate' : 'wrap', children: [animate ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { type: "dots" }), ' '] })) : live ? (`${glyphs.spinnerStill} `) : (''), head] })] }), props.memoryVersion === 2 && (_jsxs(Text, { color: theme.muted, children: ["Task memory v2", expanded ? '' : ' (ctrl+o to expand)'] })), detail.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: color, wrap: caps.unicode ? 'truncate' : 'wrap', children: detail }) })), relief.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.noticeWarn, children: relief }) })), rows.length > 0 && (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [rows.map((line, index) => (_jsx(Text, { color: theme.primary, children: line }, index))), hidden > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " +", hidden, " more lines (ctrl+o to expand)"] })), hidden === 0 && expanded === true && totalRows > COMPACTION_LIMITS.cardTextRows && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " ctrl+o to collapse"] }))] }))] }));
+                            ? 'Overflow: threshold reached' : 'Automatic: threshold reached' }), _jsxs(Text, { color: live ? color : theme.muted, wrap: caps.unicode ? 'truncate' : 'wrap', children: [animate ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { type: "dots" }), ' '] })) : live ? (`${glyphs.spinnerStill} `) : (''), head] })] }), props.memoryVersion === 2 && (_jsxs(Text, { color: theme.muted, children: ["Task memory v2", expanded ? '' : ' (ctrl+o to expand)'] })), detail.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: color, wrap: caps.unicode ? 'truncate' : 'wrap', children: detail }) })), relief.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.noticeWarn, children: relief }) })), relaxed.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.muted, children: relaxed }) })), elided.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.muted, children: elided }) })), rows.length > 0 && (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [rows.map((line, index) => (_jsx(Text, { color: theme.primary, children: line }, index))), hidden > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " +", hidden, " more lines (ctrl+o to expand)"] })), hidden === 0 && expanded === true && totalRows > COMPACTION_LIMITS.cardTextRows && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " ctrl+o to collapse"] }))] }))] }));
 }
 /**
  * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).

package/dist/ui/interaction-hints.js

@@ -29,6 +29,12 @@ export function actionCandidates(input) {
     if (input.overlay) {
         if (input.overlay === 'confirm')
             return [copy.approveTool, copy.rejectTool];
+        // THE DRAWER SELECTS, IT DOES NOT SCROLL (tui-shortcut-drawer-and-task-summary
+        // §5). It is a list with a cursor, so the generic `copy.scroll` fallback would
+        // describe the wrong interaction - and the drawer's own footer already names
+        // every key, so one clause is the whole line.
+        if (input.overlay === 'shortcuts')
+            return [copy.select];
         const selects = ['question', 'model', 'session', 'settings'].includes(input.overlay);
         return [selects ? copy.select : copy.scroll,
             ...(selects ? [input.overlay === 'settings' ? copy.saveSettings : copy.confirm] : [])];

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

@@ -10,6 +10,24 @@ interface OverlayFrameBase {
     cols?: number;
     theme: Theme;
     caps: TermCapabilities;
+    /**
+     * Where the frame sits on the row when `width` is given.
+     *
+     * DEFAULT `'left'` AND NO WRAPPER BOX: with neither new prop set, the render
+     * tree is byte-identical to the pre-`shortcut-drawer` one, which is what keeps
+     * the eight existing overlays' layout assertions green (`R-16`).
+     */
+    align?: 'left' | 'right';
+    /**
+     * An explicit width for a frame that is NOT the full terminal width - the
+     * shortcut drawer's right-hand bar.
+     *
+     * THE FRAME STILL DECIDES ITS OWN FORM from `cols` (`BORDERLESS_COLS`), so the
+     * caller passes the TERMINAL width here and the bar's width separately. Passing
+     * the bar's width as `cols` would put a 46-cell drawer on a 200-column terminal
+     * into the rail form for ever.
+     */
+    width?: number;
 }
 interface OverlayFrameControlled extends OverlayFrameBase {
     /** One element per row, each already `wrap="truncate"`. */

package/dist/ui/layout/OverlayFrame.js

@@ -60,14 +60,29 @@ export function OverlayFrame(props) {
             onScrollClamp?.(overflowOffset);
     }, [overflowOffset, onScrollClamp]);
     const inner = (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "row", height: 1, flexShrink: 0, children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, children: _jsx(Text, { wrap: "truncate", color: theme.primary, bold: true, children: title }) }), position && _jsx(Box, { width: stringWidth(position), flexShrink: 0, children: _jsx(Text, { color: theme.muted, children: position }) })] }), _jsx(Box, { flexDirection: "column", flexShrink: 0, height: unbounded ? undefined : Math.max(1, maxRows - (compact ? 2 : bordered ? 5 : 3)), overflowY: "hidden", children: body }), _jsx(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: hint })] }));
-    if (compact)
-        return _jsx(Box, { width: cols, height: Math.max(0, maxRows), flexDirection: "column", flexShrink: 0, overflowY: "hidden", children: inner });
+    // THE NEW PROPS ARE OPTIONAL AND THEIR DEFAULT IS TODAY'S BEHAVIOUR (R-16): the
+    // three branches below return exactly what they always returned unless the
+    // caller asked for a width or a right-hand placement. When it did, the SAME box
+    // is built and then placed inside one row-wide wrapper, which is the only way
+    // Ink can push a fixed-width child to the right edge (a `marginLeft: 'auto'`
+    // does not exist here).
+    const width = props.width;
+    const align = props.align ?? 'left';
+    const placed = (node) => {
+        if (width === undefined && align === 'left')
+            return node;
+        return (_jsx(Box, { width: cols, flexDirection: "row", flexShrink: 0, justifyContent: align === 'right' ? 'flex-end' : 'flex-start', children: node }));
+    };
+    const boxWidth = width === undefined ? {} : { width };
+    if (compact) {
+        return placed(_jsx(Box, { ...boxWidth, width: width ?? cols, height: Math.max(0, maxRows), flexDirection: "column", flexShrink: 0, overflowY: "hidden", children: inner }));
+    }
     if (!bordered) {
         // Narrow terminals trade the box for a rail: same grouping, 2 fewer rows
         // and 4 fewer columns (§5.2).
-        return (_jsx(Box, { flexDirection: "column", flexShrink: 0, marginTop: 1, children: _jsx(Box, { flexDirection: "column", flexShrink: 0, borderStyle: railBorderStyle, borderTop: false, borderBottom: false, borderRight: false, borderColor: theme.primary, paddingLeft: 1, children: inner }) }));
+        return placed(_jsx(Box, { flexDirection: "column", flexShrink: 0, marginTop: 1, ...boxWidth, children: _jsx(Box, { flexDirection: "column", flexShrink: 0, borderStyle: railBorderStyle, borderTop: false, borderBottom: false, borderRight: false, borderColor: theme.primary, paddingLeft: 1, children: inner }) }));
     }
-    return (_jsx(Box, { flexDirection: "column", flexShrink: 0, borderStyle: glyphs.boxStyle, borderColor: theme.primary, paddingX: 1, marginTop: 1, children: inner }));
+    return placed(_jsx(Box, { flexDirection: "column", flexShrink: 0, borderStyle: glyphs.boxStyle, borderColor: theme.primary, paddingX: 1, marginTop: 1, ...boxWidth, children: inner }));
 }
 /**
  * Rows one PgUp/PgDn - and one Shift+wheel notch - turns inside a controlled

package/dist/ui/layout/header-hints.d.ts

@@ -1,25 +1,21 @@
 /**
- * The right-hand hint budget for the header row (tui-branch-terminal-shortcut 3.8).
+ * The right-hand hint budget for the header row
+ * (tui-shortcut-drawer-and-task-summary §4.2).
  *
  * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
  *
- * WHY THIS IS A PLANNER AND NOT ANOTHER TERNARY IN THE JSX (R-0-4): the header's
- * right side used to be one hand-computed width constant (`detailCells = indexHint
- * ? 32 : 18`). Adding a third affordance to that arithmetic produces either a
- * clipped hint or a pushed-out word mark on a 72-column terminal, and NO TEST
- * WOULD SEE IT - the only thing lost is trailing characters. `ui/layout/session-chip.ts`
- * already set the precedent for the same problem: the chip has to participate in
- * one width budget rather than be appended and hoped for.
+ * THIS FILE USED TO BE A SIX-RUNG LADDER. `^L branch`, `^P prompts`, `^I Index`,
+ * `^K switch kit`, `^G more` and the expanded variants competed for a width
+ * budget, so what a user saw was not "my shortcuts" but "which clauses happen to
+ * fit at this width" - and on an 80-column terminal that was three of six. The
+ * requirement replaces the whole idea with ONE entry point (`ctrl+G more`) whose
+ * panel lists every shortcut, so the ladder is gone and what remains is a
+ * three-state single clause.
  *
- * THE RULE IS ONE COMPARISON. `budget = columns - minLeftCells`, then take the
- * first ladder rung whose `cells` fits. There is no second magic constant, and the
- * threshold table in the spec is what that comparison WORKS OUT TO, not an extra
- * branch.
- *
- * WHY `minLeftCells` IS 24: the word mark is 13 cells and `provider:model` + cwd +
- * the key symbol need at least 11 more to stay readable. It is lower than
- * `status-layout`'s 34 because the top-left half has a brand to lose while the
- * bottom-left half has a phase that must not disappear.
+ * WHY A PLANNER AND NOT A TERNARY IN THE JSX (R-0-4, unchanged): the header's
+ * right side was once one hand-computed width constant, and every later addition
+ * to it produced either a clipped hint or a pushed-out word mark with no test
+ * able to see it - the only thing lost is trailing characters.
  */
 /**
  * Bounds for the hint budget.
@@ -27,71 +23,68 @@
  * WHY THEY LIVE IN THIS FILE (R-21, accepted): `CLAUDE.md`'s general rule is that
  * structural bounds live in the subsystem's `limits.ts`, and `ui/layout/` has none
  * - `budget.ts` keeps `HINT_MIN_ROWS` beside its own module for the same reason.
- * This module has exactly one consumer. If `ui/layout/` ever grows a real
- * `limits.ts`, these three constants should move there together; this comment is
- * that future migration's note.
  */
 export declare const HEADER_HINT_LIMITS: {
-    /** Cells the LEFT half of the header must keep (`AragonAgent` is 13 of them). */
+    /**
+     * Cells the LEFT half of the header must keep.
+     *
+     * 24 = the 13-cell word mark plus at least 11 for `provider:model`, the
+     * directory and the key symbol. Lower than `status-layout`'s 34 because the top
+     * row has a brand to lose while the bottom row has a phase that must not
+     * disappear.
+     */
     readonly minLeftCells: 24;
-    /** Fixed spacing between two hint clauses. */
-    readonly gapCells: 2;
     /**
      * Blank cells between the header's left half and this hint column (defect 12).
      *
-     * A SEPARATE CONSTANT FROM `gapCells`. That one spaces two hint clauses INSIDE
-     * the right column (`buildPlan` below); this one separates the session
-     * description from that column. One constant carrying two meanings is how a
-     * later change to clause spacing silently re-lays-out the whole row.
+     * A SEPARATE CONCEPT FROM CLAUSE SPACING: this one separates the two HALVES of
+     * the row, and it is spent out of the same `columns` budget so the row still
+     * spans exactly the terminal width.
      */
     readonly separatorCells: 2;
 };
-export type HeaderHintId = 'branch' | 'prompts' | 'index' | 'kit' | 'detail';
-export interface HeaderHintClause {
-    id: HeaderHintId;
-    text: string;
-}
+/**
+ * What the right-hand column says. THREE STATES, NO LADDER.
+ *
+ * `none`      - no overlay: `^G more`, the only shortcut hint the header teaches.
+ * `shortcuts` - this panel is open: `^G close`, the key that closes it.
+ * `other`     - some other overlay owns the keyboard: `Esc close`, which is true
+ *               for every overlay and is the only key that works in all of them.
+ */
+export type HeaderPanelState = 'none' | 'shortcuts' | 'other';
 export interface HeaderHintPlan {
-    /** Clauses left to right (including the overlay's `Details on/off` replacement). */
-    clauses: HeaderHintClause[];
     /** The whole right-hand string, scroll chip included with its trailing spacing. */
     text: string;
-    /** Total cells of the right column; `Header` uses it to size the left one. */
+    /** Total cells of the right column; `Header` sizes the left one from it. */
     cells: number;
     /** Cells taken by the scroll chip (0 when there is none). */
     scrollCells: number;
-    /** True while an overlay owns the keyboard: only the detail word remains. */
-    detailsOnly: boolean;
 }
+/** The verbatim text of each state. Exported so a test can name it instead of guessing. */
+export declare const HEADER_HINTS: Readonly<Record<HeaderPanelState, string>>;
 /**
- * Plan the right-hand hints.
+ * Plan the right-hand hint.
  *
- * The inputs are the props `Header` receives plus the two switches that decide which
- * clauses exist at all - the call site does not change, only the arithmetic behind it
- * (spec 3.11 step 5).
+ * NO WIDTH BRANCHING: the clause is always rendered. When the row cannot hold it
+ * the LEFT half is what shrinks (to zero) and `overflow="hidden"` keeps that from
+ * spilling - the pre-feature behaviour, which is what makes the header safe at 20
+ * columns without a ladder. `headerHintFits` below exists only so the threshold
+ * is documented and testable, not so the renderer can branch on it.
  */
 export declare function planHeaderHints(input: {
     columns: number;
-    statusExpanded: boolean;
-    overlayOpen: boolean;
+    panel: HeaderPanelState;
     scrolledLines: number;
-    /**
-     * Whether the `^K switch kit` clause exists at all (default `true`).
-     *
-     * `App` ALWAYS PASSES TRUE, including for a user with no kits: the whole point
-     * of the requirement is discoverability of `ctrl+K`, and an empty library is
-     * exactly the state that needs it (the picker's own `No kits yet` row tells
-     * them where to create one). `false` exists for tests and for the future
-     * switch, and it degrades the six expanded rungs back into today's four.
-     */
-    kitHint?: boolean;
-    /**
-     * Whether the `^P prompts` clause exists at all (default `true`).
-     *
-     * `false` is the `prompts.hint` config key and the only reason the ladder is
-     * parameterised: a user who turned the header hint off must get exactly the row
-     * they had before this feature, which is what the unfiltered ladder below
-     * degenerates into.
-     */
-    promptsHint?: boolean;
 }): HeaderHintPlan;
+/**
+ * Whether the row can hold the hint column without squeezing the left half below
+ * `minLeftCells`.
+ *
+ * A FORMULA, NOT A TABLE OF MAGIC NUMBERS: `columns - minLeftCells -
+ * separatorCells >= scrollCells + bodyCells`. Substituting the three states gives
+ * 32 / 34 / 35 columns with no chip, plus up to 8 more for a saturated `^9999+ `.
+ * v1 claimed "any width >= 35", which forgot the chip entirely.
+ */
+export declare function headerHintFits(columns: number, panel: HeaderPanelState): boolean;
+/** The narrowest width at which each state fits with no scroll chip. */
+export declare function headerHintThreshold(panel: HeaderPanelState): number;