lazyclaw 5.4.3 → 6.0.0

package/tui/slash_dispatcher.mjs

@@ -34,6 +34,14 @@
 // LAZYCLAW_NO_INK=1. Re-implementing these as Ink overlays is a v5.5 item.
 
 import { SLASH_COMMANDS } from './slash_commands.mjs';
+import { supportsLiveFetch, fetchModelsForProvider } from '../providers/model_catalogue.mjs';
+import { providerFamilies, providerTag } from './provider_families.mjs';
+import { addCustomProvider } from '../providers/custom_provider.mjs';
+import { setAuthKey } from '../providers/auth_store.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';
 
 // ─── helpers ─────────────────────────────────────────────────────────────
 
@@ -55,6 +63,15 @@ 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.
@@ -73,14 +90,19 @@ async function _help() {
 
 async function _status(_args, ctx) {
   const registry = await _mod(ctx, 'registryMod', () => import('../providers/registry.mjs'));
-  const out = {
-    provider: ctx.getActiveProvName(),
-    model: ctx.getActiveModel(),
-    keyMasked: registry.maskApiKey(ctx.cfg && ctx.cfg['api-key']),
-    messageCount: ctx.getMessages().length,
-    sessionId: ctx.getSessionId() || null,
-  };
-  return JSON.stringify(out);
+  const provider = ctx.getActiveProvName();
+  const model = ctx.getActiveModel() || '(default)';
+  const keyMasked = registry.maskApiKey(ctx.cfg && ctx.cfg['api-key']);
+  const messageCount = ctx.getMessages().length;
+  const sessionId = ctx.getSessionId() || '(none — in-memory)';
+  return [
+    'status:',
+    `  provider:  ${provider}`,
+    `  model:     ${model}`,
+    `  api key:   ${keyMasked}`,
+    `  messages:  ${messageCount}`,
+    `  session:   ${sessionId}`,
+  ].join('\n');
 }
 
 async function _version(_args, ctx) {
@@ -91,22 +113,33 @@ async function _version(_args, ctx) {
 async function _usage(_args, ctx) {
   const msgs = ctx.getMessages();
   const runningUsage = ctx.getRunningUsage && ctx.getRunningUsage();
-  const out = {
-    messageCount: msgs.length,
-    charsSent: (ctx.getCharsSent && ctx.getCharsSent()) || 0,
-  };
-  if (runningUsage) out.tokens = runningUsage;
-  if (runningUsage && ctx.cfg && ctx.cfg.rates && typeof ctx.cfg.rates === 'object') {
-    try {
-      const { costFromUsage } = await import('../providers/rates.mjs');
-      const r = costFromUsage(
-        { provider: ctx.getActiveProvName(), model: ctx.getActiveModel(), usage: runningUsage },
-        ctx.cfg.rates,
-      );
-      if (r) out.cost = r;
-    } catch { /* never let cost-card lookup fail the slash */ }
+  const charsSent = (ctx.getCharsSent && ctx.getCharsSent()) || 0;
+  const lines = [
+    'usage:',
+    `  messages:  ${msgs.length}`,
+    `  chars sent: ${charsSent.toLocaleString('en-US')}`,
+  ];
+  if (runningUsage) {
+    lines.push(
+      `  tokens in:  ${(runningUsage.inputTokens || 0).toLocaleString('en-US')}`,
+      `  tokens out: ${(runningUsage.outputTokens || 0).toLocaleString('en-US')}`,
+      `  tokens tot: ${(runningUsage.totalTokens || 0).toLocaleString('en-US')}`,
+      `  turns:      ${runningUsage.turnsWithUsage || 0}`,
+    );
+    if (ctx.cfg && ctx.cfg.rates && typeof ctx.cfg.rates === 'object') {
+      try {
+        const { costFromUsage } = await import('../providers/rates.mjs');
+        const r = costFromUsage(
+          { provider: ctx.getActiveProvName(), model: ctx.getActiveModel(), usage: runningUsage },
+          ctx.cfg.rates,
+        );
+        if (r && r.totalUsd != null) {
+          lines.push(`  cost (USD): $${Number(r.totalUsd).toFixed(4)}`);
+        }
+      } catch { /* never let cost-card lookup fail the slash */ }
+    }
   }
-  return JSON.stringify(out);
+  return lines.join('\n');
 }
 
 async function _newReset(_args, ctx) {
@@ -130,28 +163,198 @@ function _providerLookup(registry, 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) {
+  return async function approve({ tool, args, agent }) {
+    const raw = typeof args === 'object' ? JSON.stringify(args) : String(args ?? '');
+    const summary = redactSecrets(raw).slice(0, 300);
+    const ok = await _promptConfirm(ctx, {
+      title: `Approve ${tool}?`,
+      subtitle: `agent ${agent}: ${summary}`,
+    });
+    return { approved: ok, reason: ok ? 'approved in chat' : 'denied in chat' };
+  };
+}
+
+// Register a custom OpenAI-compatible endpoint with the given fields, set it
+// active, and return a summary string. Shared by the arg form and the
+// interactive flow.
+async function _registerCustom(ctx, registry, { name, baseUrl, apiKey }) {
+  if (typeof ctx.readConfig !== 'function' || typeof ctx.writeConfig !== 'function') {
+    return 'add custom: config writer unavailable in this session — use: lazyclaw providers add <name> <baseUrl> [apiKey]';
+  }
+  try {
+    const r = await addCustomProvider({
+      registry, readConfig: ctx.readConfig, writeConfig: ctx.writeConfig, name, baseUrl, apiKey,
+    });
+    const next = _providerLookup(registry, r.name);
+    if (next) {
+      if (ctx.setActiveProvName) ctx.setActiveProvName(r.name);
+      if (ctx.setProv) ctx.setProv(next);
+    }
+    const probe = r.probe.ok
+      ? `✓ reachable — ${r.probe.count} model(s)`
+      : `! registered, but /v1/models probe failed: ${r.probe.error}`;
+    const override = r.builtinOverride ? `\n(note: overrides built-in "${r.name}")` : '';
+    return `custom provider saved → ${r.name} (${r.baseUrl})\n${probe}${override}\nprovider → ${r.name}`;
+  } catch (e) {
+    return `add custom failed: ${e && e.message ? e.message : e}`;
+  }
+}
+
+// After an interactive pick of a built-in api-key provider that has no key
+// resolved, prompt for one and persist it (mirrored in-memory so it takes
+// effect this session). No-op for keyless / custom providers, when a key
+// already resolves, or when config writers aren't wired.
+async function _maybePromptForKey(ctx, registry, provName) {
+  const meta = _infoFor(registry, provName);
+  if (!meta.requiresApiKey || meta.custom) return;
+  if (typeof ctx.readConfig !== 'function' || typeof ctx.writeConfig !== 'function') return;
+  const existing = typeof ctx.resolveAuthKey === 'function' ? ctx.resolveAuthKey(provName) : '';
+  if (existing) return;
+  const key = await _promptText(ctx, {
+    title: `${provName} needs an api key`,
+    subtitle: 'paste it now, or Esc to skip (set later via: lazyclaw auth)',
+  });
+  if (!key) return;
+  const next = setAuthKey({ readConfig: ctx.readConfig, writeConfig: ctx.writeConfig, provider: provName, key });
+  // Mirror onto the in-memory cfg so resolveAuthKey (which closes over it)
+  // sees the key on the next turn without a restart.
+  if (ctx.cfg && next) {
+    ctx.cfg.authProfiles = next.authProfiles;
+    ctx.cfg.authActiveProfile = next.authActiveProfile;
+  }
+}
+
+// Interactive add-custom: collect name/baseUrl/apiKey via sequential prompts.
+async function _addCustomFlow(ctx, registry) {
+  const name = await _promptText(ctx, { title: 'custom endpoint — short id', subtitle: 'e.g. nim, openrouter, vllm (Esc cancels)' });
+  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 });
+  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'));
-  // No arg → open the Ink modal picker (v5.4.3). 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).
+  // `/provider add <name> <baseUrl> [apiKey]` — register a custom OpenAI-
+  // compatible endpoint non-interactively.
+  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).
   if (!args) {
     if (typeof ctx.openPicker === 'function') {
-      const known = Object.keys(registry.PROVIDERS || {}).sort();
-      const info = registry.PROVIDER_INFO || {};
-      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',
-        subtitle: `current: ${ctx.getActiveProvName()}`,
-        items,
-      });
+      const picked = await _pickProviderDrillIn(ctx, registry);
       if (!picked) return 'cancelled';
+      if (picked === '__add_custom__') return _addCustomFlow(ctx, registry);
       args = picked;
+      // Built-in api-key provider with no key configured → offer to set one.
+      await _maybePromptForKey(ctx, registry, args);
     } else {
       return `provider: ${ctx.getActiveProvName()}\n(pass an arg: /provider <name>)`;
     }
@@ -166,32 +369,189 @@ async function _provider(args, ctx) {
   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;
+  }
+  return null;
+}
+
+// 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') {
-      const provName = ctx.getActiveProvName();
-      const info = (registry.PROVIDER_INFO && registry.PROVIDER_INFO[provName]) || {};
-      const suggested = Array.isArray(info.suggestedModels) ? info.suggestedModels : [];
-      if (!suggested.length) {
-        return `no suggested models known for provider "${provName}" — pass one: /model <name>`;
+      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);
       }
