lazyclaw 6.3.1 → 6.5.0

package/teams.mjs

@@ -98,6 +98,7 @@ export function registerTeam({ name, displayName, agents = [], lead = null, slac
     slackChannel: String(slackChannel || ''),
   };
   writeAtomic(p, data);
+  _invalidateTeamIndex(configDir);
   return data;
 }
 
@@ -133,6 +134,7 @@ export function patchTeam(name, patch, configDir = defaultConfigDir()) {
   if (patch.agents !== undefined) next.agents = [...new Set(patch.agents)];
   validateAgentRefs(next.agents, next.lead, configDir);
   writeAtomic(teamPath(name, configDir), next);
+  _invalidateTeamIndex(configDir);
   return next;
 }
 
@@ -142,6 +144,7 @@ export function removeTeam(name, configDir = defaultConfigDir()) {
     throw new TeamError(`no team "${name}"`, 'TEAM_NO_TEAM');
   }
   fs.unlinkSync(p);
+  _invalidateTeamIndex(configDir);
   return { name, removed: true };
 }
 
@@ -197,3 +200,78 @@ export function parseListFlag(raw) {
   if (s === '') return [];
   return s.split(',').map(x => x.trim()).filter(Boolean);
 }
+
+// Build the team's org tree for the dashboard: a nested { agent, children[] }
+// rooted at team.lead. A member nests under its `manager` when that manager is
+// also a team member; otherwise (no manager, or a manager outside the team) it
+// attaches directly under the lead, so the result is always a single tree.
+//
+// @param {{lead:string, agents:string[]}} team
+// @param {Record<string, object>} agentsById  name → agent record
+export function teamTree(team, agentsById = {}) {
+  const lead = team && team.lead;
+  if (!lead) return null;
+  const memberNames = new Set((team.agents || []));
+  const byManager = new Map(); // manager name → child names
+  for (const n of memberNames) {
+    if (n === lead) continue;
+    const rec = agentsById[n];
+    const mgr = rec && rec.manager && memberNames.has(rec.manager) && rec.manager !== n
+      ? rec.manager
+      : lead;
+    if (!byManager.has(mgr)) byManager.set(mgr, []);
+    byManager.get(mgr).push(n);
+  }
+  const build = (name, seen) => {
+    if (seen.has(name)) return null; // cycle guard (defensive — register/patch reject cycles)
+    const next = new Set(seen).add(name);
+    const node = { agent: agentsById[name] || { name }, children: [] };
+    for (const child of (byManager.get(name) || []).sort()) {
+      const c = build(child, next);
+      if (c) node.children.push(c);
+    }
+    return node;
+  };
+  return build(lead, new Set());
+}
+
+// Find the team bound to an inbound channel id (team.slackChannel), or null.
+// Used by the daemon to auto-route a Slack message to a team's multi-agent loop.
+export function teamForChannel(teams, channel) {
+  if (!channel) return null;
+  const c = String(channel);
+  return (teams || []).find((t) => t && t.slackChannel && String(t.slackChannel) === c) || null;
+}
+
+// slackChannel→team index, keyed by configDir and the teams/ dir mtime. Every
+// inbound Slack message used to re-scan the whole teams/ directory (readdir + N
+// JSON.parse) just to find one channel's team; this builds the lookup once and
+// reuses it until the directory changes. register/patch/removeTeam invalidate
+// explicitly (deterministic), and the dir-mtime key also catches manual edits.
+const _channelIndex = new Map();  // configDir → { mtimeMs, byChannel: Map<channel, team> }
+
+export function _invalidateTeamIndex(configDir = defaultConfigDir()) {
+  _channelIndex.delete(configDir);
+}
+
+// O(1) channel→team lookup for the inbound hot path. Returns null when no team
+// is bound to the channel (or there is no teams/ directory yet).
+export function teamForChannelCached(channel, configDir = defaultConfigDir()) {
+  if (!channel) return null;
+  const dir = teamsDir(configDir);
+  let mtimeMs = 0;
+  try { mtimeMs = fs.statSync(dir).mtimeMs; }
+  catch { return null; }  // no teams dir → no team bound to anything
+  const cached = _channelIndex.get(configDir);
+  let byChannel;
+  if (cached && cached.mtimeMs === mtimeMs) {
+    byChannel = cached.byChannel;
+  } else {
+    byChannel = new Map();
+    for (const t of listTeams(configDir)) {
+      if (t && t.slackChannel) byChannel.set(String(t.slackChannel), t);
+    }
+    _channelIndex.set(configDir, { mtimeMs, byChannel });
+  }
+  return byChannel.get(String(channel)) || null;
+}

