lazyclaw 5.3.0 → 5.3.2

package/cli.mjs

@@ -853,6 +853,7 @@ async function cmdDoctor() {
   await ensureRegistry();
   const cfg = readConfig();
   const issues = [];
+  const warnings = [];
   if (!cfg.provider) issues.push('config.provider is missing — run `lazyclaw onboard`');
   // Only flag a missing api-key when the picked provider actually
   // requires one. claude-cli / ollama / mock all run keylessly, so the
@@ -864,6 +865,27 @@ async function cmdDoctor() {
   if (cfg.provider && !PROVIDERS_HAS(_registryMod.PROVIDERS, cfg.provider)) {
     issues.push(`unknown provider "${cfg.provider}" — registered: ${Object.keys(_registryMod.PROVIDERS).join(', ')}`);
   }
+  // v5.3.2 soft-migration — pre-5.3.2 wizards could write
+  // `provider: 'orchestrator'` even when the user never configured the
+  // orchestrator section (planner / workers). On those installs the
+  // first chat turn dies with an opaque "orchestrator not configured"
+  // error. Surface a warning + the fix hint, but never auto-rewrite
+  // cfg.json — the user might have legitimately picked orchestrator
+  // and just hasn't finished setup yet.
+  if (cfg.provider === 'orchestrator') {
+    const orch = cfg.orchestrator;
+    const configured = orch && typeof orch === 'object'
+      && typeof orch.planner === 'string' && orch.planner
+      && Array.isArray(orch.workers) && orch.workers.length > 0;
+    if (!configured) {
+      warnings.push(
+        'config.provider is "orchestrator" but cfg.orchestrator is missing/empty. '
+        + 'Pre-v5.3.2 setup wizards could leave you in this half-configured state. '
+        + 'Either finish orchestrator setup (`lazyclaw orchestrator set-planner …` + `lazyclaw orchestrator workers add …`) '
+        + 'or switch to a single concrete provider: `lazyclaw config set provider claude-cli`.'
+      );
+    }
+  }
   // C12 — MinGit / Windows safety net. mas/tools/git.mjs shells out to
   // `git`; on a stripped Windows PATH (no Git-for-Windows installed) or
   // a minimal Docker base image, that spawnSync ENOENTs and any agent
@@ -957,6 +979,7 @@ async function cmdDoctor() {
     nodeVersion: process.version,
     platform: `${process.platform}-${process.arch}`,
     issues,
+    warnings,
     knownProviders: Object.keys(_registryMod.PROVIDERS),
     workflows,
     git: gitInfo,
@@ -1941,7 +1964,15 @@ function _providerFamilies() {
     mock: { label: 'Mock', desc: 'offline echo, only useful for testing', tag: '\x1b[38;5;245m[test]\x1b[0m', members: [] },
   };
   for (const name of all) {
+    // v5.3.2 — orchestrator is strictly opt-in. It's still registered so
+    // `lazyclaw orchestrator …` and explicit `--provider orchestrator`
+    // keep working, but the setup wizard must never land on it as a
+    // default. Previously a fresh user picking "CLI/Local" got
+    // orchestrator bucketed alongside claude-cli/ollama and could end
+    // up with `{ provider: 'orchestrator', model: 'orchestrator' }`
+    // written to cfg.json.
     if (name === 'mock') buckets.mock.members.push(name);
+    else if (name === 'orchestrator') continue;
     else if ((info[name] || {}).requiresApiKey) buckets.api.members.push(name);
     else buckets.cli.members.push(name);
   }
@@ -1975,7 +2006,11 @@ async function _pickProviderInteractive() {
       };
       process.stdin.on('data', onData);
     });
-    return { provider: ans || providers[0], model: null };
+    // v5.3.2 — non-TTY fallback used to be `providers[0]`, which was
+    // whatever happened to be first in the registry (currently
+    // anthropic). Pin to claude-cli to match the interactive onboard
+    // hint at cmdOnboard (the keyless subscription path).
+    return { provider: ans || 'claude-cli', model: null };
   }
 
   // ── Step 1 — auth family ──────────────────────────────────────
