@aragon-agent/cli 0.6.11 → 0.6.13

package/dist/ui/StatusBar.js

@@ -1,118 +1,33 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import stringWidth from 'string-width';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/** A single row of complete, measured status fields. */
+import React from 'react';
 import { Box, Text, useStdout } from 'ink';
 import { pickGlyphs } from './glyphs.js';
-import { formatCost, formatTokens, formatDuration, promptTokensOf } from '../agent/usage.js';
-import { buildGauge } from './gauge.js';
-import { MODE_LABEL } from '../agent/agent-mode.js';
-import { formatRetryChip } from '../agent/retry-view.js';
-import { FAST_LIMITS } from '../fast/limits.js';
-import { COMPACTION_LIMITS } from '../compaction/limits.js';
-import { TEAM_LIMITS } from '../team/limits.js';
-import { TODO_LIMITS } from '../todo/limits.js';
-import { PROC_LIMITS } from '../proc/limits.js';
-/** Below this the `eco` chip costs the context gauge more than it is worth. */
-const ECO_MIN_COLS = 72;
-/**
- * Where `86k/200k` starts being shown (context-usage-gauge-accuracy §3.6 / W5).
- *
- * IT TAKES THE COLUMNS THE SESSION TOTAL USED TO HAVE, and the ordering is the
- * point rather than a layout accident (D-6). "How full am I, out of how much" is
- * the question a user asks the gauge; "what has this session cost in tokens" is
- * a different one, and putting the second in front of the first spends the
- * scarce columns on the number the user is more likely to MISREAD - the total
- * looks like an occupancy until you notice it exceeds the window.
- */
-const ABSOLUTE_PAIR_MIN_COLS = 72;
-/**
- * Where the session total returns, now prefixed.
- *
- * `total ` IS AN ASCII WORD, NOT A SIGMA. `ui/**` is inside the glyph scanner's
- * scope, so a new symbol would need an entry in `glyphs.ts` with an ASCII
- * fallback for a legacy `cmd.exe` - a real cost for a three-character prefix
- * that reads worse.
- */
-const SESSION_TOTAL_MIN_COLS = 96;
-/**
- * I-5 — DO NOT "CLEAN THIS UP". Ink short-circuits identical output at TWO
- * gates (`ink.js:132` and `log-update.js:13`), so a fixed frame whose React
- * output has not changed is never repainted. `Ctrl+L` therefore cannot work by
- * writing an escape sequence; it works by making the rendered STRING differ.
- * This alternates the status bar's left gutter between U+0020 and U+00A0: both
- * render one invisible column, so there is zero visual or layout difference,
- * but the bytes differ and both gates open.
- *
- * It must sit at the START of the line: Ink `trimEnd()`s every row (output.js),
- * and JS `trimEnd` strips U+00A0 too — a trailing carrier would be deleted and
- * Ctrl+L would degrade to a silent no-op.
- */
-/** Built by code point so no formatter can normalize it back to a plain space. */
-const NBSP = String.fromCharCode(0x00a0);
-function redrawChar(nonce) {
-    return nonce % 2 === 0 ? ' ' : NBSP;
-}
+import { liveSpinner } from './ActivityLine.js';
+import { planStatusFields } from './layout/status-layout.js';
+/** An invisible leading byte change forces Ink to repaint on Ctrl+L. */
+const redrawChar = (nonce) => nonce % 2 ? String.fromCharCode(0x00a0) : ' ';
 export function StatusBar(props) {
-    const { model, provider, usageTotal, context, status, elapsedMs, thinkingLevel, tokPerSec, theme, caps, scrolledLines = 0, redrawNonce = 0, agentMode = 'build', pendingAgentMode = null, teamActive, todoActive, servicesActive, retryActive, ecoRung = 0, fastActive, compactionActive, gaugeMarks, } = props;
     const { stdout } = useStdout();
     const cols = stdout?.columns ?? 80;
-    const running = status === 'running';
-    const glyphs = pickGlyphs(caps);
-    // THE PERCENTAGE IS NOT RECOMPUTED HERE ANY MORE. It arrives already divided
-    // and clamped by the same code the compaction trigger reads, which is the
-    // whole of AC-2: a user watching 78 % and a `/compact status` reporting 91 %
-    // would rightly conclude one of them is lying.
-    const pct = context.pct;
-    // `gaugeMarks` is spread rather than passed as `undefined`, so a session with
-    // compaction off takes `buildGauge`'s own default and the bar is byte-identical
-    // to the pre-feature build.
-    const gauge = gaugeMarks
-        ? buildGauge(pct, cols < 72 ? 8 : 12, theme, caps, gaugeMarks)
-        : buildGauge(pct, cols < 72 ? 8 : 12, theme, caps);
-    // `~` BELONGS TO THE NUMERATOR, `?` TO THE DENOMINATOR (P2-7). One glyph used
-    // to carry three meanings - the window is a guess, the occupancy is a guess,
-    // the occupancy contains an appended-message estimate - and a user could not
-    // tell from it which half to distrust. The `~` keeps every case it had: an
-    // unknown window still produces it, so a session that never touches the new
-    // absolute pair sees the identical string it saw before.
-    const occupancyApproximate = context.source === 'estimate' || context.deltaTokens > 0;
-    const pctLabel = `${context.windowKnown && !occupancyApproximate ? '' : '~'}${gauge.pct}%`;
-    // `?` ON THE WINDOW, AND ONLY ON THE NEW READOUT. `windowKnown` is false
-    // exactly when `buildRuntimeModel` invented the 128k placeholder, and saying
-    // `128k?` is the difference between a denominator the user can act on and one
-    // they will assume came from their model card.
-    const windowLabel = `${formatTokens(context.window)}${context.windowKnown ? '' : '?'}`;
-    const absolutePair = `${formatTokens(context.occupied)}/${windowLabel}`;
-    // THE PROMPT-SIDE TOTAL, NOT `inputTokens` (P1-3 / AC-11). Anthropic reports
-    // `input_tokens` EXCLUDING cached tokens, so the old expression under-reported
-    // for anyone behind a caching gateway - on the same row as a `$` that has
-    // always priced the cache. Any session with cache hits sees this number grow,
-    // and that is the fix rather than a regression.
-    const tokens = `total ${formatTokens(promptTokensOf(usageTotal))}${glyphs.arrowUp} ${formatTokens(usageTotal.outputTokens)}${glyphs.arrowDown}`;
-    const statusGlyph = running ? theme.symbols.toolRunning : theme.symbols.toolPending;
-    // Nothing at all in build mode with nothing pending: the default posture is
-    // not news, and a permanent word here would be furniture.
-    const modeWord = agentMode === 'build' && !pendingAgentMode
-        ? ''
-        : pendingAgentMode
-            ? `${MODE_LABEL[agentMode]} ${glyphs.arrowRight} ${MODE_LABEL[pendingAgentMode]}`
-            : MODE_LABEL[agentMode];
-    const actionHints = [running ? (props.interruptHint ?? 'Esc abort') : '',
-        servicesActive ? `Ctrl+C stop ${servicesActive.live}` : '',
-        scrolledLines > 0 ? 'PgDn down' : ''].filter(Boolean).join(' | ');
-    const hintCols = actionHints ? Math.min(Math.max(0, cols - 1), stringWidth(actionHints) + 2) : 0;
-    const detailCols = Math.max(0, cols - 1 - hintCols);
-    return (
-    // `flexShrink={0}` on the left cluster is not cosmetic. When the two clusters
-    // over-subscribe the row, yoga shrinks the flexible children and Ink's text
-    // measurement drops a character from EACH of them — the bar renders "idl"
-    // and "? hel" rather than truncating cleanly at one end. Pinning the left
-    // cluster keeps the run status and model intact and makes the degradation
-    // land in one predictable place.
-    _jsxs(Box, { width: cols, flexDirection: "row", justifyContent: "space-between", flexShrink: 0, height: 1, overflow: "hidden", children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { children: redrawChar(redrawNonce) }) }), hintCols > 0 && (_jsx(Box, { width: hintCols, flexShrink: 0, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: theme.noticeWarn, children: [actionHints, '  '] }) })), _jsxs(Box, { display: detailCols > 0 ? 'flex' : 'none', width: detailCols, flexShrink: 0, flexDirection: "row", justifyContent: "space-between", overflow: "hidden", children: [_jsxs(Box, { flexDirection: "row", flexShrink: 0, overflow: "hidden", children: [_jsxs(Text, { color: running ? theme.toolRunning : theme.toolDone, children: [statusGlyph, " ", running ? 'running' : 'idle'] }), modeWord && (_jsxs(Text, { color: theme.accent, bold: true, children: ['  ', modeWord] })), teamActive && (_jsxs(Text, { color: theme.toolRunning, bold: true, children: ['  ', cols >= TEAM_LIMITS.statusCompactCols
-                                        ? `agents ${teamActive.running}/${teamActive.total}`
-                                        : `[${teamActive.running}]`] })), retryActive && (_jsxs(Text, { color: theme.noticeWarn, bold: true, children: ['  ', formatRetryChip(retryActive, cols)] })), todoActive && (_jsxs(Text, { color: theme.accent, children: ['  ', cols >= TODO_LIMITS.statusCompactCols
-                                        ? `todo ${todoActive.done}/${todoActive.total}`
-                                        : `[${todoActive.done}/${todoActive.total}]`] })), servicesActive && (_jsxs(Text, { color: theme.accent, children: ['  ', cols >= PROC_LIMITS.statusCompactCols
-                                        ? `svc ${servicesActive.live}`
-                                        : `[${servicesActive.live}]`] })), cols >= 60 && (cols >= 110 || (!running && !servicesActive && scrolledLines === 0)) && (_jsxs(Text, { color: theme.muted, children: ['  ', provider, ":", model] })), thinkingLevel !== 'off' && cols >= 72 && (_jsxs(Text, { color: theme.accent, children: ["  think:", thinkingLevel] }))] }), _jsxs(Box, { flexDirection: "row", children: [compactionActive && cols >= COMPACTION_LIMITS.statusCompactCols && (_jsxs(Text, { color: compactionActive.inFlight ? theme.accent : theme.muted, children: [compactionActive.inFlight ? 'compacting' : 'compact', '  '] })), fastActive && cols >= FAST_LIMITS.statusCompactCols && (_jsxs(Text, { color: theme.muted, children: ["fast", fastActive.inFlight ? '*' : '', '  '] })), ecoRung > 0 && cols >= ECO_MIN_COLS && (_jsxs(Text, { color: theme.muted, children: ["eco", '  '] })), scrolledLines > 0 && (_jsxs(Text, { color: theme.noticeWarn, children: [glyphs.arrowUp, scrolledLines, '  '] })), cols >= 60 && (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "[" }), _jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty }), _jsx(Text, { color: theme.muted, children: "] " })] })), _jsx(Text, { color: theme.muted, children: pctLabel }), cols >= ABSOLUTE_PAIR_MIN_COLS && (_jsxs(Text, { color: theme.muted, children: ["  ", absolutePair] })), cols >= SESSION_TOTAL_MIN_COLS && _jsxs(Text, { color: theme.muted, children: ["  ", tokens] }), _jsxs(Text, { color: theme.muted, children: ["  ", formatCost(usageTotal.costUsd)] }), running && (_jsxs(Text, { color: theme.muted, children: [tokPerSec > 0 && cols >= 72 ? `  ${tokPerSec} tok/s` : '', "  ", formatDuration(elapsedMs)] }))] })] })] }));
+    const phase = props.runPhase ?? (props.status === 'running' ? 'waiting' : 'idle');
+    const active = phase !== 'idle' || !!props.compactionActive?.inFlight;
+    const glyph = pickGlyphs(props.caps).spinnerStill;
+    const spinner = active ? liveSpinner(props.reducedMotion ?? false, props.caps) : null;
+    const fields = planStatusFields({
+        columns: cols, phase, pendingCount: props.pendingSteering?.length ?? 0,
+        context: props.context, usageTotal: props.usageTotal,
+        thinkingLevel: props.thinkingLevel, elapsedMs: props.elapsedMs, tokPerSec: props.tokPerSec,
+        activeTool: props.activeTool, runOutcome: props.runOutcome, spinner: active ? glyph : '',
+        waitingForConfirmation: props.waitingForConfirmation, stopping: props.stopping,
+        compacting: props.compactionActive?.inFlight, retryActive: props.retryActive,
+        mode: props.agentMode, pendingMode: props.pendingAgentMode, servicesActive: props.servicesActive,
+        teamActive: props.teamActive, todoActive: props.todoActive,
+        ecoRung: props.ecoRung, fastActive: props.fastActive, scrolledLines: props.scrolledLines,
+    });
+    const tones = { normal: props.theme.primary, muted: props.theme.muted,
+        warning: props.theme.noticeWarn, error: props.theme.noticeError };
+    return _jsxs(Box, { width: cols, height: 1, flexShrink: 0, flexDirection: "row", children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { children: redrawChar(props.redrawNonce ?? 0) }) }), fields.map((item, index) => _jsxs(React.Fragment, { children: [index > 0 && _jsx(Box, { width: 3, flexShrink: 0, children: _jsx(Text, { color: props.theme.muted, children: " | " }) }), _jsx(Box, { width: item.cells, flexShrink: 0, children: _jsx(Text, { color: tones[item.tone], children: item.id === 'phase' && active
+                                ? _jsxs(_Fragment, { children: [spinner ?? glyph, item.text.slice(glyph.length)] })
+                                : item.text }) })] }, item.id))] });
 }

