@kinqs/brainrouter-cli 0.3.6 → 0.3.7

package/dist/cli/commands/mcp.js

@@ -1,53 +1,71 @@
 /**
- * 0.3.6 item 11: `/mcp` slash-command surface. Scope-limited foundation —
- * the full multi-MCP federation (parallel cross-MCP tool calls, MCP
- * marketplace, capability tiers) is deferred to 0.4.0. What ships here:
+ * `/mcp` slash-command surface. 0.3.7 multi-MCP rewrite — third-party
+ * MCPs connect concurrently while BrainRouter MCP profiles are mutually
+ * exclusive so exactly one brain is active at a time.
  *
- *   /mcp           — show status of the active MCP (alias for /mcp list)
- *   /mcp list      — list every configured profile with identity + status
- *   /mcp reconnect — reconnect the currently-active profile
- *   /mcp tools     — list MCP tools grouped by namespace (pre-Item-11
- *                    `/mcp` no-arg behaviour, moved here verbatim)
+ *   /mcp                    — alias for /mcp list
+ *   /mcp list               — every configured profile + per-server status
+ *   /mcp tools [server]     — MCP tools grouped by `mcp__<server>__*`
+ *                             namespace; pass a server id to scope
+ *   /mcp connect <name>     — connect a configured server that's idle/offline
+ *   /mcp disconnect <name>  — close one server's transport (config preserved)
+ *   /mcp reconnect [name]   — reconnect ONE (when name given) or the selected pool
  *
- * The reconnect path leans on `mcpClient.close()` + `mcpClient.connect()`
- * with the same config the CLI launched against — no plumbing required
- * for the user beyond typing the command.
+ * Backwards-compat: `/mcp reconnect` with no arg reconnects the same
+ * selected set used at boot: all third-party MCPs plus the active
+ * BrainRouter MCP. Pass an explicit name to target one.
  */
 import chalk from 'chalk';
 import { spinner as makeSpinner } from '../spinner.js';
