agent-sh 0.12.20 → 0.12.22

package/dist/extensions/agent-backend.js

@@ -2,6 +2,7 @@ import { AgentLoop } from "../agent/agent-loop.js";
 import { LlmClient } from "../utils/llm-client.js";
 import { resolveProvider, getProviderNames, getSettings } from "../settings.js";
 import { PACKAGE_VERSION } from "../utils/package-version.js";
+import { discoverSkills } from "../agent/skills.js";
 /** Read the user's persisted defaultModel for a provider, if any. */
 function persistedModelFor(providerName) {
     if (!providerName)
@@ -11,24 +12,50 @@ function persistedModelFor(providerName) {
 function defaultReasoningBuilder(level) {
     return level === "off" ? {} : { reasoning_effort: level };
 }
+function mergeCaps(settingsCaps, payloadCaps, modelIds) {
+    if (!settingsCaps)
+        return payloadCaps.size > 0 ? payloadCaps : undefined;
+    const out = new Map();
+    for (const id of modelIds) {
+        const s = settingsCaps.get(id);
+        const p = payloadCaps.get(id);
+        if (!s && !p)
+            continue;
+        out.set(id, {
+            reasoning: s?.reasoning ?? p?.reasoning,
+            contextWindow: s?.contextWindow ?? p?.contextWindow,
+            maxTokens: s?.maxTokens ?? p?.maxTokens,
+            echoReasoning: s?.echoReasoning ?? p?.echoReasoning,
+        });
+    }
+    return out.size > 0 ? out : undefined;
+}
 export default function agentBackend(ctx) {
     const { bus } = ctx;
     const config = ctx.call("config:get-shell-config") ?? {};
-    // Seed from settings.json; runtime provider:register events add more.
+    // Immutable settings snapshot; provider:register payloads merge against it.
     const providerRegistry = new Map();
+    const settingsProviders = new Map();
     for (const name of getProviderNames()) {
         const p = resolveProvider(name);
-        if (p)
+        if (p) {
             providerRegistry.set(name, p);
+            settingsProviders.set(name, p);
+        }
     }
     const providerHooks = new Map();
+    // Bakes model id into the hook so AgentMode.buildReasoningParams keeps
+    // its (level) signature while the hook can branch on model.
+    const bindReasoning = (shapeId, model) => {
+        const hook = providerHooks.get(shapeId)?.reasoningParams;
+        return hook ? (level) => hook(level, model) : defaultReasoningBuilder;
+    };
     const buildModes = () => {
         const allModes = [];
         for (const [id, p] of providerRegistry) {
             if (!p.apiKey)
                 continue;
             const shapeId = p.reasoningShape ?? id;
-            const buildReasoningParams = providerHooks.get(shapeId)?.reasoningParams ?? defaultReasoningBuilder;
             for (const model of p.models) {
                 const mc = p.modelCapabilities?.get(model);
                 allModes.push({
@@ -40,7 +67,7 @@ export default function agentBackend(ctx) {
                     reasoning: mc?.reasoning,
                     supportsReasoningEffort: p.supportsReasoningEffort,
                     echoReasoning: mc?.echoReasoning,
-                    buildReasoningParams,
+                    buildReasoningParams: bindReasoning(shapeId, model),
                 });
             }
         }
@@ -55,11 +82,15 @@ export default function agentBackend(ctx) {
         return llmClient.complete({
             messages: messages,
             max_tokens: opts?.maxTokens,
+            model: opts?.model,
+            reasoning_effort: opts?.reasoningEffort,
         });
     });
     let modes = [];
     let initialModeIndex = 0;
     let resolved = false;
+    // Gates late-registration reconcile so its config:switch-model emit doesn't misroute under a non-ash backend.
+    let ashActive = false;
     bus.onPipe("config:get-initial-modes", () => ({ modes, initialModeIndex }));
     // AgentLoop must be constructed *before* user extensions activate,
     // because its ctor defines handlers (history:append, etc.) that
@@ -76,7 +107,9 @@ export default function agentBackend(ctx) {
         instanceId: ctx.instanceId,
         history: config.history,
     });
-    bus.on("core:extensions-loaded", () => {
+    let loadedExtensionNames = [];
+    bus.on("core:extensions-loaded", ({ names }) => {
+        loadedExtensionNames = names;
         const settings = getSettings();
         // If the user didn't pick a default, fall back to the first registered
         // provider (built-in load order biases to openrouter → openai).
@@ -121,9 +154,37 @@ export default function agentBackend(ctx) {
         resolved = true;
         bus.emit("agent:register-backend", {
             name: "ash",
-            kill: () => agentLoop.kill(),
+            kill: () => {
+                ashActive = false;
+                bus.emit("command:unregister", { name: "/compact" });
+                bus.emit("command:unregister", { name: "/context" });
+                agentLoop.kill();
+            },
             start: async () => {
                 agentLoop.wire();
+                ashActive = true;
+                bus.emit("command:register", {
+                    name: "/compact",
+                    description: "Compact conversation via the active compaction strategy",
+                    handler: () => bus.emit("agent:compact-request", {}),
+                });
+                bus.emit("command:register", {
+                    name: "/context",
+                    description: "Show context budget usage",
+                    handler: () => {
+                        const stats = bus.emitPipe("context:get-stats", {
+                            activeTokens: 0,
+                            totalTokens: 0,
+                            budgetTokens: 0,
+                        });
+                        const pct = stats.budgetTokens > 0
+                            ? Math.round((stats.activeTokens / stats.budgetTokens) * 100)
+                            : 0;
+                        bus.emit("ui:info", {
+                            message: `Active context: ~${stats.activeTokens.toLocaleString()} tokens / ${stats.budgetTokens.toLocaleString()} budget (${pct}%)`,
+                        });
+                    },
+                });
                 bus.emit("agent:info", {
                     name: "ash",
                     version: PACKAGE_VERSION,
@@ -142,46 +203,52 @@ export default function agentBackend(ctx) {
     });
     bus.on("provider:register", (p) => {
         const rawModels = p.models ?? (p.defaultModel ? [p.defaultModel] : []);
-        const modelIds = [];
-        const caps = new Map();
+        const payloadModelIds = [];
+        const payloadCaps = new Map();
         for (const m of rawModels) {
             if (typeof m === "string") {
-                modelIds.push(m);
+                payloadModelIds.push(m);
             }
             else {
-                modelIds.push(m.id);
-                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow, maxTokens: m.maxTokens, echoReasoning: m.echoReasoning });
+                payloadModelIds.push(m.id);
+                payloadCaps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow, maxTokens: m.maxTokens, echoReasoning: m.echoReasoning });
             }
         }
-        providerRegistry.set(p.id, {
+        const settings = settingsProviders.get(p.id);
+        const modelIds = settings?.modelsExplicit && settings.models.length > 0 ? settings.models : payloadModelIds;
+        const mergedCaps = mergeCaps(settings?.modelCapabilities, payloadCaps, modelIds);
+        const merged = {
             id: p.id,
-            apiKey: p.apiKey,
-            baseURL: p.baseURL,
-            defaultModel: p.defaultModel,
+            apiKey: settings?.apiKey ?? p.apiKey,
+            baseURL: settings?.baseURL ?? p.baseURL,
+            defaultModel: settings?.defaultModel ?? p.defaultModel,
             models: modelIds,
-            supportsReasoningEffort: p.supportsReasoningEffort,
-            modelCapabilities: caps.size > 0 ? caps : undefined,
-        });
-        const buildReasoningParams = providerHooks.get(p.id)?.reasoningParams ?? defaultReasoningBuilder;
+            modelsExplicit: settings?.modelsExplicit ?? false,
+            contextWindow: settings?.contextWindow,
+            supportsReasoningEffort: settings?.supportsReasoningEffort ?? p.supportsReasoningEffort,
+            modelCapabilities: mergedCaps,
+            reasoningShape: settings?.reasoningShape,
+        };
+        providerRegistry.set(p.id, merged);
         const addModes = modelIds.map((m) => {
-            const mc = caps.get(m);
+            const mc = mergedCaps?.get(m);
             return {
                 model: m,
                 provider: p.id,
-                providerConfig: { apiKey: p.apiKey ?? "", baseURL: p.baseURL },
+                providerConfig: { apiKey: merged.apiKey ?? "", baseURL: merged.baseURL },
                 contextWindow: mc?.contextWindow,
                 maxTokens: mc?.maxTokens,
                 reasoning: mc?.reasoning,
-                supportsReasoningEffort: p.supportsReasoningEffort,
+                supportsReasoningEffort: merged.supportsReasoningEffort,
                 echoReasoning: mc?.echoReasoning,
-                buildReasoningParams,
+                buildReasoningParams: bindReasoning(p.id, m),
             };
         });
         bus.emit("config:add-modes", { modes: addModes });
         // Late-registration reconcile: if this completes the user's persisted
         // default (openrouter's async fetch delivers the full catalog after
         // we've already fallen back to mode 0), quietly switch to it.
-        if (!resolved)
+        if (!resolved || !ashActive)
             return;
         const pendingProvider = getSettings().defaultProvider;
         if (pendingProvider !== p.id)
@@ -225,4 +292,17 @@ export default function agentBackend(ctx) {
         bus.emit("ui:info", { message: `Switched to ${name} (${switchModel})` });
         bus.emit("config:changed", {});
     });
+    bus.onPipe("banner:collect", (e) => {
+        const settings = getSettings();
+        if (settings.defaultBackend && settings.defaultBackend !== "ash")
+            return e;
+        if (loadedExtensionNames.length > 0) {
+            e.sections.push({ label: "Extensions", items: [...loadedExtensionNames] });
+        }
+        const skills = discoverSkills(ctx.call("cwd") ?? process.cwd());
+        if (skills.length > 0) {
+            e.sections.push({ label: "Skills", items: skills.map((s) => s.name) });
+        }
+        return e;
+    });
 }

package/dist/extensions/index.js

@@ -3,10 +3,15 @@ export const BUILTIN_EXTENSIONS = [
     { name: "agent-backend", load: () => import("./agent-backend.js").then(m => m.default) },
     { name: "openrouter",
         when: () => !!process.env.OPENROUTER_API_KEY,
-        load: () => import("./openrouter.js").then(m => m.default) },
+        load: () => import("./providers/openrouter.js").then(m => m.default) },
     { name: "openai",
-        when: () => !!process.env.OPENAI_API_KEY,
-        load: () => import("./openai.js").then(m => m.default) },
+        when: () => !!process.env.OPENAI_API_KEY && !process.env.OPENAI_BASE_URL,
+        load: () => import("./providers/openai.js").then(m => m.default) },
+    { name: "openai-compatible",
+        when: () => !!process.env.OPENAI_BASE_URL,
+        load: () => import("./providers/openai-compatible.js").then(m => m.default) },
+    { name: "deepseek",
+        load: () => import("./providers/deepseek.js").then(m => m.default) },
     { name: "tui-renderer", load: () => import("./tui-renderer.js").then(m => m.default) },
     { name: "slash-commands", load: () => import("./slash-commands.js").then(m => m.default) },
     { name: "file-autocomplete", load: () => import("./file-autocomplete.js").then(m => m.default) },

package/dist/extensions/providers/deepseek.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Native DeepSeek (api.deepseek.com). V4 ignores reasoning_effort for
+ * on/off — disable lives in a separate `thinking` field that defaults
+ * to enabled. The hook always attaches; provider registration via env
+ * is opt-in alongside any settings.json entry.
+ */
+import type { ExtensionContext } from "../../types.js";
+export default function activate(ctx: ExtensionContext): void;

package/dist/extensions/providers/deepseek.js

@@ -0,0 +1,23 @@
+const BASE_URL = "https://api.deepseek.com";
+const DEFAULT_MODELS = [
+    { id: "deepseek-v4-flash", reasoning: true, echoReasoning: true },
+    { id: "deepseek-v4-pro", reasoning: true, echoReasoning: true },
+];
+function buildReasoningParams(level, _model) {
+    return level === "off"
+        ? { thinking: { type: "disabled" } }
+        : { thinking: { type: "enabled" }, reasoning_effort: level };
+}
+export default function activate(ctx) {
+    ctx.providers.configure("deepseek", { reasoningParams: buildReasoningParams });
+    const apiKey = process.env.DEEPSEEK_API_KEY;
+    if (!apiKey)
+        return;
+    ctx.bus.emit("provider:register", {
+        id: "deepseek",
+        apiKey,
+        baseURL: BASE_URL,
+        defaultModel: DEFAULT_MODELS[0].id,
+        models: DEFAULT_MODELS,
+    });
+}

package/dist/extensions/providers/openai-compatible.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OpenAI Chat Completions-compatible local/3rd-party server (Ollama, LM
+ * Studio, vLLM, llama.cpp, …). No reasoning hook — the right shape depends
+ * on which model the server is serving; user extensions can add one.
+ */
+import type { ExtensionContext } from "../../types.js";
+export default function activate(ctx: ExtensionContext): void;

package/dist/extensions/providers/openai-compatible.js

@@ -0,0 +1,30 @@
+export default function activate(ctx) {
+    const baseURL = process.env.OPENAI_BASE_URL;
+    if (!baseURL)
+        return;
+    // Local servers often need no key; SDK still wants a non-empty string.
+    const apiKey = process.env.OPENAI_API_KEY || "no-key";
+    const id = "openai-compatible";
+    ctx.bus.emit("provider:register", { id, apiKey, baseURL, models: [] });
+    fetchModels(baseURL, apiKey).then((models) => {
+        if (models.length === 0)
+            return;
+        ctx.bus.emit("provider:register", {
+            id,
+            apiKey,
+            baseURL,
+            defaultModel: models[0],
+            models,
+        });
+    }).catch(() => { });
+}
+async function fetchModels(baseURL, apiKey) {
+    const headers = {};
+    if (apiKey && apiKey !== "no-key")
+        headers.Authorization = `Bearer ${apiKey}`;
+    const res = await fetch(`${baseURL.replace(/\/$/, "")}/models`, { headers });
+    if (!res.ok)
+        return [];
+    const data = await res.json();
+    return (data.data ?? []).map((m) => m.id);
+}

package/dist/extensions/providers/openai.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Cloud OpenAI (api.openai.com). reasoning_effort vocabulary diverges per
+ * family: o-series has no off; gpt-5-codex floors at "low"; plain gpt-5
+ * floors at "minimal"; gpt-5.1+ accepts "none" as documented full off.
+ */
+import type { ExtensionContext } from "../../types.js";
+export default function activate(ctx: ExtensionContext): void;

package/dist/extensions/providers/openai.js

@@ -0,0 +1,39 @@
+const CLOUD_MODELS = [
+    { id: "gpt-5", reasoning: true },
+    { id: "gpt-4.1", reasoning: false },
+    { id: "gpt-4o", reasoning: false },
+    { id: "gpt-4o-mini", reasoning: false },
+    { id: "o3", reasoning: true },
+    { id: "o3-mini", reasoning: true },
+];
+function offEffortFor(model) {
+    if (/^o\d/.test(model))
+        return null;
+    if (model.startsWith("gpt-5-codex"))
+        return "low";
+    if (/^gpt-5\.[1-9]/.test(model))
+        return "none";
+    if (/^gpt-5(?!\.)/.test(model))
+        return "minimal";
+    return null;
+}
+function buildReasoningParams(level, model) {
+    if (level !== "off")
+        return { reasoning_effort: level };
+    const off = model ? offEffortFor(model) : null;
+    return off ? { reasoning_effort: off } : {};
+}
+export default function activate(ctx) {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey)
+        return;
+    if (process.env.OPENAI_BASE_URL)
+        return; // openai-compatible handles this
+    ctx.providers.configure("openai", { reasoningParams: buildReasoningParams });
+    ctx.bus.emit("provider:register", {
+        id: "openai",
+        apiKey,
+        defaultModel: CLOUD_MODELS[0].id,
+        models: CLOUD_MODELS,
+    });
+}

package/dist/extensions/{openrouter.d.ts → providers/openrouter.d.ts}

@@ -3,5 +3,5 @@
  * Registers curated defaults synchronously so the first query works, then
  * fetches the full catalog to populate /model autocomplete.
  */
-import type { ExtensionContext } from "../types.js";
+import type { ExtensionContext } from "../../types.js";
 export default function activate(ctx: ExtensionContext): void;

package/dist/extensions/{openrouter.js → providers/openrouter.js}

@@ -1,4 +1,4 @@
-import { getSettings } from "../settings.js";
+import { getSettings } from "../../settings.js";
 const BASE_URL = "https://openrouter.ai/api/v1";
 const DEFAULT_MODELS = ["deepseek/deepseek-v4-flash"];
 // Built-in defaults for models requiring reasoning_content echoed back
@@ -6,9 +6,11 @@ const DEFAULT_MODELS = ["deepseek/deepseek-v4-flash"];
 //   providers.openrouter.echoReasoningPatterns = ["deepseek", "..."]
 //   providers.openrouter.models[*].echoReasoning = true | false
 const BUILTIN_ECHO_REASONING_PATTERNS = [/deepseek/i];
-function buildReasoningParams(level) {
+// `effort: "none"` is the documented disable; honored by OpenAI/Grok, ignored
+// by Anthropic/Gemini/DeepSeek-via-OpenRouter (use native deepseek for a hard off).
+function buildReasoningParams(level, _model) {
     return level === "off"
-        ? { reasoning: { enabled: false } }
+        ? { reasoning: { effort: "none" } }
         : { reasoning: { effort: level } };
 }
 export default function activate(ctx) {

package/dist/extensions/slash-commands.js

@@ -76,30 +76,6 @@ export default function activate(ctx) {
             }
         },
     });
-    register({
-        name: "/compact",
-        description: "Compact conversation via the active compaction strategy",
-        handler: () => {
-            bus.emit("agent:compact-request", {});
-        },
-    });
-    register({
-        name: "/context",
-        description: "Show context budget usage",
-        handler: () => {
-            const stats = bus.emitPipe("context:get-stats", {
-                activeTokens: 0,
-                totalTokens: 0,
-                budgetTokens: 0,
-            });
-            const pct = stats.budgetTokens > 0
-                ? Math.round((stats.activeTokens / stats.budgetTokens) * 100)
-                : 0;
-            bus.emit("ui:info", {
-                message: `Active context: ~${stats.activeTokens.toLocaleString()} tokens / ${stats.budgetTokens.toLocaleString()} budget (${pct}%)`,
-            });
-        },
-    });
     register({
         name: "/reload",
         description: "Reload user extensions from ~/.agent-sh/extensions/",

package/dist/extensions/tui-renderer.js

@@ -67,6 +67,8 @@ function createRenderState() {
         isThinking: false,
         showThinkingText: false,
         thinkingPending: false,
+        previewedDiffPending: false,
+        previewedDiffToolIds: new Set(),
     };
 }
 export default function activate(ctx) {
@@ -175,21 +177,20 @@ export default function activate(ctx) {
         s.thinkingPending = true;
         if (!s.isThinking) {
             s.isThinking = true;
-            if (s.showThinkingText) {
-                stopCurrentSpinner();
-                if (!s.renderer)
-                    startAgentResponse();
-            }
-            else {
+            if (!s.showThinkingText)
                 startThinkingSpinner();
-            }
         }
-        if (s.showThinkingText && e.text) {
-            s.thinkingPending = false;
+        if (s.showThinkingText) {
+            stopCurrentSpinner();
             if (!s.renderer)
                 startAgentResponse();
-            s.renderer.push(`${p.dim}${e.text}${p.reset}`);
-            drain();
+            if (e.text) {
+                s.thinkingPending = false;
+                // Wrap each sub-line so dim survives \n boundaries in the renderer.
+                const wrapped = `${p.dim}${e.text.replace(/\n/g, `${p.reset}\n${p.dim}`)}${p.reset}`;
+                s.renderer.push(wrapped);
+                drain();
+            }
         }
     });
     bus.on("agent:response-chunk", (e) => {
@@ -272,6 +273,10 @@ export default function activate(ctx) {
         s.currentToolKind = e.kind;
         s.toolStartTime = Date.now();
         s.orphanContHeaderKind = undefined;
+        if (s.previewedDiffPending && e.toolCallId) {
+            s.previewedDiffToolIds.add(e.toolCallId);
+        }
+        s.previewedDiffPending = false;
         if (e.title === "user_shell") {
             finalizeToolGroup();
             closeToolLine();
@@ -335,11 +340,18 @@ export default function activate(ctx) {
         s.toolExitCode = e.exitCode;
         if (e.exitCode !== 0)
             s.toolGroupAllOk = false;
+        let resultDisplay = e.resultDisplay;
+        if (e.toolCallId && s.previewedDiffToolIds.has(e.toolCallId)) {
+            s.previewedDiffToolIds.delete(e.toolCallId);
+            if (resultDisplay?.body?.kind === "diff") {
+                resultDisplay = { ...resultDisplay, body: undefined };
+            }
+        }
         if (s.toolGroupKind) {
             // Grouped tool — track success/failure and summaries, show aggregate on ⎿ line.
             // Don't restart spinner between grouped tools — it's already running from group start.
-            if (e.resultDisplay?.summary)
-                s.toolGroupSummaries.push(e.resultDisplay.summary);
+            if (resultDisplay?.summary)
+                s.toolGroupSummaries.push(resultDisplay.summary);
             if (e.toolCallId)
                 s.pendingToolCompletes.delete(e.toolCallId);
             s.toolGroupCompletedCount++;
@@ -358,10 +370,10 @@ export default function activate(ctx) {
             if (pending)
                 s.pendingToolCompletes.delete(e.toolCallId);
             if (pending?.orphaned) {
-                showOrphanedComplete(e.exitCode, e.resultDisplay, pending.title, pending.kind, pending.displayDetail);
+                showOrphanedComplete(e.exitCode, resultDisplay, pending.title, pending.kind, pending.displayDetail);
             }
             else {
-                showToolComplete(e.exitCode, e.resultDisplay, pending?.displayDetail ?? pending?.title);
+                showToolComplete(e.exitCode, resultDisplay, pending?.displayDetail ?? pending?.title);
             }
             s.currentToolKind = undefined;
             s.spinnerStartTime = 0;
@@ -432,6 +444,7 @@ export default function activate(ctx) {
             // Mark lastContentKind as "tool" so the tool call line that follows
             // doesn't inject an extra gap between the diff box and the checkmark.
             s.lastContentKind = "tool";
+            s.previewedDiffPending = true;
         }
         // Don't endAgentResponse() here — permission requests that aren't
         // file-write diffs are handled inline (auto-approved or by extensions).

package/dist/index.js

@@ -7,7 +7,6 @@ import { palette as p } from "./utils/palette.js";
 import { loadBuiltinExtensions } from "./extensions/index.js";
 import { loadExtensions } from "./extension-loader.js";
 import { getSettings } from "./settings.js";
-import { discoverSkills } from "./agent/skills.js";
 import { runInit } from "./init.js";
 import { PACKAGE_VERSION } from "./utils/package-version.js";
 /**
@@ -270,11 +269,8 @@ async function main() {
     if (process.env.DEBUG) {
         console.error('[agent-sh] Extensions loaded');
     }
-    // Tell deferred-init listeners (agent-backend) that the provider
-    // registry is now complete.
-    core.bus.emit("core:extensions-loaded", {});
-    // ── Discover skills ───────────────────────────────────────────
-    const skills = discoverSkills(process.cwd());
+    // Names ride along so backend extensions can build banner sections.
+    core.bus.emit("core:extensions-loaded", { names: loadedExtensions });
     // ── Activate agent backend ────────────────────────────────────
     // Extensions had their chance to register via agent:register-backend.
     // If none did, the built-in AgentLoop gets wired to bus events.
@@ -288,6 +284,7 @@ async function main() {
             "  Alternatively, install a bridge extension (claude-code-bridge, pi-bridge).\n");
         process.exit(1);
     }
+    // No await: banner must out-race the shell's PS1 arriving via PTY.
     core.activateBackend();
     // ── Startup banner ───────────────────────────────────────────
     const settings = getSettings();
@@ -295,31 +292,11 @@ async function main() {
         const termW = process.stdout.columns || 80;
         const bannerW = Math.min(termW, 60);
         const productName = `${p.accent}${p.bold}agent-sh${p.reset}`;
-        const info = agentInfo;
-        const backendReady = !!info?.model;
-        const backendName = info?.name ?? "ash";
-        const model = info?.model;
-        const provider = info?.provider;
-        const modelValue = model
-            ? provider ? `${model} [${provider}]` : model
-            : null;
+        const backendName = settings.defaultBackend && backendNames.includes(settings.defaultBackend)
+            ? settings.defaultBackend
+            : backendNames[0];
         let sections = "";
-        sections += `\n\n  ${p.muted}Backend:${p.reset} ${p.dim}${backendName}${backendReady ? "" : " (not configured)"}${p.reset}`;
-        if (modelValue) {
-            sections += `\n  ${p.muted}Model:${p.reset} ${p.dim}${modelValue}${p.reset}`;
-        }
-        if (loadedExtensions.length > 0) {
-            sections += `\n\n  ${p.muted}Extensions:${p.reset}`;
-            for (const name of loadedExtensions) {
-                sections += `\n    ${p.dim}${name}${p.reset}`;
-            }
-        }
-        if (skills.length > 0) {
-            sections += `\n\n  ${p.muted}Skills:${p.reset}`;
-            for (const s of skills) {
-                sections += `\n    ${p.dim}${s.name}${p.reset}`;
-            }
-        }
+        sections += `\n\n  ${p.muted}Backend:${p.reset} ${p.dim}${backendName}${p.reset}`;
         const extSections = bus.emitPipe("banner:collect", { sections: [] }).sections;
         for (const sec of extSections) {
             sections += `\n\n  ${p.muted}${sec.label}:${p.reset}`;
@@ -327,9 +304,7 @@ async function main() {
                 sections += `\n    ${p.dim}${item}${p.reset}`;
             }
         }
-        const hint = backendReady
-            ? `${p.muted}Type ${p.warning}>${p.muted} to ask AI · ${p.warning}>/help${p.muted} for commands${p.reset}`
-            : `${p.muted}Set ${p.warning}OPENROUTER_API_KEY${p.muted} or ${p.warning}OPENAI_API_KEY${p.muted} and restart to enable AI${p.reset}`;
+        const hint = `${p.muted}Type ${p.warning}>${p.muted} to ask AI · ${p.warning}>/help${p.muted} for commands${p.reset}`;
         const borderLine = `${p.muted}${"─".repeat(bannerW)}${p.reset}`;
         process.stdout.write("\n" + borderLine + "\n" +
             "  " + productName +

package/dist/settings.d.ts

@@ -143,6 +143,8 @@ export interface ResolvedProvider {
     baseURL?: string;
     defaultModel?: string;
     models: string[];
+    /** User explicitly listed `models` (locks the catalog to that list). */
+    modelsExplicit: boolean;
     contextWindow?: number;
     /** Provider supports the reasoning_effort parameter. Default: true. */
     supportsReasoningEffort?: boolean;

package/dist/settings.js

@@ -160,6 +160,7 @@ export function resolveProvider(name) {
         baseURL: provider.baseURL,
         defaultModel,
         models: modelIds.length ? modelIds : (defaultModel ? [defaultModel] : []),
+        modelsExplicit: Array.isArray(provider.models),
         contextWindow: provider.contextWindow,
         modelCapabilities: caps.size > 0 ? caps : undefined,
         reasoningShape: provider.reasoningShape,

package/dist/types.d.ts

@@ -67,14 +67,27 @@ export interface LlmSession {
 }
 export interface LlmInterface {
     readonly available: boolean;
+    /** `model` overrides the globally-configured model for this call only.
+     *  Provider-specific identifier (e.g. "claude-haiku-4-5"). When omitted,
+     *  the active provider's configured default is used.
+     *
+     *  `reasoningEffort` controls thinking-model token allocation between
+     *  reasoning and final content (e.g. "low", "medium", "high", or
+     *  provider-specific). For non-reasoning models it is ignored. Set to
+     *  "low" for cheap structured-output calls so reasoning doesn't exhaust
+     *  the max-tokens budget and leave content empty. */
     ask(opts: {
         query: string;
         system?: string;
         maxTokens?: number;
+        model?: string;
+        reasoningEffort?: string;
     }): Promise<string>;
     session(opts?: {
         system?: string;
         maxTokens?: number;
+        model?: string;
+        reasoningEffort?: string;
     }): LlmSession;
 }
 export interface AgentShellConfig {
@@ -158,7 +171,7 @@ export interface ExtensionContext {
     }) => () => void;
     providers: {
         configure: (id: string, opts: {
-            reasoningParams?: (level: string) => Record<string, unknown>;
+            reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
         }) => void;
     };
     llm: LlmInterface;