package/dist/ui/clipboard-task.d.ts

@@ -0,0 +1,29 @@
+import { type ClipboardOptions, type CopyResult } from './clipboard.js';
+export interface CopyRequest {
+    text: string;
+    lines: number;
+}
+export type CopyRequestResult = CopyResult | {
+    status: 'busy';
+};
+export interface ClipboardState {
+    busy: boolean;
+    cleanupPending: boolean;
+}
+export interface ClipboardCoordinatorOptions {
+    clipboard?: ClipboardOptions;
+    /** Clears the previous Ctrl+C exit preparation for both copy entry points. */
+    onRequest?: () => void;
+    /** A repeated request is consumed; its selection must remain untouched. */
+    onBusy?: (state: ClipboardState) => void;
+    onResult?: (result: CopyResult, request: CopyRequest) => void;
+    onStateChange?: (state: ClipboardState) => void;
+}
+export interface ClipboardCoordinator {
+    requestCopy(request: CopyRequest): Promise<CopyRequestResult>;
+    isBusy(): boolean;
+    isCleanupPending(): boolean;
+    dispose(): void;
+}
+/** Create the App-owned copy port; use its live busy state before taking a selection. */
+export declare function createClipboardCoordinator(options?: ClipboardCoordinatorOptions): ClipboardCoordinator;

