lazyclaw 6.3.1 → 6.5.0

package/tui/repl.mjs

@@ -38,173 +38,23 @@ import { Splash, renderSplashToString } from './splash.mjs';
 import { Editor } from './editor.mjs';
 import { SlashPopup, filterSlashCommands } from './slash_popup.mjs';
 import { SLASH_COMMANDS } from './slash_commands.mjs';
+import { argSpecFor } from './slash_args.mjs';
 import { ModalPicker, filterModalItems, resolveModalPick } from './modal_picker.mjs';
 import { theme } from './theme.mjs';
-
-// ─── Alt-buffer mount (DEC 1049) ─────────────────────────────────────────
-//
-// Wraps the React tree with mount/unmount side-effects that enable the
-// terminal alternate screen buffer. Three-layer cleanup so the user never
-// gets stranded on the alt canvas:
-//   1. React unmount → useEffect return-fn writes \x1b[?1049l
-//   2. Rude shutdown (SIGINT/SIGTERM/SIGHUP/'exit') → same escape via
-//      process-level listeners that we install + remove on unmount.
-//   3. cursor-visible safety on unmount (\x1b[?25h) in case anything
-//      below us turned it off.
-//
-// We deliberately do NOT install an uncaughtException handler — Ink
-// already installs one and re-throws; ours would swallow the stack
-// trace (violates §1 Truthfulness / no silent catch).
-//
-// `enabled` is false for non-TTY pipelines, CI, ink-testing-library, and
-// the LAZYCLAW_NO_ALT escape hatch. When false this is a pass-through —
-// no escape sequences leak into stdout.
-export const ALT_BUFFER_ENTER = '\x1b[?1049h';
-export const ALT_BUFFER_LEAVE = '\x1b[?1049l';
-export const CURSOR_VISIBLE   = '\x1b[?25h';
-
-// Rendering-mode decision. Default = Static scrollback (no flicker; splash
-// prints once + scrolls naturally). Alt-buffer fullscreen is opt-in via
-// LAZYCLAW_ALT=1; LAZYCLAW_NO_ALT=1 forces it off. TTY-only either way.
-export function computeAltEnabled(env, hasTTY) {
-  const e = env || {};
-  return !!hasTTY && !!e.LAZYCLAW_ALT && !e.LAZYCLAW_NO_ALT;
-}
-
-export function FullScreen({ enabled, children }) {
-  useEffect(() => {
-    if (!enabled) return undefined;
-    // Mount: enter alternate screen buffer.
-    try { process.stdout.write(ALT_BUFFER_ENTER); } catch { /* swallow — stdout closed */ }
-
-    // Rude-shutdown listeners. Each writes 1049l + cursor-visible so the
-    // terminal is restored even if React never gets a chance to unmount
-    // (e.g. parent process kills us with SIGTERM).
-    const restore = () => {
-      try { process.stdout.write(ALT_BUFFER_LEAVE + CURSOR_VISIBLE); } catch {}
-    };
-    const onExit = () => { restore(); };
-    const onSignal = () => { restore(); };
-    process.once('exit', onExit);
-    process.once('SIGINT', onSignal);
-    process.once('SIGTERM', onSignal);
-    process.once('SIGHUP', onSignal);
-
-    return () => {
-      // React unmount: restore primary buffer.
-      restore();
-      process.removeListener('exit', onExit);
-      process.removeListener('SIGINT', onSignal);
-      process.removeListener('SIGTERM', onSignal);
-      process.removeListener('SIGHUP', onSignal);
-    };
-  }, [enabled]);
-  return children;
-}
-
-// ─── Pure state ──────────────────────────────────────────────────────────
-//
-// makeReplState stays callable with zero args (existing tests rely on it).
-// The new fields default to empty so legacy callers see no behavior change.
-export function makeReplState(opts) {
-  const splashItem = opts && opts.splashItem ? opts.splashItem : null;
-  return {
-    streaming: false,
-    controller: null,
-    pendingPrepend: null,
-    nextTurnFirstMessage: null,
-    history: [],
-    scrollback: splashItem ? [splashItem] : [],
-    liveAssistant: '',
-    turnCounter: 0,
-  };
-}
-
-export function onUserInput(state, { text, controller }) {
-  if (state.streaming && state.controller) {
-    // mid-stream interrupt — abort current turn, queue text for next turn.
-    try { state.controller.abort(); } catch {}
-    return { ...state, pendingPrepend: text };
-  }
-  // idle — start a new turn. Append a 'user' entry to scrollback so the
-  // sticky-layout caller sees the prompt history above the live stream.
-  const id = `u-${state.turnCounter}`;
-  return {
-    ...state,
-    streaming: true,
-    controller,
-    history: [...state.history, text],
-    scrollback: [...state.scrollback, { kind: 'user', id, text }],
-    turnCounter: state.turnCounter + 1,
-  };
-}
-
-export function onEscape(state) {
-  if (state.streaming && state.controller) {
-    try { state.controller.abort(); } catch {}
-  }
-  // Drop any partial live assistant text on explicit Esc — the user is
-  // telling us to discard, not to keep.
-  return {
-    ...state,
-    streaming: false,
-    controller: null,
-    pendingPrepend: null,
-    liveAssistant: '',
-  };
-}
-
-// Stream chunk arrives. Completed lines are committed to the <Static>
-// scrollback immediately (so they scroll up ABOVE the sticky editor), and only
-// the in-progress trailing partial stays in the live region. Without this, a
-// reply taller than the terminal grew the live frame past the viewport and
-// spilled BELOW the input box (long orchestrator replies). Chunks without a
-// newline still just accumulate (the prior behaviour), so short replies and the
-// existing reducer tests are unchanged.
-export function onStreamChunk(state, { chunk }) {
-  const buf = state.liveAssistant + chunk;
-  const nl = buf.lastIndexOf('\n');
-  if (nl < 0) return { ...state, liveAssistant: buf };
-  const complete = buf.slice(0, nl);          // one or more whole lines
-  const remainder = buf.slice(nl + 1);        // trailing partial (may be '')
-  const id = `as-${state.turnCounter}-${state.scrollback.length}`;
-  return {
-    ...state,
-    scrollback: [...state.scrollback, { kind: 'assistant', id, text: complete }],
-    liveAssistant: remainder,
-  };
-}
-
-export function onTurnComplete(state, { reason, error } = {}) {
-  const promoted = state.pendingPrepend;
-  const suffix = reason === 'aborted' ? ' [aborted]'
-              : reason === 'error'   ? (error ? ` [error: ${error}]` : ' [error]')
-              : '';
-  const text = (state.liveAssistant || '') + suffix;
-  // Commit any accumulated live text to scrollback. If the turn produced
-  // nothing AND wasn't an error/abort, skip the empty append.
-  const shouldCommit = text.length > 0 && (state.liveAssistant.length > 0 || suffix.length > 0);
-  const id = `a-${state.turnCounter}`;
-  const kind = reason === 'error' ? 'error' : 'assistant';
-  const nextScrollback = shouldCommit
-    ? [...state.scrollback, { kind, id, text }]
-    : state.scrollback;
-  return {
-    ...state,
-    streaming: false,
-    controller: null,
-    pendingPrepend: null,
-    nextTurnFirstMessage: promoted,
-    liveAssistant: '',
-    scrollback: nextScrollback,
-    turnCounter: state.turnCounter + 1,
-  };
-}
-
-export function consumeNextTurnFirstMessage(state) {
-  const msg = state.nextTurnFirstMessage;
-  return [{ ...state, nextTurnFirstMessage: null }, msg];
-}
+import { StatusBar } from './status_bar.mjs';
+import { onConversationReset, clearTerminalScreen } from './repl_reset.mjs'; export { StatusBar };
+// Alt-buffer (DEC 1049) mount cluster moved to ./repl_altbuffer.mjs and pure
+// state reducers moved to ./repl_reducers.mjs (file-size gate). Re-exported so
+// every existing caller + test sees them on repl.mjs, and imported locally
+// because the ReplApp body binds them directly.
+import { computeAltEnabled, FullScreen } from './repl_altbuffer.mjs';
+export { ALT_BUFFER_ENTER, ALT_BUFFER_LEAVE, CURSOR_VISIBLE, computeAltEnabled, FullScreen } from './repl_altbuffer.mjs';
+import {
+  makeReplState, onUserInput, onEscape, onStreamChunk, onTurnComplete,
+} from './repl_reducers.mjs';
+export {
+  makeReplState, onUserInput, onEscape, onStreamChunk, onTurnComplete, consumeNextTurnFirstMessage,
+} from './repl_reducers.mjs';
 
 // ─── React mount ─────────────────────────────────────────────────────────
 //
