lazyclaw 6.3.1 → 6.5.0

package/tui/slash_dispatcher.mjs

@@ -26,20 +26,37 @@
 //     skillsMod,       // optional — falls back to dynamic import
 //   }
 //
-// Interactive sub-menus (provider/model pickers, /personality picker) are
-// readline-coupled in cli.mjs. In Ink we surface a hint instead of crashing;
-// operators can pass an arg form (e.g. `/provider openai`) or fall back to
-// LAZYCLAW_NO_INK=1. Re-implementing these as Ink overlays is a v5.5 item.
+// Interactive sub-menus that are readline-coupled in cli.mjs surface a hint in
+// Ink instead of crashing; pass an arg form (`/provider openai`) or set
+// LAZYCLAW_NO_INK=1.
 
 import { SLASH_COMMANDS } from './slash_commands.mjs';
-import { supportsLiveFetch, fetchModelsForProvider } from '../providers/model_catalogue.mjs';
-import { providerFamilies, providerTag } from './provider_families.mjs';
+import { nearest } from '../lib/args.mjs';
+import {
+  pickProviderModel,
+  pickProviderDrillIn as _pickProviderDrillIn,
+  infoFor as _infoFor,
+  providerLookup as _providerLookup,
+} from './model_pick.mjs';
+import { renderRecord } from '../lib/render.mjs';
 import { addCustomProvider } from '../providers/custom_provider.mjs';
 import { setAuthKey } from '../providers/auth_store.mjs';
+import { runProviderLogin, loginSlash } from './login_flow.mjs';
+import { hudSlash } from './hud.mjs';
+import { agenticSlash, planSlash, CHAT_MODE_SLASH_COMMANDS } from './chat_mode_slash.mjs';
+import { orchestratorSlash, pickAndSetModel } from './orchestrator_flow.mjs';
 import { attachGoalCron, detachGoalCron } from '../goals_cron.mjs';
 import { loadDotenvIfAny } from '../dotenv_min.mjs';
 import { SUBCOMMAND_GROUPS } from './subcommands.mjs';
 import { redactSecrets } from '../mas/redact.mjs';
+import { splitWhitespace, _mod, _promptText, _promptConfirm } from './slash_helpers.mjs';
+import { _dashboard, parseDashboardUrl } from './slash_dashboard.mjs';
+import { _channels, _context } from './slash_channels.mjs';
+import { _trainer } from './slash_trainer.mjs';
+
+// Re-export so callers/tests that import parseDashboardUrl from this module
+// (the dispatcher was its original home) keep resolving after the extraction.
+export { parseDashboardUrl };
 
 // ─── helpers ─────────────────────────────────────────────────────────────
 
@@ -55,29 +72,6 @@ export function parseSlashLine(line) {
   return { cmd: m[1], args: (m[3] || '').trim() };
 }
 
