@kinqs/brainrouter-cli 0.3.6 → 0.3.8

package/dist/cli/commands/releaseNotes.js

@@ -0,0 +1,109 @@
+/**
+ * `/release-notes` slash command — show the changelog for the running CLI version.
+ *
+ *   /release-notes            → current version's notes
+ *   /release-notes <version>  → specific version
+ *   /release-notes list       → every shipped version, sorted descending
+ *
+ * Changelog files ship inside the published package at `changelog/<version>.md`.
+ * The repo-root `brainrouter-changelog/` is copied into `brainrouter-cli/changelog/`
+ * by `prepublishOnly` so users who install via npm see them.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+const MAX_LINES = 200;
+const SEMVER_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+export async function tryHandleReleaseNotesCommand(ctx, deps = {}) {
+    if (ctx.command !== '/release-notes')
+        return false;
+    const out = runReleaseNotes(ctx.args, deps);
+    console.log(out);
+    return true;
+}
+/**
+ * Pure handler — returns the rendered string. Split from `tryHandle*` so unit
+ * tests can assert on the output without capturing stdout.
+ */
+export function runReleaseNotes(args, deps = {}) {
+    const dir = deps.changelogDir ?? defaultChangelogDir();
+    const sub = (args[0] ?? '').toLowerCase();
+    if (sub === 'list')
+        return renderList(dir);
+    let version;
+    if (sub) {
+        if (!SEMVER_RE.test(sub)) {
+            return chalk.red(`Not a valid semver: "${args[0]}". Try /release-notes list.`);
+        }
+        version = sub;
+    }
+    else {
+        const v = deps.currentVersion ?? readCurrentVersion();
+        if (!v)
+            return chalk.red('Could not determine current CLI version.');
+        version = v;
+    }
+    const filePath = path.join(dir, `${version}.md`);
+    let body;
+    try {
+        body = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return chalk.yellow(`no notes shipped for ${version}`);
+    }
+    return truncate(body, version);
+}
+function renderList(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return chalk.yellow('No bundled changelog directory found.');
+    }
+    const versions = entries
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => f.slice(0, -3))
+        .filter((v) => SEMVER_RE.test(v))
+        .sort(compareSemverDesc);
+    if (versions.length === 0)
+        return chalk.yellow('No changelog versions bundled.');
+    return versions.join('\n');
+}
+function truncate(body, version) {
+    const lines = body.split('\n');
+    if (lines.length <= MAX_LINES)
+        return body;
+    const head = lines.slice(0, MAX_LINES).join('\n');
+    return `${head}\n\n…truncated at ${MAX_LINES} lines. Run \`/release-notes ${version}\` on its own to scroll the full file in a fresh paginator.`;
+}
+function compareSemverDesc(a, b) {
+    const pa = a.split(/[-+]/)[0].split('.').map(Number);
+    const pb = b.split(/[-+]/)[0].split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (pa[i] !== pb[i])
+            return pb[i] - pa[i];
+    }
+    // Identical core → keep pre-release sort stable by string compare (descending).
+    return b.localeCompare(a);
+}
+// --- Package-root resolution -------------------------------------------------
+/**
+ * `brainrouter-cli/changelog/` — relative to this compiled file. The dist
+ * layout mirrors src, so both `src/cli/commands/releaseNotes.ts` (dev/tsx)
+ * and `dist/cli/commands/releaseNotes.js` (built) resolve to the same root.
+ */
+function defaultChangelogDir() {
+    return fileURLToPath(new URL('../../../changelog', import.meta.url));
+}
+function readCurrentVersion() {
+    try {
+        const pkgPath = fileURLToPath(new URL('../../../package.json', import.meta.url));
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        return pkg.version;
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * `/schedule` slash command — recurring cron + one-shot dispatch.
+ *
+ * Recurring  : /schedule cron "*\/15 * * * *" /ci-status
+ * One-shot   : /schedule in 30s /agents
+ *              /schedule at 14:30 /agents
+ * Management : /schedule list
+ *              /schedule remove  <id>
+ *              /schedule disable <id>
+ *              /schedule enable  <id>
+ *
+ * The dispatched command runs in the SAME session that registered the
+ * schedule (we use `agent.sessionKey` as the owner). The ticker filters
+ * by owner — if a different REPL is open against the same workspace,
+ * it won't fire someone else's jobs.
+ */
+import type { CommandContext } from './_context.js';
+export declare function tryHandleScheduleCommand(ctx: CommandContext): Promise<boolean>;

package/dist/cli/commands/schedule.js

@@ -0,0 +1,189 @@
+/**
+ * `/schedule` slash command — recurring cron + one-shot dispatch.
+ *
+ * Recurring  : /schedule cron "*\/15 * * * *" /ci-status
+ * One-shot   : /schedule in 30s /agents
+ *              /schedule at 14:30 /agents
+ * Management : /schedule list
+ *              /schedule remove  <id>
+ *              /schedule disable <id>
+ *              /schedule enable  <id>
+ *
+ * The dispatched command runs in the SAME session that registered the
+ * schedule (we use `agent.sessionKey` as the owner). The ticker filters
+ * by owner — if a different REPL is open against the same workspace,
+ * it won't fire someone else's jobs.
+ */
+import chalk from 'chalk';
+import { parseInterval } from '../../runtime/loopRunner.js';
+import { parseCron, nextCronFire } from '../../runtime/cronParser.js';
+import { addSchedule, loadSchedules, removeSchedule, setScheduleEnabled, } from '../../state/scheduleStore.js';
+export async function tryHandleScheduleCommand(ctx) {
+    if (ctx.command !== '/schedule')
+        return false;
+    const { args, agent } = ctx;
+    const sub = (args[0] ?? '').toLowerCase();
+    if (!sub || sub === 'list') {
+        renderList(agent.workspaceRoot, agent.sessionKey);
+        return true;
+    }
+    if (sub === 'remove' || sub === 'rm') {
+        const id = args[1];
+        if (!id) {
+            console.log(chalk.red('\nUsage: /schedule remove <id>\n'));
+            return true;
+        }
+        const ok = removeSchedule(agent.workspaceRoot, id);
+        console.log(ok
+            ? chalk.green(`\n✓ Removed ${id}.\n`)
+            : chalk.yellow(`\nNo schedule with id ${id}.\n`));
+        return true;
+    }
+    if (sub === 'disable' || sub === 'enable') {
+        const id = args[1];
+        if (!id) {
+            console.log(chalk.red(`\nUsage: /schedule ${sub} <id>\n`));
+            return true;
+        }
+        const ok = setScheduleEnabled(agent.workspaceRoot, id, sub === 'enable');
+        console.log(ok
+            ? chalk.green(`\n✓ ${sub === 'enable' ? 'Enabled' : 'Disabled'} ${id}.\n`)
+            : chalk.yellow(`\nNo schedule with id ${id}.\n`));
+        return true;
+    }
+    if (sub === 'cron') {
+        // Need to re-join because the splitter cracked the quoted cron expr
+        // across tokens. Re-join args after the leading "cron".
+        const rest = args.slice(1).join(' ').trim();
+        const m = /^"([^"]+)"\s+(\/\S.*)$/.exec(rest);
+        if (!m) {
+            console.log(chalk.red('\nUsage: /schedule cron "<expr>" /command'));
+            console.log(chalk.gray('  e.g. /schedule cron "*/15 * * * *" /ci-status\n'));
+            return true;
+        }
+        const expr = m[1];
+        const command = m[2].trim();
+        if (!command.startsWith('/')) {
+            console.log(chalk.red('\nSchedule only dispatches slash commands (must start with `/`).\n'));
+            return true;
+        }
+        const cron = parseCron(expr);
+        if (!cron) {
+            console.log(chalk.red(`\nInvalid cron expression: "${expr}"`));
+            console.log(chalk.gray('  Expected 5 fields: minute hour dom month dow\n'));
+            return true;
+        }
+        const nextRun = nextCronFire(cron, new Date());
+        const rec = addSchedule(agent.workspaceRoot, {
+            kind: 'cron',
+            expr,
+            command,
+            owner: agent.sessionKey,
+            nextRun: nextRun.toISOString(),
+        });
+        console.log(chalk.green(`\n✓ Registered ${rec.id}: cron "${expr}" → ${command}`));
+        console.log(chalk.gray(`  Next fire: ${formatWhen(nextRun)}\n`));
+        return true;
+    }
+    if (sub === 'in') {
+        const ms = parseInterval(args[1] ?? '');
+        const command = args.slice(2).join(' ').trim();
+        if (!ms || !command) {
+            console.log(chalk.red('\nUsage: /schedule in <duration> /command'));
+            console.log(chalk.gray('  e.g. /schedule in 5m /ci-status\n'));
+            return true;
+        }
+        if (!command.startsWith('/')) {
+            console.log(chalk.red('\nSchedule only dispatches slash commands.\n'));
+            return true;
+        }
+        const nextRun = new Date(Date.now() + ms);
+        const rec = addSchedule(agent.workspaceRoot, {
+            kind: 'once',
+            expr: nextRun.toISOString(),
+            command,
+            owner: agent.sessionKey,
+            nextRun: nextRun.toISOString(),
+        });
+        console.log(chalk.green(`\n✓ Registered ${rec.id}: one-shot in ${args[1]} → ${command}`));
+        console.log(chalk.gray(`  Fires at: ${formatWhen(nextRun)}\n`));
+        return true;
+    }
+    if (sub === 'at') {
+        const time = args[1] ?? '';
+        const command = args.slice(2).join(' ').trim();
+        const tm = /^(\d{1,2}):(\d{2})$/.exec(time);
+        if (!tm || !command) {
+            console.log(chalk.red('\nUsage: /schedule at HH:MM /command'));
+            console.log(chalk.gray('  e.g. /schedule at 14:30 /agents\n'));
+            return true;
+        }
+        if (!command.startsWith('/')) {
+            console.log(chalk.red('\nSchedule only dispatches slash commands.\n'));
+            return true;
+        }
+        const h = Number(tm[1]);
+        const min = Number(tm[2]);
+        if (h > 23 || min > 59) {
+            console.log(chalk.red('\nInvalid time. Hours 0-23, minutes 0-59.\n'));
+            return true;
+        }
+        const now = new Date();
+        const target = new Date(now);
+        target.setHours(h, min, 0, 0);
+        if (target.getTime() <= now.getTime())
+            target.setDate(target.getDate() + 1);
+        const rec = addSchedule(agent.workspaceRoot, {
+            kind: 'once',
+            expr: target.toISOString(),
+            command,
+            owner: agent.sessionKey,
+            nextRun: target.toISOString(),
+        });
+        console.log(chalk.green(`\n✓ Registered ${rec.id}: one-shot at ${time} → ${command}`));
+        console.log(chalk.gray(`  Fires at: ${formatWhen(target)}\n`));
+        return true;
+    }
+    console.log(chalk.red(`\nUnknown subcommand: /schedule ${sub}`));
+    console.log(chalk.gray('  Try: list | cron "<expr>" /cmd | in <dur> /cmd | at HH:MM /cmd | remove <id> | disable <id> | enable <id>\n'));
+    return true;
+}
+function renderList(workspaceRoot, sessionKey) {
+    const all = loadSchedules(workspaceRoot);
+    const mine = all.filter((s) => s.owner === sessionKey);
+    if (mine.length === 0) {
+        console.log(chalk.yellow('\nNo schedules registered for this session.'));
+        console.log(chalk.gray('  Add one with /schedule cron "<expr>" /command or /schedule in 5m /command\n'));
+        return;
+    }
+    console.log(chalk.bold('\nSchedules'));
+    for (const s of mine) {
+        const status = s.enabled ? chalk.green('●') : chalk.gray('○');
+        const kind = s.kind === 'cron' ? `cron "${s.expr}"` : `once`;
+        console.log(`  ${status} ${chalk.cyan(s.id)}  ${chalk.gray(kind.padEnd(28))} → ${s.command}`);
+        console.log(`      ${chalk.gray(`next: ${formatWhen(new Date(s.nextRun))}${s.lastRun ? `  ·  last: ${formatWhen(new Date(s.lastRun))}` : ''}`)}`);
+    }
+    console.log();
+}
+function formatWhen(d) {
+    if (!Number.isFinite(d.getTime()))
+        return '(invalid)';
+    const now = Date.now();
+    const delta = d.getTime() - now;
+    const abs = Math.abs(delta);
+    const human = humanDelta(abs);
+    const rel = delta >= 0 ? `in ${human}` : `${human} ago`;
+    return `${d.toISOString().replace('T', ' ').slice(0, 16)} (${rel})`;
+}
+function humanDelta(ms) {
+    const s = Math.round(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.round(s / 60);
+    if (m < 60)
+        return `${m}m`;
+    const h = Math.round(m / 60);
+    if (h < 48)
+        return `${h}h`;
+    return `${Math.round(h / 24)}d`;
+}

package/dist/cli/commands/ui.js

@@ -8,14 +8,21 @@ import { execSync } from 'node:child_process';
 import chalk from 'chalk';
 import { spinner as makeSpinner } from '../spinner.js';
 import { LOCAL_TOOLS } from '../../agent/agent.js';
-import { callMcpTool } from '../../runtime/mcpUtils.js';
+import { callMcpTool, hasMcpTool } 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:'));
@@ -126,7 +116,7 @@ export async function tryHandleUiCommand(ctx) {
                     const toolNames = new Set((res.tools || []).map((tool) => tool.name));
                     const memoryTools = ['memory_recall', 'memory_capture_turn', 'memory_working_offload'];
                     for (const name of memoryTools) {
-                        const hasTool = toolNames.has(name);
+                        const hasTool = hasMcpTool(toolNames, name);
                         console.log(`  ${name}: ${hasTool ? chalk.green('available') : chalk.yellow('not exposed')}`);
                     }
                 }
@@ -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;