@@ -212,7 +62,7 @@ export function consumeNextTurnFirstMessage(state) {
 //   - runTurnFactory(writeFn) → runTurn(text, signal)   (sticky layout)
 //   - runTurn(text, signal)                              (legacy, stdout)
 // Legacy mode is preserved verbatim for the existing cli.mjs callsite.
-export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, onSlashCommand, statusInfo, getStatus, pickerRef }) {
+export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, onSlashCommand, onArgComplete, onArgList, statusInfo, getStatus, pickerRef }) {
   // statusInfo seeds the StatusBar's provider/model/ctx. getStatus (optional)
   // returns the live values so the bar refreshes after a /provider or /model
   // switch and after each turn (token/ctx gauge) — without it the bar would
@@ -255,7 +105,7 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
   // sticky-bottom Editor actually pins. Non-alt mode keeps the legacy
   // content-sized layout so existing tests + non-TTY fallbacks behave
   // identically. Listen for SIGWINCH-driven resize events.
-  const { stdout } = useStdout();
+  const { stdout, write: writeStdout } = useStdout();
   const [rows, setRows] = useState(() => (stdout && stdout.rows) || 24);
   useEffect(() => {
     if (!stdout) return undefined;
@@ -305,6 +155,7 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
         // when the user hits Esc (onEscape aborts state.controller).
         const result = await onSlashCommand(trimmed, controller.signal);
         if (result === 'EXIT') { exit(); return; }
+        if (result === 'NEW') { clearTerminalScreen(writeStdout); setState((s) => onConversationReset(s)); refreshStatus(); return; } // /new: wipe screen + scrollback so it visually starts over
         if (typeof result === 'string' && result.length > 0) {
           setState((s) => onStreamChunk(s, { chunk: result }));
         }
@@ -330,7 +181,7 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
         reason: err && err.name === 'AbortError' ? 'aborted' : 'error',
       }));
     }
