lazyclaw 6.4.0 → 6.5.0

package/tui/editor_anchor.mjs

@@ -0,0 +1,46 @@
+// tui/editor_anchor.mjs — extracted IME cursor-anchor stdout shim (v5.4.4).
+// Pure leaf module: only touches process.stdout, imports nothing from
+// editor.mjs, so there is no circular import. The shared anchorState object
+// is a singleton — editor.mjs imports the same instance via this export.
+//
+// ─── IME cursor anchor (v5.4.4) ─────────────────────────────────────
+//
+// v5.4.3 shipped an anchor that moved the cursor inside the editor
+// after every render so IME pre-edit composition appeared in the
+// editor box. It also caused visible flicker because Ink's log-update
+// (node_modules/ink/build/log-update.js) emits an eraseLines sequence
+// (`\x1b[2K\x1b[1A...`) on every redraw — and that sequence walks UP
+// from the CURRENT cursor position. With our anchor up inside the
+// editor, eraseLines erased rows ABOVE the frame, then wrote the new
+// frame starting one editor-height higher than the previous one.
+//
+// v5.4.4 fix — monkey-patch process.stdout.write the first time the
+// anchor fires. When the patched writer sees a chunk that BEGINS with
+// `\x1b[2K` (the start of log-update's eraseLines) AND the anchor
+// offset is non-zero, it prepends `\x1b[<offset>B\r` to move the
+// cursor BACK DOWN to the row log-update expects (one below the
+// previous frame's last line). The user sees no flicker; IME still
+// reads the editor cursor position because the anchor lives across
+// the gap between renders.
+export const anchorState = { offset: 0, shimmed: false };
+
+export function installAnchorShim() {
+  if (anchorState.shimmed) return;
+  if (!(process.stdout && typeof process.stdout.write === 'function')) return;
+  const orig = process.stdout.write.bind(process.stdout);
+  process.stdout.write = function patchedWrite(chunk, ...rest) {
+    try {
+      if (
+        anchorState.offset > 0 &&
+        typeof chunk === 'string' &&
+        chunk.startsWith('\x1b[2K')
+      ) {
+        const off = anchorState.offset;
+        anchorState.offset = 0;
+        return orig.call(this, `\x1b[${off}B\r` + chunk, ...rest);
+      }
+    } catch { /* fall through to unmodified write */ }
+    return orig.call(this, chunk, ...rest);
+  };
+  anchorState.shimmed = true;
+}

package/tui/orchestrator_setup.mjs

