lazyclaw 5.4.4 → 6.0.1

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.
@@ -146,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>)`;
     }
@@ -182,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'
@@ -264,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 {
@@ -467,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;
@@ -500,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,
@@ -514,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);
@@ -524,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);
+    }
   }
 }
 
@@ -560,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}`; }
   }
@@ -580,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
@@ -721,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); }
@@ -759,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}`;
   }
@@ -813,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');
@@ -822,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') {
@@ -953,9 +1532,41 @@ async function _dashboardStop(port) {
   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);
 
@@ -990,16 +1601,30 @@ async function _dashboard(args) {
     const { spawn } = await import('node:child_process');
     let child;
     try {
-      child = spawn(process.execPath, [process.argv[1], 'dashboard', '--no-open'], {
-        detached: true, stdio: 'ignore', cwd: process.cwd(), env: process.env,
+      // 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,
       });
-      child.unref();
       _dashboardChildPid = child.pid;
     } catch (e) {
       return `dashboard error: failed to spawn — ${e?.message || e}`;
     }
+    // Prefer the daemon's own "listening at <url>" line — it carries the
+    // actual port even after a random-port fallback.
+    const boundUrl = await _waitForDashboardUrl(child, 3000);
+    // Release the captured stdout pipe so the detached daemon doesn't keep
+    // OUR event loop alive (unref, not destroy — destroying would EPIPE the
+    // daemon on its next stdout write). Then unref the child itself.
+    try { if (child.stdout) { child.stdout.removeAllListeners('data'); child.stdout.unref(); } } catch { /* ignore */ }
+    child.unref();
+    if (boundUrl) {
+      await _openBrowser(boundUrl);
+      return `✓ started dashboard (pid ${child.pid}) — opened ${boundUrl}`;
+    }
+    // Fallback: the line never arrived — poll the default port best-effort.
     const start = Date.now();
-    while (Date.now() - start < 3000) {
+    while (Date.now() - start < 1500) {
       if (await _dashboardProbe(port)) {
         await _openBrowser(url);
         return `✓ started dashboard (pid ${child.pid}) — opened ${url}`;
@@ -1012,6 +1637,39 @@ async function _dashboard(args) {
   }
 }
 
+// /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 [
+    'subcommands:',
+    ...SUBCOMMAND_GROUPS.map(([g, cmds]) => `  ${g.padEnd(9)} ${cmds.join(' ')}`),
+    '(run: lazyclaw <subcommand>)',
+  ].join('\n');
+}
+
 // ─── dispatch table ──────────────────────────────────────────────────────
 
 export const SLASH_HANDLERS = new Map([
@@ -1025,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],
@@ -1039,6 +1697,7 @@ export const SLASH_HANDLERS = new Map([
   ['/task', _task],
   ['/trainer', _trainer],
   ['/dashboard', _dashboard],
+  ['/menu', _menu],
   ['/exit', async () => 'EXIT'],
   ['/quit', async () => 'EXIT'],
 ]);