-  }, [exit, onSlashCommand, refreshStatus]);
+  }, [exit, onSlashCommand, refreshStatus, writeStdout]);
 
   // Auto-submit queued mid-stream-interrupt message (spec §5.8). Read
   // state.nextTurnFirstMessage so the effect re-fires when promoted.
@@ -347,6 +198,11 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
     setState((s) => onEscape(s));
   }, []);
 
+  // v6.4 — 2-stage Ctrl+C exit handler. First Ctrl+C reuses onEscapeKey
+  // (cancel in-flight turn + clear, same reducer as Esc); a second press
+  // within the Editor's window calls onExit. Active when exitOnCtrlC:false.
+  const onExitKey = useCallback(() => { exit(); }, [exit]);
+
   // ─── Slash popup state (v5.4) ──────────────────────────────────────
   // The editor reports its current buffer via onBufferChange; we derive
   // the filtered command list from that and own the selection index.
@@ -357,44 +213,66 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
   );
   const [bufferPeek, setBufferPeek] = useState('');
   const [selectedSuggestion, setSelectedSuggestion] = useState(0);
+  const activeLenRef = useRef(0); // length of whatever popup list is active (commands or arg candidates)
   const filtered = useMemo(
     () => filterSlashCommands(bufferPeek, catalog),
     [bufferPeek, catalog]
   );
