lazyclaw 6.3.1 → 6.4.0

package/tui/slash_dispatcher.mjs

@@ -26,16 +26,25 @@
 //     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';
@@ -156,77 +165,18 @@ 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 } = {}) {
+async function _promptText(ctx, { title, subtitle, allowEmpty, secret } = {}) {
   if (typeof ctx.openPicker !== 'function') return null;
   const picked = await ctx.openPicker({
     kind: 'text',
     title,
+    // `secret` masks the typed query on screen (api-key / token entry) while
+    // the real value still reaches the caller — the modal picker honors it.
+    secret: !!secret,
     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 }],
   });
@@ -259,7 +209,7 @@ async function _promptConfirm(ctx, { title, subtitle } = {}) {
 // 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 +260,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 +278,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 +315,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,
-    });
-  }
-  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;
+  // 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}`;
   }
-  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 +373,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 +432,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 +491,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 +566,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 +589,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 +654,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 +676,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 +693,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 +863,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 +901,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 +951,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 +974,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 +1076,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 +1148,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 +1217,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 +1237,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 +1314,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 +1325,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) {
@@ -1315,6 +1341,35 @@ 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);
+
+  // Bare /trainer with a modal available → an action menu (mirrors the bare
+  // /orchestrator menu). "Set"/"Fallback" re-enter and drill the shared
+  // provider→model picker; "Clear"/"Show" run their subcommands. Typed forms
+  // (/trainer set <p:m>, etc.) still work and skip the menu.
+  if (tokens.length === 0 && typeof ctx.openPicker === 'function') {
+    let cur = '';
+    try {
+      if (typeof registry.resolveTrainer === 'function') {
+        const e = registry.resolveTrainer(ctx.cfg || {});
+        cur = `now: ${e.provider}${e.model ? ':' + e.model : ':(default)'}`;
+      }
+    } catch { /* show menu without the current hint */ }
+    const picked = await ctx.openPicker({
+      kind: 'menu',
+      title: 'Trainer — synthesis / learning model',
+      subtitle: cur || 'pick provider + model for trainer turns',
+      items: [
+        { id: 'set', label: 'Set trainer…', desc: 'pick provider + model (or auto / provider default)' },
+        { id: 'fallback', label: 'Set fallback…', desc: 'pick a fallback provider + model' },
+        { id: 'clear', label: 'Clear', desc: 'unset — mirror the chat provider/model' },
+        { id: 'show', label: 'Show', desc: 'print the effective + configured trainer' },
+      ],
+    });
+    const id = picked && typeof picked === 'object' ? picked.id : picked;
+    if (!id || typeof id !== 'string') return _trainer('show', ctx); // cancelled → show status
+    return _trainer(id, ctx); // re-enter; set/fallback open the picker (no spec)
+  }
+
   const sub = tokens[0] || 'show';
 
   if (sub === 'show') {
@@ -1327,7 +1382,7 @@ async function _trainer(args, ctx) {
     } catch { /* fall through */ }
     const configured = (ctx.cfg && ctx.cfg.trainer) || null;
     const cfgRender = configured
-      ? JSON.stringify(configured, null, 2)
+      ? renderRecord(configured, { fields: ['provider', 'model', 'fallback'] }).split('\n').map((l) => '  ' + l).join('\n')
       : '(unset — trainer mirrors the chat provider/model)';
     return [
       'trainer (effective):',
@@ -1339,7 +1394,16 @@ async function _trainer(args, ctx) {
   }
 
   if (sub === 'set') {
-    const spec = tokens[1];
+    let spec = tokens[1];
+    let _setFromPicker = false;
+    // No spec + a modal available → drill the shared picker (with an "auto"
+    // row and a "provider default" row) instead of requiring a typed spec.
+    if (!spec && typeof ctx.openPicker === 'function') {
+      const r = await pickProviderModel(ctx, registry, { includeAuto: true, includeDefault: true });
+      if (!r || r.model == null) return 'trainer set: cancelled';
+      spec = r.provider === 'auto' ? 'auto' : (r.model ? `${r.provider}:${r.model}` : r.provider);
+      _setFromPicker = true;
+    }
     if (!spec) return 'usage: /trainer set <provider>[:<model>]  (or `auto` for orchestrator-managed)';
     const parsed = typeof registry.parseProviderModel === 'function'
       ? registry.parseProviderModel(spec)
@@ -1362,6 +1426,17 @@ async function _trainer(args, ctx) {
         return `/trainer set: unknown provider "${fp.provider}"`;
       }
     }
+    // Picker-driven set with no --fallback flag → offer an optional fallback
+    // pick (the flag form stays the escape hatch for typed callers).
+    if (_setFromPicker && !fallbackSpec && typeof ctx.openPicker === 'function') {
+      const addFb = await _promptConfirm(ctx, { title: 'Add a fallback trainer?', subtitle: 'used when the primary is unavailable · Esc / deny to skip' });
+      if (addFb) {
+        const fr = await pickProviderModel(ctx, registry, { includeAuto: true, includeDefault: true });
+        if (fr && fr.model != null) {
+          fallbackSpec = fr.provider === 'auto' ? 'auto' : (fr.model ? `${fr.provider}:${fr.model}` : fr.provider);
+        }
+      }
+    }
     // Read-merge-write so unrelated cfg keys survive.
     const fs = await import('node:fs');
     const path = await import('node:path');
@@ -1379,7 +1454,12 @@ async function _trainer(args, ctx) {
   }
 
   if (sub === 'fallback') {
-    const spec = tokens[1];
+    let spec = tokens[1];
+    if (!spec && typeof ctx.openPicker === 'function') {
+      const r = await pickProviderModel(ctx, registry, { includeAuto: true, includeDefault: true });
+      if (!r || r.model == null) return 'trainer fallback: cancelled';
+      spec = r.provider === 'auto' ? 'auto' : (r.model ? `${r.provider}:${r.model}` : r.provider);
+    }
     if (!spec) return 'usage: /trainer fallback <provider>[:<model>]  |  clear';
     const fs = await import('node:fs');
     const path = await import('node:path');
@@ -1640,7 +1720,7 @@ async function _dashboard(args) {
 // 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 +1728,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 [
@@ -1676,7 +1762,86 @@ async function _channels(args, ctx = {}) {
   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);
+  const toks = (args || '').trim().split(/\s+/).filter(Boolean);
+  const [name, action] = toks;
+
+  // `/channels [<name>] setup` — set the channel's credentials (bot token,
+  // homeserver, …) from chat instead of redirecting to /config. Reuses the
+  // masked modal prompt (_promptText) so secrets are never echoed. No modal →
+  // fall back to the readline channel step (same as /config's channel item).
+  const wantSetup = toks.some((t) => /^setup$/i.test(t));
+  if (wantSetup) {
+    const channelMod = await import('../commands/setup_channels.mjs');
+    const picked = toks.find((t) => !/^setup$/i.test(t));
+    if (typeof ctx.openPicker !== 'function') {
+      // Readline path: hand off to the existing channel wizard step.
+      ctx.requestConfigStep = 'channel';
+      return 'EXIT';
+    }
+    let chName = picked && picked.toLowerCase();
+    if (!chName) {
+      const sel = await ctx.openPicker({
+        kind: 'menu',
+        title: 'channel — set credentials',
+        subtitle: 'pick a channel to configure',
+        items: channelMod.CHANNEL_CATALOG.map((c) => ({
+          id: c.name,
+          label: c.label,
+          desc: c.builtin ? '' : `needs: ${(c.deps && c.deps.length) ? c.deps.join(', ') : (c.binary || 'creds only')}`,
+        })),
+      });
+      chName = sel && typeof sel === 'object' ? sel.id : sel;
+      if (!chName || typeof chName !== 'string') return 'channel setup: cancelled';
+    }
+    const spec = channelMod.channelByName(chName);
+    if (!spec) return `unknown channel: ${chName} (known: ${cf.KNOWN_CHANNELS.join(', ')})`;
+    if (!spec.fields.length) {
+      // No creds (e.g. http / whatsapp) — just enable it.
+      const cfgDirX = ctx.cfgDir || (await import('node:path')).dirname(cfgMod.configPath());
+      channelMod.persistChannel(cfgDirX, chName, {});
+      if (ctx.cfg) { ctx.cfg.channels = ctx.cfg.channels || {}; ctx.cfg.channels[chName] = { ...(ctx.cfg.channels[chName] || {}), enabled: true }; }
+      return `channel ${chName} → enabled (no credentials needed)`;
+    }
+    const answers = {};
+    for (const f of spec.fields) {
+      const v = await _promptText(ctx, {
+        title: `${spec.label} — ${f.prompt}`,
+        subtitle: f.optional ? 'optional · Esc to skip' : 'Esc cancels',
+        secret: !!f.secret,
+        allowEmpty: !!f.optional,
+      });
+      if (v === null) {
+        if (f.optional) continue;       // Esc on an optional field → skip it
+        return 'channel setup: cancelled';
+      }
+      if (v) answers[f.key] = v;
+    }
+    const path = await import('node:path');
+    const cfgDirX = ctx.cfgDir || path.dirname(cfgMod.configPath());
+    const entry = channelMod.persistChannel(cfgDirX, chName, answers);
+    // Mirror the PERSISTED enabled state onto the in-session cfg so a follow-up
+    // list is fresh — an in-tree channel whose runtime dep is missing stays
+    // disabled (persistChannel gates it) rather than being force-enabled.
+    if (ctx.cfg) { ctx.cfg.channels = ctx.cfg.channels || {}; ctx.cfg.channels[chName] = { ...(ctx.cfg.channels[chName] || {}), enabled: !!entry.ready }; }
+    const setKeys = Object.keys(answers);
+    let note = '';
+    if (!entry.ready) {
+      if (entry.missingDeps && entry.missingDeps.length) note += `\n(needs ${entry.missingDeps.join(', ')} — run: lazyclaw channels install ${chName})`;
+      if (entry.missingBinary) note += `\n(needs the ${entry.missingBinary} binary on your PATH)`;
+    }
+    return `✓ ${spec.label} credentials saved (${setKeys.join(', ') || 'none'}) → ${entry.ready ? 'channel enabled' : 'saved (enable once the requirement is installed)'}${note}`;
+  }
+
+  // `/channels <name> test` — verify the stored credentials with a live call.
+  if (name && /^test$/i.test(action || '')) {
+    const channelMod = await import('../commands/setup_channels.mjs');
+    try { loadDotenvIfAny(ctx.cfgDir); } catch { /* best-effort */ }
+    const r = await channelMod.verifyChannel(name.toLowerCase());
+    if (r.ok === true) return `✓ ${name} verified — ${r.detail}`;
+    if (r.ok === null) return `· ${name}: ${r.detail}`;
+    return `✗ ${name}: ${r.detail}${r.hint ? `\n  fix: ${r.hint}` : ''}`;
+  }
+
   if (name && /^(on|off|enable|disable)$/i.test(action || '')) {
     const en = /^(on|enable)$/i.test(action);
     const cfg = read();
@@ -1697,70 +1862,56 @@ async function _channels(args, ctx = {}) {
     if (ctx.cfg && ctx.cfg !== cfg && typeof ctx.cfg === 'object') {
       cf.channelSetEnabled(ctx.cfg, key, en);
     }
-    return `channel ${key} → ${en ? 'enabled' : 'disabled'}`;
+    return en
+      ? `channel ${key} → enabled`
+      : `channel ${key} → disabled (re-enable with /channels ${key} on)`;
+  }
+  // No-arg + modal → an action menu: each row toggles in place, plus a
+  // "set credentials" row. Falls through to the text list when no modal.
+  if (!toks.length && typeof ctx.openPicker === 'function') {
+    const statusRows = cf.channelStatusList(read());
+    const items = statusRows.map((c) => ({
+      id: `toggle:${c.name}`,
+      label: `${c.name} — ${c.enabled ? 'enabled' : 'disabled'}`,
+      desc: c.enabled ? 'Enter to disable' : 'Enter to enable',
+    }));
+    items.push({ id: 'setup', label: '+ Set credentials…', desc: 'pick a channel and enter bot token / homeserver / …' });
+    const picked = await ctx.openPicker({ kind: 'menu', title: 'Channels', subtitle: `${statusRows.length} configured`, items });
+    const pid = picked && typeof picked === 'object' ? picked.id : picked;
+    if (!pid || typeof pid !== 'string') return 'cancelled';
+    if (pid === 'setup') return _channels('setup', ctx);
+    if (pid.startsWith('toggle:')) {
+      const nm = pid.slice(7);
+      const cur = statusRows.find((r) => r.name === nm);
+      return _channels(`${nm} ${cur && cur.enabled ? 'off' : 'on'}`, ctx);
+    }
   }
   const rows = cf.channelStatusList(read());
-  if (!rows.length) return 'no channels configured. add creds with /config (re-runs setup) or `lazyclaw setup`.';
+  if (!rows.length) return 'no channels configured. set credentials with /channels setup (or `lazyclaw setup` for the full wizard).';
+  // Cross-reference each channel's required env creds against the loaded env so
+  // the list flags a channel that's "enabled" but missing its token.
+  let channelMod = null;
+  try {
+    loadDotenvIfAny(ctx.cfgDir);
+    channelMod = await import('../commands/setup_channels.mjs');
+  } catch { /* hint is best-effort */ }
+  const missingFor = (name) => {
+    const spec = channelMod && channelMod.channelByName(name);
+    if (!spec) return [];
+    return spec.fields.filter((f) => !f.optional && !process.env[f.env]).map((f) => f.env);
+  };
   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');
+  for (const c of rows) {
+    const miss = missingFor(c.name);
+    const credNote = miss.length ? ` · creds: missing ${miss.join(', ')}` : '';
+    lines.push(`  ${c.name}  ${c.enabled ? 'enabled' : 'disabled'}${c.boundAgent ? ' · agent: ' + c.boundAgent : ''}${credNote}`);
+  }
+  lines.push('toggle: /channels <name> on|off   ·   set creds: /channels <name> setup');
   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>]';
-}
+// /orchestrator — moved to ./orchestrator_flow.mjs (orchestratorSlash) so the
+// interactive fetch+pick planner/worker editor can grow off the ratchet.
 
 // /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
@@ -1774,6 +1925,32 @@ async function _context(args, ctx = {}) {
   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)`; };
+  // No-arg + modal → action menu → numeric picker (mirrors orchestrator maxsubtasks).
+  if (!parts.length && typeof ctx.openPicker === 'function') {
+    const w = cf.chatWindowGet(read());
+    const action = await ctx.openPicker({
+      kind: 'menu', title: 'Context window (history budget)', subtitle: `now ${w.turns} turns · ${w.tokens} tokens`,
+      items: [
+        { id: 'turns', label: 'Set turns…', desc: 'past turns to send' },
+        { id: 'tokens', label: 'Set tokens…', desc: 'token budget (min 256)' },
+        { id: 'status', label: 'Status', desc: 'show current' },
+      ],
+    });
+    const aid = action && typeof action === 'object' ? action.id : action;
+    if (!aid || typeof aid !== 'string' || aid === 'status') return fmt();
+    if (aid === 'turns') {
+      const np = await ctx.openPicker({ kind: 'menu', title: 'Turns to keep', subtitle: `currently ${w.turns}`, items: [5, 10, 15, 20, 30, 40, 50].map((x) => ({ id: String(x), label: String(x) })) });
+      const v = parseInt(np && typeof np === 'object' ? np.id : np, 10);
+      if (!Number.isFinite(v)) return 'context turns: cancelled';
+      const cfg = read(); cf.chatWindowSet(cfg, { turns: v }); persist(cfg); return fmt();
+    }
+    if (aid === 'tokens') {
+      const np = await ctx.openPicker({ kind: 'menu', title: 'Token budget', subtitle: `currently ${w.tokens}`, items: [2000, 4000, 8000, 12000, 16000, 32000].map((x) => ({ id: String(x), label: String(x) })) });
+      const v = parseInt(np && typeof np === 'object' ? np.id : np, 10);
+      if (!Number.isFinite(v) || v < 256) return 'context tokens: cancelled';
+      const cfg = read(); cf.chatWindowSet(cfg, { tokens: v }); persist(cfg); return fmt();
+    }
+  }
   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(); }
@@ -1781,6 +1958,15 @@ async function _context(args, ctx = {}) {
   return 'usage: /context [status | turns <N> | tokens <N>]';
 }
 
+// /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 ──────────────────────────────────────────────────────
 
 export const SLASH_HANDLERS = new Map([
@@ -1792,6 +1978,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 +2000,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 +2017,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);
 }