package/tui/banner.mjs

@@ -0,0 +1,72 @@
+// LazyClaw banner renderers — extracted from tui/pickers.mjs as a leaf
+// module (no cross-deps). Holds the legacy figlet box (_renderBanner), the
+// orange colour helper (_orange / _ORANGE_RGB), the mascot stubs, and the
+// lazy-loaded v5 banner assets (_loadBannerAssets). The v5 splash composer
+// (_renderV5Banner) and the chat header (_printChatBanner) stay in pickers
+// and import _orange / _ORANGE_RGB / _loadBannerAssets / _renderBanner back.
+
+// LazyClaw banner — single source of truth (chat REPL header, no-arg
+// launcher, first-run welcome). Printed once so users see the active
+// provider/model; plain ANSI, auto-skipped when stdout isn't a TTY.
+// Returns an array of pre-formatted lines the caller can splice rows into.
+//
+// Layout invariants: every inner row is forced through `.padEnd(INNER_W)`
+// and is exactly INNER_W single-cell glyphs, so the right border `│` always
+// lands in the same column. _renderMascot / _renderMascotTiny are stubs kept
+// so any leftover caller doesn't crash.
+
+export const _ORANGE_RGB = '241;130;70';  // #F18246
+export function _orange(s) { return `\x1b[38;2;${_ORANGE_RGB}m${s}\x1b[0m`; }
+
+export function _renderMascot() {
+  return ['lazyclaw'];
+}
+
+export function _renderMascotTiny() {
+  return 'lazyclaw';
+}
+
+// figlet "standard" "lazy", trimmed of leading blank line. Each row
+// is left-padded by two spaces inside the box, and every row is then
+// padded to INNER_W cells.
+const _LAZY_STANDARD = [
+  ' _                  ',
+  '| | __ _ _____   _  ',
+  '| |/ _` |_  / | | | ',
+  '| | (_| |/ /| |_| | ',
+  '|_|\\__,_/___|\\__, | ',
+  '             |___/  ',
+];
+
+const _INNER_W = 32;  // 2 left pad + 20 letter art + caption headroom
+
+export function _renderBanner(version) {
+  const v = String(version || '?.?.?');
+  const cap = `  LazyClaw  v${v}`;
+  const padInner = (s) => '  ' + s.padEnd(_INNER_W - 2, ' ');
+  const wrap = (inner) => _orange('│') + _orange(inner) + _orange('│');
+  const top = _orange('╭' + '─'.repeat(_INNER_W) + '╮');
+  const bot = _orange('╰' + '─'.repeat(_INNER_W) + '╯');
+  return [
+    top,
+    ..._LAZY_STANDARD.map((row) => wrap(padInner(row))),
+    wrap(padInner(cap)),
+    bot,
+  ];
+}
+
+// v5 hero banner assets — ANSI Shadow LAZYCLAW wordmark stacked on top of the
+// braille sloth (tui/banner.generated.mjs + tui/wordmark.mjs). Lazy-loaded and
+// cached so the missing-asset fallback only probes the dynamic import once.
+let _bannerAssetsCache = null;
+export async function _loadBannerAssets() {
+  if (_bannerAssetsCache !== null) return _bannerAssetsCache;
+  try {
+    const { banner } = await import('./banner.generated.mjs');
+    const { wordmark } = await import('./wordmark.mjs');
+    _bannerAssetsCache = { banner, wordmark };
+  } catch {
+    _bannerAssetsCache = null;
+  }
+  return _bannerAssetsCache;
+}

package/tui/chat_mode_slash.mjs

