@asobacloud/nehanda 0.6.1 → 0.7.0

package/README.md

@@ -51,31 +51,32 @@ ona-code
 
 ### 3. Provider Setup
 
-#### Option A: Nehanda Cloud (Default)
-
-The CLI defaults to the primary Nehanda endpoint (`https://nehanda-ml.asoba.co/v1`). If an API key is required:
-
-```
-❯ /key
-New Nehanda API key: <your-key>
-```
-
-#### Option B: Local LM Studio
-
-Start LM Studio locally on port `1234` or `8000`, then start the CLI. Select or switch models via:
+Use a single Goose-style wizard — provider, API key, host, and model in one flow. The CLI discovers available models from the provider (`GET /v1/models` with your key, or Ollama `/api/tags`).
 
 ```
 ❯ /model
-```
 
-#### Option C: Remote Ollama over LAN
+◆  Which provider?
+│  ● OpenRouter
+└
+◆  API key
+│  sk-or-v1-…
+└
+◆  API host
+│  https://openrouter.ai/api/v1
+└
+  Fetching models from provider…
+◆  Model
+│  ● openai/gpt-4o
+└
+  ✓ Provider / host / model saved — session active
+```
 
-To connect to an Ollama instance running on your network:
+Shortcuts:
+- `/key openrouter sk-…` — saves the key, then continues into the same host → discover → model steps
+- `/config` — read-only status (provider, model, endpoint, which keys are set)
 
-```
-❯ /config base_url http://AsobaCorp-1.local:11434/v1
-❯ /model ollama/deepseek-coder-v2:latest
-```
+Local Ollama / LM Studio: pick that provider in `/model`, accept or edit the host, then choose from the discovered catalog (or enter a custom name if discovery fails).
 
 ---
 
@@ -326,9 +327,9 @@ Place the script at `lib/scripts/my-new-tool.py`. It will receive arguments inte
 | Command | Description |
 |---|---|
 | `/help` | Display available commands |
-| `/model [name]` | Discover and switch active provider or model endpoint |
-| `/key` | Save Nehanda API key |
-| `/config` | View or set settings (e.g., `/config base_url <url>`) |
+| `/model` | Configure provider → API key → host → discover models → select (single wizard) |
+| `/key [provider] [value]` | Save API key then continue the configure wizard (`openrouter`, `zhipu`, `openai`, or Nehanda default) |
+| `/config` | Show provider, model, endpoint, and key status (read-only) |
 | `/mcp` | Manage MCP server connections (see below) |
 | `/clear` | Clear conversation history and reset transcript state |
 | `/retry` | Resend the last failed request |
@@ -497,6 +498,10 @@ node tests/unit/ui_legibility_behavioral.mjs
 
 ## Changelog
 
+### 0.7.0
+
+- **Unified `/model` configure wizard with keyed discovery (`lib/configureProvider.mjs`, `lib/modelDiscovery.mjs`, `bin/nehanda-ui.mjs`):** Provider setup is a single Goose-style flow — provider → API key → host → live model catalog → select → persist. OpenRouter / OpenAI-compat / Zhipu / Nehanda / LM Studio discover via authenticated `GET {base}/models`; Ollama keeps `/api/tags`. Discovery failure falls back to custom model name. `/key <provider>` chains into the same wizard tail. `/config` is read-only status. Behavioral coverage in `tests/unit/configure_provider_behavioral.mjs`. Closes #8.
+
 ### 0.6.1
 
 - **Fix: Laya provisioning smoke test (`lib/scripts/ensure-laya-env.sh`):** The `Router()` constructibility check was missing `import sys`, causing `npm install` to fail with `NameError: name 'sys' is not defined` even when all packages installed successfully. The marker file was never written, leaving the CLI in a permanently broken state despite a complete venv. Fixed.

package/bin/agent.mjs

@@ -20,7 +20,7 @@ import { getPhase, canTransition, setPhase } from '../lib/workflow.mjs'
 import { executeBuiltinTool, invalidateMcpToolCache } from '../lib/tools.mjs'
 import { appendEntry, makeUserPayload, makeToolResultPayload } from '../lib/transcript.mjs'
 import { loadInstructions } from '../lib/instructions.mjs'
-import { discoverOllamaModels, formatModelList } from '../lib/modelDiscovery.mjs'
+import { discoverModelsForProvider, formatModelList } from '../lib/modelDiscovery.mjs'
 import { compactConversation } from '../lib/compact.mjs'
 import { createTeam, getTeam, listTeams, deleteTeam } from '../lib/team.mjs'
 import { ensureLayaReady } from '../lib/laya_sidecar.mjs'
@@ -259,25 +259,26 @@ Session:
         app.addSystemMessage('No provider configured. Use /model to set a provider first.')
         return
       }
-      
+
       if (!supportsDiscovery(provider)) {
-        app.addSystemMessage(`Model discovery is not supported for provider: ${provider}\n\nProviders with discovery support:\n  ollama\n\nFor other providers, use /model <provider>/<model-name> directly.`)
+        app.addSystemMessage(`Model discovery is not supported for provider: ${provider}\n\nUse /model to configure a discoverable provider.`)
         return
       }
-      
-      // Get base URL for the provider
+
       const baseUrl = getBaseUrlForProvider(provider, settings)
-      
+      const apiKey = settings.model_config?.api_key
+        || (provider === 'zhipu' ? resolveZhipuApiKey() : resolveOpenAiCompatKey())
+
       app.addSystemMessage(`Discovering models from ${baseUrl}...`)
-      
+
       try {
-        const result = await discoverOllamaModels(baseUrl, { timeout: 5000 })
-        
+        const result = await discoverModelsForProvider(provider, { baseUrl, apiKey, timeout: 5000 })
+
         if (!result.success) {
-          app.addSystemMessage(`\nDiscovery failed: ${result.error}\n\nTroubleshooting:\n  • Make sure Ollama is running: ollama serve\n  • Check the base URL in settings: /config\n  • Verify network connectivity to ${baseUrl}`)
+          app.addSystemMessage(`\nDiscovery failed: ${result.error}\n\nTroubleshooting:\n  • Check the API key (/key)\n  • Check the base URL in settings: /config\n  • Verify network connectivity to ${baseUrl}`)
           return
         }
-        
+
         const formatted = formatModelList(result.models)
         app.addSystemMessage(`\n${formatted}`)
       } catch (error) {
@@ -842,32 +843,31 @@ async function mainPipe(opts) {
         io.println(ui.colors.error('  No provider configured. Use /model to set a provider first.'))
         continue
       }
-      
+
       if (!supportsDiscovery(provider)) {
         io.println(ui.colors.error(`  Model discovery is not supported for provider: ${provider}`))
-        io.println(`\n  ${ui.colors.header('Providers with discovery support:')}`)
-        io.println('    ollama')
-        io.println(`\n  ${ui.colors.dim('For other providers, use /model <provider>/<model-name> directly.')}`)
+        io.println(`\n  ${ui.colors.dim('Use /model to configure a discoverable provider.')}`)
         continue
       }
-      
-      // Get base URL for the provider
+
       const baseUrl = getBaseUrlForProvider(provider, settings)
-      
+      const apiKey = settings.model_config?.api_key
+        || (provider === 'zhipu' ? resolveZhipuApiKey() : resolveOpenAiCompatKey())
+
       io.println(`\n  Discovering models from ${baseUrl}...\n`)
-      
+
       try {
-        const result = await discoverOllamaModels(baseUrl, { timeout: 5000 })
-        
+        const result = await discoverModelsForProvider(provider, { baseUrl, apiKey, timeout: 5000 })
+
         if (!result.success) {
           io.println(ui.colors.error(`  Discovery failed: ${result.error}`))
           io.println(`\n  ${ui.colors.header('Troubleshooting:')}`)
-          io.println('    • Make sure Ollama is running: ollama serve')
+          io.println('    • Check the API key (/key)')
           io.println('    • Check the base URL in settings: /config')
           io.println(`    • Verify network connectivity to ${baseUrl}\n`)
           continue
         }
-        
+
         const formatted = formatModelList(result.models)
         io.println(formatted)
       } catch (error) {

package/bin/nehanda-ui.mjs

@@ -18,6 +18,7 @@ import { fileURLToPath } from 'node:url'
 import { runUserTurn } from '../lib/orchestrate.mjs'
 import { loadInstructions } from '../lib/instructions.mjs'
 import { modelConfigFromAgent } from '../lib/modelConfig.mjs'
+import { runConfigureWizard } from '../lib/configureProvider.mjs'
 import { applyMcpConfig, loadMcpConfig, writeGlobalMcpConfig, readGlobalMcpConfig, globalMcpConfigPath, updateMcpServerEnv } from '../lib/mcp-config.mjs'
 import { getMcpServer, closeAllMcpServers, listMcpServers, mcpListResources } from '../lib/mcp.mjs'
 import { invalidateMcpToolCache } from '../lib/tools.mjs'
@@ -137,8 +138,8 @@ function renderMd(text) {
 // ── Constants ────────────────────────────────────────────────
 const SPINNER_FRAMES = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏']
 const SLASH_COMMANDS = [
-  { name: '/model',  desc: 'Change model endpoint' },
-  { name: '/key',    desc: 'Set API key (/key, /key openrouter, /key zhipu, /key openai)' },
+  { name: '/model',  desc: 'Configure provider, key, host, and model (single wizard)' },
+  { name: '/key',    desc: 'Set API key then continue configure (/key openrouter|zhipu|openai)' },
   { name: '/config', desc: 'Show current config' },
   { name: '/mcp',    desc: 'MCP server & tool management (/mcp list)' },
   { name: '/clear',  desc: 'New conversation' },
@@ -147,41 +148,6 @@ const SLASH_COMMANDS = [
   { name: '/exit',   desc: 'Quit' },
 ]
 
-// ── Model registry ────────────────────────────────────────────
-const DEFAULT_REGISTRY = {
-  ollama_hosts: ['http://AsobaCorp-1.local:11434'],
-  models: [
-    { name: 'nehanda-rag-synthesis-27b', endpoint: 'https://nehanda-ml.asoba.co/v1',   label: 'Nehanda 27B (EC2)',          desc: 'Primary — fine-tuned Qwen3.6 27B, vLLM, af-south-1' },
-    { name: 'deepseek-coder-v2:latest',  endpoint: 'http://AsobaCorp-1.local:11434/v1', label: 'DeepSeek Coder V2 (LAN)',    desc: 'Windows LAN delegate — coding specialist' },
-    { name: 'qwen2.5:14b',              endpoint: 'http://AsobaCorp-1.local:11434/v1', label: 'Qwen 2.5 14B (LAN)',          desc: 'Windows LAN delegate — general reasoning' },
-  ],
-}
-function readRegistry() {
-  try { return JSON.parse(fs.readFileSync(path.join(AIMEE_DIR, 'model-registry.json'), 'utf8')) }
-  catch { return DEFAULT_REGISTRY }
-}
-async function discoverOllamaModels(hosts) {
-  const out = []
-  await Promise.all(hosts.map(async host => {
-    const base = host.replace(/\/$/, '')
-    try {
-      const res = await fetch(`${base}/api/tags`, { signal: AbortSignal.timeout(2000) })
-      if (!res.ok) return
-      const data = await res.json()
-      for (const m of (data.models || []))
-        out.push({ name: m.name, endpoint: `${base}/v1`, label: `${m.name} (${new URL(base).hostname})`, desc: `Discovered — ${m.name}`, discovered: true })
-    } catch {}
-  }))
-  return out
-}
-async function buildModelList() {
-  const reg  = readRegistry()
-  const base = reg.models || []
-  const disc = await discoverOllamaModels(reg.ollama_hosts || [])
-  const keys = new Set(base.map(m => `${m.name}|${m.endpoint}`))
-  return [...base, ...disc.filter(m => !keys.has(`${m.name}|${m.endpoint}`))]
-}
-
 // ── Asoba lock-up (compact) ───────────────────────────────────
 function AsobaMark() {
   return e(Box, { flexDirection: 'column', alignItems: 'center' },
@@ -390,6 +356,7 @@ function BlockConfirmMenu({ payload, onDecide }) {
 }
 
 function TokenFooter({ calls, model }) {
+  const cols = process.stdout.columns || 80
   return e(Box, { flexDirection: 'column' },
     e(Text, { dimColor: true }, '─'.repeat(cols)),
     e(Box, { flexDirection: 'row', paddingX: 1, justifyContent: 'space-between' },
@@ -517,6 +484,58 @@ function stripThink(text) {
     .trim()
 }
 
+/**
+ * UI adapter for Goose-style configure wizard (#8).
+ * Persists agents.json + runtimeSettings.model_config atomically at the end.
+ */
+async function runUiConfigureWizard(bridge, opts = {}) {
+  try {
+    const result = await runConfigureWizard({
+      ask: q => bridge.ask(q),
+      select: (title, items) => bridge.select(title, items),
+      notify: msg => bridge.addMessage({ role: 'system', text: `  ${msg}` }),
+      resolveExistingKey: async (preset) => {
+        if (preset.keySlot === 'nehanda') return readApiKey()
+        if (preset.keySlot === 'zhipu') return resolveZhipuApiKey()
+        if (preset.keySlot === 'openai_compat') return resolveOpenAiCompatKey()
+        return ''
+      },
+      saveKey: async ({ slot, key }) => {
+        if (slot === 'nehanda') writeApiKey(key)
+        else if (slot === 'zhipu') saveSecureCredentials({ zhipuApiKey: key })
+        else if (slot === 'openai_compat') saveOpenAiCompatKey(key)
+      },
+      persist: async (cfg) => {
+        const data = readAgents()
+        const ag = data.agents?.find(a => a.name === data.default_agent) || data.agents?.[0]
+        if (ag) {
+          ag.model = cfg.model
+          ag.endpoint = cfg.endpoint
+          if (cfg.provider === 'nehanda' && cfg.apiKey) ag.api_key = cfg.apiKey
+        }
+        fs.writeFileSync(AGENTS_JSON, JSON.stringify(data, null, 2), 'utf8')
+        runtimeSettings.model_config = cfg.model_config || modelConfigFromAgent(
+          { model: cfg.model, endpoint: cfg.endpoint },
+          { apiKey: cfg.apiKey || readApiKey() },
+        )
+      },
+    }, opts)
+
+    if (!result) {
+      bridge.addMessage({ role: 'system', text: '  Configure cancelled.' })
+      return
+    }
+    bridge.refreshModel()
+    bridge.addMessage({ role: 'system', text: [
+      `  ${chalk.green('✓')} Provider → ${chalk.bold(result.provider)}`,
+      `  ${chalk.green('✓')} Host     → ${chalk.dim(result.endpoint)}`,
+      `  ${chalk.green('✓')} Model    → ${chalk.bold(result.model)}`,
+    ].join('\n') })
+  } catch (err) {
+    bridge.addMessage({ role: 'error', text: 'Configure failed: ' + err.message })
+  }
+}
+
 // ── Command handler ───────────────────────────────────────────
 async function handleCommand(cmd, bridge) {
   const [name] = cmd.split(/\s+/)
@@ -529,14 +548,17 @@ async function handleCommand(cmd, bridge) {
   if (name === '/config') {
     const data = readAgents()
     const ag   = data.agents?.find(a => a.name === data.default_agent) || data.agents?.[0]
+    const mc   = runtimeSettings?.model_config
     const compatKeySet = !!resolveOpenAiCompatKey()
     const zhipuKeySet  = !!resolveZhipuApiKey()
     bridge.addMessage({ role: 'system', text: [
-      '', `  Model:             ${chalk.hex(BRAND.accent)(ag?.model || '—')}`,
-      `  Endpoint:          ${chalk.dim(ag?.endpoint || '—')}`,
+      '', `  Provider:          ${chalk.hex(BRAND.accent)(mc?.provider || '—')}`,
+      `  Model:             ${chalk.hex(BRAND.accent)(ag?.model || mc?.custom_model_name || '—')}`,
+      `  Endpoint:          ${chalk.dim(ag?.endpoint || mc?.base_url || '—')}`,
       `  Nehanda key:       ${readApiKey() ? chalk.green('set') : chalk.hex(BRAND.red)('not set')}`,
       `  OpenAI-compat key: ${compatKeySet ? chalk.green('set') : chalk.dim('not set')}`,
-      `  Zhipu key:         ${zhipuKeySet  ? chalk.green('set') : chalk.dim('not set')}`, '',
+      `  Zhipu key:         ${zhipuKeySet  ? chalk.green('set') : chalk.dim('not set')}`,
+      `  ${chalk.dim('Use /model to configure provider, key, host, and model in one flow.')}`, '',
     ].join('\n') })
     return
   }
@@ -552,74 +574,43 @@ async function handleCommand(cmd, bridge) {
   }
   if (name === '/exit' || name === '/quit') { bridge.exit(); process.exit(0) }
   if (name === '/key') {
-    // Parse optional provider subcommand: /key [openrouter|zhipu|openai] [value]
+    // /key [openrouter|zhipu|openai|nehanda] [value] — save key then continue configure wizard
     const parts = cmd.trim().split(/\s+/)
-    const sub   = parts[1] || ''
-    const KNOWN_COMPAT_PROVIDERS = ['openrouter', 'openai', 'zhipu']
+    const sub   = (parts[1] || '').toLowerCase()
+    const KEY_TO_PRESET = {
+      openrouter: 'openrouter',
+      openai: 'openai_compatible',
+      zhipu: 'zhipu',
+      nehanda: 'nehanda',
+    }
 
-    if (!sub || !KNOWN_COMPAT_PROVIDERS.includes(sub.toLowerCase())) {
-      // Default: Nehanda API key (existing behaviour, unchanged)
+    if (!sub || !KEY_TO_PRESET[sub]) {
       const answer = await bridge.ask('New Nehanda API key:')
       if (!answer) return
-      try { writeApiKey(answer); bridge.addMessage({ role: 'system', text: `  ${chalk.green('✓')} Nehanda API key updated.` }) }
-      catch (err) { bridge.addMessage({ role: 'error', text: 'Failed: ' + err.message }) }
+      try {
+        writeApiKey(answer)
+        bridge.addMessage({ role: 'system', text: `  ${chalk.green('✓')} Nehanda API key saved — continuing configure…` })
+        await runUiConfigureWizard(bridge, { presetId: 'nehanda', prefilledKey: answer })
+      } catch (err) { bridge.addMessage({ role: 'error', text: 'Failed: ' + err.message }) }
       return
     }
 
-    const provider = sub.toLowerCase()
-    // Value may be provided inline (/key openrouter sk-...) or prompted
-    const inlineValue = parts.slice(2).join('').trim()
-    const answer = inlineValue || await bridge.ask(`New ${provider} API key:`)
+    const presetId = KEY_TO_PRESET[sub]
+    const inlineValue = parts.slice(2).join(' ').trim()
+    const answer = inlineValue || await bridge.ask(`New ${sub} API key:`)
     if (!answer) return
 
     try {
-      if (provider === 'zhipu') {
-        saveSecureCredentials({ zhipuApiKey: answer })
-        bridge.addMessage({ role: 'system', text: `  ${chalk.green('✓')} Zhipu API key saved to secure storage.` })
-      } else {
-        // openrouter or openai — both use the openaiCompatApiKey slot
-        saveOpenAiCompatKey(answer)
-        if (provider === 'openrouter') {
-          // Auto-configure base_url and provider for OpenRouter
-          runtimeSettings.model_config = {
-            ...runtimeSettings.model_config,
-            base_url: 'https://openrouter.ai/api/v1',
-            provider: 'openai_compatible',
-          }
-          bridge.addMessage({ role: 'system', text: [
-            `  ${chalk.green('✓')} OpenRouter API key saved to secure storage.`,
-            `  ${chalk.green('✓')} Base URL set to ${chalk.dim('https://openrouter.ai/api/v1')}`,
-            `  ${chalk.dim('Use /model to select an OpenRouter model (e.g. openai_compatible/anthropic/claude-3.5-sonnet)')}`,
-          ].join('\n') })
-        } else {
-          bridge.addMessage({ role: 'system', text: `  ${chalk.green('✓')} OpenAI-compat API key saved to secure storage.` })
-        }
-      }
+      if (sub === 'zhipu') saveSecureCredentials({ zhipuApiKey: answer })
+      else if (sub === 'nehanda') writeApiKey(answer)
+      else saveOpenAiCompatKey(answer)
+      bridge.addMessage({ role: 'system', text: `  ${chalk.green('✓')} ${sub} API key saved — continuing configure…` })
+      await runUiConfigureWizard(bridge, { presetId, prefilledKey: answer })
     } catch (err) { bridge.addMessage({ role: 'error', text: 'Failed: ' + err.message }) }
     return
   }
   if (name === '/model') {
-    bridge.addMessage({ role: 'system', text: '  Discovering models…' })
-    const all   = await buildModelList()
-    const data0 = readAgents()
-    const curAg = data0.agents?.find(a => a.name === data0.default_agent) || data0.agents?.[0]
-    const cur   = curAg?.model || ''
-    const items = all.map(m => ({ ...m, label: m.name === cur ? `${m.label} ✓` : m.label }))
-    const sel   = await bridge.select('Select model', items)
-    if (!sel) return
-    try {
-      const data = readAgents()
-      const ag   = data.agents?.find(a => a.name === data.default_agent) || data.agents?.[0]
-      if (ag) { ag.model = sel.name; ag.endpoint = sel.endpoint }
-      fs.writeFileSync(AGENTS_JSON, JSON.stringify(data, null, 2), 'utf8')
-      // Keep in-session model_config in sync so the next turn uses the selected wire name
-      runtimeSettings.model_config = modelConfigFromAgent(
-        ag || { model: sel.name, endpoint: sel.endpoint },
-        { apiKey: readApiKey() },
-      )
-      bridge.refreshModel()
-      bridge.addMessage({ role: 'system', text: `  ${chalk.green('✓')} Model → ${chalk.bold(sel.name)}` })
-    } catch (err) { bridge.addMessage({ role: 'error', text: 'Failed: ' + err.message }) }
+    await runUiConfigureWizard(bridge)
     return
   }
   if (name === '/mcp') {
@@ -862,6 +853,8 @@ bridge.onSubmit = async (text) => {
       // field belongs to aimee and was silently reintroducing conflicting tool-call
       // syntax (<tool_call><name>...) that fights orchestrate.mjs's [TOOL_CALL] format.
       onaInstructions: onaInstructionsContent || null,
+      // Esc/Ctrl+C abort — must reach fetch / Anthropic stream (issue #7).
+      signal:          controller.signal,
       settings: {
         ...runtimeSettings,
         model_config: modelConfig,
@@ -914,7 +907,7 @@ bridge.onSubmit = async (text) => {
     bridge.lastFailedText = null
 
   } catch (err) {
-    if (err.name === 'AbortError') {
+    if (err.name === 'AbortError' || err.name === 'APIUserAbortError') {
       bridge.endAssistant({ role: 'assistant', text: lastPartial, cancelled: true })
     } else {
       bridge.discardAssistant()

package/lib/configureProvider.mjs

@@ -0,0 +1,254 @@
+/**
+ * Goose-style provider configure wizard (#8).
+ * Single flow: provider → API key → host → keyed model discovery → persist.
+ */
+
+import {
+  discoverOpenAiCompatModels,
+  discoverOllamaModels,
+} from './modelDiscovery.mjs'
+
+/** @typedef {{ id: string, label: string, provider: string, defaultHost: string, needsKey: boolean, keySlot: string|null, discovery: 'openai'|'ollama' }} ProviderPreset */
+
+/** @type {ProviderPreset[]} */
+export const PROVIDER_PRESETS = [
+  {
+    id: 'nehanda',
+    label: 'Nehanda Cloud',
+    provider: 'nehanda',
+    defaultHost: 'https://nehanda-ml.asoba.co/v1',
+    needsKey: true,
+    keySlot: 'nehanda',
+    discovery: 'openai',
+  },
+  {
+    id: 'openrouter',
+    label: 'OpenRouter',
+    provider: 'openai_compatible',
+    defaultHost: 'https://openrouter.ai/api/v1',
+    needsKey: true,
+    keySlot: 'openai_compat',
+    discovery: 'openai',
+  },
+  {
+    id: 'openai_compatible',
+    label: 'OpenAI-compatible',
+    provider: 'openai_compatible',
+    defaultHost: 'https://api.openai.com/v1',
+    needsKey: true,
+    keySlot: 'openai_compat',
+    discovery: 'openai',
+  },
+  {
+    id: 'zhipu',
+    label: 'Zhipu (z.ai)',
+    provider: 'zhipu',
+    defaultHost: 'https://open.bigmodel.cn/api/paas/v4',
+    needsKey: true,
+    keySlot: 'zhipu',
+    discovery: 'openai',
+  },
+  {
+    id: 'ollama',
+    label: 'Ollama (local / LAN)',
+    provider: 'ollama',
+    defaultHost: 'http://localhost:11434',
+    needsKey: false,
+    keySlot: null,
+    discovery: 'ollama',
+  },
+  {
+    id: 'lm_studio',
+    label: 'LM Studio',
+    provider: 'lm_studio_local',
+    defaultHost: 'http://localhost:1234/v1',
+    needsKey: false,
+    keySlot: 'openai_compat',
+    discovery: 'openai',
+  },
+]
+
+export function normalizeOpenAiBaseUrl(host) {
+  const h = String(host || '').trim().replace(/\/+$/, '')
+  if (!h) return ''
+  return h
+}
+
+/** Ollama tags API wants host without trailing /v1. */
+export function normalizeOllamaHost(host) {
+  return String(host || '').trim().replace(/\/+$/, '').replace(/\/v1$/i, '')
+}
+
+/** Persist endpoint for agents.json — OpenAI-compat style /v1 for Ollama. */
+export function endpointForAgent(preset, host) {
+  if (preset.discovery === 'ollama') {
+    const base = normalizeOllamaHost(host)
+    return base ? `${base}/v1` : ''
+  }
+  return normalizeOpenAiBaseUrl(host)
+}
+
+/**
+ * Discover models for a preset using host + optional API key.
+ * @param {ProviderPreset} preset
+ * @param {{ host: string, apiKey?: string, timeout?: number }} opts
+ */
+export async function discoverModelsForPreset(preset, opts = {}) {
+  const timeout = opts.timeout || 5000
+  if (preset.discovery === 'ollama') {
+    const host = normalizeOllamaHost(opts.host)
+    return discoverOllamaModels(host, { timeout })
+  }
+  const host = normalizeOpenAiBaseUrl(opts.host)
+  return discoverOpenAiCompatModels(host, { apiKey: opts.apiKey || '', timeout })
+}
+
+/**
+ * Interactive configure wizard.
+ *
+ * @param {object} deps
+ * @param {(q: string) => Promise<string>} deps.ask
+ * @param {(title: string, items: object[]) => Promise<object|null>} deps.select
+ * @param {(msg: string) => void} [deps.notify]
+ * @param {(ctx: {preset, host, apiKey}) => Promise<{success, models?, error?}>} [deps.discover]
+ * @param {(args: {slot: string, key: string}) => Promise<void>} [deps.saveKey]
+ * @param {(preset: ProviderPreset) => Promise<string>} [deps.resolveExistingKey]
+ * @param {(cfg: object) => Promise<void>} [deps.persist]
+ * @param {{ presetId?: string, prefilledKey?: string }} [opts]
+ * @returns {Promise<object|null>} configured result or null if cancelled
+ */
+export async function runConfigureWizard(deps, opts = {}) {
+  const ask = deps.ask
+  const select = deps.select
+  const notify = deps.notify || (() => {})
+  const discover = deps.discover || ((ctx) => discoverModelsForPreset(ctx.preset, ctx))
+  const saveKey = deps.saveKey || (async () => {})
+  const resolveExistingKey = deps.resolveExistingKey || (async () => '')
+  const persist = deps.persist || (async () => {})
+
+  let preset
+  if (opts.presetId) {
+    preset = PROVIDER_PRESETS.find(p => p.id === opts.presetId)
+    if (!preset) throw new Error(`Unknown provider preset: ${opts.presetId}`)
+  } else {
+    const items = PROVIDER_PRESETS.map(p => ({
+      id: p.id,
+      label: p.label,
+      desc: p.defaultHost,
+      ...p,
+    }))
+    const picked = await select('Which provider?', items)
+    if (!picked) return null
+    preset = PROVIDER_PRESETS.find(p => p.id === picked.id) || picked
+  }
+
+  // ── API key ────────────────────────────────────────────────
+  let apiKey = typeof opts.prefilledKey === 'string' ? opts.prefilledKey.trim() : ''
+  let keyDirty = false
+
+  if (preset.needsKey && !apiKey) {
+    const existing = (await resolveExistingKey(preset)) || ''
+    if (existing) {
+      const choice = await select('Update API key?', [
+        { id: 'keep', label: 'Keep existing key', desc: 'Use the key already in secure storage' },
+        { id: 'replace', label: 'Replace key', desc: 'Enter a new API key' },
+      ])
+      if (!choice) return null
+      if (choice.id === 'replace') {
+        const entered = await ask(`${preset.label} API key:`)
+        if (!entered) return null
+        apiKey = entered.trim()
+        keyDirty = true
+      } else {
+        apiKey = existing
+      }
+    } else {
+      const entered = await ask(`${preset.label} API key:`)
+      if (!entered) return null
+      apiKey = entered.trim()
+      keyDirty = true
+    }
+  } else if (preset.needsKey && apiKey && opts.prefilledKey) {
+    // Key already saved by /key — do not re-save
+    keyDirty = false
+  }
+
+  // ── Host ───────────────────────────────────────────────────
+  const hostPrompt = preset.discovery === 'ollama'
+    ? `Ollama host [${preset.defaultHost}]:`
+    : `API host [${preset.defaultHost}]:`
+  const hostAnswer = await ask(hostPrompt)
+  const host = (hostAnswer && hostAnswer.trim()) || preset.defaultHost
+  if (!host) return null
+
+  const endpoint = endpointForAgent(preset, host)
+  if (!endpoint) return null
+
+  // ── Discovery ──────────────────────────────────────────────
+  notify('Fetching models from provider…')
+  let discovered = []
+  let discoveryError = null
+  try {
+    const result = await discover({
+      preset,
+      host: preset.discovery === 'ollama' ? normalizeOllamaHost(host) : normalizeOpenAiBaseUrl(host),
+      apiKey,
+    })
+    if (result?.success && Array.isArray(result.models)) {
+      discovered = result.models
+    } else {
+      discoveryError = result?.error || 'Discovery failed'
+      notify(`Discovery failed: ${discoveryError}`)
+    }
+  } catch (err) {
+    discoveryError = err.message
+    notify(`Discovery failed: ${discoveryError}`)
+  }
+
+  const modelItems = discovered.map(m => ({
+    id: m.name,
+    name: m.name,
+    label: m.name,
+    desc: 'Discovered',
+    endpoint,
+  }))
+  modelItems.push({
+    id: '__custom__',
+    name: '__custom__',
+    label: '(enter custom name…)',
+    desc: discoveryError ? 'Discovery unavailable — type a model id' : 'Type a model id not listed above',
+    endpoint,
+  })
+
+  const modelPick = await select('Select model', modelItems)
+  if (!modelPick) return null
+
+  let modelName = modelPick.name
+  if (modelPick.id === '__custom__' || modelName === '__custom__') {
+    const custom = await ask('Custom model name:')
+    if (!custom || !custom.trim()) return null
+    modelName = custom.trim()
+  }
+
+  if (keyDirty && preset.keySlot && apiKey) {
+    await saveKey({ slot: preset.keySlot, key: apiKey })
+  }
+
+  const cfg = {
+    presetId: preset.id,
+    provider: preset.provider,
+    model: modelName,
+    endpoint,
+    apiKey: preset.needsKey ? apiKey : (preset.provider === 'ollama' ? 'ollama' : apiKey),
+    model_config: {
+      provider: preset.provider,
+      model_id: modelName,
+      custom_model_name: modelName,
+      base_url: endpoint,
+      api_key: preset.provider === 'ollama' ? 'ollama' : apiKey,
+    },
+  }
+
+  await persist(cfg)
+  return cfg
+}

package/lib/modelConfig.mjs

@@ -38,12 +38,14 @@ const PROVIDER_CAPABILITIES = {
   openai_compatible: {
     supportsCustomModels: true,
     requiresHardcodedMap: false,
-    supportsDiscovery: false,
+    supportsDiscovery: true,
+    discoveryEndpoint: '/models',
   },
   zhipu: {
-    supportsCustomModels: false,
-    requiresHardcodedMap: true,
-    supportsDiscovery: false,
+    supportsCustomModels: true,
+    requiresHardcodedMap: false,
+    supportsDiscovery: true,
+    discoveryEndpoint: '/models',
   },
   ollama: {
     supportsCustomModels: true,
@@ -54,12 +56,14 @@ const PROVIDER_CAPABILITIES = {
   lm_studio_local: {
     supportsCustomModels: true,
     requiresHardcodedMap: false,
-    supportsDiscovery: false,
+    supportsDiscovery: true,
+    discoveryEndpoint: '/models',
   },
   nehanda: {
-    supportsCustomModels: false,
-    requiresHardcodedMap: true,
-    supportsDiscovery: false,
+    supportsCustomModels: true,
+    requiresHardcodedMap: false,
+    supportsDiscovery: true,
+    discoveryEndpoint: '/models',
     omitToolChoice: true,
   },
 }
@@ -118,16 +122,22 @@ export function modelConfigFromAgent(agent, { apiKey = '', defaultEndpoint = DEF
   const isNehanda = model === DEFAULT_NEHANDA_MODEL || /nehanda-ml\.asoba\.co/.test(endpoint)
 
   if (isNehanda) {
+    const isDefault = model === DEFAULT_NEHANDA_MODEL
     return {
       provider: 'nehanda',
       model_id: 'nehanda_rag_synthesis_27b',
-      custom_model_name: null,
+      // Discovered / non-default names ride as custom_model_name (#8)
+      custom_model_name: isDefault ? null : model,
       base_url: endpoint,
       api_key: apiKey,
     }
   }
 
-  const provider = /:11434\b/.test(endpoint) ? 'ollama' : 'openai_compatible'
+  let provider = 'openai_compatible'
+  if (/:11434\b/.test(endpoint)) provider = 'ollama'
+  else if (/bigmodel\.cn|\.z\.ai\b/.test(endpoint)) provider = 'zhipu'
+  else if (/:1234\b|:8000\b/.test(endpoint)) provider = 'lm_studio_local'
+
   return {
     provider,
     model_id: model,

package/lib/modelDiscovery.mjs

@@ -1,6 +1,6 @@
 /**
  * Model Discovery Service
- * Queries Ollama API to discover available models
+ * Queries Ollama (/api/tags) and OpenAI-compatible (/v1/models) endpoints.
  */
 
 import http from 'node:http'
@@ -232,6 +232,130 @@ export async function discoverOllamaModels(baseUrl, options = {}) {
   }
 }
 
+/**
+ * Normalize an OpenAI-compatible base URL so `{base}/models` resolves correctly.
+ * Accepts either `https://host/v1` or `https://host`.
+ */
+export function normalizeOpenAiCompatBase(baseUrl) {
+  if (!baseUrl || typeof baseUrl !== 'string') return ''
+  // Do not force /v1 — Zhipu and similar hosts use paths like /api/paas/v4.
+  return baseUrl.trim().replace(/\/+$/, '')
+}
+
+/**
+ * Strip trailing /v1 so Ollama `/api/tags` is hit on the root host.
+ */
+export function normalizeOllamaBase(baseUrl) {
+  if (!baseUrl || typeof baseUrl !== 'string') return ''
+  return baseUrl.trim().replace(/\/+$/, '').replace(/\/v1$/i, '')
+}
+
+function isEmbeddingModelId(id) {
+  return /embedding|whisper|tts|dall-e|moderation/i.test(id)
+}
+
+/**
+ * Discover models from an OpenAI-compatible `/v1/models` endpoint (keyed).
+ * @param {string} baseUrl - e.g. https://openrouter.ai/api/v1
+ * @param {Object} options
+ * @param {string} [options.apiKey] - Bearer token (optional for local servers)
+ * @param {number} [options.timeout=5000]
+ * @returns {Promise<{success:boolean, models?:Array<{name:string}>, error?:string}>}
+ */
+export async function discoverOpenAiCompatModels(baseUrl, options = {}) {
+  const timeout = options.timeout || 5000
+  const apiKey = typeof options.apiKey === 'string' ? options.apiKey.trim() : ''
+  const cleanBase = normalizeOpenAiCompatBase(baseUrl)
+  if (!cleanBase) {
+    return { success: false, error: 'Base URL is required for model discovery.' }
+  }
+  const discoveryUrl = `${cleanBase}/models`
+
+  try {
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), timeout)
+    let response
+    try {
+      const headers = { Accept: 'application/json' }
+      if (apiKey) headers.Authorization = `Bearer ${apiKey}`
+      response = await fetch(discoveryUrl, { method: 'GET', signal: controller.signal, headers })
+    } finally {
+      clearTimeout(timeoutId)
+    }
+
+    if (!response.ok) {
+      const statusText = response.statusText || 'Unknown error'
+      if (response.status === 401 || response.status === 403) {
+        return {
+          success: false,
+          error: `Authentication failed (${response.status}): ${statusText}. Check the API key.`,
+        }
+      }
+      return {
+        success: false,
+        error: `HTTP error (${response.status}): ${statusText}`,
+      }
+    }
+
+    let data
+    try {
+      data = await response.json()
+    } catch (parseError) {
+      return { success: false, error: `Invalid JSON response from server: ${parseError.message}` }
+    }
+
+    const rows = Array.isArray(data?.data) ? data.data
+      : Array.isArray(data?.models) ? data.models
+      : null
+    if (!rows) {
+      return { success: false, error: 'Invalid response format: expected OpenAI-style { data: [...] }' }
+    }
+
+    const models = []
+    const seen = new Set()
+    for (const row of rows) {
+      const id = typeof row?.id === 'string' ? row.id.trim()
+        : typeof row?.name === 'string' ? row.name.trim()
+        : ''
+      if (!id || isEmbeddingModelId(id) || seen.has(id)) continue
+      seen.add(id)
+      models.push({ name: id })
+    }
+
+    return { success: true, models }
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      return {
+        success: false,
+        error: `Request timed out after ${timeout}ms. The server may be slow or unreachable.`,
+      }
+    }
+    if (error.code === 'ECONNREFUSED' || (error.message && error.message.includes('fetch failed'))) {
+      return {
+        success: false,
+        error: `Cannot connect to ${cleanBase}. Check the host and network.`,
+      }
+    }
+    return { success: false, error: `Discovery failed: ${error.message}` }
+  }
+}
+
+/**
+ * Route discovery by provider id (used by bin/agent.mjs `/models`).
+ * @param {string} provider
+ * @param {{ baseUrl: string, apiKey?: string, timeout?: number }} opts
+ */
+export async function discoverModelsForProvider(provider, opts = {}) {
+  const timeout = opts.timeout || 5000
+  if (provider === 'ollama') {
+    return discoverOllamaModels(normalizeOllamaBase(opts.baseUrl), { timeout })
+  }
+  return discoverOpenAiCompatModels(opts.baseUrl, {
+    apiKey: opts.apiKey || '',
+    timeout,
+  })
+}
+
 /**
  * Format a list of models for display
  * @param {Array} models - Array of model objects from discovery

package/lib/openaiCompat.mjs

@@ -28,7 +28,16 @@ function stripThinkingTraces(text) {
   return text.trim()
 }
 
-export async function streamOpenAIChatCompletion({ baseUrl, apiKey, model, messages, tools, io, maxTokens = 8192, bufferOutput = true, num_ctx: numCtx, omitToolChoice: skipToolChoice = false, useStream = true }) {
+/** True for DOM AbortError and Anthropic SDK APIUserAbortError. */
+export function isAbortError(e) {
+  if (!e) return false
+  if (e.name === 'AbortError' || e.name === 'APIUserAbortError') return true
+  if (e.constructor?.name === 'APIUserAbortError') return true
+  const msg = String(e.message || '')
+  return msg === 'Request was aborted.' || /operation was aborted/i.test(msg)
+}
+
+export async function streamOpenAIChatCompletion({ baseUrl, apiKey, model, messages, tools, io, maxTokens = 8192, bufferOutput = true, num_ctx: numCtx, omitToolChoice: skipToolChoice = false, useStream = true, signal } = {}) {
   const url = `${String(baseUrl).replace(/\/$/, '')}/chat/completions`
   const body = { model, messages, stream: useStream, max_tokens: maxTokens }
   // Suppress tool_choice:"auto" for providers that do not support it (e.g. Nehanda
@@ -41,6 +50,7 @@ export async function streamOpenAIChatCompletion({ baseUrl, apiKey, model, messa
     method: 'POST',
     headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
     body: JSON.stringify(body),
+    signal,
   })
 
   if (!res.ok) {

package/lib/orchestrate.mjs

@@ -8,7 +8,7 @@ import { runHooks } from './hookplane.mjs'
 import { appendEntry, transcriptToAnthropicMessages, transcriptToOpenAIMessages, makeUserPayload, makeAssistantPayload, makeToolResultPayload, applyEpistemicFilter } from './transcript.mjs'
 import { evaluatePermission } from './permissions.mjs'
 import { executeBuiltinTool, anthropicToolDefinitions, openAICompatToolDefinitions, LOCAL_CORE_TOOLS, EXPLORE_ONLY_TOOLS, dynamicTools, getMcpToolDefinitions } from './tools.mjs'
-import { streamOpenAIChatCompletion } from './openaiCompat.mjs'
+import { streamOpenAIChatCompletion, isAbortError } from './openaiCompat.mjs'
 import { withTransaction } from './store.mjs'
 import { getPhase, setPhase, canTransition } from './workflow.mjs'
 import { buildJevSystem2Messages } from './compact.mjs'
@@ -425,6 +425,16 @@ function classifyError(e) {
   return 'unknown'
 }
 
+/** Re-throw user aborts so Esc is not swallowed as a soft model failure (issue #7). */
+function rethrowIfAborted(e) {
+  if (!isAbortError(e)) return
+  if (e.name === 'AbortError') throw e
+  const err = new Error('abort')
+  err.name = 'AbortError'
+  err.cause = e
+  throw err
+}
+
 async function askHuman(io, q) {
   if (!process.stdin.isTTY) return true
   if (io?.ask) return (await io.ask(q)).trim().toLowerCase().startsWith('y')
@@ -637,13 +647,14 @@ If this file is not relevant to the task, say "Not relevant" and nothing else.`
         model: rt._model,
         max_tokens: 512,
         messages: [{ role: 'user', content: prompt }],
-      })
+      }, { signal: rt.signal })
       const summary = sanitizeModelText(response.content?.[0]?.text || '')
       trackTokens(rt.sessionId, response.usage?.input_tokens, response.usage?.output_tokens)
       if (summary && !/^not relevant/i.test(summary)) {
         summaries.push({ path, header, summary })
       }
-    } catch {
+    } catch (e) {
+      rethrowIfAborted(e)
       summaries.push({ path, header, summary: '(summarization failed — see header)' })
     }
     if (io.spinner) io.spinner.stop()
@@ -681,13 +692,15 @@ If this file is not relevant to the task, say "Not relevant" and nothing else.`
         bufferOutput: true,
         maxTokens: 512,
         numCtx: rt.settings?.model_config?.num_ctx,
+        signal: rt.signal,
       })
       const summary = sanitizeModelText(out.bufferedText || '')
       if (out.usage) trackTokens(rt.sessionId, out.usage.prompt_tokens, out.usage.completion_tokens)
       if (summary && !/^not relevant/i.test(summary)) {
         summaries.push({ path, header, summary })
       }
-    } catch {
+    } catch (e) {
+      rethrowIfAborted(e)
       summaries.push({ path, header, summary: '(summarization failed — see header)' })
     }
     if (io.spinner) io.spinner.stop()
