lazyclaw 5.1.0 → 5.3.0

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/slash_commands.mjs

@@ -0,0 +1,37 @@
+// tui/slash_commands.mjs — single source of truth for the REPL slash-command
+// catalog. Imported by both cli.mjs (legacy ghost-autocomplete + /help dump)
+// and tui/slash_popup.mjs (Ink popup chooser). Keeping the list here avoids
+// a tui/ → cli.mjs circular import.
+//
+// Schema:
+//   { cmd: string, help: string }
+//
+// Order matters — it is the order shown in the popup and in /help. New
+// commands should be appended unless there is a UX reason to slot them in.
+
+export const SLASH_COMMANDS = [
+  { cmd: '/help',        help: 'list available 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: '/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: '/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]]' },
+  { cmd: '/recall',      help: 'FTS5 recall across sessions and memory' },
+  { 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: '/handoff',     help: 'hand current task off to another agent' },
+  { cmd: '/exit',        help: 'leave the chat' },
+  { cmd: '/quit',        help: 'alias for /exit' },
+];

package/tui/slash_popup.mjs

@@ -0,0 +1,157 @@
+// tui/slash_popup.mjs — Ink popup chooser for slash commands.
+//
+// Renders a bordered, vertically-stacked list of slash-command suggestions
+// just above the input row. Selection state lives in the parent (ReplApp),
+// because the Editor owns the keyboard. This component is purely
+// presentational so it can be snapshotted and rendered without an Ink
+// runtime.
+//
+// Ink has no absolute positioning, so "popup" here means "flex sibling
+// rendered between the live region and the StatusBar". When the popup is
+// visible the live region naturally shrinks by its row count, which is the
+// same trick Claude CLI uses.
+//
+// Two exports:
+//   - filterSlashCommands(buffer, commands)  → pure, unit-testable
+//   - <SlashPopup buffer commands selectedIndex maxRows />  → presentational
+
+import React from 'react';
+import { Box, Text } from 'ink';
+import { theme } from './theme.mjs';
+import { SLASH_COMMANDS as DEFAULT_SLASH_COMMANDS } from './slash_commands.mjs';
+
+export { DEFAULT_SLASH_COMMANDS };
+
+// ─── Pure filter ─────────────────────────────────────────────────────────
+//
+// Returns the subset of `commands` to show in the popup for the current
+// `buffer`. Empty array means "dismiss popup". See the inline cases for
+// the precedence — prefix first, then substring fallback, then space-arg
+// degeneration into a single-row inline hint.
+export function filterSlashCommands(buffer, commands) {
+  if (!buffer || !buffer.startsWith('/')) return [];
+  const space = buffer.indexOf(' ');
+  if (space > 0) {
+    // User has typed args. Popup degenerates into a one-row inline hint
+    // showing only the matched command's help text.
+    const head = buffer.slice(0, space);
+    return commands.filter((c) => c.cmd === head);
+  }
+  if (buffer === '/') return commands.slice();
+  const q = buffer.toLowerCase();
+  const prefix = commands.filter((c) => c.cmd.toLowerCase().startsWith(q));
+  if (prefix.length > 0) return prefix;
+  // Substring fallback: '/em' → /memory. Strip the leading '/' on both
+  // sides so the substring search isn't dominated by the trigger char.
+  const sub = commands.filter((c) =>
+    c.cmd.slice(1).toLowerCase().includes(q.slice(1))
+  );
+  return sub;
+}
+
+// Truncate help text to a column budget, preserving the leading space.
+// Never wraps — the popup is a single row per command.
+function _truncate(s, max) {
+  if (max <= 0) return '';
+  if (s.length <= max) return s;
+  if (max <= 1) return s.slice(0, max);
+  return s.slice(0, max - 1) + '…';
+}
+
+// Window a long match list around the selected row so the popup doesn't
+// grow taller than `maxRows`. Returns `{ visible, windowStart }`.
+export function _computeWindow(matches, selectedIndex, maxRows) {
+  if (matches.length <= maxRows) return { visible: matches, windowStart: 0 };
+  const half = Math.floor(maxRows / 2);
+  let start = Math.max(0, selectedIndex - half);
+  const end = Math.min(matches.length, start + maxRows);
+  // Re-anchor if we overflowed past the end.
+  start = Math.max(0, end - maxRows);
+  return { visible: matches.slice(start, start + maxRows), windowStart: start };
+}
+
+// ─── Component ───────────────────────────────────────────────────────────
+//
+// Props:
+//   buffer        — string, current editor buffer (used for the inline hint)
+//   commands      — Array<{cmd,help}>, already filtered by caller
+//   selectedIndex — number, index into `commands`
+//   maxRows       — number, max visible rows (defaults to 8)
+//   columns       — number, terminal width (defaults to process.stdout.columns)
+//
+// When `columns < 50` the popup collapses to a single column (cmd only).
+export function SlashPopup({
+  buffer = '',
+  commands = [],
+  selectedIndex = 0,
+  maxRows = 8,
+  columns,
+}) {
+  if (!commands || commands.length === 0) return null;
+  const cols = columns
+    || (process.stdout && process.stdout.columns)
+    || 80;
+  const compact = cols < 50;
+  const safeSelected = Math.max(0, Math.min(commands.length - 1, selectedIndex));
+  const { visible, windowStart } = _computeWindow(commands, safeSelected, maxRows);
+
+  // Inline-hint mode: buffer already has args + a single match. Render
+  // the help text on one dimmed line. No border, no chooser.
+  const isInlineHint = buffer.includes(' ') && commands.length === 1;
+  if (isInlineHint) {
+    const c = commands[0];
+    return React.createElement(
+      Box,
+      { paddingX: 1 },
+      React.createElement(Text, { dimColor: true },
+        `${c.cmd} — ${_truncate(c.help, Math.max(10, cols - c.cmd.length - 5))}`
+      )
+    );
+  }
+
+  // Reserve 2 chars border + 2 padding + cmd column (14) + 1 gap.
+  const cmdCol = 14;
+  const helpBudget = Math.max(0, cols - cmdCol - 6);
+
+  return React.createElement(
+    Box,
+    {
+      flexDirection: 'column',
+      borderStyle: 'round',
+      borderColor: 'gray',
+      paddingX: 1,
+    },
+    visible.map((c, i) => {
+      const absIdx = i + windowStart;
+      const isSel = absIdx === safeSelected;
+      const cmdText = c.cmd.padEnd(cmdCol);
+      return React.createElement(
+        Box,
+        { key: c.cmd },
+        React.createElement(
+          Text,
+          {
+            inverse: isSel,
+            color: isSel ? theme.amber : undefined,
+            bold: isSel,
+          },
+          cmdText
+        ),
+        !compact
+          ? React.createElement(
+              Text,
+              { dimColor: true },
+              ' ' + _truncate(c.help, helpBudget)
+            )
+          : null
+      );
+    }),
+    commands.length > maxRows
+      ? React.createElement(
+          Text,
+          { dimColor: true },
+          `  ${safeSelected + 1}/${commands.length}`
+        )
+      : null
+  );
+}