@@ -0,0 +1,59 @@
+// tui/chat_mode_slash.mjs — /agentic and /plan slash handlers (Group 1).
+//
+// Extracted from slash_dispatcher.mjs (at its file-size ratchet ceiling) so
+// the agentic REPL / plan mode toggles can grow without forcing that file
+// over its pinned limit. slash_dispatcher imports + registers these in
+// SLASH_HANDLERS and the shared SLASH_COMMANDS catalog.
+//
+// Both mirror the /hud toggle (tui/hud.mjs::hudSlash): read cfg, flip the
+// chat.* key, persist via writeConfig when wired, and mirror onto the
+// in-memory cfg so the next turn (makeRunTurn → chatAgenticGet /
+// chatPlanModeGet) sees it live. No-arg flips the current value, or opens
+// an on/off picker in the Ink UI.
+
+import { chatAgenticGet, chatPlanModeGet, chatSet } from '../config_features.mjs';
+
+async function _chatToggleSlash(args, ctx, { key, label, pickerDesc }) {
+  const getter = key === 'agentic' ? chatAgenticGet : chatPlanModeGet;
+  const cfg = ctx.readConfig ? ctx.readConfig() : (ctx.cfg || {});
+  const cur = getter(cfg);
+  const a = String(args || '').trim().toLowerCase();
+  let next;
+  if (a === 'on') next = true;
+  else if (a === 'off') next = false;
+  else if (!a && typeof ctx.openPicker === 'function') {
+    const picked = await ctx.openPicker({
+      kind: 'menu',
+      title: `${label} mode`,
+      subtitle: `currently ${cur ? 'on' : 'off'}`,
+      items: [
+        { id: 'on', label: 'on', desc: pickerDesc },
+        { id: 'off', label: 'off', desc: 'off' },
+      ],
+    });
+    const id = picked && typeof picked === 'object' ? picked.id : picked;
+    if (id !== 'on' && id !== 'off') return `${label}: cancelled`;
+    next = id === 'on';
+  } else next = !cur;
+  chatSet(cfg, key, next);
+  if (ctx.writeConfig) ctx.writeConfig(cfg);
+  if (ctx.cfg && ctx.cfg !== cfg) chatSet(ctx.cfg, key, next);
+  return `${label} ${next ? 'on' : 'off'}`;
+}
+
+export const agenticSlash = (a, ctx) => _chatToggleSlash(a, ctx, {
+  key: 'agentic', label: 'agentic',
+  pickerDesc: 'run tools behind the approval gate (read/grep/skill by default)',
+});
+
+export const planSlash = (a, ctx) => _chatToggleSlash(a, ctx, {
+  key: 'planMode', label: 'plan',
+  pickerDesc: 'read-only: propose a plan, do not mutate',
+});
+
+// Catalog entries for the shared SLASH_COMMANDS list (consumed by /help, the
+// popup, ghost-autocomplete, and the d6 drift-guard).
+export const CHAT_MODE_SLASH_COMMANDS = [
+  { cmd: '/agentic', help: 'toggle the agentic REPL (tools behind approval): /agentic on|off' },
+  { cmd: '/plan', help: 'toggle plan mode (read-only: propose, do not mutate): /plan on|off' },
+];

package/tui/config_picker.mjs

@@ -17,6 +17,7 @@ const CONFIG_ITEMS = [
   { id: 'provider',     label: 'provider',            desc: 'switch the chat provider (family → vendor picker)' },
   { id: 'model',        label: 'model',               desc: 'switch the model (live list when the provider supports it)' },
   { id: 'context',      label: 'context window',      desc: 'history turns / token budget sent per turn' },
+  { id: 'hud',          label: 'HUD status bar',      desc: 'show/hide the usage · models · cost row above the input' },
   { id: 'trainer',      label: 'trainer',             desc: 'learning-loop provider/model (auto = $0 on claude-cli)' },
   { id: 'orchestrator', label: 'orchestrator',        desc: 'multi-agent on/off, planner, workers' },
   { id: 'channel',      label: 'channel credentials', desc: 'Slack/Telegram/Matrix tokens — leaves chat for the prompts, then returns' },

package/tui/editor_anchor.mjs

@@ -0,0 +1,46 @@
+// tui/editor_anchor.mjs — extracted IME cursor-anchor stdout shim (v5.4.4).
+// Pure leaf module: only touches process.stdout, imports nothing from
+// editor.mjs, so there is no circular import. The shared anchorState object
+// is a singleton — editor.mjs imports the same instance via this export.
+//
+// ─── 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.
+export const anchorState = { offset: 0, shimmed: false };
+
+export 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;
+}

package/tui/editor_keys.mjs