-  // Reset selection whenever the match list changes length (typing
-  // narrows results, so highlight the first row again).
-  const lastLenRef = useRef(0);
-  useEffect(() => {
-    if (filtered.length !== lastLenRef.current) {
-      setSelectedSuggestion(0);
-      lastLenRef.current = filtered.length;
-    } else if (selectedSuggestion >= filtered.length) {
-      setSelectedSuggestion(Math.max(0, filtered.length - 1));
-    }
-  }, [filtered.length, selectedSuggestion]);
 
   const handleBufferChange = useCallback((buf) => {
     setBufferPeek(buf || '');
   }, []);
   const handleSlashMove = useCallback((delta) => {
     setSelectedSuggestion((i) => {
-      const max = Math.max(0, filtered.length - 1);
+      const max = Math.max(0, activeLenRef.current - 1);
       const n = i + delta;
       if (n < 0) return 0;
       if (n > max) return max;
       return n;
     });
-  }, [filtered.length]);
+  }, []);
   const handleSlashDismiss = useCallback(() => {
     setBufferPeek('');
     setSelectedSuggestion(0);
   }, []);
 
-  // Hide the popup when the buffer already exactly matches the only
-  // remaining suggestion (with or without a trailing space). Otherwise
-  // the popup intercepts Enter and the fully-typed command (e.g.
-  // '/exit') never reaches handleSubmit. Belt-and-suspenders with the
-  // editor-side fall-through in tui/editor.mjs.
+  // ─── Slash-argument completion (v6.x) ──────────────────────────────
+  // argSpec resolves what (if anything) is completable after the command.
+  //   kind 'inline' → candidates render in the popup (onArgList → argList);
+  //                   ↑/↓ select, Tab/Enter fill the token (fillArgToken).
+  //   kind 'modal'  → a "↹ pick" hint shows; Tab opens the drill-in picker
+  //                   (handleArgComplete → onArgComplete → argInject).
+  const argSpec = useMemo(
+    () => argSpecFor(bufferPeek, catalog),
+    [bufferPeek, catalog],
+  );
+  const [argList, setArgList] = useState([]);
+  useEffect(() => {
+    let cancelled = false;
+    if (argSpec && argSpec.kind === 'inline' && typeof onArgList === 'function') {
+      Promise.resolve(onArgList(bufferPeek))
+        .then((items) => { if (!cancelled) setArgList(Array.isArray(items) ? items : []); })
+        .catch(() => { if (!cancelled) setArgList([]); });
+    } else {
+      setArgList((prev) => (prev.length ? [] : prev));
+    }
+    return () => { cancelled = true; };
+  }, [bufferPeek, argSpec, onArgList]);
+  const argCompletable = !!argSpec && argSpec.kind === 'modal' && typeof onArgComplete === 'function';
+  const [argInject, setArgInject] = useState(null);
+  const argNonceRef = useRef(0);
+  const handleArgComplete = useCallback(async (buf) => {
+    if (typeof onArgComplete !== 'function') return;
+    let value = null;
+    try { value = await onArgComplete(buf); } catch { value = null; }
+    if (typeof value === 'string' && value) {
+      argNonceRef.current += 1;
+      setArgInject({ value, nonce: argNonceRef.current });
+    }
+  }, [onArgComplete]);
+
+  // Hide the command popup when the buffer already exactly matches the only
+  // remaining suggestion (so Enter submits /exit etc. instead of re-filling).
   const _bufTrimmed = bufferPeek.replace(/\s+$/, '');
   const _exactOnly =
     filtered.length === 1 &&
@@ -434,6 +312,9 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
         subtitle: opts.subtitle || '',
         items: Array.isArray(opts.items) ? opts.items : [],
         searchable: opts.searchable !== false,
+        // Carry the secret flag so a credential entry (api-key / token) masks
+        // the typed query — dropping it here echoed the secret in plaintext.
+        secret: !!opts.secret,
         resolve,
       });
     });