package/tui/splash.mjs

@@ -3,10 +3,10 @@
 //
 // Layout (terminal-width responsive across four tiers):
 //
-//   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
+//   WIDE     (cols >= 140) — full wordmark + panel + sloth side-by-side
+//   MEDIUM   ( 90 <= cols < 140) — compact headline, sloth side-by-side, wrapped right column
+//   NARROW   ( 45 <= cols <  90) — sloth STACKED above full-width panel, wrapped verbs
+//   MINIMAL  (cols <  45)  — headline + provider + cwd + /help line only
 import React from 'react';
 import { Box, Text } from 'ink';
 import stringWidth from 'string-width';
@@ -19,11 +19,12 @@ 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.
+// 90 the sloth (48 cols) cannot share a row with a usable right column,
+// so NARROW stacks the sloth ABOVE a full-width wrapped panel. Below 45
+// even a stacked sloth overflows, so MINIMAL absorbs that range.
 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
+const MEDIUM_BREAKPOINT   = 90;   // side-by-side sloth+panel above this; stacked below
+const NARROW_BREAKPOINT   = 45;   // headline-only fallback below this
 
 // Subcommand catalog — grouped for the splash so a new user sees the
 // surface area at a glance. Mirrors SUBCOMMANDS in cli.mjs.
@@ -99,16 +100,6 @@ function wrapVerbs(label, verbs, maxWidth) {
   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;
@@ -274,45 +265,76 @@ function renderMedium(props, cols) {
   return lines;
 }
 
-// Narrow tier — single column, no sloth, no panel, truncated verb lists.
+// Narrow tier — sloth STACKED above a full-width panel; verb lists wrap
+// onto multiple rows instead of being truncated. Used for 45 <= cols < 90.
 function renderNarrow(props, cols) {
-  const W = cols - LMARGIN.length * 2;
+  const PANEL_W = cols - LMARGIN.length * 2;
+  const INNER = PANEL_W - 4;
+  const SLOTH_W = banner.width;
   const lines = [];
 
-  // 1) headline
+  // 1) sloth banner CENTERED above panel (stacked layout).
+  //    Only emit if the sloth itself fits within the terminal; otherwise
+  //    skip it (MINIMAL absorbs the truly tiny case below NARROW_BREAKPOINT).
+  if (cols >= SLOTH_W + LMARGIN.length * 2) {
+    const leftPad = ' '.repeat(Math.max(0, Math.floor((cols - SLOTH_W) / 2)));
+    for (const r of banner.rows) lines.push(leftPad + r);
+    lines.push('');
+  }
+
+  // 2) compact headline (no wordmark — too wide).
   lines.push(`${LMARGIN}lazyclaw ${props.version || ''}`.trimEnd());
   lines.push('');
 
-  const { tools = [], skills = [], provider, model, trainer = {}, sessionId, cwd } = props;
+  // 3) panel top — version label only, dashes fill remainder.
+  const versionLabel = ` lazyclaw ${props.version || ''} `;
+  const dashLeft = '─'.repeat(2);
+  const dashRight = '─'.repeat(Math.max(2, PANEL_W - 2 - dashLeft.length - stringWidth(versionLabel)));
+  lines.push(`${LMARGIN}╭${dashLeft}${versionLabel}${dashRight}╮`);
 
-  // 2) subcommands
-  lines.push(`${LMARGIN}Subcommands`);
+  // 4) panel body — full-width single column, wrapped via wrapVerbs.
+  const { tools = [], skills = [] } = props;
+  const body = [];
+  body.push('Subcommands');
   for (const [label, verbs] of SUBCOMMAND_GROUPS) {
-    lines.push(LMARGIN + truncateRow(label, verbs, W));
+    for (const r of wrapVerbs(label, verbs, INNER)) body.push(r);
   }
-  lines.push('');
-
-  // 3) tools
-  lines.push(`${LMARGIN}Available Tools`);
+  body.push('');
+  body.push('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));
+    for (const r of wrapVerbs(label, t.verbs.slice(0, 6), INNER)) body.push(r);
   }
-  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)`);
+  if (tools.length > 14) body.push(`(and ${tools.length - 14} more...)`);
+  body.push('');
+  body.push('Available Skills');
+  if (skills.length === 0) body.push('(none installed)');
   else {
     for (const s of skills.slice(0, 8)) {
-      lines.push(LMARGIN + truncateRow(s.group, s.names, W));
+      for (const r of wrapVerbs(s.group, s.names.slice(0, 6), INNER)) body.push(r);
     }
-    if (skills.length > 8) lines.push(`${LMARGIN}(and ${skills.length - 8} more skill groups...)`);
+    if (skills.length > 8) body.push(`(and ${skills.length - 8} more skill groups...)`);
   }
+  body.push('');
+  const subcmdCount = SUBCOMMAND_GROUPS.reduce((n, [, v]) => n + v.length, 0);
+  const summary = `${subcmdCount} subcmds · ${tools.length} tools · ${skills.length} skills · /help`;
+  if (stringWidth(summary) > INNER) {
+    body.push(`${subcmdCount} subcmds · ${tools.length} tools · ${skills.length} skills`);
+    body.push('/help for commands');
+  } else {
+    body.push(summary);
+  }
+
+  // 5) emit panel rows (single column, full INNER width, pad with spaces).
+  for (const row of body) {
+    const padded = row + ' '.repeat(Math.max(0, INNER - stringWidth(row)));
+    lines.push(`${LMARGIN}│ ${padded} │`);
+  }
+  lines.push(`${LMARGIN}╰${'─'.repeat(PANEL_W - 2)}╯`);
   lines.push('');
 
-  // 5) provider / session info
+  // 6) provider / session info (single line each, fit-truncated for safety).
+  const { provider, model, trainer = {}, sessionId, cwd } = props;
   const tProv = trainer.provider || provider;
   const tModel = trainer.model || model;
   lines.push(fit(`${LMARGIN}${provider} · ${model}  ·  trainer ${tProv} · ${tModel}`, cols).trimEnd());
@@ -322,7 +344,7 @@ function renderNarrow(props, cols) {
   lines.push(fit(`${LMARGIN}Welcome to lazyclaw. /help for commands.`, cols).trimEnd());
   lines.push('');
 
-  // 6) compact status — single line, no separator dashes
+  // 7) compact status — single line, no separator dashes.
   const ctx = props.ctxUsed != null && props.ctxTotal != null
     ? `${props.ctxUsed}/${props.ctxTotal}`
     : '--';
@@ -331,7 +353,7 @@ function renderNarrow(props, cols) {
   return lines;
 }
 
-// Minimal tier — bare-bones fallback for cols < 60.
+// Minimal tier — bare-bones fallback for cols < 45.
 function renderMinimal(props) {
   const { version, provider, model, sessionId, cwd } = props;
   const lines = [];
@@ -346,8 +368,8 @@ function renderMinimal(props) {
 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);
+  if (cols < NARROW_BREAKPOINT) lines = renderMinimal(props);
+  else if (cols < MEDIUM_BREAKPOINT) lines = renderNarrow(props, cols);
   else if (cols < WORDMARK_BREAKPOINT) lines = renderMedium(props, cols);
   else lines = renderWide(props, cols);
   return lines.join('\n');

package/web/dashboard.html

@@ -1780,7 +1780,7 @@
               <div class="name" style="margin-left:8px;">${escHtml(String(label))}</div>
               <div class="dim row-actions">bm25 ${Number(h.bm25 || 0).toFixed(2)}</div>
             </div>
-            <div class="dim" style="margin-top:6px;font-size:12px;">${h.snippet || ''}</div>
+            <div class="dim" style="margin-top:6px;font-size:12px;">${escHtml(h.snippet || '').replace(/&lt;mark&gt;/g,'<mark>').replace(/&lt;\/mark&gt;/g,'</mark>')}</div>
           </div>`;
         }).join('');
       } catch (e) {