lazyclaw 5.4.1 → 5.4.3

package/cli.mjs

@@ -2682,6 +2682,19 @@ async function cmdChat(flags = {}) {
         resolveAuthKey: (providerName) => _resolveAuthKey(cfg, providerName),
         onCharsSent: (n) => { _inkCharsSent += Number(n) || 0; },
       };
+      // v5.4.3 — ReplApp exposes an openPicker(opts) → Promise<id|null>
+      // via this ref. The slash dispatcher reads it through ctx.openPicker
+      // to drive /provider, /model, /personality without forking off raw
+      // stdin from Ink. When ReplApp hasn't populated the ref yet (early
+      // mount / non-Ink path) the dispatcher falls back to its hint
+      // string so users aren't stranded.
+      const _inkPickerRef = { current: null };
+      _inkCtx.openPicker = (opts) => {
+        const api = _inkPickerRef.current;
+        return api && typeof api.openPicker === 'function'
+          ? api.openPicker(opts)
+          : Promise.resolve(null);
+      };
       // v5.0.10: write streamed chunks straight to process.stdout. Ink
       // owns the screen, so interleaved stdout writes can produce some
       // visual jank — accepted trade for unblocking the chat loop. v5.1
@@ -2711,6 +2724,7 @@ async function cmdChat(flags = {}) {
         statusInfo: { provider: activeProvName, model: activeModel },
         runTurn: _inkRunTurn,
         onSlashCommand: _inkSlashHandler,
+        pickerRef: _inkPickerRef,
       }), { exitOnCtrlC: true, patchConsole: true });
       await ink.waitUntilExit();
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "5.4.1",
+  "version": "5.4.3",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama, orchestrating multi-step LLM workflows, and running multi-agent Slack teams with cross-task memory. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",

package/tui/editor.mjs

@@ -28,7 +28,7 @@
 // `width: '100%'` so Ink's wrap-ansi (already string-width aware) gets
 // the full terminal budget — fixes the perceived right-edge truncation
 // on long Korean buffers.
-import React, { useState, useEffect } from 'react';
+import React, { useState, useEffect, useRef } from 'react';
 import { Box, Text, useInput } from 'ink';
 import stringWidth from 'string-width';
 import { theme } from './theme.mjs';
@@ -50,6 +50,32 @@ export function displayWidth(text) {
   return stringWidth(String(text));
 }
 
+// Cell-aware soft-wrap. Returns an array of visual rows whose width
+// respects the budget (first row uses `firstBudget`, subsequent rows
+// use `contBudget`). Hoisted to module level (was inner-fn) so the
+// cursor-anchor useEffect in <Editor/> can reuse it.
+export function wrapToBudget(text, firstBudget, contBudget) {
+  if (!text) return [''];
+  const out = [];
+  let line = '';
+  let lineW = 0;
+  let budget = firstBudget;
+  for (const ch of text) {
+    const w = stringWidth(ch);
+    if (lineW + w > budget) {
+      out.push(line);
+      line = ch;
+      lineW = w;
+      budget = contBudget;
+    } else {
+      line += ch;
+      lineW += w;
+    }
+  }
+  out.push(line);
+  return out;
+}
+
 // Display column of the caret given a state. Counts wide chars as 2.
 // On the first rendered line this is offset by PROMPT_WIDTH; on
 // continuation lines (after a Shift+Enter) it is offset by
