lazyclaw 6.0.1 → 6.2.0

package/commands/channels.mjs

@@ -1,12 +1,32 @@
 // Slack / Telegram / Matrix listener commands, extracted from cli.mjs (D3).
 import path from 'node:path';
-import { configPath, readConfig, _resolveAuthKey } from '../lib/config.mjs';
-import { ensureRegistry, getRegistry } from '../lib/registry_boot.mjs';
+import { configPath, readConfig, writeConfig } from '../lib/config.mjs';
+import { ensureRegistry } from '../lib/registry_boot.mjs';
 import { loadDotenvIfAny as _loadDotenvShared } from '../dotenv_min.mjs';
+import { channelStatusList, channelSetEnabled, KNOWN_CHANNELS } from '../config_features.mjs';
+import { assertUnattendedSafe, installCrashHandlers } from '../lib/gateway_guard.mjs';
+import { makeInboundHandler } from '../lib/inbound_client.mjs';
 
 // Thin .env loader wrapper kept local so the module stays self-contained.
 export function _loadDotenvIfAny(cfgDir) { return _loadDotenvShared(cfgDir); }
 
+// Fail closed before opening a listener socket: refuse to expose a remote
+// inbound surface while the global unattended-sensitive tool override is on.
+function _bootGuard(cfg, surface) {
+  try { assertUnattendedSafe(cfg, { surface }); }
+  catch (e) { console.error(e.message); process.exit(2); }
+}
+
+// Resolve the daemon the listener forwards to. Defaults to the dashboard/
+// daemon loopback port; override with --daemon-url or LAZYCLAW_DAEMON_URL.
+const DEFAULT_DAEMON_URL = 'http://127.0.0.1:19600';
+function _daemonTarget(flags) {
+  return {
+    daemonUrl: flags['daemon-url'] || process.env.LAZYCLAW_DAEMON_URL || DEFAULT_DAEMON_URL,
+    daemonToken: flags['auth-token'] || process.env.LAZYCLAW_AUTH_TOKEN || null,
+  };
+}
+
 export async function cmdSlack(sub, positional, flags = {}) {
   if (sub !== 'listen') {
     console.error('Usage: lazyclaw slack listen [--provider X] [--model Y]');
@@ -14,73 +34,36 @@ export async function cmdSlack(sub, positional, flags = {}) {
   }
   await ensureRegistry();
   const cfg = readConfig();
+  _bootGuard(cfg, 'slack');
   const cfgDir = path.dirname(configPath());
 
   const envInfo = _loadDotenvIfAny(cfgDir);
   process.stderr.write(`[slack] .env: ${envInfo.loaded} keys loaded from ${envInfo.path}\n`);
 
-  const provName = flags.provider || cfg.provider || 'mock';
-  const prov = getRegistry().PROVIDERS[provName];
-  if (!prov) { console.error(`unknown provider: ${provName}`); process.exit(2); }
-  const model = flags.model || cfg.model;
-
-  // Per-thread rolling chat history so multi-turn coherence works
-  // without committing to on-disk sessions. Capped at MAX_TURNS to
-  // bound the prompt size.
-  const threadMsgs = new Map();
-  const MAX_TURNS = 20;
-
-  const handler = async ({ threadId, text }) => {
-    const cleaned = String(text || '').replace(/<@[A-Z0-9]+>/g, '').trim();
-    // Phase 19.2: never post a placeholder ("(empty message)" / "(empty
-    // reply)") into the thread — those leaked through as visible noise
-    // when listener self-message echoes happened. Return null and let
-    // _simulateInbound's guard drop the send. Real provider errors
-    // still surface so the operator knows something went wrong.
-    if (!cleaned) {
-      process.stderr.write('[slack] dropping empty inbound (after mention strip)\n');
-      return null;
-    }
-    const msgs = threadMsgs.get(threadId) || [];
-    msgs.push({ role: 'user', content: cleaned });
-    let acc = '';
-    try {
-      for await (const chunk of prov.sendMessage(msgs, {
-        apiKey: _resolveAuthKey(cfg, provName),
-        model,
-      })) acc += chunk;
-    } catch (err) {
-      msgs.pop();
-      const why = err?.message || String(err);
-      process.stderr.write(`[slack] provider error: ${why}\n`);
-      return `(provider error: ${why})`;
-    }
-    msgs.push({ role: 'assistant', content: acc });
-    if (msgs.length > MAX_TURNS) msgs.splice(0, msgs.length - MAX_TURNS);
-    threadMsgs.set(threadId, msgs);
-    if (!acc.trim()) {
-      process.stderr.write('[slack] provider returned empty text — not posting\n');
-      return null;
-    }
-    return acc;
-  };
+  const { daemonUrl, daemonToken } = _daemonTarget(flags);
+  // Bridge every inbound through the daemon's session-bearing /inbound so
+  // chat + dashboard + all channels share one session/memory (single agent).
+  // Slack captures the sender id (event.user) and forwards it, so a configured
+  // pairing allowlist gates Slack the same as telegram/matrix.
+  const handler = makeInboundHandler({ channel: 'slack', daemonUrl, daemonToken, provider: flags.provider, model: flags.model });
 
   const { SlackChannel } = await import('../channels/slack.mjs');
   const ch = new SlackChannel();
-  process.stderr.write(`[slack] provider=${provName} model=${model || '(default)'}\n`);
+  process.stderr.write(`[slack] bridging to daemon ${daemonUrl}${flags.provider ? ` (provider=${flags.provider})` : ''}\n`);
   try {
     await ch.start(handler);
     await ch._connectSocketMode({ logger: (line) => process.stderr.write(line) });
   } catch (err) {
     if (err?.code === 'SLACK_MISSING_ENV') {
       console.error(`slack: missing env vars: ${(err.missing || []).join(', ')}`);
-      console.error(`hint: set them in ${path.join(cfgDir, '.env')} (uncomment SLACK_APP_TOKEN / SLACK_SIGNING_SECRET)`);
+      console.error(`hint: set SLACK_APP_TOKEN (xapp-…, Socket Mode) in ${path.join(cfgDir, '.env')}`);
     } else {
       console.error(`slack: ${err?.message || err}`);
     }
     process.exit(2);
   }
   process.stderr.write(`[slack] listening. Ctrl-C to stop.\n`);
+  installCrashHandlers({ label: 'slack', stop: () => ch.stop() });
 
   await new Promise((resolve) => {
     const onSig = async () => {
@@ -106,41 +89,17 @@ export async function cmdTelegram(sub, positional, flags = {}) {
   }
   await ensureRegistry();
   const cfg = readConfig();
+  _bootGuard(cfg, 'telegram');
   const cfgDir = path.dirname(configPath());
 
   const envInfo = _loadDotenvIfAny(cfgDir);
   process.stderr.write(`[telegram] .env: ${envInfo.loaded} keys loaded from ${envInfo.path}\n`);
 
-  const provName = flags.provider || cfg.provider || 'mock';
-  const prov = getRegistry().PROVIDERS[provName];
-  if (!prov) { console.error(`unknown provider: ${provName}`); process.exit(2); }
-  const model = flags.model || cfg.model;
-
-  const threadMsgs = new Map();
-  const MAX_TURNS = 20;
-
-  const handler = async ({ threadId, text }) => {
-    const cleaned = String(text || '').trim();
-    if (!cleaned) { process.stderr.write('[telegram] dropping empty inbound\n'); return null; }
-    const msgs = threadMsgs.get(threadId) || [];
-    msgs.push({ role: 'user', content: cleaned });
-    let acc = '';
-    try {
-      for await (const chunk of prov.sendMessage(msgs, { apiKey: _resolveAuthKey(cfg, provName), model })) acc += chunk;
-    } catch (err) {
-      msgs.pop();
-      const why = err?.message || String(err);
-      process.stderr.write(`[telegram] provider error: ${why}\n`);
-      return `(provider error: ${why})`;
-    }
-    msgs.push({ role: 'assistant', content: acc });
-    if (msgs.length > MAX_TURNS) msgs.splice(0, msgs.length - MAX_TURNS);
-    threadMsgs.set(threadId, msgs);
-    if (!acc.trim()) { process.stderr.write('[telegram] provider returned empty text — not posting\n'); return null; }
-    return acc;
-  };
+  const { daemonUrl, daemonToken } = _daemonTarget(flags);
+  const handler = makeInboundHandler({ channel: 'telegram', daemonUrl, daemonToken, provider: flags.provider, model: flags.model });
 
-  // The pairing allowlist doubles as the Telegram sender allowlist.
+  // The pairing allowlist doubles as the Telegram sender allowlist (a
+  // channel-level gate complementary to the daemon's /inbound pairing check).
   const allowlist = (cfg.pairing || []).map((p) => String(p.id));
   const { TelegramChannel } = await import('../channels/telegram.mjs');
   let ch;
@@ -150,7 +109,7 @@ export async function cmdTelegram(sub, positional, flags = {}) {
     console.error(`telegram: ${err?.message || err}`);
     process.exit(2);
   }
-  process.stderr.write(`[telegram] provider=${provName} model=${model || '(default)'} allowlist=${allowlist.length || 'open'}\n`);
+  process.stderr.write(`[telegram] bridging to daemon ${daemonUrl} allowlist=${allowlist.length || 'open'}${flags.provider ? ` (provider=${flags.provider})` : ''}\n`);
   try {
     await ch.start(handler, { poll: true, logger: (line) => process.stderr.write(line) });
   } catch (err) {
@@ -163,6 +122,7 @@ export async function cmdTelegram(sub, positional, flags = {}) {
     process.exit(2);
   }
   process.stderr.write(`[telegram] listening. Ctrl-C to stop.\n`);
+  installCrashHandlers({ label: 'telegram', stop: () => ch.stop() });
 
   await new Promise((resolve) => {
     const onSig = async () => {
@@ -185,38 +145,14 @@ export async function cmdMatrix(sub, positional, flags = {}) {
   }
   await ensureRegistry();
   const cfg = readConfig();
+  _bootGuard(cfg, 'matrix');
   const cfgDir = path.dirname(configPath());
 
   const envInfo = _loadDotenvIfAny(cfgDir);
   process.stderr.write(`[matrix] .env: ${envInfo.loaded} keys loaded from ${envInfo.path}\n`);
 
-  const provName = flags.provider || cfg.provider || 'mock';
-  const prov = getRegistry().PROVIDERS[provName];
-  if (!prov) { console.error(`unknown provider: ${provName}`); process.exit(2); }
-  const model = flags.model || cfg.model;
-
-  const threadMsgs = new Map();
-  const MAX_TURNS = 20;
-  const handler = async ({ threadId, text }) => {
-    const cleaned = String(text || '').trim();
-    if (!cleaned) { process.stderr.write('[matrix] dropping empty inbound\n'); return null; }
-    const msgs = threadMsgs.get(threadId) || [];
-    msgs.push({ role: 'user', content: cleaned });
-    let acc = '';
-    try {
-      for await (const chunk of prov.sendMessage(msgs, { apiKey: _resolveAuthKey(cfg, provName), model })) acc += chunk;
-    } catch (err) {
-      msgs.pop();
-      const why = err?.message || String(err);
-      process.stderr.write(`[matrix] provider error: ${why}\n`);
-      return `(provider error: ${why})`;
-    }
-    msgs.push({ role: 'assistant', content: acc });
-    if (msgs.length > MAX_TURNS) msgs.splice(0, msgs.length - MAX_TURNS);
-    threadMsgs.set(threadId, msgs);
-    if (!acc.trim()) { process.stderr.write('[matrix] provider returned empty text — not posting\n'); return null; }
-    return acc;
-  };
+  const { daemonUrl, daemonToken } = _daemonTarget(flags);
+  const handler = makeInboundHandler({ channel: 'matrix', daemonUrl, daemonToken, provider: flags.provider, model: flags.model });
 
   const allowlist = (cfg.pairing || []).map((p) => String(p.id));
   const { MatrixChannel } = await import('../channels/matrix.mjs');
@@ -227,7 +163,7 @@ export async function cmdMatrix(sub, positional, flags = {}) {
     console.error(`matrix: ${err?.message || err}`);
     process.exit(2);
   }
-  process.stderr.write(`[matrix] provider=${provName} model=${model || '(default)'} allowlist=${allowlist.length || 'open'}\n`);
+  process.stderr.write(`[matrix] bridging to daemon ${daemonUrl} allowlist=${allowlist.length || 'open'}${flags.provider ? ` (provider=${flags.provider})` : ''}\n`);
   try {
     await ch.start(handler, { poll: true, logger: (line) => process.stderr.write(line) });
   } catch (err) {
@@ -240,6 +176,7 @@ export async function cmdMatrix(sub, positional, flags = {}) {
     process.exit(2);
   }
   process.stderr.write(`[matrix] listening. Ctrl-C to stop.\n`);
+  installCrashHandlers({ label: 'matrix', stop: () => ch.stop() });
 
   await new Promise((resolve) => {
     const onSig = async () => {
@@ -252,4 +189,66 @@ export async function cmdMatrix(sub, positional, flags = {}) {
   });
 }
 
+// `lazyclaw channels [list|enable <name>|disable <name>|install <pkg>|remove <pkg>]`
+// list   — configured built-in channels (cfg.channels.<name>) + installed plugins.
+// enable/disable — toggle cfg.channels.<name>.enabled (view/edit the setting).
+// install/remove — manage @lazyclaw/channel-* plugin packages.
+export async function cmdChannels(sub, positional = [], flags = {}) {
+  const cfgDir = path.dirname(configPath());
+  const { createLoader, listInstalled } = await import('../channels/loader.mjs');
+  const loader = createLoader({ configDir: cfgDir });
+
+  if (sub === 'install') {
+    const name = positional[0];
+    if (!name) { process.stderr.write('usage: lazyclaw channels install <@lazyclaw/channel-name>\n'); process.exit(2); }
+    const info = await loader.install(name);
+    process.stdout.write(`installed ${info.name}@${info.version}\n`);
+    return;
+  }
+  if (sub === 'remove' || sub === 'uninstall') {
+    const name = positional[0];
+    if (!name) { process.stderr.write('usage: lazyclaw channels remove <@lazyclaw/channel-name>\n'); process.exit(2); }
+    await loader.remove(name);
+    process.stdout.write(`removed ${name}\n`);
+    return;
+  }
+  if (sub === 'enable' || sub === 'disable') {
+    const name = (positional[0] || '').toLowerCase();
+    if (!name) { process.stderr.write(`usage: lazyclaw channels ${sub} <name>\n`); process.exit(2); }
+    const cfg = readConfig();
+    // Reject unknown names so a typo can't silently create a bogus
+    // cfg.channels.<name> section that then leaks into the list view.
+    // Stay permissive for pre-existing custom sections.
+    const existing = (cfg.channels && typeof cfg.channels === 'object') ? cfg.channels : {};
+    if (!KNOWN_CHANNELS.includes(name) && !(name in existing)) {
+      process.stderr.write(`unknown channel: ${name} (known: ${KNOWN_CHANNELS.join(', ')})\n`);
+      process.exit(2);
+    }
+    channelSetEnabled(cfg, name, sub === 'enable');
+    writeConfig(cfg);
+    process.stdout.write(JSON.stringify({ ok: true, channel: name, enabled: sub === 'enable' }) + '\n');
+    return;
+  }
+
+  // list (default): configured built-in channels + installed plugins.
+  const cfg = readConfig();
+  const configured = channelStatusList(cfg);
+  const plugins = listInstalled(cfgDir);
+  if (flags.json) {
+    process.stdout.write(JSON.stringify({ configured, plugins }, null, 2) + '\n');
+    return;
+  }
+  process.stdout.write('configured channels:\n');
+  if (configured.length === 0) {
+    process.stdout.write('  (none — run `lazyclaw setup` or `/config` in chat to add one)\n');
+  } else {
+    for (const ch of configured) {
+      const agent = ch.boundAgent ? ` · agent: ${ch.boundAgent}` : '';
+      process.stdout.write(`  ${ch.name}\t${ch.enabled ? 'enabled' : 'disabled'}${agent}\n`);
+    }
+  }
+  process.stdout.write(`plugins: ${plugins.length ? plugins.map((p) => `${p.name}@${p.version}`).join(', ') : '(none installed)'}\n`);
+  process.stdout.write('\ntoggle: lazyclaw channels <enable|disable> <name>  ·  add creds: lazyclaw setup\n');
+}
+
 

package/commands/chat.mjs

@@ -15,12 +15,38 @@ import {
   _pickModelInteractive, _pickProviderInteractive, _printChatBanner,
   _quickPrompt, _renderBanner, _renderV5Banner,
 } from '../tui/pickers.mjs';
-import { firstRunMode as _firstRunMode } from '../first_run.mjs';
+import { firstRunMode as _firstRunMode, hasConfiguredProvider } from '../first_run.mjs';
 import { applyChatWindow as _applyChatWindow, CHAT_WINDOW_TURNS, CHAT_WINDOW_TOKEN_BUDGET } from '../chat_window.mjs';
 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';
 
+// Legacy (non-Ink) slash routing for dispatcher-style, ctx-only commands.
+// The Ink REPL routes every slash through _dispatchSlash/SLASH_HANDLERS, but
+// the legacy readline path uses a hand-written switch (in cmdChat). Commands
+// like /config only mutate ctx and return a sentinel, so we keep that wiring
+// in one exported helper that BOTH the legacy switch and the regression test
+// drive — this is the seam that proves /config reaches setup on the legacy
+// path (the post-loop guard re-runs cmdSetup when ctx.requestSetup is set).
+// Returns 'EXIT' when the loop must break, or undefined when the command is
+// not one this helper owns (caller falls through to its own handling).
+export function legacySlashRoute(cmd, ctx) {
+  switch (cmd) {
+    case '/config':
+      // Mirror tui/slash_dispatcher.mjs '/config': signal the host, unmount.
+      ctx.requestSetup = true;
+      return 'EXIT';
+    default:
+      return undefined;
+  }
+}
+
+// Dispatcher commands the legacy readline path's default branch may delegate to
+// _dispatchSlash. Kept to ctx-safe handlers only (no _inkCtx-only setters /
+// openPicker / version), so legacy doesn't silently degrade. /channels has a
+// lib/config fallback so it's safe; add others only after confirming ctx-safety.
+const LEGACY_DELEGATED_SLASHES = new Set(['/channels', '/orchestrator', '/context']);
+
 export async function cmdChat(flags = {}) {
   await ensureRegistry();
   const sessionsMod = await import('../sessions.mjs');
@@ -37,7 +63,7 @@ export async function cmdChat(flags = {}) {
   // gets the full 5-step guided setup (provider+model, workspace, skills) —
   // not just the provider picker. `chat --pick` stays a lightweight re-pick.
   const _mode = _firstRunMode({
-    hasProvider: !!activeProvName,
+    hasProvider: hasConfiguredProvider(activeProvName),
     flagPick: !!flags.pick,
     isTTY: !!process.stdin.isTTY,
   });
@@ -82,38 +108,11 @@ export async function cmdChat(flags = {}) {
       // narrow-terminal fallback: <60 cols falls back to v4
       if ((process.stdout.columns || 80) < 60) throw new Error('narrow-terminal');
 
-      // Tool groups — read the v5 registry and collapse to one row per category.
-      let toolGroups = [];
-      try {
-        const registry = await import('../mas/tools/registry.mjs');
-        const byCat = registry.byCategory();
-        toolGroups = 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 */ }
-
-      // Skill groups — group installed skills by filename hyphen-prefix
-      // (canonical C5 fallback: <group>-<name>.md → group; bare names → 'general').
-      let skillGroups = [];
-      try {
-        const { listSkills } = await import('../skills.mjs');
-        // Use the resolved config dir, not the module default, so a
-        // LAZYCLAW_CONFIG_DIR override surfaces that install's skills.
-        const flat = listSkills(path.dirname(configPath()));
-        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);
-        }
-        skillGroups = [...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 */ }
+      // Tool + skill groups for the splash panel — shared with the setup
+      // wizard via tui/splash_props.mjs so both surfaces render the same panel.
+      const { gatherToolAndSkillGroups } = await import('../tui/splash_props.mjs');
+      const { tools: toolGroups, skills: skillGroups } =
+        await gatherToolAndSkillGroups(path.dirname(configPath()));
 
       const splashProps = {
         provider: activeProvName, model: activeModel,
@@ -255,14 +254,14 @@ export async function cmdChat(flags = {}) {
           ? api.openPicker(opts)
           : Promise.resolve(null);
       };
-      // v5.0.10: write streamed chunks straight to process.stdout. Ink
-      // owns the screen, so interleaved stdout writes can produce some
-      // visual jank — accepted trade for unblocking the chat loop. v5.1
-      // TODO: route through a ref'd scrollback <Static/> region in
-      // ReplApp so Ink owns all output.
-      const _inkRunTurn = _chatRunTurnFactory({
+      // Route streamed chunks through ReplApp's injected writeFn: chunks
+      // land in React state (liveAssistant) → live region → committed to
+      // the <Static/> scrollback on turn-complete, so Ink owns all output.
+      // Writing straight to process.stdout (the old v5.1 hack) put replies
+      // in Ink's live frame, which the next render erased — replies vanished.
+      const _inkRunTurnFactory = (writeFn) => _chatRunTurnFactory({
         ctx: _inkCtx,
-        writeFn: (chunk) => process.stdout.write(chunk),
+        writeFn,
       });
       // v5.4: full slash-command dispatch via tui/slash_dispatcher.mjs.
       // Dispatcher returns a string (rendered to scrollback by ReplApp),
@@ -291,13 +290,16 @@ export async function cmdChat(flags = {}) {
           provider: activeProvName,
           model: activeModel,
           ctxUsed: _inkRunningUsage ? _inkRunningUsage.totalTokens : undefined,
-          ctxTotal: CHAT_WINDOW_TOKEN_BUDGET,
+          ctxTotal: Number((cfg.chat || {}).windowTokens) || CHAT_WINDOW_TOKEN_BUDGET,
         }),
-        runTurn: _inkRunTurn,
+        runTurnFactory: _inkRunTurnFactory,
         onSlashCommand: _inkSlashHandler,
         pickerRef: _inkPickerRef,
       }), { exitOnCtrlC: true, patchConsole: true });
       await ink.waitUntilExit();
+      // /config asks to (re)run the wizard: now that Ink has released stdin,
+      // run setup, then return to the shell (re-launch `lazyclaw` to chat).
+      if (_inkCtx.requestSetup) await (await import('./setup.mjs')).cmdSetup(undefined, [], {});
       return;
     } catch (e) {
       // Fall through to legacy path on any ink failure (missing import,
@@ -576,7 +578,15 @@ export async function cmdChat(flags = {}) {
         return true;
       }
       case '/new':
-      case '/reset': {
+      case '/reset':
+      case '/clear': {
+        // /clear is dispatcher-only (no explicit legacy case before this),
+        // so without it /clear fell through to `default:` → _dispatchSlash →
+        // _newReset, which clears via ctx.set* setters that _legacyCtx does
+        // NOT expose — returning 'cleared' while the closure's messages/
+        // charsSent/runningUsage stayed intact (a lying no-op). Alias /clear
+        // to the /new+/reset direct-mutation body, matching the dispatcher's
+        // /clear → /new/reset session-reset aliasing.
         messages = [];
         charsSent = 0;
         runningUsage = null;
@@ -1100,9 +1110,33 @@ export async function cmdChat(flags = {}) {
         } catch { /* /exit must never hang or throw */ }
         return 'EXIT';
       }
-      default:
+      case '/config': {
+        // Route through the shared legacySlashRoute helper (covered by
+        // tests/f-config-slash-splash.test.mjs) so the legacy path's /config
+        // wiring is the exact code the regression test exercises. It sets
+        // _legacyCtx.requestSetup and returns 'EXIT'; the post-loop guard at the
+        // bottom of cmdChat re-runs the setup wizard when requestSetup is set.
+        // Without this case the legacy readline path fell through to `default:`
+        // and printed "unknown slash" instead of launching setup.
+        return legacySlashRoute(cmd, _legacyCtx);
+      }
+      default: {
+        // Delegate ONLY ctx-safe dispatcher commands to the shared handler.
+        // _legacyCtx is intentionally thin (no setters / openPicker / version),
+        // so a blanket delegation would silently degrade picker- or setter-
+        // driven handlers (/menu, /clear, /version, …). /channels is ctx-safe
+        // (it has a lib/config fallback); everything else stays an honest
+        // "unknown slash". 'EXIT' breaks the loop; a returned string prints.
+        if (LEGACY_DELEGATED_SLASHES.has(cmd)) {
+          const { args } = _parseSlashLine(line);
+          const r = await _dispatchSlash(cmd, args, _legacyCtx, (s) => process.stdout.write(s));
+          if (r === 'EXIT') return 'EXIT';
+          if (typeof r === 'string' && r.length) process.stdout.write(r + '\n');
+          return true;
+        }
         process.stdout.write(`unknown slash: ${cmd} (try /help)\n`);
         return true;
+      }
     }
   };
 
@@ -1176,6 +1210,8 @@ export async function cmdChat(flags = {}) {
     try { process.stdin.pause(); } catch (_) {}
     try { process.stdin.unref(); } catch (_) {}
   }
+  // /config in the legacy path: re-run the wizard after the readline loop closes.
+  if (_legacyCtx.requestSetup) await (await import('./setup.mjs')).cmdSetup(undefined, [], {});
 }
 
 // Light wrapper around the daemon — meant for users who installed

package/commands/daemon.mjs

@@ -3,6 +3,15 @@
 import path from 'node:path';
 import { ensureRegistry } from '../lib/registry_boot.mjs';
 import { configPath, readConfig, writeConfig, readVersionFromRepo } from '../lib/config.mjs';
+import { assertUnattendedSafe, installCrashHandlers } from '../lib/gateway_guard.mjs';
+
+// Fail closed before binding the HTTP surface: the daemon/dashboard serve
+// POST /inbound + /agent, so the global unattended-sensitive override must
+// not be on while they are exposed.
+function _bootGuard(surface) {
+  try { assertUnattendedSafe(readConfig(), { surface }); }
+  catch (e) { console.error(e.message); process.exit(2); }
+}
 
 export async function _killPortOccupant(port) {
   if (process.platform === 'win32') return false;
@@ -35,6 +44,7 @@ export async function _killPortOccupant(port) {
 
 export async function cmdDashboard(flags = {}) {
   await ensureRegistry();
+  _bootGuard('dashboard');
   const sessionsMod = await import('../sessions.mjs');
   const { startDaemon } = await import('../daemon.mjs');
   const port = flags.port !== undefined ? parseInt(flags.port, 10) : 19600;
@@ -110,6 +120,7 @@ export async function cmdDashboard(flags = {}) {
   // Forward SIGINT/SIGTERM to a graceful shutdown so Ctrl-C doesn't
   // strand a port-bound server. Same shape cmdDaemon uses.
   const { gracefulShutdown } = await import('../daemon.mjs');
+  installCrashHandlers({ label: 'dashboard', stop: () => gracefulShutdown(d.server, 5_000) });
   let shuttingDown = false;
   const shutdown = async () => {
     if (shuttingDown) return process.exit(1);
@@ -124,6 +135,7 @@ export async function cmdDashboard(flags = {}) {
 
 export async function cmdDaemon(flags) {
   await ensureRegistry();
+  _bootGuard('daemon');
   const sessionsMod = await import('../sessions.mjs');
   const { startDaemon } = await import('../daemon.mjs');
   const port = flags.port !== undefined ? parseInt(flags.port, 10) : 0;
@@ -239,6 +251,9 @@ export async function cmdDaemon(flags) {
     // mean it" signal.
     const { gracefulShutdown } = await import('../daemon.mjs');
     const timeoutMs = flags['shutdown-timeout-ms'] ? parseInt(flags['shutdown-timeout-ms'], 10) : 10_000;
+    // Always-on: make an unhandled crash observable + drain sockets, then
+    // exit non-zero so a service manager restarts us (vs. silent death).
+    installCrashHandlers({ label: 'daemon', logger, stop: () => gracefulShutdown(d.server, timeoutMs) });
     let shuttingDown = false;
     const shutdown = async () => {
       if (shuttingDown) {