lazyclaw 6.1.0 → 6.3.0

package/commands/chat.mjs

@@ -23,17 +23,16 @@ import { SLASH_COMMANDS } from '../tui/slash_commands.mjs';
 
 // Legacy (non-Ink) slash routing for dispatcher-style, ctx-only commands.
 // The Ink REPL routes every slash through _dispatchSlash/SLASH_HANDLERS, but
-// the legacy readline path uses a hand-written switch (in cmdChat). Commands
-// like /config only mutate ctx and return a sentinel, so we keep that wiring
-// in one exported helper that BOTH the legacy switch and the regression test
-// drive — this is the seam that proves /config reaches setup on the legacy
-// path (the post-loop guard re-runs cmdSetup when ctx.requestSetup is set).
-// Returns 'EXIT' when the loop must break, or undefined when the command is
-// not one this helper owns (caller falls through to its own handling).
+// the legacy readline path uses a hand-written switch (in cmdChat). This
+// exported helper is the wiring BOTH that switch and the regression test
+// drive. Returns 'EXIT' to break the loop, undefined when not owned here.
 export function legacySlashRoute(cmd, ctx) {
   switch (cmd) {
+    // Legacy readline path has no modal picker, so BOTH /setup and /config
+    // route to the full wizard here (the Ink path gives /config its
+    // single-setting picker via tui/config_picker.mjs).
     case '/config':
-      // Mirror tui/slash_dispatcher.mjs '/config': signal the host, unmount.
+    case '/setup':
       ctx.requestSetup = true;
       return 'EXIT';
     default:
@@ -297,9 +296,13 @@ export async function cmdChat(flags = {}) {
         pickerRef: _inkPickerRef,
       }), { exitOnCtrlC: true, patchConsole: true });
       await ink.waitUntilExit();
-      // /config asks to (re)run the wizard: now that Ink has released stdin,
-      // run setup, then return to the shell (re-launch `lazyclaw` to chat).
+      // /setup → full wizard (then shell). /config single step → run JUST
+      // that step now that Ink released stdin, then re-enter chat.
       if (_inkCtx.requestSetup) await (await import('./setup.mjs')).cmdSetup(undefined, [], {});
+      else if (_inkCtx.requestConfigStep) {
+        await (await import('./config_step.mjs')).runConfigStep(_inkCtx.requestConfigStep);
+        return cmdChat(flags);
+      }
       return;
     } catch (e) {
       // Fall through to legacy path on any ink failure (missing import,
@@ -1110,14 +1113,10 @@ export async function cmdChat(flags = {}) {
         } catch { /* /exit must never hang or throw */ }
         return 'EXIT';
       }