@@ -829,7 +842,10 @@ async function runAnthropicSummaryTurn(db, rt, io, hookRt, client, summaryPrompt
 
   let bufferedText = ''
   try {
-    const stream = await client.messages.stream({ model: rt._model, max_tokens: 1024, system, messages, tools: [] })
+    const stream = await client.messages.stream(
+      { model: rt._model, max_tokens: 1024, system, messages, tools: [] },
+      { signal: rt.signal },
+    )
     for await (const ev of stream) {
       if (ev.type === 'content_block_delta' && ev.delta?.type === 'text_delta' && ev.delta.text) {
         bufferedText += ev.delta.text
@@ -839,6 +855,7 @@ async function runAnthropicSummaryTurn(db, rt, io, hookRt, client, summaryPrompt
     trackTokens(rt.sessionId, final.usage?.input_tokens, final.usage?.output_tokens)
     appendEntry(db, rt.sessionId, 'assistant', makeAssistantPayload(mapAnthropicContent(final.content || [])))
   } catch (e) {
+    rethrowIfAborted(e)
     if (io.spinner) io.spinner.stop()
     return null
   }
@@ -857,11 +874,12 @@ async function runOpenAICompatSummaryTurn(db, rt, io, hookRt, provider, baseUrl,
 
   let result = null
   try {
-    const out = await streamOpenAIChatCompletion({ baseUrl, apiKey, model: rt._model, messages, tools: [], io, bufferOutput: true, numCtx: rt.settings?.model_config?.num_ctx })
+    const out = await streamOpenAIChatCompletion({ baseUrl, apiKey, model: rt._model, messages, tools: [], io, bufferOutput: true, numCtx: rt.settings?.model_config?.num_ctx, signal: rt.signal })
     if (out.usage) trackTokens(rt.sessionId, out.usage.prompt_tokens, out.usage.completion_tokens)
     appendEntry(db, rt.sessionId, 'assistant', makeAssistantPayload(out.assistantBlocks))
     result = sanitizeModelText(out.bufferedText)
-  } catch {
+  } catch (e) {
+    rethrowIfAborted(e)
   }
   if (io.spinner) io.spinner.stop()
   return result
@@ -878,7 +896,10 @@ async function runAnthropicPhase(db, rt, io, hookRt, client, tools, phase) {
 
     let assistantBlocks = [], stopReason = null, bufferedText = ''
     try {
-      const stream = await client.messages.stream({ model: rt._model, max_tokens: 8192, system, messages, tools: filteredTools })
+      const stream = await client.messages.stream(
+        { model: rt._model, max_tokens: 8192, system, messages, tools: filteredTools },
+        { signal: rt.signal },
+      )
       for await (const ev of stream) {
         if (ev.type === 'content_block_delta' && ev.delta?.type === 'text_delta' && ev.delta.text) {
           bufferedText += ev.delta.text
@@ -893,6 +914,7 @@ async function runAnthropicPhase(db, rt, io, hookRt, client, tools, phase) {
       assistantBlocks = mapAnthropicContent(final.content || [])
       trackTokens(rt.sessionId, final.usage?.input_tokens, final.usage?.output_tokens)
     } catch (e) {
+      rethrowIfAborted(e)
       if (io.spinner) io.spinner.stop()
       await runHooks(db, hookRt, 'StopFailure', { error: classifyError(e), error_details: e.message })
       io.println(`\n[model error] ${e.message}`)
@@ -942,7 +964,7 @@ async function runOpenAICompatPhase(db, rt, io, hookRt, provider, baseUrl, apiKe
       // on top of the prompt-injected instructions, producing malformed hybrid output
       // like {"Glob", "arguments": {...}} instead of {"name": "Glob", "arguments": {...}}.
       const toolsForRequest = xmlInstructions ? [] : filteredTools
-      const out = await streamOpenAIChatCompletion({ baseUrl, apiKey, model: rt._model, messages, tools: toolsForRequest, io, bufferOutput: true, numCtx: rt.settings?.model_config?.num_ctx, omitToolChoice: omitToolChoice(provider), useStream: !omitToolChoice(provider) })
+      const out = await streamOpenAIChatCompletion({ baseUrl, apiKey, model: rt._model, messages, tools: toolsForRequest, io, bufferOutput: true, numCtx: rt.settings?.model_config?.num_ctx, omitToolChoice: omitToolChoice(provider), useStream: !omitToolChoice(provider), signal: rt.signal })
       assistantBlocks = out.assistantBlocks
       bufferedText = out.bufferedText
       finishReason = out.finishReason
@@ -962,6 +984,7 @@ async function runOpenAICompatPhase(db, rt, io, hookRt, provider, baseUrl, apiKe
 
       if (out.usage) trackTokens(rt.sessionId, out.usage.prompt_tokens, out.usage.completion_tokens)
     } catch (e) {
+      rethrowIfAborted(e)
       if (e.message?.includes('does not support tools') && activeTools.length > 0) {
         if (io.spinner) io.spinner.stop()
         io.println('\n[info] Model switching to manual tool injection...')

package/lib/ui.mjs

@@ -120,12 +120,12 @@ export function formatHelp(provider, dbPath) {
     cmd('/compact', 'Compact conversation'),
     cmd('/team', 'Manage teams'),
     '',
-    cmd('/model [name]', 'Change model'),
+    cmd('/model', 'Configure provider, key, host, model'),
+    cmd('/key [provider] [value]', 'Save API key then continue configure'),
     cmd('/login', 'Store credentials'),
     cmd('/logout', 'Clear credentials'),
     cmd('/status', 'Auth status'),
-    cmd('/config', 'Show / set settings'),
-    cmd('/config set <key> <value>', 'Set any config value'),
+    cmd('/config', 'Show provider / model / key status'),
     cmd('/mcp', 'MCP server management & guide'),
     cmd('/mcp list', 'List all discovered tools & descriptions'),
     cmd('/mcp status', 'Show configured MCP servers'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asobacloud/nehanda",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "type": "module",
   "description": "Agentic terminal REPL and single-process engine for governed AI deep research and software development. Connects to Nehanda v3, OpenRouter, Ollama, LM Studio, ZhipuAI, or any OpenAI-compatible API. Includes Laya System-1 control plane for memory management, pre-execution safety gating, and intent-driven instruction shaping.",
   "keywords": [