lazyclaw 6.3.1 → 6.4.0

package/commands/mcp.mjs

@@ -0,0 +1,150 @@
+// commands/mcp.mjs — `lazyclaw mcp <list|add|remove|call>`.
+//
+// MCP servers are stored in cfg.mcp.servers[] (stdio transport only; an entry
+// is { name, command, args[], env{}, allowGlob }). They are spawned at daemon
+// boot by mcp/server_spawn.startConfigured. This command manages that list and
+// lets you invoke a single tool from the CLI for a quick check.
+//
+// Verb dispatch + output convention mirror commands/agents.mjs cmdTeam:
+// success → JSON on stdout, usage/validation errors → console.error + exit 2,
+// operational failures → exit 1.
+
+import { readConfig, writeConfig } from '../lib/config.mjs';
+
+// The name becomes the tool namespace `mcp:<name>:<tool>`, so it must not carry
+// a colon or whitespace — reuse the cron/job name grammar.
+const NAME_RE = /^[A-Za-z0-9_.-]+$/;
+
+const emitJson = (o) => process.stdout.write(JSON.stringify(o, null, 2) + '\n');
+
+// `--args "-y pkg /tmp"` and `--env "K=V K2=V2"` arrive as one whitespace-
+// joined string (parseArgs consumes a single argv token), so split on spaces.
+function splitWords(raw) {
+  if (raw === undefined || raw === null || raw === true) return [];
+  return String(raw).split(/\s+/).filter(Boolean);
+}
+function parseEnv(raw) {
+  const env = {};
+  for (const pair of splitWords(raw)) {
+    const i = pair.indexOf('=');
+    if (i > 0) env[pair.slice(0, i)] = pair.slice(i + 1);
+  }
+  return env;
+}
+
+export async function cmdMcp(sub, positional = [], flags = {}) {
+  const cfg = readConfig();
+  const servers = (cfg.mcp && Array.isArray(cfg.mcp.servers)) ? cfg.mcp.servers : [];
+
+  switch (sub) {
+    case undefined:
+    case 'list': {
+      const configured = servers.map((s) => ({
+        name: s.name, command: s.command, args: s.args || [], allowGlob: s.allowGlob || '*',
+      }));
+      // listServers() reports servers connected in THIS process; the short-lived
+      // CLI never boots them, so this is normally empty — surfaced anyway so the
+      // same shape works when the command runs inside the daemon.
+      let connected = [];
+      try { connected = (await import('../mcp/client.mjs')).listServers(); }
+      catch { /* mcp client unavailable — report configured only */ }
+      emitJson({ ok: true, configured, connected });
+      return;
+    }
+
+    case 'add': {
+      const name = positional[0];
+      const command = flags.command;
+      if (!name || !command || command === true) {
+        console.error('Usage: lazyclaw mcp add <name> --command <cmd> [--args "<a b c>"] [--allow-glob <glob>] [--env "K=V ..."]');
+        process.exit(2);
+      }
+      if (!NAME_RE.test(name)) {
+        console.error(`mcp add: invalid name "${name}" — letters/digits/.-_ only (it becomes the tool namespace mcp:${name}:<tool>)`);
+        process.exit(2);
+      }
+      if (servers.find((s) => s.name === name)) {
+        console.error(`mcp add: server "${name}" already exists — remove it first or pick another name`);
+        process.exit(2);
+      }
+      const record = {
+        name,
+        command: String(command),
+        args: splitWords(flags.args),
+        allowGlob: (flags['allow-glob'] && flags['allow-glob'] !== true) ? String(flags['allow-glob']) : '*',
+      };
+      const env = parseEnv(flags.env);
+      if (Object.keys(env).length) record.env = env;
+      cfg.mcp = cfg.mcp || {};
+      cfg.mcp.servers = servers.concat([record]);
+      writeConfig(cfg);
+      emitJson({ ok: true, added: record });
+      return;
+    }
+
+    case 'remove':
+    case 'rm':
+    case 'delete': {
+      const name = positional[0];
+      if (!name) { console.error('Usage: lazyclaw mcp remove <name>'); process.exit(2); }
+      if (!servers.find((s) => s.name === name)) {
+        console.error(`mcp remove: no configured server "${name}"`);
+        process.exit(2);
+      }
+      cfg.mcp = cfg.mcp || {};
+      cfg.mcp.servers = servers.filter((s) => s.name !== name);
+      writeConfig(cfg);
+      emitJson({ ok: true, removed: name });
+      return;
+    }
+
+    case 'call': {
+      const server = positional[0];
+      const toolName = positional[1];
+      if (!server || !toolName) {
+        console.error('Usage: lazyclaw mcp call <server> <tool> [--args-json \'{"k":"v"}\']');
+        process.exit(2);
+      }
+      const sconf = servers.find((s) => s.name === server);
+      if (!sconf) {
+        console.error(`mcp call: no configured server "${server}" — add it with 'lazyclaw mcp add ${server} --command <cmd>'`);
+        process.exit(2);
+      }
+      let args = {};
+      if (flags['args-json'] !== undefined && flags['args-json'] !== true) {
+        try { args = JSON.parse(String(flags['args-json'])); }
+        catch (e) { console.error(`mcp call: --args-json is not valid JSON: ${e.message}`); process.exit(2); }
+      }
+      const mcpClient = await import('../mcp/client.mjs');
+      const registry = await import('../mas/tools/registry.mjs');
+      let started = false;
+      try {
+        // sensitive:true — the same approval-gate invariant the daemon boot
+        // enforces (server_spawn). A CLI call can never downgrade an MCP tool.
+        await mcpClient.startServer({
+          name: sconf.name, command: sconf.command, args: sconf.args || [],
+          env: sconf.env || {}, allowGlob: sconf.allowGlob || '*', sensitive: true,
+        });
+        started = true;
+        const full = `mcp:${server}:${toolName}`;
+        const tool = registry.lookup(full);
+        if (!tool) {
+          const available = registry.listNames().filter((n) => n.startsWith(`mcp:${server}:`));
+          console.error(`mcp call: tool "${full}" not found. Available: ${available.join(', ') || '(none)'}`);
+          process.exit(1);
+        }
+        emitJson(await tool.exec(args));
+      } catch (e) {
+        console.error(`mcp call: ${e?.message || e}`);
+        process.exit(1);
+      } finally {
+        if (started) { try { await mcpClient.stopServer(server); } catch { /* best-effort */ } }
+      }
+      return;
+    }
+
+    default:
+      console.error('Usage: lazyclaw mcp <list|add|remove|call> ...');
+      process.exit(2);
+  }
+}

