@aragon-agent/cli 0.6.9 → 0.6.10

package/dist/ui/App.js

@@ -68,6 +68,7 @@ import { CommandRegistry, runSlashInput } from '../commands/registry.js';
 import { registerBuiltinCommands } from '../commands/builtins.js';
 import { makeSkillsCommand, registerSkillCommands } from '../commands/skills.js';
 import { MODE_LABEL, MODE_TOGGLE_KEYS, nextMode } from '../agent/agent-mode.js';
+import { copyText } from './clipboard.js';
 import { emptyTailState } from './layout/follow-state.js';
 /**
  * Decide what the `Max tokens` field means, WITHOUT letting a bad value in it
@@ -1367,7 +1368,12 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         cancelConfirmation();
         if (interactionPhase.current === 'running') {
             controller.steer(message);
-            toast('info', 'Steering queued.');
+            // THE TRANSCRIPT ENTRY IS THE FEEDBACK (tui-shift-enter-copy-queue
+            // 5.3). A 2.5 s toast cannot satisfy "until the message is picked
+            // up": the `queued` entry stays visible and is rewritten in place
+            // as the user message it became on the next `turn_start`. Keeping
+            // the toast too would confirm one event twice.
+            dispatch({ type: 'steerQueued', text: message });
             return;
         }
         if (interactionPhase.current === 'starting') {
@@ -1602,6 +1608,27 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // `Esc` IS DELIBERATELY NOT GIVEN A SECOND MEANING (§4.4.6). It aborts a
         // run, and an emergency exit is the last key that should silently absorb a
         // press; it clears the selection here like every other key and nothing more.
+        //
+        // THE ONE EXCEPTION, AND IT SITS AHEAD OF THE UNCONDITIONAL CLEAR
+        // (tui-shift-enter-copy-queue 4.3): Ctrl+C over a RELEASED, non-empty
+        // selection means COPY. Selecting is browsing; copying is committing,
+        // and the commit key is the one a terminal user already reaches for.
+        // `takeSelection` runs BEFORE `copyText` because the copy writes OSC
+        // 52 through `writeForeign`, which invalidates the differ and would
+        // otherwise re-clear this controller a tick later (R7). A failed copy
+        // (`via === 'none'`) still reports through the shared toast funnel and
+        // returns: the selection is already consumed, and the NEXT Ctrl+C
+        // walks the original ladder.
+        if (key.ctrl &&
+            (input === 'c' || input === 'C') &&
+            (selectionController?.hasPendingSelection() ?? false)) {
+            const payload = selectionController.takeSelection();
+            if (payload) {
+                const via = copyText(payload.text, terminal?.writeForeign);
+                selectionBridge?.onCopied?.(via, payload.lines, payload.text.length);
+                return; // copied -- no service stop, no arm, no clear
+            }
+        }
         selectionController?.clear();
         if (key.ctrl && (input === 'c' || input === 'C')) {
             // RUNG ONE: Ctrl+C acquires the meaning a terminal user already expects
@@ -1961,7 +1988,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // threading the raw flag into a fifth consumer is the one silent way back to
     // two spinners (R-2).
     const viewReducedMotion = reducedMotion || activityVisible;
-    // The run status row (spinner + phrase + steer/interrupt hint) replaces the idle
+    // The run status row (spinner + phrase + queue/interrupt hint) replaces the idle
     // hint row ABOVE the input while running; it exists only when that hint row
     // would, so the footer height is identical with and without it. `running`, not
     // `activityVisible`: an overlay must not flip the Composer between two layouts.

package/dist/ui/Composer.d.ts

@@ -22,7 +22,7 @@ import { type RunActivity } from './run-status-row.js';
 import { type AgentMode } from '../agent/agent-mode.js';
 /**
  * The run status row (tui-scrollbar-edge-and-run-row §3.3): the spinner, the phrase
- * and the `steer / interrupt / exit` clauses on ONE row above the input box.
+ * and the `queue / interrupt / exit` clauses on ONE row above the input box.
  * `App` passes it only while a run is in flight AND the idle hint row would have
  * been shown, so enabling it never changes the footer's height.
  */