@@ -0,0 +1,275 @@
+// tui/editor_keys.mjs — pure editor state machine + cursor-aware editing
+// helpers for <Editor/> (v6.4).
+//
+// Extracted from tui/editor.mjs to keep that file under the 500-line gate.
+// editor.mjs re-exports the public surface (makeEditorState, applyKey,
+// displayWidth, cursorDisplayCol, wrapToBudget, fillSlashCommand and the
+// PROMPT_* / CONTINUATION_* constants) so all existing import paths stay
+// valid. These operate on the editor state's `buffer` (a string) and
+// `cursor` (a UTF-16 code-unit index — the same unit `buffer.slice(0,
+// cursor)` expects). Movement steps over whole codepoints so a surrogate
+// pair (e.g. an emoji) is never split mid-character.
+import stringWidth from 'string-width';
+
+// v6.4 — 2-stage Ctrl+C window. A second Ctrl+C within this many ms exits;
+// otherwise the first press only cancels/clears and resets the timer.
+export const INTERRUPT_WINDOW_MS = 1500;
+
+// The accent prompt (`› `) prepended to the first rendered line. Its display
+// width matters for any caller that wants the usable inner width of the box.
+export const PROMPT_PREFIX = '› ';
+export const PROMPT_WIDTH = stringWidth(PROMPT_PREFIX);
+export const CONTINUATION_GUTTER = '  ';
+export const CONTINUATION_WIDTH = stringWidth(CONTINUATION_GUTTER);
+
+// Public helper: display width of a buffer (or any substring), counting wide
+// chars (CJK, fullwidth, most emoji) as 2 cells and ignoring ANSI escapes.
+// Use this — never `.length` — for column math.
+export function displayWidth(text) {
+  if (!text) return 0;
+  return stringWidth(String(text));
+}
+
+// Cell-aware soft-wrap. Returns an array of visual rows whose width respects
+// the budget (first row uses `firstBudget`, subsequent rows use `contBudget`).
+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 CONTINUATION_WIDTH. Callers that only
+// need the in-buffer column can pass `{ withPrefix: false }`.
+export function cursorDisplayCol(state, { withPrefix = true } = {}) {
+  const before = String(state.buffer || '').slice(0, state.cursor || 0);
+  const newlineIdx = before.lastIndexOf('\n');
+  const lineSlice = newlineIdx === -1 ? before : before.slice(newlineIdx + 1);
+  const inLine = stringWidth(lineSlice);
+  if (!withPrefix) return inLine;
+  const prefix = newlineIdx === -1 ? PROMPT_WIDTH : CONTINUATION_WIDTH;
+  return prefix + inLine;
+}
+
+export function makeEditorState({ history = [] } = {}) {
+  return {
+    buffer: '',
+    cursor: 0,
+    historyIdx: history.length,
+    history,
+    lastSubmit: null,
+    lastWasPaste: false,
+  };
+}
+
+// Pure reducer: apply one key event to the editor state, returning the next
+// state. Cursor-aware (v6.4) — insert/Backspace act AT the cursor, with
+// Left/Right/Home/End/Ctrl+A/E/K/W movement & edit shortcuts.
+export function applyKey(state, evt) {
+  const { input = '', key = {}, paste = false } = evt;
+  const next = { ...state, lastSubmit: null, lastWasPaste: false };
+
+  if (key.return && key.shift) {
+    // Insert a literal newline AT the cursor (cursor-aware multiline edit).
+    const r = insertAt(state.buffer, state.cursor, '\n');
+    next.buffer = r.buffer;
+    next.cursor = r.cursor;
+    return next;
+  }
+  if (key.return) {
+    next.lastSubmit = state.buffer;
+    next.buffer = '';
+    next.cursor = 0;
+    next.historyIdx = state.history.length;
+    return next;
+  }
+  if (key.upArrow) {
+    const idx = Math.max(0, state.historyIdx - 1);
+    if (state.history[idx] !== undefined) {
+      next.historyIdx = idx;
+      next.buffer = state.history[idx];
+      next.cursor = next.buffer.length;
+    }
+    return next;
+  }
+  if (key.downArrow) {
+    const idx = Math.min(state.history.length, state.historyIdx + 1);
+    next.historyIdx = idx;
+    next.buffer = state.history[idx] !== undefined ? state.history[idx] : '';
+    next.cursor = next.buffer.length;
+    return next;
+  }
+  // ─── Mid-line cursor movement (v6.4) ──────────────────────────────────
+  if (key.leftArrow) {
+    next.cursor = prevCodepointIndex(state.buffer, state.cursor);
+    return next;
+  }
+  if (key.rightArrow) {
+    next.cursor = nextCodepointIndex(state.buffer, state.cursor);
+    return next;
+  }
+  // Home / Ctrl+A → start of the current line; End / Ctrl+E → end of it.
+  if (key.home || (key.ctrl && (input === 'a' || input === 'A'))) {
+    next.cursor = lineStartIndex(state.buffer, state.cursor);
+    return next;
+  }
+  if (key.end || (key.ctrl && (input === 'e' || input === 'E'))) {
+    next.cursor = lineEndIndex(state.buffer, state.cursor);
+    return next;
+  }
+  // Ctrl+K kill-to-end-of-line; Ctrl+W delete-word-backward.
+  if (key.ctrl && (input === 'k' || input === 'K')) {
+    const r = killToLineEnd(state.buffer, state.cursor);
+    next.buffer = r.buffer;
+    next.cursor = r.cursor;
+    return next;
+  }
+  if (key.ctrl && (input === 'w' || input === 'W')) {
+    const r = deleteWordBackward(state.buffer, state.cursor);
+    next.buffer = r.buffer;
+    next.cursor = r.cursor;
+    return next;
+  }
+  if (key.backspace || key.delete) {
+    // Delete the codepoint BEFORE the cursor (not always the end-of-buffer).
+    const r = deleteBackward(state.buffer, state.cursor);
+    next.buffer = r.buffer;
+    next.cursor = r.cursor;
+    return next;
+  }
+  if (input) {
+    // Other Ctrl/Meta chords are not insertable text — swallow so they
+    // don't land as literal letters in the buffer.
+    if (key.ctrl || key.meta) return next;
+    // Insert AT the cursor (was: always append at end).
+    const r = insertAt(state.buffer, state.cursor, input);
+    next.buffer = r.buffer;
+    next.cursor = r.cursor;
+    next.lastWasPaste = paste || input.length >= 16;
+    return next;
+  }
+  return next;
+}
+
+// Pure helper used by the slash-popup branch in <Editor/>. Replaces the
+// editor buffer with `${cmd} ` (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,
+  };
+}
+
+// Replace the whitespace-delimited token that ENDS the buffer with `value`.
+// Used by slash-argument completion: the user types `/model gpt`, picks
+// `gpt-4.1` from the modal, and the partial token is swapped in place. Does NOT
+// submit. Leaves the cursor at the end of the inserted value. When the buffer
+// ends in a space (empty arg token), `value` is appended.
+export function fillArgToken(state, value) {
+  const buffer = state.buffer || '';
+  // Replace the token after the last separator. Comma is a separator too so
+  // comma-lists (`/skill a,b`) complete the trailing segment in place.
+  const start = Math.max(buffer.lastIndexOf(' '), buffer.lastIndexOf(',')) + 1;
+  const filled = buffer.slice(0, start) + value;
+  return {
+    ...state,
+    buffer: filled,
+    cursor: filled.length,
+    lastSubmit: null,
+    lastWasPaste: false,
+  };
+}
+
+// Step one codepoint LEFT of `idx` in `buffer` (UTF-16 aware). Returns the
+// new index (>= 0). If the char before idx is a low surrogate, skip both
+// units so we land before the full astral codepoint.
+export function prevCodepointIndex(buffer, idx) {
+  if (idx <= 0) return 0;
+  const code = buffer.charCodeAt(idx - 1);
+  // Low surrogate (0xDC00–0xDFFF) preceded by a high surrogate → 2 units.
+  if (code >= 0xdc00 && code <= 0xdfff && idx >= 2) {
+    const hi = buffer.charCodeAt(idx - 2);
+    if (hi >= 0xd800 && hi <= 0xdbff) return idx - 2;
+  }
+  return idx - 1;
+}
+
+// Step one codepoint RIGHT of `idx` in `buffer`. Returns the new index
+// (<= buffer.length). High surrogate at idx → consume both units.
+export function nextCodepointIndex(buffer, idx) {
+  const len = buffer.length;
+  if (idx >= len) return len;
+  const code = buffer.charCodeAt(idx);
+  if (code >= 0xd800 && code <= 0xdbff && idx + 1 < len) {
+    const lo = buffer.charCodeAt(idx + 1);
+    if (lo >= 0xdc00 && lo <= 0xdfff) return idx + 2;
+  }
+  return idx + 1;
+}
+
+// Index of the start of the current logical line (after the last '\n' at or
+// before `idx`). Home / Ctrl+A target.
+export function lineStartIndex(buffer, idx) {
+  const nl = buffer.lastIndexOf('\n', Math.max(0, idx - 1));
+  return nl === -1 ? 0 : nl + 1;
+}
+
+// Index of the end of the current logical line (the next '\n' at or after
+// `idx`, or end of buffer). End / Ctrl+E target.
+export function lineEndIndex(buffer, idx) {
+  const nl = buffer.indexOf('\n', idx);
+  return nl === -1 ? buffer.length : nl;
+}
+
+// Insert `text` at `cursor`, returning { buffer, cursor }. Cursor advances by
+// the inserted text's code-unit length so it rests just after the insertion.
+export function insertAt(buffer, cursor, text) {
+  const before = buffer.slice(0, cursor);
+  const after = buffer.slice(cursor);
+  return { buffer: before + text + after, cursor: cursor + text.length };
+}
+
+// Backspace: delete one codepoint BEFORE the cursor (no-op at column 0).
+export function deleteBackward(buffer, cursor) {
+  if (cursor <= 0) return { buffer, cursor };
+  const start = prevCodepointIndex(buffer, cursor);
+  return { buffer: buffer.slice(0, start) + buffer.slice(cursor), cursor: start };
+}
+
+// Ctrl+K: kill from the cursor to the end of the current logical line.
+export function killToLineEnd(buffer, cursor) {
+  const end = lineEndIndex(buffer, cursor);
+  return { buffer: buffer.slice(0, cursor) + buffer.slice(end), cursor };
+}
+
+// Ctrl+W: delete the whitespace-delimited word before the cursor. Eats any
+// run of trailing spaces first (so "foo " + Ctrl+W removes "foo "), matching
+// readline's unix-word-rubout.
+export function deleteWordBackward(buffer, cursor) {
+  let i = cursor;
+  while (i > 0 && /\s/.test(buffer[i - 1])) i -= 1;   // trailing whitespace
+  while (i > 0 && !/\s/.test(buffer[i - 1])) i -= 1;   // the word itself
+  return { buffer: buffer.slice(0, i) + buffer.slice(cursor), cursor: i };
+}