@@ -2070,17 +2105,13 @@ async function _pickProviderInteractive() {
     provider = picked;
   }
 
-  // ── Step 3 — model (or, for composite providers, a config wizard) ───
-  // The orchestrator (and any future composite provider) has no model
-  // of its own — it dispatches to other providers. Step 3 routes
-  // through a custom wizard instead of the standard model picker.
-  const providerMeta = (_registryMod.PROVIDER_INFO || {})[provider.id] || {};
-  if (providerMeta.composite || provider.id === 'orchestrator') {
-    const result = await _setupOrchestratorInteractive();
-    if (result === 'CANCEL') return null;
-    if (result === 'BACK')   return _pickProviderInteractive();
-    return { provider: provider.id, model: 'orchestrator' };
-  }
+  // ── Step 3 — model picker ────────────────────────────────────────
+  // v5.3.2 — the setup wizard no longer surfaces composite providers
+  // (orchestrator is filtered out of _providerFamilies above), so this
+  // step is just the regular model picker. The orchestrator wizard
+  // (_setupOrchestratorInteractive) stays reachable via the dedicated
+  // `lazyclaw orchestrator …` subcommand and an explicit
+  // `--provider orchestrator` invocation.
   const picked = await _pickModelInteractive(provider.id, {
     titlePrefix: 'LazyClaw setup — Step 3 of 3:',
     onBack: 'restart',
@@ -2471,7 +2502,11 @@ async function cmdChat(flags = {}) {
       if (picked.model) activeModel = picked.model;
     }
   }
-  if (!activeProvName) activeProvName = 'mock';
+  // v5.3.2 — last-resort safety net used to fall through to 'mock' (the
+  // offline echo provider), which silently degraded a wiped config into
+  // garbage replies. Default to claude-cli so the user lands on the
+  // keyless subscription path instead.
+  if (!activeProvName) activeProvName = 'claude-cli';
   let prov = lookupProv(activeProvName);
   if (!prov) { console.error(`unknown provider: ${activeProvName}`); process.exit(2); }
 
@@ -2634,9 +2669,53 @@ async function cmdChat(flags = {}) {
         ctx: _inkCtx,
         writeFn: (chunk) => process.stdout.write(chunk),
       });
+      // Minimal slash dispatcher for the Ink branch. Covers the read-only
+      // info commands so the user sees something useful instead of having
+      // their slash command sent to the model as a prompt. /exit + /quit
+      // are intercepted inside ReplApp before this fires. Returning a
+      // string causes ReplApp to render the result into scrollback.
+      //
+      // The full set of mutating commands (/model, /provider, /skill,
+      // /personality, ...) still lives in the legacy readline path and
+      // remains accessible via LAZYCLAW_NO_INK=1. Wiring those through
+      // the Ink branch is a follow-up; today we at least stop sending
+      // them as prompts.
+      const _inkSlashHandler = async (line) => {
+        const cmd = line.split(/\s+/)[0];
+        switch (cmd) {
+          case '/help': {
+            const lines = ['slash commands:'];
+            for (const c of SLASH_COMMANDS) lines.push(`  ${c.cmd.padEnd(14)} — ${c.help}`);
+            return lines.join('\n') + '\n';
+          }
+          case '/status': {
+            const out = {
+              provider: activeProvName,
+              model: activeModel,
+              keyMasked: _registryMod.maskApiKey(cfg['api-key']),
+              messageCount: _inkMessages.length,
+            };
+            return JSON.stringify(out) + '\n';
+          }
+          case '/version': {
+            return `lazyclaw ${readVersionFromRepo()} (node ${process.version}, ${process.platform})\n`;
+          }
+          case '/exit':
+          case '/quit':
+            // ReplApp intercepts these before onSlashCommand fires, but
+            // return EXIT defensively in case that contract ever changes.
+            return 'EXIT';
+          default:
+            // Mutating commands still require the legacy readline path.
+            // Telling the user explicitly beats silently sending the
+            // slash text to the model as a prompt.
+            return `${cmd} is not yet wired into the ink REPL — set LAZYCLAW_NO_INK=1 and restart to use it.\n`;
+        }
+      };
       const ink = render(/* @__PURE__ */ React.createElement(ReplApp, {
         splashProps,
         runTurn: _inkRunTurn,
+        onSlashCommand: _inkSlashHandler,
       }));
       await ink.waitUntilExit();
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "5.3.0",
+  "version": "5.3.2",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama, orchestrating multi-step LLM workflows, and running multi-agent Slack teams with cross-task memory. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",

