@aragon-agent/cli 0.6.20 → 0.6.22

package/dist/team/task-tool.d.ts

@@ -39,6 +39,13 @@ export interface TaskToolDeps {
     activeProvider: () => string;
     /** The lead's cost table, so the report header states real spend (R-5). */
     modelCost: () => ModelCost | undefined;
+    /**
+     * The FAST tier's cost table, so the report's supervisor spend line states
+     * real spend (subagent-overseer-v2 D-7 / R-P1-2). OPTIONAL and returning
+     * `undefined`: an unpriced fast model renders `pricing unknown`, never a
+     * fabricated `$0.00` - the C-11 / RV-4 rule.
+     */
+    fastModelCost?: () => ModelCost | undefined;
     /**
      * Run the dispatch with the LEAD's idle watchdog paused, `try/finally` inside.
      *

package/dist/team/task-tool.js

@@ -123,8 +123,10 @@ export function createTaskTool(deps) {
             //    shape, and D-14 one level up). Every child ran the lead's own model,
             //    so the lead's cost table is the one honest price for the total.
             const cost = deps.modelCost();
+            const fastCost = deps.fastModelCost?.();
             return textResult(buildDispatchReport(outcome, {
                 ...(cost ? { cost } : {}),
+                ...(fastCost ? { fastCost } : {}),
             }));
         },
     };

package/dist/team/types.d.ts

@@ -159,6 +159,22 @@ export interface SubagentRun {
      * report reads "this row is the Nth body of the same brief".
      */
     replacements?: number;
+    /**
+     * The most recent supervisor decision applied to this child
+     * (subagent-overseer-v2 section 6). TRANSIENT, never persisted - the
+     * same rule as `activity` / `activityArgs`; a resumed session has no
+     * live dispatch.
+     *
+     * `at` is ABSOLUTE epoch ms, the same units as `startedAt` / `endedAt`
+     * (R-P2-3), so the panel renders `nudged 2m` with one subtraction and
+     * no second clock convention. `reasonHead` <= 60 chars, for the UI
+     * badge line only.
+     */
+    lastIntervention?: {
+        action: OverseerAction;
+        at: number;
+        reasonHead: string;
+    };
 }
 /** What the supervisor may do with one inspected child. */
 export type OverseerAction = 'wait' | 'nudge' | 'replace' | 'abandon';
@@ -184,8 +200,14 @@ export interface OverseerIntervention {
     at: number;
     action: OverseerAction;
     reason: string;
-    /** What the trigger was: event stall, wall-clock check, or post-mortem. */
-    trigger: 'silence' | 'clock' | 'postmortem';
+    /**
+     * What the trigger was: event stall, wall-clock check, post-mortem, or
+     * the supervisor going QUIET (subagent-overseer-v2 D-10) - the look
+     * budget ran out and supervision stopped waking this child. A VALUE OF
+     * THE UNION, never a reason prefix: a human-readable sentence is not a
+     * machine contract (the `run.error` rule).
+     */
+    trigger: 'silence' | 'clock' | 'postmortem' | 'quiet';
 }
 /**
  * A terminal supervisor decision handed to the WORKER LOOP, which is the only
@@ -231,6 +253,25 @@ export interface DispatchOutcome {
      * total priced at the lead's table is the honest accounting.
      */
     usage: TokenUsage;