package/commands/misc.mjs

@@ -4,6 +4,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { configPath } from '../lib/config.mjs';
 import { resolveSandbox, listBackends } from '../sandbox/index.mjs';
+import { pickAvailableConfiner } from '../sandbox/spawn.mjs';
 
 export async function cmdBrowse(url, flags = {}) {
   if (!url) { console.error('Usage: lazyclaw browse <url> [--max-bytes <N>] [--timeout-ms <N>] [--meta]'); process.exit(2); }
@@ -33,6 +34,25 @@ export async function cmdSandbox(args, flags = {}) {
     return 0;
   }
 
+  if (sub === 'status') {
+    // Show the EFFECTIVE default-on confinement posture for this host so the
+    // operator can audit what sensitive tools run under.
+    const cfg = _sandboxLoadConfigOrEmpty();
+    const sb = cfg.sandbox || {};
+    const off = sb.confine === false || sb.default === 'off' || sb.default === 'none';
+    const confiner = (sb.local && sb.local.confiner && sb.local.confiner !== 'auto')
+      ? sb.local.confiner
+      : pickAvailableConfiner();
+    const allowNet = sb.allowNet !== false;
+    process.stdout.write(`confinement: ${off ? 'OFF' : 'ON'} (default-on; opt out with cfg.sandbox.confine=false)\n`);
+    process.stdout.write(`host confiner: ${confiner}\n`);
+    process.stdout.write(`policy: writes → workspace + temp only · secret dirs unreadable · network ${allowNet ? 'allowed' : 'denied'}\n`);
+    if (!off && confiner === 'none') {
+      process.stdout.write('note: no OS confiner available on this host — sensitive tools run UNCONFINED. Install bubblewrap or firejail on Linux.\n');
+    }
+    return 0;
+  }
+
   if (sub === 'test') {
     const name = args[1];
     if (!name) { process.stderr.write('usage: lazyclaw sandbox test <kind|profile>\n'); return 2; }

package/commands/sessions.mjs

@@ -7,6 +7,65 @@ import { ensureRegistry, getRegistry } from '../lib/registry_boot.mjs';
 
 const BUNDLE_VERSION = 1;
 
+// Key names that carry secrets. A bundle on a teammate's laptop must never
+// leak per-provider keys (cfg.authProfiles[<provider>][i].key, written by
+// providers/auth_store.mjs) or any other secret-bearing config value, not
+// just the legacy top-level cfg['api-key']. Match on the KEY name so we can
+// redact custom/nested entries without knowing the config schema ahead of
+// time, while leaving non-secret keys (baseUrl, model, label, …) untouched.
+const SECRET_KEY_RE = /(?:api[-_]?key|secret|token|password|authorization|access[-_]?key)/i;
+
+// Deep-clone cfg with every secret-bearing string value redacted. Pure — never
+// mutates the input. Preserves structure/labels so the bundle stays
+// inspectable (e.g. authProfiles keeps {label} but drops {key}).
+function redactSecrets(value, keyName = '') {
+  if (Array.isArray(value)) return value.map((v) => redactSecrets(v));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = redactSecrets(v, k);
+    return out;
+  }
+  if (typeof value === 'string' && SECRET_KEY_RE.test(keyName)) return '***REDACTED***';
+  return value;
+}
+
+// Reciprocal of the export redaction: deep-clone cfg with every
+// '***REDACTED***' placeholder dropped, so importing a redacted bundle never
+// persists the literal placeholder string into config.json. Skipping the key
+// (rather than writing it) means an existing real value survives the default
+// "bundle wins" merge, and an authProfiles entry keeps its {label} slot minus
+// the secret. Symmetric with redactSecrets / redactAuthProfileKeys above.
+const REDACTED_PLACEHOLDER = '***REDACTED***';
+function stripRedacted(value) {
+  if (Array.isArray(value)) return value.map(stripRedacted);
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (v === REDACTED_PLACEHOLDER) continue;   // drop the redacted key entirely
+      out[k] = stripRedacted(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+// Redact the per-provider api keys in authProfiles. The field is literally
+// named `key` (not `apiKey`), so the generic key-name match above doesn't
+// catch it; handle it structurally instead. Keep `label` so the auth profile
+// shape stays inspectable. Operates on the already-cloned safeCfg.
+function redactAuthProfileKeys(safeCfg) {
+  const profiles = safeCfg.authProfiles;
+  if (!profiles || typeof profiles !== 'object') return safeCfg;
+  for (const provider of Object.keys(profiles)) {
+    const arr = profiles[provider];
+    if (!Array.isArray(arr)) continue;
+    profiles[provider] = arr.map((p) =>
+      p && typeof p === 'object' && 'key' in p ? { ...p, key: '***REDACTED***' } : p,
+    );
+  }
+  return safeCfg;
+}
+
 export async function cmdExport(flags) {
   // Portable bundle: config + every installed skill + (optionally) every
   // persisted session. Writes JSON to stdout so the caller pipes it
@@ -19,10 +78,9 @@ export async function cmdExport(flags) {
   const sessionsMod = await import('../sessions.mjs');
   const cfgDir = path.dirname(configPath());
   const cfg = readConfig();
-  const safeCfg = { ...cfg };
-  if (!flags['include-secrets']) {
-    if (safeCfg['api-key']) safeCfg['api-key'] = '***REDACTED***';
-  }
+  // redactSecrets deep-clones, so --include-secrets keeps the original cfg
+  // verbatim while the default path emits a fully redacted copy.
+  const safeCfg = flags['include-secrets'] ? cfg : redactAuthProfileKeys(redactSecrets(cfg));
   const skills = skillsMod.listSkills(cfgDir).map(s => ({
     name: s.name,
     content: skillsMod.loadSkill(s.name, cfgDir),
@@ -79,11 +137,13 @@ export async function cmdImport(flags) {
   // Config
   if (bundle.config && typeof bundle.config === 'object') {
     const existing = readConfig();
+    // Strip every redacted placeholder from the incoming config BEFORE the
+    // merge so the literal '***REDACTED***' is never persisted — at the
+    // top-level api-key, inside authProfiles[].key, or any nested secret.
+    const incoming = stripRedacted(bundle.config);
     const next = flags['no-overwrite-config']
-      ? { ...bundle.config, ...existing }    // existing wins
-      : { ...existing, ...bundle.config };   // bundle wins (default)
-    // Drop redacted secrets so we never write the placeholder string.
-    if (next['api-key'] === '***REDACTED***') delete next['api-key'];
+      ? { ...incoming, ...existing }    // existing wins
+      : { ...existing, ...incoming };   // bundle wins (default)
     writeConfig(next);
     stats.configKeys = Object.keys(bundle.config).length;
   }

package/commands/setup.mjs

@@ -15,7 +15,8 @@ import { SUBCOMMANDS, parseArgs, AGENT_REG_SUBS } from '../lib/args.mjs';
 import {
   _attachGhostAutocomplete, _fetchModelsForProvider, _pauseChatForSubMenu,
   _pickModelInteractive, _pickProviderInteractive, _printChatBanner,
-  _quickPrompt, _renderBanner, _renderV5Banner,
+  _quickPrompt, _quickPromptSecret, _renderBanner, _renderV5Banner,
+  _pickYesNo,
 } from '../tui/pickers.mjs';
 import { firstRunMode as _firstRunMode } from '../first_run.mjs';
 import { applyChatWindow as _applyChatWindow, CHAT_WINDOW_TURNS, CHAT_WINDOW_TOKEN_BUDGET } from '../chat_window.mjs';
@@ -78,9 +79,13 @@ export async function cmdOnboard(flags) {
     const meta = (getRegistry().PROVIDER_INFO || {})[flags.provider] || {};
     if (meta.requiresApiKey && !flags['api-key']) {
       const prefix = meta.keyPrefix ? ` (starts with "${meta.keyPrefix}")` : '';
-      flags['api-key'] = (await ask(`api-key${prefix}: `)).trim();
+      // Close the line-mode reader before the masked raw-mode read so they
+      // don't both consume stdin. The key is masked (•) — never echoed.
+      rl.close();
+      flags['api-key'] = await _quickPromptSecret(`api-key${prefix}: `);
+    } else {
+      rl.close();
     }
-    rl.close();
   }
   const next = applyOnboardConfig(readConfig(), flags);
   if (!next.provider) { console.error('onboard: provider is required'); process.exit(2); }
@@ -160,7 +165,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  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.',
+  setup: 'Usage: lazyclaw setup [--skip-test] [--only <steps>] [--skip <steps>]\n  --only/--skip take a comma list of: provider verify channel workspace skill webhook orchestrator (e.g. --only channel re-runs just that step).\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.',
 };
@@ -206,7 +211,16 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
   const cfgDir = path.dirname(configPath());
   const colors = { accent, bold, dim, ok, warn };
 
+  // Per-step gating: `--only a,b` runs ONLY those; `--skip a,b` runs all but
+  // those. Steps: provider verify channel workspace skill webhook orchestrator.
+  // e.g. `lazyclaw setup --only channel` re-runs just the channel step.
+  const onlySet = flags.only ? new Set(String(flags.only).toLowerCase().split(',').map((s) => s.trim()).filter(Boolean)) : null;
+  const skipSet = new Set(String(flags.skip || '').toLowerCase().split(',').map((s) => s.trim()).filter(Boolean));
+  const want = (step) => (onlySet ? onlySet.has(step) : !skipSet.has(step));
+  let cfgAfterOnboard = cfg;
+
   // ── Step 1/7: Provider + model (mandatory) ──────────────────
+  if (want('provider')) {
   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 ');
@@ -225,7 +239,7 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
   // no provider set, bail out early — the rest of the wizard depends
   // on a provider being configured. `return` (not process.exit) so a
   // launcher caller can re-prompt or fall back gracefully.
-  const cfgAfterOnboard = readConfig();
+  cfgAfterOnboard = readConfig();
   if (!cfgAfterOnboard.provider) {
     process.stdout.write(`\n  ${warn('Setup not completed — provider was not configured.')}\n`);
     process.stdout.write(`  ${dim('Run `lazyclaw setup` again when ready, or pick "Onboard" from the menu for a single-step picker.')}\n\n`);
@@ -236,12 +250,14 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
   // 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.
+  if (want('verify') && cfgAfterOnboard.provider) {
   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';
+  const wantPing = !flags['skip-test'] && await _pickYesNo('Test the provider now?', { subtitle: 'sends a 1-token ping to confirm a clean reply', yesLabel: 'Test now', noLabel: 'Skip', defaultYes: true });
   if (wantPing) {
     try {
       // No-exit probe (providers/probe.mjs) — the CLI `providers test` calls
@@ -258,15 +274,20 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
   } else {
     process.stdout.write(`  ${dim('— skipped —')}\n\n`);
   }
+  }
 
   // ── Step 3/7: Channel / gateway (optional) ──────────────────
+  if (want('channel')) {
   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 ────────────────────────────
+  if (want('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();
+  const wantWs = await _pickYesNo('Initialise a workspace?', { yesLabel: 'Create one', noLabel: 'Skip', defaultYes: false });
+  const wsName = wantWs ? (await _quickPrompt('  workspace name: ')).trim() : '';
   if (wsName && /^[A-Za-z0-9_.-]+$/.test(wsName)) {
     try {
       const ws = await import('../workspace.mjs');
@@ -281,11 +302,14 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
   } else {
     process.stdout.write(`  ${dim('— skipped —')}\n\n`);
   }
+  }
 
   // ── Step 5/7: Optional skill bundle install ─────────────────
+  if (want('skill')) {
   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();
+  const wantSkill = await _pickYesNo('Install a skill bundle from GitHub?', { yesLabel: 'Install one', noLabel: 'Skip', defaultYes: false });
+  const skillSpec = wantSkill ? (await _quickPrompt('  github spec (<user>/<repo>[@<ref>]): ')).trim() : '';
   if (skillSpec) {
     try {
       const inst = await import('../skills_install.mjs');
@@ -302,14 +326,19 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
   } else {
     process.stdout.write(`  ${dim('— skipped —')}\n\n`);
   }
+  }
 
   // ── Step 6/7: Optional outbound webhook ─────────────────────
+  if (want('webhook')) {
   process.stdout.write(`  ${accent('Step 6/7 ·')} ${bold('Add an outbound webhook?')} ${dim('(optional)')}\n`);
   await runWebhookStep({ prompt: _quickPrompt, colors });
+  }
 
   // ── Step 7/7: Optional multi-agent orchestration ────────────
+  if (want('orchestrator')) {
   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');
@@ -319,6 +348,13 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
   process.stdout.write(`    ${dim('•')} lazyclaw agent "..."          ${dim('— one-shot prompt')}\n`);
   process.stdout.write(`    ${dim('•')} lazyclaw doctor              ${dim('— diagnostic JSON')}\n`);
   process.stdout.write(`    ${dim('•')} lazyclaw setup               ${dim('— re-run this wizard any time')}\n\n`);
+
+  // Release stdin so `lazyclaw setup` returns to the shell instead of hanging
+  // at "Setup complete". The interactive prompts (_arrowMenu / _quickPrompt)
+  // resume()+ref() stdin to read input; without an unref the ref'd handle keeps
+  // the event loop alive after the last step. When setup is invoked from the
+  // launcher, the next menu resume()+ref()s stdin again, so this is safe there.
+  try { if (process.stdin.unref) process.stdin.unref(); } catch { /* best-effort */ }
 }
 
 // First-run welcome panel + delegated onboard. Drawn once before the