package/providers/orchestrator.mjs

@@ -124,18 +124,33 @@ export function makeOrchestratorProvider(opts = {}) {
       const fallbackSpec = cfg.provider && cfg.provider !== 'orchestrator'
         ? `${cfg.provider}${cfg.model ? ':' + cfg.model : ''}`
         : 'claude-cli';
-      // First-run hint when cfg.orchestrator is missing entirely. The
-      // fallback path below still works (planner = cfg.provider, single
-      // worker = same), but the user almost certainly meant to opt in
-      // explicitly — surface the shortest valid CLI to set it up.
-      if (!cfg.orchestrator) {
-        yield `> orchestrator: \`cfg.orchestrator\` is not set. Defaulting to a single-agent chain on \`${fallbackSpec}\`.\n` +
-          `> Configure properly:  \`lazyclaw orchestrator set-planner ${fallbackSpec}\` then  \`lazyclaw orchestrator workers add <provider:model>\` (one per agent).\n\n`;
+      // Unconfigured-orchestrator path (v5.3.2 fix): when cfg.orchestrator
+      // is missing OR has no workers configured, the multi-agent pipeline
+      // is unjustified — there is no second backend to delegate to. The
+      // previous behaviour printed a "single-agent chain" banner and then
+      // still ran Plan → Execute(N) → Synthesis against the same backend,
+      // turning a trivial question into a 4-subtask decomposition. That
+      // violates §1 truthfulness (the banner promised a single chain) and
+      // the user's stated intent. Do a real passthrough instead.
+      const hasWorkers = Array.isArray(o.workers) && o.workers.length > 0;
+      if (!cfg.orchestrator || !hasWorkers) {
+        const direct = _lookupProvider(fallbackSpec);
+        if (!direct || direct.name === 'orchestrator') {
+          yield `⚠ orchestrator: not configured and fallback provider \`${fallbackSpec}\` is not registered. ` +
+            `Set \`cfg.orchestrator.planner\` + \`cfg.orchestrator.workers\`, or set \`cfg.provider\` to a real backend.\n`;
+          return;
+        }
+        yield `> Orchestrator not configured — using single-shot \`${direct.name}${direct.model ? ':' + direct.model : ''}\`. ` +
+          `Run \`lazyclaw orchestrator set-planner ${fallbackSpec}\` then \`lazyclaw orchestrator workers add <provider:model>\` to enable multi-agent.\n\n`;
+        for await (const chunk of direct.prov.sendMessage(messages, {
+          apiKey: keyResolver(cfg, direct.name),
+          model: direct.model || undefined,
+          signal: callerOpts.signal,
+        })) yield String(chunk);
+        return;
       }
       const plannerSpec = String(o.planner || fallbackSpec);
-      const workerSpecs = Array.isArray(o.workers) && o.workers.length
-        ? o.workers.map(String)
-        : [plannerSpec];
+      const workerSpecs = o.workers.map(String);
       const maxSubtasks = Number.isFinite(o.maxSubtasks) && o.maxSubtasks > 0 ? Math.min(10, o.maxSubtasks) : 5;
 
       const planner = _lookupProvider(plannerSpec);

package/tui/editor.mjs

@@ -10,10 +10,61 @@
 // 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.
+//
+// v5.5: <Editor/> now renders inside a round-bordered Box — the
+// Claude-CLI-style input frame. The border uses `theme.border` (a
+// muted gray) so the accent `›` and sloth gutter stay the dominant
+// amber notes. The box auto-fills the available terminal width via
+// Ink's flex defaults and grows vertically as the buffer wraps onto
+// new lines (Shift+Enter).
+//
+// v5.3.2: CJK / wide-character correctness. `string.length` returns the
+// UTF-16 code-unit count, which is wrong for column math — a Hangul or
+// Han glyph occupies 2 terminal cells but reports `.length === 1`. We
+// keep `state.cursor` in codepoint-index units (so `buffer.slice(0,
+// cursor)`, Backspace, and history recall still work), but expose all
+// display-column math through the `displayWidth()` helper and the
+// derived `cursorDisplayCol` field. The render also pins the Box to
+// `width: '100%'` so Ink's wrap-ansi (already string-width aware) gets
+// the full terminal budget — fixes the perceived right-edge truncation
+// on long Korean buffers.
 import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
+import stringWidth from 'string-width';
 import { theme } from './theme.mjs';
 
+// The accent prompt (`› `) prepended to the first rendered line. Its
+// display width matters for any caller that wants to know the usable
+// inner width of the editor box. Defined once so the value stays in
+// sync if the prompt glyph ever changes.
+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 of it),
+// 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));
+}
+
+// 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: '',
@@ -125,17 +176,29 @@ export function Editor({
       }
       // Tab / Enter — fill the buffer with the highlighted command.
       // First Enter fills, second Enter runs (matches Anthropic's UX).
+      // Exception: if the buffer already exactly matches the picked
+      // command (with or without a trailing space), there is nothing left
+      // to autocomplete. For Enter, fall through to the normal submit
+      // path so /exit, /quit, /help etc. fire on a single Enter. For Tab
+      // on an exact match, no-op.
       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 {}
+        const bufTrim = state.buffer.replace(/\s+$/, '');
+        const alreadyExact = !!picked && (state.buffer === picked.cmd || bufTrim === picked.cmd);
+        if (alreadyExact) {
+          if (key.tab) return; // no completion to make
+          // key.return on exact match → fall through to applyKey/submit.
+        } else {
+          if (picked) {
+            const next = fillSlashCommand(state, picked.cmd);
+            setState(next);
+            if (onBufferChange) {
+              try { onBufferChange(next.buffer); } catch {}
+            }
           }
+          return;
         }
-        return;
       }
       // Anything else (printable, backspace) falls through to applyKey.
     }
