lazyclaw 6.0.1 → 6.2.0

package/commands/gateway.mjs

@@ -0,0 +1,194 @@
+// commands/gateway.mjs — `lazyclaw gateway`: the single-process always-on
+// agent (Phase 5, "approach B").
+//
+// One process owns everything: it starts the HTTP daemon in-process (the
+// session-bearing core) AND the configured channel transports (Slack Socket
+// Mode / Telegram long-poll / Matrix /sync), feeding every inbound through
+// the same POST /inbound the standalone listeners use — so the bridge
+// contract, pairing gate, dedup, cost cap, and learning hook are identical.
+// Because the channels live in-process, each registers a live sender into
+// ctx.channelSenders, which finally gives POST /handoff a notifier: the
+// target channel receives a resume marker and a failed notify rolls the
+// binding back (channels/handoff.mjs). `slack|telegram|matrix listen` remain
+// supported as standalone single-channel forwarders.
+import path from 'node:path';
+import fs from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { configPath, readConfig, writeConfig, readVersionFromRepo } from '../lib/config.mjs';
+import { ensureRegistry } from '../lib/registry_boot.mjs';
+import { loadDotenvIfAny } from '../dotenv_min.mjs';
+import { assertUnattendedSafe, installCrashHandlers } from '../lib/gateway_guard.mjs';
+import { makeInboundHandler } from '../lib/inbound_client.mjs';
+
+export const GATEWAY_CHANNELS = ['slack', 'telegram', 'matrix'];
+
+// Default per-channel constructors. Each receives { handler, logger,
+// allowlist }, must return a started channel exposing send()/stop().
+// Injectable so tests can run the full gateway with stub transports.
+const DEFAULT_FACTORIES = {
+  async slack({ handler, logger }) {
+    const { SlackChannel } = await import('../channels/slack.mjs');
+    const ch = new SlackChannel();
+    await ch.start(handler);
+    await ch._connectSocketMode({ logger });
+    return ch;
+  },
+  async telegram({ handler, logger, allowlist }) {
+    const { TelegramChannel } = await import('../channels/telegram.mjs');
+    const ch = new TelegramChannel({ allowlist });
+    await ch.start(handler, { poll: true, logger });
+    return ch;
+  },
+  async matrix({ handler, logger, allowlist }) {
+    const { MatrixChannel } = await import('../channels/matrix.mjs');
+    const ch = new MatrixChannel({ allowlist });
+    await ch.start(handler, { poll: true, logger });
+    return ch;
+  },
+};
+
+// Which channels should the gateway run? --channels a,b wins; otherwise the
+// enabled cfg.channels sections that we have a built-in transport for.
+export function _selectChannels(cfg, flags = {}) {
+  if (flags.channels) {
+    return String(flags.channels).split(',').map((s) => s.trim().toLowerCase()).filter(Boolean)
+      .filter((n) => GATEWAY_CHANNELS.includes(n));
+  }
+  const configured = (cfg.channels && typeof cfg.channels === 'object') ? cfg.channels : {};
+  return GATEWAY_CHANNELS.filter((n) => configured[n] && configured[n].enabled !== false);
+}
+
+// The whole gateway, with injectable deps so tests can drive it end-to-end
+// (stub transports, ephemeral port) without Slack/Telegram/Matrix creds.
+// Throws GatewayGuardError on an unsafe config. Returns { port, channels,
+// channelSenders, skipped, stop }.
+export async function runGateway(flags = {}, deps = {}) {
+  await ensureRegistry();
+  const log = deps.log || ((s) => process.stderr.write(s));
+  const cfg = deps.readConfig ? deps.readConfig() : readConfig();
+  assertUnattendedSafe(cfg, { surface: 'gateway' });
+  const cfgDir = path.dirname(configPath());
+  loadDotenvIfAny(cfgDir);
+
+  // The gateway is session-bearing AND sits on a well-known always-on port,
+  // so unlike the ad-hoc daemon it does not run unauthenticated by default:
+  // resolve --auth-token > env > the persisted gateway.token, else mint one
+  // and persist it 0600 (so `service install gateway` restarts keep the same
+  // token and the operator can read it from the file — it is never logged).
+  // --no-auth opts back into the historical open-loopback posture.
+  let authToken = flags['auth-token'] || process.env.LAZYCLAW_AUTH_TOKEN || null;
+  const tokenFile = path.join(cfgDir, 'gateway.token');
+  if (!authToken && !flags['no-auth']) {
+    try { authToken = fs.readFileSync(tokenFile, 'utf8').trim() || null; } catch { /* not minted yet */ }
+    if (!authToken) {
+      authToken = randomBytes(24).toString('hex');
+      fs.writeFileSync(tokenFile, authToken + '\n', { mode: 0o600 });
+    }
+    log(`[gateway] auth token active (read it from ${tokenFile}; external callers need Authorization: Bearer)\n`);
+  }
+  if (!authToken) log('[gateway] warning: --no-auth — any local process can drive the agent on this port.\n');
+  const allowlistArr = (cfg.pairing || []).map((p) => String(p.id));
+  if (allowlistArr.length === 0) {
+    log('[gateway] warning: pairing allowlist is empty — the agent will answer ANYONE who can reach a connected channel. Pair senders with `lazyclaw pairing add <id>`.\n');
+  }
+
+  // Live sender map: channels register here as they come up; the daemon's
+  // handoff route reads it per-request (live Map, registrations visible).
+  const channelSenders = new Map();
+
+  const sessionsMod = await import('../sessions.mjs');
+  const { startDaemon } = await import('../daemon.mjs');
+  const startDaemonImpl = deps.startDaemonImpl || startDaemon;
+  const d = await startDaemonImpl({
+    port: flags.port !== undefined ? parseInt(flags.port, 10) : 19600,
+    once: false,
+    readConfig,
+    writeConfig: authToken ? writeConfig : undefined,
+    sessionsDirGetter: () => cfgDir,
+    sessionsMod,
+    version: () => readVersionFromRepo(),
+    authToken: authToken || undefined,
+    allowedOrigins: [],
+    logger: deps.logger || null,
+    channelSenders,
+  });
+  log(`[gateway] daemon core on http://127.0.0.1:${d.port}\n`);
+
+  const daemonUrl = `http://127.0.0.1:${d.port}`;
+  const factories = { ...DEFAULT_FACTORIES, ...(deps.channelFactories || {}) };
+  const wanted = _selectChannels(cfg, flags);
+  if (wanted.length === 0) {
+    log('[gateway] no channels configured/enabled — running the daemon core only. Add one with `lazyclaw setup` or pass --channels slack,telegram,matrix.\n');
+  }
+
+  const channels = [];
+  const skipped = [];
+  for (const name of wanted) {
+    const handler = makeInboundHandler({
+      channel: name, daemonUrl, daemonToken: authToken,
+      provider: flags.provider, model: flags.model,
+    });
+    try {
+      const ch = await factories[name]({
+        handler,
+        logger: (line) => log(line),
+        allowlist: allowlistArr.length ? allowlistArr : null,
+      });
+      channels.push({ name, ch });
+      channelSenders.set(name, (externalId, text) => ch.send(externalId, text));
+      log(`[gateway] ${name}: connected\n`);
+    } catch (err) {
+      // One channel missing creds must not take down the others.
+      skipped.push({ name, error: err?.message || String(err) });
+      log(`[gateway] ${name}: skipped (${err?.message || err})\n`);
+    }
+  }
+
+  const stop = async () => {
+    for (const { name, ch } of channels) {
+      try { await ch.stop(); } catch { /* best-effort drain */ }
+      channelSenders.delete(name);
+    }
+    // A wedged in-flight request must not hang shutdown forever — the crash
+    // handler awaits stop() before exiting, and a hang there would leave a
+    // crashed gateway alive-but-dead with no service-manager restart.
+    await Promise.race([
+      d.close(),
+      new Promise((r) => setTimeout(r, 8_000)),
+    ]);
+  };
+
+  return { port: d.port, channels, channelSenders, skipped, stop, authToken };
+}
+
+export async function cmdGateway(flags = {}) {
+  let gw;
+  try {
+    gw = await runGateway(flags);
+  } catch (err) {
+    console.error(`gateway: ${err?.message || err}`);
+    process.exit(2);
+  }
+  process.stdout.write(JSON.stringify({
+    ok: true,
+    url: `http://127.0.0.1:${gw.port}`,
+    port: gw.port,
+    channels: gw.channels.map((c) => c.name),
+    skipped: gw.skipped,
+  }) + '\n');
+  process.stderr.write('[gateway] running. Ctrl-C to stop.\n');
+
+  installCrashHandlers({ label: 'gateway', stop: () => gw.stop() });
+  await new Promise((resolve) => {
+    let shuttingDown = false;
+    const onSig = async () => {
+      if (shuttingDown) return process.exit(1);
+      shuttingDown = true;
+      process.stderr.write('\n[gateway] shutting down…\n');
+      try { await gw.stop(); } catch { /* best-effort */ }
+      resolve();
+    };
+    process.once('SIGINT', onSig);
+    process.once('SIGTERM', onSig);
+  });
+}