package/tui/hud.mjs

@@ -0,0 +1,111 @@
+// tui/hud.mjs — claude-hud-style status row. The compact status bar shows
+// provider · model · ctx; with the HUD enabled (cfg.chat.hud, default on) a
+// second line adds real-time usage, session cost, the trainer model, and the
+// orchestrator shape. Toggle from /config → "HUD status bar" or the /hud slash.
+//
+// Kept out of repl.mjs/chat.mjs (both at the file-size ratchet) so the gauge
+// can grow without those files growing.
+
+import { costFromUsage } from '../providers/rates.mjs';
+import { resolveTrainer } from '../providers/registry.mjs';
+import chalk from 'chalk';
+
+// HUD on unless explicitly disabled — new users see the richer bar by default.
+export function hudEnabled(cfg) {
+  return !cfg || !cfg.chat || cfg.chat.hud !== false;
+}
+
+// Build the HUD field bundle from live chat state, or null when disabled.
+// `usage` is the running session usage (_inkRunningUsage / runningUsage).
+export function hudStatus(cfg, usage) {
+  if (!hudEnabled(cfg)) return null;
+  const u = usage || {};
+  const inTok = Number(u.inputTokens) || 0;
+  const outTok = Number(u.outputTokens) || 0;
+  // Session cost: a provider-reported total (claude-cli) or rate-card math.
+  let costUsd = 0;
+  try {
+    const c = costFromUsage({ provider: cfg && cfg.provider, model: cfg && cfg.model, usage: u }, cfg && cfg.rates);
+    costUsd = (c && Number(c.cost)) || 0;
+  } catch (_) { /* no rate card → no cost segment */ }
+  // Trainer (learning-loop) model — "auto"/omitted mirrors the chat provider.
+  let trainer = '';
+  try {
+    const t = resolveTrainer(cfg || {});
+    if (t && t.provider) trainer = t.model ? `${t.provider}:${t.model}` : t.provider;
+  } catch (_) { /* ignore */ }
+  // Orchestrator shape, only when it's the active provider.
+  let orch = '';
+  if (cfg && cfg.provider === 'orchestrator' && cfg.orchestrator) {
+    const o = cfg.orchestrator;
+    const w = Array.isArray(o.workers) ? o.workers.length : 0;
+    orch = `${o.planner || '?'} +${w}w`;
+  }
+  return { inTok, outTok, costUsd, trainer, orch };
+}
+
+const fmtTok = (n) => (n >= 1000 ? (n / 1000).toFixed(1) + 'k' : String(n | 0));
+
+// Context gauge: compact counts + percent + a tiny inline bar, with a warn/
+// danger marker once the window fills up. Pure (used, budget) → string so the
+// status bar and tests can share it. chalk is level-gated (0 under NO_COLOR /
+// non-TTY), so colors degrade to plain text automatically; the warn/danger
+// markers are also plain glyphs so they survive even with color off.
+const GAUGE_CELLS = 8;
+const GAUGE_FILLED = '▰';
+const GAUGE_EMPTY = '▱';
+export function formatGauge(used, budget) {
+  const u = Number(used);
+  const b = Number(budget);
+  if (!Number.isFinite(u) || !Number.isFinite(b) || b <= 0) return '--';
+  const pct = (u / b) * 100;
+  const filled = Math.min(GAUGE_CELLS, Math.max(0, Math.round((pct / 100) * GAUGE_CELLS)));
+  const bar = GAUGE_FILLED.repeat(filled) + GAUGE_EMPTY.repeat(GAUGE_CELLS - filled);
+  const body = `${fmtTok(u)}/${fmtTok(b)} ${Math.round(pct)}% ${bar}`;
+  // >=95% danger, >=80% warn — prefix a plain marker so it's legible without
+  // color, then tint the whole gauge so it stands out at a glance.
+  if (pct >= 95) return chalk.red(`! ${body}`);
+  if (pct >= 80) return chalk.yellow(`⚠ ${body}`);
+  return body;
+}
+
+// Render the HUD line (the extra row below the compact status line). Returns
+// '' when there's nothing worth showing.
+export function formatHudRow(f) {
+  if (!f) return '';
+  const seg = [`↑${fmtTok(f.inTok)} ↓${fmtTok(f.outTok)} tok`];
+  if (f.costUsd > 0) seg.push(`$${f.costUsd.toFixed(4)}`);
+  if (f.trainer) seg.push(`trainer ${f.trainer}`);
+  if (f.orch) seg.push(`orch ${f.orch}`);
+  return seg.join('   ');
+}
+
+// `/hud [on|off]` — toggle the HUD row. /config delegates here. No arg opens an
+// on/off picker in the Ink UI, or flips the current value on the legacy path.
+export async function hudSlash(args, ctx) {
+  const cfg = ctx.readConfig ? ctx.readConfig() : (ctx.cfg || {});
+  const cur = hudEnabled(cfg);
+  const a = String(args || '').trim().toLowerCase();
+  let next;
+  if (a === 'on') next = true;
+  else if (a === 'off') next = false;
+  else if (!a && typeof ctx.openPicker === 'function') {
+    const picked = await ctx.openPicker({
+      kind: 'menu',
+      title: 'HUD status bar',
+      subtitle: `currently ${cur ? 'on' : 'off'}`,
+      items: [
+        { id: 'on', label: 'on', desc: 'usage / cost / trainer / orchestrator row' },
+        { id: 'off', label: 'off', desc: 'compact bar (provider · model · ctx)' },
+      ],
+    });
+    const id = picked && typeof picked === 'object' ? picked.id : picked;
+    if (id !== 'on' && id !== 'off') return 'hud: cancelled';
+    next = id === 'on';
+  } else next = !cur;
+  cfg.chat = (cfg.chat && typeof cfg.chat === 'object') ? cfg.chat : {};
+  cfg.chat.hud = next;
+  if (ctx.writeConfig) ctx.writeConfig(cfg);
+  if (ctx.cfg) ctx.cfg.chat = cfg.chat; // mirror so getStatus sees it live
+  return `HUD ${next ? 'on' : 'off'}`;
+}