+import { saveConfig } from '../../config/config.js';
+import { resolveIdentityFromConfig } from '../../runtime/mcpClient.js';
+import { selectMcpServerIds } from '../../runtime/mcpPool.js';
+import { buildBannerInputs, renderBanner } from '../banner.js';
+import { resolveTheme } from '../theme.js';
 export async function tryHandleMcpCommand(ctx) {
     const { command, args, mcpClient, config } = ctx;
     if (command !== '/mcp')
         return false;
     const sub = (args[0] ?? 'list').toLowerCase();
+    const targetName = args[1]?.trim();
     if (sub === 'tools') {
-        // Pre-Item-11 `/mcp` no-arg behaviour: namespace-grouped tool listing.
-        // Kept verbatim under a subcommand so the muscle memory survives.
-        const profileName = config.activeServer;
-        const server = config.servers[profileName];
-        console.log(chalk.bold('\nMCP server'));
-        console.log(`  Profile: ${chalk.green(profileName)} (${chalk.cyan(server?.type ?? 'unknown')})`);
-        if (server?.type === 'http') {
-            console.log(`  URL:     ${chalk.blue(server.url ?? '')}`);
-        }
-        else if (server?.type === 'stdio') {
-            console.log(`  Cmd:     ${chalk.blue(server.command ?? '')} ${server.args?.join(' ') || ''}`);
-        }
-        const spinner = makeSpinner(chalk.gray('Fetching MCP tool surface...')).start();
+        const onlyServer = targetName;
+        console.log(chalk.bold('\nMCP tools (pooled)'));
+        const statuses = mcpClient.getStatuses();
+        const connected = statuses.filter((s) => s.status === 'connected');
+        if (connected.length === 0) {
+            console.log(chalk.yellow('  No MCP servers connected. Try /mcp reconnect.\n'));
+            return true;
+        }
+        const spinner = makeSpinner(chalk.gray('Fetching pooled tool surface...')).start();
         try {
             const res = await mcpClient.listTools();
-            const tools = res.tools || [];
-            spinner.succeed(chalk.green(`${tools.length} MCP tools available`));
-            const namespaces = {};
-            for (const t of tools) {
-                const parts = (t.name || '').split('_');
-                const ns = parts.length > 1 ? parts[0] : 'misc';
-                (namespaces[ns] ||= []).push(t.name);
+            const allTools = res.tools || [];
+            spinner.succeed(chalk.green(`${allTools.length} tools across ${connected.length} server${connected.length === 1 ? '' : 's'}`));
+            // Pool tools are exposed as `mcp__<serverId>__<rawTool>`. Group by serverId.
+            const byServer = {};
+            for (const t of allTools) {
+                const m = /^mcp__([^_]+(?:_[^_]+)*?)__(.+)$/.exec(t.name);
+                const serverId = m?.[1] ?? '__unknown__';
+                const raw = m?.[2] ?? t.name;
+                if (onlyServer && serverId !== onlyServer)
+                    continue;
+                (byServer[serverId] ||= []).push(raw);
             }
-            for (const ns of Object.keys(namespaces).sort()) {
-                console.log(`\n  ${chalk.bold.cyan(ns)} (${namespaces[ns].length})`);
-                for (const name of namespaces[ns].sort()) {
-                    console.log(`    ${chalk.gray('•')} ${name}`);
+            const serverIds = Object.keys(byServer).sort();
+            if (serverIds.length === 0) {
+                console.log(chalk.gray(`\n  No tools for server "${onlyServer}".\n`));
+                return true;
+            }
+            for (const section of groupServerIdsByEcosystem(serverIds, (id) => mcpClient.getStatus(id)?.identity ?? 'unknown')) {
+                console.log(`\n${section.title}`);
+                for (const id of section.ids) {
+                    const ident = mcpClient.getStatus(id)?.identity ?? 'unknown';
+                    const identTag = formatIdentityTag(ident);
+                    console.log(`  ${chalk.bold.green(id)} ${identTag} (${byServer[id].length})`);
+                    for (const name of byServer[id].sort()) {
+                        console.log(`    ${chalk.gray('•')} ${name}  ${chalk.gray(`mcp__${id}__${name}`)}`);
+                    }
                 }
             }
         }
@@ -58,64 +76,211 @@ export async function tryHandleMcpCommand(ctx) {
         return true;
     }
     if (sub === 'list') {
-        const activeName = config.activeServer;
         const profiles = Object.keys(config.servers ?? {});
         if (profiles.length === 0) {
-            console.log(chalk.yellow('\nNo MCP profiles configured. Run `brainrouter login` or `brainrouter config` to set one up.\n'));
+            console.log(chalk.yellow('\nNo MCP profiles configured. Run `/login` or `brainrouter config` to set one up.\n'));
             return true;
         }
-        console.log(chalk.bold('\nConfigured MCP profiles'));
-        for (const name of profiles) {
+        console.log(chalk.bold('\nMCP servers'));
+        const statuses = mcpClient.getStatuses();
+        const statusById = new Map(statuses.map((s) => [s.serverId, s]));
+        const activeName = config.activeServer;
+        for (const section of groupServerIdsByEcosystem(profiles, (name) => {
             const profile = config.servers[name];
-            const isActive = name === activeName;
-            // Identity: explicit config field > live wrapper > 'unknown'.
-            let identity = profile.identity ?? 'unknown';
-            if (isActive && typeof mcpClient.getIdentity === 'function') {
-                identity = mcpClient.getIdentity();
+            return statusById.get(name)?.identity ?? profile?.identity ?? 'unknown';
+        })) {
+            console.log(`\n${section.title}`);
+            for (const name of section.ids) {
+                const profile = config.servers[name];
+                const poolStatus = statusById.get(name);
+                // Identity: pool live > config metadata > 'unknown'.
+                const identity = poolStatus?.identity ?? profile.identity ?? 'unknown';
+                // Status: pool live > 'not in pool' (configured but never tried).
+                const liveStatus = poolStatus?.status;
+                const statusLabel = liveStatus === 'connected' ? chalk.green('online') :
+                    liveStatus === 'failed' ? chalk.red('failed') :
+                        liveStatus === 'connecting' ? chalk.yellow('connecting') :
+                            liveStatus === 'offline' ? chalk.gray('disconnected') :
+                                chalk.gray('idle');
+                const idLabel = formatIdentityTag(identity);
+                const marker = name === activeName ? chalk.bold('★ ') : '  ';
+                const transport = profile.type;
+                const target = profile.type === 'http' ? profile.url ?? '<no url>' : profile.command ?? '<no command>';
+                const toolTag = poolStatus?.toolCount != null ? chalk.gray(`${poolStatus.toolCount} tools`) : '';
+                const errTag = liveStatus === 'failed' && poolStatus?.error ? chalk.red(` · ${poolStatus.error}`) : '';
+                console.log(`${marker}${chalk.bold(name)}  ${idLabel}  ${transport}  ${statusLabel}  ${chalk.gray(target)}  ${toolTag}${errTag}`);
             }
-            const onlineLabel = isActive
-                ? (mcpClient.isConnected() ? chalk.green('online') : chalk.red('offline'))
-                : chalk.gray('idle');
-            const idLabel = identity === 'brainrouter'
-                ? chalk.cyan('brainrouter')
-                : identity === 'third-party'
-                    ? chalk.yellow('third-party')
-                    : chalk.gray('unknown');
-            const marker = isActive ? chalk.bold('★ ') : '  ';
-            const transport = profile.type;
-            const target = profile.type === 'http' ? profile.url ?? '<no url>' : profile.command ?? '<no command>';
-            console.log(`${marker}${chalk.bold(name)}  ${idLabel}  ${transport}  ${onlineLabel}  ${chalk.gray(target)}`);
-        }
-        console.log(chalk.gray('\n★ = active profile.  /mcp reconnect to refresh the active connection.\n'));
+        }
+        console.log(chalk.gray('\n★ = highlighted profile in the banner.'));
+        console.log(chalk.gray('  Multi-MCP: third-party MCPs connect together; only one BrainRouter MCP is active. Use /mcp connect|disconnect|reconnect <name> to manage.\n'));
         return true;
     }
     if (sub === 'reconnect') {
-        const activeName = config.activeServer;
-        const profile = config.servers?.[activeName];
-        if (!profile) {
-            console.log(chalk.red(`\nNo active MCP profile to reconnect (\`activeServer\` = ${JSON.stringify(activeName)}).\n`));
+        if (!targetName) {
+            // No name → reconnect every configured server in the pool.
+            const ids = selectMcpServerIds(config.servers ?? {}, config.activeServer);
+            if (ids.length === 0) {
+                console.log(chalk.red(`\nNo MCP profiles configured.\n`));
+                return true;
+            }
+            console.log(chalk.gray(`Reconnecting all servers (${ids.length})…`));
+            await Promise.allSettled(ids.map(async (id) => {
+                try {
+                    await mcpClient.reconnectOne(id);
+                    const s = mcpClient.getStatus(id);
+                    if (s?.status === 'connected') {
+                        console.log(chalk.green(`  ✓ ${id}`));
+                    }
+                    else {
+                        console.log(chalk.red(`  ✗ ${id} — ${s?.error ?? 'failed'}`));
+                    }
+                }
+                catch (err) {
+                    console.log(chalk.red(`  ✗ ${id} — ${err?.message ?? err}`));
+                }
+            }));
+            console.log();
             return true;
         }
-        console.log(chalk.gray(`Reconnecting "${activeName}"…`));
+        if (!config.servers?.[targetName]) {
+            console.log(chalk.red(`\nNo profile named "${targetName}".\n`));
+            return true;
+        }
+        console.log(chalk.gray(`Reconnecting "${targetName}"…`));
         try {
-            try {
-                await mcpClient.close();
+            await disconnectOtherBrainrouterServers(ctx, targetName);
+            await mcpClient.reconnectOne(targetName);
+            const s = mcpClient.getStatus(targetName);
+            if (s?.status === 'connected') {
+                const activated = activateBrainrouterProfile(ctx, targetName);
+                console.log(chalk.green(`✓ Reconnected to "${targetName}".\n`));
+                if (activated) {
+                    console.log(chalk.gray(`  Active BrainRouter profile saved as "${targetName}" for this and future sessions.\n`));
+                    printRefreshedBanner(ctx);
+                }
             }
-            catch { /* idempotent */ }
-            await mcpClient.connect(profile, config.llm, activeName);
-            // Re-probe tools so identity tagging and the prompt's tool list refresh.
-            try {
-                await mcpClient.listTools();
+            else {
+                console.log(chalk.red(`✗ "${targetName}" remained ${s?.status ?? 'offline'} — ${s?.error ?? 'unknown'}\n`));
             }
-            catch { /* tool-list failure is non-fatal */ }
-            console.log(chalk.green(`✓ Reconnected to "${activeName}" (${profile.type}).\n`));
         }
         catch (err) {
             console.log(chalk.red(`✗ Reconnect failed: ${err?.message ?? err}\n`));
-            console.log(chalk.gray('The CLI stays in offline mode. Check the MCP server, then try `/mcp reconnect` again.\n'));
         }
         return true;
     }
-    console.log(chalk.red(`\nUnknown /mcp subcommand "${sub}". Usage: /mcp list | /mcp reconnect | /mcp tools\n`));
+    if (sub === 'connect') {
+        if (!targetName) {
+            console.log(chalk.red('\nUsage: /mcp connect <name>\n'));
+            return true;
+        }
+        const profile = config.servers?.[targetName];
+        if (!profile) {
+            console.log(chalk.red(`\nNo profile named "${targetName}". Available: ${Object.keys(config.servers ?? {}).join(', ') || '(none)'}.\n`));
+            return true;
+        }
+        console.log(chalk.gray(`Connecting "${targetName}"…`));
+        try {
+            await disconnectOtherBrainrouterServers(ctx, targetName);
+            await mcpClient.connectOne(targetName, profile, config.llm, 5_000);
+            const s = mcpClient.getStatus(targetName);
+            if (s?.status === 'connected') {
+                const activated = activateBrainrouterProfile(ctx, targetName);
+                console.log(chalk.green(`✓ "${targetName}" online (${s.toolCount ?? 0} tools).\n`));
+                if (activated) {
+                    console.log(chalk.gray(`  Active BrainRouter profile saved as "${targetName}" for this and future sessions.\n`));
+                    printRefreshedBanner(ctx);
+                }
+            }
+            else {
+                console.log(chalk.red(`✗ "${targetName}" failed — ${s?.error ?? 'unknown'}\n`));
+            }
+        }
+        catch (err) {
+            console.log(chalk.red(`✗ Connect failed: ${err?.message ?? err}\n`));
+        }
+        return true;
+    }
+    if (sub === 'disconnect') {
+        if (!targetName) {
+            console.log(chalk.red('\nUsage: /mcp disconnect <name>\n'));
+            return true;
+        }
+        if (!mcpClient.getStatus(targetName)) {
+            console.log(chalk.yellow(`\n"${targetName}" is not in the pool.\n`));
+            return true;
+        }
+        try {
+            await mcpClient.disconnectOne(targetName);
+            console.log(chalk.green(`✓ "${targetName}" disconnected. Config preserved — /mcp connect ${targetName} to bring it back.\n`));
+        }
+        catch (err) {
+            console.log(chalk.red(`✗ Disconnect failed: ${err?.message ?? err}\n`));
+        }
+        return true;
+    }
+    console.log(chalk.red(`\nUnknown /mcp subcommand "${sub}". Usage: /mcp list | /mcp tools [server] | /mcp connect <name> | /mcp disconnect <name> | /mcp reconnect [name]\n`));
+    return true;
+}
+function formatIdentityTag(identity) {
+    return identity === 'brainrouter' ? chalk.cyan('brainrouter') :
+        identity === 'third-party' ? chalk.yellow('third-party') :
+            chalk.gray('unknown');
+}
+function groupServerIdsByEcosystem(ids, identityFor) {
+    const brainrouter = [];
+    const other = [];
+    for (const id of ids.slice().sort()) {
+        if (identityFor(id) === 'brainrouter')
+            brainrouter.push(id);
+        else
+            other.push(id);
+    }
+    const sections = [];
+    if (brainrouter.length > 0) {
+        sections.push({ title: chalk.bold.cyan('BrainRouter MCP (Our Ecosystem)'), ids: brainrouter });
+    }
+    if (other.length > 0) {
+        sections.push({ title: chalk.bold.yellow('Third-party MCPs (Other)'), ids: other });
+    }
+    return sections;
+}
+async function disconnectOtherBrainrouterServers(ctx, targetName) {
+    const targetProfile = ctx.config.servers?.[targetName];
+    if (!targetProfile)
+        return;
+    if (resolveIdentityFromConfig(targetProfile, targetName) !== 'brainrouter')
+        return;
+    for (const [id, profile] of Object.entries(ctx.config.servers ?? {})) {
+        if (id === targetName)
+            continue;
+        if (resolveIdentityFromConfig(profile, id) !== 'brainrouter')
+            continue;
+        const status = ctx.mcpClient.getStatus(id);
+        if (status?.status === 'connected' || status?.status === 'connecting') {
+            await ctx.mcpClient.disconnectOne(id);
+        }
+    }
+}
+function activateBrainrouterProfile(ctx, targetName) {
+    const status = ctx.mcpClient.getStatus(targetName);
+    const profile = ctx.config.servers?.[targetName];
+    const isBrainrouter = status?.identity === 'brainrouter' ||
+        (profile ? resolveIdentityFromConfig(profile, targetName) === 'brainrouter' : false);
+    if (!isBrainrouter)
+        return false;
+    ctx.config.activeServer = targetName;
+    saveConfig(ctx.config);
     return true;
 }
+function printRefreshedBanner(ctx) {
+    const theme = resolveTheme(ctx.agent.workspaceRoot);
+    const banner = renderBanner(buildBannerInputs(ctx.config, ctx.agent, ctx.mcpClient), theme);
+    if (ctx.repl.replaceBanner) {
+        ctx.repl.replaceBanner('\n' + banner);
+    }
+    else {
+        console.log(chalk.gray('Updated active BrainRouter banner:'));
+        console.log(banner);
+        console.log();
+    }
+}

package/dist/cli/commands/orchestration.js

@@ -5,6 +5,7 @@
 import chalk from 'chalk';
 import { childSessionKey } from '../../runtime/mcpUtils.js';
 import { listRoles } from '../../orchestration/roles.js';
+import { listAll as listAgentDefs } from '../../orchestration/agentRegistry.js';
 import { formatSessionSummary, getSession, listSessions, reconcileStale } from '../../orchestration/orchestrator.js';
 import { readPreferences, writePreferences } from '../../state/preferencesStore.js';
 import { readTranscriptEntries } from '../../state/sessionStore.js';
@@ -26,6 +27,23 @@ export async function tryHandleOrchestrationCommand(ctx) {
             }
         case '/agents':
             {
+                if (args[0] === 'defs') {
+                    const defs = listAgentDefs(agent.workspaceRoot);
+                    console.log(chalk.bold('\nAgent Definitions:'));
+                    const ID_W = Math.max(...defs.map((l) => l.def.id.length), 4) + 2;
+                    const TIER_W = 12;
+                    const SRC_W = 10;
+                    console.log(chalk.gray(`  ${'ID'.padEnd(ID_W)}${'TIER'.padEnd(TIER_W)}${'SOURCE'.padEnd(SRC_W)}PATH`));
+                    for (const loaded of defs) {
+                        const idStr = chalk.cyan(loaded.def.id.padEnd(ID_W));
+                        const tierColor = loaded.def.tier === 'reasoning' ? chalk.blue : chalk.yellow;
+                        const tierStr = tierColor(loaded.def.tier.padEnd(TIER_W));
+                        const srcStr = chalk.gray(loaded.source.padEnd(SRC_W));
+                        console.log(`  ${idStr}${tierStr}${srcStr}${chalk.gray(loaded.filePath)}`);
+                    }
+                    console.log();
+                    return true;
+                }
                 reconcileStale(agent.workspaceRoot);
                 const sessions = listSessions(agent.workspaceRoot);
                 // `--json` for scripting. Emits a single JSON line on stdout so

package/dist/cli/commands/ui.js

@@ -12,10 +12,17 @@ import { callMcpTool } from '../../runtime/mcpUtils.js';
 import { listSessions, reconcileStale } from '../../orchestration/orchestrator.js';
 import { readPreferences, resolveEffort, writePreferences } from '../../state/preferencesStore.js';
 import { readPlan } from '../../state/taskStore.js';
-import { getConfigPath } from '../../config/config.js';
+// initAgentMd usage moved to commands/init.ts (0.3.7 wizard). The
+// legacy /config + /init switch cases here are gone — the dispatcher
+// in repl.ts routes them to the new handlers first. getConfigPath
+// stays in scope because /doctor still surfaces the path.
+import { getConfigPath, saveConfig } from '../../config/config.js';
 import { copyToClipboard } from '../../runtime/clipboard.js';
-import { initAgentMd } from '../../prompt/initAgentMd.js';
 import { completeWorkspacePath, renderHelp } from '../repl.js';
+import { PROVIDER_CATALOG, findProvider } from '../wizard/providers.js';
+import { selectModel } from '../wizard/modelsApi.js';
+import { buildTheme } from '../theme.js';
+import { listFilesystemSkills } from '../../prompt/skillCatalog.js';
 export async function tryHandleUiCommand(ctx) {
     const { command, args, agent, mcpClient, config, rl, repl } = ctx;
     // 'ctx' alias to keep references to the old ReplContext name working
@@ -78,27 +85,10 @@ export async function tryHandleUiCommand(ctx) {
                 console.log();
                 return true;
             }
-        case '/config':
-            {
-                console.log(chalk.bold('\n⚙️  Active Configuration:'));
-                console.log(`  File Path: ${chalk.blue(getConfigPath())}\n`);
-                // Print config without API keys
-                const scrubbedConfig = JSON.parse(JSON.stringify(config));
-                if (scrubbedConfig.llm?.apiKey) {
-                    scrubbedConfig.llm.apiKey = 'br_••••••••••••••••';
-                }
-                for (const s of Object.values(scrubbedConfig.servers)) {
-                    const srv = s;
-                    if (srv.apiKey)
-                        srv.apiKey = 'br_••••••••••••••••';
-                    if (srv.env?.BRAINROUTER_API_KEY) {
-                        srv.env.BRAINROUTER_API_KEY = 'br_••••••••••••••••';
-                    }
-                }
-                console.log(chalk.gray(JSON.stringify(scrubbedConfig, null, 2)));
-                console.log();
-                return true;
-            }
+        // /config now lives in commands/config.ts (0.3.7 settings home panel
+        // + verb-overloaded get/set). The dispatcher in repl.ts routes it
+        // before this case, so leaving anything here is dead — removed.
+        // Use `/config raw` if you want the old scrubbed-JSON dump.
         case '/doctor':
             {
                 console.log(chalk.bold('\nBrainRouter Doctor:'));
@@ -178,30 +168,69 @@ export async function tryHandleUiCommand(ctx) {
                 console.log();
                 return true;
             }
-        case '/init':
-            {
-                const result = initAgentMd(agent.workspaceRoot);
-                if (result.status === 'created') {
-                    console.log(chalk.green(`\n✓ Created ${result.path}`));
-                    console.log(chalk.gray('Edit it to describe your project, conventions, and boundaries — any AGENT.md-aware coding agent will read it.\n'));
-                }
-                else {
-                    console.log(chalk.yellow(`\nFile already exists: ${result.path}`));
-                    console.log(chalk.gray('Open it and edit by hand if you want to refresh it.\n'));
-                }
-                return true;
-            }
+        // /init is now the onboarding-wizard entrypoint (commands/init.ts).
+        // The AGENT.md-only path lives behind `/init agentmd` for back-compat.
+        // Routed before this case in repl.ts; no fall-through handler needed.
         case '/model':
             {
                 const newModel = args[0];
-                if (!newModel) {
-                    console.log(chalk.bold(`\nCurrent model: ${chalk.cyan(agent.getModel())}`));
-                    console.log(chalk.gray('Switch with: /model <model-name> (e.g. /model gpt-4o-mini, /model gpt-5, /model qwen2.5-coder)\n'));
+                const previous = agent.getModel();
+                // Direct-switch form `/model <name>` stays for scripts and muscle
+                // memory. No-arg opens the picker (0.3.7).
+                if (newModel) {
+                    agent.setModel(newModel);
+                    if (config.llm) {
+                        config.llm.model = newModel;
+                        saveConfig(config);
+                    }
+                    console.log(chalk.green(`\n✓ Model switched: ${chalk.gray(previous)} → ${chalk.cyan(newModel)}\n`));
                     return true;
                 }
-                const previous = agent.getModel();
-                agent.setModel(newModel);
-                console.log(chalk.green(`\n✓ Model switched: ${chalk.gray(previous)} → ${chalk.cyan(newModel)}\n`));
+                // No-arg → open the picker. Resolves provider by matching the
+                // saved endpoint against PROVIDER_CATALOG; falls back to the
+                // OpenAI entry when nothing matches (the agent loop also
+                // defaults to OpenAI-compatible shapes).
+                const themeMode = readPreferences(agent.workspaceRoot).theme;
+                const theme = buildTheme(themeMode === 'mono' ? 'mono' : themeMode === 'light' ? 'light' : 'dark');
+                const llm = config.llm;
+                const provider = (llm?.endpoint && PROVIDER_CATALOG.find((p) => p.endpoint.replace(/\/$/, '') === (llm.endpoint ?? '').replace(/\/$/, ''))) ||
+                    findProvider('openai');
+                const result = await selectModel({
+                    theme,
+                    provider,
+                    apiKey: llm?.apiKey ?? '',
+                    endpointOverride: llm?.endpoint,
+                    currentModel: previous,
+                    title: '/model — quick-swap',
+                    badge: provider.label,
+                });
+                if (!result) {
+                    console.log(chalk.yellow('\n  /model cancelled.\n'));
+                    return true;
+                }
+                if (result.model === previous) {
+                    console.log(chalk.gray(`\n  Model unchanged (${previous}).\n`));
+                    return true;
+                }
+                // Cross-provider sanity check — if the picked model looks like
+                // a different vendor's namespace (anthropic/*, google/*, etc.)
+                // and the active provider isn't a multi-vendor gateway, warn so
+                // the user doesn't hit a confusing 404 on the next turn.
+                if (looksLikeForeignModel(result.model, provider)) {
+                    console.log(chalk.yellow(`\n  ⚠ "${result.model}" looks like a different provider's namespace. ` +
+                        `Active endpoint: ${provider.label}.` +
+                        `\n    Run /config provider <id> to switch endpoints, or /model again to pick a native model.\n`));
+                }
+                agent.setModel(result.model);
+                if (config.llm) {
+                    config.llm.model = result.model;
+                    saveConfig(config);
+                }
+                const sourceTag = result.source === 'live' ? `live · ${result.liveCount} models` :
+                    result.source === 'fallback' ? `offline · static catalog (${result.liveError ?? 'unknown'})` :
+                        'static catalog';
+                console.log(chalk.green(`\n✓ Model switched: ${chalk.gray(previous)} → ${chalk.cyan(result.model)}`));
+                console.log(chalk.gray(`  Source: ${sourceTag}\n`));
                 return true;
             }
         // /mcp moved to its own command file (commands/mcp.ts) as part of 0.3.6
@@ -410,12 +439,22 @@ export async function tryHandleUiCommand(ctx) {
                     console.log(chalk.gray('  Drop a folder under skills/<category>/<name>/SKILL.md to register one.\n'));
                     return true;
                 }
-                for (const root of roots) {
-                    const entries = fs.readdirSync(root, { withFileTypes: true });
-                    for (const entry of entries) {
-                        if (!entry.isDirectory())
-                            continue;
-                        console.log(chalk.cyan(`  ${path.relative(agent.workspaceRoot, path.join(root, entry.name))}`));
+                const skills = listFilesystemSkills(agent.workspaceRoot);
+                if (skills.length > 0) {
+                    console.log(chalk.gray('  Skills'));
+                    for (const skill of skills) {
+                        const category = skill.category ? `${skill.category}/` : '';
+                        console.log(`  • ${chalk.cyan(`${category}${skill.name}`)} (${chalk.gray(skill.scope ?? 'filesystem')})`);
+                    }
+                }
+                if (fs.existsSync(pluginsRoot)) {
+                    const entries = fs.readdirSync(pluginsRoot, { withFileTypes: true });
+                    const pluginDirs = entries.filter((entry) => entry.isDirectory());
+                    if (pluginDirs.length > 0) {
+                        console.log(chalk.gray('  Plugin folders'));
+                        for (const entry of pluginDirs) {
+                            console.log(`  • ${chalk.cyan(path.relative(agent.workspaceRoot, path.join(pluginsRoot, entry.name)))}`);
+                        }
                     }
                 }
                 console.log();
@@ -496,23 +535,19 @@ export async function tryHandleUiCommand(ctx) {
         case '/where':
             {
                 const { gatherWhereInputs, renderWhere } = await import('../whereView.js');
+                const { resolveDisplayedMcpState } = await import('../banner.js');
                 const { resolveTheme } = await import('../theme.js');
                 const theme = resolveTheme(agent.workspaceRoot);
-                const profileName = config.activeServer;
-                const server = config.servers[profileName];
+                const displayedMcp = resolveDisplayedMcpState(config, mcpClient);
                 const briefing = agent.getLastBriefing();
                 const inputs = gatherWhereInputs({
                     workspaceRoot: agent.workspaceRoot,
                     sessionKey: agent.sessionKey,
                     model: agent.getModel(),
-                    mcpProfile: profileName,
-                    mcpTransport: server?.type ?? 'unknown',
-                    mcpOnline: mcpClient.isConnected(),
-                    // 10c: identity flows from the live wrapper; falls back to the
-                    // config field when present, otherwise 'unknown'.
-                    mcpIdentity: typeof mcpClient.getIdentity === 'function'
-                        ? mcpClient.getIdentity()
-                        : (server?.identity ?? 'unknown'),
+                    mcpProfile: displayedMcp.profile,
+                    mcpTransport: displayedMcp.transport,
+                    mcpOnline: displayedMcp.online,
+                    mcpIdentity: displayedMcp.identity,
                     accessMode: agent.getAccessMode(),
                     recalledRecords: agent.getRecalledRecords(),
                     briefingSources: briefing.sources,
@@ -527,3 +562,27 @@ export async function tryHandleUiCommand(ctx) {
     }
     return false;
 }
+/**
+ * Heuristic — does the picked model id look like it belongs to a
+ * different vendor than the active provider's endpoint? Catches the
+ * common foot-gun of picking `anthropic/claude-*` while pointed at
+ * OpenAI direct, where the request 404s at the endpoint and the user
+ * has no obvious "you needed to switch endpoints" signal.
+ *
+ * Returns false for gateway providers (OpenRouter, "anthropic-via-gateway")
+ * since multi-vendor namespaces are expected there.
+ */
+function looksLikeForeignModel(model, provider) {
+    // Gateways are vendor-agnostic by design.
+    if (provider.id === 'openrouter' || provider.id === 'anthropic-via-gateway')
+        return false;
+    const FOREIGN_PREFIXES = {
+        openai: ['anthropic/', 'google/', 'meta/', 'mistralai/', 'qwen/', 'deepseek/'],
+        deepseek: ['anthropic/', 'google/', 'openai/', 'meta/', 'mistralai/'],
+        gemini: ['anthropic/', 'openai/', 'meta/', 'mistralai/', 'deepseek/'],
+        lmstudio: [],
+        ollama: [],
+    };
+    const list = FOREIGN_PREFIXES[provider.id] ?? [];
+    return list.some((prefix) => model.startsWith(prefix));
+}

package/dist/cli/commands/workflow.d.ts

@@ -3,6 +3,7 @@
  * Hand-tune imports if the compiler complains.
  */
 import type { CommandContext } from './_context.js';
+import { type SkillListItem } from '../../prompt/skillCatalog.js';
 /**
  * Decide whether `/grill-me` should refuse to fire because the current
  * workflow already has a written `spec.md`. The clarifying pass is meant to
@@ -22,3 +23,4 @@ export declare function shouldSkipGrillMe(workspaceRoot: string, force: boolean,
     specPath?: string;
 };
 export declare function tryHandleWorkflowCommand(ctx: CommandContext): Promise<boolean>;
+export declare function normalizeSkillsList(payload: any): SkillListItem[] | undefined;