package/dist/ui/clipboard-task.js

@@ -0,0 +1,66 @@
+import { startClipboardTask, } from './clipboard.js';
+class SharedClipboardCoordinator {
+    options;
+    busy = false;
+    cleanupPending = false;
+    disposed = false;
+    abort = new AbortController();
+    constructor(options) {
+        this.options = options;
+        options.clipboard?.signal?.addEventListener('abort', this.dispose, { once: true });
+        if (options.clipboard?.signal?.aborted)
+            this.dispose();
+    }
+    isBusy() { return this.busy; }
+    isCleanupPending() { return this.cleanupPending; }
+    state() {
+        return { busy: this.busy, cleanupPending: this.cleanupPending };
+    }
+    notifyState() {
+        if (!this.disposed)
+            this.options.onStateChange?.(this.state());
+    }
+    requestCopy = (request) => {
+        if (this.disposed)
+            return Promise.resolve({ status: 'failed', reason: 'cancelled' });
+        if (this.busy) {
+            this.options.onRequest?.();
+            this.options.onBusy?.(this.state());
+            return Promise.resolve({ status: 'busy' });
+        }
+        // Claim synchronously, before callbacks or Promise work can re-enter this port.
+        this.busy = true;
+        this.options.onRequest?.();
+        this.notifyState();
+        const snapshot = { ...request };
+        const task = startClipboardTask(snapshot.text, {
+            ...this.options.clipboard, signal: this.abort.signal,
+        });
+        const result = task.result.then((value) => {
+            if (!this.disposed) {
+                this.cleanupPending = this.busy && value.status === 'failed';
+                this.notifyState();
+                this.options.onResult?.(value, snapshot);
+            }
+            return value;
+        });
+        // Failure feedback is not a release signal: the old native writer may still live.
+        void task.released.then(() => {
+            this.busy = false;
+            this.cleanupPending = false;
+            this.notifyState();
+        });
+        return result;
+    };
+    dispose = () => {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.options.clipboard?.signal?.removeEventListener('abort', this.dispose);
+        this.abort.abort();
+    };
+}
+/** Create the App-owned copy port; use its live busy state before taking a selection. */
+export function createClipboardCoordinator(options = {}) {
+    return new SharedClipboardCoordinator(options);
+}