@@ -0,0 +1,135 @@
+// tui/orchestrator_setup.mjs — the composite-provider (orchestrator) setup
+// wizard, extracted verbatim from tui/pickers.mjs. It builds
+// `cfg.orchestrator = { planner, workers, maxSubtasks }` interactively and
+// persists it.
+//
+// CIRCULAR IMPORT: this module imports _arrowMenu / _quickPrompt from
+// ./pickers.mjs, and pickers re-exports _setupOrchestratorInteractive from
+// here — a pickers ↔ orchestrator_setup cycle. It is safe because both helpers
+// are referenced at CALL TIME (inside the function body), never at module load,
+// and ES live bindings resolve them once pickers finishes loading. pickers puts
+// its re-export line at the bottom (after _arrowMenu/_quickPrompt are declared),
+// and both helpers are hoisted top-level function declarations.
+import { readConfig, writeConfig } from '../lib/config.mjs';
+import { getRegistry } from '../lib/registry_boot.mjs';
+import { paint } from './theme.mjs';
+import { _arrowMenu, _quickPrompt } from './pickers.mjs';
+
+// Step-3 alternative for composite providers (currently only the
+// orchestrator). Builds `cfg.orchestrator = { planner, workers,
+// maxSubtasks }` interactively and persists it before returning.
+//
+// planner: single picker over registered non-composite providers.
+// workers: multi-select with a running list + add/remove/done loop.
+// maxSubtasks: typed integer, default 5.
+export async function _setupOrchestratorInteractive() {
+  const accent = (s) => paint('38;5;208', s);
+  const dim    = (s) => paint('2', s);
+  const bold   = (s) => paint('1', s);
+  const ok     = (s) => paint('32', s);
+  const info = getRegistry().PROVIDER_INFO || {};
+  const eligibleNames = Object.keys(getRegistry().PROVIDERS).filter((n) => n !== 'orchestrator' && n !== 'mock');
+  if (eligibleNames.length === 0) {
+    process.stdout.write('\n' + accent('orchestrator setup') + ': no eligible workers — register a real provider first.\n');
+    await _quickPrompt('  press Enter to continue ');
+    return 'CANCEL';
+  }
+  const cfg = readConfig();
+  const existing = cfg.orchestrator && typeof cfg.orchestrator === 'object' ? cfg.orchestrator : {};
+
+  // ── Pick planner ─────────────────────────────────────────────────
+  const plannerItems = eligibleNames.map((name) => {
+    const m = info[name] || {};
+    const defaultModel = m.defaultModel || '';
+    return {
+      id: `${name}${defaultModel ? ':' + defaultModel : ''}`,
+      label: m.label && m.label !== name ? `${name} — ${m.label}` : name,
+      desc: defaultModel ? `default model: ${defaultModel}` : '',
+    };
+  });
+  const plannerPick = await _arrowMenu({
+    title: 'LazyClaw setup — Step 3 of 3:  orchestrator — pick the planner',
+    subtitle: 'The planner decomposes the user request into subtasks and writes the final synthesis. Strong reasoning models work best here.',
+    items: plannerItems,
+    searchable: true,
+    defaultIdx: Math.max(0, plannerItems.findIndex((p) => p.id === existing.planner)),
+  });
+  if (plannerPick === 'CANCEL') return 'CANCEL';
+  if (plannerPick === 'BACK')   return 'BACK';
+  const planner = plannerPick.id;
+
+  // ── Pick workers (iterative add/remove) ──────────────────────────
+  const workers = Array.isArray(existing.workers) ? existing.workers.slice() : [];
+  while (true) {
+    process.stdout.write('\x1b[2J\x1b[H');
+    process.stdout.write(accent('Orchestrator workers') + '\n');
+    process.stdout.write(dim('Subtasks are dispatched round-robin across this list.') + '\n\n');
+    if (workers.length === 0) {
+      process.stdout.write('  ' + dim('(none yet — add at least one)') + '\n\n');
+    } else {
+      workers.forEach((w, i) => {
+        process.stdout.write(`  ${i + 1}. ${ok(w)}\n`);
+      });
+      process.stdout.write('\n');
+    }
+    const items = [
+      { id: '__add__',    label: '+ Add a worker',     desc: 'pick from registered providers' },
+      { id: '__remove__', label: '- Remove a worker',  desc: workers.length ? 'pick which entry to drop' : '(nothing to remove)' },
+      { id: '__done__',   label: `Done${workers.length ? ` (${workers.length} worker${workers.length === 1 ? '' : 's'})` : ' — at least one worker required'}`, desc: workers.length ? 'save cfg.orchestrator and finish' : 'add one worker first' },
+    ];
+    const action = await _arrowMenu({
+      title: 'LazyClaw setup — orchestrator workers',
+      subtitle: `Planner: ${planner}`,
+      items,
+    });
+    if (action === 'CANCEL') return 'CANCEL';
+    if (action === 'BACK')   return 'BACK';
+    if (action.id === '__add__') {
+      const wPick = await _arrowMenu({
+        title: 'Add worker',
+        subtitle: 'Picked entries are appended to the workers list.',
+        items: plannerItems.filter((p) => !workers.includes(p.id)),
+        searchable: true,
+      });
+      if (wPick === 'CANCEL' || wPick === 'BACK') continue;
+      workers.push(wPick.id);
+      continue;
+    }
+    if (action.id === '__remove__') {
+      if (!workers.length) continue;
+      const rPick = await _arrowMenu({
+        title: 'Remove worker',
+        subtitle: 'Highlighted entry is removed from the list.',
+        items: workers.map((w) => ({ id: w, label: w })),
+      });
+      if (rPick === 'CANCEL' || rPick === 'BACK') continue;
+      const idx = workers.indexOf(rPick.id);
+      if (idx >= 0) workers.splice(idx, 1);
+      continue;
+    }
+    if (action.id === '__done__') {
+      if (workers.length === 0) continue;
+      break;
+    }
+  }
+
+  // ── maxSubtasks ──────────────────────────────────────────────────
+  const defaultMax = Number.isFinite(existing.maxSubtasks) && existing.maxSubtasks > 0
+    ? Math.min(10, existing.maxSubtasks)
+    : 5;
+  const rawMax = (await _quickPrompt(`  ${bold('maxSubtasks')} ${dim(`(2..10, blank → ${defaultMax}):`)} `)).trim();
+  let maxSubtasks = defaultMax;
+  if (rawMax) {
+    const n = parseInt(rawMax, 10);
+    if (Number.isFinite(n) && n >= 1) maxSubtasks = Math.min(10, Math.max(1, n));
+  }
+
+  // ── Persist ──────────────────────────────────────────────────────
+  cfg.orchestrator = { planner, workers, maxSubtasks };
+  writeConfig(cfg);
+  process.stdout.write('\n');
+  process.stdout.write(`  ${ok('✓ orchestrator saved')}  ${dim('→')} ` +
+    `planner ${ok(planner)}  ·  ${workers.length} worker${workers.length === 1 ? '' : 's'}  ·  maxSubtasks ${maxSubtasks}\n`);
+  await _quickPrompt('  press Enter to continue ');
+  return { ok: true };
+}