+    /**
+     * The supervisor's own fast-tier spend for this dispatch
+     * (subagent-overseer-v2 D-7). Absent when nothing supervised the
+     * dispatch; read straight off the provider at dispatch end so there is
+     * exactly one accounting of it.
+     */
+    overseerUsage?: TokenUsage;
+    /** Inspection calls made, including ones that failed softly. */
+    overseerCalls?: number;
+    /**
+     * EDGE-LATCHED, once per dispatch (D-10): the fast tier was missing at
+     * least one cadence tick and the children waited UNASSISTED - announced,
+     * never killed. The per-child wait events of a degraded tick
+     * deliberately do NOT enter `interventions`; this flag plus the tick
+     * count below are the report's aggregate note.
+     */
+    overseerDegraded?: boolean;
+    /** How many cadence ticks ran unassisted (the aggregate note's number). */
+    overseerDegradedTicks?: number;
 }
 /**
  * What the UI renders: a cheap immutable projection, rebuilt per event.

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 });
@@ -657,6 +664,20 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                     const snap = controller.getTeamSnapshot();
                     if (snap)
                         dispatch({ type: 'teamUpdate', snapshot: snap });
+                    // G-4 / AC-5 (subagent-overseer-v2): a TERMINAL verdict is the
+                    // one decision the user must not discover from the final report
+                    // - it removes work they watched running. wait and nudge stay
+                    // panel-only so the transcript gains no per-tick noise.
+                    if (event.decision.action === 'replace' || event.decision.action === 'abandon') {
+                        const verb = event.decision.action === 'replace' ? 'replaced' : 'abandoned';
+                        const level = event.decision.action === 'replace' ? 'info' : 'warn';
+                        const reason = event.decision.reason.slice(0, 120);
+                        dispatch({
+                            type: 'notice',
+                            level,
+                            text: `team supervisor ${verb} ${event.label} - ${reason}`,
+                        });
+                    }
                     break;
                 }
                 case 'usage': {
@@ -1145,6 +1166,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 +1779,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 +1827,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 +2208,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 +2236,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/TeamPanel.d.ts

@@ -57,4 +57,26 @@ export declare function activityBudget(cols: number): number;
  * columns and break at 80.
  */
 export declare function activityLine(run: SubagentRun, cols: number): string;
+/**
+ * The row's supervisor badge (subagent-overseer-v2 AC-5): what the supervisor
+ * last did to THIS child and how long ago, e.g. `nudged 2m03s`.
+ *
+ * `lastIntervention.at` is ABSOLUTE epoch ms (R-P2-3), the same units as
+ * `startedAt`, so this is one subtraction - no second clock convention.
+ */
+export declare function overseerBadge(run: SubagentRun, at: number): string;
+/**
+ * The activity column WITH the badge composed in (AC-5 / risk table): the
+ * badge rides the SAME `activityBudget(cols)` allocation the prose uses, so
+ * a row can never grow past its terminal; on a narrow terminal the badge
+ * degrades to the action word alone - the who-acted fact outranks the
+ * what-they-are-doing tail exactly when there is room for only one.
+ */
+export declare function activityWithBadge(run: SubagentRun, cols: number, at: number): string;
+/**
+ * The panel's one supervisor status line (AC-5): the most recent intervention
+ * across the roster, human-phrased. Empty when the supervisor has not acted
+ * yet - furniture that says nothing is worse than no line.
+ */
+export declare function supervisorStatusLine(runs: SubagentRun[], at: number): string;
 export declare function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, now, layout, }: TeamPanelProps): React.ReactElement | null;

package/dist/ui/TeamPanel.js

@@ -101,6 +101,69 @@ export function activityLine(run, cols) {
             return 'aborted';
     }
 }