-      const items = suggested.map((m) => ({
-        id: m,
-        label: m,
-        desc: info.defaultModel === m ? '(default)' : '',
-      }));
-      const picked = await ctx.openPicker({
-        kind: 'model',
-        title: `select model for ${provName}`,
-        subtitle: `current: ${ctx.getActiveModel() || '(default)'}`,
-        items,
-      });
-      if (!picked) return 'cancelled';
-      args = picked;
-    } else {
-      return `model: ${ctx.getActiveModel() || '(default)'}\n(pass an arg: /model <name>)`;
+      // 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;
+      }
+      if (model == null || model === '__switch_provider__') {
+        return switched ? `provider → ${provName} (model unchanged)` : 'cancelled';
+      }
+      if (ctx.setActiveModel) ctx.setActiveModel(model);
+      return switched
+        ? `provider → ${provName} · model → ${model}`
+        : `model → ${model}`;
     }
+    return `model: ${ctx.getActiveModel() || '(default)'}\n(pass an arg: /model <name>)`;
   }
   const { parseSlashProviderModel } = registry;
   const parsed = typeof parseSlashProviderModel === 'function'
@@ -248,6 +608,36 @@ async function _skill(args, ctx) {
   }
 }
 
+// /skills — list + pick installed skills (the v5.4 alias only forwarded to
+// _skill, which activates/clears but never *shows* what's available). With an
+// arg it activates directly (like /skill); with no arg it opens a picker (or
+// lists, or — when nothing is installed — explains how to install).
+async function _skillsList(args, ctx) {
+  if (args && args.trim()) return _skill(args, ctx);
+  const skillsMod = await _mod(ctx, 'skillsMod', () => import('../skills.mjs'));
+  let names = [];
+  try { names = (skillsMod.listSkills(ctx.cfgDir) || []).map((s) => s.name).filter(Boolean); }
+  catch (e) { return `skills unavailable: ${e?.message || e}`; }
+  if (!names.length) {
+    return [
+      'no skills installed.',
+      'install one:  lazyclaw skills install <owner>/<repo>',
+      'then /skills to pick, or /skill <name>[,<name>] to activate.',
+    ].join('\n');
+  }
+  if (typeof ctx.openPicker === 'function') {
+    const picked = await ctx.openPicker({
+      kind: 'skill',
+      title: 'activate a skill',
+      subtitle: `${names.length} installed · Enter activates · Esc cancels`,
+      items: names.map((n) => ({ id: n, label: n, desc: '' })),
+    });
+    if (!picked) return 'cancelled';
+    return _skill(typeof picked === 'string' ? picked : picked.id, ctx);
+  }
+  return `installed skills (${names.length}):\n${names.map((n) => `  · ${n}`).join('\n')}\n(activate: /skill <name>[,<name>])`;
+}
+
 async function _tools(_args) {
   let registry;
   try {
@@ -295,8 +685,15 @@ async function _memory(args, ctx) {
     return body || '(empty core memory)';
   }
   if (which === 'recent') {
-    const items = mem.loadRecent(20, ctx.cfgDir);
-    return JSON.stringify(items, null, 2);
+    const items = mem.loadRecent(20, ctx.cfgDir) || [];
+    if (!items.length) return '(no recent memory)';
+    return ['recent memory (last ' + items.length + '):',
+      ...items.map((it, i) => {
+        const role = it.role || 'msg';
+        const content = String(it.content || '').replace(/\s+/g, ' ').slice(0, 80);
+        return `  ${String(i + 1).padStart(2)}. [${role}] ${content}${(it.content || '').length > 80 ? '…' : ''}`;
+      })
+    ].join('\n');
   }
   if (which === 'episodic') {
     const topic = tokens[1];
@@ -304,7 +701,11 @@ async function _memory(args, ctx) {
       const body = mem.loadEpisodic(topic, ctx.cfgDir);
       return body || `(no episodic file "${topic}")`;
     }
-    return JSON.stringify(mem.listEpisodic(ctx.cfgDir), null, 2);
+    const items = mem.listEpisodic(ctx.cfgDir) || [];
+    if (!items.length) return '(no episodic files yet — run /dream to consolidate)';
+    return ['episodic files:',
+      ...items.map((it) => `  • ${typeof it === 'string' ? it : (it.topic || JSON.stringify(it))}`)
+    ].join('\n');
   }
   return 'usage: /memory [core|recent|episodic [topic]]';
 }
@@ -440,10 +841,10 @@ async function _loop(args, ctx, write) {
   catch (e) { return `loop unavailable: ${e?.message || e}`; }
   if (!args) {
     return [
-      'usage: /loop <prompt> [--max N] [--until "<regex>"]',
+      'usage: /loop <prompt> [--max N] [--until "<regex>"] [--use-memory] [--recall "<q>"]',
       `  default --max ${loopMod.LOOP_MAX_DEFAULT}, ceiling ${loopMod.LOOP_MAX_CEILING}`,
       `  session: ${ctx.getSessionId && ctx.getSessionId() || '(none — turns will not be persisted)'}`,
-      '  note: Ink chat runs /loop without mid-loop Ctrl-C abort; set LAZYCLAW_NO_INK=1 for the full loop UX.',
+      '  press Esc to abort a running loop.',
     ].join('\n');
   }
   let parsed;
@@ -473,7 +874,31 @@ async function _loop(args, ctx, write) {
   };
 
   const messages = ctx.getMessages();
-  const ac = new AbortController();
+  // --memory / --recall rebuild the system message from disk every iteration
+  // (a parallel writer mutating core.md mid-loop is reflected next call). We
+  // capture the chat's prior system so it can be restored after the loop.
+  const _sysBefore = (messages.find((m) => m.role === 'system') || {}).content ?? null;
+  let memMod = null;
+  if (parsed.useMemory || parsed.recall) {
+    try { memMod = await import('../memory.mjs'); } catch { memMod = null; }
+  }
+  const buildSystem = memMod ? (() => {
+    const parts = [];
+    if (parsed.useMemory) {
+      const core = memMod.loadCore(ctx.cfgDir);
+      if (core && core.trim()) parts.push(core);
+    }
+    if (parsed.recall) {
+      const text = memMod.recall(parsed.recall, { topN: 3 }, ctx.cfgDir);
+      if (text && text.trim()) parts.push(text);
+    }
+    if (_sysBefore) parts.push(_sysBefore);
+    return parts.join('\n\n---\n\n');
+  }) : null;
+
+  // Use the abort signal the REPL threads in (Esc / Ctrl-C aborts the running
+  // loop). Falls back to a fresh controller for non-Ink callers.
+  const signal = ctx.loopSignal || new AbortController().signal;
   try {
     const result = await loopMod.runLoop({
       prompt: parsed.prompt,
@@ -487,7 +912,8 @@ async function _loop(args, ctx, write) {
           try { write(`  ↻ loop iteration ${i}/${max}\n`); } catch {}
         }
       },
-      signal: ac.signal,
+      signal,
+      buildSystem,
     });
     if (ctx.setCharsSent && ctx.getCharsSent) {
       ctx.setCharsSent(ctx.getCharsSent() + parsed.prompt.length * result.iterations);
@@ -497,6 +923,19 @@ async function _loop(args, ctx, write) {
     return `✓ loop done — ${result.iterations}/${parsed.max} iteration(s)${tail}`;
   } catch (err) {
     return `loop error: ${err?.message || String(err)}`;
+  } finally {
+    // Restore the chat's prior system message — the engine overwrote
+    // messages[0] with the per-iteration memory composition.
+    if (buildSystem) {
+      const sysIdx = messages.findIndex((m) => m.role === 'system');
+      if (_sysBefore != null) {
+        if (sysIdx >= 0) messages[sysIdx] = { role: 'system', content: _sysBefore };
+        else messages.unshift({ role: 'system', content: _sysBefore });
+      } else if (sysIdx >= 0) {
+        messages.splice(sysIdx, 1);
+      }
+      if (ctx.setMessages) ctx.setMessages(messages);
+    }
   }
 }
 
@@ -533,9 +972,23 @@ async function _goal(args, ctx) {
     if (!name) return 'usage: /goal add <name> [--desc "..."] [--cron "<spec>"]';
     try {
       const g = goalsMod.registerGoal({ name, description: desc, schedule: cron }, ctx.cfgDir);
-      // Cron attach is cli.mjs-internal (_attachGoalCron); Ink chat skips it
-      // and the operator can attach via the `lazyclaw goal add --cron` CLI.
-      const cronNote = cron ? ' (cron attach via Ink chat is not wired in v5.4 — use the CLI form)' : '';
+      let cronNote = '';
+      if (cron) {
+        // Actually attach the schedule (P3 — was a stub). Needs the config
+        // writers the Ink session wires onto ctx; fall back to a CLI hint if
+        // they're absent (non-Ink callers).
+        if (typeof ctx.readConfig === 'function' && typeof ctx.writeConfig === 'function') {
+          try {
+            const cronMod = await import('../cron.mjs');
+            const r = await attachGoalCron({ readConfig: ctx.readConfig, writeConfig: ctx.writeConfig, cron: cronMod, name: g.name, schedule: cron });
+            cronNote = r.skipped ? ' (cron recorded; backend install skipped)' : ' (cron scheduled)';
+          } catch (ce) {
+            cronNote = ` (cron attach failed: ${ce?.message || ce} — use: lazyclaw goal add ${g.name} --cron "${cron}")`;
+          }
+        } else {
+          cronNote = ' (cron recorded — attach via: lazyclaw goal add --cron)';
+        }
+      }
       return `✓ goal ${g.name} added (status: active${cron ? `, cron: ${cron}` : ''})${cronNote}`;
     } catch (e) { return `goal error: ${e?.message || e}`; }
   }
@@ -553,7 +1006,17 @@ async function _goal(args, ctx) {
     if (!name) return 'usage: /goal close <name> [done|abandoned]';
     try {
       const g = goalsMod.closeGoal(name, outcome, ctx.cfgDir);
-      return `✓ goal ${g.name} closed (status: ${g.status})`;
+      // Detach any attached cron so a closed goal stops ticking (P3 — the
+      // Ink path used to leave it dangling).
+      let detachNote = '';
+      if (typeof ctx.readConfig === 'function' && typeof ctx.writeConfig === 'function') {
+        try {
+          const cronMod = await import('../cron.mjs');
+          const removed = await detachGoalCron({ readConfig: ctx.readConfig, writeConfig: ctx.writeConfig, cron: cronMod, name: g.name });
+          if (removed) detachNote = ' (cron detached)';
+        } catch { /* best-effort */ }
+      }
+      return `✓ goal ${g.name} closed (status: ${g.status})${detachNote}`;
     } catch (e) { return `goal error: ${e?.message || e}`; }
   }
   // single-arg branch: switch
@@ -694,11 +1157,11 @@ function _personalityUse(name, ctx, fs, path) {
   return `active personality → ${name}`;
 }
 
-async function _task(args, ctx) {
+async function _task(args, ctx, write) {
   let tasksMod, loopMod;
   try {
-    tasksMod = await import('../tasks.mjs');
-    loopMod = await import('../loop-engine.mjs');
+    tasksMod = await _mod(ctx, 'tasksMod', () => import('../tasks.mjs'));
+    loopMod = await _mod(ctx, 'loopMod', () => import('../loop-engine.mjs'));
   } catch (e) { return `/task unavailable: ${e?.message || e}`; }
   let tokens;
   try { tokens = loopMod.splitArgs(args); }
@@ -732,18 +1195,120 @@ async function _task(args, ctx) {
     }
     if (sub === 'abandon' || sub === 'done') {
       if (!id) return `usage: /task ${sub} <id>`;
-      const next = tasksMod.patchTask(id, { status: sub === 'done' ? 'done' : 'abandoned' }, ctx.cfgDir);
-      return `✓ task ${id} → ${next?.status || sub}`;
+      const target = sub === 'done' ? 'done' : 'abandoned';
+      const next = tasksMod.patchTask(id, { status: target }, ctx.cfgDir);
+      // Best-effort closing post in the original Slack thread (parity with the
+      // CLI cmdTask), so collaborators see the resolution. Never rolls back
+      // the status change.
+      let slackNote = '';
+      if (next && next.slackChannel && next.slackThreadTs) {
+        try {
+          loadDotenvIfAny(ctx.cfgDir);
+          const SlackChannel = ctx.SlackChannel || (await import('../channels/slack.mjs')).SlackChannel;
+          const slack = new SlackChannel({ requireInbound: false });
+          await slack.start(async () => '', {});
+          const threadId = `${next.slackChannel}:${next.slackThreadTs}`;
+          const msg = target === 'done'
+            ? `:white_check_mark: Task *${next.title}* marked done.`
+            : `:no_entry: Task *${next.title}* abandoned.`;
+          await slack.send(threadId, msg);
+          await slack.stop().catch(() => {});
+          slackNote = ' (posted to Slack thread)';
+        } catch (e) { slackNote = ` (Slack post failed: ${e?.message || e})`; }
+      }
+      return `✓ task ${id} → ${next?.status || target}${slackNote}`;
     }
     if (sub === 'remove' || sub === 'rm' || sub === 'delete') {
       if (!id) return 'usage: /task remove <id>';
       tasksMod.removeTask(id, ctx.cfgDir);
       return `✓ removed task ${id}`;
     }
-    if (sub === 'start' || sub === 'tick') {
-      return `task ${sub}: needs Slack + multi-agent router — run from the shell:\n  lazyclaw task ${sub} ...`;
+    if (sub === 'start') {
+      // /task start <team> --title "..." [--description "..."] [--lead <name>]
+      const teamsMod = await _mod(ctx, 'teamsMod', () => import('../teams.mjs'));
+      const agentsMod = await _mod(ctx, 'agentsMod', () => import('../agents.mjs'));
+      const rest = tokens.slice(1);
+      let teamName = null, title = '', description = '', lead = null;
+      for (let i = 0; i < rest.length; i++) {
+        const t = rest[i];
+        if (t === '--title') title = rest[++i] || '';
+        else if (t === '--description' || t === '--desc') description = rest[++i] || '';
+        else if (t === '--lead') lead = rest[++i] || null;
+        else if (!teamName && !t.startsWith('--')) teamName = t;
+      }
+      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}"`;
+      const leadName = lead || team.lead;
+      const leadAgent = agentsMod.getAgent(leadName, ctx.cfgDir);
+      const seeded = tasksMod.registerTask(
+        { title, description, team: teamName, lead: leadName, slackChannel: team.slackChannel, status: 'pending' },
+        ctx.cfgDir,
+      );
+      let ts = '';
+      if (team.slackChannel) {
+        try {
+          loadDotenvIfAny(ctx.cfgDir);
+          const SlackChannel = ctx.SlackChannel || (await import('../channels/slack.mjs')).SlackChannel;
+          const slack = new SlackChannel({ requireInbound: false });
+          await slack.start(async () => '', {});
+          const text = tasksMod.buildKickoffMessage({
+            id: seeded.id, title: seeded.title, description: seeded.description,
+            leadDisplayName: (leadAgent && leadAgent.displayName) || leadName,
+            teamDisplayName: team.displayName || team.name,
+          });
+          const res = await slack.send(team.slackChannel, text);
+          ts = (res && res.ts) || '';
+          await slack.stop().catch(() => {});
+        } catch (e) {
+          try { tasksMod.removeTask(seeded.id, ctx.cfgDir); } catch { /* best-effort */ }
+          return `task start: ${e?.message || e}`;
+        }
+      }
+      const turns = ts ? [{ agent: 'system', text: `Task opened by user. Lead: ${leadName}.`, ts }] : [];
+      const finalTask = tasksMod.patchTask(seeded.id, { slackThreadTs: ts, status: ts ? 'running' : 'pending', turns }, ctx.cfgDir);
+      return `✓ task ${finalTask.id} started (status: ${finalTask.status}${ts ? `, slack thread ${ts}` : ', no Slack thread'})`;
     }
-    return `/task: unknown sub "${sub}" — list|show|transcript|abandon|done|remove (start/tick: use CLI)`;
+    if (sub === 'tick') {
+      // /task tick <id> [message] — one multi-agent router turn. The router
+      // emits through a logger callback (not raw stdout), so it runs inline in
+      // the Ink chat with output routed through `write`.
+      if (!id) return 'usage: /task tick <id> [message]';
+      const teamsMod = await _mod(ctx, 'teamsMod', () => import('../teams.mjs'));
+      const agentsMod = await _mod(ctx, 'agentsMod', () => import('../agents.mjs'));
+      const task = tasksMod.getTask(id, ctx.cfgDir);
+      if (!task) return `no task "${id}"`;
+      const team = teamsMod.getTeam(task.team, ctx.cfgDir);
+      if (!team) return `task tick: team "${task.team}" disappeared`;
+      const agentsById = {};
+      for (const name of team.agents) {
+        const rec = agentsMod.getAgent(name, ctx.cfgDir);
+        if (!rec) return `task tick: agent "${name}" disappeared`;
+        agentsById[name] = rec;
+      }
+      loadDotenvIfAny(ctx.cfgDir);
+      const router = await _mod(ctx, 'routerMod', () => import('../mas/mention_router.mjs'));
+      const leadAgent = agentsById[team.lead];
+      const apiKey = ctx.resolveAuthKey ? ctx.resolveAuthKey(leadAgent.provider) : '';
+      const baseUrl = ctx.resolveBaseUrl ? ctx.resolveBaseUrl(leadAgent.provider) : undefined;
+      const userMsg = tokens.slice(2).join(' ').trim();
+      try {
+        if (typeof write === 'function') { try { write('  ↻ running task turn…\n'); } catch {} }
+        const result = await router.runTaskTurn({
+          task, team, agentsById,
+          userMessage: userMsg || undefined,
+          configDir: ctx.cfgDir,
+          apiKey, baseUrl,
+          logger: (line) => { if (typeof write === 'function') { try { write(line); } catch {} } },
+          approve: _makeInkApprove(ctx),
+          security: ctx.cfg?.security,
+        });
+        return `✓ task ${result.task.id} → ${result.task.status} (${result.iterations} agent turn(s)${result.stoppedBy ? `, stopped by ${result.stoppedBy}` : ''})`;
+      } catch (e) {
+        return `task tick: ${e?.message || e}`;
+      }
+    }
+    return `/task: unknown sub "${sub}" — start|tick|list|show|transcript|abandon|done|remove`;
   } catch (e) {
     return `/task error: ${e?.message || e}`;
   }
@@ -786,6 +1351,19 @@ async function _trainer(args, ctx) {
       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');
@@ -795,10 +1373,38 @@ async function _trainer(args, ctx) {
     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 : ''}`;
+    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') {
@@ -817,53 +1423,251 @@ async function _trainer(args, ctx) {
   return `/trainer: unknown sub "${sub}" — show|set <p:m>|clear`;
 }
 
-// /dashboard — open the lazyclaw web UI. Reuses an already-running
-// daemon if one answers /healthz on 19600; otherwise spawns a detached
-// `node cli.mjs dashboard --no-open` child so the daemon outlives this
-// chat session. Never installs signal handlers / never process.exits —
-// Ctrl-C inside chat must NOT touch the dashboard.
-async function _dashboard(_args) {
-  const port = 19600;
-  const url = `http://127.0.0.1:${port}/dashboard`;
-  const healthUrl = `http://127.0.0.1:${port}/healthz`;
-  const { spawn } = await import('node:child_process');
-  const openBrowser = (u) => {
+// /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 = [u]; }
-    else if (process.platform === 'win32')  { cmd = 'cmd';      args = ['/c', 'start', '""', u]; }
-    else                                    { cmd = 'xdg-open'; args = [u]; }
+    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 */ }
-  };
-  const probe = async () => {
-    if (typeof fetch !== 'function') return false;
+  });
+}
+
+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 ac = new AbortController();
-      const t = setTimeout(() => ac.abort(), 300);
-      const r = await fetch(healthUrl, { signal: ac.signal });
-      clearTimeout(t);
-      return !!(r && r.ok);
-    } catch { return false; }
-  };
-  if (await probe()) {
-    openBrowser(url);
+      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}`;
   }
-  // Spawn detached so the daemon outlives this chat process.
+
+  // 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 child = spawn(process.execPath, [process.argv[1], 'dashboard', '--no-open'], {
-      detached: true, stdio: 'ignore', cwd: process.cwd(), env: process.env,
-    });
+    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();
-  } catch (e) {
-    return `dashboard error: failed to spawn — ${e?.message || e}`;
+    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;
   }
-  // Poll /healthz up to ~3s before opening the browser.
-  const start = Date.now();
-  while (Date.now() - start < 3000) {
-    if (await probe()) { openBrowser(url); return `✓ started dashboard — opened ${url}`; }
-    await new Promise((r) => setTimeout(r, 150));
+}
+
+// /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) {
+  if (typeof ctx.openPicker === 'function') {
+    const items = [];
+    const seen = new Set();
+    for (const [group, cmds] of SUBCOMMAND_GROUPS) {
+      for (const c of cmds) {
+        if (seen.has(c)) continue;
+        seen.add(c);
+        items.push({ id: c, label: c, desc: group });
+      }
+    }
+    const picked = await ctx.openPicker({
+      kind: 'menu',
+      title: 'lazyclaw subcommands',
+      subtitle: 'Enter shows how to run it · Esc cancels',
+      items,
+    });
+    if (!picked) return 'cancelled';
+    const cmd = typeof picked === 'string' ? picked : picked.id;
+    return `run from a shell:  lazyclaw ${cmd}`;
   }
-  return `⚠ dashboard didn't come up within 3s. Try \`lazyclaw dashboard\` from another terminal. URL: ${url}`;
+  return [
+    'subcommands:',
+    ...SUBCOMMAND_GROUPS.map(([g, cmds]) => `  ${g.padEnd(9)} ${cmds.join(' ')}`),
+    '(run: lazyclaw <subcommand>)',
+  ].join('\n');
 }
 
 // ─── dispatch table ──────────────────────────────────────────────────────
@@ -879,7 +1683,7 @@ export const SLASH_HANDLERS = new Map([
   ['/provider', _provider],
   ['/model', _model],
   ['/skill', _skill],
-  ['/skills', _skill],
+  ['/skills', _skillsList],
   ['/tools', _tools],
   ['/recall', _recall],
   ['/memory', _memory],
@@ -893,6 +1697,7 @@ export const SLASH_HANDLERS = new Map([
   ['/task', _task],
   ['/trainer', _trainer],
   ['/dashboard', _dashboard],
+  ['/menu', _menu],
   ['/exit', async () => 'EXIT'],
   ['/quit', async () => 'EXIT'],
 ]);