@@ -478,16 +359,34 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
   }, []);
   const modalOpen = !!modal;
 
-  // Slash popup is suppressed whenever a modal picker is active so the
-  // overlays don't stack, AND once the buffer has a space (the user is typing
-  // ARGS, e.g. `/orchestrator off`). Without the space guard the popup stayed
-  // open as a one-row hint and the editor treated Enter as "fill the matched
-  // command", which dropped the args and reverted the buffer to the bare
-  // command. With args, Enter must submit the full line instead.
-  const showSlashPopup =
+  // Command popup (no space) vs inline-arg popup (has space + an inline spec) —
+  // mutually exclusive via the space. Both feed the same Editor/SlashPopup
+  // machinery; slashFillMode tells the Editor which fill to apply (whole
+  // command vs the arg token). Modal-kind args show a hint instead (Tab opens
+  // the drill-in picker). Suppressed entirely while a modal picker is up.
+  const cmdPopup =
     !modalOpen &&
     bufferPeek.startsWith('/') && bufferPeek.indexOf(' ') < 0 &&
     filtered.length > 0 && !_exactOnly;
+  const argPopup = !modalOpen && !cmdPopup && !!argSpec && argSpec.kind === 'inline' && argList.length > 0;
+  const popupRows = cmdPopup
+    ? filtered
+    : argPopup
+      ? argList.map((i) => ({ cmd: i.value, help: i.desc || '' }))
+      : [];
+  const showSlashPopup = popupRows.length > 0;
+  const slashFillMode = argPopup ? 'arg' : 'command';
+  activeLenRef.current = popupRows.length;
+  // Reset / clamp the highlighted row when the active list changes.
+  const lastLenRef = useRef(0);
+  useEffect(() => {
+    if (popupRows.length !== lastLenRef.current) {
+      setSelectedSuggestion(0);
+      lastLenRef.current = popupRows.length;
+    } else if (selectedSuggestion >= popupRows.length) {
+      setSelectedSuggestion(Math.max(0, popupRows.length - 1));
+    }
+  }, [popupRows.length, selectedSuggestion]);
 
   // Outer column height: pinned to rows-1 in alt-buffer mode so the
   // Editor truly sticks to the bottom. Non-alt keeps content-sized layout
@@ -554,10 +453,21 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
       showSlashPopup
         ? React.createElement(SlashPopup, {
             buffer: bufferPeek,
-            commands: filtered,
+            commands: popupRows,
             selectedIndex: selectedSuggestion,
+            forceChooser: slashFillMode === 'arg',
           })
         : null,
+      // 3a) Modal-kind arg hint — for 2-step specs (/model, /trainer set,
+      //     /orchestrator planner) Tab opens the drill-in picker. Inline-kind
+      //     args render their candidates in the popup above instead.
+      (!showSlashPopup && argSpec && argSpec.kind === 'modal' && !modalOpen)
+        ? React.createElement(
+            Box,
+            { paddingX: 1, key: 'arghint' },
+            React.createElement(Text, { dimColor: true }, `↹ pick ${argSpec.name}`)
+          )
+        : null,
       // 3b) Modal picker (v5.4.3) — flex sibling above StatusBar, only
       //     visible while ReplApp's `modal` state is set. Suppresses the
       //     slash popup so the overlays don't stack.
@@ -569,6 +479,7 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
             selectedIndex: modalIdx,
             query: modalQuery,
             searchable: modal.searchable,
+            secret: modal.secret,
           })
         : null,
       // 4) Status bar (sticky, single row above input). flexShrink:0 so
@@ -579,6 +490,7 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
         streaming: state.streaming,
         ctxUsed: _status.ctxUsed,
         ctxTotal: _status.ctxTotal,
+        hud: _status.hud,
       }),
       // 5) Editor — sticky bottom, content-sized. Wrapped in a flexShrink:0
       //    Box so Yoga doesn't squeeze the input row when scrollback fills.
