lazyclaw 5.4.2 → 5.4.4

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.2",
+  "version": "5.4.4",
   "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

@@ -50,6 +50,74 @@ export function displayWidth(text) {
   return stringWidth(String(text));
 }
 
+// ─── 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.
+const _anchorState = { offset: 0, shimmed: false };
+
+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;
+}
+
+// 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,6 +214,22 @@ 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;
@@ -167,6 +251,35 @@ export function Editor({
 
   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
@@ -232,38 +345,79 @@ 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;
+    _installAnchorShim();
+    _anchorState.offset = rowsUp;
+    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

@@ -38,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) ─────────────────────────────────────────
@@ -187,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
@@ -356,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
@@ -385,7 +467,16 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
         ? React.createElement(
             Box,
             { flexDirection: 'column', flexGrow: 1, flexShrink: 1, overflow: 'hidden' },
-            state.scrollback.map((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
@@ -420,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, {
@@ -443,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

@@ -14,15 +14,17 @@ export const SLASH_COMMANDS = [
   { cmd: '/status',      help: 'print current provider, model, masked key' },
   { cmd: '/version',     help: 'print version + node + platform' },
   { cmd: '/new',         help: 'clear conversation and start over' },
+  { cmd: '/clear',       help: 'alias for /new — clear conversation' },
   { cmd: '/reset',       help: 'alias for /new' },
   { cmd: '/usage',       help: 'show message count + chars sent so far' },
   { cmd: '/skills',      help: 'list and activate skills (alias /skill)' },
   { cmd: '/skill',       help: 'switch active skills: /skill review,style (no arg → clear)' },
   { cmd: '/tools',       help: 'list available tool registry verbs' },
-  { cmd: '/provider',    help: 'switch provider: /provider openai (no arg → print current)' },
-  { cmd: '/model',       help: 'switch model: /model gpt-4.1 or anthropic/claude-opus-4-7' },
-  { cmd: '/trainer',     help: 'configure trainer provider/model for learning loop' },
-  { cmd: '/personality', help: 'switch agent personality preset' },
+  { cmd: '/provider',    help: 'pick provider from a list (or pass a name: /provider openai)' },
+  { cmd: '/model',       help: 'pick a model from a list (or pass a name: /model gpt-4.1)' },
+  { cmd: '/trainer',     help: 'view or set trainer provider/model: /trainer show|set <p:m>|clear' },
+  { cmd: '/personality', help: 'pick a personality (or sub: list|show|install|remove|use)' },
+  { cmd: '/dashboard',   help: 'open the lazyclaw web UI in your browser' },
   { cmd: '/loop',        help: 'repeat one prompt: /loop "fix lint" [--max N] [--until "<regex>"]' },
   { cmd: '/goal',        help: 'register/switch goal: /goal add NAME | /goal list' },
   { cmd: '/memory',      help: 'show layered memory: /memory [core|recent|episodic [topic]]' },
@@ -30,7 +32,7 @@ export const SLASH_COMMANDS = [
   { cmd: '/dream',       help: 'consolidate recent memory into per-topic episodic files' },
   { cmd: '/agent',       help: 'spawn or switch agent: /agent NAME' },
   { cmd: '/team',        help: 'list, create, or join a team' },
-  { cmd: '/task',        help: 'create, list, or manage tasks' },
+  { cmd: '/task',        help: 'list/show/transcript/abandon/done/remove (start/tick: CLI)' },
   { cmd: '/handoff',     help: 'hand current task off to another agent' },
   { cmd: '/exit',        help: 'leave the chat' },
   { cmd: '/quit',        help: 'alias for /exit' },

package/tui/slash_dispatcher.mjs

@@ -73,14 +73,19 @@ async function _help() {
 
 async function _status(_args, ctx) {
   const registry = await _mod(ctx, 'registryMod', () => import('../providers/registry.mjs'));
-  const out = {
-    provider: ctx.getActiveProvName(),
-    model: ctx.getActiveModel(),
-    keyMasked: registry.maskApiKey(ctx.cfg && ctx.cfg['api-key']),
-    messageCount: ctx.getMessages().length,
-    sessionId: ctx.getSessionId() || null,
-  };
-  return JSON.stringify(out);
+  const provider = ctx.getActiveProvName();
+  const model = ctx.getActiveModel() || '(default)';
+  const keyMasked = registry.maskApiKey(ctx.cfg && ctx.cfg['api-key']);
+  const messageCount = ctx.getMessages().length;
+  const sessionId = ctx.getSessionId() || '(none — in-memory)';
+  return [
+    'status:',
+    `  provider:  ${provider}`,
+    `  model:     ${model}`,
+    `  api key:   ${keyMasked}`,
+    `  messages:  ${messageCount}`,
+    `  session:   ${sessionId}`,
+  ].join('\n');
 }
 
 async function _version(_args, ctx) {
@@ -91,22 +96,33 @@ async function _version(_args, ctx) {
 async function _usage(_args, ctx) {
   const msgs = ctx.getMessages();
   const runningUsage = ctx.getRunningUsage && ctx.getRunningUsage();
-  const out = {
-    messageCount: msgs.length,
-    charsSent: (ctx.getCharsSent && ctx.getCharsSent()) || 0,
-  };
-  if (runningUsage) out.tokens = runningUsage;
-  if (runningUsage && ctx.cfg && ctx.cfg.rates && typeof ctx.cfg.rates === 'object') {
-    try {
-      const { costFromUsage } = await import('../providers/rates.mjs');
-      const r = costFromUsage(
-        { provider: ctx.getActiveProvName(), model: ctx.getActiveModel(), usage: runningUsage },
-        ctx.cfg.rates,
-      );
-      if (r) out.cost = r;
-    } catch { /* never let cost-card lookup fail the slash */ }
-  }
-  return JSON.stringify(out);
+  const charsSent = (ctx.getCharsSent && ctx.getCharsSent()) || 0;
+  const lines = [
+    'usage:',
+    `  messages:  ${msgs.length}`,
+    `  chars sent: ${charsSent.toLocaleString('en-US')}`,
+  ];
+  if (runningUsage) {
+    lines.push(
+      `  tokens in:  ${(runningUsage.inputTokens || 0).toLocaleString('en-US')}`,
+      `  tokens out: ${(runningUsage.outputTokens || 0).toLocaleString('en-US')}`,
+      `  tokens tot: ${(runningUsage.totalTokens || 0).toLocaleString('en-US')}`,
+      `  turns:      ${runningUsage.turnsWithUsage || 0}`,
+    );
+    if (ctx.cfg && ctx.cfg.rates && typeof ctx.cfg.rates === 'object') {
+      try {
+        const { costFromUsage } = await import('../providers/rates.mjs');
+        const r = costFromUsage(
+          { provider: ctx.getActiveProvName(), model: ctx.getActiveModel(), usage: runningUsage },
+          ctx.cfg.rates,
+        );
+        if (r && r.totalUsd != null) {
+          lines.push(`  cost (USD): $${Number(r.totalUsd).toFixed(4)}`);
+        }
+      } catch { /* never let cost-card lookup fail the slash */ }
+    }
+  }
+  return lines.join('\n');
 }
 
 async function _newReset(_args, ctx) {
@@ -125,16 +141,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 +185,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);
@@ -254,8 +311,15 @@ async function _memory(args, ctx) {
     return body || '(empty core memory)';
   }
   if (which === 'recent') {
-    const items = mem.loadRecent(20, ctx.cfgDir);
-    return JSON.stringify(items, null, 2);
+    const items = mem.loadRecent(20, ctx.cfgDir) || [];
+    if (!items.length) return '(no recent memory)';
+    return ['recent memory (last ' + items.length + '):',
+      ...items.map((it, i) => {
+        const role = it.role || 'msg';
+        const content = String(it.content || '').replace(/\s+/g, ' ').slice(0, 80);
+        return `  ${String(i + 1).padStart(2)}. [${role}] ${content}${(it.content || '').length > 80 ? '…' : ''}`;
+      })
+    ].join('\n');
   }
   if (which === 'episodic') {
     const topic = tokens[1];
@@ -263,7 +327,11 @@ async function _memory(args, ctx) {
       const body = mem.loadEpisodic(topic, ctx.cfgDir);
       return body || `(no episodic file "${topic}")`;
     }
-    return JSON.stringify(mem.listEpisodic(ctx.cfgDir), null, 2);
+    const items = mem.listEpisodic(ctx.cfgDir) || [];
+    if (!items.length) return '(no episodic files yet — run /dream to consolidate)';
+    return ['episodic files:',
+      ...items.map((it) => `  • ${typeof it === 'string' ? it : (it.topic || JSON.stringify(it))}`)
+    ].join('\n');
   }
   return 'usage: /memory [core|recent|episodic [topic]]';
 }
@@ -562,19 +630,386 @@ 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)`;
 }
 
-async function _task() {
-  return 'task: slash form lands in v5.5 — use the `lazyclaw task` CLI for now.';
+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 _trainer() {
-  return 'trainer: configure via config.json (cfg.trainer) or `lazyclaw trainer` CLI — slash form lands in v5.5.';
+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 _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`;
+}
+
+// /dashboard — open the lazyclaw web UI.
+//
+// v5.4.4 ROOT-CAUSE FIX (was: rapid repeated /dashboard within one chat
+// session spawned 20+ daemon children).
+//
+// Original implementation:
+//   probe /healthz → if !200, spawn detached `lazyclaw dashboard
+//   --no-open` and poll for up to 3s.
+//
+// Failure mode that produced the 20+ spawn pile-up:
+//   1. User types /dashboard. probe fails (no daemon). Spawn child A.
+//   2. Child A begins binding port 19600. Takes ~500ms-2s to be ready.
+//   3. User types /dashboard again BEFORE A is ready. probe still fails.
+//      Spawn child B. Child B sees EADDRINUSE and calls _killPortOccupant
+//      (cli.mjs:3611) which SIGTERMs child A. B takes over.
+//   4. Repeat. Each /dashboard kills the previous daemon and starts a
+//      new one. With autorepeat / many slash calls this stacks fast.
+//
+// Two-layer guard:
+//   - A module-level _dashboardSpawning latch refuses concurrent spawn
+//     attempts. While a spawn is in flight, /dashboard says so + returns
+//     without firing another child.
+//   - A _dashboardChildPid cache remembers the PID we already spawned;
+//     subsequent calls check kill(pid, 0) to confirm the child is alive
+//     and just open the browser without spawning.
+//
+// We probe both /healthz (HTTP) AND a raw net.connect port check so a
+// slow-starting daemon (binding the listener but not yet answering HTTP)
+// still counts as "running".
+let _dashboardSpawning = false;
+let _dashboardChildPid = null;
+
+function _portIsListening(port, timeoutMs = 200) {
+  return new Promise((resolve) => {
+    import('node:net').then(({ createConnection }) => {
+      let settled = false;
+      const sock = createConnection({ host: '127.0.0.1', port });
+      const done = (ok) => {
+        if (settled) return;
+        settled = true;
+        try { sock.destroy(); } catch {}
+        resolve(ok);
+      };
+      sock.once('connect', () => done(true));
+      sock.once('error', () => done(false));
+      setTimeout(() => done(false), timeoutMs);
+    }).catch(() => resolve(false));
+  });
+}
+
+async function _dashboardProbe(port) {
+  // Fast path — port-level probe. Catches a daemon that has bound the
+  // socket but hasn't finished initializing its HTTP routes.
+  if (await _portIsListening(port, 200)) return true;
+  // Slow path — full /healthz fetch, for defense in depth.
+  if (typeof fetch !== 'function') return false;
+  try {
+    const ac = new AbortController();
+    const t = setTimeout(() => ac.abort(), 250);
+    const r = await fetch(`http://127.0.0.1:${port}/healthz`, { signal: ac.signal });
+    clearTimeout(t);
+    return !!(r && r.ok);
+  } catch { return false; }
+}
+
+function _openBrowser(url) {
+  return import('node:child_process').then(({ spawn }) => {
+    let cmd, args;
+    if (process.platform === 'darwin')      { cmd = 'open';     args = [url]; }
+    else if (process.platform === 'win32')  { cmd = 'cmd';      args = ['/c', 'start', '""', url]; }
+    else                                    { cmd = 'xdg-open'; args = [url]; }
+    try { spawn(cmd, args, { stdio: 'ignore', detached: true }).unref(); } catch { /* swallow */ }
+  });
+}
+
+async function _dashboardStop(port) {
+  // Best-effort kill of every lazyclaw dashboard daemon on the box.
+  // Used to clean up after the v5.4.3 spawn pile-up bug.
+  if (process.platform === 'win32') {
+    return 'dashboard stop: not implemented on Windows yet — kill via Task Manager';
+  }
+  const { spawn } = await import('node:child_process');
+  // Step 1: lsof the port and SIGTERM each PID.
+  const portPids = await new Promise((resolve) => {
+    try {
+      const lsof = spawn('lsof', ['-ti', `tcp:${port}`], { stdio: ['ignore', 'pipe', 'ignore'] });
+      let buf = '';
+      lsof.stdout.on('data', (d) => { buf += d.toString('utf8'); });
+      lsof.on('error', () => resolve([]));
+      lsof.on('close', () => resolve(
+        buf.trim().split(/\s+/).map((s) => parseInt(s, 10)).filter(Number.isFinite)
+      ));
+    } catch { resolve([]); }
+  });
+  for (const pid of portPids) {
+    try { process.kill(pid, 'SIGTERM'); } catch { /* gone */ }
+  }
+  // Step 2: pkill any process whose command line includes "lazyclaw dashboard"
+  // — catches detached children that bound a different (random) port via
+  // cmdDashboard's EADDRINUSE fallback.
+  let pkilled = 0;
+  try {
+    const pkill = spawn('pkill', ['-f', 'lazyclaw dashboard'], { stdio: ['ignore', 'ignore', 'ignore'] });
+    pkilled = await new Promise((r) => pkill.on('close', (code) => r(code === 0 ? 1 : 0)));
+  } catch { /* fine */ }
+  _dashboardChildPid = null;
+  return `✓ stopped ${portPids.length} listener(s) on :${port}${pkilled ? ' + remaining `lazyclaw dashboard` processes via pkill' : ''}`;
+}
+
+async function _dashboard(args) {
+  const port = 19600;
+  const url = `http://127.0.0.1:${port}/dashboard`;
+  const sub = splitWhitespace(args)[0];
+  if (sub === 'stop' || sub === 'kill') return _dashboardStop(port);
+
+  // 1. Already running anywhere on the machine? → reuse.
+  if (await _dashboardProbe(port)) {
+    await _openBrowser(url);
+    return `✓ dashboard already running — opened ${url}`;
+  }
+
+  // 2. We spawned in this chat — is that child still alive?
+  if (_dashboardChildPid != null) {
+    try {
+      process.kill(_dashboardChildPid, 0); // signal 0 = liveness probe
+      // Child alive but not answering yet. Don't re-spawn; just nudge.
+      await _openBrowser(url);
+      return `✓ dashboard starting (pid ${_dashboardChildPid}) — opened ${url}`;
+    } catch {
+      _dashboardChildPid = null; // child died; fall through and respawn.
+    }
+  }
+
+  // 3. Spawn already in flight from a concurrent /dashboard? Don't pile on.
+  if (_dashboardSpawning) {
+    await _openBrowser(url);
+    return `dashboard is still booting — opened ${url}; try again in a moment if it didn't load`;
+  }
+
+  // 4. Cold start. Spawn ONE detached child, poll up to 3s, latch the
+  //    spawn flag in a finally so it always clears.
+  _dashboardSpawning = true;
+  try {
+    const { spawn } = await import('node:child_process');
+    let child;
+    try {
+      child = spawn(process.execPath, [process.argv[1], 'dashboard', '--no-open'], {
+        detached: true, stdio: 'ignore', cwd: process.cwd(), env: process.env,
+      });
+      child.unref();
+      _dashboardChildPid = child.pid;
+    } catch (e) {
+      return `dashboard error: failed to spawn — ${e?.message || e}`;
+    }
+    const start = Date.now();
+    while (Date.now() - start < 3000) {
+      if (await _dashboardProbe(port)) {
+        await _openBrowser(url);
+        return `✓ started dashboard (pid ${child.pid}) — opened ${url}`;
+      }
+      await new Promise((r) => setTimeout(r, 150));
+    }
+    return `⚠ dashboard didn't come up within 3s (pid ${child.pid}). URL: ${url}`;
+  } finally {
+    _dashboardSpawning = false;
+  }
 }
 
 // ─── dispatch table ──────────────────────────────────────────────────────
@@ -586,6 +1021,7 @@ export const SLASH_HANDLERS = new Map([
   ['/usage', _usage],
   ['/new', _newReset],
   ['/reset', _newReset],
+  ['/clear', _newReset],
   ['/provider', _provider],
   ['/model', _model],
   ['/skill', _skill],
@@ -602,6 +1038,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;
 }