-// Tiny utility — split args on whitespace, drop empties. Used by sub-command
-// handlers that don't need the loop-engine's full quote-aware splitter.
-function splitWhitespace(s) {
-  return (s || '').split(/\s+/).filter(Boolean);
-}
-
-// Parse a "provider[:model]" spec, preferring the registry's parser.
-function _parseProvModel(registry, spec) {
-  if (registry && typeof registry.parseProviderModel === 'function') return registry.parseProviderModel(spec);
-  const s = String(spec || '');
-  const i = s.indexOf(':');
-  if (i < 0) return { provider: s || null, model: null };
-  return { provider: s.slice(0, i) || null, model: s.slice(i + 1) || null };
-}
-
-// Best-effort dynamic import. Returns the resolved ctx field if the caller
-// pre-injected it (test hot path), else loads the real module. Throwing is
-// fine — handlers wrap calls in try/catch where appropriate.
-async function _mod(ctx, key, importer) {
-  if (ctx && ctx[key]) return ctx[key];
-  return importer();
-}
-
 // ─── handlers ────────────────────────────────────────────────────────────
 
 async function _help() {
@@ -156,110 +150,11 @@ async function _newReset(_args, ctx) {
   return 'cleared — new conversation';
 }
 
-function _providerLookup(registry, name) {
-  if (typeof registry.lookupProv === 'function') return registry.lookupProv(name);
-  return registry.PROVIDERS ? registry.PROVIDERS[name] : null;
-}
-
-// Pick a provider via the family drill-in (API key / CLI-Local / Mock),
-// mirroring the legacy readline wizard. Single-option steps auto-advance.
-// orchestrator is never listed. Returns a provider id or null on cancel.
-async function _pickProviderDrillIn(ctx, registry) {
-  const info = registry.PROVIDER_INFO || {};
-  const families = providerFamilies(registry);
-  const nonEmpty = Object.values(families).filter((f) => f.members.length > 0);
-  if (!nonEmpty.length) return null;
-
-  // ── Step 1 — auth family (skipped when only one is populated) ──
-  let family = nonEmpty[0];
-  if (nonEmpty.length > 1) {
-    const picked = await ctx.openPicker({
-      kind: 'provider-family',
-      title: 'select provider — how do you want to auth?',
-      subtitle: 'API: bring your own key · CLI/Local: use this machine · Mock: offline',
-      items: nonEmpty.map((f) => ({
-        id: f.id,
-        label: f.label,
-        desc: `${f.desc} · ${f.members.slice(0, 3).join(' / ')}${f.members.length > 3 ? ` (+${f.members.length - 3})` : ''}`,
-        tag: f.tag,
-      })),
-    });
-    if (!picked || typeof picked !== 'string') return null;
-    family = families[picked];
-    if (!family || !family.members.length) return null;
-  }
-
-  // ── Step 2 — provider in that family (auto-advances on a single member) ──
-  // The API-key family also offers "+ add a custom endpoint" so NIM /
-  // OpenRouter / vLLM / etc. can be registered without leaving chat. The
-  // add-custom row is never auto-advanced past, so don't single-skip it in.
-  const items = family.members.map((id) => {
-    const meta = info[id] || {};
-    let desc = '';
-    if (meta.custom) desc = `custom · ${meta.baseUrl || ''}`;
-    else if (meta.builtinOpenAICompat) desc = meta.label || meta.baseUrl || '';
-    else if (meta.label && meta.label !== id) desc = meta.label;
-    return { id, label: id, desc, tag: providerTag(meta) };
-  });
-  if (family.id === 'api') {
-    items.push({
-      id: '__add_custom__',
-      label: '+ add a custom OpenAI-compatible endpoint…',
-      desc: 'NIM · OpenRouter · Together · Groq · vLLM · LM Studio',
-      tag: 'new',
-    });
-  }
-  if (items.length === 1) return items[0].id;
-  const picked = await ctx.openPicker({
-    kind: 'provider',
-    title: `select provider — ${family.label}`,
-    subtitle: `current: ${ctx.getActiveProvName()}`,
-    items,
-  });
-  return typeof picked === 'string' ? picked : null;
-}
-
-// Single free-text prompt reusing the modal's filter buffer (no dedicated
-// input widget). Returns the typed value, '' (only when allowEmpty), or null
-// on cancel / required-but-empty.
-async function _promptText(ctx, { title, subtitle, allowEmpty } = {}) {
-  if (typeof ctx.openPicker !== 'function') return null;
-  const picked = await ctx.openPicker({
-    kind: 'text',
-    title,
-    subtitle: subtitle || 'type into the filter, then pick the row · Esc cancels',
-    items: [{ id: '__text__', label: '✓ use what I typed above', desc: '', pinned: true, freeText: true }],
-  });
-  if (picked == null) return null;
-  if (typeof picked === 'object') {
-    const v = String(picked.query || '').trim();
-    if (!v && !allowEmpty) return null;
-    return v;
-  }
-  return null;
-}
-
-// Yes/no confirmation modal for sensitive-tool approval. Esc (or no modal
-// available) DENIES — approval is never granted by omission.
-async function _promptConfirm(ctx, { title, subtitle } = {}) {
-  if (typeof ctx.openPicker !== 'function') return false;
-  const picked = await ctx.openPicker({
-    kind: 'menu',
-    title: title || 'Approve sensitive tool?',
-    subtitle: subtitle || 'Enter selects · Esc denies',
-    items: [
-      { id: 'approve', label: '✓ approve once', desc: 'run this tool call' },
-      { id: 'deny', label: '✗ deny', desc: 'block this tool call' },
-    ],
-  });
-  const id = picked && typeof picked === 'object' ? picked.id : picked;
-  return id === 'approve';
-}
 
 // Default in-chat approval hook: prompts the operator to confirm each
 // sensitive tool call. Used to drive the fail-closed tool runner from the
 // Ink REPL, where stdin is owned by Ink so a raw readline prompt can't run.
-function _makeInkApprove(ctx) {
+export function _makeInkApprove(ctx) {
   return async function approve({ tool, args, agent }) {
     const raw = typeof args === 'object' ? JSON.stringify(args) : String(args ?? '');
     const summary = redactSecrets(raw).slice(0, 300);
@@ -310,6 +205,7 @@ async function _maybePromptForKey(ctx, registry, provName) {
   const key = await _promptText(ctx, {
     title: `${provName} needs an api key`,
     subtitle: 'paste it now, or Esc to skip (set later via: lazyclaw auth)',
+    secret: true,
   });
   if (!key) return;
   const next = setAuthKey({ readConfig: ctx.readConfig, writeConfig: ctx.writeConfig, provider: provName, key });
@@ -327,30 +223,30 @@ async function _addCustomFlow(ctx, registry) {
   if (!name) return 'cancelled';
   const baseUrl = await _promptText(ctx, { title: `baseUrl for ${name}`, subtitle: 'must start with http(s) and end in /v1' });
   if (!baseUrl) return 'cancelled';
-  const apiKey = await _promptText(ctx, { title: `api-key for ${name}`, subtitle: 'leave blank for an auth-less endpoint (e.g. local vLLM)', allowEmpty: true });
+  const apiKey = await _promptText(ctx, { title: `api-key for ${name}`, subtitle: 'leave blank for an auth-less endpoint (e.g. local vLLM)', allowEmpty: true, secret: true });
   if (apiKey === null) return 'cancelled';
   return _registerCustom(ctx, registry, { name, baseUrl, apiKey });
 }
 
 async function _provider(args, ctx) {
   const registry = await _mod(ctx, 'registryMod', () => import('../providers/registry.mjs'));
-  // `/provider add <name> <baseUrl> [apiKey]` — register a custom OpenAI-
-  // compatible endpoint non-interactively.
+  // `/provider add <name> <baseUrl> [apiKey]` — register a custom OpenAI-compat endpoint.
   const addMatch = args && args.match(/^add\s+(.+)$/i);
   if (addMatch) {
     const [name, baseUrl, apiKey] = splitWhitespace(addMatch[1]);
     if (!name || !baseUrl) return 'usage: /provider add <name> <baseUrl> [apiKey]';
     return _registerCustom(ctx, registry, { name, baseUrl, apiKey });
   }
-  // No arg → drill-in modal picker (family -> provider). Falls back to the
-  // pre-v5.4.3 hint string when ctx.openPicker isn't available (e.g. non-Ink
-  // callers or before the picker ref settles).
+  // No arg → drill-in modal picker (family -> provider); falls back to a hint
+  // string when ctx.openPicker isn't available (non-Ink / picker not settled).
+  let _fromPicker = false;
   if (!args) {
     if (typeof ctx.openPicker === 'function') {
       const picked = await _pickProviderDrillIn(ctx, registry);
       if (!picked) return 'cancelled';
       if (picked === '__add_custom__') return _addCustomFlow(ctx, registry);
       args = picked;
+      _fromPicker = true;
       // Built-in api-key provider with no key configured → offer to set one.
       await _maybePromptForKey(ctx, registry, args);
     } else {
@@ -364,190 +260,43 @@ async function _provider(args, ctx) {
   }
   if (ctx.setActiveProvName) ctx.setActiveProvName(args);
   if (ctx.setProv) ctx.setProv(next);
-  return `provider → ${args}`;
-}
-
-function _infoFor(registry, provName) {
-  return (registry.PROVIDER_INFO && registry.PROVIDER_INFO[provName]) || {};
-}
-
-// A composite provider (orchestrator) has no real model list — its only
-// "model" is the provider name itself, so the model picker would dead-end
-// on a single bogus row. Detect it so we can redirect to a provider pick.
-function _isCompositeProvider(info, provName) {
-  if (info && info.composite) return true;
-  const s = info && Array.isArray(info.suggestedModels) ? info.suggestedModels : null;
-  return !!(s && s.length === 1 && s[0] === provName);
-}
-
-// Whether the active provider exposes any selectable model (a suggested
-// model that isn't just the provider name, or a live-fetchable catalogue).
-function _hasRealModels(info, provName) {
-  if (supportsLiveFetch(info, provName)) return true;
-  const s = info && Array.isArray(info.suggestedModels) ? info.suggestedModels : [];
-  return s.some((m) => m && m !== provName);
-}
-
-// Build the model-picker rows: suggested + any live-fetched models, deduped,
-// with the provider default tagged, plus pinned sentinel rows for live-fetch
-// (when supported) and free-text custom entry.
-function _buildModelItems(info, provName, dynamicModels) {
-  const base = Array.isArray(info.suggestedModels) ? info.suggestedModels : [];
-  const all = Array.from(new Set([...(dynamicModels || []), ...base])).filter((m) => m && m !== provName);
-  const items = [];
-  if (supportsLiveFetch(info, provName)) {
-    items.push({
-      id: '__fetch_models__',
-      label: '↻ fetch live model list',
-      desc: 'pull the current catalogue from the provider',
-      pinned: true,
-    });
+  // Keyless CLI not signed in → inline connect menu ('EXIT' = foreground login).
+  const r = await runProviderLogin(ctx, args, { promptText: _promptText });
+  if (r !== null) return r;
+  // Picked from the modal → chain straight into a model pick so provider+model
+  // are set together (no separate /model step). Composites have no model list.
+  if (_fromPicker && args !== 'orchestrator' && typeof ctx.openPicker === 'function') {
+    const mm = await pickAndSetModel(ctx, registry, args);
+    if (mm) return `provider → ${args} · ${mm}`;
   }
-  for (const m of all) {
-    items.push({ id: m, label: m, desc: info.defaultModel === m ? '(default)' : '' });
-  }
-  items.push({
-    id: '__custom_model__',
-    label: '… type a custom model id',
-    desc: 'type the id into the filter above, then pick this row',
-    pinned: true,
-    freeText: true,
-  });
-  // Reach another provider's models (e.g. claude-cli's opus) without leaving
-  // /model — the active provider isn't the only place to pick a model.
-  items.push({
-    id: '__switch_provider__',
-    label: '⇄ pick a different provider…',
-    desc: 'switch provider (e.g. claude-cli for opus/sonnet), then its model',
-    pinned: true,
-  });
-  return items;
-}
-
-// Run the model picker for `provName`, looping on the live-fetch row and
-// resolving the free-text row from the typed filter. Returns a concrete
-// model id, or null on cancel.
-async function _pickModelLoop(ctx, registry, provName) {
-  const info = _infoFor(registry, provName);
-  let dynamic = [];
-  let note = '';
-  for (let guard = 0; guard < 50; guard++) {
-    const items = _buildModelItems(info, provName, dynamic);
-    const picked = await ctx.openPicker({
-      kind: 'model',
-      title: `select model for ${provName}`,
-      subtitle: note || `current: ${ctx.getActiveModel() || '(default)'}`,
-      items,
-    });
-    if (picked == null) return null;
-    if (typeof picked === 'object') {
-      // free-text custom row → { id, query }
-      const typed = String(picked.query || '').trim();
-      if (!typed) { note = 'type a model id into the filter first'; continue; }
-      return typed;
-    }
-    if (picked === '__fetch_models__') {
-      try {
-        const fetcher = typeof ctx.fetchModels === 'function'
-          ? ctx.fetchModels
-          : (provId) => fetchModelsForProvider({
-              cfg: ctx.cfg,
-              registryMod: registry,
-              resolveAuthKey: (id) => (ctx.resolveAuthKey ? ctx.resolveAuthKey(id) : ''),
-              providerId: provId,
-            });
-        const fetched = await fetcher(provName);
-        if (Array.isArray(fetched) && fetched.length) {
-          dynamic = fetched;
-          note = `fetched ${fetched.length} model(s) — pick one or type a custom id`;
-        } else {
-          note = 'no models returned — using the suggested list';
-        }
-      } catch (e) {
-        note = `fetch failed: ${e && e.message ? e.message : e}`;
-      }
-      continue;
-    }
-    // Switch to a different provider's models (e.g. claude-cli's opus).
-    if (picked === '__switch_provider__') return '__switch_provider__';
-    return picked;
-  }
-  return null;
+  return `provider → ${args}`;
 }
 
-// Flat provider picker used to escape a composite/model-less active provider
-// or to switch providers from inside /model. Hides composites + mock,
-// mirroring the legacy wizard's filter (cli.mjs:1979).
-async function _pickProviderForModel(ctx, registry, subtitle) {
-  const info = registry.PROVIDER_INFO || {};
-  const known = Object.keys(registry.PROVIDERS || {})
-    .filter((id) => id !== 'mock' && !((info[id] || {}).composite))
-    .sort();
-  const items = known.map((id) => ({
-    id,
-    label: id,
-    desc: info[id] && info[id].docs ? String(info[id].docs).split('\n')[0].slice(0, 60) : '',
-  }));
-  const picked = await ctx.openPicker({
-    kind: 'provider',
-    title: 'select provider (then a model)',
-    subtitle: subtitle || `${ctx.getActiveProvName()} has no selectable models — pick a provider`,
-    items,
-  });
-  return typeof picked === 'string' ? picked : null;
-}
 
 async function _model(args, ctx) {
   const registry = await _mod(ctx, 'registryMod', () => import('../providers/registry.mjs'));
   if (!args) {
     if (typeof ctx.openPicker === 'function') {
-      let provName = ctx.getActiveProvName();
-      let info = _infoFor(registry, provName);
-      let switched = false;
-      // Composite (orchestrator) or model-less active provider → pick a
-      // provider first so the user is never dead-ended on a single row.
-      if (_isCompositeProvider(info, provName) || !_hasRealModels(info, provName)) {
-        const pickedProv = await _pickProviderForModel(ctx, registry);
-        if (!pickedProv) return 'cancelled';
-        if (pickedProv !== provName) {
-          const next = _providerLookup(registry, pickedProv);
-          if (!next) return `unknown provider: ${pickedProv}`;
-          if (ctx.setActiveProvName) ctx.setActiveProvName(pickedProv);
-          if (ctx.setProv) ctx.setProv(next);
-          switched = true;
-        }
-        provName = pickedProv;
-        info = _infoFor(registry, provName);
-      }
-      // Model pick loop — the "⇄ pick a different provider" row re-enters the
-      // provider picker so models from any provider (e.g. claude-cli's opus)
-      // are reachable without leaving /model.
-      let model = null;
-      for (let guard = 0; guard < 25; guard++) {
-        model = await _pickModelLoop(ctx, registry, provName);
-        if (model === '__switch_provider__') {
-          const np = await _pickProviderForModel(ctx, registry, `current: ${provName} — pick a provider`);
-          if (!np) continue; // cancelled the switch → back to the model list
-          if (np !== provName) {
-            const next = _providerLookup(registry, np);
-            if (!next) { continue; }
-            if (ctx.setActiveProvName) ctx.setActiveProvName(np);
-            if (ctx.setProv) ctx.setProv(next);
-            switched = true;
-            provName = np;
-            info = _infoFor(registry, provName);
-          }
-          continue;
-        }
-        break;
+      // Shared canonical picker: provider drill-in (only when the active
+      // provider has no models) → model loop with the "⇄ switch provider"
+      // and custom-id rows. Session-only — /model does not persist to disk.
+      const r = await pickProviderModel(ctx, registry, { includeSwitch: true });
+      if (!r) return 'cancelled';
+      const switched = r.provider !== ctx.getActiveProvName();
+      if (switched) {
+        const next = _providerLookup(registry, r.provider);
+        if (!next) return `unknown provider: ${r.provider}`;
+        if (ctx.setActiveProvName) ctx.setActiveProvName(r.provider);
+        if (ctx.setProv) ctx.setProv(next);
       }
-      if (model == null || model === '__switch_provider__') {
-        return switched ? `provider → ${provName} (model unchanged)` : 'cancelled';
+      // Model pick cancelled (null) → keep any provider switch, leave model.
+      if (r.model == null) {
+        return switched ? `provider → ${r.provider} (model unchanged)` : 'cancelled';
       }
-      if (ctx.setActiveModel) ctx.setActiveModel(model);
+      if (ctx.setActiveModel) ctx.setActiveModel(r.model);
       return switched
-        ? `provider → ${provName} · model → ${model}`
-        : `model → ${model}`;
+        ? `provider → ${r.provider} · model → ${r.model}`
+        : `model → ${r.model}`;
     }
     return `model: ${ctx.getActiveModel() || '(default)'}\n(pass an arg: /model <name>)`;
   }
@@ -569,13 +318,22 @@ async function _model(args, ctx) {
 async function _skill(args, ctx) {
   // `/skill name1,name2` — replace the active system message with a
   // composition. No-arg → clear system message. Mirrors cli.mjs:3046.
-  const names = args.split(',').map((s) => s.trim()).filter(Boolean);
+  // `clear`/`unset` are not skill names — treat them as the explicit clear verb
+  // so they reach the clear branch instead of being composed as a skill.
+  const isClear = /^(clear|unset)$/i.test((args || '').trim());
+  const names = isClear ? [] : args.split(',').map((s) => s.trim()).filter(Boolean);
   const messages = ctx.getMessages().slice(); // mutable copy
   const sysIdx = messages.findIndex((m) => m.role === 'system');
   const sid = ctx.getSessionId && ctx.getSessionId();
   const sessionsMod = await _mod(ctx, 'sessionsMod', () => import('../sessions.mjs'));
 
   if (names.length === 0) {
+    // Footgun guard: bare `/skill` used to silently wipe the active skills.
+    // Now no-arg opens the skill picker; clearing requires explicit /skill clear.
+    if (!isClear) {
+      if (typeof ctx.openPicker === 'function') return _skillsList('', ctx);
+      return 'usage: /skill <name>[,<name>]  ·  /skill clear to unset  ·  /skills to pick';
+    }
     if (sysIdx >= 0) messages.splice(sysIdx, 1);
     if (ctx.setMessages) ctx.setMessages(messages);
     if (sid) {
@@ -619,7 +377,8 @@ async function _skillsList(args, ctx) {
   if (!names.length) {
     return [
       'no skills installed.',
-      'install one:  lazyclaw skills install <owner>/<repo>',
+      'starter pack:  lazyclaw skills starter',
+      'install more:  lazyclaw skills install <owner>/<repo>',
       'then /skills to pick, or /skill <name>[,<name>] to activate.',
     ].join('\n');
   }
@@ -677,6 +436,18 @@ async function _memory(args, ctx) {
   try { mem = await import('../memory.mjs'); }
   catch (e) { return `memory unavailable: ${e?.message || e}`; }
   const tokens = splitWhitespace(args);
+  if (!tokens.length && typeof ctx.openPicker === 'function') {
+    const picked = await ctx.openPicker({
+      kind: 'menu', title: 'Memory', subtitle: 'view a memory store',
+      items: [
+        { id: 'core', label: 'Core', desc: 'persistent core memory' },
+        { id: 'recent', label: 'Recent', desc: 'last ~20 messages' },
+        { id: 'episodic', label: 'Episodic', desc: 'consolidated topic files' },
+      ],
+    });
+    const pid = picked && typeof picked === 'object' ? picked.id : picked;
+    return _memory(typeof pid === 'string' && pid ? pid : 'core', ctx);
+  }
   const which = tokens[0] || 'core';
   if (which === 'core') {
     const body = mem.loadCore(ctx.cfgDir);
@@ -740,6 +511,20 @@ async function _agent(args, ctx) {
   const rest = tokens.slice(1);
   const aname = rest[0];
   try {
+    if (!sub && typeof ctx.openPicker === 'function') {
+      const picked = await ctx.openPicker({
+        kind: 'menu', title: 'Agents', subtitle: `${agentsMod.listAgents(ctx.cfgDir).length} registered`,
+        items: [
+          { id: 'list', label: 'List agents', desc: 'show all' },
+          { id: 'add', label: 'Add agent…', desc: '/agent add <name> [role]' },
+          { id: 'edit', label: 'Edit agent…', desc: 'pick provider + model' },
+          { id: 'show', label: 'Show agent…', desc: 'print one record' },
+          { id: 'remove', label: 'Remove agent…', desc: 'delete a record' },
+        ],
+      });
+      const pid = picked && typeof picked === 'object' ? picked.id : picked;
+      return _agent(typeof pid === 'string' && pid ? pid : 'list', ctx);
+    }
     if (!sub || sub === 'list') {
       const agents = agentsMod.listAgents(ctx.cfgDir);
       if (agents.length === 0) return 'no agents registered. /agent add <name> [...] to create.';
@@ -749,33 +534,63 @@ async function _agent(args, ctx) {
       }).join('\n');
     }
     if (sub === 'show') {
-      if (!aname) return 'usage: /agent show <name>';
+      if (!aname) return 'usage: /agent show <name> [json]';
       const a = agentsMod.getAgent(aname, ctx.cfgDir);
       if (!a) return `no agent "${aname}"`;
-      return JSON.stringify(a, null, 2);
+      return rest[1] === 'json'
+        ? JSON.stringify(a, null, 2)
+        : renderRecord(a, { fields: ['name', 'displayName', 'provider', 'model', 'role', 'tools', 'tags', 'iconEmoji', 'memoryWrite', 'skillWrite', 'createdAt', 'updatedAt'] });
     }
     if (sub === 'add') {
-      if (!aname) return 'usage: /agent add <name> [role text…]';
-      const roleText = rest.slice(1).join(' ').trim();
-      const a = agentsMod.registerAgent({ name: aname, role: roleText }, ctx.cfgDir);
-      return `✓ added agent ${a.name} (tools=${(a.tools || []).join(',')})`;
+      let name = aname;
+      let roleText = rest.slice(1).join(' ').trim();
+      // Guided fill: no name typed + a modal available → prompt for it.
+      if (!name && typeof ctx.openPicker === 'function') {
+        name = await _promptText(ctx, { title: 'New agent — name', subtitle: 'short id, e.g. scout (Esc cancels)' });
+        if (!name) return 'agent add: cancelled';
+        if (!roleText) {
+          const r = await _promptText(ctx, { title: `Role for ${name}`, subtitle: 'one line describing what this agent does (Esc to skip)', allowEmpty: true });
+          roleText = r || '';
+        }
+      }
+      if (!name) return 'usage: /agent add <name> [role text…]';
+      const a = agentsMod.registerAgent({ name, role: roleText }, ctx.cfgDir);
+      return `✓ added agent ${a.name} (tools=${(a.tools || []).join(',')}) — set its model with /agent edit ${a.name}`;
+    }
+    if (sub === 'edit') {
+      if (!aname) return 'usage: /agent edit <name>';
+      const existing = agentsMod.getAgent(aname, ctx.cfgDir);
+      if (!existing) return `no agent "${aname}"`;
+      if (typeof ctx.openPicker !== 'function') {
+        return `agent edit: picker unavailable here — use: lazyclaw agent edit ${aname} --provider <p> --model <m>`;
+      }
+      const registry = await _mod(ctx, 'registryMod', () => import('../providers/registry.mjs'));
+      const r = await pickProviderModel(ctx, registry, { pickProvider: true, includeDefault: true, includeSwitch: false });
+      if (!r || r.model == null) return 'agent edit: cancelled';
+      const patched = agentsMod.patchAgent(aname, { provider: r.provider, model: r.model || '' }, ctx.cfgDir);
+      return `✓ ${patched.name} → ${patched.provider}${patched.model ? '/' + patched.model : ''}`;
     }
     if (sub === 'remove' || sub === 'rm' || sub === 'delete') {
       if (!aname) return 'usage: /agent remove <name>';
+      if (typeof ctx.openPicker === 'function') {
+        const ok = await _promptConfirm(ctx, { title: `Remove agent "${aname}"?`, subtitle: 'This cannot be undone. Enter selects · Esc cancels' });
+        if (!ok) return `agent remove: cancelled — "${aname}" not removed`;
+      }
       agentsMod.removeAgent(aname, ctx.cfgDir);
       return `✓ removed agent ${aname}`;
     }
-    return `/agent: unknown sub "${sub}" — list|show|add|remove`;
+    return `/agent: unknown sub "${sub}" — list|show|add|edit|remove`;
   } catch (e) {
     return `/agent error: ${e?.message || e}`;
   }
 }
 
 async function _team(args, ctx) {
-  let teamsMod, loopMod;
+  let teamsMod, loopMod, agentsMod;
   try {
     teamsMod = await import('../teams.mjs');
     loopMod = await import('../loop-engine.mjs');
+    agentsMod = await import('../agents.mjs');
   } catch (e) { return `/team unavailable: ${e?.message || e}`; }
   let tokens;
   try { tokens = loopMod.splitArgs(args); }
@@ -784,6 +599,19 @@ async function _team(args, ctx) {
   const rest = tokens.slice(1);
   const tname = rest[0];
   try {
+    if (!sub && typeof ctx.openPicker === 'function') {
+      const picked = await ctx.openPicker({
+        kind: 'menu', title: 'Teams', subtitle: `${teamsMod.listTeams(ctx.cfgDir).length} registered`,
+        items: [
+          { id: 'list', label: 'List teams', desc: 'show all' },
+          { id: 'add', label: 'Add team…', desc: '/team add <name> --agents a,b --lead a' },
+          { id: 'show', label: 'Show team…', desc: 'print one record' },
+          { id: 'remove', label: 'Remove team…', desc: 'delete a team' },
+        ],
+      });
+      const pid = picked && typeof picked === 'object' ? picked.id : picked;
+      return _team(typeof pid === 'string' && pid ? pid : 'list', ctx);
+    }
     if (!sub || sub === 'list') {
       const teams = teamsMod.listTeams(ctx.cfgDir);
       if (teams.length === 0) return 'no teams registered. /team add <name> --agents a,b --lead a [--channel #x]';
@@ -793,14 +621,16 @@ async function _team(args, ctx) {
       }).join('\n');
     }
     if (sub === 'show') {
-      if (!tname) return 'usage: /team show <name>';
+      if (!tname) return 'usage: /team show <name> [json]';
       const t = teamsMod.getTeam(tname, ctx.cfgDir);
       if (!t) return `no team "${tname}"`;
-      return JSON.stringify(t, null, 2);
+      return rest[1] === 'json'
+        ? JSON.stringify(t, null, 2)
+        : renderRecord(t, { fields: ['name', 'displayName', 'lead', 'agents', 'slackChannel', 'createdAt', 'updatedAt'] });
     }
     if (sub === 'add') {
-      if (!tname) return 'usage: /team add <name> --agents a,b,c [--lead a] [--channel #x]';
       let agentsCsv = null, lead = null, channel = '';
+      let teamName = tname;
       for (let i = 1; i < rest.length; i++) {
         const t = rest[i];
         if (t === '--agents') agentsCsv = rest[++i] || '';
@@ -808,18 +638,51 @@ async function _team(args, ctx) {
         else if (t === '--channel') channel = rest[++i] || '';
         else return `/team error: unknown token "${t}"`;
       }
-      if (!agentsCsv) return '/team add: --agents is required';
-      const agentsList = teamsMod.parseListFlag(agentsCsv);
+      // Guided fill: no --agents + a modal available → name prompt, then a
+      // multi-pick over registered agents, then a lead pick. Typed form
+      // (--agents …) and the no-modal path are unchanged.
+      let agentsList;
+      if (!agentsCsv && typeof ctx.openPicker === 'function') {
+        if (!teamName) {
+          teamName = await _promptText(ctx, { title: 'New team — name', subtitle: 'short id (Esc cancels)' });
+          if (!teamName) return 'team add: cancelled';
+        }
+        const all = agentsMod ? agentsMod.listAgents(ctx.cfgDir).map((a) => a.name) : [];
+        if (!all.length) return 'team add: no agents registered yet — add one with /agent add first';
+        const chosen = [];
+        for (let guard = 0; guard < 50; guard++) {
+          const items = all.filter((n) => !chosen.includes(n)).map((n) => ({ id: n, label: n }));
+          if (chosen.length) items.unshift({ id: '__done__', label: `✓ done (${chosen.length} selected)`, pinned: true });
+          if (!items.length) break;
+          const p = await ctx.openPicker({ kind: 'menu', title: `Team agents — ${chosen.length} picked`, subtitle: 'pick agents one at a time · ✓ done to finish · Esc cancels', items });
+          const id = p && typeof p === 'object' ? p.id : p;
+          if (!id) { if (chosen.length) break; return 'team add: cancelled'; }
+          if (id === '__done__') break;
+          chosen.push(id);
+        }
+        if (!chosen.length) return 'team add: cancelled (no agents picked)';
+        const lp = await ctx.openPicker({ kind: 'menu', title: 'Team lead', subtitle: 'who leads this team?', items: chosen.map((n) => ({ id: n, label: n })) });
+        lead = (lp && typeof lp === 'object' ? lp.id : lp) || chosen[0];
+        agentsList = chosen;
+      } else {
+        if (!teamName) return 'usage: /team add <name> --agents a,b,c [--lead a] [--channel #x]';
+        if (!agentsCsv) return '/team add: --agents is required';
+        agentsList = teamsMod.parseListFlag(agentsCsv);
+      }
       const ch = channel ? await teamsMod.resolveSlackChannel(channel, {
         botToken: process.env.SLACK_BOT_TOKEN || null,
         apiBase: process.env.SLACK_API_BASE || 'https://slack.com/api',
         logger: () => {},
       }) : '';
-      const team = teamsMod.registerTeam({ name: tname, agents: agentsList, lead, slackChannel: ch }, ctx.cfgDir);
+      const team = teamsMod.registerTeam({ name: teamName, agents: agentsList, lead, slackChannel: ch }, ctx.cfgDir);
       return `✓ added team ${team.name} (lead=${team.lead}, agents=${team.agents.join(',')})`;
     }
     if (sub === 'remove' || sub === 'rm' || sub === 'delete') {
       if (!tname) return 'usage: /team remove <name>';
+      if (typeof ctx.openPicker === 'function') {
+        const ok = await _promptConfirm(ctx, { title: `Remove team "${tname}"?`, subtitle: 'This cannot be undone. Enter selects · Esc cancels' });
+        if (!ok) return `team remove: cancelled — "${tname}" not removed`;
+      }
       teamsMod.removeTeam(tname, ctx.cfgDir);
       return `✓ removed team ${tname}`;
     }
@@ -945,6 +808,22 @@ async function _goal(args, ctx) {
     sessionsMod = await _mod(ctx, 'sessionsMod', () => import('../sessions.mjs'));
   } catch (e) { return `/goal unavailable: ${e?.message || e}`; }
   if (!args) {
+    if (typeof ctx.openPicker === 'function') {
+      const active = goalsMod.listGoals(ctx.cfgDir).filter((g) => g.status === 'active');
+      const picked = await ctx.openPicker({
+        kind: 'menu', title: 'Goals', subtitle: `${active.length} active`,
+        items: [
+          { id: 'list', label: 'List goals', desc: 'show all' },
+          { id: 'add', label: 'Add goal…', desc: '/goal add <name> [--desc] [--cron]' },
+          { id: 'show', label: 'Show goal…', desc: 'print one record' },
+          { id: 'close', label: 'Close goal…', desc: 'mark done/abandoned' },
+          ...active.map((g) => ({ id: g.name, label: `↪ switch: ${g.name}`, desc: g.description || '' })),
+        ],
+      });
+      const pid = picked && typeof picked === 'object' ? picked.id : picked;
+      if (pid && typeof pid === 'string') return _goal(pid, ctx);
+      // cancelled → fall through to the text list below
+    }
     const items = goalsMod.listGoals(ctx.cfgDir).filter((g) => g.status === 'active');
     if (!items.length) return 'no active goals';
     return items.map((g) =>
@@ -967,6 +846,30 @@ async function _goal(args, ctx) {
       else if (!name) name = t;
       else return `goal error: unexpected arg "${t}"`;
     }
+    // Guided fill: no name + a modal available → prompt name + desc, and offer
+    // a cron preset picker instead of a hand-typed spec. Typed form unchanged.
+    if (!name && typeof ctx.openPicker === 'function') {
+      name = await _promptText(ctx, { title: 'New goal — name', subtitle: 'short id (Esc cancels)' });
+      if (!name) return 'goal add: cancelled';
+      if (!desc) {
+        const d = await _promptText(ctx, { title: `Goal "${name}" — description`, subtitle: 'what is this goal? (Esc to skip)', allowEmpty: true });
+        desc = d || '';
+      }
+      if (!cron) {
+        const cp = await ctx.openPicker({
+          kind: 'menu', title: 'Schedule (optional)', subtitle: 'run this goal on a cron?',
+          items: [
+            { id: '', label: 'none', desc: 'no schedule' },
+            { id: '0 9 * * *', label: 'daily 09:00', desc: '0 9 * * *' },
+            { id: '0 * * * *', label: 'hourly', desc: '0 * * * *' },
+            { id: '0 9 * * 1', label: 'weekly (Mon 09:00)', desc: '0 9 * * 1' },
+            { id: '__custom__', label: 'custom…', desc: 'type a cron spec', freeText: true },
+          ],
+        });
+        if (cp && typeof cp === 'object' && cp.id === '__custom__') cron = String(cp.query || '').trim() || null;
+        else { const cid = cp && typeof cp === 'object' ? cp.id : cp; cron = cid && typeof cid === 'string' ? cid : null; }
+      }
+    }
     if (!name) return 'usage: /goal add <name> [--desc "..."] [--cron "<spec>"]';
     try {
       const g = goalsMod.registerGoal({ name, description: desc, schedule: cron }, ctx.cfgDir);
@@ -993,10 +896,12 @@ async function _goal(args, ctx) {
   if (sub === 'list') return JSON.stringify(goalsMod.listGoals(ctx.cfgDir), null, 2);
   if (sub === 'show') {
     const name = rest[0];
-    if (!name) return 'usage: /goal show <name>';
+    if (!name) return 'usage: /goal show <name> [json]';
     const g = goalsMod.getGoal(name, ctx.cfgDir);
     if (!g) return `no goal "${name}"`;
-    return JSON.stringify(g, null, 2);
+    return rest[1] === 'json'
+      ? JSON.stringify(g, null, 2)
+      : renderRecord(g, { fields: ['name', 'status', 'description', 'schedule', 'channels', 'createdAt', 'memoryPath'] });
   }
   if (sub === 'close') {
     const name = rest[0];
@@ -1014,7 +919,7 @@ async function _goal(args, ctx) {
           if (removed) detachNote = ' (cron detached)';
         } catch { /* best-effort */ }
       }
-      return `✓ goal ${g.name} closed (status: ${g.status})${detachNote}`;
+      return `✓ goal ${g.name} closed (status: ${g.status})${detachNote} — start a fresh goal with /goal add ${g.name} --desc "..."`;
     } catch (e) { return `goal error: ${e?.message || e}`; }
   }
   // single-arg branch: switch
@@ -1116,17 +1021,37 @@ async function _personality(args, ctx) {
     return fs.readFileSync(p, 'utf8');
   }
   if (sub === 'install') {
-    if (!a || !b) return 'usage: /personality install <name> <file.md>';
-    const dst = path.join(dir, `${a}.md`);
-    if (fs.existsSync(dst)) return `personality already installed: ${a}`;
-    if (!fs.existsSync(b)) return `source file not found: ${b}`;
-    fs.writeFileSync(dst, fs.readFileSync(b, 'utf8'));
-    return `installed ${a}`;
+    let nm = a, src = b;
+    // Guided fill: missing name/file + a modal → prompt for them, and retry on
+    // a bad path instead of erroring out (up to a few attempts).
+    if ((!nm || !src) && typeof ctx.openPicker === 'function') {
+      if (!nm) {
+        nm = await _promptText(ctx, { title: 'Install personality — name', subtitle: 'short id to install it as (Esc cancels)' });
+        if (!nm) return 'personality install: cancelled';
+      }
+      if (fs.existsSync(path.join(dir, `${nm}.md`))) return `personality already installed: ${nm}`;
+      for (let attempt = 0; attempt < 3 && !src; attempt++) {
+        const p = await _promptText(ctx, { title: `Source file for ${nm}`, subtitle: attempt ? 'not found — try again (Esc cancels)' : 'path to a .md file (Esc cancels)' });
+        if (!p) return 'personality install: cancelled';
+        if (fs.existsSync(p)) { src = p; break; }
+      }
+      if (!src) return 'personality install: source file not found after 3 tries';
+    }
+    if (!nm || !src) return 'usage: /personality install <name> <file.md>';
+    const dst = path.join(dir, `${nm}.md`);
+    if (fs.existsSync(dst)) return `personality already installed: ${nm}`;
+    if (!fs.existsSync(src)) return `source file not found: ${src}`;
+    fs.writeFileSync(dst, fs.readFileSync(src, 'utf8'));
+    return `installed ${nm}`;
   }
   if (sub === 'remove' || sub === 'rm' || sub === 'delete') {
     if (!a) return 'usage: /personality remove <name>';
     const p = path.join(dir, `${a}.md`);
     if (!fs.existsSync(p)) return `personality not installed: ${a}`;
+    if (typeof ctx.openPicker === 'function') {
+      const ok = await _promptConfirm(ctx, { title: `Remove personality "${a}"?`, subtitle: 'This cannot be undone. Enter selects · Esc cancels' });
+      if (!ok) return `personality remove: cancelled — "${a}" not removed`;
+    }
     fs.unlinkSync(p);
     return `removed ${a}`;
   }
@@ -1168,18 +1093,37 @@ async function _task(args, ctx, write) {
   const id = tokens[1];
 
   try {
+    if (!sub && typeof ctx.openPicker === 'function') {
+      const picked = await ctx.openPicker({
+        kind: 'menu', title: 'Tasks', subtitle: `${tasksMod.listTasks(ctx.cfgDir).length} task(s)`,
+        items: [
+          { id: 'list', label: 'List tasks', desc: 'show all' },
+          { id: 'start', label: 'Start task…', desc: 'open a new multi-agent task' },
+          { id: 'tick', label: 'Tick task…', desc: 'one router turn' },
+          { id: 'show', label: 'Show task…', desc: 'print a record' },
+          { id: 'transcript', label: 'Transcript…', desc: 'dump turns' },
+          { id: 'done', label: 'Mark done…', desc: 'close a task' },
+          { id: 'abandon', label: 'Abandon…', desc: 'abandon a task' },
+          { id: 'remove', label: 'Remove…', desc: 'delete a task' },
+        ],
+      });
+      const pid = picked && typeof picked === 'object' ? picked.id : picked;
+      return _task(typeof pid === 'string' && pid ? pid : 'list', ctx, write);
+    }
     if (!sub || sub === 'list') {
       const items = tasksMod.listTasks(ctx.cfgDir);
-      if (!items.length) return 'no tasks. `lazyclaw task start --team ... --title ...` from the shell to create one.';
+      if (!items.length) return 'no tasks yet. /task start <team> --title "..." to create one.';
       return items.map((t) =>
         `• ${t.id} [${t.status || 'unknown'}] ${t.title || '(no title)'}${t.team ? ` — team=${t.team}` : ''}${t.lead ? ` — lead=${t.lead}` : ''}`
       ).join('\n');
     }
     if (sub === 'show') {
-      if (!id) return 'usage: /task show <id>';
+      if (!id) return 'usage: /task show <id> [json]';
       const t = tasksMod.getTask(id, ctx.cfgDir);
       if (!t) return `no task "${id}"`;
-      return JSON.stringify(t, null, 2);
+      return tokens[2] === 'json'
+        ? JSON.stringify(t, null, 2)
+        : renderRecord(t, { fields: ['id', 'status', 'title', 'description', 'team', 'lead', 'slackChannel', 'createdAt', 'updatedAt'] });
     }
     if (sub === 'transcript') {
       if (!id) return 'usage: /task transcript <id> [text|md|json]';
@@ -1218,6 +1162,10 @@ async function _task(args, ctx, write) {
     }
     if (sub === 'remove' || sub === 'rm' || sub === 'delete') {
       if (!id) return 'usage: /task remove <id>';
+      if (typeof ctx.openPicker === 'function') {
+        const ok = await _promptConfirm(ctx, { title: `Remove task ${id}?`, subtitle: 'This cannot be undone. Enter selects · Esc cancels' });
+        if (!ok) return `task remove: cancelled — ${id} not removed`;
+      }
       tasksMod.removeTask(id, ctx.cfgDir);
       return `✓ removed task ${id}`;
     }
@@ -1234,6 +1182,25 @@ async function _task(args, ctx, write) {
         else if (t === '--lead') lead = rest[++i] || null;
         else if (!teamName && !t.startsWith('--')) teamName = t;
       }
+      // Guided fill: missing team/title + a modal available → pick the team
+      // from the registry and prompt for a title. Typed form unchanged.
+      if ((!teamName || !title) && typeof ctx.openPicker === 'function') {
+        if (!teamName) {
+          const teams = teamsMod.listTeams(ctx.cfgDir);
+          if (!teams.length) return 'task start: no teams yet — create one with /team add first';
+          const tp = await ctx.openPicker({ kind: 'menu', title: 'Start task — pick a team', items: teams.map((t) => ({ id: t.name, label: t.name, desc: `lead=${t.lead || '?'} · agents=${(t.agents || []).join(',')}` })) });
+          teamName = tp && typeof tp === 'object' ? tp.id : tp;
+          if (!teamName || typeof teamName !== 'string') return 'task start: cancelled';
+        }
+        if (!title) {
+          title = await _promptText(ctx, { title: `Task title (team: ${teamName})`, subtitle: 'one line describing the task (Esc cancels)' });
+          if (!title) return 'task start: cancelled';
+        }
+        if (!description) {
+          const d = await _promptText(ctx, { title: 'Task description', subtitle: 'optional detail (Esc to skip)', allowEmpty: true });
+          description = d || '';
+        }
+      }
       if (!teamName || !title) return 'usage: /task start <team> --title "..." [--description "..."] [--lead <name>]';
       const team = teamsMod.getTeam(teamName, ctx.cfgDir);
       if (!team) return `no team "${teamName}"`;
@@ -1292,6 +1259,9 @@ async function _task(args, ctx, write) {
       const userMsg = tokens.slice(2).join(' ').trim();
       try {
         if (typeof write === 'function') { try { write('  ↻ running task turn…\n'); } catch {} }
+        // Default-on isolation: confine every tool the team runs. Lazy-imported
+        // so the sandbox backends stay off the chat module-load path.
+        const { defaultSandboxSpec } = await import('../sandbox/index.mjs');
         const result = await router.runTaskTurn({
           task, team, agentsById,
           userMessage: userMsg || undefined,
@@ -1300,6 +1270,7 @@ async function _task(args, ctx, write) {
           logger: (line) => { if (typeof write === 'function') { try { write(line); } catch {} } },
           approve: _makeInkApprove(ctx),
           security: ctx.cfg?.security,
+          sandbox: defaultSandboxSpec(ctx.cfg, { cwd: process.cwd(), configDir: ctx.cfgDir }),
         });
         return `✓ task ${result.task.id} → ${result.task.status} (${result.iterations} agent turn(s)${result.stoppedBy ? `, stopped by ${result.stoppedBy}` : ''})`;
       } catch (e) {
@@ -1312,335 +1283,15 @@ async function _task(args, ctx, write) {
   }
 }
 
-async function _trainer(args, ctx) {
-  const registry = await _mod(ctx, 'registryMod', () => import('../providers/registry.mjs'));
-  const tokens = splitWhitespace(args);
-  const sub = tokens[0] || 'show';
-
-  if (sub === 'show') {
-    let effective = { provider: ctx.getActiveProvName ? ctx.getActiveProvName() : null,
-                      model: ctx.getActiveModel ? ctx.getActiveModel() : null };
-    try {
-      if (typeof registry.resolveTrainer === 'function') {
-        effective = registry.resolveTrainer(ctx.cfg || {});
-      }
-    } catch { /* fall through */ }
-    const configured = (ctx.cfg && ctx.cfg.trainer) || null;
-    const cfgRender = configured
-      ? JSON.stringify(configured, null, 2)
-      : '(unset — trainer mirrors the chat provider/model)';
-    return [
-      'trainer (effective):',
-      `  provider: ${effective.provider}`,
-      `  model:    ${effective.model || '(default)'}`,
-      'trainer (configured):',
-      cfgRender,
-    ].join('\n');
-  }
-
-  if (sub === 'set') {
-    const spec = tokens[1];
-    if (!spec) return 'usage: /trainer set <provider>[:<model>]  (or `auto` for orchestrator-managed)';
-    const parsed = typeof registry.parseProviderModel === 'function'
-      ? registry.parseProviderModel(spec)
-      : { provider: spec.split(':')[0], model: spec.split(':')[1] || null };
-    if (!parsed || !parsed.provider) return `/trainer set: could not parse "${spec}"`;
-    if (parsed.provider !== 'auto') {
-      const next = _providerLookup(registry, parsed.provider);
-      if (!next) return `/trainer set: unknown provider "${parsed.provider}"`;
-    }
-    // Optional `--fallback <provider[:model]>` — resolveTrainer routes here
-    // when opts.useFallback is set. Validate before persisting.
-    let fallbackSpec = null;
-    const fi = tokens.indexOf('--fallback');
-    if (fi >= 0) {
-      fallbackSpec = tokens[fi + 1];
-      if (!fallbackSpec) return 'usage: /trainer set <p:m> --fallback <p:m>';
-      const fp = _parseProvModel(registry, fallbackSpec);
-      if (!fp.provider) return `/trainer set: could not parse fallback "${fallbackSpec}"`;
-      if (fp.provider !== 'auto' && !_providerLookup(registry, fp.provider)) {
-        return `/trainer set: unknown provider "${fp.provider}"`;
-      }
-    }
-    // Read-merge-write so unrelated cfg keys survive.
-    const fs = await import('node:fs');
-    const path = await import('node:path');
-    const cfgPath = path.join(ctx.cfgDir, 'config.json');
-    let diskCfg = {};
-    try { diskCfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8')); } catch { /* fresh */ }
-    diskCfg.trainer = { ...(diskCfg.trainer || {}), provider: parsed.provider };
-    if (parsed.model) diskCfg.trainer.model = parsed.model;
-    else delete diskCfg.trainer.model;
-    if (fallbackSpec) diskCfg.trainer.fallback = fallbackSpec;
-    try { fs.mkdirSync(ctx.cfgDir, { recursive: true }); } catch {}
-    fs.writeFileSync(cfgPath, JSON.stringify(diskCfg, null, 2));
-    if (ctx.cfg) ctx.cfg.trainer = { ...diskCfg.trainer };
-    return `✓ trainer → ${parsed.provider}${parsed.model ? ':' + parsed.model : ''}${fallbackSpec ? ` (fallback: ${fallbackSpec})` : ''}`;
-  }
-
-  if (sub === 'fallback') {
-    const spec = tokens[1];
-    if (!spec) return 'usage: /trainer fallback <provider>[:<model>]  |  clear';
-    const fs = await import('node:fs');
-    const path = await import('node:path');
-    const cfgPath = path.join(ctx.cfgDir, 'config.json');
-    let diskCfg = {};
-    try { diskCfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8')); } catch { /* fresh */ }
-    if (spec === 'clear' || spec === 'unset') {
-      if (diskCfg.trainer) delete diskCfg.trainer.fallback;
-      try { fs.mkdirSync(ctx.cfgDir, { recursive: true }); } catch {}
-      fs.writeFileSync(cfgPath, JSON.stringify(diskCfg, null, 2));
-      if (ctx.cfg && ctx.cfg.trainer) delete ctx.cfg.trainer.fallback;
-      return '✓ trainer fallback cleared';
-    }
-    const fp = _parseProvModel(registry, spec);
-    if (!fp.provider) return `/trainer fallback: could not parse "${spec}"`;
-    if (fp.provider !== 'auto' && !_providerLookup(registry, fp.provider)) {
-      return `/trainer fallback: unknown provider "${fp.provider}"`;
-    }
-    diskCfg.trainer = { ...(diskCfg.trainer || {}), fallback: spec };
-    try { fs.mkdirSync(ctx.cfgDir, { recursive: true }); } catch {}
-    fs.writeFileSync(cfgPath, JSON.stringify(diskCfg, null, 2));
-    if (ctx.cfg) ctx.cfg.trainer = { ...diskCfg.trainer };
-    return `✓ trainer fallback → ${spec}`;
-  }
-
-  if (sub === 'clear' || sub === 'unset') {
-    const fs = await import('node:fs');
-    const path = await import('node:path');
-    const cfgPath = path.join(ctx.cfgDir, 'config.json');
-    let diskCfg = {};
-    try { diskCfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8')); } catch { /* fresh */ }
-    delete diskCfg.trainer;
-    try { fs.mkdirSync(ctx.cfgDir, { recursive: true }); } catch {}
-    fs.writeFileSync(cfgPath, JSON.stringify(diskCfg, null, 2));
-    if (ctx.cfg) delete ctx.cfg.trainer;
-    return '✓ trainer cleared (will mirror chat provider/model)';
-  }
-
-  return `/trainer: unknown sub "${sub}" — show|set <p:m>|clear`;
-}
-
-// /dashboard — open the lazyclaw web UI.
-//
-// v5.4.4 ROOT-CAUSE FIX (was: rapid repeated /dashboard within one chat
-// session spawned 20+ daemon children).
-//
-// Original implementation:
-//   probe /healthz → if !200, spawn detached `lazyclaw dashboard
-//   --no-open` and poll for up to 3s.
-//
-// Failure mode that produced the 20+ spawn pile-up:
-//   1. User types /dashboard. probe fails (no daemon). Spawn child A.
-//   2. Child A begins binding port 19600. Takes ~500ms-2s to be ready.
-//   3. User types /dashboard again BEFORE A is ready. probe still fails.
-//      Spawn child B. Child B sees EADDRINUSE and calls _killPortOccupant
-//      (cli.mjs:3611) which SIGTERMs child A. B takes over.
-//   4. Repeat. Each /dashboard kills the previous daemon and starts a
-//      new one. With autorepeat / many slash calls this stacks fast.
-//
-// Two-layer guard:
-//   - A module-level _dashboardSpawning latch refuses concurrent spawn
-//     attempts. While a spawn is in flight, /dashboard says so + returns
-//     without firing another child.
-//   - A _dashboardChildPid cache remembers the PID we already spawned;
-//     subsequent calls check kill(pid, 0) to confirm the child is alive
-//     and just open the browser without spawning.
-//
-// We probe both /healthz (HTTP) AND a raw net.connect port check so a
-// slow-starting daemon (binding the listener but not yet answering HTTP)
-// still counts as "running".
-let _dashboardSpawning = false;
-let _dashboardChildPid = null;
-
-function _portIsListening(port, timeoutMs = 200) {
-  return new Promise((resolve) => {
-    import('node:net').then(({ createConnection }) => {
-      let settled = false;
-      const sock = createConnection({ host: '127.0.0.1', port });
-      const done = (ok) => {
-        if (settled) return;
-        settled = true;
-        try { sock.destroy(); } catch {}
-        resolve(ok);
-      };
-      sock.once('connect', () => done(true));
-      sock.once('error', () => done(false));
-      setTimeout(() => done(false), timeoutMs);
-    }).catch(() => resolve(false));
-  });
-}
-
-async function _dashboardProbe(port) {
-  // Fast path — port-level probe. Catches a daemon that has bound the
-  // socket but hasn't finished initializing its HTTP routes.
-  if (await _portIsListening(port, 200)) return true;
-  // Slow path — full /healthz fetch, for defense in depth.
-  if (typeof fetch !== 'function') return false;
-  try {
-    const ac = new AbortController();
-    const t = setTimeout(() => ac.abort(), 250);
-    const r = await fetch(`http://127.0.0.1:${port}/healthz`, { signal: ac.signal });
-    clearTimeout(t);
-    return !!(r && r.ok);
-  } catch { return false; }
-}
-
-function _openBrowser(url) {
-  return import('node:child_process').then(({ spawn }) => {
-    let cmd, args;
-    if (process.platform === 'darwin')      { cmd = 'open';     args = [url]; }
-    else if (process.platform === 'win32')  { cmd = 'cmd';      args = ['/c', 'start', '""', url]; }
-    else                                    { cmd = 'xdg-open'; args = [url]; }
-    try { spawn(cmd, args, { stdio: 'ignore', detached: true }).unref(); } catch { /* swallow */ }
-  });
-}
-
-async function _dashboardStop(port) {
-  // Best-effort kill of every lazyclaw dashboard daemon on the box.
-  // Used to clean up after the v5.4.3 spawn pile-up bug.
-  if (process.platform === 'win32') {
-    return 'dashboard stop: not implemented on Windows yet — kill via Task Manager';
-  }
-  const { spawn } = await import('node:child_process');
-  // Step 1: lsof the port and SIGTERM each PID.
-  const portPids = await new Promise((resolve) => {
-    try {
-      const lsof = spawn('lsof', ['-ti', `tcp:${port}`], { stdio: ['ignore', 'pipe', 'ignore'] });
-      let buf = '';
-      lsof.stdout.on('data', (d) => { buf += d.toString('utf8'); });
-      lsof.on('error', () => resolve([]));
-      lsof.on('close', () => resolve(
-        buf.trim().split(/\s+/).map((s) => parseInt(s, 10)).filter(Number.isFinite)
-      ));
-    } catch { resolve([]); }
-  });
-  for (const pid of portPids) {
-    try { process.kill(pid, 'SIGTERM'); } catch { /* gone */ }
-  }
-  // Step 2: pkill any process whose command line includes "lazyclaw dashboard"
-  // — catches detached children that bound a different (random) port via
-  // cmdDashboard's EADDRINUSE fallback.
-  let pkilled = 0;
-  try {
-    const pkill = spawn('pkill', ['-f', 'lazyclaw dashboard'], { stdio: ['ignore', 'ignore', 'ignore'] });
-    pkilled = await new Promise((r) => pkill.on('close', (code) => r(code === 0 ? 1 : 0)));
-  } catch { /* fine */ }
-  _dashboardChildPid = null;
-  return `✓ stopped ${portPids.length} listener(s) on :${port}${pkilled ? ' + remaining `lazyclaw dashboard` processes via pkill' : ''}`;
-}
-
-// Parse the daemon's "listening at <url>" stdout line so /dashboard opens the
-// actually-bound port (the child may fall back to a random port on EADDRINUSE).
-export function parseDashboardUrl(text) {
-  const m = String(text || '').match(/listening at\s+(https?:\/\/\S+)/i);
-  return m ? m[1] : null;
-}
-
-// Resolve the daemon's real URL from its stdout within `timeoutMs`, or null.
-function _waitForDashboardUrl(child, timeoutMs) {
-  return new Promise((resolve) => {
-    if (!child || !child.stdout) { resolve(null); return; }
-    let buf = '';
-    let done = false;
-    const finish = (v) => {
-      if (done) return;
-      done = true;
-      try { child.stdout.off('data', onData); } catch { /* ignore */ }
-      resolve(v);
-    };
-    const onData = (d) => {
-      buf += d.toString('utf8');
-      const u = parseDashboardUrl(buf);
-      if (u) finish(u);
-    };
-    child.stdout.on('data', onData);
-    setTimeout(() => finish(null), timeoutMs);
-  });
-}
-
-async function _dashboard(args) {
-  const port = 19600;
-  const url = `http://127.0.0.1:${port}/dashboard`;
-  // Under the node:test runner, never launch a real daemon or open a browser
-  // (it leaked a background daemon + opened a tab on every test run).
-  if (process.env.NODE_TEST_CONTEXT) return `dashboard: ${url} (spawn skipped under test)`;
-  const sub = splitWhitespace(args)[0];
-  if (sub === 'stop' || sub === 'kill') return _dashboardStop(port);
-
-  // 1. Already running anywhere on the machine? → reuse.
-  if (await _dashboardProbe(port)) {
-    await _openBrowser(url);
-    return `✓ dashboard already running — opened ${url}`;
-  }
-
-  // 2. We spawned in this chat — is that child still alive?
-  if (_dashboardChildPid != null) {
-    try {
-      process.kill(_dashboardChildPid, 0); // signal 0 = liveness probe
-      // Child alive but not answering yet. Don't re-spawn; just nudge.
-      await _openBrowser(url);
-      return `✓ dashboard starting (pid ${_dashboardChildPid}) — opened ${url}`;
-    } catch {
-      _dashboardChildPid = null; // child died; fall through and respawn.
-    }
-  }
-
-  // 3. Spawn already in flight from a concurrent /dashboard? Don't pile on.
-  if (_dashboardSpawning) {
-    await _openBrowser(url);
-    return `dashboard is still booting — opened ${url}; try again in a moment if it didn't load`;
-  }
-
-  // 4. Cold start. Spawn ONE detached child, poll up to 3s, latch the
-  //    spawn flag in a finally so it always clears.
-  _dashboardSpawning = true;
-  try {
-    const { spawn } = await import('node:child_process');
-    let child;
-    try {
-      // Pass --port so the child tries 19600 first; pipe stdout so we can read
-      // the real bound URL (it may fall back to a random port on EADDRINUSE).
-      child = spawn(process.execPath, [process.argv[1], 'dashboard', '--port', String(port), '--no-open'], {
-        detached: true, stdio: ['ignore', 'pipe', 'ignore'], cwd: process.cwd(), env: process.env,
-      });
-      _dashboardChildPid = child.pid;
-    } catch (e) {
-      return `dashboard error: failed to spawn — ${e?.message || e}`;
-    }
-    // Prefer the daemon's own "listening at <url>" line — it carries the
-    // actual port even after a random-port fallback.
-    const boundUrl = await _waitForDashboardUrl(child, 3000);
-    // Release the captured stdout pipe so the detached daemon doesn't keep
-    // OUR event loop alive (unref, not destroy — destroying would EPIPE the
-    // daemon on its next stdout write). Then unref the child itself.
-    try { if (child.stdout) { child.stdout.removeAllListeners('data'); child.stdout.unref(); } } catch { /* ignore */ }
-    child.unref();
-    if (boundUrl) {
-      await _openBrowser(boundUrl);
-      return `✓ started dashboard (pid ${child.pid}) — opened ${boundUrl}`;
-    }
-    // Fallback: the line never arrived — poll the default port best-effort.
-    const start = Date.now();
-    while (Date.now() - start < 1500) {
-      if (await _dashboardProbe(port)) {
-        await _openBrowser(url);
-        return `✓ started dashboard (pid ${child.pid}) — opened ${url}`;
-      }
-      await new Promise((r) => setTimeout(r, 150));
-    }
-    return `⚠ dashboard didn't come up within 3s (pid ${child.pid}). URL: ${url}`;
-  } finally {
-    _dashboardSpawning = false;
-  }
-}
+// /trainer — moved to ./slash_trainer.mjs (Group 4) so the set/fallback/show/
+// clear branches can grow off this file's size ratchet.
 
 // /menu — in-chat command palette over the full subcommand catalog. The
 // no-arg launcher menu used to be the home screen; defaulting to chat hid it
 // behind `lazyclaw menu`. This restores discoverability: browse subcommands
 // and get the exact command to run. (Most subcommands own stdout / spawn, so
 // they can't safely run inline in the Ink scrollback — we echo the command.)
-async function _menu(args, ctx) {
+async function _menu(args, ctx, write) {
   if (typeof ctx.openPicker === 'function') {
     const items = [];
     const seen = new Set();
@@ -1648,17 +1299,23 @@ async function _menu(args, ctx) {
       for (const c of cmds) {
         if (seen.has(c)) continue;
         seen.add(c);
-        items.push({ id: c, label: c, desc: group });
+        // Mark which subcommands can run in-chat (a /slash equivalent exists).
+        const inChat = SLASH_HANDLERS.has(`/${c}`);
+        items.push({ id: c, label: c, desc: inChat ? `${group} · runs in chat` : group });
       }
     }
     const picked = await ctx.openPicker({
       kind: 'menu',
       title: 'lazyclaw subcommands',
-      subtitle: 'Enter shows how to run it · Esc cancels',
+      subtitle: 'Enter runs it in chat (or shows the shell command) · Esc cancels',
       items,
     });
     if (!picked) return 'cancelled';
     const cmd = typeof picked === 'string' ? picked : picked.id;
+    // If there's an in-chat slash equivalent, dispatch it directly instead of
+    // telling the user to leave chat.
+    const handler = SLASH_HANDLERS.get(`/${cmd}`);
+    if (handler) return handler('', ctx, write);
     return `run from a shell:  lazyclaw ${cmd}`;
   }
   return [
@@ -1668,117 +1325,18 @@ 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>]';
+// /orchestrator — moved to ./orchestrator_flow.mjs (orchestratorSlash) so the
+// interactive fetch+pick planner/worker editor can grow off the ratchet.
+// /channels + /context — moved to ./slash_channels.mjs (Group 3) so they can
+// grow off this file's size ratchet.
+
+// /agentic + /plan live in ./chat_mode_slash.mjs (Group 1) — kept out of this
+// file (at its size ratchet) so the toggles can grow there. Register their
+// catalog rows in the shared SLASH_COMMANDS so /help, the popup,
+// ghost-autocomplete, and the d6 drift-guard see them (idempotent — ESM runs
+// module init once; appended per the catalog's ordering note).
+for (const entry of CHAT_MODE_SLASH_COMMANDS) {
+  if (!SLASH_COMMANDS.some((c) => c.cmd === entry.cmd)) SLASH_COMMANDS.push(entry);
 }
 
 // ─── dispatch table ──────────────────────────────────────────────────────
@@ -1792,6 +1350,10 @@ export const SLASH_HANDLERS = new Map([
   ['/reset', _newReset],
   ['/clear', _newReset],
   ['/provider', _provider],
+  ['/login', (a, ctx) => loginSlash(a, ctx, { promptText: _promptText })],
+  ['/hud', hudSlash],
+  ['/agentic', agenticSlash],
+  ['/plan', planSlash],
   ['/model', _model],
   ['/skill', _skill],
   ['/skills', _skillsList],
@@ -1810,7 +1372,7 @@ export const SLASH_HANDLERS = new Map([
   ['/dashboard', _dashboard],
   ['/menu', _menu],
   ['/channels', _channels],
-  ['/orchestrator', _orchestrator],
+  ['/orchestrator', orchestratorSlash],
   ['/context', _context],
   // /setup — full wizard (every step); /config — pick ONE setting to change
   // (in-chat where possible; credential steps unmount, run, re-enter chat).
@@ -1827,6 +1389,9 @@ export const SLASH_HANDLERS = new Map([
  */
 export async function dispatchSlash(cmd, args, ctx, write) {
   const handler = SLASH_HANDLERS.get(cmd);
-  if (!handler) return `unknown slash command: ${cmd} (try /help)`;
+  if (!handler) {
+    const hint = nearest(cmd, [...SLASH_HANDLERS.keys()]);
+    return `unknown slash command: ${cmd}${hint ? ` — did you mean ${hint}?` : ''} (try /help)`;
+  }
   return handler(args || '', ctx || {}, write);
 }