package/tui/pickers.mjs

@@ -12,6 +12,24 @@ import {
   supportsLiveFetch as _supportsLiveFetch,
 } from '../providers/model_catalogue.mjs';
 import { paint } from './theme.mjs';
+// Banner renderers live in a leaf sibling module (tui/banner.mjs). We import
+// the ones pickers' own code still calls (_orange / _ORANGE_RGB in
+// _printChatBanner, _loadBannerAssets / _renderBanner / _orange in
+// _renderV5Banner) and re-export the public surface so existing importers
+// (cli.mjs / commands/setup.mjs / commands/chat.mjs) keep resolving them here.
+import {
+  _ORANGE_RGB,
+  _orange,
+  _renderBanner,
+  _loadBannerAssets,
+} from './banner.mjs';
+export {
+  _orange,
+  _renderMascot,
+  _renderMascotTiny,
+  _renderBanner,
+  _loadBannerAssets,
+} from './banner.mjs';
 
 // Read exactly ONE line from a non-TTY stream (piped stdin) and hand the rest
 // back so the next reader (the next picker / a credential prompt) still gets
@@ -141,73 +159,16 @@ export function _attachGhostAutocomplete(rl) {
   };
 }
 
-// LazyClaw banner — single source of truth (chat REPL header, no-arg
-// launcher, first-run welcome). Printed once so users see the active
-// provider/model; plain ANSI, auto-skipped when stdout isn't a TTY.
-// Returns an array of pre-formatted lines the caller can splice rows into.
-//
-// Layout invariants: every inner row is forced through `.padEnd(INNER_W)`
-// and is exactly INNER_W single-cell glyphs, so the right border `│` always
-// lands in the same column. _renderMascot / _renderMascotTiny are stubs kept
-// so any leftover caller doesn't crash.
-
-const _ORANGE_RGB = '241;130;70';  // #F18246
-export function _orange(s) { return `\x1b[38;2;${_ORANGE_RGB}m${s}\x1b[0m`; }
-
-export function _renderMascot() {
-  return ['lazyclaw'];
-}
-
-export function _renderMascotTiny() {
-  return 'lazyclaw';
-}
-
-// figlet "standard" "lazy", trimmed of leading blank line. Each row
-// is left-padded by two spaces inside the box, and every row is then
-// padded to INNER_W cells.
-const _LAZY_STANDARD = [
-  ' _                  ',
-  '| | __ _ _____   _  ',
-  '| |/ _` |_  / | | | ',
-  '| | (_| |/ /| |_| | ',
-  '|_|\\__,_/___|\\__, | ',
-  '             |___/  ',
-];
-
-const _INNER_W = 32;  // 2 left pad + 20 letter art + caption headroom
-
-export function _renderBanner(version) {
-  const v = String(version || '?.?.?');
-  const cap = `  LazyClaw  v${v}`;
-  const padInner = (s) => '  ' + s.padEnd(_INNER_W - 2, ' ');
-  const wrap = (inner) => _orange('│') + _orange(inner) + _orange('│');
-  const top = _orange('╭' + '─'.repeat(_INNER_W) + '╮');
-  const bot = _orange('╰' + '─'.repeat(_INNER_W) + '╯');
-  return [
-    top,
-    ..._LAZY_STANDARD.map((row) => wrap(padInner(row))),
-    wrap(padInner(cap)),
-    bot,
-  ];
-}
+// Banner renderers (_ORANGE_RGB / _orange / _renderMascot / _renderMascotTiny
+// / _renderBanner / _loadBannerAssets) moved to tui/banner.mjs — imported at
+// the top of this file and re-exported there for existing callers. The v5
+// splash composer and chat header below still live here because they read
+// pickers-local state and stay close to the wizard that prints them.
 
 // v5 hero banner — ANSI Shadow LAZYCLAW wordmark stacked on top of the
 // braille sloth (tui/banner.generated.mjs + tui/wordmark.mjs). Left-aligned
 // with a 2-cell margin so wide terminals don't push the art to the right.
 // Opt out with LAZYCLAW_LEGACY_MENU=1 to fall back to the v4 figlet box.