package/dist/ui/Composer.js

@@ -32,7 +32,10 @@ import { MODE_LABEL, MODE_TOGGLE_KEYS, nextMode } from '../agent/agent-mode.js';
  */
 export function runningHintClauses(opts) {
     const { glyphs, services } = opts;
-    const clauses = [`${glyphs.enterKey} steer`, `esc${glyphs.times}2 interrupt`];
+    // `queue`, NOT `steer` (tui-shift-enter-copy-queue 5.5): the gesture's
+    // consequence now has a name in the transcript (`Queue: ...`), and one
+    // behaviour with two names is undiscoverable.
+    const clauses = [`${glyphs.enterKey} queue`, `esc${glyphs.times}2 interrupt`];
     // Confirmation is named even when service controls also need space.
     if (services > 0)
         clauses.push(`ctrl+c stop ${services}`);

package/dist/ui/PromptInput.js

@@ -29,6 +29,7 @@ import { AutocompletePopup } from './AutocompletePopup.js';
 import { buildAutocompleteLayout } from './layout/autocomplete.js';
 import { editorReducer, INITIAL_EDITOR_STATE, } from './editor-reducer.js';
 import { hasPasteFrame, splitPasteFrames } from './paste-frames.js';
+import { hasEnterFrame, mergeWithPasteRuns, splitEnterFrames, } from './enter-frames.js';
 import { allocatePasteId, expandPastes, expandRangeOverTokens } from './paste-tokens.js';
 import { draftMaxRows } from './composer-limits.js';
 import { layoutComposer, splitRowAtColumn } from './composer-rows.js';
@@ -543,7 +544,16 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
         // The text runs inside `segments` are already sanitised (I-14): Ink drains
         // its whole buffer in one `read()`, so this same string can carry the `\r`
         // of a user who pasted and pressed Enter inside the burst window.
-        if (hasPasteFrame(input)) {
+        //
+        // NO NEWLINE INTENT IN THE CHUNK (tui-shift-enter-copy-queue 3.5):
+        // that same one-`read()` coalescing means a paste frame can share an
+        // `input` with an enter frame or a bare Ctrl+J, and those chunks
+        // belong to the newline branch below, whose `mergeWithPasteRuns`
+        // interleaves both families in byte order. This branch's
+        // `splitPasteFrames` would strip the enter frame's NUL and leak its
+        // letter as text. A multi-line payload (a `\n` of its own) routes
+        // there too and comes back byte-identical inside its paste segment.
+        if (hasPasteFrame(input) && !hasEnterFrame(input) && !input.includes('\n')) {
             const runs = splitPasteFrames(input);
             const segments = runs.map((run) => run.kind === 'paste' ? { kind: 'paste', text: run.text, id: allocatePasteId() } : run);
             if (segments.length === 0)
@@ -559,6 +569,28 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
             dispatch({ type: 'input', segments });
             return;
         }
+        // A NEWLINE INTENT, from either source (tui-shift-enter-copy-queue
+        // 3.5): the NUL frame the filter wrote for Shift+Enter / Alt+Enter /
+        // CSI-u Enter, or a bare `\n` (Ctrl+J), which Ink delivers WITHOUT
+        // `key.return`. Sits beside the paste branch -- after every key test so
+        // it can never shadow one, before `isControlSeq` because both sources
+        // begin with a control byte and would otherwise be dropped. ONE
+        // dispatch carries the whole ordered chunk, paste runs included when
+        // Ink coalesced the filter's two writes into one input string.
+        if (hasEnterFrame(input) || input.includes('\n')) {
+            const runs = mergeWithPasteRuns(input, splitEnterFrames(input));
+            const segments = runs.map((run) => run.kind === 'paste' ? { kind: 'paste', text: run.text, id: allocatePasteId() } : run);
+            if (segments.length === 0)
+                return;
+            const refusal = draftLimitRefusal(segments, editor);
+            if (refusal) {
+                onNotice?.('warn', refusal);
+                return;
+            }
+            onInteraction?.();
+            dispatch({ type: 'input', segments });
+            return;
+        }
         // Printable input — drop any unrecognized control/escape byte.
         if (input && !key.tab && !isControlSeq(input))
             insert(input);
@@ -566,7 +598,7 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
     const marker = running ? glyphs.steer : glyphs.caret;
     const markerColor = running ? theme.toolRunning : theme.primary;
     const placeholder = running
-        ? `Type to steer the run, Esc twice to interrupt${glyphs.ellipsis}`
+        ? `Type to queue a message, Esc twice to interrupt${glyphs.ellipsis}`
         : agentMode === 'plan'
             ? `Describe what you want to build; I'll research and plan it first${glyphs.ellipsis}`
             : `Send a message (/ for commands, @ for files)${glyphs.ellipsis}`;

package/dist/ui/Transcript.js

@@ -8,6 +8,7 @@ import { pickGlyphs, toolGlyph } from './glyphs.js';
 import { separationRows } from './density.js';
 import { EntryFrame } from './entries/EntryFrame.js';
 import { UserEntry } from './entries/UserEntry.js';
+import { QueuedEntry } from './entries/QueuedEntry.js';
 import { AssistantEntry } from './entries/AssistantEntry.js';
 import { ToolCard, statusColor, toolEntryGlyph } from './entries/ToolCard.js';
 import { TeamCard, teamCardColor } from './entries/TeamCard.js';
@@ -58,6 +59,11 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
     switch (entry.kind) {
         case 'user':
             return frame(glyphs.user, theme.user, _jsx(UserEntry, { text: entry.text, theme: theme, caps: caps }));
+        case 'queued':
+            // `theme.muted`: quieter than a user message, louder than a notice --
+            // the row exists to be noticed UNTIL it is accepted, then rewritten in
+            // place by `turnStart` (5.2.3).
+            return frame(glyphs.queued, theme.muted, _jsx(QueuedEntry, { text: entry.text, theme: theme, caps: caps }));
         case 'assistant': {
             const animate = entry.streaming && !reducedMotion && caps.unicode;
             return frame(animate ? _jsx(Spinner, { type: "dots" }) : glyphs.assistant, theme.primary, _jsx(AssistantEntry, { text: entry.text, thinking: entry.thinking, thinkingOpen: entry.thinkingOpen, thinkingVisible: thinkingVisible, streaming: entry.streaming, aborted: entry.aborted, 

package/dist/ui/enter-frames.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Reading Enter frames back out of an Ink `input` string
+ * (tui-shift-enter-copy-queue 3.5) -- pure.
+ *
+ * The stdin filter rewrites a modified Enter into `ENTER_NEWLINE_FRAME` inline,
+ * in stream order, exactly the way it frames a paste. This module is the only
+ * place that takes those frames apart again, and it handles BOTH newline
+ * sources the composer can see in one `input` string:
+ *
+ *  - `ENTER_NEWLINE_FRAME` -- Shift+Enter / Alt+Enter / CSI-u Enter, translated
+ *    by the filter; and
+ *  - a bare `\n` -- Ctrl+J, which Ink parses to `name: 'enter'` with
+ *    `input === '\n'` and NO `key.return`, so it reaches this branch as an
+ *    ordinary (control) character that must still mean "newline".
+ *
+ * I-12, THE BROADCAST OBLIGATION, APPLIES TO THESE FRAMES TOO. `useInput`
+ * re-emits every chunk to every mounted handler, `stripPasteFrames` does not
+ * know this frame, and a NUL appended into `SettingsScreen`'s API-key field
+ * renders as nothing and silently breaks authentication -- the exact accident
+ * class that function's own doc records. `stripEnterFrames` is the equivalent
+ * guard for overlays with no paste model of their own.
+ */
+import { type FrameSegment } from './paste-frames.js';
+/** True when this `input` carries at least one Enter frame -- the branch guard. */
+export declare function hasEnterFrame(input: string): boolean;
+/**
+ * Split an `input` string into ordered text runs and newline runs.
+ *
+ * Text-only by construction (paste frames are `mergeWithPasteRuns`'s job), so
+ * the paste id never has to exist here -- `PromptInput` allocates ids for paste
+ * segments while building the reducer's action, exactly as the paste branch
+ * does (P1-5: the reducer stays pure and this stays a function of its input).
+ */
+export declare function splitEnterFrames(input: string): FrameSegment[];
+/**
+ * Merge newline runs with the paste frames that share the same `input`.
+ *
+ * Ink drains its buffer in one size-less `read()`, so the filter's TWO writes
+ * (one per frame family) can arrive as ONE chunk carrying both a paste frame
+ * and an Enter frame. Neither splitter alone preserves that order --
+ * `splitPasteFrames` sanitises `\n` out of its text runs, and this module's
+ * spans treat a paste payload as ordinary text -- so the merge walks the
+ * ORIGINAL string once: paste frames become paste segments (payload through
+ * `sanitisePaste`, as `splitPasteFrames` does), and the spans between them are
+ * segmented with the SAME walker `splitEnterFrames` uses, which is what keeps
+ * the two views from disagreeing about where a newline sits.
+ *
+ * Paste segments carry NO id here (P1-5); the caller assigns one per segment
+ * only when it builds the reducer's action.
+ */
+export declare function mergeWithPasteRuns(input: string, runs: FrameSegment[]): FrameSegment[];
+/**
+ * Remove every Enter frame for a consumer that has no newline model of its
+ * own, replacing each frame with `'\n'` (tui-shift-enter-copy-queue 3.5, the
+ * I-12 analogue for this frame family).
+ *
+ * NO OTHER SANITISATION, unlike `stripPasteFrames`: the overlay call sites wrap
+ * this INSIDE their existing `stripPasteFrames(...)` call, and the composite
+ * keeps that function's byte-level guarantees. Composed the other way round a
+ * lone NUL frame would survive as its payload letter; composed this way the
+ * frame's newline lands exactly where a bare Ctrl+J lands today.
+ */
+export declare function stripEnterFrames(input: string): string;

package/dist/ui/enter-frames.js

@@ -0,0 +1,136 @@
+/**
+ * Reading Enter frames back out of an Ink `input` string
+ * (tui-shift-enter-copy-queue 3.5) -- pure.
+ *
+ * The stdin filter rewrites a modified Enter into `ENTER_NEWLINE_FRAME` inline,
+ * in stream order, exactly the way it frames a paste. This module is the only
+ * place that takes those frames apart again, and it handles BOTH newline
+ * sources the composer can see in one `input` string:
+ *
+ *  - `ENTER_NEWLINE_FRAME` -- Shift+Enter / Alt+Enter / CSI-u Enter, translated
+ *    by the filter; and
+ *  - a bare `\n` -- Ctrl+J, which Ink parses to `name: 'enter'` with
+ *    `input === '\n'` and NO `key.return`, so it reaches this branch as an
+ *    ordinary (control) character that must still mean "newline".
+ *
+ * I-12, THE BROADCAST OBLIGATION, APPLIES TO THESE FRAMES TOO. `useInput`
+ * re-emits every chunk to every mounted handler, `stripPasteFrames` does not
+ * know this frame, and a NUL appended into `SettingsScreen`'s API-key field
+ * renders as nothing and silently breaks authentication -- the exact accident
+ * class that function's own doc records. `stripEnterFrames` is the equivalent
+ * guard for overlays with no paste model of their own.
+ */
+import { ENTER_NEWLINE_FRAME, PASTE_CLOSE, PASTE_OPEN } from '../input/limits.js';
+import { sanitisePaste } from '../input/paste-parse.js';
+import { sanitiseTyped } from './paste-frames.js';
+/** True when this `input` carries at least one Enter frame -- the branch guard. */
+export function hasEnterFrame(input) {
+    return input.includes(ENTER_NEWLINE_FRAME);
+}
+/**
+ * Split one Enter-frame-free span into ordered text / newline segments.
+ *
+ * Every newline source -- frame or bare `\n` -- yields ONE
+ * `{ kind: 'text', text: '\n' }` segment, so the editor's existing `input`
+ * action inserts it through the same path typing uses and the draft's row
+ * budget applies unchanged. Non-newline text is accumulated and passed through
+ * `sanitiseTyped` (I-14): a chunk that carries a frame can also carry the
+ * keystrokes that arrived beside it, and a coalesced CR must not be spliced
+ * back into the draft raw.
+ */
+function splitEnterSpan(span) {
+    const segments = [];
+    let text = '';
+    const pushText = () => {
+        const clean = sanitiseTyped(text);
+        if (clean.length > 0)
+            segments.push({ kind: 'text', text: clean });
+        text = '';
+    };
+    let i = 0;
+    while (i < span.length) {
+        if (span.startsWith(ENTER_NEWLINE_FRAME, i)) {
+            pushText();
+            segments.push({ kind: 'text', text: '\n' });
+            i += ENTER_NEWLINE_FRAME.length;
+            continue;
+        }
+        if (span[i] === '\n') {
+            pushText();
+            segments.push({ kind: 'text', text: '\n' });
+            i += 1;
+            continue;
+        }
+        text += span[i];
+        i += 1;
+    }
+    pushText();
+    return segments;
+}
+/**
+ * Split an `input` string into ordered text runs and newline runs.
+ *
+ * Text-only by construction (paste frames are `mergeWithPasteRuns`'s job), so
+ * the paste id never has to exist here -- `PromptInput` allocates ids for paste
+ * segments while building the reducer's action, exactly as the paste branch
+ * does (P1-5: the reducer stays pure and this stays a function of its input).
+ */
+export function splitEnterFrames(input) {
+    return splitEnterSpan(input);
+}
+/**
+ * Merge newline runs with the paste frames that share the same `input`.
+ *
+ * Ink drains its buffer in one size-less `read()`, so the filter's TWO writes
+ * (one per frame family) can arrive as ONE chunk carrying both a paste frame
+ * and an Enter frame. Neither splitter alone preserves that order --
+ * `splitPasteFrames` sanitises `\n` out of its text runs, and this module's
+ * spans treat a paste payload as ordinary text -- so the merge walks the
+ * ORIGINAL string once: paste frames become paste segments (payload through
+ * `sanitisePaste`, as `splitPasteFrames` does), and the spans between them are
+ * segmented with the SAME walker `splitEnterFrames` uses, which is what keeps
+ * the two views from disagreeing about where a newline sits.
+ *
+ * Paste segments carry NO id here (P1-5); the caller assigns one per segment
+ * only when it builds the reducer's action.
+ */
+export function mergeWithPasteRuns(input, runs) {
+    if (!input.includes(PASTE_OPEN))
+        return runs;
+    const merged = [];
+    let i = 0;
+    while (i < input.length) {
+        const open = input.indexOf(PASTE_OPEN, i);
+        if (open === -1) {
+            merged.push(...splitEnterSpan(input.slice(i)));
+            break;
+        }
+        merged.push(...splitEnterSpan(input.slice(i, open)));
+        const bodyStart = open + PASTE_OPEN.length;
+        const close = input.indexOf(PASTE_CLOSE, bodyStart);
+        const body = close === -1 ? input.slice(bodyStart) : input.slice(bodyStart, close);
+        const payload = sanitisePaste(body);
+        if (payload.length > 0)
+            merged.push({ kind: 'paste', text: payload });
+        if (close === -1)
+            break;
+        i = close + PASTE_CLOSE.length;
+    }
+    return merged;
+}
+/**
+ * Remove every Enter frame for a consumer that has no newline model of its
+ * own, replacing each frame with `'\n'` (tui-shift-enter-copy-queue 3.5, the
+ * I-12 analogue for this frame family).
+ *
+ * NO OTHER SANITISATION, unlike `stripPasteFrames`: the overlay call sites wrap
+ * this INSIDE their existing `stripPasteFrames(...)` call, and the composite
+ * keeps that function's byte-level guarantees. Composed the other way round a
+ * lone NUL frame would survive as its payload letter; composed this way the
+ * frame's newline lands exactly where a bare Ctrl+J lands today.
+ */
+export function stripEnterFrames(input) {
+    if (!hasEnterFrame(input))
+        return input;
+    return input.split(ENTER_NEWLINE_FRAME).join('\n');
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Render a queued steering message (tui-shift-enter-copy-queue 5.4).
+ *
+ * ONE ROW, ALWAYS. `wrap="truncate"` -- the run-status-row width policy, for
+ * the height-estimate reason DiffView learned the hard way: a queued message
+ * can be arbitrarily long, and an entry whose wrapped height disagrees with its
+ * estimate is exactly the one the virtual window never re-measures.
+ *
+ * The glyph and the rail belong to `EntryFrame`, exactly as for every other
+ * entry; this component renders content only.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+declare function QueuedEntryImpl({ text, theme, caps, }: {
+    text: string;
+    theme: Theme;
+    caps: TermCapabilities;
+}): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator, like every sibling entry card: the
+ * reducer rebuilds the entry object only when it changes, and a `queued` entry
+ * changes exactly twice -- once when appended, once when it is rewritten into a
+ * `user` entry and stops being this component's problem.
+ */
+export declare const QueuedEntry: React.MemoExoticComponent<typeof QueuedEntryImpl>;
+export {};

package/dist/ui/entries/QueuedEntry.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Render a queued steering message (tui-shift-enter-copy-queue 5.4).
+ *
+ * ONE ROW, ALWAYS. `wrap="truncate"` -- the run-status-row width policy, for
+ * the height-estimate reason DiffView learned the hard way: a queued message
+ * can be arbitrarily long, and an entry whose wrapped height disagrees with its
+ * estimate is exactly the one the virtual window never re-measures.
+ *
+ * The glyph and the rail belong to `EntryFrame`, exactly as for every other
+ * entry; this component renders content only.
+ */
+import React from 'react';
+import { Text } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+function QueuedEntryImpl({ text, theme, caps, }) {
+    const glyphs = pickGlyphs(caps);
+    const lines = text.split('\n');
+    const first = lines[0] ?? '';
+    const extra = lines.length - 1;
+    const suffix = extra > 0 ? ` ${glyphs.ellipsis}+${extra} line${extra === 1 ? '' : 's'}` : '';
+    return (_jsx(Text, { wrap: "truncate", color: theme.muted, children: `Queue: ${first}${suffix}` }));
+}
+/**
+ * `React.memo` with the DEFAULT comparator, like every sibling entry card: the
+ * reducer rebuilds the entry object only when it changes, and a `queued` entry
+ * changes exactly twice -- once when appended, once when it is rewritten into a
+ * `user` entry and stops being this component's problem.
+ */
+export const QueuedEntry = React.memo(QueuedEntryImpl);

package/dist/ui/glyphs.d.ts

@@ -117,6 +117,15 @@ export interface Glyphs {
      * scan fails the build if either spelling appears anywhere else.
      */
     retry: string;
+    /**
+     * A message queued behind a running turn (tui-shift-enter-copy-queue 5.4).
+     * The rail marker on the `Queue: ...` row.
+     *
+     * HERE rather than in `QueuedEntry`, for the reason this file's header
+     * gives: a literal in a component bypasses `pickGlyphs` entirely and
+     * shows mojibake on a legacy console whatever the capability probe said.
+     */
+    queued: string;
     /**
      * Context compaction (context-auto-compaction §6.3). The rail marker on the
      * compaction card.

package/dist/ui/glyphs.js

@@ -66,6 +66,7 @@ const UNICODE_GLYPHS = {
     todoDone: '✔',
     retry: '↻',
     compaction: '⤓',
+    queued: '◷',
     tool: {
         read_file: '▤',
         write_file: '✎',
@@ -129,6 +130,7 @@ const ASCII_GLYPHS = {
     todoDone: '[x]',
     retry: '[r]',
     compaction: '[c]',
+    queued: '*',
     tool: {
         read_file: '=',
         write_file: '+',

package/dist/ui/overlays/HelpOverlay.js

@@ -27,8 +27,9 @@ function keyRows(times) {
         // a key, so it has to be named somewhere they can look it up. The one-shot
         // startup notice is the other place, and it scrolls away.
         ['Drag right edge', 'Scroll messages and input together; type to return'],
-        ['Run status row', 'Spinner and steer / interrupt keys, above the input during a run'],
-        ['Drag text (left button)', 'Select text on screen; releasing copies it'],
+        ['Run status row', 'Spinner and queue / interrupt keys, above the input during a run'],
+        ['Drag text (left button)', 'Select text on screen; the highlight waits'],
+        ['Ctrl+C (with a selection)', 'Copy the pending selection - does not arm exit'],
         ['Up / Down', 'Prompt history (empty input)'],
         // Pasting is the one affordance here with no key of its own, so the only
         // place a user can learn what happened to their 218 lines is this row.

package/dist/ui/overlays/PlanReviewOverlay.js

@@ -28,6 +28,7 @@ import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
 import { wrapToRows } from '../layout/wrap-rows.js';
 import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
 /** The frame's border plus its one-column padding on each side. */
 const FRAME_CHROME_COLS = 4;
 export function PlanReviewOverlay({ plan, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onVerdict, }) {
@@ -63,7 +64,10 @@ export function PlanReviewOverlay({ plan, maxRows, cols, scrollOffset, onScrollC
             // pastes — a failing test, a stack trace — and a framed paste appended
             // verbatim would put NULs into text the model then reads.
             if (input && !key.ctrl && !key.meta && !key.tab) {
-                setFeedback(feedback + stripPasteFrames(input));
+                // `stripEnterFrames` rides inside it for the newline frame a
+                // Shift+Enter broadcasts (tui-shift-enter-copy-queue 3.5): same hazard,
+                // same fix, and this order is the one that leaves no NUL in the draft.
+                setFeedback(feedback + stripPasteFrames(stripEnterFrames(input)));
             }
             return;
         }

package/dist/ui/overlays/QuestionOverlay.js

@@ -20,6 +20,7 @@ import { Box, Text, useInput } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
 import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
 /** Which option index each question starts on: the recommended one. */
 function initialCursors(questions) {
     return questions.map((q) => Math.max(0, q.options.findIndex((o) => o.recommended)));
@@ -125,8 +126,12 @@ export function QuestionOverlay({ questions, maxRows, cols, theme, caps, onSubmi
             // `stripPasteFrames`, NOT `input` (I-12 / P0-2) -- the same broadcast
             // hazard `SettingsScreen` documents at length: a framed paste appended
             // verbatim stores NULs that render as nothing.
-            if (input && !key.ctrl && !key.meta && !key.tab)
-                setDraft(draft + stripPasteFrames(input));
+            // `stripEnterFrames` rides inside it for the newline frame a
+            // Shift+Enter broadcasts (tui-shift-enter-copy-queue 3.5): same hazard,
+            // same fix, and this order is the one that leaves no NUL in the draft.
+            if (input && !key.ctrl && !key.meta && !key.tab) {
+                setDraft(draft + stripPasteFrames(stripEnterFrames(input)));
+            }
             return;
         }
         // phase === 'choosing'

package/dist/ui/overlays/SettingsScreen.js

@@ -16,6 +16,7 @@ import { LOG_LEVEL_NAMES } from '../../logging/levels.js';
 import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
 import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
 const SHOW_THINKING_OPTIONS = ['off', 'on'];
 const LIVE_OUTPUT_OPTIONS = ['off', 'on'];
 const FAST_ENABLED_OPTIONS = ['off', 'on'];
@@ -302,7 +303,13 @@ export function SettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset,
             // `controller.setApiKey()`. The user is told the settings were saved and
             // every request afterwards fails to authenticate with nothing on screen to
             // explain it. Pasting IS how a key enters this process.
-            const text = stripPasteFrames(input);
+            // `stripEnterFrames` INSIDE (tui-shift-enter-copy-queue 3.5): the same
+            // broadcast carries the newline frame a Shift+Enter produced, and this
+            // composition order is the one that leaves no NUL in the field -- the
+            // outer paste strip removes the frame's newline for a single-line field
+            // exactly as it removes a bare Ctrl+J today, while the reverse order
+            // would leak the frame's letter as visible text.
+            const text = stripPasteFrames(stripEnterFrames(input));
             if (text.length === 0)
                 return;
             setValues((prev) => ({ ...prev, [field.key]: String(prev[field.key]) + text }));

package/dist/ui/selection/selection-controller.d.ts

@@ -1,8 +1,8 @@
 /**
  * The selection controller (tui-selection-and-scroll-follow §4.4). NON-REACT: it
- * owns the mouse lifecycle, the 16 ms drag coalescer, the `decorate` hook and the
- * copy-on-release, and it reaches the React tree only through the two callbacks
- * `App` registers on mount.
+ * owns the mouse lifecycle, the 16 ms drag coalescer, the `decorate` hook and
+ * the released-selection state Ctrl+C consumes, and it reaches the React tree
+ * only through the callbacks `App` registers on mount.
  *
  * WHY IT IS NOT A COMPONENT (D-6). A React re-render per motion report goes
  * through the render governor and the whole component tree; the frame pipeline
@@ -28,9 +28,9 @@
  *    than by a staleness check that can be wrong.
  */
 import type { MouseSource } from '../../input/stdin-filter.js';
+import type { CopyVia } from '../clipboard.js';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
-import type { CopyVia } from '../clipboard.js';
 /**
  * How long a nominally-held button may sit MOTIONLESS before the watchdog lets
  * go of it (I-11). Reset by every motion report, so it only fires when the
@@ -49,9 +49,6 @@ export interface SelectionControllerOptions {
     repaint: () => boolean;
     /** `App`'s `redrawNonce`, for the invalidated case (§4.4.3). */
     requestRedraw: () => void;
-    copy: (text: string) => CopyVia;
-    /** Toast sink, registered by `App` on mount (§6.3). */
-    onCopied: (via: CopyVia, lines: number, chars: number) => void;
     theme: () => Theme;
     caps: TermCapabilities;
     /** Terminal width, for the right edge of a multi-row highlight. */
@@ -64,6 +61,25 @@ export interface SelectionControllerOptions {
 export interface SelectionController {
     /** Feed to `createFrameDiffer({ decorate })`. Mirrors, then paints. */
     decorate(lines: string[]): string[];
+    /**
+     * Whether a RELEASED, non-empty selection is waiting for Ctrl+C
+     * (tui-shift-enter-copy-queue 4.2). Dragging does not count: the gesture
+     * is not finished, and a copy key pressed mid-drag must fall through to
+     * whatever it meant before this feature.
+     */
+    hasPendingSelection(): boolean;
+    /**
+     * Take the pending selection: returns its text and line count, and clears
+     * the highlight, the settled state and the hold. `null` when nothing is
+     * pending. The caller owns the copy itself (`copyText` is the single
+     * clipboard path) and MUST take BEFORE copying: OSC 52 writes through
+     * `writeForeign`, the differ invalidates, and its `onInvalidate` clears
+     * this controller -- taking first makes that clear a no-op (4.3 / R7).
+     */
+    takeSelection(): {
+        text: string;
+        lines: number;
+    } | null;
     /** Subscribe to `hold` transitions; `App` mirrors this into React state. */
     onHoldChange(listener: (hold: boolean) => void): () => void;
     /** Called by `App` for key / resize / overlay / clear, and by `onInvalidate`. */