package/dist/ui/clipboard.d.ts

@@ -1,52 +1,31 @@
-/**
- * Clipboard (tui-selection-and-scroll-follow §4.4.5) — the SINGLE clipboard path
- * for the package. `/copy` and the selection release both come through here.
- *
- * Two mechanisms, both attempted, and the return value names the better one so
- * the toast can say what was SENT rather than claiming a success neither one can
- * confirm:
- *
- *  1. **OSC 52.** It reaches the clipboard of the machine the USER is sitting
- *     at, which is the only correct target over SSH, and it is the only mechanism
- *     that works with no helper binary installed. `/copy` gained SSH support the
- *     moment it moved onto this module.
- *  2. **The platform binary** (`clip` / `pbcopy` / `xclip`), moved here unchanged
- *     from `commands/builtins.ts`, for the local case and for terminals that
- *     ignore OSC 52 (tmux without `set -g set-clipboard on`, R-7).
- *
- * IT TAKES A WRITE *DOOR*, NOT A STREAM, and that is P1-6 rather than taste. In
- * full-screen mode stdout is a `Proxy` in front of the frame differ; an
- * unrecognised chunk there takes `passThrough(true)`, which increments
- * `fallbacks` and — on the first one — raises `onFirstFallback`, wired to
- * `console.warn(FRAME_FALLBACK_NOTICE)`. Sending OSC 52 through the proxy would
- * therefore print a diagnostic at a user who did nothing wrong the first time
- * they copied anything, and would permanently corrupt a counter documented to
- * mean "something wrote to stdout behind Ink's back". The caller supplies
- * `writeForeign` instead, and this module cannot pick the wrong door.
- */
-export type CopyVia = 'osc52' | 'native' | 'none';
-/**
- * Ceiling on an OSC 52 payload, in bytes of the ORIGINAL text.
- *
- * xterm's default limit is around 100 000 BASE64 characters and tmux / screen
- * are stricter, so 56 000 source bytes (~74 700 base64) stays inside all three
- * with room to spare. Past it the sequence is skipped rather than truncated: a
- * terminal that drops an over-long OSC 52 leaves the clipboard holding whatever
- * was there before, and half a selection is worse than none.
- */
+export type CopyFailureReason = 'empty' | 'unavailable' | 'write' | 'timeout' | 'too-large' | 'cancelled';
+export type CopyResult = {
+    status: 'confirmed';
+    via: 'native';
+} | {
+    status: 'sent';
+    via: 'osc52';
+    fallbackReason?: CopyFailureReason;
+} | {
+    status: 'failed';
+    reason: CopyFailureReason;
+};
+export interface ClipboardOptions {
+    /** Frame differ's foreign-write door, never the intercepted stdout stream. */
+    write?: (chunk: string) => void;
+    remote?: boolean;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface ClipboardTask {
+    result: Promise<CopyResult>;
+    /** Resolves only after no writer can change the clipboard again. */
+    released: Promise<void>;
+}
 export declare const MAX_OSC52_BYTES = 56000;
-/** `\x1b]52;c;<base64>\x07` — `c` is the CLIPBOARD selection, not PRIMARY. */
+/** Encode the full clipboard selection as UTF-8, without truncating its payload. */
 export declare function osc52(text: string): string;
-/**
- * Put `text` on the clipboard and report the best mechanism that was reached.
- *
- * `write` is the foreign-write door (see the module header). Omit it and OSC 52
- * is skipped entirely, which is the correct behaviour for a caller that has no
- * terminal to write to.
- *
- * NEITHER MECHANISM IS DETECTABLE. `spawn` returning without throwing does not
- * mean `xclip` exists, and an OSC 52 sequence a terminal ignores is
- * indistinguishable from one it honours. The return value therefore names what
- * was ATTEMPTED, and every caller's user-facing text is worded accordingly.
- */
-export declare function copyText(text: string, write?: (chunk: string) => void): CopyVia;
+/** Start a copy without rejecting; result and writer release are separate signals. */
+export declare function startClipboardTask(text: string, options?: ClipboardOptions): ClipboardTask;
+/** Promise convenience wrapper; interactive callers must use the shared coordinator. */
+export declare function copyText(text: string, options?: ClipboardOptions): Promise<CopyResult>;

package/dist/ui/clipboard.js

@@ -1,91 +1,157 @@
-/**
- * Clipboard (tui-selection-and-scroll-follow §4.4.5) — the SINGLE clipboard path
- * for the package. `/copy` and the selection release both come through here.
- *
- * Two mechanisms, both attempted, and the return value names the better one so
- * the toast can say what was SENT rather than claiming a success neither one can
- * confirm:
- *
- *  1. **OSC 52.** It reaches the clipboard of the machine the USER is sitting
- *     at, which is the only correct target over SSH, and it is the only mechanism
- *     that works with no helper binary installed. `/copy` gained SSH support the
- *     moment it moved onto this module.
- *  2. **The platform binary** (`clip` / `pbcopy` / `xclip`), moved here unchanged
- *     from `commands/builtins.ts`, for the local case and for terminals that
- *     ignore OSC 52 (tmux without `set -g set-clipboard on`, R-7).
- *
- * IT TAKES A WRITE *DOOR*, NOT A STREAM, and that is P1-6 rather than taste. In
- * full-screen mode stdout is a `Proxy` in front of the frame differ; an
- * unrecognised chunk there takes `passThrough(true)`, which increments
- * `fallbacks` and — on the first one — raises `onFirstFallback`, wired to
- * `console.warn(FRAME_FALLBACK_NOTICE)`. Sending OSC 52 through the proxy would
- * therefore print a diagnostic at a user who did nothing wrong the first time
- * they copied anything, and would permanently corrupt a counter documented to
- * mean "something wrote to stdout behind Ink's back". The caller supplies
- * `writeForeign` instead, and this module cannot pick the wrong door.
- */
+/** The only clipboard writer. Interaction callers share clipboard-task's coordinator. */
 import { spawn } from 'node:child_process';
 import process from 'node:process';
-/**
- * Ceiling on an OSC 52 payload, in bytes of the ORIGINAL text.
- *
- * xterm's default limit is around 100 000 BASE64 characters and tmux / screen
- * are stricter, so 56 000 source bytes (~74 700 base64) stays inside all three
- * with room to spare. Past it the sequence is skipped rather than truncated: a
- * terminal that drops an over-long OSC 52 leaves the clipboard holding whatever
- * was there before, and half a selection is worse than none.
- */
 export const MAX_OSC52_BYTES = 56_000;
-/** `\x1b]52;c;<base64>\x07` — `c` is the CLIPBOARD selection, not PRIMARY. */
+const CLEANUP_GRACE_MS = 500;
+// clip.exe preserves a supplied BOM and guesses BOM-less UTF-16 incorrectly for
+// short CJK text. Decode stdin explicitly; never interpolate clipboard content.
+const WINDOWS_CLIPBOARD_COMMAND = "$ErrorActionPreference='Stop'; "
+    + '$reader=[IO.StreamReader]::new([Console]::OpenStandardInput(),'
+    + '[Text.UTF8Encoding]::new($false),$false); Set-Clipboard -Value $reader.ReadToEnd()';
+/** Encode the full clipboard selection as UTF-8, without truncating its payload. */
 export function osc52(text) {
-    return `\x1b]52;c;${Buffer.from(text, 'utf-8').toString('base64')}\x07`;
+    return `\x1b]52;c;${Buffer.from(text, 'utf8').toString('base64')}\x07`;
 }
-/** Best-effort clipboard copy via the platform's clipboard CLI. */
-function copyNative(text) {
-    const cmd = process.platform === 'win32'
-        ? { file: 'clip', args: [] }
-        : process.platform === 'darwin'
-            ? { file: 'pbcopy', args: [] }
-            : { file: 'xclip', args: ['-selection', 'clipboard'] };
+function sendOsc52(text, options, fallbackReason) {
+    if (options.signal?.aborted)
+        return { status: 'failed', reason: 'cancelled' };
+    if (Buffer.byteLength(text, 'utf8') > MAX_OSC52_BYTES) {
+        return { status: 'failed', reason: 'too-large' };
+    }
+    if (!options.write)
+        return { status: 'failed', reason: fallbackReason ?? 'unavailable' };
     try {
-        const child = spawn(cmd.file, cmd.args, { stdio: ['pipe', 'ignore', 'ignore'] });
-        child.on('error', () => {
-            /* swallow — clipboard is best-effort, and a missing xclip is ordinary */
-        });
-        child.stdin?.end(text);
-        return true;
+        options.write(osc52(text));
+        return { status: 'sent', via: 'osc52', ...(fallbackReason ? { fallbackReason } : {}) };
     }
     catch {
-        return false;
+        return { status: 'failed', reason: 'write' };
     }
 }
-/**
- * Put `text` on the clipboard and report the best mechanism that was reached.
- *
- * `write` is the foreign-write door (see the module header). Omit it and OSC 52
- * is skipped entirely, which is the correct behaviour for a caller that has no
- * terminal to write to.
- *
- * NEITHER MECHANISM IS DETECTABLE. `spawn` returning without throwing does not
- * mean `xclip` exists, and an OSC 52 sequence a terminal ignores is
- * indistinguishable from one it honours. The return value therefore names what
- * was ATTEMPTED, and every caller's user-facing text is worded accordingly.
- */
-export function copyText(text, write) {
-    if (text.length === 0)
-        return 'none';
-    let sentOsc52 = false;
-    if (write && Buffer.byteLength(text, 'utf-8') <= MAX_OSC52_BYTES) {
+function settledTask(result) {
+    return { result: Promise.resolve(result), released: Promise.resolve() };
+}
+function spawnNative() {
+    const windows = process.platform === 'win32';
+    const file = windows ? 'powershell.exe' : process.platform === 'darwin' ? 'pbcopy' : 'xclip';
+    const args = windows
+        ? ['-NoProfile', '-NonInteractive', '-STA', '-Command', WINDOWS_CLIPBOARD_COMMAND]
+        : file === 'xclip' ? ['-selection', 'clipboard'] : [];
+    return spawn(file, args, {
+        stdio: ['pipe', 'ignore', 'ignore'], shell: false, windowsHide: true,
+    });
+}
+/** Owns a writer through close, even when its user-facing result timed out earlier. */
+class NativeClipboardTask {
+    child;
+    text;
+    options;
+    result;
+    released;
+    resolveResult;
+    resolveReleased;
+    settled = false;
+    closed = false;
+    stopping = false;
+    failure;
+    timer;
+    cleanupTimer;
+    constructor(child, text, options) {
+        this.child = child;
+        this.text = text;
+        this.options = options;
+        this.result = new Promise((resolve) => { this.resolveResult = resolve; });
+        this.released = new Promise((resolve) => { this.resolveReleased = resolve; });
+        child.on('error', this.onError);
+        child.once('close', this.onClose);
+        child.stdin?.on('error', this.onStdinError);
+        options.signal?.addEventListener('abort', this.onAbort, { once: true });
+        this.timer = setTimeout(() => this.stop('timeout'), options.timeoutMs ?? 1500);
+        if (options.signal?.aborted) {
+            this.onAbort();
+            return;
+        }
+        if (!child.stdin) {
+            this.stop('write');
+            return;
+        }
         try {
-            write(osc52(text));
-            sentOsc52 = true;
+            child.stdin.end(Buffer.from(text, 'utf8'));
         }
         catch {
-            // A closed or broken stdout must never turn a copy into a crash.
+            this.stop('write');
         }
     }
-    const sentNative = copyNative(text);
-    if (sentOsc52)
-        return 'osc52';
-    return sentNative ? 'native' : 'none';
+    settle(result) {
+        if (this.settled)
+            return;
+        this.settled = true;
+        clearTimeout(this.timer);
+        clearTimeout(this.cleanupTimer);
+        this.resolveResult(result);
+    }
+    stop(reason) {
+        if (this.closed || this.stopping)
+            return;
+        this.stopping = true;
+        this.failure = reason;
+        clearTimeout(this.timer);
+        // No fallback before close: even a successful kill request is not proof of exit.
+        if (!this.settled) {
+            this.cleanupTimer = setTimeout(() => {
+                this.settle({ status: 'failed', reason });
+            }, CLEANUP_GRACE_MS);
+        }
+        try {
+            this.child.stdin?.destroy();
+        }
+        catch { /* Keep error listeners until close. */ }
+        try {
+            this.child.kill();
+        }
+        catch { /* A failed kill must not release the writer lock. */ }
+    }
+    onAbort = () => {
+        this.settle({ status: 'failed', reason: 'cancelled' });
+        this.stop('cancelled');
+    };
+    onError = () => { this.stop('unavailable'); };
+    onStdinError = () => { this.stop('write'); };
+    onClose = (code) => {
+        this.closed = true;
+        clearTimeout(this.timer);
+        clearTimeout(this.cleanupTimer);
+        this.options.signal?.removeEventListener('abort', this.onAbort);
+        if (!this.settled) {
+            const result = code === 0 && !this.failure
+                ? { status: 'confirmed', via: 'native' }
+                : sendOsc52(this.text, this.options, this.failure ?? 'write');
+            this.settle(result);
+        }
+        this.child.removeListener('error', this.onError);
+        this.child.stdin?.removeListener('error', this.onStdinError);
+        this.resolveReleased();
+    };
+}
+/** Start a copy without rejecting; result and writer release are separate signals. */
+export function startClipboardTask(text, options = {}) {
+    if (options.signal?.aborted)
+        return settledTask({ status: 'failed', reason: 'cancelled' });
+    if (text.length === 0)
+        return settledTask({ status: 'failed', reason: 'empty' });
+    const remote = options.remote ?? Boolean(process.env.SSH_CONNECTION || process.env.SSH_TTY);
+    if (remote)
+        return settledTask(sendOsc52(text, options));
+    let child;
+    try {
+        child = spawnNative();
+    }
+    catch {
+        return settledTask(sendOsc52(text, options, 'unavailable'));
+    }
+    return new NativeClipboardTask(child, text, options);
+}
+/** Promise convenience wrapper; interactive callers must use the shared coordinator. */
+export function copyText(text, options = {}) {
+    return startClipboardTask(text, options).result;
 }

package/dist/ui/composer-input.d.ts

@@ -0,0 +1,28 @@
+import { type EditorState, type InputSegment } from './editor-reducer.js';
+export interface ComposerSubmitResult {
+    accepted: boolean;
+    reason?: string;
+}
+export type ComposerInputIntent = InputSegment | {
+    kind: 'newline';
+} | {
+    kind: 'submit';
+};
+export interface ComposerInputOptions {
+    editor: EditorState;
+    intents: readonly ComposerInputIntent[];
+    resolveSubmit: (editor: EditorState) => string | null;
+    checkPasteLimit: (segments: InputSegment[], editor: EditorState) => string | null;
+}
+export interface ComposerInputPlan {
+    nextEditor: EditorState;
+    rejectedEditor: EditorState;
+    submission?: string;
+    notice?: string;
+    refusal?: string;
+}
+/**
+ * Plan both accepted and rejected drafts before any submission side effect.
+ * Uses caller-assigned paste IDs and pure callbacks; never mutates the source editor.
+ */
+export declare function planComposerInput(options: ComposerInputOptions): ComposerInputPlan;

package/dist/ui/composer-input.js

@@ -0,0 +1,46 @@
+import { editorReducer } from './editor-reducer.js';
+const MORE_INPUT_NOTICE = 'More input is kept in the draft; press Enter to send.';
+/**
+ * Plan both accepted and rejected drafts before any submission side effect.
+ * Uses caller-assigned paste IDs and pure callbacks; never mutates the source editor.
+ */
+export function planComposerInput(options) {
+    let nextEditor = options.editor;
+    let rejectedEditor = options.editor;
+    let acceptedBase = options.editor;
+    let acceptedPastes = [];
+    const rejectedPastes = [];
+    let submission;
+    let notice;
+    for (const intent of options.intents) {
+        if (intent.kind === 'submit') {
+            const text = options.resolveSubmit(nextEditor);
+            if (submission !== undefined) {
+                notice = MORE_INPUT_NOTICE;
+            }
+            else if (text !== null && text.trim().length > 0) {
+                submission = text;
+                nextEditor = editorReducer(nextEditor, { type: 'clear' });
+                acceptedBase = nextEditor;
+                acceptedPastes = [];
+            }
+            continue;
+        }
+        const segment = intent.kind === 'newline'
+            ? { kind: 'text', text: '\n' } : intent;
+        const segments = [segment];
+        if (segment.kind === 'paste') {
+            // Inline pastes have no map entry; count every paste in this callback as before.
+            acceptedPastes.push(segment);
+            rejectedPastes.push(segment);
+            const refusal = options.checkPasteLimit(acceptedPastes, acceptedBase)
+                ?? options.checkPasteLimit(rejectedPastes, options.editor);
+            if (refusal) {
+                return { nextEditor: options.editor, rejectedEditor: options.editor, refusal };
+            }
+        }
+        nextEditor = editorReducer(nextEditor, { type: 'input', segments });
+        rejectedEditor = editorReducer(rejectedEditor, { type: 'input', segments });
+    }
+    return { nextEditor, rejectedEditor, submission, notice };
+}