-let _bannerAssetsCache = null;
-export async function _loadBannerAssets() {
-  if (_bannerAssetsCache !== null) return _bannerAssetsCache;
-  try {
-    const { banner } = await import('./banner.generated.mjs');
-    const { wordmark } = await import('./wordmark.mjs');
-    _bannerAssetsCache = { banner, wordmark };
-  } catch {
-    _bannerAssetsCache = null;
-  }
-  return _bannerAssetsCache;
-}
-
 export async function _renderV5Banner(version) {
   const a = await _loadBannerAssets();
   if (!a) return _renderBanner(version); // missing tarball asset → v4 figlet
@@ -618,124 +579,10 @@ export async function _pickProviderInteractive() {
   return { provider: provider.id, model: picked };
 }
 
-// Step-3 alternative for composite providers (currently only the
-// orchestrator). Builds `cfg.orchestrator = { planner, workers,
-// maxSubtasks }` interactively and persists it before returning.
-//
-// planner: single picker over registered non-composite providers.
-// workers: multi-select with a running list + add/remove/done loop.
-// maxSubtasks: typed integer, default 5.
-export async function _setupOrchestratorInteractive() {
-  const accent = (s) => paint('38;5;208', s);
-  const dim    = (s) => paint('2', s);
-  const bold   = (s) => paint('1', s);
-  const ok     = (s) => paint('32', s);
-  const info = getRegistry().PROVIDER_INFO || {};
-  const eligibleNames = Object.keys(getRegistry().PROVIDERS).filter((n) => n !== 'orchestrator' && n !== 'mock');
-  if (eligibleNames.length === 0) {
-    process.stdout.write('\n' + accent('orchestrator setup') + ': no eligible workers — register a real provider first.\n');
-    await _quickPrompt('  press Enter to continue ');
-    return 'CANCEL';
-  }
-  const cfg = readConfig();
-  const existing = cfg.orchestrator && typeof cfg.orchestrator === 'object' ? cfg.orchestrator : {};
-
-  // ── Pick planner ─────────────────────────────────────────────────
-  const plannerItems = eligibleNames.map((name) => {
-    const m = info[name] || {};
-    const defaultModel = m.defaultModel || '';
-    return {
-      id: `${name}${defaultModel ? ':' + defaultModel : ''}`,
-      label: m.label && m.label !== name ? `${name} — ${m.label}` : name,
-      desc: defaultModel ? `default model: ${defaultModel}` : '',
-    };
-  });
-  const plannerPick = await _arrowMenu({
-    title: 'LazyClaw setup — Step 3 of 3:  orchestrator — pick the planner',
-    subtitle: 'The planner decomposes the user request into subtasks and writes the final synthesis. Strong reasoning models work best here.',
-    items: plannerItems,
-    searchable: true,
-    defaultIdx: Math.max(0, plannerItems.findIndex((p) => p.id === existing.planner)),
-  });
-  if (plannerPick === 'CANCEL') return 'CANCEL';
-  if (plannerPick === 'BACK')   return 'BACK';
-  const planner = plannerPick.id;
-
-  // ── Pick workers (iterative add/remove) ──────────────────────────
-  const workers = Array.isArray(existing.workers) ? existing.workers.slice() : [];
-  while (true) {
-    process.stdout.write('\x1b[2J\x1b[H');
-    process.stdout.write(accent('Orchestrator workers') + '\n');
-    process.stdout.write(dim('Subtasks are dispatched round-robin across this list.') + '\n\n');
-    if (workers.length === 0) {
-      process.stdout.write('  ' + dim('(none yet — add at least one)') + '\n\n');
-    } else {
-      workers.forEach((w, i) => {
-        process.stdout.write(`  ${i + 1}. ${ok(w)}\n`);
-      });
-      process.stdout.write('\n');
-    }
-    const items = [
-      { id: '__add__',    label: '+ Add a worker',     desc: 'pick from registered providers' },
-      { id: '__remove__', label: '- Remove a worker',  desc: workers.length ? 'pick which entry to drop' : '(nothing to remove)' },
-      { id: '__done__',   label: `Done${workers.length ? ` (${workers.length} worker${workers.length === 1 ? '' : 's'})` : ' — at least one worker required'}`, desc: workers.length ? 'save cfg.orchestrator and finish' : 'add one worker first' },
-    ];
-    const action = await _arrowMenu({
-      title: 'LazyClaw setup — orchestrator workers',
-      subtitle: `Planner: ${planner}`,
-      items,
-    });
-    if (action === 'CANCEL') return 'CANCEL';
-    if (action === 'BACK')   return 'BACK';
-    if (action.id === '__add__') {
-      const wPick = await _arrowMenu({
-        title: 'Add worker',
-        subtitle: 'Picked entries are appended to the workers list.',
-        items: plannerItems.filter((p) => !workers.includes(p.id)),
-        searchable: true,
-      });
-      if (wPick === 'CANCEL' || wPick === 'BACK') continue;
-      workers.push(wPick.id);
-      continue;
-    }
-    if (action.id === '__remove__') {
-      if (!workers.length) continue;
-      const rPick = await _arrowMenu({
-        title: 'Remove worker',
-        subtitle: 'Highlighted entry is removed from the list.',
-        items: workers.map((w) => ({ id: w, label: w })),
-      });
-      if (rPick === 'CANCEL' || rPick === 'BACK') continue;
-      const idx = workers.indexOf(rPick.id);
-      if (idx >= 0) workers.splice(idx, 1);
-      continue;
-    }
-    if (action.id === '__done__') {
-      if (workers.length === 0) continue;
-      break;
-    }
-  }
-
-  // ── maxSubtasks ──────────────────────────────────────────────────
-  const defaultMax = Number.isFinite(existing.maxSubtasks) && existing.maxSubtasks > 0
-    ? Math.min(10, existing.maxSubtasks)
-    : 5;
-  const rawMax = (await _quickPrompt(`  ${bold('maxSubtasks')} ${dim(`(2..10, blank → ${defaultMax}):`)} `)).trim();
-  let maxSubtasks = defaultMax;
-  if (rawMax) {
-    const n = parseInt(rawMax, 10);
-    if (Number.isFinite(n) && n >= 1) maxSubtasks = Math.min(10, Math.max(1, n));
-  }
-
-  // ── Persist ──────────────────────────────────────────────────────
-  cfg.orchestrator = { planner, workers, maxSubtasks };
-  writeConfig(cfg);
-  process.stdout.write('\n');
-  process.stdout.write(`  ${ok('✓ orchestrator saved')}  ${dim('→')} ` +
-    `planner ${ok(planner)}  ·  ${workers.length} worker${workers.length === 1 ? '' : 's'}  ·  maxSubtasks ${maxSubtasks}\n`);
-  await _quickPrompt('  press Enter to continue ');
-  return { ok: true };
-}
+// _setupOrchestratorInteractive moved to tui/orchestrator_setup.mjs (it imports
+// _arrowMenu / _quickPrompt back from here at call time → a safe cycle). The
+// re-export line sits at the BOTTOM of this file, after those helpers are
+// declared, so the live bindings resolve.
 
 // Pause the chat REPL's readline + ghost-autocomplete while a sub-picker
 // (provider / model arrow menu) takes over the terminal. The sub-picker
@@ -1030,3 +877,10 @@ export async function _quickPromptSecret(label) {
   });
   return value.trim();
 }
+
+// Re-export the orchestrator setup wizard (moved to tui/orchestrator_setup.mjs).
+// Kept at the BOTTOM so _arrowMenu / _quickPrompt — which that module imports
+// back from here — are already declared when the cycle resolves. The helpers
+// are hoisted top-level function declarations and used only at call time, so
+// the pickers ↔ orchestrator_setup cycle never reads an uninitialised binding.
+export { _setupOrchestratorInteractive } from './orchestrator_setup.mjs';

package/tui/repl.mjs

@@ -43,171 +43,18 @@ import { ModalPicker, filterModalItems, resolveModalPick } from './modal_picker.
 import { theme } from './theme.mjs';
 import { StatusBar } from './status_bar.mjs';
 import { onConversationReset, clearTerminalScreen } from './repl_reset.mjs'; export { StatusBar };
-
-// ─── 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];
-}
+// 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 ─────────────────────────────────────────────────────────
 //