lazyclaw 5.0.9 → 5.2.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/repl.mjs

@@ -56,6 +56,12 @@ export function consumeNextTurnFirstMessage(state) {
 }
 
 // ─── React mount ─────────────────────────────────────────────────────────
+// v5.1 TODO (C7 follow-up): replace direct stdout writes in cli.mjs's
+// _chatRunTurnFactory with a scrollback ref'd via this component. The
+// shape would be an `onOutput` prop that pushes chunks into a `useState`
+// array rendered through Ink's <Static items={scrollback}/>. v5.0.10
+// ships with raw stdout writes interleaved with Ink (acceptable visual
+// jank in exchange for unblocking the chat loop).
 export function ReplApp({ splashProps, runTurn }) {
   const [state, setState] = useState(makeReplState);
   const { exit } = useApp();

package/tui/run_turn.mjs

@@ -0,0 +1,138 @@
+// tui/run_turn.mjs — shared chat-turn streaming closure (v5 Group C, C7).
+//
+// Single source of truth for the streaming + persist + post-task
+// learning loop. The same factory backs:
+//   - the ink REPL path (ReplApp.runTurn)
+//   - the legacy readline path (cli.mjs's `for await (const line of rl)` body)
+//
+// One factory ⇒ one set of bugs. Both call sites get the same buffered
+// writer (CJK-safe 30 ms coalescing), the same persistTurn dual-write
+// (sessions + memory/recent), and the same fire-and-forget learning
+// hook (queueMicrotask).
+//
+// `ctx` carries the chat-session state. Getter functions close over
+// *current* bindings so a mid-session /provider switch takes effect on
+// the very next turn without re-creating the closure.
+//
+// `writeFn` is the sink for streamed chunks — the legacy path passes
+// `(s) => process.stdout.write(s)`; the ink path also writes to stdout
+// for v5.0.10 (interleaves with Ink output; visual jank accepted in
+// exchange for unblocking the chat loop). v5.1 TODO: route the ink
+// writeFn through a scrollback ref in ReplApp.
+//
+// Errors are swallowed (matches v4 legacy behavior) — we write
+// "error: ..." into writeFn but do not re-throw, so the caller's
+// turn-completion logic (ReplApp onTurnComplete, legacy `rl.prompt`)
+// runs unconditionally.
+
+/**
+ * @typedef {Object} RunTurnCtx
+ * @property {Object} cfg                                  Active config.
+ * @property {string} cfgDir                               Resolved configDir.
+ * @property {Object|null} sandboxSpec                     Parsed --sandbox spec (or null).
+ * @property {string} syntheticChatSessionId              Session-id fallback when --session not set.
+ * @property {() => Array<{role:string,content:string}>} getMessages
+ * @property {() => { sendMessage: Function, name?: string }} getProv
+ * @property {() => string} getActiveProvName
+ * @property {() => string|null} getActiveModel
+ * @property {() => string|null} getSessionId
+ * @property {(role: string, content: string) => void} persistTurn
+ * @property {(u: any) => void} accumulateUsage
+ * @property {(provider: string) => string} resolveAuthKey  Caller supplies; mirrors cli.mjs::_resolveAuthKey.
+ * @property {(n: number) => void} [onCharsSent]            Optional observer (legacy path increments charsSent).
+ */
+
+/**
+ * Build a runTurn(text, signal) closure that drives one provider turn
+ * end-to-end.
+ *
+ * @param {{ ctx: RunTurnCtx, writeFn: (chunk: string) => void }} args
+ * @returns {(text: string, signal?: AbortSignal) => Promise<void>}
+ */
+export function makeRunTurn({ ctx, writeFn }) {
+  return async function runTurn(text, signal) {
+    if (signal?.aborted) return;
+    const messages = ctx.getMessages();
+    messages.push({ role: 'user', content: text });
+    try { ctx.onCharsSent && ctx.onCharsSent(text.length); }
+    catch { /* observer is best-effort */ }
+    ctx.persistTurn('user', text);
+
+    let acc = '';
+    let _writeBuf = '';
+    let _writeTimer = null;
+    const _flush = () => {
+      if (_writeBuf) {
+        try { writeFn(_writeBuf); }
+        catch { /* sink failure must not kill the turn */ }
+        _writeBuf = '';
+      }
+      _writeTimer = null;
+    };
+    const _writeChunk = (s) => {
+      _writeBuf += s;
+      if (!_writeTimer) _writeTimer = setTimeout(_flush, 30);
+    };
+
+    try {
+      const sysMsg = messages.find((m) => m.role === 'system');
+      const prov = ctx.getProv();
+      const activeProvName = ctx.getActiveProvName();
+      const activeModel = ctx.getActiveModel();
+      // C8 — prompt-cache the static system prefix. The Anthropic
+      // provider prefers `systemStatic` when present; non-Anthropic
+      // providers ignore the field and fall back to the legacy
+      // single-block path with `cache:true`.
+      for await (const chunk of prov.sendMessage(messages, {
+        apiKey: ctx.resolveAuthKey(activeProvName),
+        model: activeModel,
+        sandbox: ctx.sandboxSpec,
+        signal,
+        onUsage: ctx.accumulateUsage,
+        cache: true,
+        ...(sysMsg ? { systemStatic: sysMsg.content } : {}),
+      })) {
+        _writeChunk(chunk);
+        acc += chunk;
+      }
+      if (_writeTimer) clearTimeout(_writeTimer);
+      _flush();
+      try { writeFn('\n'); }
+      catch { /* sink failure must not kill the turn */ }
+      messages.push({ role: 'assistant', content: acc });
+      ctx.persistTurn('assistant', acc);
+      // v5 Group A (C1): close the post-task learning loop on every
+      // successful chat turn. Fire-and-forget via queueMicrotask so the
+      // next prompt is never blocked on trajectory write / synth.
+      try {
+        queueMicrotask(() => {
+          import('../mas/learning.mjs').then((mod) => mod.runLearning('post-task', {
+            agent: { name: 'chat', provider: activeProvName, model: activeModel, role: '' },
+            task: {
+              id: ctx.getSessionId() || ctx.syntheticChatSessionId,
+              title: '(chat turn)',
+              turns: messages.slice(-2).map((m) => ({
+                agent: m.role === 'user' ? 'user' : 'chat',
+                text: m.content,
+                ts: new Date().toISOString(),
+              })),
+            },
+            configDir: ctx.cfgDir,
+            cfg: ctx.cfg,
+            transcript: acc.slice(0, 8000),
+          })).catch(() => { /* learning loop is best-effort */ });
+        });
+      } catch { /* never let learning hook break the chat */ }
+    } catch (err) {
+      if (_writeTimer) clearTimeout(_writeTimer);
+      _flush();
+      // ABORT errors are user-initiated; drop the partial reply (don't
+      // push an incomplete assistant message — next turn would treat
+      // it as a complete reply and confuse the model).
+      if (err?.code !== 'ABORT' && !signal?.aborted) {
+        try { writeFn(`error: ${err?.message || String(err)}\n`); }
+        catch { /* sink failure must not mask err */ }
+      }
+    }
+  };
+}

package/tui/splash.mjs

@@ -1,29 +1,12 @@
 // tui/splash.mjs — Hermes-style hero splash with gradient wordmark,
 // subcommand catalog, tool registry, skill index, and a bottom status bar.
 //
-// Layout (terminal-width responsive):
+// Layout (terminal-width responsive across four tiers):
 //
-//   LAZYCLAW wordmark (top, per-row gradient orange)
-//
-//   ╭─ lazyclaw vX.Y.Z · trainer-split · FTS5 recall · 6-backend sandbox ─╮
-//   │  [sloth braille]   Subcommands                                       │
-//   │                    core / workflow / config / state / ...            │
-//   │                    Available Tools                                   │
-//   │                    fs / exec / git / ...                             │
-//   │                    Available Skills                                  │
-//   │                    N subcommands · M tool groups · K skills · /help  │
-//   ╰──────────────────────────────────────────────────────────────────────╯
-//
-//   provider · X · Y  ·  trainer · A · B
-//   /cwd
-//   Session: ...
-//
-//   Welcome to lazyclaw. Type your message or /help for commands.
-//   + Tip: ...
-//
-//   ───────────────────────────────────────────────────────────────────────
-//    provider · model | ctx -- | [progress] | 0s
-//   ───────────────────────────────────────────────────────────────────────
+//   WIDE     (cols >= 140) — full wordmark + panel + sloth + 2-col right side
+//   MEDIUM   ( 90 <= cols < 140) — compact headline, panel + sloth + wrapped right column
+//   NARROW   ( 60 <= cols <  90) — single column, no sloth/panel, truncated verb lists
+//   MINIMAL  (cols <  60)  — headline + provider + cwd + /help line only
 import React from 'react';
 import { Box, Text } from 'ink';
 import stringWidth from 'string-width';
@@ -34,6 +17,14 @@ import { wordmark } from './wordmark.mjs';
 const LMARGIN = '  ';
 const TITLE = ' trainer-split · FTS5 recall · 6-backend sandbox ';
 
+// Tier breakpoints. Wordmark is 120 cols wide + LMARGIN(2)*2 = 124 minimum;
+// the user constraint pins WIDE at >=140 to give comfortable slack. Below
+// 90 the sloth (48 cols) leaves <40 cols for the right column, so we drop
+// it and go single-column. Below 60 we emit only a minimal headline.
+const WORDMARK_BREAKPOINT = 140;  // drop wordmark below this
+const PANEL_BREAKPOINT    = 90;   // drop sloth+panel below this
+const MINIMAL_BREAKPOINT  = 60;   // drop everything but headline below this
+
 // Subcommand catalog — grouped for the splash so a new user sees the
 // surface area at a glance. Mirrors SUBCOMMANDS in cli.mjs.
 export const SUBCOMMAND_GROUPS = [
@@ -79,10 +70,48 @@ function subcommandRow([label, verbs]) {
   return `${label.padEnd(12)} ${verbs.join(' · ')}`;
 }
 
-export function renderSplashToString(props, opts = {}) {
-  const cols = opts.columns || process.stdout.columns || 100;
-  const TERM = Math.max(80, cols);
-  const PANEL_W = TERM - LMARGIN.length * 2;
+// Wrap a labeled verb list onto multiple rows when it would overflow maxWidth.
+// First row: '<label.padEnd(12)> verb · verb'; continuations: '             verb · verb'.
+function wrapVerbs(label, verbs, maxWidth) {
+  const pad = ' '.repeat(13); // label.padEnd(12) + ' ' = 13 cells
+  const rows = [];
+  let current = label.padEnd(12) + ' ';
+  let firstOnRow = true;
+  for (const v of verbs) {
+    const candidate = firstOnRow ? current + v : current + ' · ' + v;
+    if (stringWidth(candidate) > maxWidth) {
+      if (firstOnRow) {
+        // even a single verb overflows — emit it anyway (truncated) to make progress.
+        rows.push(fit(candidate, maxWidth).trimEnd());
+        current = pad;
+        firstOnRow = true;
+      } else {
+        rows.push(current.trimEnd());
+        current = pad + v;
+        firstOnRow = false;
+      }
+    } else {
+      current = candidate;
+      firstOnRow = false;
+    }
+  }
+  if (current.trim()) rows.push(current.trimEnd());
+  return rows;
+}
+
+// Crush-style truncation for NARROW tier — take first N verbs, append '…' if more.
+function truncateRow(label, verbs, maxWidth, take = 3) {
+  const head = label.padEnd(12) + ' ';
+  const tail = verbs.slice(0, take).join(' · ');
+  let line = head + tail;
+  if (verbs.length > take) line += ' …';
+  if (stringWidth(line) <= maxWidth) return line;
+  return fit(line, maxWidth).trimEnd();
+}
+
+// Wide tier — original v5.0.9 layout, kept verbatim.
+function renderWide(props, cols) {
+  const PANEL_W = cols - LMARGIN.length * 2;
   const INNER = PANEL_W - 4;
   const SLOTH_W = banner.width;
   const RIGHT_W = Math.max(40, INNER - SLOTH_W - 2);
@@ -99,7 +128,7 @@ export function renderSplashToString(props, opts = {}) {
   const dashRight = '─'.repeat(Math.max(2, PANEL_W - 2 - dashLeft.length - stringWidth(versionLabel)));
   lines.push(`${LMARGIN}╭${dashLeft}${versionLabel}${dashRight}╮`);
 
-  // 3) right column content (subcommands + tools + skills)
+  // 3) right column content
   const { tools = [], skills = [] } = props;
   const right = [];
   right.push('Subcommands');
@@ -143,7 +172,97 @@ export function renderSplashToString(props, opts = {}) {
   lines.push(`${LMARGIN}+ Tip: trainer learns from your Claude Pro subscription at $0.`);
   lines.push('');
 
-  // 5) bottom border + status bar + border (Hermes-style separator)
+  // 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);
+
+  return lines;
+}
+
+// Medium tier — no wordmark, compact panel title, sloth + wrapped right column.
+function renderMedium(props, cols) {
+  const PANEL_W = cols - LMARGIN.length * 2;
+  const INNER = PANEL_W - 4;
+  const SLOTH_W = banner.width;
+  const RIGHT_W = Math.max(20, INNER - SLOTH_W - 2);
+
+  const lines = [];
+
+  // 1) compact headline (no wordmark)
+  lines.push(`${LMARGIN}lazyclaw ${props.version || ''}`.trimEnd());
+  lines.push('');
+
+  // 2) compact panel top — drop the TITLE chain, just version
+  const versionLabel = ` lazyclaw ${props.version || ''} `;
+  const dashLeft = '─'.repeat(4);
+  const dashRight = '─'.repeat(Math.max(2, PANEL_W - 2 - dashLeft.length - stringWidth(versionLabel)));
+  lines.push(`${LMARGIN}╭${dashLeft}${versionLabel}${dashRight}╮`);
+
+  // 3) build right column with wrapping
+  const { tools = [], skills = [] } = props;
+  const right = [];
+  right.push('Subcommands');
+  for (const [label, verbs] of SUBCOMMAND_GROUPS) {
+    for (const r of wrapVerbs(label, verbs, RIGHT_W)) right.push(r);
+  }
+  right.push('');
+  right.push('Available Tools');
+  for (const t of tools.slice(0, 14)) {
+    const label = t.sensitive ? `${t.category}*` : t.category;
+    for (const r of wrapVerbs(label, t.verbs.slice(0, 6), RIGHT_W)) right.push(r);
+  }
+  if (tools.length > 14) right.push(`(and ${tools.length - 14} more...)`);
+  right.push('');
+  right.push('Available Skills');
+  if (skills.length === 0) right.push('(none installed)');
+  else {
+    for (const s of skills.slice(0, 8)) {
+      for (const r of wrapVerbs(s.group, s.names.slice(0, 6), RIGHT_W)) right.push(r);
+    }
+    if (skills.length > 8) right.push(`(and ${skills.length - 8} more skill groups...)`);
+  }
+  right.push('');
+  const subcmdCount = SUBCOMMAND_GROUPS.reduce((n, [, v]) => n + v.length, 0);
+  const summary = `${subcmdCount} subcommands · ${tools.length} tool groups · ${skills.length} skills · /help`;
+  if (stringWidth(summary) > RIGHT_W) {
+    right.push(`${subcmdCount} subcmds · ${tools.length} tools · ${skills.length} skills`);
+    right.push('/help for commands');
+  } else {
+    right.push(summary);
+  }
+
+  const sloth = banner.rows.slice();
+  while (sloth.length < right.length) sloth.push(' '.repeat(SLOTH_W));
+  while (right.length < sloth.length) right.push('');
+
+  for (let i = 0; i < sloth.length; i++) {
+    const l = sloth[i] || ' '.repeat(SLOTH_W);
+    // pad (no ellipsis) — wrapVerbs already guarantees width <= RIGHT_W
+    const raw = right[i] || '';
+    const r = raw + ' '.repeat(Math.max(0, RIGHT_W - stringWidth(raw)));
+    lines.push(`${LMARGIN}│ ${l}  ${r} │`);
+  }
+  lines.push(`${LMARGIN}╰${'─'.repeat(PANEL_W - 2)}╯`);
+  lines.push('');
+
+  // 4) provider / session info
+  const { provider, model, trainer = {}, sessionId, cwd } = props;
+  const tProv = trainer.provider || provider;
+  const tModel = trainer.model || model;
+  lines.push(`${LMARGIN}${provider} · ${model}  ·  trainer ${tProv} · ${tModel}`);
+  lines.push(`${LMARGIN}${shortCwd(cwd || process.cwd())}`);
+  if (sessionId) lines.push(`${LMARGIN}Session: ${sessionId}`);
+  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
@@ -152,25 +271,103 @@ export function renderSplashToString(props, opts = {}) {
   lines.push(`${LMARGIN} ${provider} · ${model} | ctx -- | ${ctx} | 0s`);
   lines.push(LMARGIN + sep);
 
+  return lines;
+}
+
+// Narrow tier — single column, no sloth, no panel, truncated verb lists.
+function renderNarrow(props, cols) {
+  const W = cols - LMARGIN.length * 2;
+  const lines = [];
+
+  // 1) headline
+  lines.push(`${LMARGIN}lazyclaw ${props.version || ''}`.trimEnd());
+  lines.push('');
+
+  const { tools = [], skills = [], provider, model, trainer = {}, sessionId, cwd } = props;
+
+  // 2) subcommands
+  lines.push(`${LMARGIN}Subcommands`);
+  for (const [label, verbs] of SUBCOMMAND_GROUPS) {
+    lines.push(LMARGIN + truncateRow(label, verbs, W));
+  }
+  lines.push('');
+
+  // 3) tools
+  lines.push(`${LMARGIN}Available Tools`);
+  for (const t of tools.slice(0, 14)) {
+    const label = t.sensitive ? `${t.category}*` : t.category;
+    lines.push(LMARGIN + truncateRow(label, t.verbs, W));
+  }
+  if (tools.length > 14) lines.push(`${LMARGIN}(and ${tools.length - 14} more...)`);
+  lines.push('');
+
+  // 4) skills
+  lines.push(`${LMARGIN}Available Skills`);
+  if (skills.length === 0) lines.push(`${LMARGIN}(none installed)`);
+  else {
+    for (const s of skills.slice(0, 8)) {
+      lines.push(LMARGIN + truncateRow(s.group, s.names, W));
+    }
+    if (skills.length > 8) lines.push(`${LMARGIN}(and ${skills.length - 8} more skill groups...)`);
+  }
+  lines.push('');
+
+  // 5) provider / session info
+  const tProv = trainer.provider || provider;
+  const tModel = trainer.model || model;
+  lines.push(fit(`${LMARGIN}${provider} · ${model}  ·  trainer ${tProv} · ${tModel}`, cols).trimEnd());
+  lines.push(fit(`${LMARGIN}${shortCwd(cwd || process.cwd())}`, cols).trimEnd());
+  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('');
+
+  // 6) 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());
+
+  return lines;
+}
+
+// Minimal tier — bare-bones fallback for cols < 60.
+function renderMinimal(props) {
+  const { version, provider, model, sessionId, cwd } = props;
+  const lines = [];
+  lines.push(`lazyclaw ${version || ''}`.trimEnd());
+  lines.push(`${provider} · ${model}`);
+  lines.push(shortCwd(cwd || process.cwd()));
+  if (sessionId) lines.push(`Session: ${sessionId}`);
+  lines.push('/help for commands');
+  return lines;
+}
+
+export function renderSplashToString(props, opts = {}) {
+  const cols = opts.columns || process.stdout.columns || 100;
+  let lines;
+  if (cols < MINIMAL_BREAKPOINT) lines = renderMinimal(props);
+  else if (cols < PANEL_BREAKPOINT) lines = renderNarrow(props, cols);
+  else if (cols < WORDMARK_BREAKPOINT) lines = renderMedium(props, cols);
+  else lines = renderWide(props, cols);
   return lines.join('\n');
 }
 
 export function Splash(props) {
   const cols = process.stdout.columns || 100;
-  const TERM = Math.max(80, cols);
-  const PANEL_W = TERM - LMARGIN.length * 2;
   const out = renderSplashToString(props, { columns: cols });
   const lines = out.split('\n');
   const palette = wordmark.palette;
   const gradient = wordmark.gradient;
+  const showWordmark = cols >= WORDMARK_BREAKPOINT;
 
   return React.createElement(
     Box,
     { flexDirection: 'column' },
     lines.map((line, i) => {
       let color;
-      if (i < wordmark.height) color = palette[gradient[i] ?? 1];
-      else if (i < wordmark.height + 1 + 1 + banner.height) color = theme.fg;  // panel + sloth tinted
+      if (showWordmark && i < wordmark.height) color = palette[gradient[i] ?? 1];
+      else if (showWordmark && i < wordmark.height + 1 + 1 + banner.height) color = theme.fg;
       return React.createElement(Text, { key: i, color }, line);
     })
   );