@aragon-agent/cli 0.6.19 → 0.6.21

package/dist/compaction/meter.d.ts

@@ -103,6 +103,8 @@ export declare class ContextMeter {
     private last;
     /** Whether the history has changed since the last measurement. */
     private dirty;
+    /** Whether the one-per-run empty-measurement warning has been spent. */
+    private hasWarnedUnmeasuredInput;
     private prefixLast;
     private sampledPrompt;
     private sampledVersion;
@@ -206,6 +208,16 @@ export declare class ContextMeter {
      */
     attach(subscribe: (listener: (event: AgentEvent) => void) => () => void): void;
     dispose(): void;
+    /**
+     * ONE warn per run (context-usage-zero-input-tokens B). A single day of
+     * real usage logged 1,973 zero-input turns; a per-turn warning is a flood
+     * that teaches whoever reads the file to ignore it.
+     *
+     * The logger is resolved LAZILY rather than captured at construction:
+     * hosts build this class before `installLogging()`, and a child captured
+     * then would stay bound to the silent pre-install logger forever.
+     */
+    private warnUnmeasuredInputOnce;
     private onAgentEvent;
     /**
      * The structural belt for a missed invalidation site (I-9).

package/dist/compaction/meter.js

@@ -27,7 +27,8 @@
  * `CompactionWiring.settlePending`'s own synchronous code (I-9), and why
  * `current()` carries a structural belt for a missed invalidation site.
  */
-import { computeEstimateOffset, computePressure } from './pressure.js';
+import { getLogger } from '../logging/logger.js';
+import { computeEstimateOffset, computePressure, isInputSideUnmeasured } from './pressure.js';
 /**
  * How long a scheduled publish waits.
  *
@@ -103,6 +104,8 @@ export class ContextMeter {
     last = null;
     /** Whether the history has changed since the last measurement. */
     dirty = true;
+    /** Whether the one-per-run empty-measurement warning has been spent. */
+    hasWarnedUnmeasuredInput = false;
     prefixLast;
     sampledPrompt;
     sampledVersion;
@@ -174,6 +177,21 @@ export class ContextMeter {
      * better number to wait for.
      */
     onTurnEnd(usage) {
+        if (isInputSideUnmeasured(usage)) {
+            // A usage that discloses NOTHING on the input side is not a
+            // measurement of this history (context-usage-zero-input-tokens B):
+            // arming the measured branch with it collapses occupancy to the
+            // turn's own outputTokens and strips the `~` off the gauge. KEEP
+            // WHATEVER IS STILL TRUSTED - an earlier good measurement of a
+            // prefix that still exists (the history only grows between splices,
+            // so "old good base + appended estimate" stays self-consistent), and
+            // the estimate offset it calibrated - and re-measure NOW so the
+            // gauge degrades in this frame instead of after the next turn.
+            this.warnUnmeasuredInputOnce(usage);
+            this.dirty = true;
+            this.current();
+            return;
+        }
         const messages = this.deps.getMessages();
         const systemPrompt = this.readSystemPrompt();
         this.lastUsage = usage;
@@ -307,6 +325,21 @@ export class ContextMeter {
     // =========================================================================
     // Internals
     // =========================================================================
+    /**
+     * ONE warn per run (context-usage-zero-input-tokens B). A single day of
+     * real usage logged 1,973 zero-input turns; a per-turn warning is a flood
+     * that teaches whoever reads the file to ignore it.
+     *
+     * The logger is resolved LAZILY rather than captured at construction:
+     * hosts build this class before `installLogging()`, and a child captured
+     * then would stay bound to the silent pre-install logger forever.
+     */
+    warnUnmeasuredInputOnce(usage) {
+        if (this.hasWarnedUnmeasuredInput)
+            return;
+        this.hasWarnedUnmeasuredInput = true;
+        getLogger().warn('compaction', 'context_input_tokens_unreported', { in: usage.inputTokens, out: usage.outputTokens });
+    }
     onAgentEvent(event) {
         switch (event.type) {
             case 'turn_end':

package/dist/compaction/pressure.d.ts

@@ -40,6 +40,35 @@ import type { Pressure } from './types.js';
  * the feature is broken, and turns it off.
  */
 export declare function occupiedTokens(usage: TokenUsage): number;
+/**
+ * Whether a usage measured ANYTHING on the input side
+ * (context-usage-zero-input-tokens B).
+ *
+ * THE EMPTY MEASUREMENT THIS EXISTS FOR. A turn that billed output tokens
+ * while reporting inputTokens 0 AND no cache terms did not measure the
+ * request - no real request is free of input. Anthropic-COMPATIBLE relays
+ * emit exactly this shape (bigmodel on every turn, Kimi intermittently),
+ * and the meter used to arm its measured branch with it: occupancy collapsed
+ * to the turn's own outputTokens, the `~` honesty marker vanished with
+ * `source: 'usage'`, and the trigger - which reads the same number - never
+ * fired. The defense is to not trust such a usage as a measurement.
+ *
+ * THE CACHE TERMS ARE PART OF THE INPUT SIDE, DELIBERATELY. Anthropic's real
+ * `input_tokens` EXCLUDES cached tokens, so a deeply cached turn reports a
+ * tiny `input_tokens` next to a huge `cache_read_input_tokens`. That IS a
+ * valid measurement (C-14), and judging on `inputTokens === 0` alone would
+ * reject it and strand a correct gauge on the estimator.
+ *
+ * `outputTokens > 0` separates "the stream ran, billed output, and disclosed
+ * no input" from a degenerate all-zero usage, which the reviewed predicate
+ * deliberately does not speak for.
+ *
+ * SINGLE AUTHORITY. The meter consumes this, and any future observability
+ * hint (fix C) must too: two inline copies of "did the gateway disclose
+ * input" would drift apart exactly the way the gauge and the trigger once
+ * could (R-11).
+ */
+export declare function isInputSideUnmeasured(usage: TokenUsage): boolean;
 /**
  * The calibration offset for this turn (D-23 / P1-11).
  *

package/dist/compaction/pressure.js

@@ -44,6 +44,38 @@ export function occupiedTokens(usage) {
         (usage.cacheWriteTokens ?? 0) +
         usage.outputTokens);
 }
+/**
+ * Whether a usage measured ANYTHING on the input side
+ * (context-usage-zero-input-tokens B).
+ *
+ * THE EMPTY MEASUREMENT THIS EXISTS FOR. A turn that billed output tokens
+ * while reporting inputTokens 0 AND no cache terms did not measure the
+ * request - no real request is free of input. Anthropic-COMPATIBLE relays
+ * emit exactly this shape (bigmodel on every turn, Kimi intermittently),
+ * and the meter used to arm its measured branch with it: occupancy collapsed
+ * to the turn's own outputTokens, the `~` honesty marker vanished with
+ * `source: 'usage'`, and the trigger - which reads the same number - never
+ * fired. The defense is to not trust such a usage as a measurement.
+ *
+ * THE CACHE TERMS ARE PART OF THE INPUT SIDE, DELIBERATELY. Anthropic's real
+ * `input_tokens` EXCLUDES cached tokens, so a deeply cached turn reports a
+ * tiny `input_tokens` next to a huge `cache_read_input_tokens`. That IS a
+ * valid measurement (C-14), and judging on `inputTokens === 0` alone would
+ * reject it and strand a correct gauge on the estimator.
+ *
+ * `outputTokens > 0` separates "the stream ran, billed output, and disclosed
+ * no input" from a degenerate all-zero usage, which the reviewed predicate
+ * deliberately does not speak for.
+ *
+ * SINGLE AUTHORITY. The meter consumes this, and any future observability
+ * hint (fix C) must too: two inline copies of "did the gateway disclose
+ * input" would drift apart exactly the way the gauge and the trigger once
+ * could (R-11).
+ */
+export function isInputSideUnmeasured(usage) {
+    const inputSide = usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+    return inputSide === 0 && usage.outputTokens > 0;
+}
 /**
  * The calibration offset for this turn (D-23 / P1-11).
  *

package/dist/ui/App.js

@@ -128,6 +128,13 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const { stdout } = useStdout();
     const size = useTerminalSize();
     const [draftRows, setDraftRows] = useState(1);
+    // Ctrl+C draft ladder (ctrl-c-clear-draft-exit). The nonce ticks when
+    // the armed ladder spends its clear rung; the flag marks "clear spent"
+    // so the render-time feedback already reads the exit wording at the
+    // nonce render (the async clear lands a frame later - see the timing
+    // invariant beside the ladder itself).
+    const [draftClearNonce, setDraftClearNonce] = useState(0);
+    const [draftClearedByCtrlC, setDraftClearedByCtrlC] = useState(false);
     const [popupRows, setPopupRows] = useState(0);
     const [statusExpanded, setStatusExpanded] = useState(false);
     const dimensions = buildFrameBudget({ ...size, draftRows, popupRows, statusExpanded });
@@ -1145,6 +1152,21 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const onDraftRows = useCallback((next) => {
         setDraftRows(previous => previous === next ? previous : next);
     }, []);
+    /**
+     * Draft presence, written to a REF on purpose (ctrl-c-clear-draft-exit):
+     * promoting it to state would re-render the transcript on the first
+     * keystroke of every message - the exact cost Composer.tsx documents
+     * for keeping `hasDraft` local. The ladder reads the ref inside its key
+     * handler, where freshness is guaranteed; the render-time feedback
+     * uses `hasDraftRef.current && !draftClearedByCtrlC` instead.
+     */
+    const hasDraftRef = useRef(false);
+    const onDraftPresence = useCallback((hasDraft) => {
+        hasDraftRef.current = hasDraft;
+        // A draft that re-appears after a ladder clear re-arms the clear rung.
+        if (hasDraft)
+            setDraftClearedByCtrlC(false);
+    }, []);
     // --- Auto-update bridge (cli-auto-update section 3.8 / 6.3). ------------
     //
     // TWO ARRIVAL ORDERS, AND BOTH HAPPEN. The service is built by a dynamic
@@ -1743,7 +1765,43 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                 toast('warn', `Stopping ${live} service${live === 1 ? '' : 's'}.`);
                 return;
             }
+            //
+            // RENDER-TIMING INVARIANT (part of this fix, not an implementation
+            // detail): the status feedback is evaluated during render, but
+            // `hasDraftRef` is a ref that does not itself trigger one. Every
+            // rung still lands exactly one render - arm bumps `metricsClock`,
+            // the clear rung bumps `draftClearNonce`/`draftClearedByCtrlC` - and
+            // the async clear (nonce -> effect -> 'clear' -> the onDraftChange
+            // transition) refills the ref within the same tick, far faster than
+            // a human's next press. `draftClearedByCtrlC` exists because the
+            // nonce render happens BEFORE that chain: without it the feedback
+            // would still read hasDraft=true and repeat the clear prompt after
+            // clearing. If a future rung ever becomes a pure ref write with no
+            // state change, its feedback text will silently go stale.
+            //
+            // TWO ACCEPTED EDGES (facts drive the ladder, by design):
+            // - arm (empty, "to exit") then PASTE a draft within 1.5s: the
+            //   second press clears instead of exiting - the cleared text is
+            //   still in the clipboard, so nothing is actually lost.
+            // - arm (draft, "to clear") then Ctrl+U kills the draft by hand:
+            //   the second press falls to the exit branch - with nothing left
+            //   to clear, the next rung owns the press (tmux/htop behave the
+            //   same way).
+            //
+            // RUNG TWO/TREE, composed from two existing facts: armed x
+            // hasDraft. No new counter, no new timer - clearing the draft
+            // flips hasDraftRef to false, so the NEXT press naturally lands on
+            // the exit branch: draft present -> x2 clears, x3 exits; empty ->
+            // x2 exits, byte-identical to the previous behaviour.
             if (ctrlCArmed.current) {
+                if (hasDraftRef.current) {
+                    setDraftClearNonce(value => value + 1);
+                    setDraftClearedByCtrlC(true);
+                    // Stays armed and the 1500ms clock keeps running: the clear
+                    // rung must not re-arm the whole ladder (that would make
+                    // exiting a draft x4 presses).
+                    return;
+                }
                 doExit();
                 return;
             }
@@ -1755,6 +1813,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             ctrlCTimer.current = setTimeout(() => {
                 ctrlCTimer.current = null;
                 ctrlCArmed.current = false;
+                setDraftClearedByCtrlC(false);
                 setMetricsClock(value => value + 1);
             }, 1500);
             return;
@@ -2135,6 +2194,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const feedbackProjection = projectStatusFeedback({
         interactionPhase: interactionPhase.current, interruptPhase: interruptGesture.current.phase,
         completion, overlay, copyState, copyResult, ctrlCArmed: ctrlCArmed.current,
+        // The flag, not the raw ref: the nonce render precedes the async
+        // clear, so the ref alone would repeat the clear wording (see the
+        // render-timing invariant beside the ladder).
+        hasDraft: hasDraftRef.current && !draftClearedByCtrlC,
         selectionPending: selectionController?.hasPendingSelection() ?? false, liveServices,
         toast: latestToast ? { text: latestToast.text,
             level: latestToast.level === 'success' ? 'info' : latestToast.level } : undefined,
@@ -2159,10 +2222,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         hints: { interactionPhase: interactionPhase.current, cols, completion, overlay,
             selectionPending: selectionController?.hasPendingSelection() ?? false,
             copyInFlight: copyState.busy, copyCleanupPending: copyState.cleanupPending,
-            services: liveServices, hintsEnabled: cfg.hints, modeToggleKey,
+            hasDraft: hasDraftRef.current, services: liveServices,
+            hintsEnabled: cfg.hints, modeToggleKey,
             interruptPhase: interruptGesture.current.phase,
             updateAvailable: !!updateSnapshot && shouldRenderUpdateLine(updateSnapshot) } });
-    const composer = (_jsx(Composer, { deleteDisambiguated: terminal?.deleteDisambiguated ?? false, onCompletionContextChange: setCompletion, cols: frameBudget.composerCols, terminalRows: rows, statusExpanded: statusExpanded, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: false, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: frameBudget.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onDraftRows: onDraftRows, onNotice: notify, theme: theme, caps: caps, onSubmit: handleSubmit, onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }));
+    const composer = (_jsx(Composer, { deleteDisambiguated: terminal?.deleteDisambiguated ?? false, onCompletionContextChange: setCompletion, cols: frameBudget.composerCols, terminalRows: rows, statusExpanded: statusExpanded, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: false, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: frameBudget.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onDraftRows: onDraftRows, onDraftPresence: onDraftPresence, draftClearNonce: draftClearNonce, onNotice: notify, theme: theme, caps: caps, onSubmit: handleSubmit, onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }));
     const team = state.team ? (_jsx(TeamPanel, { snapshot: state.team, layout: teamLayout, rows: rows, cols: contentCols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     const rail = showRail && state.todos ? (_jsx(TodoPanel, { snapshot: state.todos, width: railWidth, rows: railRows, running: running, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     const viewport = (_jsxs(ScrollViewport, { active: overlay === null && !tooSmall, overlay: overlayNode, footer: _jsxs(_Fragment, { children: [team, _jsx(QueuePanel, { layout: queueLayout, theme: theme })] }), rail: rail, scrollbar: terminal?.scrollbar, resetKey: scrollResetKey, intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, onViewportShiftChange: onViewportShiftChange, onGeometryChange: onGeometryChange, geometryKey: `${rows}:${cols}:${viewportBudget}:${frameBudget.composerSlotRows}:${frameBudget.statusRows}:${contentCols}:${overlay}:${tooSmall}`, tailRowsRef: tailSink, hold: selectionHold, resumeMs: cfg.scrollResumeMs, showScrollIndicator: true, cols: contentCols, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: transcriptEntries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: density, nowSec: nowSec, theme: theme, caps: caps, windowSize: transcriptWindow, cols: contentCols, heights: heights, mountedSink: mountedCount, tailSink: tailSink })] }));

package/dist/ui/Composer.d.ts

@@ -64,6 +64,19 @@ export interface ComposerProps {
      * character, which is what keeps the re-render rate the same (R-6).
      */
     onDraftRows?: (rows: number) => void;
+    /**
+     * Draft PRESENCE, forwarded upward for the Ctrl+C ladder
+     * (ctrl-c-clear-draft-exit). App stores it in a ref only - no state,
+     * so the transcript does not re-render on the first keystroke of a
+     * message (the same cost the comment above documents).
+     */
+    onDraftPresence?: (hasDraft: boolean) => void;
+    /**
+     * Downward half of the same channel: ticks when App asks the editor
+     * to clear the draft (Ctrl+C x2 while drafting). Passed through to
+     * PromptInput unchanged.
+     */
+    draftClearNonce?: number;
     /** Paste refusals from `PromptInput`, routed to `App`'s notice dispatch. */
     onNotice?: (level: 'warn' | 'error', text: string) => void;
     theme: Theme;
@@ -88,5 +101,5 @@ declare function hintText(opts: {
 }): string;
 /** Compatibility export for existing hint contract tests. */
 export declare const hintTextForTest: typeof hintText;
-export declare function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onNotice, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
+export declare function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onDraftPresence, draftClearNonce, onNotice, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
 export {};

package/dist/ui/Composer.js

@@ -36,12 +36,15 @@ function hintText(opts) {
 }
 /** Compatibility export for existing hint contract tests. */
 export const hintTextForTest = hintText;
-export function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onNotice, theme, caps, onSubmit, onHelp, }) {
+export function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onDraftPresence, draftClearNonce, onNotice, theme, caps, onSubmit, onHelp, }) {
     const [hasDraft, setHasDraft] = useState(false);
     const onDraftChange = useCallback((next) => {
         setHasDraft(next.hasDraft);
+        // Presence FIRST: the App ref must be current before the row-count
+        // report below can trigger the App render that reads it.
+        onDraftPresence?.(next.hasDraft);
         onDraftRows?.(next.rows);
-    }, [onDraftRows]);
+    }, [onDraftPresence, onDraftRows]);
     // Plan mode inserts ONE branch, above `draft` and below `running`. The
     // ordering is load-bearing: an in-flight run's border must stay `toolRunning`,
     // because "is it running" is more urgent than "which mode".
@@ -54,5 +57,5 @@ export function Composer({ deleteDisambiguated, onCompletionContextChange, cols,
                 : hasDraft
                     ? theme.focusBorder ?? theme.primary
                     : theme.idleBorder ?? theme.border;
-    return (_jsx(Box, { ref: measureRef, width: cols, flexDirection: "column", flexShrink: 0, children: _jsx(PromptInput, { deleteDisambiguated: deleteDisambiguated, onCompletionContextChange: onCompletionContextChange, cols: cols, terminalRows: terminalRows, statusExpanded: statusExpanded, cursorVisible: cursorVisible, onInteraction: onInteraction, isActive: isActive, reducedMotion: reducedMotion, onEscape: onEscape, onEscapeDismiss: onEscapeDismiss, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, popupMaxHeight: popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, borderColor: borderColor, onDraftChange: onDraftChange, onNotice: onNotice }) }));
+    return (_jsx(Box, { ref: measureRef, width: cols, flexDirection: "column", flexShrink: 0, children: _jsx(PromptInput, { deleteDisambiguated: deleteDisambiguated, onCompletionContextChange: onCompletionContextChange, cols: cols, terminalRows: terminalRows, statusExpanded: statusExpanded, cursorVisible: cursorVisible, onInteraction: onInteraction, isActive: isActive, reducedMotion: reducedMotion, onEscape: onEscape, onEscapeDismiss: onEscapeDismiss, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, popupMaxHeight: popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, borderColor: borderColor, onDraftChange: onDraftChange, draftClearNonce: draftClearNonce, onNotice: onNotice }) }));
 }

package/dist/ui/PromptInput.d.ts

@@ -93,6 +93,15 @@ interface PromptInputProps {
      * component is the only place that holds both facts.
      */
     onNotice?: (level: 'warn' | 'error', text: string) => void;
+    /**
+     * App-owned draft clearing (ctrl-c-clear-draft-exit): the second
+     * Ctrl+C of the armed ladder asks the editor to drop the draft. A
+     * NUMBER, not a boolean, so repeated requests stay distinguishable
+     * and the effect below never re-fires for an unchanged value.
+     * `'clear'` returns the editor to INITIAL_EDITOR_STATE, releasing
+     * paste payloads with it.
+     */
+    draftClearNonce?: number;
     scrolledLines?: number;
 }
 export interface ScrollChip {
@@ -159,5 +168,5 @@ export declare function fileTokenAt(buffer: string, cursor: number): {
     end: number;
     query: string;
 } | null;
-export declare function PromptInput({ cols: colsProp, terminalRows: terminalRowsProp, statusExpanded, cursorVisible, onInteraction, isActive, running, history, commands, cwd, theme, caps, popupMaxRows, popupMaxHeight, onPopupRowsChange, onCompletionContextChange, deleteDisambiguated, agentMode, onSubmit, onHelp, onEscape, onEscapeDismiss, reducedMotion, borderColor, onDraftChange, onNotice, }: PromptInputProps): React.ReactElement;
+export declare function PromptInput({ cols: colsProp, terminalRows: terminalRowsProp, statusExpanded, cursorVisible, onInteraction, isActive, running, history, commands, cwd, theme, caps, popupMaxRows, popupMaxHeight, onPopupRowsChange, onCompletionContextChange, deleteDisambiguated, agentMode, onSubmit, onHelp, onEscape, onEscapeDismiss, reducedMotion, borderColor, onDraftChange, draftClearNonce, onNotice, }: PromptInputProps): React.ReactElement;
 export {};

package/dist/ui/PromptInput.js

@@ -244,7 +244,7 @@ function isControlSeq(input) {
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
-export function PromptInput({ cols: colsProp, terminalRows: terminalRowsProp, statusExpanded = false, cursorVisible = true, onInteraction, isActive, running, history, commands, cwd, theme, caps, popupMaxRows, popupMaxHeight, onPopupRowsChange, onCompletionContextChange, deleteDisambiguated = false, agentMode, onSubmit, onHelp, onEscape, onEscapeDismiss, reducedMotion = false, borderColor, onDraftChange, onNotice, }) {
+export function PromptInput({ cols: colsProp, terminalRows: terminalRowsProp, statusExpanded = false, cursorVisible = true, onInteraction, isActive, running, history, commands, cwd, theme, caps, popupMaxRows, popupMaxHeight, onPopupRowsChange, onCompletionContextChange, deleteDisambiguated = false, agentMode, onSubmit, onHelp, onEscape, onEscapeDismiss, reducedMotion = false, borderColor, onDraftChange, draftClearNonce, onNotice, }) {
     const { stdout } = useStdout();
     const [editor, dispatch] = useReducer(editorReducer, INITIAL_EDITOR_STATE);
     const { buffer, cursor, historyIndex, dismissed, sel } = editor;
@@ -373,6 +373,16 @@ export function PromptInput({ cols: colsProp, terminalRows: terminalRowsProp, st
         lastReportedDraft.current = { hasDraft, rows: draftRowCount };
         onDraftChange({ hasDraft, rows: draftRowCount });
     }, [hasDraft, draftRowCount, onDraftChange]);
+    // --- App-requested draft clear (ctrl-c-clear-draft-exit). --------
+    // The NONCE, not the buffer, is the dependency: App cannot reach this
+    // reducer directly, and keying on content would miss back-to-back
+    // requests that land on the same (empty) buffer. `'clear'` is
+    // idempotent, so a StrictMode double-invoked effect is harmless.
+    useEffect(() => {
+        if (draftClearNonce === undefined || draftClearNonce <= 0)
+            return;
+        dispatch({ type: 'clear' });
+    }, [draftClearNonce]);
     // --- Mutators. -----------------------------------------------------------
     // ONE DISPATCH EACH, and that is the rule §3.4 asks a reviewer to check line
     // by line. Two dispatches from one key would put the legacy root back to two

package/dist/ui/editor-reducer.js

@@ -160,17 +160,22 @@ export function editorReducer(state, action) {
         case 'recall':
             // `historyIndex` is SET, not reset, which is why recall cannot reuse
             // `replace` — the two differ in exactly the field that keeps the walk
-            // alive. `dismissed` and `sel` are LEFT ALONE, which is not an oversight:
-            // the three `setState` calls this replaces did not touch them either, and
-            // an Esc-dismissed popup that reopened when the user stepped through their
-            // history would be a behaviour change smuggled in by a refactor whose whole
-            // claim is that input semantics are identical (K-7).
+            // alive. `dismissed` is forced TRUE (history-recall-autocomplete-popup):
+            // recalled content is not a query the user is typing, so the suggestion
+            // popup must not appear over it - while it is visible it owns Up/Down and
+            // the second Up moves the highlight instead of stepping history. Any
+            // buffer edit (insert / backspace / replace / input ...) re-arms the
+            // popup through DRAFT_FLAGS, so typing over a recall restores them. The
+            // same gate covers the `@file` popup, which shares `dismissed`.
+            // `sel` is still LEFT ALONE: invisible while dismissed, re-homed by the
+            // next buffer change; touching it would only widen the diff (K-7 note).
             return withPrune({
                 ...state,
                 buffer: action.buffer,
                 cursor: snapGrapheme(action.buffer, action.cursor),
                 preferredVisualColumn: undefined,
                 historyIndex: action.historyIndex,
+                dismissed: true,
             });
         case 'select':
             return state.sel === action.sel ? state : { ...state, sel: action.sel };

package/dist/ui/interaction-copy.d.ts

@@ -68,6 +68,7 @@ export declare const interactionCopy: {
     readonly confirm: "Enter confirm";
     readonly stopServices: "Ctrl+C stop services";
     readonly exit: "Ctrl+C x2 exit";
+    readonly exitDraft: "Ctrl+C x2 clear input, x3 exit";
     readonly help: "/help";
     readonly shiftNewline: "Shift+Enter newline needs terminal support";
     readonly mode: "Shift+Tab switch mode";

package/dist/ui/interaction-copy.js

@@ -26,6 +26,7 @@ export const interactionCopy = {
     close: 'Esc close', closeCompletion: 'Esc menu', executeCommand: 'Enter command',
     complete: 'Tab complete', select: 'Up/Down select', scroll: 'PgUp/PgDn scroll',
     confirm: 'Enter confirm', stopServices: 'Ctrl+C stop services', exit: 'Ctrl+C x2 exit',
+    exitDraft: 'Ctrl+C x2 clear input, x3 exit',
     help: '/help', shiftNewline: 'Shift+Enter newline needs terminal support',
     mode: 'Shift+Tab switch mode', update: '/update',
     idlePlaceholder: 'Ask a question or describe a task...', runningPlaceholder: 'Add a follow-up...',

package/dist/ui/interaction-hints.d.ts

@@ -17,6 +17,8 @@ export interface ActionHintInput {
     updateAvailable?: boolean;
     exitHint?: string;
     modeToggleKey?: string;
+    /** Draft present: the exit clause becomes the clear-then-exit ladder. */
+    hasDraft?: boolean;
 }
 export declare function escapeClause(input: ActionHintInput): string;
 export declare function clipStatusText(text: string, cells: number): string;

package/dist/ui/interaction-hints.js

@@ -71,7 +71,7 @@ export function buildActionClauses(input) {
     if (!feedback && input.hintsEnabled !== false && !input.overlay) {
         if (input.updateAvailable)
             add(copy.update);
-        add(copy.exit);
+        add(input.hasDraft ? copy.exitDraft : copy.exit);
         add((input.modeToggleKey ?? 'Shift+Tab') + ' ' + copy.modeLabel);
         add(copy.help);
     }

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

@@ -83,6 +83,7 @@ function feedbackLabel(input, form) {
     const labels = {
         confirm: ['Awaiting confirmation', 'Ask', 'Ask'], stopping: ['Esc stop', 'EscS', 'EscS'],
         'force-stop': ['Esc force', 'EscF', 'EscF'], exit: ['^C exit', '^Cexit', '^C'],
+        'clear-input': ['^C clear', '^Cclear', '^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'],

package/dist/ui/overlays/HelpOverlay.js

@@ -17,7 +17,10 @@ function keyRows(times) {
         // either of them is a key the affected user never learns about, which is the
         // one-shot notice's failure repeated with a different switch.
         ['Shift+Tab / Ctrl+P', 'Toggle plan mode (same as /plan)'],
-        [`Ctrl+C ${times}2`, 'Exit'],
+        // The ladder clears a draft first (ctrl-c-clear-draft-exit):
+        // with a draft x2 clears the input and x3 exits; an empty input
+        // keeps the previous x2 exit.
+        ['Ctrl+C', `Draft: ${times}2 clear input, ${times}3 exit. Empty: ${times}2 exit`],
         ['Ctrl+L', 'Redraw the frame'],
         ['Ctrl+T', 'Show/hide thinking (off by default)'],
         ['Ctrl+I', 'Build the project index (bundled skill; asks first; needs keyboard enhancement)'],

package/dist/ui/overlays/ModelProfilePicker.js

@@ -128,6 +128,16 @@ function usePickerInput(props, state) {
             activate();
         else if (input === '/' && searchable)
             setSearching(true);
+        // `e` edits the focused profile directly (profile-picker-edit-key). The
+        // branch is deliberately NOT guarded by `!props.manager`: the manager page
+        // gains the same one-keystroke path (there `selected === focused`, see the
+        // effect in usePickerState), which spares the Enter-to-the-action-row hop.
+        // No-op on the `Current custom` row and the action rows (`focused` is
+        // undefined there), and the `searching` early-return above keeps `e` a
+        // query character while typing a search.
+        else if (!key.ctrl && !key.meta && input.toLowerCase() === 'e' && focused) {
+            props.onEdit(focused);
+        }
     });
 }
 function profilePickerLabel(props, entry) {
@@ -165,5 +175,6 @@ export function ModelProfilePicker(props) {
     usePickerInput(props, state);
     return _jsx(OverlayFrame, { ...props, title: props.error ?? (props.manager ? 'Manage profiles'
             : `${props.role === 'main' ? 'Main' : 'Fast'} profile`), rows: buildPickerRows(props, state), scrollOffset: state.searching ? 0 : state.offset, hint: state.searching ? 'Type search | Enter done | Esc back'
-            : 'Enter select/action | Esc back' });
+            : props.manager ? 'Enter action | e edit | Esc back'
+                : 'Enter select | e edit | Esc back' });
 }

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

@@ -1,6 +1,6 @@
 /** 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';
+    kind: 'confirm' | 'stopping' | 'force-stop' | 'exit' | 'clear-input' | 'copying' | 'copied' | 'copy-sent' | 'copy-cleanup' | 'copy-error' | 'notice';
     text: string;
     level: 'info' | 'warn' | 'error';
 }
@@ -19,6 +19,8 @@ export interface StatusFeedbackInput {
         text: string;
     };
     ctrlCArmed?: boolean;
+    /** Draft present: the armed feedback names the clear rung, not exit. */
+    hasDraft?: boolean;
     selectionPending?: boolean;
     liveServices?: number;
     toast?: {

package/dist/ui/status-feedback.js

@@ -7,7 +7,9 @@ export function projectStatusFeedback(input) {
     let feedback;
     if (input.ctrlCArmed && !input.copyState?.busy && !input.copyState?.cleanupPending
         && !input.selectionPending && !input.liveServices) {
-        feedback = { kind: 'exit', text: 'Press Ctrl+C again to exit', level: 'warn' };
+        feedback = input.hasDraft
+            ? { kind: 'clear-input', text: 'Press Ctrl+C again to clear input', level: 'warn' }
+            : { kind: 'exit', text: 'Press Ctrl+C again to exit', level: 'warn' };
     }
     else if (input.copyState?.cleanupPending) {
         feedback = { kind: 'copy-cleanup', text: 'Copy failed; cleaning up', level: 'error' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.19",
+  "version": "0.6.21",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.31",
+    "@aragon-agent/core": "^0.2.33",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",