@@ -146,19 +172,80 @@ export function Editor({
   slashSelectedIndex,    // number
   onSlashMove,           // (delta: -1 | +1) => void
   onSlashDismiss,        // () => void
+  // v5.4.3 modal-picker wiring (all optional — pre-v5.4.3 callers pass none).
+  // When modalOpen is true the Editor intercepts every key and routes it
+  // to the host callbacks; nothing reaches applyKey / onSubmit so the
+  // chat buffer is untouched while a picker is up.
+  modalOpen,             // boolean
+  modalQuery,            // string — current filter buffer (host-owned)
+  onModalMove,           // (delta: -1 | +1) => void
+  onModalConfirm,        // () => void
+  onModalCancel,         // () => void
+  onModalQuery,          // (next: string) => void
+  // v5.4.3 IME cursor anchor — when altEnabled is true, the Editor
+  // moves the terminal cursor back inside its content row after each
+  // render so macOS IMEs (Hangul / Japanese / Chinese) draw their
+  // pre-edit overlay at the actual typing position. Opt-out via the
+  // LAZYCLAW_NO_CURSOR_ANCHOR env var (handled internally).
+  altEnabled,
 }) {
   const [state, setState] = useState(() => makeEditorState({ history }));
   const slashOpen = Array.isArray(slashSuggestions) && slashSuggestions.length > 0;
 
+  // v5.4.2: keep a synchronous mirror of the editor state so back-to-back
+  // keystrokes don't lose characters to React's stale-closure problem.
+  // Korean / Japanese IME commits each completed syllable as a separate
+  // stdin event; if two events fire inside one React frame the second
+  // useInput call captures the pre-first-event `state` and overwrites
+  // the first event's setState payload — leaving the first character
+  // missing from `buffer`. Reading + writing through the ref means every
+  // applyKey() sees the latest buffer regardless of render timing.
+  const stateRef = useRef(state);
+  useEffect(() => { stateRef.current = state; }, [state]);
+  const commit = (next) => {
+    stateRef.current = next;
+    setState(next);
+  };
+
   useInput((input, key) => {
+    const current = stateRef.current;
+    // ─── Modal-picker keyboard contract (highest priority — v5.4.3) ──
+    // When a host-owned picker is up, EVERY key is consumed by the
+    // picker. The chat buffer is never mutated and onSubmit is never
+    // fired. This is what prevents "Enter while picking a model" from
+    // accidentally submitting the typed-so-far buffer as a chat turn.
+    if (modalOpen) {
+      if (key.escape) { if (onModalCancel) onModalCancel(); return; }
+      if (key.return) { if (onModalConfirm) onModalConfirm(); return; }
+      if (key.upArrow)   { if (onModalMove) onModalMove(-1); return; }
+      if (key.downArrow) { if (onModalMove) onModalMove(+1); return; }
+      if (key.pageUp)    { if (onModalMove) onModalMove(-10); return; }
+      if (key.pageDown)  { if (onModalMove) onModalMove(+10); return; }
+      // Ctrl+U clears the filter (Unix-style line kill).
+      if (key.ctrl && (input === 'u' || input === 'U')) {
+        if (onModalQuery) onModalQuery('');
+        return;
+      }
+      if (key.backspace || key.delete) {
+        if (onModalQuery) onModalQuery(String(modalQuery || '').slice(0, -1));
+        return;
+      }
+      // Printable single char (no modifier) appends to filter.
+      if (input && !key.ctrl && !key.meta && input.length >= 1 && !key.tab) {
+        if (onModalQuery) onModalQuery(String(modalQuery || '') + input);
+        return;
+      }
+      // Anything else (Tab, function keys, etc.) swallowed.
+      return;
+    }
     // ─── Slash-popup keyboard contract (highest priority when open) ──
     if (slashOpen) {
       // Esc: clear the buffer and dismiss the popup. The host's onEscape
       // is NOT called in this branch — Esc here is a popup gesture, not
       // a turn-abort. (Outside of popup mode Esc still aborts streaming.)
       if (key.escape) {
-        const cleared = { ...state, buffer: '', cursor: 0, lastSubmit: null, lastWasPaste: false };
-        setState(cleared);
+        const cleared = { ...current, buffer: '', cursor: 0, lastSubmit: null, lastWasPaste: false };
+        commit(cleared);
         if (onBufferChange) {
           try { onBufferChange(''); } catch {}
         }
@@ -184,15 +271,15 @@ export function Editor({
       if (key.tab || key.return) {
         const safeIdx = Math.max(0, Math.min(slashSuggestions.length - 1, slashSelectedIndex || 0));
         const picked = slashSuggestions[safeIdx];
-        const bufTrim = state.buffer.replace(/\s+$/, '');
-        const alreadyExact = !!picked && (state.buffer === picked.cmd || bufTrim === picked.cmd);
+        const bufTrim = current.buffer.replace(/\s+$/, '');
+        const alreadyExact = !!picked && (current.buffer === picked.cmd || bufTrim === picked.cmd);
         if (alreadyExact) {
           if (key.tab) return; // no completion to make
           // key.return on exact match → fall through to applyKey/submit.
         } else {
           if (picked) {
-            const next = fillSlashCommand(state, picked.cmd);
-            setState(next);
+            const next = fillSlashCommand(current, picked.cmd);
+            commit(next);
             if (onBufferChange) {
               try { onBufferChange(next.buffer); } catch {}
             }
@@ -206,8 +293,8 @@ export function Editor({
     // Esc: forward to host (ReplApp uses this to abort an in-flight turn).
     // Do not mutate the buffer — the user may want to keep typing.
     if (key.escape) { if (onEscape) onEscape(); return; }
-    const next = applyKey(state, { input, key });
-    setState(next);
+    const next = applyKey(current, { input, key });
+    commit(next);
     if (onBufferChange) {
       try { onBufferChange(next.buffer); } catch { /* observer is best-effort */ }
     }
@@ -216,38 +303,77 @@ export function Editor({
     if (state.lastSubmit !== null && onSubmit) onSubmit(state.lastSubmit);
   }, [state.lastSubmit]);
 
+  // v5.4.3 — IME cursor anchor.
+  //
+  // After every Ink render commit, move the terminal cursor BACK inside
+  // the editor's content row so macOS Hangul / Japanese / Chinese IMEs
+  // draw their pre-edit overlay where the user is actually typing
+  // (instead of on the row below the editor box, where Ink's log-update
+  // parks the cursor by default via its trailing '\n').
+  //
+  // Trade-off: each render briefly moves the cursor, which means the
+  // NEXT render's log-update eraseLines starts from inside the editor.
+  // Ink immediately overwrites with the full new frame, so the user
+  // sees at most a one-tick flicker. The IME-correctness win is worth
+  // the cosmetic cost. Opt out via LAZYCLAW_NO_CURSOR_ANCHOR=1.
+  useEffect(() => {
+    if (!altEnabled) return;
+    if (process.env.LAZYCLAW_NO_CURSOR_ANCHOR === '1') return;
+    if (!(process.stdout && process.stdout.isTTY)) return;
+    const cols = Math.max(20, process.stdout.columns || 80);
+    const inner = Math.max(8, cols - 4);
+    const fb = inner - PROMPT_WIDTH;
+    const cb = inner - CONTINUATION_WIDTH;
+
+    // Count total rendered rows (for "rowsUp" math) and locate the
+    // cursor's (rowInEditor, colInLine) by wrapping the buffer up to
+    // the codepoint cursor position.
+    const fullLines = String(state.buffer || '').split('\n');
+    let totalRows = 0;
+    for (let li = 0; li < fullLines.length; li++) {
+      const wrapped = wrapToBudget(fullLines[li], fb, cb);
+      totalRows += wrapped.length;
+    }
+    const before = String(state.buffer || '').slice(0, state.cursor || 0);
+    const beforeLines = before.split('\n');
+    let rowInEditor = 0;
+    for (let li = 0; li < beforeLines.length - 1; li++) {
+      const wrapped = wrapToBudget(beforeLines[li], fb, cb);
+      rowInEditor += wrapped.length;
+    }
+    const lastBefore = beforeLines[beforeLines.length - 1] || '';
+    const lastWrapped = wrapToBudget(lastBefore, fb, cb);
+    rowInEditor += lastWrapped.length - 1;
+    const lastSegment = lastWrapped[lastWrapped.length - 1] || '';
+    const colInLine = stringWidth(lastSegment);
+
+    // After Ink writes `<frame>\n`, cursor sits on the line below the
+    // editor's bottom border at column 0. Editor geometry: 1 top border
+    // + totalRows content + 1 bottom border. So the row count between
+    // "below editor" and the cursor's target content row is
+    // (1 trailing-\n + 1 bottom border + (totalRows - 1 - rowInEditor))
+    // = totalRows + 1 - rowInEditor.
+    const rowsUp = Math.max(1, totalRows + 1 - rowInEditor);
+
+    // Column: 1-indexed. Left border at col 1, padX at col 2, prefix
+    // starts at col 3. Cursor sits one cell past the typed content.
+    const prefixWidth = rowInEditor === 0 ? PROMPT_WIDTH : CONTINUATION_WIDTH;
+    const colTarget = 3 + prefixWidth + colInLine;
+    try {
+      process.stdout.write(`\x1b[${rowsUp}A\x1b[${colTarget}G\x1b[?25h`);
+    } catch { /* stdout closed — swallow */ }
+  }, [state.buffer, state.cursor, altEnabled]);
+
   const lines = state.buffer.split('\n');
-  // Manual cell-aware wrapping. Ink's <Text wrap="wrap"> uses wrap-ansi,
-  // which IS string-width aware, but the box's width:'100%' resolves
-  // against ink-testing-library's stdout shim (and some real terminals
-  // when columns is reset by SIGWINCH late) at 100 cols regardless of
-  // the actual viewport — so wide CJK buffers visibly bleed past the
-  // box right edge in narrow terminals. Pre-wrap to the actual cell
-  // budget so Ink never has to guess.
+  // Ink's <Text wrap="wrap"> uses wrap-ansi (string-width aware) but the
+  // box's width resolves against ink-testing-library's stdout shim and
+  // some real terminals at 100 cols regardless of the actual viewport,
+  // so wide CJK buffers bleed past the right edge in narrow terminals.
+  // Pre-wrap to the actual cell budget via the module-level wrapToBudget
+  // (see top of this file) so Ink never has to guess.
   const TERM = Math.max(20, process.stdout.columns || 80);
   // Box overhead: 1 border + 1 padX on each side = 4 cells; first row
   // also reserves PROMPT_WIDTH; continuation rows reserve CONTINUATION_WIDTH.
-  function wrapToBudget(text, firstBudget, contBudget) {
-    if (!text) return [''];
-    const out = [];
-    let line = '';
-    let lineW = 0;
-    let budget = firstBudget;
-    for (const ch of text) {
-      const w = stringWidth(ch);
-      if (lineW + w > budget) {
-        out.push(line);
-        line = ch;
-        lineW = w;
-        budget = contBudget;
-      } else {
-        line += ch;
-        lineW += w;
-      }
-    }
-    out.push(line);
-    return out;
-  }
   const innerCells = Math.max(8, TERM - 4); // 2 border + 2 padX
   const renderedLines = [];
   for (let li = 0; li < lines.length; li++) {

package/tui/modal_picker.mjs

@@ -0,0 +1,166 @@
+// tui/modal_picker.mjs — v5.4.3 in-Ink modal picker.
+//
+// Used by /provider, /model, /personality (and any future overlay slash
+// that needs a single-shot selection from a fixed list). Mounted as a
+// flex sibling above <StatusBar/> when ReplApp's `modal` state is set;
+// Editor intercepts keys (Up/Down/Enter/Esc/printable filter) and
+// forwards them as host callbacks. The component itself is purely
+// presentational + a pure scoring helper so it stays snapshot-testable.
+//
+// Picker resolves via Promise (ReplApp's openPicker(opts) returns one).
+// Confirm → resolve(itemId). Cancel/Esc → resolve(null). Unmount during
+// active picker → also resolve(null) so dispatcher promises never hang.
+
+import React from 'react';
+import { Box, Text } from 'ink';
+import stringWidth from 'string-width';
+import { theme } from './theme.mjs';
+
+const DEFAULT_MAX_ROWS = 12;
+
+// Pure filter — prefix > substring > subsequence. Stable order within
+// each tier (original list order is the tiebreaker).
+export function filterModalItems(query, items) {
+  const q = String(query || '').trim().toLowerCase();
+  const list = Array.isArray(items) ? items : [];
+  if (!q) return list.slice();
+  const prefix = [], substr = [], subseq = [];
+  for (const it of list) {
+    const hay = `${it.label || it.id || ''} ${it.desc || ''}`.toLowerCase();
+    if (hay.startsWith(q)) prefix.push(it);
+    else if (hay.includes(q)) substr.push(it);
+    else if (_isSubseq(q, hay)) subseq.push(it);
+  }
+  return [...prefix, ...substr, ...subseq];
+}
+
+function _isSubseq(needle, hay) {
+  let i = 0;
+  for (const ch of hay) {
+    if (ch === needle[i]) i++;
+    if (i === needle.length) return true;
+  }
+  return false;
+}
+
+// Pure window computation — slide a window of `maxRows` items so that
+// `selectedIndex` is always visible. Mirrors the pattern in
+// tui/slash_popup.mjs._computeWindow.
+export function _computeWindow(idx, total, maxRows) {
+  const n = Math.max(0, total);
+  const m = Math.max(1, maxRows);
+  if (n <= m) return { start: 0, end: n };
+  let start = Math.max(0, Math.min(n - m, idx - Math.floor(m / 2)));
+  return { start, end: start + m };
+}
+
+// Presentational component.
+//
+// Props:
+//   title:string         — top label (bold)
+//   subtitle?:string     — second row (dim)
+//   items:Array          — [{id, label, desc?, tag?}]
+//   selectedIndex:number — host-owned selection cursor (in filtered list)
+//   query:string         — host-owned filter buffer
+//   searchable?:boolean  — show the filter row (default true)
+//   maxRows?:number      — viewport height (default 12)
+//   toast?:string        — transient one-line message below the list
+//   columns?:number      — terminal width override (tests)
+export function ModalPicker({
+  title,
+  subtitle,
+  items,
+  selectedIndex,
+  query,
+  searchable = true,
+  maxRows = DEFAULT_MAX_ROWS,
+  toast,
+  columns,
+}) {
+  const list = Array.isArray(items) ? items : [];
+  const total = list.length;
+  const idx = Math.max(0, Math.min(total - 1, Number.isFinite(selectedIndex) ? selectedIndex : 0));
+  const { start, end } = _computeWindow(idx, total, maxRows);
+  const visible = list.slice(start, end);
+  const cols = Number.isFinite(columns) ? columns : (process.stdout.columns || 80);
+
+  // Label column width = longest visible label, capped at 36.
+  const labelW = Math.min(36, Math.max(
+    8,
+    ...visible.map((it) => stringWidth(String(it.label || it.id || '')))
+  ));
+
+  const rows = [];
+
+  // Title.
+  rows.push(React.createElement(
+    Text, { key: 'title', bold: true }, String(title || 'select')
+  ));
+  if (subtitle) {
+    rows.push(React.createElement(
+      Text, { key: 'sub', dimColor: true },
+      String(subtitle)
+    ));
+  }
+  // Filter row.
+  if (searchable) {
+    const q = String(query || '');
+    const tail = total > 0 ? `${total} match${total === 1 ? '' : 'es'}` : 'no matches';
+    rows.push(React.createElement(
+      Text, { key: 'filter' },
+      `${theme.accent ? theme.accent('› ') : '› '}${q}${q.length ? '' : ' '}  `,
+      React.createElement(Text, { key: 'count', dimColor: true }, tail),
+    ));
+  }
+
+  // Items.
+  if (total === 0) {
+    rows.push(React.createElement(
+      Text, { key: 'empty', dimColor: true }, '  (no items)'
+    ));
+  } else {
+    for (let i = 0; i < visible.length; i++) {
+      const it = visible[i];
+      const absoluteIdx = start + i;
+      const selected = absoluteIdx === idx;
+      const marker = selected ? '❯ ' : '  ';
+      const label = String(it.label || it.id || '').padEnd(labelW);
+      const desc = it.desc ? `  ${it.desc}` : '';
+      // Render selected row inverse-bold for contrast.
+      rows.push(React.createElement(
+        Text,
+        { key: `it-${absoluteIdx}`, bold: selected, inverse: selected },
+        `${marker}${label}${desc}`,
+      ));
+    }
+    if (end < total) {
+      rows.push(React.createElement(
+        Text, { key: 'more', dimColor: true },
+        `  … ${total - end} more (Down to scroll)`,
+      ));
+    }
+  }
+  if (toast) {
+    rows.push(React.createElement(
+      Text, { key: 'toast', color: 'yellow' }, toast,
+    ));
+  }
+  // Footer.
+  rows.push(React.createElement(
+    Text, { key: 'help', dimColor: true },
+    '  ↑/↓ move · Enter pick · Esc cancel · type to filter · Ctrl+U clear',
+  ));
+
+  return React.createElement(
+    Box,
+    {
+      flexDirection: 'column',
+      borderStyle: 'round',
+      borderColor: theme.amber || theme.border || 'yellow',
+      paddingX: 1,
+      width: Math.min(cols, 100),
+      flexShrink: 0,
+    },
+    rows,
+  );
+}

package/tui/repl.mjs

@@ -2,11 +2,15 @@
 // (spec §5.8) AND a sticky-bottom chat layout (v5.3).
 //
 // Layout (top → bottom inside the outer column):
-//   1. <Static items={scrollback}/> — splash item + per-turn user/assistant
-//      blocks. Static renders each item ONCE to terminal scrollback and
-//      never re-renders it, so the splash + history scroll away naturally
-//      as new content appends. This is the Claude CLI / opencode pattern
-//      translated to Ink's idiom — Static IS the scroll buffer.
+//   1. Scrollback — splash item + per-turn user/assistant blocks.
+//      Non-alt path uses <Static items={scrollback}/>: Ink writes each
+//      item ONCE to terminal scrollback so the splash + history scroll
+//      away naturally as new content appends (the v5.3 contract).
+//      Alt-buffer path renders the same items as regular flex children
+//      instead — Static's "write above the live frame" mechanism is
+//      invisible inside the DEC 1049 alt canvas (the live frame
+//      immediately overwrites that area), so v5.4.1 splashes vanished.
+//      Flex children re-render each frame; <Splash/> output is stable.
 //   2. Live region — partial assistant stream (state.liveAssistant) and
 //      optional <SlashHints/> while the input buffer starts with '/'.
 //      This Box re-renders on every chunk; the rest of the tree does not.
@@ -34,6 +38,7 @@ 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 { ModalPicker, filterModalItems } from './modal_picker.mjs';
 import { theme } from './theme.mjs';
 
 // ─── Alt-buffer mount (DEC 1049) ─────────────────────────────────────────
@@ -183,7 +188,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 }) {
+export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, onSlashCommand, statusInfo, pickerRef }) {
   // statusInfo lets the host supply provider/model/ctx to the StatusBar
   // independently of splashProps. Needed for the alt-buffer hand-off
   // where splashProps is pre-printed to the primary buffer (not the
@@ -352,7 +357,88 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
   const _exactOnly =
     filtered.length === 1 &&
     (filtered[0].cmd === bufferPeek || filtered[0].cmd === _bufTrimmed);
+
+  // ─── Modal picker state (v5.4.3) ───────────────────────────────────
+  // openPicker(opts) → Promise<id|null>. Stores the resolver on `modal`
+  // so confirm/cancel/unmount can settle it. The Editor intercepts
+  // Up/Down/Enter/Esc/Backspace/printable when modalOpen is true and
+  // routes them as host callbacks below; chat buffer and onSubmit are
+  // untouched while a picker is up.
+  const [modal, setModal] = useState(null);
+  const [modalIdx, setModalIdx] = useState(0);
+  const [modalQuery, setModalQuery] = useState('');
+  const modalView = useMemo(
+    () => (modal ? filterModalItems(modalQuery, modal.items) : []),
+    [modal, modalQuery],
+  );
+  const modalRef = useRef(null);
+  modalRef.current = modal;
+  const closeModal = useCallback((picked) => {
+    const m = modalRef.current;
+    setModal(null);
+    setModalIdx(0);
+    setModalQuery('');
+    if (m && typeof m.resolve === 'function') {
+      try { m.resolve(picked); } catch { /* swallow */ }
+    }
+  }, []);
+  const openPicker = useCallback((opts = {}) => {
+    return new Promise((resolve) => {
+      setModalIdx(Number.isFinite(opts.defaultIdx) ? opts.defaultIdx : 0);
+      setModalQuery('');
+      setModal({
+        kind: opts.kind || 'generic',
+        title: opts.title || 'select',
+        subtitle: opts.subtitle || '',
+        items: Array.isArray(opts.items) ? opts.items : [],
+        searchable: opts.searchable !== false,
+        resolve,
+      });
+    });
+  }, []);
+  // Expose openPicker via the host-supplied ref so cli.mjs can inject
+  // it into the slash dispatcher's ctx.
+  useEffect(() => {
+    if (pickerRef && typeof pickerRef === 'object') {
+      pickerRef.current = { openPicker };
+    }
+    return () => {
+      if (pickerRef && typeof pickerRef === 'object') {
+        pickerRef.current = null;
+      }
+      // If the app unmounts while a picker is open, resolve(null) so
+      // the awaiting dispatcher promise doesn't hang the next /command.
+      const m = modalRef.current;
+      if (m && typeof m.resolve === 'function') {
+        try { m.resolve(null); } catch { /* swallow */ }
+      }
+    };
+  }, [pickerRef, openPicker]);
+
+  const onModalMove = useCallback((delta) => {
+    setModalIdx((i) => {
+      const max = Math.max(0, modalView.length - 1);
+      const n = i + delta;
+      if (n < 0) return 0;
+      if (n > max) return max;
+      return n;
+    });
+  }, [modalView.length]);
+  const onModalConfirm = useCallback(() => {
+    const picked = modalView[modalIdx];
+    closeModal(picked ? picked.id : null);
+  }, [modalView, modalIdx, closeModal]);
+  const onModalCancel = useCallback(() => { closeModal(null); }, [closeModal]);
+  const onModalQuery = useCallback((next) => {
+    setModalQuery(next || '');
+    setModalIdx(0);
+  }, []);
+  const modalOpen = !!modal;
+
+  // Slash popup is suppressed whenever a modal picker is active so the
+  // overlays don't stack.
   const showSlashPopup =
+    !modalOpen &&
     bufferPeek.startsWith('/') && filtered.length > 0 && !_exactOnly;
 
   // Outer column height: pinned to rows-1 in alt-buffer mode so the
@@ -366,19 +452,32 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
     React.createElement(
       Box,
       { flexDirection: 'column', height: outerHeight },
-      // 1) Scrollback (write-once via Ink Static).
-      //    In alt-buffer mode the Static lives inside a flex-grow inner
-      //    Box so it absorbs slack rather than pushing the editor out of
-      //    the viewport. In legacy mode it stays sibling-flat so the
-      //    structural test (Editor must be last sibling) still passes.
+      // 1) Scrollback.
+      //    Alt-buffer path: render items as regular flex children, NOT via
+      //    <Static/>. Ink's <Static/> writes once to stdout above the live
+      //    frame — in the DEC 1049 alt canvas that area is immediately
+      //    overwritten by the next live frame, so the splash + history
+      //    end up invisible (v5.4.1 regression). Trade-off: items
+      //    re-render each frame; <Splash/> output is stable so this is
+      //    visually identical to the Static version.
+      //    Non-alt path: keeps <Static/> — the legacy v5.3 contract
+      //    (splash scrolls away naturally on the primary buffer) AND the
+      //    structural snapshot in tests/v53-repl-layout.test.mjs.
       altEnabled
         ? React.createElement(
             Box,
             { flexDirection: 'column', flexGrow: 1, flexShrink: 1, overflow: 'hidden' },
-            React.createElement(
-              Static,
-              { items: state.scrollback },
-              (item) => React.createElement(ScrollbackItem, { key: item.id, item })
+            // v5.4.3 — once any user/assistant turn has been committed,
+            // drop the splash from the visible scrollback. Inside the
+            // alt-buffer canvas the splash cannot scroll off naturally
+            // (no native scrollback), so leaving it visible pushes the
+            // newest content past the StatusBar+Editor on tall outputs
+            // like /help. The splash still flashes on first mount.
+            (state.scrollback.length > 1
+              ? state.scrollback.filter((it) => it.kind !== 'splash')
+              : state.scrollback
+            ).map((item) =>
+              React.createElement(ScrollbackItem, { key: item.id, item })
             ),
             // Live region — partial assistant stream (inside the scroll
             // region so it grows naturally above the status bar).
@@ -412,6 +511,19 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
             selectedIndex: selectedSuggestion,
           })
         : 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.
+      modalOpen
+        ? React.createElement(ModalPicker, {
+            title: modal.title,
+            subtitle: modal.subtitle,
+            items: modalView,
+            selectedIndex: modalIdx,
+            query: modalQuery,
+            searchable: modal.searchable,
+          })
+        : null,
       // 4) Status bar (sticky, single row above input). flexShrink:0 so
       //    it isn't squeezed when the scrollback grows.
       React.createElement(StatusBar, {
@@ -435,6 +547,20 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
           slashSelectedIndex: selectedSuggestion,
           onSlashMove: handleSlashMove,
           onSlashDismiss: handleSlashDismiss,
+          // v5.4.3 — modal picker key contract. When modalOpen the
+          // Editor swallows all keys (no buffer mutation, no submit).
+          modalOpen,
+          modalQuery,
+          onModalMove,
+          onModalConfirm,
+          onModalCancel,
+          onModalQuery,
+          // v5.4.3 — when alt-buffer is on, Editor moves the terminal
+          // cursor back inside its content row after each render so
+          // macOS Hangul / Japanese / Chinese IMEs draw their pre-edit
+          // overlay where the user is actually typing instead of on
+          // the row below the editor box. Opt-out via env.
+          altEnabled,
         })
       )
     )

package/tui/slash_commands.mjs

@@ -32,6 +32,8 @@ export const SLASH_COMMANDS = [
   { cmd: '/team',        help: 'list, create, or join a team' },
   { cmd: '/task',        help: 'create, list, or manage tasks' },
   { cmd: '/handoff',     help: 'hand current task off to another agent' },
+  { cmd: '/dashboard',   help: 'open the lazyclaw web UI in your browser' },
+  { cmd: '/clear',       help: 'alias for /new — clear conversation' },
   { cmd: '/exit',        help: 'leave the chat' },
   { cmd: '/quit',        help: 'alias for /exit' },
 ];

package/tui/slash_dispatcher.mjs

@@ -125,16 +125,38 @@ async function _newReset(_args, ctx) {
   return 'cleared — new conversation';
 }
 
+function _providerLookup(registry, name) {
+  if (typeof registry.lookupProv === 'function') return registry.lookupProv(name);
+  return registry.PROVIDERS ? registry.PROVIDERS[name] : null;
+}
+
 async function _provider(args, ctx) {
   const registry = await _mod(ctx, 'registryMod', () => import('../providers/registry.mjs'));
-  const lookup = (name) => {
-    if (typeof registry.lookupProv === 'function') return registry.lookupProv(name);
-    return registry.PROVIDERS ? registry.PROVIDERS[name] : null;
-  };
+  // No arg → open the Ink modal picker (v5.4.3). Falls back to the
+  // pre-v5.4.3 hint string when ctx.openPicker isn't available (e.g.
+  // non-Ink callers or before the picker ref settles).
   if (!args) {
-    return `provider: ${ctx.getActiveProvName()}\n(interactive picker not available in Ink chat — pass an arg: /provider <name>)`;
+    if (typeof ctx.openPicker === 'function') {
+      const known = Object.keys(registry.PROVIDERS || {}).sort();
+      const info = registry.PROVIDER_INFO || {};
+      const items = known.map((id) => ({
+        id,
+        label: id,
+        desc: info[id] && info[id].docs ? String(info[id].docs).split('\n')[0].slice(0, 60) : '',
+      }));
+      const picked = await ctx.openPicker({
+        kind: 'provider',
+        title: 'select provider',
+        subtitle: `current: ${ctx.getActiveProvName()}`,
+        items,
+      });
+      if (!picked) return 'cancelled';
+      args = picked;
+    } else {
+      return `provider: ${ctx.getActiveProvName()}\n(pass an arg: /provider <name>)`;
+    }
   }
-  const next = lookup(args);
+  const next = _providerLookup(registry, args);
   if (!next) {
     const known = registry.PROVIDERS ? Object.keys(registry.PROVIDERS).join(', ') : '?';
     return `unknown provider: ${args} (known: ${known})`;
@@ -147,17 +169,36 @@ async function _provider(args, ctx) {
 async function _model(args, ctx) {
   const registry = await _mod(ctx, 'registryMod', () => import('../providers/registry.mjs'));
   if (!args) {
-    return `model: ${ctx.getActiveModel() || '(default)'}\n(interactive picker not available in Ink chat — pass an arg: /model <name>)`;
+    if (typeof ctx.openPicker === 'function') {
+      const provName = ctx.getActiveProvName();
+      const info = (registry.PROVIDER_INFO && registry.PROVIDER_INFO[provName]) || {};
+      const suggested = Array.isArray(info.suggestedModels) ? info.suggestedModels : [];
+      if (!suggested.length) {
+        return `no suggested models known for provider "${provName}" — pass one: /model <name>`;
+      }
+      const items = suggested.map((m) => ({
+        id: m,
+        label: m,
+        desc: info.defaultModel === m ? '(default)' : '',
+      }));
+      const picked = await ctx.openPicker({
+        kind: 'model',
+        title: `select model for ${provName}`,
+        subtitle: `current: ${ctx.getActiveModel() || '(default)'}`,
+        items,
+      });
+      if (!picked) return 'cancelled';
+      args = picked;
+    } else {
+      return `model: ${ctx.getActiveModel() || '(default)'}\n(pass an arg: /model <name>)`;
+    }
   }
   const { parseSlashProviderModel } = registry;
   const parsed = typeof parseSlashProviderModel === 'function'
     ? parseSlashProviderModel(args)
     : { provider: null, model: args };
   if (parsed.provider) {
-    const lookup = (name) => (typeof registry.lookupProv === 'function'
-      ? registry.lookupProv(name)
-      : (registry.PROVIDERS ? registry.PROVIDERS[name] : null));
-    const next = lookup(parsed.provider);
+    const next = _providerLookup(registry, parsed.provider);
     if (!next) return `unknown provider: ${parsed.provider}`;
     if (ctx.setActiveProvName) ctx.setActiveProvName(parsed.provider);
     if (ctx.setProv) ctx.setProv(next);
@@ -562,19 +603,267 @@ async function _handoff(args, ctx) {
   }
 }
 
-async function _personality(_args) {
-  // cmdPersonality lives in cli.mjs and is readline-coupled (reads from
-  // stdin via the global rl). Lifting it cleanly is a v5.5 follow-up; for
-  // v5.4 we surface the CLI alternative so operators aren't stranded.
-  return 'personality: interactive picker not yet wired into Ink chat — use `lazyclaw personality list|set <name>` from the shell, or restart with LAZYCLAW_NO_INK=1.';
+async function _personality(args, ctx) {
+  // cmdPersonality in cli.mjs is actually non-interactive (takes
+  // sub+a+b args). We mirror that surface here without going through
+  // cli.mjs (avoid circular import) — list / show / install / remove /
+  // use, plus a no-arg picker over installed personality files.
+  let fs, path;
+  try {
+    fs = await import('node:fs');
+    path = await import('node:path');
+  } catch (e) { return `/personality unavailable: ${e?.message || e}`; }
+  const dir = path.join(ctx.cfgDir, 'personalities');
+  try { fs.mkdirSync(dir, { recursive: true }); } catch { /* swallow */ }
+
+  const list = () => fs.existsSync(dir)
+    ? fs.readdirSync(dir).filter((f) => f.endsWith('.md')).map((f) => f.slice(0, -3)).sort()
+    : [];
+
+  const tokens = splitWhitespace(args);
+  const sub = tokens[0];
+  const a = tokens[1];
+  const b = tokens[2];
+
+  // No arg → open Ink modal picker (v5.4.3). Confirm selects + activates.
+  if (!sub) {
+    const names = list();
+    if (!names.length) return 'no personalities installed — `lazyclaw personality install <name> <file.md>`';
+    if (typeof ctx.openPicker !== 'function') {
+      return `personalities: ${names.join(', ')}\n(pass an arg: /personality use <name>)`;
+    }
+    const items = names.map((n) => ({ id: n, label: n }));
+    const picked = await ctx.openPicker({
+      kind: 'personality',
+      title: 'select personality',
+      subtitle: 'Enter activates · Esc cancels',
+      items,
+    });
+    if (!picked) return 'cancelled';
+    return _personalityUse(picked, ctx, fs, path);
+  }
+
+  if (sub === 'list') {
+    const names = list();
+    if (!names.length) return 'no personalities installed';
+    return names.join('\n');
+  }
+  if (sub === 'show') {
+    if (!a) return 'usage: /personality show <name>';
+    const p = path.join(dir, `${a}.md`);
+    if (!fs.existsSync(p)) return `personality not found: ${a}`;
+    return fs.readFileSync(p, 'utf8');
+  }
+  if (sub === 'install') {
+    if (!a || !b) return 'usage: /personality install <name> <file.md>';
+    const dst = path.join(dir, `${a}.md`);
+    if (fs.existsSync(dst)) return `personality already installed: ${a}`;
+    if (!fs.existsSync(b)) return `source file not found: ${b}`;
+    fs.writeFileSync(dst, fs.readFileSync(b, 'utf8'));
+    return `installed ${a}`;
+  }
+  if (sub === 'remove' || sub === 'rm' || sub === 'delete') {
+    if (!a) return 'usage: /personality remove <name>';
+    const p = path.join(dir, `${a}.md`);
+    if (!fs.existsSync(p)) return `personality not installed: ${a}`;
+    fs.unlinkSync(p);
+    return `removed ${a}`;
+  }
+  if (sub === 'use') {
+    if (!a) return 'usage: /personality use <name>';
+    return _personalityUse(a, ctx, fs, path);
+  }
+  return `/personality: unknown sub "${sub}" — list|show|install|remove|use (or no-arg picker)`;
+}
+
+function _personalityUse(name, ctx, fs, path) {
+  const dir = path.join(ctx.cfgDir, 'personalities');
+  const p = path.join(dir, `${name}.md`);
+  if (!fs.existsSync(p)) return `personality not installed: ${name}`;
+  // Read-merge-write config.json so we never clobber unrelated keys.
+  const cfgPath = path.join(ctx.cfgDir, 'config.json');
+  let diskCfg = {};
+  try { diskCfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8')); } catch { /* fresh */ }
+  diskCfg.persona = { ...(diskCfg.persona || {}), personality: name };
+  try { fs.mkdirSync(ctx.cfgDir, { recursive: true }); } catch {}
+  fs.writeFileSync(cfgPath, JSON.stringify(diskCfg, null, 2));
+  // Mirror onto the in-memory cfg so the next turn picks up the change.
+  if (ctx.cfg) {
+    ctx.cfg.persona = { ...(ctx.cfg.persona || {}), personality: name };
+  }
+  return `active personality → ${name}`;
+}
+
+async function _task(args, ctx) {
+  let tasksMod, loopMod;
+  try {
+    tasksMod = await import('../tasks.mjs');
+    loopMod = await import('../loop-engine.mjs');
+  } catch (e) { return `/task unavailable: ${e?.message || e}`; }
+  let tokens;
+  try { tokens = loopMod.splitArgs(args); }
+  catch (e) { return `/task error: ${e?.message || e}`; }
+  const sub = tokens[0];
+  const id = tokens[1];
+
+  try {
+    if (!sub || sub === 'list') {
+      const items = tasksMod.listTasks(ctx.cfgDir);
+      if (!items.length) return 'no tasks. `lazyclaw task start --team ... --title ...` from the shell to create one.';
+      return items.map((t) =>
+        `• ${t.id} [${t.status || 'unknown'}] ${t.title || '(no title)'}${t.team ? ` — team=${t.team}` : ''}${t.lead ? ` — lead=${t.lead}` : ''}`
+      ).join('\n');
+    }
+    if (sub === 'show') {
+      if (!id) return 'usage: /task show <id>';
+      const t = tasksMod.getTask(id, ctx.cfgDir);
+      if (!t) return `no task "${id}"`;
+      return JSON.stringify(t, null, 2);
+    }
+    if (sub === 'transcript') {
+      if (!id) return 'usage: /task transcript <id> [text|md|json]';
+      const t = tasksMod.getTask(id, ctx.cfgDir);
+      if (!t) return `no task "${id}"`;
+      const fmt = tokens[2] || 'text';
+      if (typeof tasksMod.formatTranscript === 'function') {
+        return tasksMod.formatTranscript(t, fmt);
+      }
+      return JSON.stringify(t.turns || [], null, 2);
+    }
+    if (sub === 'abandon' || sub === 'done') {
+      if (!id) return `usage: /task ${sub} <id>`;
+      const next = tasksMod.patchTask(id, { status: sub === 'done' ? 'done' : 'abandoned' }, ctx.cfgDir);
+      return `✓ task ${id} → ${next?.status || sub}`;
+    }
+    if (sub === 'remove' || sub === 'rm' || sub === 'delete') {
+      if (!id) return 'usage: /task remove <id>';
+      tasksMod.removeTask(id, ctx.cfgDir);
+      return `✓ removed task ${id}`;
+    }
+    if (sub === 'start' || sub === 'tick') {
+      return `task ${sub}: needs Slack + multi-agent router — run from the shell:\n  lazyclaw task ${sub} ...`;
+    }
+    return `/task: unknown sub "${sub}" — list|show|transcript|abandon|done|remove (start/tick: use CLI)`;
+  } catch (e) {
+    return `/task error: ${e?.message || e}`;
+  }
 }
 
-async function _task() {
-  return 'task: slash form lands in v5.5 — use the `lazyclaw task` CLI for now.';
+async function _trainer(args, ctx) {
+  const registry = await _mod(ctx, 'registryMod', () => import('../providers/registry.mjs'));
+  const tokens = splitWhitespace(args);
+  const sub = tokens[0] || 'show';
+
+  if (sub === 'show') {
+    let effective = { provider: ctx.getActiveProvName ? ctx.getActiveProvName() : null,
+                      model: ctx.getActiveModel ? ctx.getActiveModel() : null };
+    try {
+      if (typeof registry.resolveTrainer === 'function') {
+        effective = registry.resolveTrainer(ctx.cfg || {});
+      }
+    } catch { /* fall through */ }
+    const configured = (ctx.cfg && ctx.cfg.trainer) || null;
+    const cfgRender = configured
+      ? JSON.stringify(configured, null, 2)
+      : '(unset — trainer mirrors the chat provider/model)';
+    return [
+      'trainer (effective):',
+      `  provider: ${effective.provider}`,
+      `  model:    ${effective.model || '(default)'}`,
+      'trainer (configured):',
+      cfgRender,
+    ].join('\n');
+  }
+
+  if (sub === 'set') {
+    const spec = tokens[1];
+    if (!spec) return 'usage: /trainer set <provider>[:<model>]  (or `auto` for orchestrator-managed)';
+    const parsed = typeof registry.parseProviderModel === 'function'
+      ? registry.parseProviderModel(spec)
+      : { provider: spec.split(':')[0], model: spec.split(':')[1] || null };
+    if (!parsed || !parsed.provider) return `/trainer set: could not parse "${spec}"`;
+    if (parsed.provider !== 'auto') {
+      const next = _providerLookup(registry, parsed.provider);
+      if (!next) return `/trainer set: unknown provider "${parsed.provider}"`;
+    }
+    // Read-merge-write so unrelated cfg keys survive.
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const cfgPath = path.join(ctx.cfgDir, 'config.json');
+    let diskCfg = {};
+    try { diskCfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8')); } catch { /* fresh */ }
+    diskCfg.trainer = { ...(diskCfg.trainer || {}), provider: parsed.provider };
+    if (parsed.model) diskCfg.trainer.model = parsed.model;
+    else delete diskCfg.trainer.model;
+    try { fs.mkdirSync(ctx.cfgDir, { recursive: true }); } catch {}
+    fs.writeFileSync(cfgPath, JSON.stringify(diskCfg, null, 2));
+    if (ctx.cfg) ctx.cfg.trainer = { ...diskCfg.trainer };
+    return `✓ trainer → ${parsed.provider}${parsed.model ? ':' + parsed.model : ''}`;
+  }
+
+  if (sub === 'clear' || sub === 'unset') {
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const cfgPath = path.join(ctx.cfgDir, 'config.json');
+    let diskCfg = {};
+    try { diskCfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8')); } catch { /* fresh */ }
+    delete diskCfg.trainer;
+    try { fs.mkdirSync(ctx.cfgDir, { recursive: true }); } catch {}
+    fs.writeFileSync(cfgPath, JSON.stringify(diskCfg, null, 2));
+    if (ctx.cfg) delete ctx.cfg.trainer;
+    return '✓ trainer cleared (will mirror chat provider/model)';
+  }
+
+  return `/trainer: unknown sub "${sub}" — show|set <p:m>|clear`;
 }
 
-async function _trainer() {
-  return 'trainer: configure via config.json (cfg.trainer) or `lazyclaw trainer` CLI — slash form lands in v5.5.';
+// /dashboard — open the lazyclaw web UI. Reuses an already-running
+// daemon if one answers /healthz on 19600; otherwise spawns a detached
+// `node cli.mjs dashboard --no-open` child so the daemon outlives this
+// chat session. Never installs signal handlers / never process.exits —
+// Ctrl-C inside chat must NOT touch the dashboard.
+async function _dashboard(_args) {
+  const port = 19600;
+  const url = `http://127.0.0.1:${port}/dashboard`;
+  const healthUrl = `http://127.0.0.1:${port}/healthz`;
+  const { spawn } = await import('node:child_process');
+  const openBrowser = (u) => {
+    let cmd, args;
+    if (process.platform === 'darwin')      { cmd = 'open';     args = [u]; }
+    else if (process.platform === 'win32')  { cmd = 'cmd';      args = ['/c', 'start', '""', u]; }
+    else                                    { cmd = 'xdg-open'; args = [u]; }
+    try { spawn(cmd, args, { stdio: 'ignore', detached: true }).unref(); } catch { /* swallow */ }
+  };
+  const probe = async () => {
+    if (typeof fetch !== 'function') return false;
+    try {
+      const ac = new AbortController();
+      const t = setTimeout(() => ac.abort(), 300);
+      const r = await fetch(healthUrl, { signal: ac.signal });
+      clearTimeout(t);
+      return !!(r && r.ok);
+    } catch { return false; }
+  };
+  if (await probe()) {
+    openBrowser(url);
+    return `✓ dashboard already running — opened ${url}`;
+  }
+  // Spawn detached so the daemon outlives this chat process.
+  try {
+    const child = spawn(process.execPath, [process.argv[1], 'dashboard', '--no-open'], {
+      detached: true, stdio: 'ignore', cwd: process.cwd(), env: process.env,
+    });
+    child.unref();
+  } catch (e) {
+    return `dashboard error: failed to spawn — ${e?.message || e}`;
+  }
+  // Poll /healthz up to ~3s before opening the browser.
+  const start = Date.now();
+  while (Date.now() - start < 3000) {
+    if (await probe()) { openBrowser(url); return `✓ started dashboard — opened ${url}`; }
+    await new Promise((r) => setTimeout(r, 150));
+  }
+  return `⚠ dashboard didn't come up within 3s. Try \`lazyclaw dashboard\` from another terminal. URL: ${url}`;
 }
 
 // ─── dispatch table ──────────────────────────────────────────────────────
@@ -586,6 +875,7 @@ export const SLASH_HANDLERS = new Map([
   ['/usage', _usage],
   ['/new', _newReset],
   ['/reset', _newReset],
+  ['/clear', _newReset],
   ['/provider', _provider],
   ['/model', _model],
   ['/skill', _skill],
@@ -602,6 +892,7 @@ export const SLASH_HANDLERS = new Map([
   ['/personality', _personality],
   ['/task', _task],
   ['/trainer', _trainer],
+  ['/dashboard', _dashboard],
   ['/exit', async () => 'EXIT'],
   ['/quit', async () => 'EXIT'],
 ]);

package/tui/splash.mjs

@@ -161,16 +161,10 @@ function renderWide(props, cols) {
   lines.push('');
   lines.push(`${LMARGIN}Welcome to lazyclaw. Type your message or /help for commands.`);
   lines.push(`${LMARGIN}+ Tip: trainer learns from your Claude Pro subscription at $0.`);
-  lines.push('');
-
-  // 5) status bar (Hermes-style separator)
-  const sep = '─'.repeat(PANEL_W);
-  lines.push(LMARGIN + sep);
-  const ctx = props.ctxUsed != null && props.ctxTotal != null
-    ? `[${'░'.repeat(20)}] ${props.ctxUsed}/${props.ctxTotal}`
-    : `[${'░'.repeat(20)}] --`;
-  lines.push(`${LMARGIN} ${provider} · ${model} | ctx -- | ${ctx} | 0s`);
-  lines.push(LMARGIN + sep);
+  // v5.4.3 — the baked-in status row that used to live here duplicated
+  // ReplApp's real <StatusBar/> (tui/repl.mjs:476). Removing it cuts 4
+  // rows from the splash AND eliminates the visible overlap the user
+  // saw on /help in alt-buffer mode.
 
   return lines;
 }
@@ -251,16 +245,7 @@ function renderMedium(props, cols) {
   lines.push('');
   lines.push(`${LMARGIN}Welcome to lazyclaw. Type your message or /help for commands.`);
   lines.push(`${LMARGIN}+ Tip: trainer learns from your Claude Pro subscription at $0.`);
-  lines.push('');
-
-  // 5) status bar
-  const sep = '─'.repeat(PANEL_W);
-  lines.push(LMARGIN + sep);
-  const ctx = props.ctxUsed != null && props.ctxTotal != null
-    ? `[${'░'.repeat(20)}] ${props.ctxUsed}/${props.ctxTotal}`
-    : `[${'░'.repeat(20)}] --`;
-  lines.push(`${LMARGIN} ${provider} · ${model} | ctx -- | ${ctx} | 0s`);
-  lines.push(LMARGIN + sep);
+  // v5.4.3 — baked-in status row removed; ReplApp renders the real one.
 
   return lines;
 }
@@ -342,13 +327,7 @@ function renderNarrow(props, cols) {
   if (sessionId) lines.push(fit(`${LMARGIN}Session: ${sessionId}`, cols).trimEnd());
   lines.push('');
   lines.push(fit(`${LMARGIN}Welcome to lazyclaw. /help for commands.`, cols).trimEnd());
-  lines.push('');
-
-  // 7) compact status — single line, no separator dashes.
-  const ctx = props.ctxUsed != null && props.ctxTotal != null
-    ? `${props.ctxUsed}/${props.ctxTotal}`
-    : '--';
-  lines.push(fit(`${LMARGIN}${provider} · ${model} · ctx ${ctx}`, cols).trimEnd());
+  // v5.4.3 — baked-in status row removed; ReplApp renders the real one.
 
   return lines;
 }