@@ -156,7 +219,23 @@ export function Editor({
   const lines = state.buffer.split('\n');
   return React.createElement(
     Box,
-    { flexDirection: 'column' },
-    lines.map((ln, i) => React.createElement(Text, { key: i }, i === 0 ? theme.accent('› ') + ln : '  ' + ln))
+    {
+      borderStyle: 'round',
+      borderColor: theme.border,
+      paddingX: 1,
+      flexDirection: 'column',
+      flexShrink: 0,
+      // Pin to full terminal width. Ink's wrap-ansi (which is
+      // string-width aware) then has the correct cell budget for
+      // wrapping long CJK buffers — fixes the right-edge truncation
+      // perceived on Hangul / Han input. See `displayWidth`/
+      // `cursorDisplayCol` above for the public width helpers.
+      width: '100%',
+    },
+    lines.map((ln, i) => React.createElement(
+      Text,
+      { key: i },
+      i === 0 ? theme.accent(PROMPT_PREFIX) + ln : CONTINUATION_GUTTER + ln,
+    )),
   );
 }

package/tui/repl.mjs

@@ -130,7 +130,7 @@ export function consumeNextTurnFirstMessage(state) {
 //   - runTurnFactory(writeFn) → runTurn(text, signal)   (sticky layout)
 //   - runTurn(text, signal)                              (legacy, stdout)
 // Legacy mode is preserved verbatim for the existing cli.mjs callsite.
-export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands }) {
+export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, onSlashCommand }) {
   // 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);
@@ -163,18 +163,46 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands })
   }
 
   const handleSubmit = useCallback(async (text) => {
-    if (text === '/exit' || text === '/quit') { exit(); return; }
+    // Normalize trailing whitespace so '/exit ' (left over from a popup
+    // fill) is treated identically to '/exit'. Empty input → no-op.
+    const trimmed = (text || '').replace(/\s+$/, '');
+    if (!trimmed) return;
+    // /exit + /quit unmount the Ink app. Done inline so the popup path
+    // and the no-popup path both terminate cleanly.
+    if (trimmed === '/exit' || trimmed === '/quit') { exit(); return; }
+    // Other slash commands: hand off to the host's slash dispatcher
+    // (cli.mjs handleSlash) when one is provided. The host returns a
+    // string (or void) which we append to scrollback as an assistant
+    // turn so the user sees the result inline. If no dispatcher is
+    // wired, fall through to runTurn (legacy behavior).
+    if (trimmed.startsWith('/') && typeof onSlashCommand === 'function') {
+      const controller = new AbortController();
+      setState((s) => onUserInput(s, { text: trimmed, controller }));
+      try {
+        const result = await onSlashCommand(trimmed);
+        if (result === 'EXIT') { exit(); return; }
+        if (typeof result === 'string' && result.length > 0) {
+          setState((s) => onStreamChunk(s, { chunk: result }));
+        }
+        setState((s) => onTurnComplete(s, { reason: 'done' }));
+      } catch (err) {
+        setState((s) => onTurnComplete(s, {
+          reason: err && err.name === 'AbortError' ? 'aborted' : 'error',
+        }));
+      }
+      return;
+    }
     const controller = new AbortController();
-    setState((s) => onUserInput(s, { text, controller }));
+    setState((s) => onUserInput(s, { text: trimmed, controller }));
     try {
-      await runTurnRef.current(text, controller.signal);
+      await runTurnRef.current(trimmed, controller.signal);
       setState((s) => onTurnComplete(s, { reason: 'done' }));
     } catch (err) {
       setState((s) => onTurnComplete(s, {
         reason: err && err.name === 'AbortError' ? 'aborted' : 'error',
       }));
     }
-  }, [exit]);
+  }, [exit, onSlashCommand]);
 
   // Auto-submit queued mid-stream-interrupt message (spec §5.8). Read
   // state.nextTurnFirstMessage so the effect re-fires when promoted.
