@kimbho/kimbho-cli 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -3346,7 +3346,7 @@ var {
 // package.json
 var package_default = {
   name: "@kimbho/kimbho-cli",
-  version: "0.1.2",
+  version: "0.1.4",
   description: "Kimbho CLI is a terminal-native coding agent for planning, execution, and verification.",
   type: "module",
   engines: {
@@ -8072,6 +8072,34 @@ function assignBrain(config, role, settings) {
     }
   });
 }
+function buildRetainedBrainSettings(current, providerId, model) {
+  return {
+    providerId,
+    ...model ? {
+      model
+    } : {},
+    ...typeof current.temperature === "number" ? {
+      temperature: current.temperature
+    } : {},
+    ...typeof current.maxTokens === "number" ? {
+      maxTokens: current.maxTokens
+    } : {},
+    ...current.promptPreamble ? {
+      promptPreamble: current.promptPreamble
+    } : {}
+  };
+}
+function assignProviderToAllBrains(config, providerId, model) {
+  return KimbhoConfigSchema.parse({
+    ...config,
+    brains: {
+      planner: buildRetainedBrainSettings(config.brains.planner, providerId, model),
+      coder: buildRetainedBrainSettings(config.brains.coder, providerId, model),
+      reviewer: buildRetainedBrainSettings(config.brains.reviewer, providerId, model),
+      fast: buildRetainedBrainSettings(config.brains.fast, providerId, model)
+    }
+  });
+}
 function resolveBrainSettings(config, role) {
   return config.brains[role];
 }
