lazyclaw 5.1.0 → 5.3.0

package/providers/tool_use/anthropic.mjs

@@ -51,6 +51,13 @@ export async function callOnce({
   baseUrl,
   fetchImpl,
   signal,
+  // Group B / C9 — prompt caching. Opt-in; the existing phase 12b/24
+  // test surface asserts the no-cache byte shape so this defaults off.
+  // Production call sites (agent_turn, mention_router) pass `cache:true`
+  // so every real Messages API call from the tool-use path gets a
+  // cache_control:ephemeral block on the static system prefix AND on
+  // the last tool object (so the tool schema cache also benefits).
+  cache = false,
 } = {}) {
   if (!Array.isArray(messages) || messages.length === 0) {
     throw new AnthropicToolUseError('messages[] is required and non-empty', 'NO_MESSAGES');
@@ -65,16 +72,45 @@ export async function callOnce({
     max_tokens: maxTokens,
     messages,
   };
-  if (system && String(system).trim()) body.system = String(system);
-  if (tools && tools.length) body.tools = tools;
+  if (system && String(system).trim()) {
+    if (cache) {
+      // Lift the system string into a one-block array carrying
+      // cache_control. The Anthropic API accepts either a plain string
+      // OR an array of text blocks here; we use the array form so we
+      // can attach the breakpoint marker.
+      body.system = [{ type: 'text', text: String(system), cache_control: { type: 'ephemeral' } }];
+    } else {
+      body.system = String(system);
+    }
+  }
+  if (tools && tools.length) {
+    if (cache) {
+      // Clone the array (don't mutate the caller's reference) and
+      // attach cache_control to the LAST tool — that marks the entire
+      // tool block as cacheable, per Anthropic's spec.
+      const cloned = tools.map((t, i) => (i === tools.length - 1
+        ? { ...t, cache_control: { type: 'ephemeral' } }
+        : t));
+      body.tools = cloned;
+    } else {
+      body.tools = tools;
+    }
+  }
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'x-api-key': apiKey,
+    'anthropic-version': ANTHROPIC_VERSION,
+  };
+  if (cache) {
+    // The prompt-caching beta header. Required only on early adoption;
+    // safe to include on newer API versions where it's a no-op.
+    headers['anthropic-beta'] = 'prompt-caching-2024-07-31';
+  }
 
   const res = await fetchFn(url, {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'x-api-key': apiKey,
-      'anthropic-version': ANTHROPIC_VERSION,
-    },
+    headers,
     body: JSON.stringify(body),
     signal,
   });

package/skills.mjs

@@ -15,6 +15,22 @@ import os from 'node:os';
 const SKILLS_DIRNAME = 'skills';
 const SKILL_EXT = '.md';
 
+// Group B / M8 — memoize listSkills() + skillsIndex() per configDir.
+// composePromptStack is called on every chat/agent turn; listing the
+// skills directory + statting + reading every file used to cost ~2-5 ms
+// at ~30 skills, and was the largest non-network item in the per-turn
+// flame graph. Cache key is the skills/ directory's mtimeMs — any
+// install/remove via this module bumps it (writeFile updates the
+// containing dir's mtime). Manual edits with `vim` also bust the cache
+// because writing a file in a directory updates that dir's mtime.
+// _invalidateSkillsCache() is exported as the safety hatch for callers
+// that want to be explicit.
+const _indexCache = new Map();  // cfgDir → { mtimeMs, skills, index }
+
+export function _invalidateSkillsCache(configDir = defaultConfigDir()) {
+  _indexCache.delete(configDir);
+}
+
 export function defaultConfigDir() {
   return process.env.LAZYCLAW_CONFIG_DIR || path.join(os.homedir(), '.lazyclaw');
 }
@@ -33,7 +49,14 @@ export function skillPath(name, configDir = defaultConfigDir()) {
 export function listSkills(configDir = defaultConfigDir()) {
   const dir = skillsDir(configDir);
   if (!fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir)
+  // M8 — cache hit when the skills/ directory's mtime is unchanged.
+  let dirMtime = 0;
+  try { dirMtime = fs.statSync(dir).mtimeMs; } catch { /* unreadable → bypass cache */ }
+  const cached = _indexCache.get(configDir);
+  if (cached && cached.mtimeMs === dirMtime && dirMtime > 0) {
+    return cached.skills;
+  }
+  const skills = fs.readdirSync(dir)
     .filter(name => name.endsWith(SKILL_EXT))
     .map(name => {
       const full = path.join(dir, name);
@@ -57,6 +80,10 @@ export function listSkills(configDir = defaultConfigDir()) {
       };
     })
     .sort((a, b) => a.name.localeCompare(b.name));
+  if (dirMtime > 0) {
+    _indexCache.set(configDir, { mtimeMs: dirMtime, skills, index: null });
+  }
+  return skills;
 }
 
 // Parse a leading YAML frontmatter block (--- … ---). Only the flat
@@ -108,9 +135,19 @@ function firstHeading(body) {
 // paying for their full bodies (progressive disclosure — the model
 // pulls a full skill on demand via the skill_view tool).
 export function skillsIndex(configDir = defaultConfigDir()) {
+  // Memoize the rendered index alongside the cached skills array — both
+  // are pure functions of the skills/ mtime.
+  const cached = _indexCache.get(configDir);
+  if (cached && cached.index !== null) return cached.index;
   const skills = listSkills(configDir);
-  if (!skills.length) return '';
-  return skills.map((s) => `- ${s.name}: ${s.summary}`.trimEnd()).join('\n');
+  if (!skills.length) {
+    if (cached) cached.index = '';
+    return '';
+  }
+  const index = skills.map((s) => `- ${s.name}: ${s.summary}`.trimEnd()).join('\n');
+  const refreshed = _indexCache.get(configDir);
+  if (refreshed) refreshed.index = index;
+  return index;
 }
 
 export function loadSkill(name, configDir = defaultConfigDir()) {
@@ -123,12 +160,14 @@ export function installSkill(name, content, configDir = defaultConfigDir()) {
   const p = skillPath(name, configDir);
   fs.mkdirSync(path.dirname(p), { recursive: true });
   fs.writeFileSync(p, content);
+  _invalidateSkillsCache(configDir);
   return p;
 }
 
 export function removeSkill(name, configDir = defaultConfigDir()) {
   const p = skillPath(name, configDir);
   if (fs.existsSync(p)) fs.unlinkSync(p);
+  _invalidateSkillsCache(configDir);
 }
 
 export function skillExists(name, configDir = defaultConfigDir()) {

package/tasks.mjs

@@ -157,7 +157,30 @@ export function appendTurn(id, turn, configDir = defaultConfigDir()) {
   const t = getTask(id, configDir);
   if (!t) throw new TaskError(`no task "${id}"`, 'TASK_NO_TASK');
   const turns = Array.isArray(t.turns) ? [...t.turns, turn] : [turn];
-  return patchTask(id, { turns }, configDir);
+  const next = patchTask(id, { turns }, configDir);
+  // v5 Group A (M4): mirror the appended turn to the FTS5 sessions
+  // index using session_id = `task:<id>` so the recall tool can surface
+  // task transcripts the same way it surfaces chat sessions. Namespaced
+  // with the `task:` prefix to avoid colliding with chat session ids.
+  // Best-effort: any FTS failure stays inside the dynamic-import block
+  // so a missing index_db (e.g. in a stripped test env) never breaks
+  // task writes.
+  try {
+    void (async () => {
+      try {
+        const { indexSessionTurn } = await import('./mas/index_db.mjs');
+        const turnIdx = turns.length - 1;
+        indexSessionTurn({
+          session_id: `task:${id}`,
+          turn_idx: turnIdx,
+          role: turn.agent === 'user' ? 'user' : 'assistant',
+          ts: Date.parse(turn.ts) || Date.now(),
+          content: turn.text || '',
+        }, configDir);
+      } catch { /* swallow */ }
+    })();
+  } catch { /* swallow */ }
+  return next;
 }
 
 export function removeTask(id, configDir = defaultConfigDir()) {

package/tui/editor.mjs

@@ -2,6 +2,14 @@
 //
 // Pure-functional core (makeEditorState, applyKey) so it is testable
 // without ink stdin. The React component <Editor/> wraps useInput().
+//
+// v5.4: slash-popup integration. When the parent passes a non-empty
+// `slashSuggestions` array, ↑/↓ move the popup selection (instead of
+// scrolling history) and Tab/Enter fill the buffer with the highlighted
+// command WITHOUT submitting it (Anthropic's recent UX rule: first
+// Enter fills, second Enter runs). Esc clears the buffer + dismisses.
+// All popup-aware branches are guarded by `slashOpen` so legacy callers
+// see the pre-v5.4 behavior verbatim.
 import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import { theme } from './theme.mjs';
@@ -63,11 +71,83 @@ export function applyKey(state, evt) {
   return next;
 }
 
-export function Editor({ history, onSubmit }) {
+// Pure helper used by the slash-popup branch in <Editor/>. Replaces the
+// editor buffer with `${cmd} ` (note trailing space so the user can keep
+// typing args without an extra keystroke). Does NOT submit.
+export function fillSlashCommand(state, cmd) {
+  const filled = cmd.endsWith(' ') ? cmd : cmd + ' ';
+  return {
+    ...state,
+    buffer: filled,
+    cursor: filled.length,
+    lastSubmit: null,
+    lastWasPaste: false,
+  };
+}
+
+export function Editor({
+  history,
+  onSubmit,
+  onEscape,
+  onBufferChange,
+  // v5.4 slash-popup wiring (all optional — pre-v5.4 callers pass none):
+  slashSuggestions,      // Array<{cmd,help}> | null
+  slashSelectedIndex,    // number
+  onSlashMove,           // (delta: -1 | +1) => void
+  onSlashDismiss,        // () => void
+}) {
   const [state, setState] = useState(() => makeEditorState({ history }));
+  const slashOpen = Array.isArray(slashSuggestions) && slashSuggestions.length > 0;
+
   useInput((input, key) => {
+    // ─── 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);
+        if (onBufferChange) {
+          try { onBufferChange(''); } catch {}
+        }
+        if (onSlashDismiss) onSlashDismiss();
+        return;
+      }
+      // ↑/↓ navigate the popup instead of history.
+      if (key.upArrow) {
+        if (onSlashMove) onSlashMove(-1);
+        return;
+      }
+      if (key.downArrow) {
+        if (onSlashMove) onSlashMove(+1);
+        return;
+      }
+      // Tab / Enter — fill the buffer with the highlighted command.
+      // First Enter fills, second Enter runs (matches Anthropic's UX).
+      if (key.tab || key.return) {
+        const safeIdx = Math.max(0, Math.min(slashSuggestions.length - 1, slashSelectedIndex || 0));
+        const picked = slashSuggestions[safeIdx];
+        if (picked) {
+          const next = fillSlashCommand(state, picked.cmd);
+          setState(next);
+          if (onBufferChange) {
+            try { onBufferChange(next.buffer); } catch {}
+          }
+        }
+        return;
+      }
+      // Anything else (printable, backspace) falls through to applyKey.
+    }
+
+    // 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);
+    if (onBufferChange) {
+      try { onBufferChange(next.buffer); } catch { /* observer is best-effort */ }
+    }
   });
   useEffect(() => {
     if (state.lastSubmit !== null && onSubmit) onSubmit(state.lastSubmit);

package/tui/repl.mjs

@@ -1,18 +1,56 @@
 // tui/repl.mjs — REPL host with mid-stream interrupt-and-redirect
-// (spec §5.8). Pure state functions for testability; the React
-// mount lives at the bottom and is exercised only when stdin isTTY.
-import React, { useState, useEffect } from 'react';
-import { Box, useApp } from 'ink';
-import { Splash } from './splash.mjs';
+// (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.
+//   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.
+//   3. <StatusBar/> — single row above the input. flexShrink:0.
+//   4. <Editor/> — sticky bottom, content-sized (1 line idle, grows with
+//      multiline). Last sibling in the column so it pins to the bottom.
+//
+// Streaming chunks now flow into React state via an injected writeFn
+// (state.liveAssistant += chunk). On turn completion the accumulated
+// text is committed to scrollback so React stops re-rendering it.
+// This closes the v5.0.10 TODO from cli.mjs:2628-2632.
+//
+// Backward-compat contracts (do not break):
+//   - makeReplState()              — still callable with zero args.
+//   - onUserInput, onEscape, onTurnComplete, consumeNextTurnFirstMessage
+//     keep their pre-v5.3 shapes (tests/phaseC-repl-interrupt.test.mjs).
+//   - ReplApp({ splashProps, runTurn })  — legacy callsite (cli.mjs:2637)
+//     still works; runTurn writes go to wherever its writeFn points.
+//   - ReplApp({ splashProps, runTurnFactory })  — new callsite for the
+//     sticky layout; ReplApp injects writeFn → scrollback.
+//
+import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import { Box, Static, Text, useApp } from 'ink';
+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 { theme } from './theme.mjs';
 
-export function makeReplState() {
+// ─── Pure state ──────────────────────────────────────────────────────────
+//
+// makeReplState stays callable with zero args (existing tests rely on it).
+// The new fields default to empty so legacy callers see no behavior change.
+export function makeReplState(opts) {
+  const splashItem = opts && opts.splashItem ? opts.splashItem : null;
   return {
     streaming: false,
     controller: null,
     pendingPrepend: null,
     nextTurnFirstMessage: null,
     history: [],
+    scrollback: splashItem ? [splashItem] : [],
+    liveAssistant: '',
+    turnCounter: 0,
   };
 }
 
@@ -22,12 +60,16 @@ export function onUserInput(state, { text, controller }) {
     try { state.controller.abort(); } catch {}
     return { ...state, pendingPrepend: text };
   }
-  // idle — start a new turn.
+  // idle — start a new turn. Append a 'user' entry to scrollback so the
+  // sticky-layout caller sees the prompt history above the live stream.
+  const id = `u-${state.turnCounter}`;
   return {
     ...state,
     streaming: true,
     controller,
     history: [...state.history, text],
+    scrollback: [...state.scrollback, { kind: 'user', id, text }],
+    turnCounter: state.turnCounter + 1,
   };
 }
 
@@ -35,18 +77,45 @@ export function onEscape(state) {
   if (state.streaming && state.controller) {
     try { state.controller.abort(); } catch {}
   }
-  return { ...state, streaming: false, controller: null, pendingPrepend: null };
+  // Drop any partial live assistant text on explicit Esc — the user is
+  // telling us to discard, not to keep.
+  return {
+    ...state,
+    streaming: false,
+    controller: null,
+    pendingPrepend: null,
+    liveAssistant: '',
+  };
+}
+
+// New reducer: stream chunk arrives, accumulate in liveAssistant.
+export function onStreamChunk(state, { chunk }) {
+  return { ...state, liveAssistant: state.liveAssistant + chunk };
 }
 
 export function onTurnComplete(state, { reason } = {}) {
-  void reason;
   const promoted = state.pendingPrepend;
+  const suffix = reason === 'aborted' ? ' [aborted]'
+              : reason === 'error'   ? ' [error]'
+              : '';
+  const text = (state.liveAssistant || '') + suffix;
+  // Commit any accumulated live text to scrollback. If the turn produced
+  // nothing AND wasn't an error/abort, skip the empty append.
+  const shouldCommit = text.length > 0 && (state.liveAssistant.length > 0 || suffix.length > 0);
+  const id = `a-${state.turnCounter}`;
+  const kind = reason === 'error' ? 'error' : 'assistant';
+  const nextScrollback = shouldCommit
+    ? [...state.scrollback, { kind, id, text }]
+    : state.scrollback;
   return {
     ...state,
     streaming: false,
     controller: null,
     pendingPrepend: null,
     nextTurnFirstMessage: promoted,
+    liveAssistant: '',
+    scrollback: nextScrollback,
+    turnCounter: state.turnCounter + 1,
   };
 }
 
@@ -56,34 +125,202 @@ export function consumeNextTurnFirstMessage(state) {
 }
 
 // ─── React mount ─────────────────────────────────────────────────────────
-export function ReplApp({ splashProps, runTurn }) {
-  const [state, setState] = useState(makeReplState);
+//
+// Two prop modes:
+//   - 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 }) {
+  // Splash is rendered ONCE as scrollback[0] via <Static>. Build it lazily
+  // so SSR-style imports without a TTY don't crash on process.stdout.
+  const splashItemRef = useRef(null);
+  if (splashItemRef.current === null) {
+    splashItemRef.current = splashProps
+      ? { kind: 'splash', id: 'splash-0', splashProps }
+      : null;
+  }
+  const [state, setState] = useState(() => makeReplState({ splashItem: splashItemRef.current }));
   const { exit } = useApp();
 
-  async function handleSubmit(text) {
-    if (text === '/exit') { exit(); return; }
+  // writeFn for run_turn: route chunks into React state instead of stdout.
+  // Only used when runTurnFactory is provided; the legacy `runTurn` prop
+  // keeps writing wherever its caller wired it.
+  const writeFn = useCallback((chunk) => {
+    setState((s) => onStreamChunk(s, { chunk }));
+  }, []);
+
+  // Build the actual runTurn once. Prefer factory (new); fall back to
+  // the legacy `runTurn` prop (existing cli.mjs callsite).
+  const runTurnRef = useRef(null);
+  if (runTurnRef.current === null) {
+    if (typeof runTurnFactory === 'function') {
+      runTurnRef.current = runTurnFactory(writeFn);
+    } else if (typeof runTurn === 'function') {
+      runTurnRef.current = runTurn;
+    } else {
+      runTurnRef.current = async () => {};
+    }
+  }
+
+  const handleSubmit = useCallback(async (text) => {
+    if (text === '/exit' || text === '/quit') { exit(); return; }
     const controller = new AbortController();
     setState((s) => onUserInput(s, { text, controller }));
     try {
-      await runTurn(text, controller.signal);
+      await runTurnRef.current(text, controller.signal);
       setState((s) => onTurnComplete(s, { reason: 'done' }));
     } catch (err) {
-      setState((s) => onTurnComplete(s, { reason: err.name === 'AbortError' ? 'aborted' : 'error' }));
+      setState((s) => onTurnComplete(s, {
+        reason: err && err.name === 'AbortError' ? 'aborted' : 'error',
+      }));
     }
-  }
+  }, [exit]);
 
+  // Auto-submit queued mid-stream-interrupt message (spec §5.8). Read
+  // state.nextTurnFirstMessage so the effect re-fires when promoted.
   useEffect(() => {
-    const [next, msg] = consumeNextTurnFirstMessage(state);
-    if (msg) {
-      setState(next);
+    if (state.nextTurnFirstMessage) {
+      const msg = state.nextTurnFirstMessage;
+      setState((s) => ({ ...s, nextTurnFirstMessage: null }));
       handleSubmit(msg);
     }
-  }, [state.nextTurnFirstMessage]);
+  }, [state.nextTurnFirstMessage, handleSubmit]);
+
+  // Esc handler — abort streaming turn, drop partial output.
+  const onEscapeKey = useCallback(() => {
+    setState((s) => onEscape(s));
+  }, []);
+
+  // ─── Slash popup state (v5.4) ──────────────────────────────────────
+  // The editor reports its current buffer via onBufferChange; we derive
+  // the filtered command list from that and own the selection index.
+  const catalog = useMemo(
+    () => (Array.isArray(slashCommands) && slashCommands.length > 0
+      ? slashCommands : SLASH_COMMANDS),
+    [slashCommands]
+  );
+  const [bufferPeek, setBufferPeek] = useState('');
+  const [selectedSuggestion, setSelectedSuggestion] = useState(0);
+  const filtered = useMemo(
+    () => filterSlashCommands(bufferPeek, catalog),
+    [bufferPeek, catalog]
+  );
+  // Reset selection whenever the match list changes length (typing
+  // narrows results, so highlight the first row again).
+  const lastLenRef = useRef(0);
+  useEffect(() => {
+    if (filtered.length !== lastLenRef.current) {
+      setSelectedSuggestion(0);
+      lastLenRef.current = filtered.length;
+    } else if (selectedSuggestion >= filtered.length) {
+      setSelectedSuggestion(Math.max(0, filtered.length - 1));
+    }
+  }, [filtered.length, selectedSuggestion]);
+
+  const handleBufferChange = useCallback((buf) => {
+    setBufferPeek(buf || '');
+  }, []);
+  const handleSlashMove = useCallback((delta) => {
+    setSelectedSuggestion((i) => {
+      const max = Math.max(0, filtered.length - 1);
+      const n = i + delta;
+      if (n < 0) return 0;
+      if (n > max) return max;
+      return n;
+    });
+  }, [filtered.length]);
+  const handleSlashDismiss = useCallback(() => {
+    setBufferPeek('');
+    setSelectedSuggestion(0);
+  }, []);
+
+  const showSlashPopup = bufferPeek.startsWith('/') && filtered.length > 0;
 
   return React.createElement(
     Box,
     { flexDirection: 'column' },
-    React.createElement(Splash, splashProps),
-    React.createElement(Editor, { history: state.history, onSubmit: handleSubmit })
+    // 1) Scrollback (write-once via Ink Static)
+    React.createElement(
+      Static,
+      { items: state.scrollback },
+      (item) => React.createElement(ScrollbackItem, { key: item.id, item })
+    ),
+    // 2) Live region — partial assistant stream
+    state.liveAssistant
+      ? React.createElement(
+          Box,
+          { flexDirection: 'column' },
+          React.createElement(Text, { color: theme.fg }, state.liveAssistant)
+        )
+      : null,
+    // 3) Slash popup — flex sibling above the StatusBar; Ink can't
+    //    absolutely position so this is the "just above input" pattern.
+    showSlashPopup
+      ? React.createElement(SlashPopup, {
+          buffer: bufferPeek,
+          commands: filtered,
+          selectedIndex: selectedSuggestion,
+        })
+      : null,
+    // 4) Status bar (sticky, single row above input)
+    React.createElement(StatusBar, {
+      provider: splashProps && splashProps.provider,
+      model: splashProps && splashProps.model,
+      streaming: state.streaming,
+      ctxUsed: splashProps && splashProps.ctxUsed,
+      ctxTotal: splashProps && splashProps.ctxTotal,
+    }),
+    // 5) Editor — sticky bottom, content-sized
+    React.createElement(Editor, {
+      history: state.history,
+      onSubmit: handleSubmit,
+      onEscape: onEscapeKey,
+      onBufferChange: handleBufferChange,
+      slashSuggestions: showSlashPopup ? filtered : null,
+      slashSelectedIndex: selectedSuggestion,
+      onSlashMove: handleSlashMove,
+      onSlashDismiss: handleSlashDismiss,
+    })
   );
 }
+
+// ScrollbackItem renders each <Static/> child. Splash renders via the
+// real <Splash/> component (preserves gradient wordmark colorization);
+// everything else is plain Text.
+export function ScrollbackItem({ item }) {
+  if (item.kind === 'splash') {
+    return React.createElement(Splash, item.splashProps);
+  }
+  if (item.kind === 'user') {
+    return React.createElement(
+      Box,
+      { flexDirection: 'column' },
+      React.createElement(Text, null, theme.accent('› ') + item.text)
+    );
+  }
+  if (item.kind === 'error') {
+    return React.createElement(Text, { color: 'red' }, item.text);
+  }
+  // 'assistant' (default)
+  return React.createElement(Text, { color: theme.fg }, item.text);
+}
+
+// StatusBar — single row, provider · model · ctx · streaming indicator.
+// Kept intentionally minimal in v5.3; token gauges land separately once
+// usage metrics flow into state.
+export function StatusBar({ provider, model, streaming, ctxUsed, ctxTotal }) {
+  const ctx = (ctxUsed != null && ctxTotal != null) ? `${ctxUsed}/${ctxTotal}` : '--';
+  const indicator = streaming ? theme.accent('● streaming') : theme.dim('○ idle');
+  const prov = provider || '?';
+  const mdl = model || '?';
+  return React.createElement(
+    Box,
+    { flexShrink: 0, paddingX: 1 },
+    React.createElement(Text, null, `${indicator}  ${prov} · ${mdl}  ctx ${ctx}`)
+  );
+}
+
+// Exported for tests that want to verify the splash snapshot without a TTY.
+export function _renderSplashToString(splashProps) {
+  return renderSplashToString(splashProps);
+}