@@ -234,7 +262,17 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands })
     setSelectedSuggestion(0);
   }, []);
 
-  const showSlashPopup = bufferPeek.startsWith('/') && filtered.length > 0;
+  // Hide the popup when the buffer already exactly matches the only
+  // remaining suggestion (with or without a trailing space). Otherwise
+  // the popup intercepts Enter and the fully-typed command (e.g.
+  // '/exit') never reaches handleSubmit. Belt-and-suspenders with the
+  // editor-side fall-through in tui/editor.mjs.
+  const _bufTrimmed = bufferPeek.replace(/\s+$/, '');
+  const _exactOnly =
+    filtered.length === 1 &&
+    (filtered[0].cmd === bufferPeek || filtered[0].cmd === _bufTrimmed);
+  const showSlashPopup =
+    bufferPeek.startsWith('/') && filtered.length > 0 && !_exactOnly;
 
   return React.createElement(
     Box,

package/tui/splash.mjs

@@ -382,14 +382,55 @@ export function Splash(props) {
   const palette = wordmark.palette;
   const gradient = wordmark.gradient;
   const showWordmark = cols >= WORDMARK_BREAKPOINT;
+  // Sloth banner is emitted at the TOP of NARROW output (45..89) only when
+  // it fits inside the terminal width — see renderNarrow() guard.
+  const showSlothNarrow =
+    cols >= NARROW_BREAKPOINT && cols < MEDIUM_BREAKPOINT &&
+    cols >= banner.width + LMARGIN.length * 2;
+
+  // Per-tier sloth row range [start, end). MEDIUM interleaves the sloth
+  // inside panel rows, so it gets colored via the border regex below — no
+  // dedicated band is needed for that tier.
+  let slothStart = -1, slothEnd = -1;
+  if (showWordmark) {
+    slothStart = wordmark.height + 1 + 1; // wordmark + blank + panel-top
+    slothEnd   = slothStart + banner.height;
+  } else if (showSlothNarrow) {
+    slothStart = 0; // sloth is the first thing emitted
+    slothEnd   = banner.height;
+  }
+
+  // Section headers / summary / compact headline on NARROW that should be
+  // amber to match the WIDE wordmark accent. Matched by exact content.
+  const ACCENT_HEADERS = new Set(['Subcommands', 'Available Tools', 'Available Skills']);
+  // Panel border / status separator glyphs (leading box-drawing after
+  // optional whitespace). Catches ╭ ╰ │ as well as ─ separators.
+  const BORDER_RE = /^\s*[╭╰│├┤┬┴┼─╮╯]/;
+  // NARROW compact headline (e.g. "  lazyclaw 5.3.0").
+  const HEADLINE_RE = /^\s*lazyclaw\s+\S/;
+  // NARROW summary line ("N subcmds · M tools · K skills · /help" or its
+  // wrapped variant). Also catches "/help for commands".
+  const SUMMARY_RE = /(subcmds\s+·|tools\s+·\s+\d+\s+skills|\/help\s+for\s+commands)/;
 
   return React.createElement(
     Box,
     { flexDirection: 'column' },
     lines.map((line, i) => {
       let color;
-      if (showWordmark && i < wordmark.height) color = palette[gradient[i] ?? 1];
-      else if (showWordmark && i < wordmark.height + 1 + 1 + banner.height) color = theme.fg;
+      const trimmed = line.trim();
+      if (showWordmark && i < wordmark.height) {
+        color = palette[gradient[i] ?? 1]; // wordmark gradient
+      } else if (i >= slothStart && i < slothEnd) {
+        color = theme.fg; // sloth band — any tier that stacks the sloth
+      } else if (BORDER_RE.test(line)) {
+        color = theme.fg; // panel borders + status separators
+      } else if (ACCENT_HEADERS.has(trimmed)) {
+        color = theme.fg; // section headers
+      } else if (!showWordmark && HEADLINE_RE.test(line) && /\d/.test(line)) {
+        color = theme.fg; // narrow/medium compact headline ("lazyclaw 5.x.y")
+      } else if (!showWordmark && SUMMARY_RE.test(line)) {
+        color = theme.fg; // narrow/medium summary line
+      }
       return React.createElement(Text, { key: i, color }, line);
     })
   );

package/tui/theme.mjs

@@ -1,9 +1,14 @@
 // tui/theme.mjs — single source of truth for lazyclaw v5 color tokens.
 // The amber hex is also stamped into tui/banner.generated.mjs so the
 // sloth gutter and the prompt accent stay visually paired.
+//
+// v5.5: added `border` token for the chat-input frame (Claude-CLI-style
+// rounded box around the editor). Kept subtly grayer than `amber` so the
+// frame doesn't compete with the accent `›` or the sloth gutter.
 import chalk from 'chalk';
 
 const AMBER_HEX = '#FFB347';
+const BORDER_HEX = '#5A5A5A';
 
 function amber(text) {
   return chalk.hex(AMBER_HEX)(text);
@@ -28,6 +33,7 @@ function plain(text) {
 export const theme = {
   amber: AMBER_HEX,
   fg: AMBER_HEX,
+  border: BORDER_HEX,
   colorize: amber,
   dim,
   accent,