-      case '/config': {
-        // Route through the shared legacySlashRoute helper (covered by
-        // tests/f-config-slash-splash.test.mjs) so the legacy path's /config
-        // wiring is the exact code the regression test exercises. It sets
-        // _legacyCtx.requestSetup and returns 'EXIT'; the post-loop guard at the
-        // bottom of cmdChat re-runs the setup wizard when requestSetup is set.
-        // Without this case the legacy readline path fell through to `default:`
-        // and printed "unknown slash" instead of launching setup.
+      case '/config':
+      case '/setup': {
+        // Shared legacySlashRoute wiring (tests/f-config-slash-splash.test.mjs):
+        // sets requestSetup + 'EXIT'; the post-loop guard runs the wizard.
         return legacySlashRoute(cmd, _legacyCtx);
       }
       default: {

package/commands/config_step.mjs

@@ -0,0 +1,39 @@
+// commands/config_step.mjs — run ONE setup step outside the full wizard.
+//
+// Backs the in-chat `/config` picker: credential steps (channel tokens,
+// outbound webhook) need raw readline prompts that can't run inside the Ink
+// REPL, so the REPL unmounts with ctx.requestConfigStep set, chat.mjs calls
+// runConfigStep(step) here, and then re-enters chat — the user changes one
+// value (e.g. a webhook URL) without re-walking every wizard step.
+
+import path from 'node:path';
+import { configPath } from '../lib/config.mjs';
+import { _quickPrompt } from '../tui/pickers.mjs';
+import { runChannelStep, runWebhookStep } from './setup_channels.mjs';
+
+const COLORS = {
+  accent: (s) => `\x1b[38;2;217;179;90m${s}\x1b[0m`,
+  bold:   (s) => `\x1b[1m${s}\x1b[0m`,
+  dim:    (s) => `\x1b[2m${s}\x1b[0m`,
+  ok:     (s) => `\x1b[32m${s}\x1b[0m`,
+  warn:   (s) => `\x1b[33m${s}\x1b[0m`,
+};
+
+export async function runConfigStep(step, deps = {}) {
+  const prompt = deps.prompt || _quickPrompt;
+  const colors = deps.colors || COLORS;
+  const write = deps.write || ((s) => process.stdout.write(s));
+  const cfgDir = deps.cfgDir || path.dirname(configPath());
+
+  write(`\n  ${colors.bold(`⚙ config — ${step}`)}\n`);
+  if (step === 'channel') {
+    await runChannelStep({ cfgDir, prompt, colors, write });
+    return true;
+  }
+  if (step === 'webhook') {
+    await runWebhookStep({ prompt, colors, write });
+    return true;
+  }
+  write(`  ${colors.warn(`unknown config step: ${step}`)}\n`);
+  return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "6.1.0",
+  "version": "6.3.0",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama, orchestrating multi-step LLM workflows, and running multi-agent Slack teams with cross-task memory. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",

package/providers/codex_cli.mjs

@@ -144,6 +144,16 @@ export const codexCliProvider = {
     const onAbort = () => { try { proc.kill('SIGTERM'); } catch (_) { /* ignore */ } };
     if (opts.signal) opts.signal.addEventListener('abort', onAbort);
 
+    // A missing binary surfaces as an ASYNC ChildProcess 'error' event on
+    // some platforms (the sync try/catch above doesn't see it). Without a
+    // listener that's an uncaughtException that kills the WHOLE process mid
+    // `providers test` — capture it and surface a per-provider CliMissingError
+    // instead (same fix claude_cli.mjs received in F8).
+    let spawnError = null;
+    const spawnErrorPromise = new Promise((resolve) => {
+      proc.once('error', (err) => { spawnError = err; resolve(); });
+    });
+
     let stderr = '';
     proc.stderr.setEncoding('utf8');
     proc.stderr.on('data', (chunk) => { stderr += chunk; });
@@ -184,7 +194,13 @@ export const codexCliProvider = {
           if (text) yield text;
         } catch (_) { /* incomplete tail — drop */ }
       }
-      await exitPromise;
+      // Wait for either a clean exit or an async spawn error. On ENOENT the
+      // process never starts, so 'close' never fires — racing against
+      // spawnErrorPromise keeps this from hanging forever.
+      await Promise.race([exitPromise, spawnErrorPromise]);
+      if (spawnError) {
+        throw spawnError.code === 'ENOENT' ? new CliMissingError() : spawnError;
+      }
       if (exitInfo && exitInfo.code !== 0 && !opts.signal?.aborted) {
         throw new CliExitError(exitInfo.code, exitInfo.signal, stderr);
       }

package/providers/compat_vendors.mjs

@@ -0,0 +1,161 @@
+// providers/compat_vendors.mjs — the built-in OpenAI-compatible vendor
+// catalogue, split out of registry.mjs (file-size ratchet). Pure data:
+// registry.mjs imports this and expands it into PROVIDERS / PROVIDER_INFO.
+
+// Built-in OpenAI-compatible vendors. Same wire format → one factory call
+// each. The picker treats these like first-class providers so users don't
+// have to walk through "+ Add a custom endpoint" for the popular ones.
+//
+// Each entry must define baseUrl + envKey (the env var the chat path
+// consults when no api-key is configured) + suggestedModels (curated list
+// shown before the user fetches the live /v1/models catalogue).
+//
+// Adding a new vendor: drop a row here. The PROVIDERS / PROVIDER_INFO loops
+// below pick it up automatically.
+export const OPENAI_COMPAT_BUILTINS = {
+  nim: {
+    label: 'NVIDIA NIM',
+    baseUrl: 'https://integrate.api.nvidia.com/v1',
+    envKey: 'NVIDIA_API_KEY',
+    altEnvKeys: ['NIM_API_KEY'],
+    keyPrefix: 'nvapi-',
+    docs: 'NVIDIA NIM hosted catalogue (Llama 3.x, Nemotron, DeepSeek-R1, Mixtral, Phi-3, Qwen, etc.). Auth: NVIDIA_API_KEY env var or in-app api-key. Endpoint speaks the OpenAI v1 wire format.',
+    defaultModel: 'meta/llama-3.1-405b-instruct',
+    suggestedModels: [
+      'meta/llama-3.1-405b-instruct',
+      'meta/llama-3.1-70b-instruct',
+      'meta/llama-3.1-8b-instruct',
+      'nvidia/llama-3.1-nemotron-70b-instruct',
+      'nvidia/nemotron-mini-4b-instruct',
+      'nvidia/llama-3.3-nemotron-super-49b-v1',
+      'mistralai/mistral-nemo-12b-instruct',
+      'mistralai/mixtral-8x22b-instruct-v0.1',
+      'microsoft/phi-3-medium-4k-instruct',
+      'deepseek-ai/deepseek-r1',
+      'qwen/qwen2.5-7b-instruct',
+      'qwen/qwen2.5-coder-32b-instruct',
+    ],
+  },
+  openrouter: {
+    label: 'OpenRouter',
+    baseUrl: 'https://openrouter.ai/api/v1',
+    envKey: 'OPENROUTER_API_KEY',
+    keyPrefix: 'sk-or-',
+    docs: 'OpenRouter unified gateway — 200+ models behind one OpenAI-compatible endpoint. Auth: OPENROUTER_API_KEY env var or in-app api-key. Uses x-title/HTTP-Referer headers for attribution.',
+    defaultModel: 'anthropic/claude-3.5-sonnet',
+    headers: { 'http-referer': 'https://github.com/cmblir/lazyclaude', 'x-title': 'lazyclaw' },
+    suggestedModels: [
+      'anthropic/claude-3.5-sonnet',
+      'anthropic/claude-3-opus',
+      'openai/gpt-4o',
+      'openai/gpt-4o-mini',
+      'openai/o1-preview',
+      'meta-llama/llama-3.1-405b-instruct',
+      'meta-llama/llama-3.3-70b-instruct',
+      'google/gemini-2.0-flash-exp:free',
+      'google/gemini-pro-1.5',
+      'deepseek/deepseek-chat',
+      'deepseek/deepseek-r1',
+      'qwen/qwen-2.5-coder-32b-instruct',
+      'mistralai/mistral-large',
+    ],
+  },
+  groq: {
+    label: 'Groq',
+    baseUrl: 'https://api.groq.com/openai/v1',
+    envKey: 'GROQ_API_KEY',
+    keyPrefix: 'gsk_',
+    docs: 'Groq LPU inference — fastest-token-per-second tier for Llama / Mixtral / Gemma. Auth: GROQ_API_KEY env var or in-app api-key.',
+    defaultModel: 'llama-3.3-70b-versatile',
+    suggestedModels: [
+      'llama-3.3-70b-versatile',
+      'llama-3.1-70b-versatile',
+      'llama-3.1-8b-instant',
+      'llama-3.2-90b-vision-preview',
+      'mixtral-8x7b-32768',
+      'gemma2-9b-it',
+      'qwen-2.5-coder-32b',
+      'qwen-2.5-32b',
+      'deepseek-r1-distill-llama-70b',
+    ],
+  },
+  together: {
+    label: 'Together AI',
+    baseUrl: 'https://api.together.xyz/v1',
+    envKey: 'TOGETHER_API_KEY',
+    docs: 'Together AI hosted inference for open-weight models (Llama, Mixtral, Qwen, DeepSeek, etc.). Auth: TOGETHER_API_KEY env var or in-app api-key.',
+    defaultModel: 'meta-llama/Llama-3.3-70B-Instruct-Turbo',
+    suggestedModels: [
+      'meta-llama/Llama-3.3-70B-Instruct-Turbo',
+      'meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo',
+      'meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo',
+      'meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo',
+      'mistralai/Mixtral-8x22B-Instruct-v0.1',
+      'mistralai/Mixtral-8x7B-Instruct-v0.1',
+      'Qwen/Qwen2.5-72B-Instruct-Turbo',
+      'Qwen/Qwen2.5-Coder-32B-Instruct',
+      'deepseek-ai/DeepSeek-V3',
+      'deepseek-ai/DeepSeek-R1',
+    ],
+  },
+  xai: {
+    label: 'xAI (Grok)',
+    baseUrl: 'https://api.x.ai/v1',
+    envKey: 'XAI_API_KEY',
+    altEnvKeys: ['GROK_API_KEY'],
+    keyPrefix: 'xai-',
+    docs: 'xAI Grok models. Auth: XAI_API_KEY env var or in-app api-key.',
+    defaultModel: 'grok-2-latest',
+    suggestedModels: [
+      'grok-2-latest',
+      'grok-2-1212',
+      'grok-2-vision-1212',
+      'grok-beta',
+      'grok-vision-beta',
+    ],
+  },
+  deepseek: {
+    label: 'DeepSeek',
+    baseUrl: 'https://api.deepseek.com/v1',
+    envKey: 'DEEPSEEK_API_KEY',
+    keyPrefix: 'sk-',
+    docs: 'DeepSeek (deepseek-chat / deepseek-reasoner). Auth: DEEPSEEK_API_KEY env var or in-app api-key.',
+    defaultModel: 'deepseek-chat',
+    suggestedModels: [
+      'deepseek-chat',
+      'deepseek-reasoner',
+      'deepseek-coder',
+    ],
+  },
+  mistral: {
+    label: 'Mistral La Plateforme',
+    baseUrl: 'https://api.mistral.ai/v1',
+    envKey: 'MISTRAL_API_KEY',
+    docs: 'Mistral La Plateforme (mistral-large, codestral, ministral, pixtral). Auth: MISTRAL_API_KEY env var or in-app api-key.',
+    defaultModel: 'mistral-large-latest',
+    suggestedModels: [
+      'mistral-large-latest',
+      'mistral-small-latest',
+      'codestral-latest',
+      'ministral-8b-latest',
+      'ministral-3b-latest',
+      'pixtral-large-latest',
+      'open-mistral-nemo',
+    ],
+  },
+  fireworks: {
+    label: 'Fireworks AI',
+    baseUrl: 'https://api.fireworks.ai/inference/v1',
+    envKey: 'FIREWORKS_API_KEY',
+    docs: 'Fireworks AI hosted models. Auth: FIREWORKS_API_KEY env var or in-app api-key.',
+    defaultModel: 'accounts/fireworks/models/llama-v3p3-70b-instruct',
+    suggestedModels: [
+      'accounts/fireworks/models/llama-v3p3-70b-instruct',
+      'accounts/fireworks/models/llama-v3p1-405b-instruct',
+      'accounts/fireworks/models/qwen2p5-coder-32b-instruct',
+      'accounts/fireworks/models/deepseek-r1',
+      'accounts/fireworks/models/deepseek-v3',
+      'accounts/fireworks/models/mixtral-8x22b-instruct',
+    ],
+  },
+};

package/providers/gemini_cli.mjs

@@ -133,6 +133,16 @@ export const geminiCliProvider = {
     const onAbort = () => { try { proc.kill('SIGTERM'); } catch (_) { /* ignore */ } };
     if (opts.signal) opts.signal.addEventListener('abort', onAbort);
 
+    // A missing binary surfaces as an ASYNC ChildProcess 'error' event on
+    // some platforms (the sync try/catch above doesn't see it). Without a
+    // listener that's an uncaughtException that kills the WHOLE process mid
+    // `providers test` — capture it and surface a per-provider CliMissingError
+    // instead (same fix claude_cli.mjs received in F8).
+    let spawnError = null;
+    const spawnErrorPromise = new Promise((resolve) => {
+      proc.once('error', (err) => { spawnError = err; resolve(); });
+    });
+
     let stdout = '';
     let stderr = '';
     proc.stdout.setEncoding('utf8');
@@ -140,9 +150,15 @@ export const geminiCliProvider = {
     proc.stdout.on('data', (c) => { stdout += c; });
     proc.stderr.on('data', (c) => { stderr += c; });
 
-    const exitInfo = await new Promise((resolve) => {
-      proc.on('close', (code, signal) => resolve({ code, signal }));
-    });
+    const exitInfo = await Promise.race([
+      new Promise((resolve) => { proc.on('close', (code, signal) => resolve({ code, signal })); }),
+      spawnErrorPromise.then(() => null),
+    ]);
+    if (spawnError) {
+      if (opts.signal) opts.signal.removeEventListener('abort', onAbort);
+      if (spawnError.code === 'ENOENT') throw new CliMissingError();
+      throw spawnError;
+    }
 
     try {
       if (opts.signal?.aborted) throw new AbortError('aborted mid-run');

package/providers/model_catalogue.mjs

@@ -11,13 +11,18 @@
 // Dependency-injected (no cli.mjs internals) so it stays import-light and
 // unit-testable with no network.
 
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
 /**
- * Whether a provider exposes an OpenAI-compatible `/v1/models` catalogue we
- * can live-fetch. True for openai, ollama, any builtin OpenAI-compat vendor
- * (nim / openrouter / groq / together / xai / deepseek / mistral /
- * fireworks), and any provider carrying an explicit `baseUrl` (custom
- * endpoints). False for anthropic / gemini / claude-cli / mock /
- * orchestrator.
+ * Whether a provider exposes a model catalogue we can live-fetch. True for
+ * openai, ollama, any builtin OpenAI-compat vendor (nim / openrouter / groq /
+ * together / xai / deepseek / mistral / fireworks), any provider carrying an
+ * explicit `baseUrl` (custom endpoints), and — via their NATIVE list
+ * endpoints — anthropic (`GET /v1/models`) and gemini
+ * (`GET /v1beta/models`). False for claude-cli (keyless subprocess, no
+ * catalogue endpoint) / mock / orchestrator.
  *
  * @param {object} meta       PROVIDER_INFO[providerId]
  * @param {string} providerId
@@ -28,9 +33,70 @@ export function supportsLiveFetch(meta, providerId) {
   return !!m.baseUrl
     || providerId === 'openai'
     || providerId === 'ollama'
+    || providerId === 'anthropic'
+    || providerId === 'gemini'
+    // Keyless CLI providers borrow the credential their vendor accepts
+    // (anthropic key / Claude Code OAuth token; gemini key; openai key or
+    // a plain key stored in ~/.codex/auth.json) — best-effort with an
+    // honest, actionable error when none is available.
+    || providerId === 'claude-cli'
+    || providerId === 'gemini-cli'
+    || providerId === 'codex-cli'
     || !!m.builtinOpenAICompat;
 }
 
+/**
+ * Live-list Anthropic models via the native Models API. Surfaces newly
+ * released models (e.g. claude-fable-5) the day they ship instead of waiting
+ * for a curated-list update. Sorted, deduped.
+ *
+ * @param {{apiKey:string, fetchImpl?:typeof fetch}} opts
+ * @returns {Promise<string[]>}
+ */
+export async function fetchAnthropicModels({ apiKey, oauthToken, fetchImpl } = {}) {
+  if (!apiKey && !oauthToken) throw new Error('anthropic model listing requires an api key (set ANTHROPIC_API_KEY or configure the provider)');
+  const f = fetchImpl || globalThis.fetch;
+  // OAuth tokens (Claude Code subscription login) authenticate with a Bearer
+  // header plus the documented oauth beta header; api keys use x-api-key.
+  const auth = apiKey
+    ? { 'x-api-key': apiKey }
+    : { 'authorization': `Bearer ${oauthToken}`, 'anthropic-beta': 'oauth-2025-04-20' };
+  const res = await f('https://api.anthropic.com/v1/models?limit=1000', {
+    method: 'GET',
+    headers: { ...auth, 'anthropic-version': '2023-06-01', 'accept': 'application/json' },
+  });
+  if (!res.ok) throw new Error(`anthropic /v1/models returned HTTP ${res.status}`);
+  const obj = await res.json();
+  const ids = (Array.isArray(obj?.data) ? obj.data : [])
+    .map((m) => m && m.id)
+    .filter((id) => typeof id === 'string');
+  return Array.from(new Set(ids)).sort((a, b) => a.localeCompare(b));
+}
+
+/**
+ * Live-list Gemini models via the Generative Language API, keeping only
+ * chat-capable entries (supportedGenerationMethods includes
+ * generateContent) and stripping the `models/` resource prefix.
+ *
+ * @param {{apiKey:string, fetchImpl?:typeof fetch}} opts
+ * @returns {Promise<string[]>}
+ */
+export async function fetchGeminiModels({ apiKey, fetchImpl } = {}) {
+  if (!apiKey) throw new Error('gemini model listing requires an api key (set GEMINI_API_KEY or configure the provider)');
+  const f = fetchImpl || globalThis.fetch;
+  const res = await f(`https://generativelanguage.googleapis.com/v1beta/models?pageSize=1000&key=${encodeURIComponent(apiKey)}`, {
+    method: 'GET',
+    headers: { 'accept': 'application/json' },
+  });
+  if (!res.ok) throw new Error(`gemini models list returned HTTP ${res.status}`);
+  const obj = await res.json();
+  const ids = (Array.isArray(obj?.models) ? obj.models : [])
+    .filter((m) => Array.isArray(m?.supportedGenerationMethods) && m.supportedGenerationMethods.includes('generateContent'))
+    .map((m) => String(m.name || '').replace(/^models\//, ''))
+    .filter(Boolean);
+  return Array.from(new Set(ids)).sort((a, b) => a.localeCompare(b));
+}
+
 /**
  * Resolve `{ baseUrl, apiKey }` for a provider's OpenAI-compatible
  * `/v1/models` endpoint. Returns `null` when the provider has no such
@@ -75,12 +141,79 @@ export function modelCatalogueFor({ cfg, registryMod, resolveAuthKey, providerId
  * @param {object} deps  same shape as {@link modelCatalogueFor}
  * @returns {Promise<string[]>}
  */
+// Claude Code OAuth token from the credential store `claude login` writes on
+// Linux / non-keychain setups. On macOS the token lives in the OS Keychain
+// (no file), so this returns null there — the caller falls through to its
+// honest "set ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN" error. Read-only;
+// the token is only ever sent to api.anthropic.com, never logged.
+export function _claudeCodeOAuthToken({ home, readFileSync } = {}) {
+  const h = home || os.homedir();
+  const read = readFileSync || fs.readFileSync;
+  for (const rel of ['.claude/.credentials.json', '.config/claude/.credentials.json']) {
+    try {
+      const j = JSON.parse(read(path.join(h, rel), 'utf8'));
+      const tok = j?.claudeAiOauth?.accessToken || j?.accessToken || j?.access_token;
+      if (typeof tok === 'string' && tok) return tok;
+    } catch { /* missing / unreadable / not JSON — try the next location */ }
+  }
+  return null;
+}
+
+// A plain API key stored by `codex login --api-key` in ~/.codex/auth.json.
+// ChatGPT-OAuth logins store an empty OPENAI_API_KEY object plus OAuth
+// tokens — those do NOT authenticate the platform /v1/models endpoint, so
+// they are deliberately ignored.
+export function _codexStoredApiKey({ home, readFileSync } = {}) {
+  const h = home || os.homedir();
+  const read = readFileSync || fs.readFileSync;
+  try {
+    const j = JSON.parse(read(path.join(h, '.codex/auth.json'), 'utf8'));
+    const k = j?.OPENAI_API_KEY;
+    if (typeof k === 'string' && k) return k;
+    if (k && typeof k === 'object' && typeof k.value === 'string' && k.value) return k.value;
+  } catch { /* missing / unreadable */ }
+  return null;
+}
+
 export async function fetchModelsForProvider(deps) {
-  const c = modelCatalogueFor(deps);
   const providerId = deps && deps.providerId;
+  const key = (id) => (typeof deps?.resolveAuthKey === 'function' ? deps.resolveAuthKey(id) : '') || '';
+  const credReader = deps?._credReader; // test seam: () => token|null per helper
+  // Native-API providers list through their own endpoints (they are not
+  // OpenAI-compatible). Env fallbacks cover the common keyless-config case.
+  if (providerId === 'anthropic') {
+    return fetchAnthropicModels({ apiKey: key('anthropic') || process.env.ANTHROPIC_API_KEY || '', fetchImpl: deps?.fetchImpl });
+  }
+  if (providerId === 'gemini') {
+    return fetchGeminiModels({ apiKey: key('gemini') || process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || '', fetchImpl: deps?.fetchImpl });
+  }
+  // Keyless CLI providers: borrow the credential their vendor accepts.
+  if (providerId === 'claude-cli') {
+    const apiKey = key('claude-cli') || key('anthropic') || process.env.ANTHROPIC_API_KEY || '';
+    if (apiKey) return fetchAnthropicModels({ apiKey, fetchImpl: deps?.fetchImpl });
+    const oauthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN
+      || (credReader ? credReader('claude') : _claudeCodeOAuthToken());
+    if (oauthToken) return fetchAnthropicModels({ oauthToken, fetchImpl: deps?.fetchImpl });
+    throw new Error('claude-cli model listing needs a credential: set ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN (on macOS the `claude` login lives in the Keychain, which is not readable here)');
+  }
+  if (providerId === 'gemini-cli') {
+    const apiKey = key('gemini-cli') || key('gemini') || process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || '';
+    if (apiKey) return fetchGeminiModels({ apiKey, fetchImpl: deps?.fetchImpl });
+    throw new Error('gemini-cli model listing needs a credential: set GEMINI_API_KEY or GOOGLE_API_KEY (the `gemini` CLI login token cannot list models)');
+  }
+  if (providerId === 'codex-cli') {
+    const apiKey = key('codex-cli') || key('openai') || process.env.OPENAI_API_KEY
+      || (credReader ? credReader('codex') : _codexStoredApiKey()) || '';
+    if (apiKey) {
+      const { fetchOpenAICompatModels } = await import('./openai_compat.mjs');
+      return fetchOpenAICompatModels({ baseUrl: 'https://api.openai.com/v1', apiKey, fetch: deps?.fetchImpl });
+    }
+    throw new Error('codex-cli model listing needs a credential: set OPENAI_API_KEY (a ChatGPT-plan `codex` login has no platform API key)');
+  }
+  const c = modelCatalogueFor(deps);
   if (!c) {
-    throw new Error(`provider "${providerId}" does not expose an OpenAI-compatible /v1/models endpoint`);
+    throw new Error(`provider "${providerId}" does not expose a model catalogue endpoint`);
   }
   const { fetchOpenAICompatModels } = await import('./openai_compat.mjs');
-  return fetchOpenAICompatModels({ baseUrl: c.baseUrl, apiKey: c.apiKey });
+  return fetchOpenAICompatModels({ baseUrl: c.baseUrl, apiKey: c.apiKey, fetch: deps?.fetchImpl });
 }

package/providers/registry.mjs

@@ -12,9 +12,12 @@ import { openaiProvider } from './openai.mjs';
 import { ollamaProvider } from './ollama.mjs';
 import { geminiProvider } from './gemini.mjs';
 import { claudeCliProvider } from './claude_cli.mjs';
+import { geminiCliProvider } from './gemini_cli.mjs';
+import { codexCliProvider } from './codex_cli.mjs';
 import { hasClaudeCliSession } from './claude_cli_detect.mjs';
 import { makeOpenAICompatProvider, fetchOpenAICompatModels } from './openai_compat.mjs';
 import { makeOrchestratorProvider } from './orchestrator.mjs';
+import { OPENAI_COMPAT_BUILTINS } from './compat_vendors.mjs';
 
 /**
  * @typedef {{ role: 'user'|'assistant'|'system', content: string }} ChatMessage
@@ -116,163 +119,10 @@ export function resolveTrainer(cfg, opts = {}) {
   return { provider: t.provider, model: t.model || chatModel };
 }
 
-// Built-in OpenAI-compatible vendors. Same wire format → one factory call
-// each. The picker treats these like first-class providers so users don't
-// have to walk through "+ Add a custom endpoint" for the popular ones.
-//
-// Each entry must define baseUrl + envKey (the env var the chat path
-// consults when no api-key is configured) + suggestedModels (curated list
-// shown before the user fetches the live /v1/models catalogue).
-//
-// Adding a new vendor: drop a row here. The PROVIDERS / PROVIDER_INFO loops
-// below pick it up automatically.
-export const OPENAI_COMPAT_BUILTINS = {
-  nim: {
-    label: 'NVIDIA NIM',
-    baseUrl: 'https://integrate.api.nvidia.com/v1',
-    envKey: 'NVIDIA_API_KEY',
-    altEnvKeys: ['NIM_API_KEY'],
-    keyPrefix: 'nvapi-',
-    docs: 'NVIDIA NIM hosted catalogue (Llama 3.x, Nemotron, DeepSeek-R1, Mixtral, Phi-3, Qwen, etc.). Auth: NVIDIA_API_KEY env var or in-app api-key. Endpoint speaks the OpenAI v1 wire format.',
-    defaultModel: 'meta/llama-3.1-405b-instruct',
-    suggestedModels: [
-      'meta/llama-3.1-405b-instruct',
-      'meta/llama-3.1-70b-instruct',
-      'meta/llama-3.1-8b-instruct',
-      'nvidia/llama-3.1-nemotron-70b-instruct',
-      'nvidia/nemotron-mini-4b-instruct',
-      'nvidia/llama-3.3-nemotron-super-49b-v1',
-      'mistralai/mistral-nemo-12b-instruct',
-      'mistralai/mixtral-8x22b-instruct-v0.1',
-      'microsoft/phi-3-medium-4k-instruct',
-      'deepseek-ai/deepseek-r1',
-      'qwen/qwen2.5-7b-instruct',
-      'qwen/qwen2.5-coder-32b-instruct',
-    ],
-  },
-  openrouter: {
-    label: 'OpenRouter',
-    baseUrl: 'https://openrouter.ai/api/v1',
-    envKey: 'OPENROUTER_API_KEY',
-    keyPrefix: 'sk-or-',
-    docs: 'OpenRouter unified gateway — 200+ models behind one OpenAI-compatible endpoint. Auth: OPENROUTER_API_KEY env var or in-app api-key. Uses x-title/HTTP-Referer headers for attribution.',
-    defaultModel: 'anthropic/claude-3.5-sonnet',
-    headers: { 'http-referer': 'https://github.com/cmblir/lazyclaude', 'x-title': 'lazyclaw' },
-    suggestedModels: [
-      'anthropic/claude-3.5-sonnet',
-      'anthropic/claude-3-opus',
-      'openai/gpt-4o',
-      'openai/gpt-4o-mini',
-      'openai/o1-preview',
-      'meta-llama/llama-3.1-405b-instruct',
-      'meta-llama/llama-3.3-70b-instruct',
-      'google/gemini-2.0-flash-exp:free',
-      'google/gemini-pro-1.5',
-      'deepseek/deepseek-chat',
-      'deepseek/deepseek-r1',
-      'qwen/qwen-2.5-coder-32b-instruct',
-      'mistralai/mistral-large',
-    ],
-  },
-  groq: {
-    label: 'Groq',
-    baseUrl: 'https://api.groq.com/openai/v1',
-    envKey: 'GROQ_API_KEY',
-    keyPrefix: 'gsk_',
-    docs: 'Groq LPU inference — fastest-token-per-second tier for Llama / Mixtral / Gemma. Auth: GROQ_API_KEY env var or in-app api-key.',
-    defaultModel: 'llama-3.3-70b-versatile',
-    suggestedModels: [
-      'llama-3.3-70b-versatile',
-      'llama-3.1-70b-versatile',
-      'llama-3.1-8b-instant',
-      'llama-3.2-90b-vision-preview',
-      'mixtral-8x7b-32768',
-      'gemma2-9b-it',
-      'qwen-2.5-coder-32b',
-      'qwen-2.5-32b',
-      'deepseek-r1-distill-llama-70b',
-    ],
-  },
-  together: {
-    label: 'Together AI',
-    baseUrl: 'https://api.together.xyz/v1',
-    envKey: 'TOGETHER_API_KEY',
-    docs: 'Together AI hosted inference for open-weight models (Llama, Mixtral, Qwen, DeepSeek, etc.). Auth: TOGETHER_API_KEY env var or in-app api-key.',
-    defaultModel: 'meta-llama/Llama-3.3-70B-Instruct-Turbo',
-    suggestedModels: [
-      'meta-llama/Llama-3.3-70B-Instruct-Turbo',
-      'meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo',
-      'meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo',
-      'meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo',
-      'mistralai/Mixtral-8x22B-Instruct-v0.1',
-      'mistralai/Mixtral-8x7B-Instruct-v0.1',
-      'Qwen/Qwen2.5-72B-Instruct-Turbo',
-      'Qwen/Qwen2.5-Coder-32B-Instruct',
-      'deepseek-ai/DeepSeek-V3',
-      'deepseek-ai/DeepSeek-R1',
-    ],
-  },
-  xai: {
-    label: 'xAI (Grok)',
-    baseUrl: 'https://api.x.ai/v1',
-    envKey: 'XAI_API_KEY',
-    altEnvKeys: ['GROK_API_KEY'],
-    keyPrefix: 'xai-',
-    docs: 'xAI Grok models. Auth: XAI_API_KEY env var or in-app api-key.',
-    defaultModel: 'grok-2-latest',
-    suggestedModels: [
-      'grok-2-latest',
-      'grok-2-1212',
-      'grok-2-vision-1212',
-      'grok-beta',
-      'grok-vision-beta',
-    ],
-  },
-  deepseek: {
-    label: 'DeepSeek',
-    baseUrl: 'https://api.deepseek.com/v1',
-    envKey: 'DEEPSEEK_API_KEY',
-    keyPrefix: 'sk-',
-    docs: 'DeepSeek (deepseek-chat / deepseek-reasoner). Auth: DEEPSEEK_API_KEY env var or in-app api-key.',
-    defaultModel: 'deepseek-chat',
-    suggestedModels: [
-      'deepseek-chat',
-      'deepseek-reasoner',
-      'deepseek-coder',
-    ],
-  },
-  mistral: {
-    label: 'Mistral La Plateforme',
-    baseUrl: 'https://api.mistral.ai/v1',
-    envKey: 'MISTRAL_API_KEY',
-    docs: 'Mistral La Plateforme (mistral-large, codestral, ministral, pixtral). Auth: MISTRAL_API_KEY env var or in-app api-key.',
-    defaultModel: 'mistral-large-latest',
-    suggestedModels: [
-      'mistral-large-latest',
-      'mistral-small-latest',
-      'codestral-latest',
-      'ministral-8b-latest',
-      'ministral-3b-latest',
-      'pixtral-large-latest',
-      'open-mistral-nemo',
-    ],
-  },
-  fireworks: {
-    label: 'Fireworks AI',
-    baseUrl: 'https://api.fireworks.ai/inference/v1',
-    envKey: 'FIREWORKS_API_KEY',
-    docs: 'Fireworks AI hosted models. Auth: FIREWORKS_API_KEY env var or in-app api-key.',
-    defaultModel: 'accounts/fireworks/models/llama-v3p3-70b-instruct',
-    suggestedModels: [
-      'accounts/fireworks/models/llama-v3p3-70b-instruct',
-      'accounts/fireworks/models/llama-v3p1-405b-instruct',
-      'accounts/fireworks/models/qwen2p5-coder-32b-instruct',
-      'accounts/fireworks/models/deepseek-r1',
-      'accounts/fireworks/models/deepseek-v3',
-      'accounts/fireworks/models/mixtral-8x22b-instruct',
-    ],
-  },
-};
+// Built-in OpenAI-compatible vendor catalogue — moved to
+// providers/compat_vendors.mjs (pure data; add new vendors THERE).
+// Re-exported below so existing importers keep working.
+export { OPENAI_COMPAT_BUILTINS } from './compat_vendors.mjs';
 
 // Insertion order is the picker order. The list goes first-to-last in
 // rough "user-familiar / popular" order so a first-time onboard lands
@@ -280,8 +130,11 @@ export const OPENAI_COMPAT_BUILTINS = {
 // user feedback ("gemini, codex 이런거 먼저 나오게끔").
 export const PROVIDERS = {
   // Tier 1 — popular / brand-name vendors users come in looking for.
+  // Keyless CLI variants sit next to their API siblings.
   gemini: geminiProvider,
+  'gemini-cli': geminiCliProvider,   // keyless — local `gemini` CLI login
   openai: openaiProvider,        // surfaces gpt-5-codex / gpt-5 / o3-pro etc.
+  'codex-cli': codexCliProvider,     // keyless — local `codex` CLI (ChatGPT plan)
   // Tier 2 — Claude. CLI variant first because it's keyless.
   'claude-cli': claudeCliProvider,
   anthropic: anthropicProvider,
@@ -340,7 +193,10 @@ export const PROVIDER_INFO = {
     endpoint: 'subprocess: claude -p',
     defaultModel: 'claude-opus-4-7',
     suggestedModels: [
+      'claude-fable-5',
+      'claude-opus-4-8',
       'claude-opus-4-7',
+      'claude-opus-4-6',
       'claude-sonnet-4-6',
       'claude-haiku-4-5',
       'opus',
@@ -348,6 +204,22 @@ export const PROVIDER_INFO = {
       'haiku',
     ],
   },
+  'gemini-cli': {
+    name: 'gemini-cli',
+    requiresApiKey: false,
+    docs: 'Google Gemini via the local `gemini` CLI (free Google-account login). No API key — auth flows through whatever account `gemini` is logged in with. Requires @google/gemini-cli installed.',
+    endpoint: 'subprocess: gemini -p',
+    defaultModel: 'gemini-2.5-pro',
+    suggestedModels: ['gemini-2.5-pro', 'gemini-2.5-flash', 'pro', 'flash'],
+  },
+  'codex-cli': {
+    name: 'codex-cli',
+    requiresApiKey: false,
+    docs: 'OpenAI via the local `codex` CLI (ChatGPT Plus/Pro subscription). No API key — auth flows through `codex` login. Requires the codex CLI installed.',
+    endpoint: 'subprocess: codex exec',
+    defaultModel: 'gpt-5-codex',
+    suggestedModels: ['gpt-5-codex', 'gpt-5', 'o3'],
+  },
   anthropic: {
     name: 'anthropic',
     requiresApiKey: true,
@@ -356,13 +228,13 @@ export const PROVIDER_INFO = {
     endpoint: 'https://api.anthropic.com/v1/messages',
     defaultModel: 'claude-opus-4-7',
     suggestedModels: [
+      'claude-fable-5',
+      'claude-opus-4-8',
       'claude-opus-4-7',
       'claude-opus-4-6',
       'claude-sonnet-4-6',
       'claude-sonnet-4-5',
       'claude-haiku-4-5',
-      'claude-3-5-sonnet-20241022',
-      'claude-3-5-haiku-20241022',
     ],
   },
   openai: {
@@ -395,9 +267,6 @@ export const PROVIDER_INFO = {
       'gemini-2.5-pro',
       'gemini-2.5-flash',
       'gemini-2.0-flash',
-      'gemini-2.0-flash-thinking-exp',
-      'gemini-1.5-pro',
-      'gemini-1.5-flash',
     ],
   },
   ollama: {

package/tui/config_picker.mjs

@@ -0,0 +1,54 @@
+// tui/config_picker.mjs — the `/config` slash: change ONE setting without
+// re-running the whole wizard.
+//
+// Split of duties (user-requested):
+//   /setup  — first-run / full re-setup: leaves chat and runs EVERY wizard
+//             step (the behavior /config used to have).
+//   /config — settings editor: pick a single item. In-chat items (provider /
+//             model / context / trainer / orchestrator) delegate to their
+//             existing slash handlers and stay inside chat; credential items
+//             (channel tokens, outbound webhook) need readline prompts, so
+//             they unmount, run JUST that step, and re-enter chat.
+//
+// On the legacy readline path (no ctx.openPicker modal) /config falls back
+// to the full wizard — same as before, no silent degradation.
+
+const CONFIG_ITEMS = [
+  { id: 'provider',     label: 'provider',            desc: 'switch the chat provider (family → vendor picker)' },
+  { id: 'model',        label: 'model',               desc: 'switch the model (live list when the provider supports it)' },
+  { id: 'context',      label: 'context window',      desc: 'history turns / token budget sent per turn' },
+  { id: 'trainer',      label: 'trainer',             desc: 'learning-loop provider/model (auto = $0 on claude-cli)' },
+  { id: 'orchestrator', label: 'orchestrator',        desc: 'multi-agent on/off, planner, workers' },
+  { id: 'channel',      label: 'channel credentials', desc: 'Slack/Telegram/Matrix tokens — leaves chat for the prompts, then returns' },
+  { id: 'webhook',      label: 'outbound webhook',    desc: 'message-send webhook URL — leaves chat, then returns' },
+  { id: 'wizard',       label: 'everything (full wizard)', desc: 'rerun all setup steps — same as /setup' },
+];
+
+export async function runConfigSlash(_args, ctx, handlers) {
+  if (typeof ctx.openPicker !== 'function') {
+    // Legacy readline path has no modal picker — keep the old /config
+    // behavior there (full wizard) rather than failing.
+    ctx.requestSetup = true;
+    return 'EXIT';
+  }
+  const picked = await ctx.openPicker({
+    kind: 'config-item',
+    title: 'config — change one setting',
+    subtitle: 'Enter to edit · Esc to cancel · /setup reruns the whole wizard',
+    items: CONFIG_ITEMS.map((i) => ({ id: i.id, label: i.label, desc: i.desc })),
+  });
+  const id = typeof picked === 'string' ? picked : (picked && picked.id);
+  if (!id || id === 'CANCEL') return 'config: cancelled';
+  if (id === 'wizard') { ctx.requestSetup = true; return 'EXIT'; }
+  if (id === 'channel' || id === 'webhook') {
+    // These steps need raw readline prompts (secrets), so the REPL unmounts,
+    // chat.mjs runs the single step, and chat restarts automatically.
+    ctx.requestConfigStep = id;
+    return 'EXIT';
+  }
+  const handler = handlers && handlers.get && handlers.get(`/${id}`);
+  if (!handler) return `config: no in-chat editor for "${id}"`;
+  return handler('', ctx);
+}
+
+export { CONFIG_ITEMS };

package/tui/editor.mjs

@@ -422,7 +422,12 @@ export function Editor({
     try {
       process.stdout.write(`${undo}\x1b[${rowsUp}A\x1b[${colTarget}G\x1b[?25h`);
     } catch { /* stdout closed — swallow */ }
-  }, [state.buffer, state.cursor, altEnabled]);
+  });
+  // ^ NO dependency array — re-anchor after EVERY commit. Renders triggered
+  // by OTHER components (status-bar ticks, streaming output) redraw the
+  // frame and park the terminal cursor below it; with buffer-only deps the
+  // anchor didn't re-run and the cursor drifted out of the box whenever the
+  // user wasn't typing. The pending-offset undo above makes repeats safe.
 
   const lines = state.buffer.split('\n');
   // Ink's <Text wrap="wrap"> uses wrap-ansi (string-width aware) but the
@@ -446,6 +451,17 @@ export function Editor({
       });
     }
   }
+  // Always-visible caret: an inverse-video cell drawn AT the cursor (the
+  // editor has no mid-line cursor movement, so the cursor is always at the
+  // end of the buffer — including column 0 of an empty box). The real
+  // terminal cursor is anchored to the same cell for IME pre-edit; this
+  // glyph keeps the position visible even between anchor writes (e.g.
+  // while another component renders). Hidden while a modal picker owns
+  // the keyboard so it can't masquerade as an active prompt.
+  if (!modalOpen && renderedLines.length > 0) {
+    const last = renderedLines[renderedLines.length - 1];
+    last.text = `${last.text}\x1b[7m \x1b[27m`;
+  }
   return React.createElement(
     Box,
     {

package/tui/pickers.mjs

@@ -417,13 +417,13 @@ export async function _arrowMenu({ title, subtitle, footer, items, defaultIdx =
 // here (rather than registry.mjs) because it's a UX concept, not
 // an intrinsic provider attribute.
 export function _providerFamilies() {
-  // Membership (api/cli/mock, orchestrator excluded) is shared with the Ink
-  // picker via tui/provider_families.mjs so both paths bucket identically.
-  // The ANSI tags below are readline-specific, so they're applied here.
+  // Membership (api/cli/meta/mock) is shared with the Ink picker via
+  // tui/provider_families.mjs; the ANSI tags below are readline-specific.
   const b = _bucketProviders(getRegistry());
   return {
     api: { label: 'API key', desc: 'paste an sk-... key during setup',  tag: '\x1b[38;5;245m[needs key]\x1b[0m', members: b.api },
     cli: { label: 'CLI / Local', desc: 'keyless — uses an existing CLI login or a local daemon', tag: '\x1b[38;5;208m[no key]\x1b[0m', members: b.cli },
+    meta: { label: 'Multi-agent', desc: 'orchestrator — fan a task out to a planner + workers (advanced)', tag: '\x1b[38;5;245m[meta]\x1b[0m', members: b.meta },
     mock: { label: 'Mock', desc: 'offline echo, only useful for testing', tag: '\x1b[38;5;245m[test]\x1b[0m', members: b.mock },
   };
 }

package/tui/provider_families.mjs

@@ -5,17 +5,18 @@
 // (API key / CLI-Local / Mock) as shared, unit-testable data so both the
 // readline picker (cli.mjs) and the Ink dispatcher use one bucketing rule.
 
-// Bucket every registered provider into one of three auth families.
-// orchestrator is excluded entirely (strictly opt-in; never a wizard
-// default — see cli.mjs v5.3.2 note). Returns { api:[], cli:[], mock:[] }
-// of provider-id strings.
+// Bucket every registered provider into one of four auth families.
+// orchestrator sits in its own `meta` family — visible and pickable, but
+// never a wizard default (the cursor always starts on api/cli — see the
+// cli.mjs v5.3.2 note). Returns { api:[], cli:[], mock:[], meta:[] } of
+// provider-id strings.
 export function bucketProviders(registry) {
   const info = (registry && registry.PROVIDER_INFO) || {};
   const all = Object.keys((registry && registry.PROVIDERS) || {});
-  const out = { api: [], cli: [], mock: [] };
+  const out = { api: [], cli: [], mock: [], meta: [] };
   for (const name of all) {
     if (name === 'mock') out.mock.push(name);
-    else if (name === 'orchestrator') continue;
+    else if (name === 'orchestrator') out.meta.push(name);
     else if ((info[name] || {}).requiresApiKey) out.api.push(name);
     else out.cli.push(name);
   }
@@ -29,6 +30,7 @@ export function providerFamilies(registry) {
   return {
     api: { id: 'api', label: 'API key', desc: 'paste an sk-... key', tag: 'needs key', members: b.api },
     cli: { id: 'cli', label: 'CLI / Local', desc: 'keyless — an existing CLI login or a local daemon', tag: 'no key', members: b.cli },
+    meta: { id: 'meta', label: 'Multi-agent', desc: 'orchestrator — fan a task out to a planner + workers (advanced)', tag: 'meta', members: b.meta },
     mock: { id: 'mock', label: 'Mock', desc: 'offline echo, only useful for testing', tag: 'test', members: b.mock },
   };
 }

package/tui/slash_commands.mjs

@@ -26,7 +26,8 @@ export const SLASH_COMMANDS = [
   { cmd: '/personality', help: 'pick a personality (or sub: list|show|install|remove|use)' },
   { cmd: '/dashboard',   help: 'open the lazyclaw web UI in your browser' },
   { cmd: '/menu',        help: 'browse the full subcommand catalog (command palette)' },
-  { cmd: '/config',      help: 'leave chat and re-run the setup wizard (provider, model, channels)' },
+  { cmd: '/setup',       help: 'first-run / full re-setup: leave chat and run every wizard step' },
+  { cmd: '/config',      help: 'change ONE setting: provider, model, context, channel creds, webhook, …' },
   { cmd: '/channels',    help: 'view configured channels; /channels <name> on|off to toggle' },
   { cmd: '/orchestrator', help: 'multi-agent: status | on | off | planner <spec> | worker add|remove <spec>' },
   { cmd: '/context',      help: 'chat history window: status | turns <N> | tokens <N>' },

package/tui/slash_dispatcher.mjs

@@ -1,8 +1,6 @@
 // tui/slash_dispatcher.mjs — single source of slash-command routing for the
 // Ink chat REPL (v5.4). Lifted from cli.mjs's legacy readline handler so the
-// Ink branch stops shipping the "not yet wired" placeholder and so future
-// channels (Slack/Telegram inline commands, /handoff cross-channel control)
-// can share one dispatch table.
+// Ink branch and future channel surfaces share one dispatch table.
 //
 // Contract:
 //   dispatchSlash(cmd, args, ctx, write) → Promise<string|'EXIT'|void>
@@ -1814,17 +1812,18 @@ export const SLASH_HANDLERS = new Map([
   ['/channels', _channels],
   ['/orchestrator', _orchestrator],
   ['/context', _context],
-  // /config — unmount and let chat.mjs run the setup wizard (ctx.requestSetup).
-  ['/config', async (_a, ctx) => { ctx.requestSetup = true; return 'EXIT'; }],
+  // /setup — full wizard (every step); /config — pick ONE setting to change
+  // (in-chat where possible; credential steps unmount, run, re-enter chat).
+  ['/setup', async (_a, ctx) => { ctx.requestSetup = true; return 'EXIT'; }],
+  ['/config', async (a, ctx) => (await import('./config_picker.mjs')).runConfigSlash(a, ctx, SLASH_HANDLERS)],
   ['/exit', async () => 'EXIT'],
   ['/quit', async () => 'EXIT'],
 ]);
 
 /**
- * Primary entry point. Resolves the command name to a handler in
- * SLASH_HANDLERS and invokes it. Unknown commands return a friendly
- * "unknown" string (caller renders to scrollback) rather than throwing,
- * so the user sees feedback instead of an error toast.
+ * Primary entry point. Resolves the command name to a SLASH_HANDLERS entry
+ * and invokes it. Unknown commands return a friendly "unknown" string
+ * (rendered to scrollback) rather than throwing.
  */
 export async function dispatchSlash(cmd, args, ctx, write) {
   const handler = SLASH_HANDLERS.get(cmd);