@@ -590,10 +502,19 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
           onSubmit: handleSubmit,
           onEscape: onEscapeKey,
           onBufferChange: handleBufferChange,
-          slashSuggestions: showSlashPopup ? filtered : null,
+          // v6.4 — 2-stage Ctrl+C wiring (active when exitOnCtrlC:false).
+          onInterrupt: onEscapeKey,
+          onExit: onExitKey,
+          slashSuggestions: showSlashPopup ? popupRows : null,
           slashSelectedIndex: selectedSuggestion,
+          slashFillMode,
           onSlashMove: handleSlashMove,
           onSlashDismiss: handleSlashDismiss,
+          // v6.x slash-argument completion (inline fills the token; modal kind
+          // uses argCompletable+onArgComplete to open the drill-in picker).
+          argCompletable,
+          onArgComplete: handleArgComplete,
+          argInject,
           // v5.4.3 — modal picker key contract. When modalOpen the
           // Editor swallows all keys (no buffer mutation, no submit).
           modalOpen,
@@ -640,20 +561,8 @@ export const ScrollbackItem = React.memo(function ScrollbackItem({ item }) {
   return React.createElement(Text, { color: theme.fg }, item.text);
 });
 
-// StatusBar — single row, provider · model · ctx · streaming indicator.
-// Kept intentionally minimal in v5.3; token gauges land separately once
-// usage metrics flow into state.
-export function StatusBar({ provider, model, streaming, ctxUsed, ctxTotal }) {
-  const ctx = (ctxUsed != null && ctxTotal != null) ? `${ctxUsed}/${ctxTotal}` : '--';
-  const indicator = streaming ? theme.accent('● streaming') : theme.dim('○ idle');
-  const prov = provider || '?';
-  const mdl = model || '?';
-  return React.createElement(
-    Box,
-    { flexShrink: 0, paddingX: 1 },
-    React.createElement(Text, null, `${indicator}  ${prov} · ${mdl}  ctx ${ctx}`)
-  );
-}
+// StatusBar moved to ./status_bar.mjs (re-exported above) so the HUD row can
+// grow without pushing repl.mjs over the file-size ratchet.
 
 // Exported for tests that want to verify the splash snapshot without a TTY.
 export function _renderSplashToString(splashProps) {

package/tui/repl_altbuffer.mjs

@@ -0,0 +1,63 @@
+// tui/repl_altbuffer.mjs — alt-buffer (DEC 1049) mount cluster for the REPL.
+//
+// Extracted verbatim from repl.mjs (file-size gate). Wraps the React tree
+// with mount/unmount side-effects that enable the terminal alternate screen
+// buffer. Three-layer cleanup so the user never gets stranded on the alt
+// canvas:
+//   1. React unmount → useEffect return-fn writes \x1b[?1049l
+//   2. Rude shutdown (SIGINT/SIGTERM/SIGHUP/'exit') → same escape via
+//      process-level listeners that we install + remove on unmount.
+//   3. cursor-visible safety on unmount (\x1b[?25h) in case anything
+//      below us turned it off.
+//
+// We deliberately do NOT install an uncaughtException handler — Ink
+// already installs one and re-throws; ours would swallow the stack
+// trace (violates §1 Truthfulness / no silent catch).
+//
+// `enabled` is false for non-TTY pipelines, CI, ink-testing-library, and
+// the LAZYCLAW_NO_ALT escape hatch. When false this is a pass-through —
+// no escape sequences leak into stdout.
+import { useEffect } from 'react';
+
+export const ALT_BUFFER_ENTER = '\x1b[?1049h';
+export const ALT_BUFFER_LEAVE = '\x1b[?1049l';
+export const CURSOR_VISIBLE   = '\x1b[?25h';
+
+// Rendering-mode decision. Default = Static scrollback (no flicker; splash
+// prints once + scrolls naturally). Alt-buffer fullscreen is opt-in via
+// LAZYCLAW_ALT=1; LAZYCLAW_NO_ALT=1 forces it off. TTY-only either way.
+export function computeAltEnabled(env, hasTTY) {
+  const e = env || {};
+  return !!hasTTY && !!e.LAZYCLAW_ALT && !e.LAZYCLAW_NO_ALT;
+}
+
+export function FullScreen({ enabled, children }) {
+  useEffect(() => {
+    if (!enabled) return undefined;
+    // Mount: enter alternate screen buffer.
+    try { process.stdout.write(ALT_BUFFER_ENTER); } catch { /* swallow — stdout closed */ }
+
+    // Rude-shutdown listeners. Each writes 1049l + cursor-visible so the
+    // terminal is restored even if React never gets a chance to unmount
+    // (e.g. parent process kills us with SIGTERM).
+    const restore = () => {
+      try { process.stdout.write(ALT_BUFFER_LEAVE + CURSOR_VISIBLE); } catch {}
+    };
+    const onExit = () => { restore(); };
+    const onSignal = () => { restore(); };
+    process.once('exit', onExit);
+    process.once('SIGINT', onSignal);
+    process.once('SIGTERM', onSignal);
+    process.once('SIGHUP', onSignal);
+
+    return () => {
+      // React unmount: restore primary buffer.
+      restore();
+      process.removeListener('exit', onExit);
+      process.removeListener('SIGINT', onSignal);
+      process.removeListener('SIGTERM', onSignal);
+      process.removeListener('SIGHUP', onSignal);
+    };
+  }, [enabled]);
+  return children;
+}

package/tui/repl_reducers.mjs

@@ -0,0 +1,114 @@
+// tui/repl_reducers.mjs — pure state reducers for the REPL host.
+//
+// Extracted verbatim from repl.mjs (file-size gate). These are pure
+// functions: no shared mutable module state, no JSX. They keep their
+// pre-v5.3 shapes — tests/phaseC-repl-interrupt.test.mjs depends on them.
+//
+// Backward-compat contracts (do not break):
+//   - makeReplState()              — still callable with zero args.
+//   - onUserInput, onEscape, onTurnComplete, consumeNextTurnFirstMessage
+//     keep their pre-v5.3 shapes.
+
+// ─── Pure state ──────────────────────────────────────────────────────────
+//
+// makeReplState stays callable with zero args (existing tests rely on it).
+// The new fields default to empty so legacy callers see no behavior change.
+export function makeReplState(opts) {
+  const splashItem = opts && opts.splashItem ? opts.splashItem : null;
+  return {
+    streaming: false,
+    controller: null,
+    pendingPrepend: null,
+    nextTurnFirstMessage: null,
+    history: [],
+    scrollback: splashItem ? [splashItem] : [],
+    liveAssistant: '',
+    turnCounter: 0,
+  };
+}
+
+export function onUserInput(state, { text, controller }) {
+  if (state.streaming && state.controller) {
+    // mid-stream interrupt — abort current turn, queue text for next turn.
+    try { state.controller.abort(); } catch {}
+    return { ...state, pendingPrepend: text };
+  }
+  // idle — start a new turn. Append a 'user' entry to scrollback so the
+  // sticky-layout caller sees the prompt history above the live stream.
+  const id = `u-${state.turnCounter}`;
+  return {
+    ...state,
+    streaming: true,
+    controller,
+    history: [...state.history, text],
+    scrollback: [...state.scrollback, { kind: 'user', id, text }],
+    turnCounter: state.turnCounter + 1,
+  };
+}
+
+export function onEscape(state) {
+  if (state.streaming && state.controller) {
+    try { state.controller.abort(); } catch {}
+  }
+  // Drop any partial live assistant text on explicit Esc — the user is
+  // telling us to discard, not to keep.
+  return {
+    ...state,
+    streaming: false,
+    controller: null,
+    pendingPrepend: null,
+    liveAssistant: '',
+  };
+}
+
+// Stream chunk arrives. Completed lines are committed to the <Static>
+// scrollback immediately (so they scroll up ABOVE the sticky editor), and only
+// the in-progress trailing partial stays in the live region. Without this, a
+// reply taller than the terminal grew the live frame past the viewport and
+// spilled BELOW the input box (long orchestrator replies). Chunks without a
+// newline still just accumulate (the prior behaviour), so short replies and the
+// existing reducer tests are unchanged.
+export function onStreamChunk(state, { chunk }) {
+  const buf = state.liveAssistant + chunk;
+  const nl = buf.lastIndexOf('\n');
+  if (nl < 0) return { ...state, liveAssistant: buf };
+  const complete = buf.slice(0, nl);          // one or more whole lines
+  const remainder = buf.slice(nl + 1);        // trailing partial (may be '')
+  const id = `as-${state.turnCounter}-${state.scrollback.length}`;
+  return {
+    ...state,
+    scrollback: [...state.scrollback, { kind: 'assistant', id, text: complete }],
+    liveAssistant: remainder,
+  };
+}
+
+export function onTurnComplete(state, { reason, error } = {}) {
+  const promoted = state.pendingPrepend;
+  const suffix = reason === 'aborted' ? ' [aborted]'
+              : reason === 'error'   ? (error ? ` [error: ${error}]` : ' [error]')
+              : '';
+  const text = (state.liveAssistant || '') + suffix;
+  // Commit any accumulated live text to scrollback. If the turn produced
+  // nothing AND wasn't an error/abort, skip the empty append.
+  const shouldCommit = text.length > 0 && (state.liveAssistant.length > 0 || suffix.length > 0);
+  const id = `a-${state.turnCounter}`;
+  const kind = reason === 'error' ? 'error' : 'assistant';
+  const nextScrollback = shouldCommit
+    ? [...state.scrollback, { kind, id, text }]
+    : state.scrollback;
+  return {
+    ...state,
+    streaming: false,
+    controller: null,
+    pendingPrepend: null,
+    nextTurnFirstMessage: promoted,
+    liveAssistant: '',
+    scrollback: nextScrollback,
+    turnCounter: state.turnCounter + 1,
+  };
+}
+
+export function consumeNextTurnFirstMessage(state) {
+  const msg = state.nextTurnFirstMessage;
+  return [{ ...state, nextTurnFirstMessage: null }, msg];
+}

package/tui/repl_reset.mjs

@@ -0,0 +1,37 @@
+// tui/repl_reset.mjs — pure reducer for the `/new` conversation reset.
+//
+// Lives in its own file (not repl.mjs) only because repl.mjs is at its
+// file-size ceiling (scripts/lint-file-size.mjs). It is the scrollback-clearing
+// counterpart to the dispatcher's in-memory reset: /new wiped ctx.setMessages
+// but left the <Static/> scrollback intact, so the old conversation stayed on
+// screen. This empties the scrollback back to the splash item (the established
+// fresh-start look) and drops any in-flight / live-region state.
+
+export function onConversationReset(state) {
+  // Keep the splash header so a reset screen looks like a fresh launch, not a
+  // blank void. Everything else (user lines, assistant replies, live partial)
+  // is discarded.
+  const splash = state.scrollback.find((it) => it && it.kind === 'splash') || null;
+  return {
+    ...state,
+    streaming: false,
+    controller: null,
+    pendingPrepend: null,
+    nextTurnFirstMessage: null,
+    liveAssistant: '',
+    history: [],
+    scrollback: splash ? [splash] : [],
+  };
+}
+
+// Erase the terminal screen + scrollback buffer. Resetting the React scrollback
+// state alone cannot un-print Ink's <Static/> output (it is write-once and
+// append-only), so /new must also wipe the physical terminal. `\x1b[3J` drops
+// the scrollback buffer so the old conversation can't be scrolled back to.
+// `write` is the Ink-provided useStdout().write (clears the live frame first).
+export const CLEAR_TERMINAL = '\x1b[2J\x1b[3J\x1b[H';
+export function clearTerminalScreen(write) {
+  if (typeof write === 'function') {
+    try { write(CLEAR_TERMINAL); } catch { /* swallow — stdout may be closed */ }
+  }
+}