package/commands/providers.mjs

@@ -3,6 +3,7 @@
 import { readConfig, writeConfig } from '../lib/config.mjs';
 import { ensureRegistry, getRegistry } from '../lib/registry_boot.mjs';
 import { _fetchModelsForProvider } from '../tui/pickers.mjs';
+import { probeProvider } from '../providers/probe.mjs';
 
 export async function cmdRates(sub, positional, flags = {}) {
   // Manage cfg.rates without hand-editing JSON. Same shape as
@@ -234,47 +235,15 @@ export async function cmdProviders(sub, positional, flags = {}) {
       }
       // cfg already declared above for the all-mode branch; reuse it.
       const meta = getRegistry().PROVIDER_INFO[name] || {};
-      // --model / --prompt come in via the parsed flags map (parseArgs
-      // lifted them out of positional). --model wins over config.model
-      // wins over PROVIDER_INFO.defaultModel.
+      // --model wins over config.model wins over PROVIDER_INFO.defaultModel.
       const model = flags.model || cfg.model || meta.defaultModel || 'unknown';
       const prompt = flags.prompt || 'ping';
       const apiKey = cfg['api-key'] || '';
-      const t0 = Date.now();
-      try {
-        // Drain the streaming response (every provider yields chunks of
-        // string). For mock this is instant; for real providers it's
-        // bounded by the prompt length and provider latency. We don't
-        // support a timeout flag here — the user can SIGINT if a
-        // provider hangs.
-        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;
-        console.log(JSON.stringify({
-          ok,
-          provider: name,
-          model,
-          durationMs,
-          replyLength: reply.length,
-          reply: reply.slice(0, 200) + (reply.length > 200 ? '…' : ''),
-        }, null, 2));
-        process.exit(ok ? 0 : 1);
-      } catch (err) {
-        const durationMs = Date.now() - t0;
-        console.log(JSON.stringify({
-          ok: false,
-          provider: name,
-          model,
-          durationMs,
-          error: err?.message || String(err),
-          code: err?.code || null,
-        }, null, 2));
-        process.exit(1);
-      }
+      // Shared, no-exit probe (providers/probe.mjs). The CLI prints JSON and
+      // exits; the setup wizard renders one line and keeps going.
+      const result = await probeProvider({ name, model, prompt, apiKey });
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(result.ok ? 0 : 1);
     }
     case 'add': {
       // Register an OpenAI-compatible custom endpoint non-interactively.
@@ -437,6 +406,16 @@ export async function cmdOrchestrator(sub, positional, _flags = {}) {
       }, null, 2));
       return;
     }