@@ -8826,6 +8854,28 @@ function listProviderTemplates() {
 function findProviderTemplate(templateId) {
   return BUILTIN_PROVIDER_TEMPLATES.find((template) => template.id === templateId);
 }
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function normalizeTemplateBaseUrl(templateId, baseUrl) {
+  if (!baseUrl) {
+    return void 0;
+  }
+  const normalized = trimTrailingSlash(baseUrl);
+  if (templateId !== "lmstudio") {
+    return normalized;
+  }
+  try {
+    const parsed = new URL(normalized);
+    if (!parsed.pathname || parsed.pathname === "/") {
+      parsed.pathname = "/v1";
+      return trimTrailingSlash(parsed.toString());
+    }
+  } catch {
+    return normalized;
+  }
+  return normalized;
+}
 function buildProviderFromTemplate(templateId, options = {}) {
   const template = findProviderTemplate(templateId);
   if (!template) {
@@ -8835,8 +8885,8 @@ function buildProviderFromTemplate(templateId, options = {}) {
     id: options.providerId ?? template.id,
     label: options.label ?? template.label,
     driver: template.driver,
-    ...options.baseUrl ?? template.defaultBaseUrl ? {
-      baseUrl: options.baseUrl ?? template.defaultBaseUrl
+    ...normalizeTemplateBaseUrl(templateId, options.baseUrl) ?? template.defaultBaseUrl ? {
+      baseUrl: normalizeTemplateBaseUrl(templateId, options.baseUrl) ?? template.defaultBaseUrl
     } : {},
     ...options.apiKeyEnv ?? template.defaultApiKeyEnv ? {
       apiKeyEnv: options.apiKeyEnv ?? template.defaultApiKeyEnv
@@ -8875,11 +8925,11 @@ async function requestJson(url, init, timeoutMs = 3e4) {
   }
   return response.json();
 }
-function trimTrailingSlash(value) {
+function trimTrailingSlash2(value) {
   return value.replace(/\/+$/, "");
 }
 function joinUrl(baseUrl, suffix) {
-  const normalizedBase = trimTrailingSlash(baseUrl);
+  const normalizedBase = trimTrailingSlash2(baseUrl);
   const normalizedSuffix = suffix.startsWith("/") ? suffix : `/${suffix}`;
   return `${normalizedBase}${normalizedSuffix}`;
 }
@@ -8908,7 +8958,7 @@ function buildProviderHeaders(definition, apiKey, includeJsonContentType = true)
 }
 function filterModels(models, input = {}) {
   const normalized = input.search?.trim().toLowerCase();
-  const filtered = normalized ? models.filter((model) => [model.id, model.name, model.description].filter((value) => Boolean(value)).some((value) => value.toLowerCase().includes(normalized))) : models;
+  const filtered = normalized ? models.filter((model) => [model.id, model.name].filter((value) => Boolean(value)).some((value) => value.toLowerCase().includes(normalized))) : models;
   return typeof input.limit === "number" ? filtered.slice(0, input.limit) : filtered;
 }
 function mapOpenAIStyleModels(providerId, payload, input) {
@@ -9187,9 +9237,26 @@ var OpenAICompatibleProvider = class {
       };
     }
     const apiKey = resolveApiKey(this.definition);
+    if (this.definition.apiKeyEnv && !apiKey) {
+      return {
+        ok: false,
+        message: `${this.definition.baseUrl} (${this.definition.defaultModel ?? "model not set"}), missing ${this.definition.apiKeyEnv}`
+      };
+    }
+    try {
+      await requestJson(joinUrl(this.definition.baseUrl, "/models"), {
+        method: "GET",
+        headers: buildProviderHeaders(this.definition, apiKey, false)
+      }, 2e3);
+    } catch (error) {
+      return {
+        ok: false,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
     return {
-      ok: !this.definition.apiKeyEnv || Boolean(apiKey),
-      message: `${this.definition.baseUrl} (${this.definition.defaultModel ?? "model not set"})${this.definition.apiKeyEnv && !apiKey ? `, missing ${this.definition.apiKeyEnv}` : ""}`
+      ok: true,
+      message: `${this.definition.baseUrl} (${this.definition.defaultModel ?? "model not set"})`
     };
   }
   async listModels(input) {
@@ -9745,11 +9812,19 @@ function renderModelLine(model) {
   ].filter((value) => Boolean(value));
   return details.length > 0 ? `${model.id} | ${details.join(" | ")}` : model.id;
 }
+function filterCachedModels(models, options) {
+  const normalizedSearch = options.search?.trim().toLowerCase();
+  const filtered = normalizedSearch ? models.filter((model) => model.id.toLowerCase().includes(normalizedSearch)) : models;
+  return typeof options.limit === "number" ? filtered.slice(0, options.limit) : filtered;
+}
 async function fetchProviderModels(provider, options) {
-  const cachedModels = provider.models.map((modelId) => ({
-    id: modelId,
-    providerId: provider.id
-  }));
+  const cachedModels = filterCachedModels(
+    provider.models.map((modelId) => ({
+      id: modelId,
+      providerId: provider.id
+    })),
+    options
+  );
   if (options.cached) {
     return {
       source: "cache",
@@ -9852,7 +9927,7 @@ function createModelsCommand() {
     console.log(`Updated ${outputPath}`);
     console.log(`Synced ${models.length} models for ${provider.id}`);
   });
-  command.command("use").description("Select a model for a provider and optionally assign it to a brain role.").argument("<model>", "Model id to select").requiredOption("--provider <provider>", "Provider id to use").option("--role <role>", "Brain role to assign: planner, coder, reviewer, or fast").option("--set-default", "Also set this model as the provider default", false).option("--force", "Skip remote model validation", false).option("--temperature <value>", "Temperature override for the role", parseNumber2).option("--max-tokens <value>", "Max token override for the role", parseInteger).action(async (model, options) => {
+  command.command("use").description("Select a model for a provider and assign it globally unless a specific role is requested.").argument("<model>", "Model id to select").requiredOption("--provider <provider>", "Provider id to use").option("--role <role>", "Brain role to assign: planner, coder, reviewer, or fast").option("--set-default", "Also set this model as the provider default", false).option("--force", "Skip remote model validation", false).option("--temperature <value>", "Temperature override for the role", parseNumber2).option("--max-tokens <value>", "Max token override for the role", parseInteger).action(async (model, options) => {
     let config = await loadConfig(import_node_process5.default.cwd());
     if (!config) {
       requireConfigMessage2();
@@ -9902,12 +9977,16 @@ function createModelsCommand() {
           maxTokens: options.maxTokens
         } : {}
       });
+    } else {
+      config = assignProviderToAllBrains(config, provider.id, model);
     }
     const outputPath = await saveConfig(config, import_node_process5.default.cwd());
     console.log(`Updated ${outputPath}`);
     console.log(`Selected ${provider.id}/${model}`);
     if (options.role) {
       console.log(`Assigned role ${options.role}`);
+    } else {
+      console.log("Assigned all roles");
     }
     if (shouldSetDefault) {
       console.log(`Set provider default model to ${model}`);
@@ -10559,6 +10638,7 @@ var DIM = "\x1B[2m";
 var RESET = "\x1B[0m";
 var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "agents",
+  "brain",
   "brains",
   "doctor",
   "fix",
@@ -10568,15 +10648,30 @@ var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "models",
   "new",
   "plan",
+  "provider",
   "providers",
   "quit",
   "resume",
   "review",
   "run",
   "scaffold",
+  "select",
   "shell",
-  "status"
+  "status",
+  "use-model"
 ]);
+var MODEL_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "help",
+  "list",
+  "sync",
+  "use"
+]);
+var BRAIN_ROLES = [
+  "planner",
+  "coder",
+  "reviewer",
+  "fast"
+];
 function color(code, value) {
   return `${code}${value}${RESET}`;
 }
@@ -10589,12 +10684,14 @@ function renderBanner() {
     "|_|\\_\\_|_|  |_|____/|____/|_| |_|\\___/ "
   ].map((line) => color(AMBER, line)).join("\n");
 }
-async function getShellSessionState(cwd) {
+async function getShellSessionState(cwd, focusRole) {
   const config = await loadConfig(cwd);
   if (!config) {
     return {
+      focusRole,
       providerLabel: "unconfigured",
       providerId: "-",
+      focusModel: "not set",
       coderModel: "not set",
       plannerModel: "not set",
       approvalMode: "manual",
@@ -10603,11 +10700,13 @@ async function getShellSessionState(cwd) {
       configured: false
     };
   }
-  const coderSettings = config.brains.coder;
-  const provider = findProviderById(config, coderSettings.providerId);
+  const focusSettings = config.brains[focusRole];
+  const provider = findProviderById(config, focusSettings.providerId);
   return {
+    focusRole,
     providerLabel: provider?.label ?? provider?.id ?? "unknown",
-    providerId: provider?.id ?? coderSettings.providerId,
+    providerId: provider?.id ?? focusSettings.providerId,
+    focusModel: resolveBrainModel(config, focusRole) ?? "not set",
     coderModel: resolveBrainModel(config, "coder") ?? "not set",
     plannerModel: resolveBrainModel(config, "planner") ?? "not set",
     approvalMode: config.approvalMode,
@@ -10640,20 +10739,25 @@ function renderBox(lines) {
 function renderHelp() {
   return [
     `${color(DIM, "Commands")}`,
-    "/status           Show the active model, provider, and workspace state.",
-    "/plan <goal>      Create a structured implementation plan.",
-    "/run <goal>       Start a Kimbho execution session for a goal.",
-    "/new <goal>       Alias for /run <goal>.",
-    "/scaffold <goal>  Alias for /run <goal> with scaffolding intent.",
-    "/resume           Show the latest saved session.",
-    "/agents           Inspect agent roles and the active session.",
-    "/providers        Manage model providers.",
-    "/model            Show the active planner/coder model selection.",
-    "/models           Discover and select provider models.",
-    "/brains           Inspect or assign planner/coder/reviewer brains.",
-    "/doctor           Check local environment and config.",
-    "/clear            Redraw the shell.",
-    "/quit, /exit      Leave the shell.",
+    "/status                  Show the active role, provider, and workspace state.",
+    "/brain <role>            Change shell focus to planner, coder, reviewer, or fast.",
+    "/model                   Show current brain assignments.",
+    "/providers               List configured providers.",
+    "/providers templates     Show built-in provider templates.",
+    "/providers add <tpl> [id] [--base-url <url>] [--model <id>] [--api-key-env <env>]",
+    "                         Add a provider from a built-in template.",
+    "/providers use <id>      Use a provider for all agent roles.",
+    "/providers check         Run provider health checks.",
+    "/models [search]         Discover models for the active role's provider.",
+    "/select <n>              Select a model from the last numbered /models list.",
+    "/use-model <id>          Assign a model to all agent roles.",
+    "/plan <goal>             Create a structured implementation plan.",
+    "/run <goal>              Start a Kimbho execution session for a goal.",
+    "/resume                  Show the latest saved session.",
+    "/agents                  Inspect agent roles and the active session.",
+    "/doctor                  Check local environment and config.",
+    "/clear                   Redraw the shell.",
+    "/quit, /exit             Leave the shell.",
     "",
     `${color(DIM, "Tip")}`,
     "Type a natural-language goal directly and Kimbho will treat it as /run <goal>."
@@ -10662,6 +10766,8 @@ function renderHelp() {
 function renderStartupCard(cwd, state) {
   const cardLines = [
     `${color(BOLD, "Kimbho CLI")} (v${KIMBHO_VERSION})`,
+    renderCardLine("focus", state.focusRole),
+    renderCardLine("model", state.focusModel),
     renderCardLine("coder", state.coderModel),
     renderCardLine("planner", state.plannerModel),
     renderCardLine("provider", `${state.providerLabel} [${state.providerId}]`),
@@ -10669,23 +10775,23 @@ function renderStartupCard(cwd, state) {
     renderCardLine("approval", state.approvalMode),
     renderCardLine("sandbox", state.sandboxMode),
     renderCardLine("preset", state.stackPreset),
-    renderCardLine("shortcuts", "/help  /status  /plan  /run  /models  /brains  /quit")
+    renderCardLine("shortcuts", "/brain  /providers  /models  /select  /use-model  /quit")
   ];
   if (!state.configured) {
-    cardLines.push("setup: run /init to create .kimbho/config.json");
+    cardLines.push("setup: run /init or /providers add <template> to create .kimbho/config.json");
   }
   return renderBox(cardLines);
 }
 function formatPrompt(state) {
-  const coderModel = state.coderModel === "not set" ? "unconfigured" : shortenMiddle(state.coderModel, 18);
-  return `${color(AMBER, "kimbho")} ${color(DIM, `[${coderModel}]`)} > `;
+  const model = state.focusModel === "not set" ? "unconfigured" : shortenMiddle(state.focusModel, 18);
+  return `${color(AMBER, "kimbho")} ${color(DIM, `[${state.focusRole}:${model}]`)} > `;
 }
 function printHeader(cwd, state) {
   console.log(renderBanner());
   console.log(color(DIM, "Terminal-native coding agent"));
   console.log(renderStartupCard(cwd, state));
   console.log("");
-  console.log(color(DIM, "Tip: describe the app or repo change you want, and Kimbho will route it into /run."));
+  console.log(color(DIM, "Tip: configure providers and models here, then describe the work and Kimbho will route it into /run."));
   console.log(renderHelp());
   console.log("");
 }
@@ -10736,21 +10842,426 @@ function tokenizeInput(input) {
   }
   return tokens;
 }
-function toCommandTokens(input) {
+function normalizeInputTokens(input) {
   const trimmed = input.trim();
   if (!trimmed) {
-    return [];
+    return {
+      normalizedInput: "",
+      tokens: [],
+      head: null
+    };
   }
   const normalizedInput = trimmed.startsWith("kimbho ") ? trimmed.slice("kimbho ".length).trim() : trimmed;
   const tokens = tokenizeInput(normalizedInput);
-  if (tokens.length === 0) {
+  const firstToken = tokens[0];
+  if (!firstToken) {
+    return {
+      normalizedInput,
+      tokens,
+      head: null
+    };
+  }
+  return {
+    normalizedInput,
+    tokens,
+    head: firstToken.startsWith("/") ? firstToken.slice(1) : firstToken
+  };
+}
+function defaultProviderIdForTemplate(templateId) {
+  switch (templateId) {
+    case "openai":
+      return "openai-main";
+    case "anthropic":
+      return "anthropic-main";
+    case "openrouter":
+      return "openrouter-main";
+    case "ollama":
+      return "ollama-local";
+    case "lmstudio":
+      return "lmstudio-local";
+    default:
+      return `${templateId}-main`;
+  }
+}
+function parseProviderAddOptions(tokens) {
+  const templateId = tokens[2];
+  if (!templateId) {
+    throw new Error("Usage: /providers add <template> [provider-id] [--base-url <url>] [--model <id>] [--api-key-env <env>]");
+  }
+  let index = 3;
+  let providerId;
+  if (tokens[index] && !tokens[index]?.startsWith("-")) {
+    providerId = tokens[index];
+    index += 1;
+  }
+  const options = {
+    templateId,
+    ...providerId ? {
+      providerId
+    } : {}
+  };
+  while (index < tokens.length) {
+    const flag = tokens[index];
+    if (!flag?.startsWith("--")) {
+      throw new Error(`Unexpected token "${flag}".`);
+    }
+    const value = tokens[index + 1];
+    if (!value || value.startsWith("--")) {
+      throw new Error(`Missing value for ${flag}.`);
+    }
+    switch (flag) {
+      case "--label":
+        options.label = value;
+        break;
+      case "--base-url":
+        options.baseUrl = normalizeTemplateBaseUrl(templateId, value) ?? value;
+        break;
+      case "--api-key-env":
+        options.apiKeyEnv = value;
+        break;
+      case "--model":
+        options.model = value;
+        break;
+      default:
+        throw new Error(`Unknown option "${flag}". Supported: --label, --base-url, --api-key-env, --model.`);
+    }
+    index += 2;
+  }
+  return options;
+}
+function buildCachedModels(provider, search, limit = 25) {
+  const normalized = search?.trim().toLowerCase();
+  const filtered = normalized ? provider.models.filter((modelId) => modelId.toLowerCase().includes(normalized)) : provider.models;
+  return filtered.slice(0, limit).map((modelId) => ({
+    id: modelId,
+    providerId: provider.id
+  }));
+}
+async function fetchModelsForProvider(cwd, config, provider, search, limit = 25) {
+  const registry = createDefaultBrainProviderRegistry(cwd);
+  const cachedModels = buildCachedModels(provider, search, limit);
+  try {
+    const models = await registry.listModels(provider, {
+      ...search ? {
+        search
+      } : {},
+      limit
+    });
+    const nextConfig = upsertProvider(config, {
+      ...provider,
+      models: Array.from(/* @__PURE__ */ new Set([
+        ...provider.models,
+        ...models.map((model) => model.id)
+      ]))
+    });
+    if (nextConfig !== config) {
+      await saveConfig(nextConfig, cwd);
+    }
+    return {
+      config: nextConfig,
+      source: "remote",
+      models
+    };
+  } catch (error) {
+    if (cachedModels.length > 0) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        config,
+        source: "cache",
+        note: `Using cached models because remote discovery failed: ${message}`,
+        models: cachedModels
+      };
+    }
+    throw error;
+  }
+}
+async function assignModelGlobally(cwd, providerId, model) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    throw new Error("No config found. Run /init or /providers add first.");
+  }
+  const provider = findProviderById(config, providerId);
+  if (!provider) {
+    throw new Error(`Unknown provider "${providerId}".`);
+  }
+  const nextConfig = assignProviderToAllBrains(
+    upsertProvider(config, {
+      ...provider,
+      defaultModel: model,
+      models: Array.from(/* @__PURE__ */ new Set([
+        ...provider.models,
+        model
+      ]))
+    }),
+    providerId,
+    model
+  );
+  const outputPath = await saveConfig(nextConfig, cwd);
+  return outputPath;
+}
+async function useProviderGlobally(cwd, providerId) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    throw new Error("No config found. Run /init or /providers add first.");
+  }
+  const provider = findProviderById(config, providerId);
+  if (!provider) {
+    throw new Error(`Unknown provider "${providerId}".`);
+  }
+  const resolvedModel = provider.defaultModel ?? provider.models[0] ?? null;
+  const nextConfig = assignProviderToAllBrains(config, provider.id, resolvedModel);
+  const outputPath = await saveConfig(nextConfig, cwd);
+  return {
+    outputPath,
+    model: resolvedModel
+  };
+}
+function renderModelLine2(model) {
+  const details = [
+    model.name,
+    model.contextLength ? `ctx ${model.contextLength}` : null,
+    model.promptPrice ? `in ${model.promptPrice}` : null,
+    model.completionPrice ? `out ${model.completionPrice}` : null,
+    model.modality
+  ].filter((value) => Boolean(value));
+  return details.length > 0 ? `${model.id} | ${details.join(" | ")}` : model.id;
+}
+async function printProviderList(cwd, focusRole) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    console.log("No config found. Run /init or /providers add <template> first.");
+    return;
+  }
+  const activeProviderId = config.brains[focusRole].providerId;
+  for (const provider of config.providers) {
+    const marker = provider.id === activeProviderId ? "*" : " ";
+    const envState = provider.apiKeyEnv ? import_node_process10.default.env[provider.apiKeyEnv] ? "present" : `missing ${provider.apiKeyEnv}` : "no key required";
+    console.log(`${marker} ${provider.id}`);
+    console.log(`  label: ${provider.label ?? "-"}`);
+    console.log(`  driver: ${provider.driver}`);
+    console.log(`  model: ${provider.defaultModel ?? "-"}`);
+    console.log(`  baseUrl: ${provider.baseUrl ?? "-"}`);
+    console.log(`  auth: ${envState}`);
+    console.log(`  cachedModels: ${provider.models.length}`);
+  }
+}
+function printProviderTemplates() {
+  for (const template of listProviderTemplates()) {
+    console.log(`${template.id}`);
+    console.log(`  label: ${template.label}`);
+    console.log(`  driver: ${template.driver}`);
+    console.log(`  apiKeyEnv: ${template.defaultApiKeyEnv ?? "-"}`);
+    console.log(`  model: ${template.defaultModel ?? "-"}`);
+    console.log(`  notes: ${template.notes}`);
+  }
+}
+async function addProviderFromTemplate(cwd, options) {
+  const provider = buildProviderFromTemplate(options.templateId, {
+    providerId: options.providerId ?? defaultProviderIdForTemplate(options.templateId),
+    ...options.label ? {
+      label: options.label
+    } : {},
+    ...options.baseUrl ? {
+      baseUrl: options.baseUrl
+    } : {},
+    ...options.apiKeyEnv ? {
+      apiKeyEnv: options.apiKeyEnv
+    } : {},
+    ...options.model ? {
+      model: options.model
+    } : {}
+  });
+  const config = await loadConfig(cwd);
+  if (!config) {
+    const outputPath = await saveConfig(createDefaultConfig({ provider }), cwd);
+    return outputPath;
+  }
+  return saveConfig(upsertProvider(config, provider), cwd);
+}
+async function printProviderHealth(cwd) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    console.log("No config found. Run /init or /providers add <template> first.");
+    return;
+  }
+  const registry = createDefaultBrainProviderRegistry(cwd);
+  for (const provider of config.providers) {
+    try {
+      const result = await registry.healthCheck(provider);
+      console.log(`${result.ok ? "PASS" : "FAIL"} ${provider.id}: ${provider.driver} | ${result.message}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`FAIL ${provider.id}: ${provider.driver} | ${message}`);
+    }
+  }
+}
+async function printBrainAssignments(cwd) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    console.log("No config found. Run /init or /providers add <template> first.");
+    return;
+  }
+  for (const role of BRAIN_ROLES) {
+    const settings = resolveBrainSettings(config, role);
+    console.log(`${role}`);
+    console.log(`  provider: ${settings.providerId}`);
+    console.log(`  model: ${resolveBrainModel(config, role) ?? "-"}`);
+    console.log(`  temperature: ${settings.temperature ?? "-"}`);
+    console.log(`  maxTokens: ${settings.maxTokens ?? "-"}`);
+  }
+}
+function isBrainRole(value) {
+  return BRAIN_ROLES.includes(value);
+}
+async function handleProvidersCommand(cwd, tokens, runtime) {
+  const subcommand = tokens[1];
+  if (!subcommand || subcommand === "list") {
+    await printProviderList(cwd, runtime.focusRole);
+    return;
+  }
+  if (subcommand === "templates") {
+    printProviderTemplates();
+    return;
+  }
+  if (subcommand === "check") {
+    await printProviderHealth(cwd);
+    return;
+  }
+  if (subcommand === "add") {
+    const options = parseProviderAddOptions(tokens);
+    const outputPath = await addProviderFromTemplate(cwd, options);
+    const resolvedProviderId = options.providerId ?? defaultProviderIdForTemplate(options.templateId);
+    console.log(`Updated ${outputPath}`);
+    console.log(`Added provider ${resolvedProviderId} from template ${options.templateId}`);
+    if (options.baseUrl) {
+      console.log(`Base URL ${options.baseUrl}`);
+    }
+    console.log(`Next: /providers use ${resolvedProviderId}`);
+    return;
+  }
+  if (subcommand === "use") {
+    const providerId = tokens[2];
+    if (!providerId) {
+      throw new Error("Usage: /providers use <provider-id>");
+    }
+    const result = await useProviderGlobally(cwd, providerId);
+    runtime.lastModels = null;
+    console.log(`Updated ${result.outputPath}`);
+    console.log(`All roles now use provider ${providerId}${result.model ? ` (${result.model})` : ""}`);
+    return;
+  }
+  throw new Error("Usage: /providers [list|templates|add|use|check]");
+}
+async function handleBrainCommand(cwd, tokens, runtime) {
+  const subcommand = tokens[1];
+  if (!subcommand || subcommand === "list") {
+    await printBrainAssignments(cwd);
+    return;
+  }
+  if (subcommand === "use" && tokens[2] && isBrainRole(tokens[2])) {
+    runtime.focusRole = tokens[2];
+    runtime.lastModels = null;
+    console.log(`Shell focus role is now ${runtime.focusRole}.`);
+    return;
+  }
+  if (isBrainRole(subcommand)) {
+    runtime.focusRole = subcommand;
+    runtime.lastModels = null;
+    console.log(`Shell focus role is now ${runtime.focusRole}.`);
+    return;
+  }
+  throw new Error("Usage: /brain [planner|coder|reviewer|fast]");
+}
+async function handleModelsCommand(cwd, tokens, runtime) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    throw new Error("No config found. Run /init or /providers add <template> first.");
+  }
+  const providerId = config.brains[runtime.focusRole].providerId;
+  const provider = findProviderById(config, providerId);
+  if (!provider) {
+    throw new Error(`Active role "${runtime.focusRole}" points to unknown provider "${providerId}".`);
+  }
+  const subcommand = tokens[1];
+  if (subcommand === "use") {
+    const modelId = tokens.slice(2).join(" ").trim();
+    if (!modelId) {
+      throw new Error("Usage: /models use <model-id>");
+    }
+    const outputPath = await assignModelGlobally(cwd, provider.id, modelId);
+    console.log(`Updated ${outputPath}`);
+    console.log(`Selected ${provider.id}/${modelId}`);
+    console.log("Assigned all roles");
+    return;
+  }
+  const search = !subcommand || MODEL_SUBCOMMANDS.has(subcommand) ? void 0 : tokens.slice(1).join(" ");
+  const result = await fetchModelsForProvider(cwd, config, provider, search, 25);
+  runtime.lastModels = {
+    providerId: provider.id,
+    role: runtime.focusRole,
+    source: result.source,
+    ...search ? {
+      search
+    } : {},
+    models: result.models
+  };
+  console.log(`${provider.id} (${result.source})`);
+  if (result.note) {
+    console.log(`  note: ${result.note}`);
+  }
+  if (result.models.length === 0) {
+    console.log("  no models found");
+    return;
+  }
+  for (const [index, model] of result.models.entries()) {
+    console.log(`  ${index + 1}. ${renderModelLine2(model)}`);
+  }
+  console.log(``);
+  console.log("Use /select <number> or /use-model <model-id> to assign one to all roles.");
+}
+async function handleModelSelection(cwd, modelId, runtime) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    throw new Error("No config found. Run /init or /providers add <template> first.");
+  }
+  const providerId = config.brains[runtime.focusRole].providerId;
+  const provider = findProviderById(config, providerId);
+  if (!provider) {
+    throw new Error(`Active role "${runtime.focusRole}" points to unknown provider "${providerId}".`);
+  }
+  const outputPath = await assignModelGlobally(cwd, provider.id, modelId);
+  console.log(`Updated ${outputPath}`);
+  console.log(`Selected ${provider.id}/${modelId}`);
+  console.log("Assigned all roles");
+}
+async function handleSelectCommand(cwd, tokens, runtime) {
+  const rawIndex = tokens[1];
+  if (!rawIndex) {
+    throw new Error("Usage: /select <number>");
+  }
+  if (!runtime.lastModels || runtime.lastModels.models.length === 0) {
+    throw new Error("No model list is active. Run /models first.");
+  }
+  const index = Number.parseInt(rawIndex, 10);
+  if (!Number.isInteger(index) || index <= 0) {
+    throw new Error(`Expected a positive model number, received "${rawIndex}".`);
+  }
+  const model = runtime.lastModels.models[index - 1];
+  if (!model) {
+    throw new Error(`Model number ${index} is out of range.`);
+  }
+  runtime.focusRole = runtime.lastModels.role;
+  await handleModelSelection(cwd, model.id, runtime);
+}
+function toExternalCommandTokens(input, state) {
+  const { normalizedInput, tokens, head } = normalizeInputTokens(input);
+  if (!head || tokens.length === 0) {
     return [];
   }
   const firstToken = tokens[0];
   if (!firstToken) {
     return [];
   }
-  const head = firstToken.startsWith("/") ? firstToken.slice(1) : firstToken;
   if (head === "new") {
     return [
       "run",
@@ -10764,12 +11275,6 @@ function toCommandTokens(input) {
       `scaffold ${goal}`.trim()
     ];
   }
-  if (head === "model") {
-    return [
-      "brains",
-      "list"
-    ];
-  }
   if (!firstToken.startsWith("/") && !TOP_LEVEL_COMMANDS.has(head) && !head.startsWith("-")) {
     return [
       "run",
@@ -10779,62 +11284,122 @@ function toCommandTokens(input) {
   tokens[0] = head;
   return tokens;
 }
+async function handleShellCommand(cwd, input, state, runtime, execute) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return;
+  }
+  if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit" || trimmed === "/quit") {
+    throw new Error("__kimbho_exit__");
+  }
+  if (trimmed === "/help" || trimmed === "help" || trimmed === "?") {
+    console.log(renderHelp());
+    return;
+  }
+  if (trimmed === "/status" || trimmed === "status") {
+    console.log(renderStartupCard(cwd, state));
+    return;
+  }
+  if (trimmed === "/clear" || trimmed === "clear") {
+    if (import_node_process10.default.stdout.isTTY) {
+      import_node_process10.default.stdout.write("\x1Bc");
+    }
+    const nextState = await getShellSessionState(cwd, runtime.focusRole);
+    printHeader(cwd, nextState);
+    return;
+  }
+  const { tokens, head } = normalizeInputTokens(trimmed);
+  if (!head) {
+    return;
+  }
+  if (head === "provider" || head === "providers") {
+    const subcommand = tokens[1];
+    const canHandleLocally = !subcommand || subcommand === "list" || subcommand === "templates" || subcommand === "check" || subcommand === "use" || subcommand === "add" && Boolean(tokens[2]) && !tokens[2]?.startsWith("-");
+    if (canHandleLocally) {
+      await handleProvidersCommand(cwd, [
+        "providers",
+        ...tokens.slice(1)
+      ], runtime);
+      return;
+    }
+  }
+  if (head === "brain" || head === "brains") {
+    const subcommand = tokens[1];
+    const roleArg = tokens[2];
+    const canHandleLocally = !subcommand || subcommand === "list" || isBrainRole(subcommand) || subcommand === "use" && (roleArg ? isBrainRole(roleArg) : false);
+    if (canHandleLocally) {
+      await handleBrainCommand(cwd, [
+        "brain",
+        ...tokens.slice(1)
+      ], runtime);
+      return;
+    }
+  }
+  if (head === "model") {
+    await printBrainAssignments(cwd);
+    return;
+  }
+  if (head === "models") {
+    await handleModelsCommand(cwd, [
+      "models",
+      ...tokens.slice(1)
+    ], runtime);
+    return;
+  }
+  if (head === "use-model") {
+    const modelId = tokens.slice(1).join(" ").trim();
+    if (!modelId) {
+      throw new Error("Usage: /use-model <model-id>");
+    }
+    await handleModelSelection(cwd, modelId, runtime);
+    return;
+  }
+  if (head === "select") {
+    await handleSelectCommand(cwd, [
+      "select",
+      ...tokens.slice(1)
+    ], runtime);
+    return;
+  }
+  const externalTokens = toExternalCommandTokens(trimmed, state);
+  if (externalTokens.length === 0) {
+    return;
+  }
+  await execute(externalTokens);
+}
 async function runInteractiveShell(options) {
   const readline = (0, import_promises8.createInterface)({
     input: import_node_process10.default.stdin,
     output: import_node_process10.default.stdout,
     terminal: Boolean(import_node_process10.default.stdin.isTTY && import_node_process10.default.stdout.isTTY)
   });
+  const runtime = {
+    focusRole: "coder",
+    lastModels: null
+  };
   let closed = false;
   readline.on("SIGINT", () => {
     closed = true;
     readline.close();
   });
-  let state = await getShellSessionState(options.cwd);
+  let state = await getShellSessionState(options.cwd, runtime.focusRole);
   printHeader(options.cwd, state);
   while (!closed) {
     let line;
     try {
-      state = await getShellSessionState(options.cwd);
+      state = await getShellSessionState(options.cwd, runtime.focusRole);
       line = await readline.question(formatPrompt(state));
     } catch {
       break;
     }
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
-    if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit" || trimmed === "/quit") {
-      closed = true;
-      break;
-    }
-    if (trimmed === "/help" || trimmed === "help" || trimmed === "?") {
-      console.log(renderHelp());
-      console.log("");
-      continue;
-    }
-    if (trimmed === "/status" || trimmed === "status") {
-      state = await getShellSessionState(options.cwd);
-      console.log(renderStartupCard(options.cwd, state));
-      console.log("");
-      continue;
-    }
-    if (trimmed === "/clear" || trimmed === "clear") {
-      if (import_node_process10.default.stdout.isTTY) {
-        import_node_process10.default.stdout.write("\x1Bc");
-      }
-      state = await getShellSessionState(options.cwd);
-      printHeader(options.cwd, state);
-      continue;
-    }
     try {
-      const tokens = toCommandTokens(trimmed);
-      if (tokens.length === 0) {
-        continue;
-      }
-      await options.execute(tokens);
+      await handleShellCommand(options.cwd, line, state, runtime, options.execute);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
+      if (message === "__kimbho_exit__") {
+        closed = true;
+        break;
+      }
       console.error(message);
     } finally {
       import_node_process10.default.exitCode = 0;