lazyclaw 6.0.0 → 6.1.0

package/lib/service_install.mjs

@@ -0,0 +1,207 @@
+// lib/service_install.mjs — install a lazyclaw long-running command as an
+// always-on OS service across three backends:
+//   - launchd  (macOS): plist with RunAtLoad + KeepAlive
+//   - systemd  (Linux user unit): Restart=always
+//   - fallback (no service manager): detached child + pidfile
+//
+// The unit-file builders + backend detection are PURE. The apply layer
+// (install/uninstall/status) takes injectable deps (fs/spawn/spawnSync/isAlive)
+// so it is fully testable without touching the real OS.
+//
+// NOTE: this is distinct from cron.mjs's plist machinery, which emits a
+// StartCalendarInterval (scheduled) plist with RunAtLoad=false — the opposite
+// of an always-on service.
+
+import os from 'node:os';
+import path from 'node:path';
+import fsReal from 'node:fs';
+import { spawn as spawnReal, spawnSync as spawnSyncReal } from 'node:child_process';
+import { isProcessAlive } from '../loops.mjs';
+
+export class ServiceError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = 'ServiceError';
+    this.code = code || 'SERVICE_ERR';
+  }
+}
+
+function xmlEscape(s) {
+  return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+// ---- pure helpers ----
+
+export function servicePaths(name, { home = os.homedir(), configDir } = {}) {
+  const cfg = configDir || path.join(home, '.lazyclaw');
+  return {
+    launchd: path.join(home, 'Library', 'LaunchAgents', `com.lazyclaw.${name}.plist`),
+    systemd: path.join(home, '.config', 'systemd', 'user', `lazyclaw-${name}.service`),
+    pidfile: path.join(cfg, `${name}.pid`),
+    logfile: path.join(cfg, `${name}.log`),
+  };
+}
+
+export function detectBackend({ platform = process.platform, hasSystemctl = false, override = null } = {}) {
+  if (override) return override;
+  if (platform === 'darwin') return 'launchd';
+  if (platform === 'linux' && hasSystemctl) return 'systemd';
+  return 'fallback';
+}
+
+export function buildLaunchdPlist({ name, execPath, args, workingDir, logfile, env = {} }) {
+  const progArgs = [execPath, ...args]
+    .map((a) => `    <string>${xmlEscape(a)}</string>`)
+    .join('\n');
+  const envBlock = Object.keys(env).length
+    ? `  <key>EnvironmentVariables</key>\n  <dict>\n` +
+      Object.entries(env).map(([k, v]) => `    <key>${xmlEscape(k)}</key><string>${xmlEscape(v)}</string>`).join('\n') +
+      `\n  </dict>\n`
+    : '';
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>com.lazyclaw.${xmlEscape(name)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${progArgs}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>WorkingDirectory</key><string>${xmlEscape(workingDir)}</string>
+  <key>StandardOutPath</key><string>${xmlEscape(logfile)}</string>
+  <key>StandardErrorPath</key><string>${xmlEscape(logfile)}</string>
+${envBlock}</dict>
+</plist>
+`;
+}
+
+export function buildSystemdUnit({ description, execPath, args, workingDir, env = {} }) {
+  // systemd ExecStart wants an absolute path + a single command line. We keep
+  // the argv simple (paths/flags lazyclaw produces have no shell metachars),
+  // so a plain space-join is correct and readable.
+  const exec = [execPath, ...args].join(' ');
+  const envLines = Object.entries(env).map(([k, v]) => `Environment=${k}=${v}`).join('\n');
+  return `[Unit]
+Description=${description}
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${exec}
+WorkingDirectory=${workingDir}
+Restart=always
+RestartSec=3
+${envLines ? envLines + '\n' : ''}
+[Install]
+WantedBy=default.target
+`;
+}
+
+// ---- apply layer (side-effectful, injectable deps) ----
+
+function resolveDeps(deps = {}) {
+  return {
+    fs: deps.fs || fsReal,
+    spawnSync: deps.spawnSync || spawnSyncReal,
+    spawn: deps.spawn || spawnReal,
+    isAlive: deps.isAlive || isProcessAlive,
+  };
+}
+
+export function installService(spec, depsIn = {}) {
+  const { name, execPath, args, workingDir, env = {}, backend, description, home, configDir, logfile } = spec;
+  const deps = resolveDeps(depsIn);
+  const p = servicePaths(name, { home, configDir });
+  const log = logfile || p.logfile;
+
+  if (backend === 'launchd') {
+    deps.fs.mkdirSync(path.dirname(p.launchd), { recursive: true });
+    deps.fs.writeFileSync(p.launchd, buildLaunchdPlist({ name, execPath, args, workingDir, logfile: log, env }));
+    deps.spawnSync('launchctl', ['unload', p.launchd], { stdio: 'ignore' });
+    const r = deps.spawnSync('launchctl', ['load', p.launchd], { encoding: 'utf8' });
+    if (r && r.status !== 0) throw new ServiceError(`launchctl load failed: ${r.stderr || r.status}`, 'SERVICE_LAUNCHD_FAIL');
+    return { backend, target: p.launchd };
+  }
+
+  if (backend === 'systemd') {
+    deps.fs.mkdirSync(path.dirname(p.systemd), { recursive: true });
+    deps.fs.writeFileSync(p.systemd, buildSystemdUnit({ description, execPath, args, workingDir, env }));
+    deps.spawnSync('systemctl', ['--user', 'daemon-reload'], { stdio: 'ignore' });
+    const r = deps.spawnSync('systemctl', ['--user', 'enable', '--now', `lazyclaw-${name}.service`], { encoding: 'utf8' });
+    if (r && r.status !== 0) throw new ServiceError(`systemctl enable failed: ${r.stderr || r.status}`, 'SERVICE_SYSTEMD_FAIL');
+    return { backend, target: p.systemd };
+  }
+
+  if (backend === 'fallback') {
+    // No service manager: detach a child and record its pid. This survives
+    // the launching terminal but NOT a reboot — the caller is told so.
+    deps.fs.mkdirSync(path.dirname(p.pidfile), { recursive: true });
+    const child = deps.spawn(execPath, args, {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...process.env, ...env },
+    });
+    if (child && typeof child.unref === 'function') child.unref();
+    deps.fs.writeFileSync(p.pidfile, String(child.pid));
+    return { backend, pid: child.pid, pidfile: p.pidfile };
+  }
+
+  throw new ServiceError(`unknown service backend: ${backend}`, 'SERVICE_BAD_BACKEND');
+}
+
+export function uninstallService(spec, depsIn = {}) {
+  const { name, backend, home, configDir } = spec;
+  const deps = resolveDeps(depsIn);
+  const p = servicePaths(name, { home, configDir });
+
+  if (backend === 'launchd') {
+    if (deps.fs.existsSync(p.launchd)) {
+      deps.spawnSync('launchctl', ['unload', p.launchd], { stdio: 'ignore' });
+      deps.fs.rmSync(p.launchd);
+    }
+    return { backend, removed: p.launchd };
+  }
+  if (backend === 'systemd') {
+    deps.spawnSync('systemctl', ['--user', 'disable', '--now', `lazyclaw-${name}.service`], { stdio: 'ignore' });
+    if (deps.fs.existsSync(p.systemd)) deps.fs.rmSync(p.systemd);
+    deps.spawnSync('systemctl', ['--user', 'daemon-reload'], { stdio: 'ignore' });
+    return { backend, removed: p.systemd };
+  }
+  if (backend === 'fallback') {
+    let pid = null;
+    if (deps.fs.existsSync(p.pidfile)) {
+      pid = parseInt(deps.fs.readFileSync(p.pidfile, 'utf8'), 10);
+      if (Number.isFinite(pid)) { try { process.kill(pid); } catch { /* already gone */ } }
+      deps.fs.rmSync(p.pidfile);
+    }
+    return { backend, killed: pid };
+  }
+  throw new ServiceError(`unknown service backend: ${backend}`, 'SERVICE_BAD_BACKEND');
+}
+
+export function serviceStatus(spec, depsIn = {}) {
+  const { name, backend, home, configDir } = spec;
+  const deps = resolveDeps(depsIn);
+  const p = servicePaths(name, { home, configDir });
+
+  if (backend === 'launchd') {
+    return { backend, installed: deps.fs.existsSync(p.launchd), target: p.launchd };
+  }
+  if (backend === 'systemd') {
+    const installed = deps.fs.existsSync(p.systemd);
+    const r = deps.spawnSync('systemctl', ['--user', 'is-active', `lazyclaw-${name}.service`], { encoding: 'utf8' });
+    const running = !!r && typeof r.stdout === 'string' && r.stdout.trim() === 'active';
+    return { backend, installed, running, target: p.systemd };
+  }
+  if (backend === 'fallback') {
+    if (!deps.fs.existsSync(p.pidfile)) return { backend, installed: false, running: false };
+    const pid = parseInt(deps.fs.readFileSync(p.pidfile, 'utf8'), 10);
+    return { backend, installed: true, running: Number.isFinite(pid) && deps.isAlive(pid), pid: Number.isFinite(pid) ? pid : null };
+  }
+  throw new ServiceError(`unknown service backend: ${backend}`, 'SERVICE_BAD_BACKEND');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "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",
@@ -33,15 +33,27 @@
   "scripts": {
     "test": "node --test tests/*.test.mjs && playwright test",
     "lint:size": "node scripts/lint-file-size.mjs",
+    "lint:pack": "node scripts/check-pack.mjs",
     "test:bench": "node scripts/bench-providers.mjs",
     "test:bench:index": "node --test tests/index_store.bench.mjs",
     "test:perf": "node --test tests/phaseH-perf.test.mjs tests/index_store.bench.mjs",
-    "migrate:v5": "node scripts/migrate-v5.mjs",
-    "build:splash": "node scripts/build-splash.mjs"
+    "migrate:v5": "node scripts/migrate-v5.mjs"
   },
   "files": [
     "cli.mjs",
     "daemon.mjs",
+    "daemon/",
+    "lib/",
+    "commands/",
+    "first_run.mjs",
+    "dotenv_min.mjs",
+    "goals_cron.mjs",
+    "secure_write.mjs",
+    "channels-discord/",
+    "channels-email/",
+    "channels-signal/",
+    "channels-voice/",
+    "channels-whatsapp/",
     "sessions.mjs",
     "skills.mjs",
     "logger.mjs",

package/providers/probe.mjs

@@ -0,0 +1,28 @@
+// providers/probe.mjs — smoke-test a single provider with a tiny prompt.
+//
+// Returns the result object; it never logs and never calls process.exit, so
+// callers decide how to render and whether to exit. The CLI `providers test`
+// prints JSON and exits; the setup wizard's verify step prints one concise
+// line and KEEPS GOING (a process.exit here would kill the rest of the
+// wizard — the bug this split fixes).
+import { getRegistry } from '../lib/registry_boot.mjs';
+
+export async function probeProvider({ name, model, prompt = 'ping', apiKey = '' }) {
+  const provider = getRegistry().PROVIDERS[name];
+  if (!provider) {
+    return { ok: false, provider: name, model, durationMs: 0, error: `unknown provider: ${name}`, code: 'UNKNOWN_PROVIDER' };
+  }
+  const t0 = Date.now();
+  try {
+    let reply = '';
+    const stream = provider.sendMessage([{ role: 'user', content: prompt }], { apiKey, model });
+    for await (const chunk of stream) {
+      if (typeof chunk === 'string') reply += chunk;
+    }
+    const durationMs = Date.now() - t0;
+    const ok = reply.length > 0;
+    return { ok, provider: name, model, durationMs, replyLength: reply.length, reply: reply.slice(0, 200) + (reply.length > 200 ? '…' : '') };
+  } catch (err) {
+    return { ok: false, provider: name, model, durationMs: Date.now() - t0, error: err?.message || String(err), code: err?.code || null };
+  }
+}

package/secure_write.mjs

@@ -0,0 +1,46 @@
+// secure_write.mjs — atomic file writes with owner-only (0600/0700) perms,
+// for files that hold secrets: config.json (plaintext API keys / auth
+// profiles), workflow state (transcript content), any .env the tool writes.
+//
+// Lifted from gateway/device_auth.mjs::writeAtomic: set restrictive modes on
+// create AND re-assert with chmod after rename, because the active umask can
+// clear bits at mkdir/open time and a pre-existing file keeps its old (looser)
+// mode otherwise. chmod is best-effort (a no-op / unsupported on some
+// filesystems and on Windows); the {mode} on write is the primary guard.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const SECURE_DIR_MODE = 0o700;
+export const SECURE_FILE_MODE = 0o600;
+
+function chmodQuiet(p, mode) {
+  try { fs.chmodSync(p, mode); } catch { /* unsupported FS / platform — mode on write stands */ }
+}
+
+export function writeTextSecure(filePath, text) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
+  chmodQuiet(dir, SECURE_DIR_MODE);
+  const tmp = `${filePath}.tmp`;
+  fs.writeFileSync(tmp, text, { mode: SECURE_FILE_MODE });
+  chmodQuiet(tmp, SECURE_FILE_MODE);
+  fs.renameSync(tmp, filePath);
+  chmodQuiet(filePath, SECURE_FILE_MODE);
+}
+
+export function writeJsonSecure(filePath, obj) {
+  writeTextSecure(filePath, JSON.stringify(obj, null, 2));
+}
+
+// Tighten an existing secrets file to 0600 if it is currently group/other
+// accessible. Best-effort + idempotent — used to migrate already-deployed
+// world-readable config.json the first time it is read. Returns true if it
+// changed the mode.
+export function tightenIfLoose(filePath) {
+  try {
+    const st = fs.statSync(filePath);
+    if ((st.mode & 0o077) !== 0) { fs.chmodSync(filePath, SECURE_FILE_MODE); return true; }
+  } catch { /* missing / unreadable → nothing to tighten */ }
+  return false;
+}

package/tui/editor.mjs

@@ -359,7 +359,13 @@ export function Editor({
   // sees at most a one-tick flicker. The IME-correctness win is worth
   // the cosmetic cost. Opt out via LAZYCLAW_NO_CURSOR_ANCHOR=1.
   useEffect(() => {
-    if (!altEnabled) return;
+    // Runs in BOTH the alt-buffer and the default (non-alt Static) layouts: the
+    // editor is the last child either way, so the cursor parks below it and the
+    // rowsUp math (editor geometry only) is identical. Anchoring in non-alt is
+    // what makes the terminal cursor visible AT the caret (so you can see where
+    // you're typing) and what keeps a CJK/Hangul IME pre-edit inside the box
+    // instead of leaking onto the row below. Opt out via LAZYCLAW_NO_CURSOR_ANCHOR=1.
+    void altEnabled;
     if (process.env.LAZYCLAW_NO_CURSOR_ANCHOR === '1') return;
     if (!(process.stdout && process.stdout.isTTY)) return;
     const cols = Math.max(20, process.stdout.columns || 80);
@@ -402,9 +408,19 @@ export function Editor({
     const prefixWidth = rowInEditor === 0 ? PROMPT_WIDTH : CONTINUATION_WIDTH;
     const colTarget = 3 + prefixWidth + colInLine;
     _installAnchorShim();
+    // If a previous anchor moved the cursor up and NO render's eraseLines has
+    // consumed that offset yet (two state updates between redraws — e.g. fast
+    // typing or backspace), the cursor is still parked up inside the editor.
+    // Undo that move first (\x1b[<pending>B) so we re-anchor from the true
+    // "below the frame" baseline. Without this the moves stacked, the shim
+    // only compensated for the LAST one, and eraseLines walked up into — and
+    // erased — the scrollback above the editor (corruption was invisible in
+    // the fixed alt-buffer canvas, visible in the default Static layout).
+    const pending = _anchorState.offset;
+    const undo = pending > 0 ? `\x1b[${pending}B\r` : '';
     _anchorState.offset = rowsUp;
     try {
-      process.stdout.write(`\x1b[${rowsUp}A\x1b[${colTarget}G\x1b[?25h`);
+      process.stdout.write(`${undo}\x1b[${rowsUp}A\x1b[${colTarget}G\x1b[?25h`);
     } catch { /* stdout closed — swallow */ }
   }, [state.buffer, state.cursor, altEnabled]);
 

package/tui/repl.mjs

@@ -154,9 +154,25 @@ export function onEscape(state) {
   };
 }
 
-// New reducer: stream chunk arrives, accumulate in liveAssistant.
+// Stream chunk arrives. Completed lines are committed to the <Static>
+// scrollback immediately (so they scroll up ABOVE the sticky editor), and only
+// the in-progress trailing partial stays in the live region. Without this, a
+// reply taller than the terminal grew the live frame past the viewport and
+// spilled BELOW the input box (long orchestrator replies). Chunks without a
+// newline still just accumulate (the prior behaviour), so short replies and the
+// existing reducer tests are unchanged.
 export function onStreamChunk(state, { chunk }) {
-  return { ...state, liveAssistant: state.liveAssistant + chunk };
+  const buf = state.liveAssistant + chunk;
+  const nl = buf.lastIndexOf('\n');
+  if (nl < 0) return { ...state, liveAssistant: buf };
+  const complete = buf.slice(0, nl);          // one or more whole lines
+  const remainder = buf.slice(nl + 1);        // trailing partial (may be '')
+  const id = `as-${state.turnCounter}-${state.scrollback.length}`;
+  return {
+    ...state,
+    scrollback: [...state.scrollback, { kind: 'assistant', id, text: complete }],
+    liveAssistant: remainder,
+  };
 }
 
 export function onTurnComplete(state, { reason, error } = {}) {
@@ -463,10 +479,15 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
   const modalOpen = !!modal;
 
   // Slash popup is suppressed whenever a modal picker is active so the
-  // overlays don't stack.
+  // overlays don't stack, AND once the buffer has a space (the user is typing
+  // ARGS, e.g. `/orchestrator off`). Without the space guard the popup stayed
+  // open as a one-row hint and the editor treated Enter as "fill the matched
+  // command", which dropped the args and reverted the buffer to the bare
+  // command. With args, Enter must submit the full line instead.
   const showSlashPopup =
     !modalOpen &&
-    bufferPeek.startsWith('/') && filtered.length > 0 && !_exactOnly;
+    bufferPeek.startsWith('/') && bufferPeek.indexOf(' ') < 0 &&
+    filtered.length > 0 && !_exactOnly;
 
   // Outer column height: pinned to rows-1 in alt-buffer mode so the
   // Editor truly sticks to the bottom. Non-alt keeps content-sized layout

package/tui/slash_commands.mjs

@@ -26,6 +26,10 @@ export const SLASH_COMMANDS = [
   { cmd: '/personality', help: 'pick a personality (or sub: list|show|install|remove|use)' },
   { cmd: '/dashboard',   help: 'open the lazyclaw web UI in your browser' },
   { cmd: '/menu',        help: 'browse the full subcommand catalog (command palette)' },
+  { cmd: '/config',      help: 'leave chat and re-run the setup wizard (provider, model, channels)' },
+  { cmd: '/channels',    help: 'view configured channels; /channels <name> on|off to toggle' },
+  { cmd: '/orchestrator', help: 'multi-agent: status | on | off | planner <spec> | worker add|remove <spec>' },
+  { cmd: '/context',      help: 'chat history window: status | turns <N> | tokens <N>' },
   { 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]]' },

package/tui/slash_dispatcher.mjs

@@ -1670,6 +1670,119 @@ async function _menu(args, ctx) {
   ].join('\n');
 }
 
+// /channels — view configured channels and toggle them. `/channels` lists;
+// `/channels <name> on|off` enables/disables. Reads/writes cfg via ctx when
+// available, else lib/config directly, so it works on both REPL paths.
+async function _channels(args, ctx = {}) {
+  const cf = await import('../config_features.mjs');
+  const cfgMod = await import('../lib/config.mjs');
+  const read = typeof ctx.readConfig === 'function' ? ctx.readConfig : cfgMod.readConfig;
+  const write = typeof ctx.writeConfig === 'function' ? ctx.writeConfig : cfgMod.writeConfig;
+  const [name, action] = (args || '').trim().split(/\s+/).filter(Boolean);
+  if (name && /^(on|off|enable|disable)$/i.test(action || '')) {
+    const en = /^(on|enable)$/i.test(action);
+    const cfg = read();
+    const key = name.toLowerCase();
+    // Reject unknown names so a typo can't silently create a bogus
+    // cfg.channels.<name> section (which would then leak into the list).
+    // Stay permissive for pre-existing custom sections.
+    const existing = (cfg.channels && typeof cfg.channels === 'object') ? cfg.channels : {};
+    if (!cf.KNOWN_CHANNELS.includes(key) && !(key in existing)) {
+      return `unknown channel: ${key} (known: ${cf.KNOWN_CHANNELS.join(', ')})`;
+    }
+    cf.channelSetEnabled(cfg, key, en); write(cfg);
+    // Legacy fallback path: the readline ctx (_legacyCtx) has no
+    // readConfig/writeConfig, so we read/wrote disk above against a fresh
+    // cfg object. Mirror the toggle onto the in-session ctx.cfg so a
+    // follow-up `/channels` (list) or other in-session read stays
+    // consistent instead of showing the stale pre-toggle value.
+    if (ctx.cfg && ctx.cfg !== cfg && typeof ctx.cfg === 'object') {
+      cf.channelSetEnabled(ctx.cfg, key, en);
+    }
+    return `channel ${key} → ${en ? 'enabled' : 'disabled'}`;
+  }
+  const rows = cf.channelStatusList(read());
+  if (!rows.length) return 'no channels configured. add creds with /config (re-runs setup) or `lazyclaw setup`.';
+  const lines = ['configured channels:'];
+  for (const c of rows) lines.push(`  ${c.name}  ${c.enabled ? 'enabled' : 'disabled'}${c.boundAgent ? ' · agent: ' + c.boundAgent : ''}`);
+  lines.push('toggle: /channels <name> on|off   ·   add creds: /config');
+  return lines.join('\n');
+}
+
+// /orchestrator — view/edit multi-agent config. `status` (default), `on`/`off`,
+// `planner <spec>`, `worker add|remove <spec>`, `maxsubtasks <N>`. ctx-or-
+// lib/config fallback so it works on both REPL paths.
+async function _orchestrator(args, ctx = {}) {
+  const cf = await import('../config_features.mjs');
+  const cfgMod = await import('../lib/config.mjs');
+  const read = typeof ctx.readConfig === 'function' ? ctx.readConfig : cfgMod.readConfig;
+  const write = typeof ctx.writeConfig === 'function' ? ctx.writeConfig : cfgMod.writeConfig;
+  const persist = (cfg) => { write(cfg); if (ctx.cfg) ctx.cfg = cfg; };
+  const parts = (args || '').trim().split(/\s+/).filter(Boolean);
+  const fmt = () => {
+    const s = cf.orchestratorGet(read());
+    return `orchestrator: ${s.active ? 'ON' : 'off'}  ·  planner: ${s.planner || '(default)'}  ·  workers: ${s.workers.length ? s.workers.join(', ') : '(none)'}  ·  maxSubtasks: ${s.maxSubtasks}`;
+  };
+  // Bare `/orchestrator` → arrow-key picker (Ink). Pick ON/OFF/Status instead
+  // of typing the subcommand. Legacy path (no openPicker) shows status text.
+  if (parts.length === 0 && typeof ctx.openPicker === 'function') {
+    const s = cf.orchestratorGet(read());
+    const picked = await ctx.openPicker({
+      title: 'Orchestration',
+      subtitle: `now ${s.active ? 'ON' : 'off'} · planner ${s.planner || '(default)'} · ${s.workers.length} worker(s)`,
+      items: [
+        { id: 'on', label: 'Turn ON', desc: 'route chats through planner + workers' },
+        { id: 'off', label: 'Turn OFF', desc: 'back to a single provider' },
+        { id: 'status', label: 'Status', desc: 'show current config' },
+      ],
+    });
+    if (!picked || typeof picked !== 'string') return fmt();
+    return _orchestrator(picked, ctx);
+  }
+  const sub = (parts[0] || 'status').toLowerCase();
+  if (sub === 'status') return fmt();
+  const cfg = read();
+  if (sub === 'on' || sub === 'enable') {
+    if (!cf.orchestratorGet(cfg).planner) {
+      const base = cfg.provider && cfg.provider !== 'orchestrator' ? cfg.provider : 'claude-cli';
+      cf.orchestratorSet(cfg, { planner: base });
+    }
+    cf.orchestratorEnable(cfg, true); persist(cfg);
+    const after = cf.orchestratorGet(read());
+    return after.workers.length ? 'orchestration ON.\n' + fmt() : 'orchestration ON — but no workers yet. Add one: /orchestrator worker add <provider[:model]>';
+  }
+  if (sub === 'off' || sub === 'disable') { cf.orchestratorEnable(cfg, false); persist(cfg); return 'orchestration off. provider → ' + read().provider; }
+  if (sub === 'planner') { if (!parts[1]) return 'usage: /orchestrator planner <provider[:model]>'; cf.orchestratorSet(cfg, { planner: parts[1] }); persist(cfg); return 'planner → ' + parts[1]; }
+  if (sub === 'maxsubtasks') { const n = parseInt(parts[1], 10); if (!Number.isFinite(n)) return 'usage: /orchestrator maxsubtasks <N>'; cf.orchestratorSet(cfg, { maxSubtasks: Math.max(1, Math.min(10, n)) }); persist(cfg); return fmt(); }
+  if (sub === 'worker') {
+    const action = (parts[1] || '').toLowerCase(); const spec = parts[2];
+    const workers = [...cf.orchestratorGet(cfg).workers];
+    if (action === 'add' && spec) { if (!workers.includes(spec)) workers.push(spec); cf.orchestratorSet(cfg, { workers }); persist(cfg); return 'workers: ' + workers.join(', '); }
+    if ((action === 'remove' || action === 'rm') && spec) { const next = workers.filter((w) => w !== spec); cf.orchestratorSet(cfg, { workers: next }); persist(cfg); return 'workers: ' + (next.join(', ') || '(none)'); }
+    return 'usage: /orchestrator worker add|remove <provider[:model]>';
+  }
+  return 'usage: /orchestrator [status|on|off|planner <spec>|worker add|remove <spec>|maxsubtasks <N>]';
+}
+
+// /context — view/set the chat history window (turns + token budget). This is
+// the sliding history budget sent each turn, NOT the model's hard context
+// limit. ctx-or-lib/config fallback so it works on both REPL paths.
+async function _context(args, ctx = {}) {
+  const cf = await import('../config_features.mjs');
+  const cfgMod = await import('../lib/config.mjs');
+  const read = typeof ctx.readConfig === 'function' ? ctx.readConfig : cfgMod.readConfig;
+  const write = typeof ctx.writeConfig === 'function' ? ctx.writeConfig : cfgMod.writeConfig;
+  const persist = (cfg) => { write(cfg); if (ctx.cfg) ctx.cfg = cfg; };
+  const parts = (args || '').trim().split(/\s+/).filter(Boolean);
+  const sub = (parts[0] || 'status').toLowerCase();
+  const fmt = () => { const w = cf.chatWindowGet(read()); return `context window: ${w.turns} turns · ${w.tokens} tokens  (history budget — not the model's hard limit)`; };
+  if (sub === 'status') return fmt();
+  const n = parseInt(parts[1], 10);
+  if (sub === 'turns') { if (!Number.isFinite(n) || n < 1) return 'usage: /context turns <N>'; const cfg = read(); cf.chatWindowSet(cfg, { turns: n }); persist(cfg); return fmt(); }
+  if (sub === 'tokens') { if (!Number.isFinite(n) || n < 256) return 'usage: /context tokens <N>  (min 256)'; const cfg = read(); cf.chatWindowSet(cfg, { tokens: n }); persist(cfg); return fmt(); }
+  return 'usage: /context [status | turns <N> | tokens <N>]';
+}
+
 // ─── dispatch table ──────────────────────────────────────────────────────
 
 export const SLASH_HANDLERS = new Map([
@@ -1698,6 +1811,11 @@ export const SLASH_HANDLERS = new Map([
   ['/trainer', _trainer],
   ['/dashboard', _dashboard],
   ['/menu', _menu],
+  ['/channels', _channels],
+  ['/orchestrator', _orchestrator],
+  ['/context', _context],
+  // /config — unmount and let chat.mjs run the setup wizard (ctx.requestSetup).
+  ['/config', async (_a, ctx) => { ctx.requestSetup = true; return 'EXIT'; }],
   ['/exit', async () => 'EXIT'],
   ['/quit', async () => 'EXIT'],
 ]);

package/tui/splash_props.mjs

@@ -0,0 +1,52 @@
+// tui/splash_props.mjs — gather the dynamic props the splash panel needs
+// (tool groups + skill groups), shared by the chat REPL and the setup wizard
+// so both surfaces render the same lazyclaw splash instead of drifting apart
+// (the setup wizard used to show a small figlet banner instead).
+import path from 'node:path';
+import { configPath } from '../lib/config.mjs';
+
+// Re-export the renderer so setup/onboarding callers need one import.
+export { renderSplashToString } from './splash.mjs';
+
+// Verbatim from the chat REPL's former inline block: collapse the v5 tool
+// registry to one row per category, and group installed skills by their
+// filename hyphen-prefix. Failures degrade to empty lists, never throw.
+export async function gatherToolAndSkillGroups(cfgDir) {
+  let tools = [];
+  try {
+    const registry = await import('../mas/tools/registry.mjs');
+    const byCat = registry.byCategory();
+    tools = Object.entries(byCat).map(([category, items]) => ({
+      category,
+      sensitive: items.some((t) => t.sensitive),
+      verbs: items.map((t) => t.name.replace(/^[a-z]+_/, '')).slice(0, 6),
+    })).sort((a, b) => a.category.localeCompare(b.category));
+  } catch { /* registry unavailable → empty list */ }
+
+  let skills = [];
+  try {
+    const { listSkills } = await import('../skills.mjs');
+    const flat = listSkills(cfgDir);
+    const byGroup = new Map();
+    for (const s of flat) {
+      const i = s.name.indexOf('-');
+      const group = i > 0 ? s.name.slice(0, i) : 'general';
+      const sub = i > 0 ? s.name.slice(i + 1) : s.name;
+      if (!byGroup.has(group)) byGroup.set(group, []);
+      byGroup.get(group).push(sub);
+    }
+    skills = [...byGroup.entries()]
+      .map(([group, names]) => ({ group, names: names.slice(0, 6) }))
+      .sort((a, b) => a.group.localeCompare(b.group));
+  } catch { /* skills dir unavailable → empty list */ }
+
+  return { tools, skills };
+}
+
+// Build the full splash props for the setup wizard. Self-contained (resolves
+// the config dir itself) so call sites stay one line.
+export async function splashPropsForSetup({ version = '', provider = '', model = '' } = {}) {
+  const cfgDir = path.dirname(configPath());
+  const { tools, skills } = await gatherToolAndSkillGroups(cfgDir);
+  return { provider, model, trainer: {}, sessionId: '', cwd: process.cwd(), version, tools, skills };
+}

package/web/dashboard.css

@@ -4,7 +4,8 @@
       --border: #2a2a36;
       --text: #e8e8ea;
       --dim: #a8a8b8;
-      --accent: #d97757;
+      --accent: #d9b35a;
+      --accent-ink: #1a1610;
       --ok: #4ade80;
       --warn: #f59e0b;
       --err: #ef4444;
@@ -27,14 +28,7 @@
       gap: 14px;
     }
     .logo { font-weight: 700; font-size: 16px; color: var(--accent); display: flex; align-items: center; gap: 10px; }
-    .logo .mascot { width: 44px; height: 44px; flex: none; image-rendering: pixelated; image-rendering: crisp-edges; }
     .ver  { color: var(--dim); font-size: 11px; }
-    /* lazyclaw 16x16 pixel mascot — Claude Design handoff (mascot sheet
-       v0.1, "claude original" palette). Claude's asterisk star (#d97757)
-       worn under a crustacean helmet (#c33d2a) with two antenna-claws.
-       Idle pose (sleepy slits). Hover gently brightens the helmet. */
-    .mascot { transition: filter 0.2s ease; }
-    .logo:hover .mascot { filter: drop-shadow(0 0 6px rgba(217, 119, 87, 0.45)); }
     nav.tabs {
       display: flex;
       flex-wrap: wrap;
@@ -81,7 +75,7 @@
     .dim { color: var(--dim); font-size: 12px; }
     button.btn {
       background: var(--accent);
-      color: #fff;
+      color: var(--accent-ink);
       border: 0;
       border-radius: 6px;
       padding: 8px 14px;
@@ -119,7 +113,7 @@
       gap: 14px;
     }
     .msg { padding: 8px 12px; border-radius: 6px; max-width: 90%; white-space: pre-wrap; word-wrap: break-word; }
-    .msg.user { align-self: flex-end; background: rgba(217, 119, 87, 0.15); border: 1px solid rgba(217, 119, 87, 0.3); }
+    .msg.user { align-self: flex-end; background: rgba(217, 179, 90, 0.15); border: 1px solid rgba(217, 179, 90, 0.3); }
     .msg.assistant { align-self: flex-start; background: rgba(74, 222, 128, 0.06); border: 1px solid rgba(74, 222, 128, 0.18); }
     .msg.error { align-self: stretch; background: rgba(239, 68, 68, 0.12); border: 1px solid rgba(239, 68, 68, 0.3); color: #ffd3d3; }
     .input-row {
@@ -230,9 +224,9 @@
     .modal-body { padding: 16px 18px; overflow-y: auto; flex: 1; }
     .modal-foot { padding: 12px 18px; border-top: 1px solid var(--border); display: flex; gap: 8px; justify-content: flex-end; }
     .clickable { cursor: pointer; }
-    .clickable:hover { background: rgba(217, 119, 87, 0.05); }
+    .clickable:hover { background: rgba(217, 179, 90, 0.05); }
     .turn { padding: 8px 12px; border-radius: 6px; margin-bottom: 8px; white-space: pre-wrap; word-wrap: break-word; font-size: 13px; }
-    .turn.user      { background: rgba(217, 119, 87, 0.10); border: 1px solid rgba(217, 119, 87, 0.25); }
+    .turn.user      { background: rgba(217, 179, 90, 0.10); border: 1px solid rgba(217, 179, 90, 0.25); }
     .turn.assistant { background: rgba(74, 222, 128, 0.06); border: 1px solid rgba(74, 222, 128, 0.18); }
     .turn.system    { background: rgba(245, 158, 11, 0.06); border: 1px solid rgba(245, 158, 11, 0.20); }
     .turn .role-tag { display: block; color: var(--dim); font-size: 10px; text-transform: uppercase; letter-spacing: 0.05em; margin-bottom: 4px; }