+    case 'on':
+    case 'off': {
+      // Route cfg.provider to/from 'orchestrator' (shared with /orchestrator).
+      const cf = await import('../config_features.mjs');
+      cf.orchestratorEnable(cfg, sub === 'on');
+      writeConfig(cfg);
+      const w = Array.isArray(orch.workers) ? orch.workers.length : 0;
+      console.log(JSON.stringify({ ok: true, enabled: sub === 'on', provider: cfg.provider, ...(sub === 'on' && w === 0 ? { warning: 'no workers configured — add one: lazyclaw orchestrator workers add <provider[:model]>' } : {}) }, null, 2));
+      return;
+    }
     case 'set-planner': {
       try {
         const spec = validateSpec(positional[0]);

package/commands/service.mjs

@@ -0,0 +1,113 @@
+// commands/service.mjs — `lazyclaw service <install|uninstall|status|restart>`.
+// Wraps a lazyclaw long-running command as an always-on OS service via
+// lib/service_install.mjs (launchd / systemd / detached-fallback).
+//
+// v1 manages the DAEMON — the single always-on agent core. Once the channel
+// listeners forward into the daemon's /inbound (next phase), the daemon is
+// the one process that has to stay up; channel surfaces graduate to their own
+// service targets in a later phase.
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+import { configPath, readConfig } from '../lib/config.mjs';
+import { assertUnattendedSafe, assertServicePairing } from '../lib/gateway_guard.mjs';
+import { detectBackend, installService, uninstallService, serviceStatus } from '../lib/service_install.mjs';
+
+const SUPPORTED_SURFACES = new Set(['daemon', 'gateway']);
+
+function hasSystemctl() {
+  try {
+    const r = spawnSync('systemctl', ['--version'], { stdio: 'ignore' });
+    return !r.error && r.status === 0;
+  } catch { return false; }
+}
+
+function cliPath() {
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'cli.mjs');
+}
+
+// Exported for tests: builds the service spec (wrapped argv + backend) without
+// any side effects.
+export function _buildSpec(surface, flags = {}, cfgDir = '', deps = {}) {
+  const hasSystemd = typeof deps.hasSystemctl === 'function' ? deps.hasSystemctl() : hasSystemctl();
+  const args = [deps.cliPath ? deps.cliPath() : cliPath(), surface];
+  // Default the service to the well-known port the channel listeners dial
+  // (the LAZYCLAW_DAEMON_URL default), so `service install` + `* listen`
+  // work together out of the box. Bare `lazyclaw daemon` still defaults to a
+  // random port for ad-hoc / scripted use.
+  args.push('--port', flags.port !== undefined ? String(flags.port) : '19600');
+  if (flags['auth-token']) args.push('--auth-token', String(flags['auth-token']));
+  if (flags.log) args.push('--log', String(flags.log));
+  if (flags.channels) args.push('--channels', String(flags.channels));
+  return {
+    name: surface,
+    surface,
+    execPath: process.execPath,
+    args,
+    workingDir: deps.cwd || process.cwd(),
+    configDir: cfgDir,
+    description: `lazyclaw always-on ${surface}`,
+    env: { LAZYCLAW_CONFIG_DIR: cfgDir },
+    backend: detectBackend({ override: flags.backend || null, hasSystemctl: hasSystemd }),
+  };
+}
+
+export async function cmdService(sub, positional = [], flags = {}) {
+  const surface = (positional[0] || 'daemon').toLowerCase();
+  if (!SUPPORTED_SURFACES.has(surface)) {
+    console.error(`service: only '${[...SUPPORTED_SURFACES].join("', '")}' is supported in this version (channel gateway lands in a later phase). Got: ${surface}`);
+    process.exit(2);
+  }
+  const cfg = readConfig();
+  const cfgDir = path.dirname(configPath());
+
+  // Fail closed before installing: never wrap a remote surface as a service
+  // while the global unattended-sensitive tool override is on (RCE). Channel
+  // surfaces additionally require a non-empty pairing allowlist.
+  try {
+    assertUnattendedSafe(cfg, { surface });
+    if (surface !== 'daemon') assertServicePairing(cfg, { service: true, surface });
+  } catch (e) { console.error(e.message); process.exit(2); }
+
+  const spec = _buildSpec(surface, flags, cfgDir);
+  const emit = (obj) => process.stdout.write(JSON.stringify(obj) + '\n');
+
+  try {
+    if (sub === 'install') {
+      const r = installService(spec);
+      emit({ ok: true, action: 'install', ...r });
+      if (r.backend === 'fallback') {
+        process.stderr.write('note: no service manager detected — running detached with a pidfile. This survives the terminal but NOT a reboot. Re-run `lazyclaw service install` after reboot, or install launchd/systemd.\n');
+        // The detached child's fate is invisible (stdio ignored), so verify it
+        // actually stayed up — a daemon that hit EADDRINUSE (port already in
+        // use) exits within ~200ms. Surface that instead of a false "ok".
+        await new Promise((s) => setTimeout(s, 800));
+        const st = serviceStatus(spec);
+        if (!st.running) {
+          const port = flags.port !== undefined ? String(flags.port) : '19600';
+          process.stderr.write(`warning: the daemon did not stay up — port ${port} may already be in use (a daemon is already running?). Check: lsof -ti tcp:${port}. Free it or pass --port, then re-run.\n`);
+        }
+      }
+      return;
+    }
+    if (sub === 'uninstall' || sub === 'remove') {
+      emit({ ok: true, action: 'uninstall', ...uninstallService(spec) });
+      return;
+    }
+    if (sub === 'status') {
+      emit({ ok: true, action: 'status', ...serviceStatus(spec) });
+      return;
+    }
+    if (sub === 'restart') {
+      try { uninstallService(spec); } catch { /* not installed yet */ }
+      emit({ ok: true, action: 'restart', ...installService(spec) });
+      return;
+    }
+  } catch (e) {
+    console.error(`service: ${e.message}`);
+    process.exit(2);
+  }
+
+  console.error('Usage: lazyclaw service <install|uninstall|status|restart> [daemon|gateway] [--port N] [--auth-token T] [--log LEVEL] [--channels a,b] [--backend launchd|systemd|fallback]');
+  process.exit(2);
+}

package/commands/setup.mjs

@@ -22,6 +22,8 @@ import { applyChatWindow as _applyChatWindow, CHAT_WINDOW_TURNS, CHAT_WINDOW_TOK
 import { makeRunTurn as _chatRunTurnFactory } from '../tui/run_turn.mjs';
 import { dispatchSlash as _dispatchSlash, parseSlashLine as _parseSlashLine } from '../tui/slash_dispatcher.mjs';
 import { SLASH_COMMANDS } from '../tui/slash_commands.mjs';
+import { runChannelStep, runWebhookStep, runOrchestratorStep, runContextStep } from './setup_channels.mjs';
+import { splashPropsForSetup, renderSplashToString } from '../tui/splash_props.mjs';
 
 function applyOnboardConfig(currentCfg, flags) {
   // Honors the OpenClaw-style unified provider/model string ("anthropic/claude-opus-4-7")
@@ -60,7 +62,7 @@ export async function cmdOnboard(flags) {
     const ask = q => new Promise(resolve => rl.question(q, resolve));
     if (!flags.provider) {
       const provs = Object.keys(getRegistry().PROVIDERS).join('|');
-      const noKeyHint = '\x1b[38;5;208mclaude-cli\x1b[0m (subscription, no key) is the default';
+      const noKeyHint = '\x1b[38;2;217;179;90mclaude-cli\x1b[0m (subscription, no key) is the default';
       process.stdout.write(`hint: ${noKeyHint}\n`);
       flags.provider = (await ask(`provider [${provs}]: `)).trim() || 'claude-cli';
     }
@@ -117,7 +119,7 @@ const HELP_SUMMARIES = {
   workspace:  'AGENTS.md / SOUL.md / TOOLS.md system-prompt convention (workspace list|init|show|remove|path)',
   browse:     'Fetch a URL and emit Markdown on stdout (browse <url> [--max-bytes <N>])',
   cron:       'Schedule recurring agent runs via launchd / crontab (cron list|add|remove|show|sync|run)',
-  setup:      'OpenClaw-style multi-step first-run wizard (provider + workspace + skill + webhook + ping)',
+  setup:      'Hermes-style phased first-run wizard (provider + verify chat + channel + workspace + skill + webhook)',
   dashboard:  'Launch the lazyclaw-only web UI (lighter than the full lazyclaude dashboard)',
   inspect:    'Print persisted workflow state without executing',
   clear:      'Delete a persisted workflow state file (idempotent)',
@@ -158,7 +160,7 @@ const HELP_DETAILS = {
   workspace: 'Usage: lazyclaw workspace <list | init <name> | show <name> [<file>] | remove <name> | path <name>>\n  Workspace = a directory under <configDir>/workspaces/<name>/ containing AGENTS.md, SOUL.md, TOOLS.md.\n  When `chat` or `agent` is invoked with --workspace <name>, the three files are stitched into a single system prompt at the head of the conversation. Missing files are skipped silently.\n  init scaffolds the three files with short stubs you replace.\n  show prints the composed prompt; show <name> AGENTS.md (etc) prints just one file.',
   browse: 'Usage: lazyclaw browse <url> [--max-bytes <N>] [--timeout-ms <N>] [--user-agent <ua>] [--meta]\n  Fetches the URL and emits Markdown on stdout. Pipes cleanly into `agent`:\n      lazyclaw browse https://example.com/docs | lazyclaw agent -\n  Strips <script>/<style>/<svg>/comments, prefers <main>/<article>, falls back to <body>.\n  --max-bytes caps the body read (default 2 MB) so a misconfigured upstream can\'t OOM the process.\n  --meta prints { url, title, bytes, truncated } as JSON to stderr alongside the markdown on stdout.',
   cron: 'Usage: lazyclaw cron <list | add <name> "<cron-spec>" -- <cmd> ... | remove <name> | show <name> | sync | run <name>>\n  Schedule recurring agent runs. macOS uses launchd (~/Library/LaunchAgents/com.lazyclaw.<name>.plist); Linux / WSL uses the user crontab.\n  Cron spec is the standard 5-field form (minute hour dom month dow). Supports *, range a-b, list a,b,c, step */N.\n  add: pass the command after `--`. Typical use:\n      lazyclaw cron add daily-summary "0 9 * * 1-5" -- lazyclaw agent "Summarise today\'s TODOs"\n  list / show: read from cfg.cron[name] (config is the source of truth).\n  sync: re-installs every job in cfg.cron into the system scheduler — handy after a reinstall.\n  run: one-shot in-process execution of the named job; the OS scheduler does the same thing on its trigger.\n  Logs: ~/.lazyclaw/logs/cron-<name>.{out,err}.log (macOS launchd path).',
-  setup: 'Usage: lazyclaw setup [--skip-test]\n  OpenClaw-style multi-step first-run wizard. Walks through:\n    1. Provider + model + api-key (delegates to onboard --pick)\n    2. Optional workspace init  (AGENTS.md / SOUL.md / TOOLS.md)\n    3. Optional skill bundle install from GitHub\n    4. Optional outbound webhook (Slack / Discord)\n    5. Reachability test against the picked provider\n  Each optional step takes Enter or "skip" to bypass. Re-runnable safely.\n  Also fires automatically on first run when `lazyclaw` is invoked with no config.',
+  setup: 'Usage: lazyclaw setup [--skip-test]\n  Hermes-style phased first-run wizard — get one clean chat working first,\n  then optionally add the rest. Walks through:\n    1. Provider + model + api-key (delegates to onboard --pick; ≥64k-context tip)\n    2. Verify the provider responds (1-token ping; --skip-test bypasses)\n    3. Optional channel / gateway (Slack / Telegram / Matrix / HTTP built in;\n       Discord / Email / Signal / Voice / WhatsApp via plugin packages)\n    4. Optional workspace init  (AGENTS.md / SOUL.md / TOOLS.md)\n    5. Optional skill bundle install from GitHub\n    6. Optional outbound webhook (Slack / Discord)\n    7. Optional multi-agent orchestration (planner + workers)\n  Each optional step takes Enter or "skip" to bypass. Re-runnable safely.\n  Also fires automatically on first run when `lazyclaw` is invoked with no config.',
   dashboard: 'Usage: lazyclaw dashboard [--port <N>] [--no-open]\n  Launches the lazyclaw-only web UI on http://127.0.0.1:<port> (default 19600) and opens it in the default browser.\n  Wraps `lazyclaw daemon` + a static HTML; no Python / lazyclaude dashboard required.\n  See web/dashboard.html for the current tab set (v5: Chat / Sessions / Workflows / Skills / Providers / Rates / Metrics / Doctor / Config / Status / Agents / Teams / Tasks / Trainer / Recall / Sandbox / Channels).\n  --no-open keeps the browser closed (handy for SSH / headless / dev). The bound URL is always printed to stdout.',
   orchestrator: 'Usage: lazyclaw orchestrator <status | set-planner <provider[:model]> | workers add <spec> | workers remove <spec> | workers set <spec,spec,...> | workers clear | set-max-subtasks <N> | clear>\n  Read/write cfg.orchestrator without editing config.json by hand.\n  status               — print {planner, workers, maxSubtasks} as JSON; lists registered providers for reference.\n  set-planner          — replace the planner spec ("provider" or "provider:model"). "orchestrator" itself is rejected (self-recursion).\n  workers add          — append a worker (idempotent — duplicates skipped).\n  workers remove       — drop a worker by exact match. Idempotent.\n  workers set          — replace the whole list (comma-separated specs).\n  workers clear        — empty the workers list.\n  set-max-subtasks <N> — cap subtasks per request, clamped 1..10 (default 5).\n  clear                — delete the cfg.orchestrator block entirely.\n  Pair with: `lazyclaw config set provider orchestrator` to route chats through it.',
 };
@@ -187,7 +189,7 @@ export function cmdHelp(name) {
 
 export async function cmdSetup(_sub, _positional, flags = {}) {
   await ensureRegistry();
-  const accent = (s) => `\x1b[38;5;208m${s}\x1b[0m`;
+  const accent = (s) => `\x1b[38;2;217;179;90m${s}\x1b[0m`;
   const bold   = (s) => `\x1b[1m${s}\x1b[0m`;
   const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
   const ok     = (s) => `\x1b[32m${s}\x1b[0m`;
@@ -195,17 +197,18 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
 
   // Header.
   if (process.stdout.isTTY) process.stdout.write('\x1b[2J\x1b[H');
-  _renderBanner(readVersionFromRepo()).forEach((l) => process.stdout.write(l + '\n'));
+  process.stdout.write(renderSplashToString(await splashPropsForSetup({ version: readVersionFromRepo() })) + '\n');
   process.stdout.write('\n');
   process.stdout.write(`  ${bold('🔧 Setup wizard')}\n`);
-  process.stdout.write(`  ${dim('Five short steps. Press Enter to accept the default; type "skip" or "n" to bypass an optional step.')}\n\n`);
+  process.stdout.write(`  ${dim('Get one clean chat working first, then optionally add a channel, workspace, or skills. Press Enter to accept the default; type "skip" or "n" to bypass an optional step.')}\n\n`);
 
   const cfg = readConfig();
   const cfgDir = path.dirname(configPath());
+  const colors = { accent, bold, dim, ok, warn };
 
-  // ── Step 1: Provider + model (mandatory) ────────────────────
-  process.stdout.write(`  ${accent('Step 1/5 ·')} ${bold('Pick a provider + model')}\n`);
-  process.stdout.write(`  ${dim('Opens the arrow-key picker. The list leads with gemini / openai / claude-cli — pick the one you have an account or login for.')}\n\n`);
+  // ── Step 1/7: Provider + model (mandatory) ──────────────────
+  process.stdout.write(`  ${accent('Step 1/7 ·')} ${bold('Pick a provider + model')}\n`);
+  process.stdout.write(`  ${dim('Opens the arrow-key picker. Tip: pick a model with ≥64k context — small windows can\'t hold multi-step tool-calling state.')}\n\n`);
   await _quickPrompt('  ▶ press Enter to open the picker ');
   try {
     await cmdOnboard({ pick: true });
@@ -230,8 +233,38 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
   }
   process.stdout.write(`\n  ${ok('✓ provider:')} ${cfgAfterOnboard.provider}  ${dim('model:')} ${cfgAfterOnboard.model || '(default)'}\n\n`);
 
-  // ── Step 2: Optional workspace ──────────────────────────────
-  process.stdout.write(`  ${accent('Step 2/5 ·')} ${bold('Initialise a workspace?')} ${dim('(optional)')}\n`);
+  // Context window — asked right after the model pick (optional; Enter keeps
+  // defaults). Not a numbered step: it's part of the core model setup.
+  await runContextStep({ prompt: _quickPrompt, colors });
+
+  // ── Step 2/7: Verify one clean chat works ───────────────────
+  // Hermes rule: get a clean reply before layering on channels/skills.
+  process.stdout.write(`  ${accent('Step 2/7 ·')} ${bold('Verify the provider responds')}\n`);
+  process.stdout.write(`  ${dim('Sends a 1-token "ping" via `lazyclaw providers test`. Confirm a clean reply before layering on channels/skills.')}\n\n`);
+  const wantPing = !flags['skip-test'] && (await _quickPrompt('  test now? [Y/n] ')).trim().toLowerCase() !== 'n';
+  if (wantPing) {
+    try {
+      // No-exit probe (providers/probe.mjs) — the CLI `providers test` calls
+      // process.exit, which would kill the rest of this wizard. Render one
+      // concise line instead of the full JSON dump and keep going.
+      const { probeProvider } = await import('../providers/probe.mjs');
+      const r = await probeProvider({ name: cfgAfterOnboard.provider, model: cfgAfterOnboard.model || undefined });
+      if (r.ok) process.stdout.write(`  ${ok('✓ ' + (r.reply || 'ok'))}  ${dim(`· ${r.model || cfgAfterOnboard.provider} · ${r.durationMs}ms`)}\n`);
+      else process.stdout.write(`  ${warn('✗ ' + (r.error || 'no reply'))}  ${dim(`· retry: lazyclaw providers test ${cfgAfterOnboard.provider}`)}\n`);
+    } catch (e) {
+      process.stdout.write(`  ${warn('test errored:')} ${e?.message || e}\n`);
+    }
+    process.stdout.write('\n');
+  } else {
+    process.stdout.write(`  ${dim('— skipped —')}\n\n`);
+  }
+
+  // ── Step 3/7: Channel / gateway (optional) ──────────────────
+  process.stdout.write(`  ${accent('Step 3/7 ·')} ${bold('Where will you run it?')} ${dim('(optional)')}\n`);
+  await runChannelStep({ cfgDir, prompt: _quickPrompt, colors });
+
+  // ── Step 4/7: Optional workspace ────────────────────────────
+  process.stdout.write(`  ${accent('Step 4/7 ·')} ${bold('Initialise a workspace?')} ${dim('(optional)')}\n`);
   process.stdout.write(`  ${dim('A workspace is a folder of AGENTS.md / SOUL.md / TOOLS.md prompt files that auto-inject into chat / agent. Skip if you don\'t need project-specific personas yet.')}\n\n`);
   const wsName = (await _quickPrompt('  workspace name (Enter to skip): ')).trim();
   if (wsName && /^[A-Za-z0-9_.-]+$/.test(wsName)) {
@@ -249,8 +282,8 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
     process.stdout.write(`  ${dim('— skipped —')}\n\n`);
   }
 
-  // ── Step 3: Optional skill bundle install ───────────────────
-  process.stdout.write(`  ${accent('Step 3/5 ·')} ${bold('Install a skill bundle from GitHub?')} ${dim('(optional)')}\n`);
+  // ── Step 5/7: Optional skill bundle install ─────────────────
+  process.stdout.write(`  ${accent('Step 5/7 ·')} ${bold('Install a skill bundle from GitHub?')} ${dim('(optional)')}\n`);
   process.stdout.write(`  ${dim('Format: <user>/<repo>[@<ref>]. Skills are .md prompt fragments that compose into the system prompt via --skill.')}\n\n`);
   const skillSpec = (await _quickPrompt('  github spec (Enter to skip): ')).trim();
   if (skillSpec) {
@@ -270,45 +303,13 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
     process.stdout.write(`  ${dim('— skipped —')}\n\n`);
   }
 
-  // ── Step 4: Optional outbound webhook ───────────────────────
-  process.stdout.write(`  ${accent('Step 4/5 ·')} ${bold('Add an outbound webhook?')} ${dim('(optional)')}\n`);
-  process.stdout.write(`  ${dim('Use with: lazyclaw message send <name> <text>. Slack / Discord Incoming Webhook URLs work as-is.')}\n\n`);
-  const hookName = (await _quickPrompt('  webhook name (Enter to skip): ')).trim();
-  if (hookName) {
-    const hookUrl = (await _quickPrompt('  webhook URL: ')).trim();
-    if (!hookUrl) {
-      process.stdout.write(`  ${warn('skipped:')} URL required\n\n`);
-    } else {
-      try {
-        const cf = await import('../config_features.mjs');
-        const fresh = readConfig();
-        cf.messageAdd(fresh, hookName, hookUrl);
-        writeConfig(fresh);
-        process.stdout.write(`  ${ok('✓ webhook saved:')} ${hookName}\n\n`);
-      } catch (e) {
-        process.stdout.write(`  ${warn('skipped:')} ${e?.message || e}\n\n`);
-      }
-    }
-  } else {
-    process.stdout.write(`  ${dim('— skipped —')}\n\n`);
-  }
+  // ── Step 6/7: Optional outbound webhook ─────────────────────
+  process.stdout.write(`  ${accent('Step 6/7 ·')} ${bold('Add an outbound webhook?')} ${dim('(optional)')}\n`);
+  await runWebhookStep({ prompt: _quickPrompt, colors });
 
-  // ── Step 5: Reachability check ──────────────────────────────
-  process.stdout.write(`  ${accent('Step 5/5 ·')} ${bold('Verify the picked provider responds')}\n`);
-  process.stdout.write(`  ${dim('Sends a 1-token "ping" via `lazyclaw providers test`. Confirms your key / subscription / local daemon is wired up.')}\n\n`);
-  const wantPing = !flags['skip-test'] && (await _quickPrompt('  test now? [Y/n] ')).trim().toLowerCase() !== 'n';
-  if (wantPing) {
-    try {
-      // Reuse the existing providers-test path so behaviour matches
-      // a manual `lazyclaw providers test`.
-      await (await import('../commands/providers.mjs')).cmdProviders('test', [cfgAfterOnboard.provider], {});
-    } catch (e) {
-      process.stdout.write(`  ${warn('test errored:')} ${e?.message || e}\n`);
-      process.stdout.write(`  ${dim('Setup still completed; you can retry with:')} lazyclaw providers test ${cfgAfterOnboard.provider}\n`);
-    }
-  } else {
-    process.stdout.write(`  ${dim('— skipped —')}\n`);
-  }
+  // ── Step 7/7: Optional multi-agent orchestration ────────────
+  process.stdout.write(`  ${accent('Step 7/7 ·')} ${bold('Enable multi-agent orchestration?')} ${dim('(optional)')}\n`);
+  await runOrchestratorStep({ prompt: _quickPrompt, colors });
 
   // ── Wrap up ─────────────────────────────────────────────────
   process.stdout.write('\n');
@@ -327,11 +328,11 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
 // exits politely instead of dropping into a menu where every option
 // would error.
 async function _runFirstTimeOnboard() {
-  const accent = (s) => `\x1b[38;5;208m${s}\x1b[0m`;
+  const accent = (s) => `\x1b[38;2;217;179;90m${s}\x1b[0m`;
   const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
   const bold   = (s) => `\x1b[1m${s}\x1b[0m`;
   process.stdout.write('\x1b[2J\x1b[H');
-  _renderBanner(readVersionFromRepo()).forEach((l) => process.stdout.write(l + '\n'));
+  process.stdout.write(renderSplashToString(await splashPropsForSetup({ version: readVersionFromRepo() })) + '\n');
   process.stdout.write('\n');
   process.stdout.write(`  ${bold('👋 Welcome — first-time setup')}\n\n`);
   process.stdout.write(`  ${dim('No provider configured yet at')} ${configPath()}\n`);
@@ -513,7 +514,7 @@ export async function cmdLauncher() {
     { id: 'quit',         label: 'Quit',         desc: 'exit lazyclaw',                                 argv: null },
   ];
 
-  const accent = (s) => `\x1b[38;5;208m${s}\x1b[0m`;
+  const accent = (s) => `\x1b[38;2;217;179;90m${s}\x1b[0m`;
   const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
   const bold   = (s) => `\x1b[1m${s}\x1b[0m`;
   const ok     = (s) => `\x1b[32m${s}\x1b[0m`;