+/** The past-tense word the supervisor badge and status line render. */
+function interventionWord(action) {
+    switch (action) {
+        case 'nudge':
+            return 'nudged';
+        case 'replace':
+            return 'replaced';
+        case 'abandon':
+            return 'abandoned';
+        default:
+            return 'waited';
+    }
+}
+/**
+ * The row's supervisor badge (subagent-overseer-v2 AC-5): what the supervisor
+ * last did to THIS child and how long ago, e.g. `nudged 2m03s`.
+ *
+ * `lastIntervention.at` is ABSOLUTE epoch ms (R-P2-3), the same units as
+ * `startedAt`, so this is one subtraction - no second clock convention.
+ */
+export function overseerBadge(run, at) {
+    const last = run.lastIntervention;
+    if (last === undefined)
+        return '';
+    return `${interventionWord(last.action)} ${formatDuration(Math.max(0, at - last.at))}`;
+}
+/**
+ * The activity column WITH the badge composed in (AC-5 / risk table): the
+ * badge rides the SAME `activityBudget(cols)` allocation the prose uses, so
+ * a row can never grow past its terminal; on a narrow terminal the badge
+ * degrades to the action word alone - the who-acted fact outranks the
+ * what-they-are-doing tail exactly when there is room for only one.
+ */
+export function activityWithBadge(run, cols, at) {
+    const last = run.lastIntervention;
+    if (last === undefined)
+        return activityLine(run, cols);
+    const badge = overseerBadge(run, at);
+    if (cols < TEAM_LIMITS.activityWideCols)
+        return interventionWord(last.action);
+    return sanitizeActivity(`${badge}; ${activityLine(run, cols)}`, activityBudget(cols));
+}
+/**
+ * The panel's one supervisor status line (AC-5): the most recent intervention
+ * across the roster, human-phrased. Empty when the supervisor has not acted
+ * yet - furniture that says nothing is worse than no line.
+ */
+export function supervisorStatusLine(runs, at) {
+    let label = '';
+    let latest;
+    for (const run of runs) {
+        const last = run.lastIntervention;
+        if (last !== undefined && (latest === undefined || last.at > latest.at)) {
+            latest = last;
+            label = run.label;
+        }
+    }
+    if (latest === undefined)
+        return '';
+    const ago = formatDuration(Math.max(0, at - latest.at));
+    const head = latest.reasonHead.length > 0 ? ` (${latest.reasonHead})` : '';
+    return `supervisor: ${interventionWord(latest.action)} ${label} ${ago} ago${head}`;
+}
 export function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, now, layout, }) {
     const projection = layout ?? buildTeamPanelLayout({
         snapshot, terminalRows: rows, availableRows: Infinity,
@@ -130,8 +193,14 @@ export function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, no
                 // `reducedMotion` and a non-Unicode terminal fall back to the same
                 // static marker, exactly as `AssistantEntry` and `ToolCard` already do.
                 const animate = isRunning(run) && !reducedMotion && caps.unicode;
-                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: color, children: [' ', animate ? _jsx(Spinner, { type: "dots" }) : marker(run, glyphs), ' '] }), _jsx(Text, { color: theme.primary, children: run.label.padEnd(8).slice(0, 8) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: run.description.replace(/\s+/g, ' ') }) }), _jsx(Box, { flexShrink: 1, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: color, children: ['  ', activityLine(run, cols)] }) }), _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? at) - run.startedAt)) : ''] })] }, run.label));
-            }), hiddenTotal > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', "+", hiddenTotal, " more", hiddenRunning > 0 ? ` (${hiddenRunning} running)` : ''] })), snapshot.lastMessage && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [' ', glyphs.teamMail, " ", snapshot.lastMessage.from, " ", glyphs.arrowRight, " ", snapshot.lastMessage.to, ": ", snapshot.lastMessage.subject.replace(/\s+/g, ' ')] }))] }));
+                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: color, children: [' ', animate ? _jsx(Spinner, { type: "dots" }) : marker(run, glyphs), ' '] }), _jsx(Text, { color: theme.primary, children: run.label.padEnd(8).slice(0, 8) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: run.description.replace(/\s+/g, ' ') }) }), _jsx(Box, { flexShrink: 1, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: color, children: ['  ', activityWithBadge(run, cols, at)] }) }), _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? at) - run.startedAt)) : ''] })] }, run.label));
+            }), hiddenTotal > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', "+", hiddenTotal, " more", hiddenRunning > 0 ? ` (${hiddenRunning} running)` : ''] })), (() => {
+                // The panel's supervisor line (AC-5): one row, only when the
+                // supervisor has actually acted - the per-row badges above already
+                // carry the per-child facts.
+                const line = supervisorStatusLine(snapshot.runs, at);
+                return line ? (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', line] })) : null;
+            })(), snapshot.lastMessage && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [' ', glyphs.teamMail, " ", snapshot.lastMessage.from, " ", glyphs.arrowRight, " ", snapshot.lastMessage.to, ": ", snapshot.lastMessage.subject.replace(/\s+/g, ' ')] }))] }));
 }
 function marker(run, glyphs) {
     if (run.phase === 'done')

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/layout/team-panel.js

@@ -12,7 +12,10 @@ export function buildTeamPanelLayout(input) {
     }
     const selection = selectPanelRows(input.snapshot.runs, TEAM_LIMITS.panelMaxRows);
     const natural = 1 + selection.visible.length + Number(selection.hiddenTotal > 0)
-        + Number(Boolean(input.snapshot.lastMessage));
+        + Number(Boolean(input.snapshot.lastMessage))
+        // The supervisor status line (subagent-overseer-v2 AC-5) occupies one
+        // row whenever any run carries an intervention badge.
+        + Number(input.snapshot.runs.some((run) => run.lastIntervention !== undefined));
     const collapsed = nonNegativeInt(input.terminalRows) < TEAM_LIMITS.panelCollapseRows
         || available - natural < TODO_LIMITS.panelMinRows;
     return { ...selection, collapsed, rowCount: collapsed ? 1 : natural };

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