@code-yeongyu/senpi 2026.10.9 → 2026.10.10-3

package/dist/core/extensions/builtin/mcp/manager.js

@@ -0,0 +1,193 @@
+import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { resolveAuthMode } from "./auth/context.js";
+import { updateMcpServerConfig } from "./config-edit.js";
+import { collectAllPages } from "./expose/pagination.js";
+import { McpManagerView } from "./manager-view.js";
+import { buildMcpStatusRows, formatMcpStatus } from "./status.js";
+const EXPOSURES = ["auto", "direct", "search", "proxy"];
+export async function showMcpManager(ctx, pi, service, run) {
+    const authAction = await ctx.ui.custom((tui, theme, keybindings, done) => {
+        const view = new McpManagerView(tui, theme, keybindings);
+        void manage(view, ctx, pi, service, run).then(done, (error) => {
+            done(undefined);
+            ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+        });
+        return view;
+    });
+    // The existing auth flow retains notices in the transcript; do not hide it behind a custom view.
+    if (authAction)
+        await run(authAction.command, authAction.name, ctx);
+}
+async function manage(view, ctx, pi, service, run) {
+    const subscribe = (listener) => {
+        let disconnect = [];
+        const bind = () => {
+            for (const stop of disconnect)
+                stop();
+            disconnect = service.getServerSnapshots().flatMap((snapshot) => {
+                const connection = service.getConnection(snapshot.name);
+                return connection ? [connection.onStateChange(listener)] : [];
+            });
+        };
+        bind();
+        const unregister = service.onMcpRegistrationChanged(() => {
+            bind();
+            listener();
+        });
+        return () => {
+            unregister();
+            for (const stop of disconnect)
+                stop();
+        };
+    };
+    for (;;) {
+        const name = await view.menu(async () => {
+            const rows = await buildMcpStatusRows(service.getServerSnapshots(), (server) => service.getServerExposureStatus(server));
+            return {
+                title: "MCP servers",
+                items: rows.map(({ snapshot, exposure }) => {
+                    const resources = service.getMcpResourceServers(pi).find((server) => server.server === snapshot.name);
+                    return {
+                        value: snapshot.name,
+                        label: snapshot.name,
+                        description: [
+                            snapshot.configState === "enabled" ? snapshot.lifecycleState : snapshot.configState,
+                            `${exposure.toolCount ?? "?"} tools`,
+                            ...(resources ? [`${resources.resources.length} resources`] : []),
+                            exposure.mode ?? service.getAuthTarget(snapshot.name)?.config.exposure ?? "auto",
+                            snapshot.source ?? "unknown",
+                        ].join(" · "),
+                    };
+                }),
+                empty: "No MCP servers configured. Add one with /mcp add <name> <command...|url>.",
+                confirmLabel: "manage",
+                cancelLabel: "close",
+            };
+        }, subscribe);
+        if (name === undefined)
+            return undefined;
+        let message;
+        for (;;) {
+            const action = await view.menu(() => {
+                const snapshot = service.getServerSnapshots().find((server) => server.name === name);
+                const config = service.getAuthTarget(name)?.config;
+                return {
+                    title: `MCP server ${name}`,
+                    details: [snapshot?.lastError, message].filter(Boolean).join("\n") || undefined,
+                    items: snapshot ? serverActions(snapshot, config, service.getServerAuthStatus(name) === "oAuth") : [],
+                    empty: "This server is no longer configured.",
+                    confirmLabel: "select",
+                    cancelLabel: "back",
+                };
+            }, subscribe);
+            if (action === undefined)
+                break;
+            const snapshot = service.getServerSnapshots().find((server) => server.name === name);
+            if (!snapshot)
+                break;
+            if (action === "auth" || action === "logout")
+                return { command: action, name };
+            message = undefined;
+            try {
+                if (action === "status") {
+                    const rows = await buildMcpStatusRows([snapshot], (server) => service.getServerExposureStatus(server));
+                    await showText(view, `Details of ${name}`, formatMcpStatus("", rows).trim());
+                }
+                else if (action === "logs") {
+                    await showText(view, `Logs of ${name}`, service.getLogLines(name, 20).join("\n") || "(empty)");
+                }
+                else if (action === "tools") {
+                    const connection = service.getConnection(name);
+                    if (connection?.state !== "connected")
+                        continue;
+                    const tools = await collectAllPages((cursor) => connection.client.listTools(cursor === undefined ? {} : { cursor }, { timeout: 2000 }));
+                    await view.menu(() => ({
+                        title: `Tools of ${name}`,
+                        items: tools.items.map((tool) => ({
+                            value: tool.name,
+                            label: tool.name,
+                            description: tool.description,
+                        })),
+                        empty: "The server offers no tools.",
+                        confirmLabel: "back",
+                        cancelLabel: "back",
+                    }));
+                }
+                else if (action === "enable" || action === "disable" || action === "exposure") {
+                    let exposure;
+                    if (action === "exposure") {
+                        const choice = await view.menu(() => ({
+                            title: `Exposure of ${name}`,
+                            items: EXPOSURES.map((value) => ({ value, label: value })),
+                            selected: service.getAuthTarget(name)?.config.exposure,
+                            confirmLabel: "save",
+                            cancelLabel: "back",
+                        }));
+                        exposure = EXPOSURES.find((value) => value === choice);
+                        if (exposure === undefined)
+                            continue;
+                    }
+                    if (!isWritable(snapshot) || !snapshot.sourcePath)
+                        continue;
+                    const patch = exposure === undefined ? { enabled: action === "enable" } : { exposure };
+                    if (!updateMcpServerConfig(snapshot.sourcePath, name, patch)) {
+                        message = "This server is no longer in its configuration file.";
+                        continue;
+                    }
+                    view.status(`MCP server ${name}`, "Applying configuration...");
+                    await service.attachSession({ type: "session_start", reason: "reload" }, ctx, pi);
+                    message = "Configuration saved.";
+                }
+                else if (action === "test" || action === "reconnect") {
+                    view.status(`MCP server ${name}`, action === "test" ? "Testing..." : "Reconnecting...");
+                    const notices = [];
+                    await run(action, name, ctx, (text) => notices.push(text));
+                    message = notices.join("\n");
+                }
+            }
+            catch (error) {
+                message = error instanceof Error ? error.message : String(error);
+            }
+        }
+    }
+}
+function isWritable(snapshot) {
+    return snapshot.configState !== "untrusted" && (snapshot.source === "global" || snapshot.source === "project");
+}
+function serverActions(snapshot, config, loggedIn) {
+    const items = [
+        { value: "status", label: "Details" },
+        { value: "logs", label: "Logs" },
+    ];
+    if (snapshot.configState === "enabled") {
+        if (snapshot.lifecycleState === "connected")
+            items.push({ value: "tools", label: "Tools" });
+        items.push({ value: "test", label: "Test connection" }, { value: "reconnect", label: "Reconnect" });
+        if (config && resolveAuthMode(config) === "oauth") {
+            items.push(loggedIn
+                ? { value: "logout", label: "Sign out", description: "deletes stored credentials" }
+                : { value: "auth", label: "Sign in", description: "closes this view and opens authorization" });
+        }
+    }
+    if (isWritable(snapshot)) {
+        items.push({
+            value: snapshot.configState === "disabled" ? "enable" : "disable",
+            label: snapshot.configState === "disabled" ? "Enable" : "Disable",
+            description: `saved to ${snapshot.source} mcp.json`,
+        });
+        items.push({ value: "exposure", label: "Exposure", description: config?.exposure });
+    }
+    return items;
+}
+async function showText(view, title, text) {
+    await view.menu(() => ({
+        title,
+        items: wrapTextWithAnsi(text, Math.max(1, view.columns - 4)).map((label, index) => ({
+            value: String(index),
+            label,
+        })),
+        confirmLabel: "back",
+        cancelLabel: "back",
+    }));
+}
+//# sourceMappingURL=manager.js.map

package/dist/core/extensions/builtin/mcp/service.d.ts

@@ -4,7 +4,7 @@ import type { ServerConnection } from "./connection.ts";
 import type { McpServerExposureStatus } from "./expose/status.ts";
 import { McpOutputArtifacts } from "./guard/output-guard.ts";
 import type { McpResourceServer } from "./resources.ts";
-import type { McpDisposeReason, McpServerSnapshot, McpServiceSnapshot, McpSessionContext, McpSessionOptions, McpWireStatusSnapshot } from "./service-types.ts";
+import type { McpDisposeReason, McpServerSnapshot, McpServiceSnapshot, McpSessionContext, McpSessionOptions, McpWireAuthStatus, McpWireStatusSnapshot } from "./service-types.ts";
 import type { SkillServerRegistration } from "./skills.ts";
 import { type McpStartupRaceResult } from "./startup-race.ts";
 type McpElicitationUi = Pick<ExtensionUIContext, "input" | "select" | "confirm">;
@@ -97,6 +97,8 @@ export declare class McpService {
         env?: Record<string, string | undefined>;
         callbackUrl?: string;
     } | undefined;
+    /** Live auth status without fetching catalogs or exposing credentials. */
+    getServerAuthStatus(name: string): McpWireAuthStatus;
     getCachedInstructions(name: string): string | undefined;
     /** Resolved `settings.nativeToolSearch` (auto | true | false | undefined).
      * Drives the native provider tool-search adapter gate. */

package/dist/core/extensions/builtin/mcp/service.js

@@ -688,6 +688,10 @@ export class McpService {
             callbackUrl: this.#config?.settings.oauthCallbackUrl,
         };
     }
+    /** Live auth status without fetching catalogs or exposing credentials. */
+    getServerAuthStatus(name) {
+        return wireAuthStatus(this.#entryForName(name), this.#config?.servers[name]);
+    }
     getCachedInstructions(name) {
         return this.#entryForName(name)?.cachedCatalog?.instructions;
     }

package/dist/core/extensions/builtin/rules/rules/finder.js

@@ -1,6 +1,6 @@
 import { existsSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, posix, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, posix, relative, resolve } from "node:path";
 import { GLOBAL_DISTANCE, PROJECT_RULE_SUBDIRS, PROJECT_SINGLE_FILES, USER_HOME_RULE_SUBDIRS, USER_HOME_SINGLE_FILES, } from "./constants.js";
 import { UnsupportedRuleSourceError } from "./errors.js";
 import { scanRuleFiles } from "./scanner.js";
@@ -151,7 +151,9 @@ function getWalkDirectories(projectRoot, targetFile) {
     let distance = 0;
     while (true) {
         walkDirectories.push({ directory: currentDirectory, distance });
-        if (currentDirectory === projectRoot) {
+        // Windows drive letters are case-insensitive, so an exact string compare misses
+        // "c:\proj" against a "C:\proj" root and walks past it; relative() folds the case.
+        if (relative(projectRoot, currentDirectory) === "") {
             break;
         }
         const parentDirectory = dirname(currentDirectory);
@@ -165,7 +167,10 @@ function getWalkDirectories(projectRoot, targetFile) {
 }
 function isSameOrChildPath(childPath, parentPath) {
     const childRelativePath = relative(parentPath, childPath);
-    return childRelativePath === "" || (!childRelativePath.startsWith("..") && !childRelativePath.startsWith("/"));
+    // Cross-drive / UNC: relative() between two Windows roots returns an absolute
+    // path (e.g. "D:\other"), which starts with neither ".." nor "/", so a
+    // startsWith("/") test would accept a target outside the project root.
+    return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
 }
 function readSingleFileInfo(filePath) {
     if (!existsSync(filePath)) {

package/dist/core/extensions/builtin/websearch/websearch/config.js

@@ -28,6 +28,7 @@ const PROVIDERS = [
     "google-html",
     "exa-mcp",
     "searxng",
+    "keenable",
 ];
 /** Engines that need no key or account; a block on any of them puts it on a per-session cooldown. */
 export const KEYLESS_PROVIDERS = new Set([
@@ -38,6 +39,7 @@ export const KEYLESS_PROVIDERS = new Set([
     "google-html",
     "exa-mcp",
     "searxng",
+    "keenable",
 ]);
 // These entries may omit apiKey: the search then uses the matching senpi login.
 const SESSION_LOGIN_PROVIDERS = ["chatgpt-subscription", "google"];

package/dist/core/extensions/builtin/websearch/websearch/provider-endpoints.js

@@ -22,6 +22,7 @@ const DEFAULT_PROVIDER_URLS = {
     ecosia: "https://www.ecosia.org/search",
     "google-html": "https://www.google.com/search",
     "exa-mcp": "https://mcp.exa.ai/mcp",
+    keenable: "https://api.keenable.ai/v1/search",
 };
 /** SearXNG is self-hosted, so it has no default endpoint; config validation requires its `baseUrl`. */
 export function defaultProviderUrl(provider) {

package/dist/core/extensions/builtin/websearch/websearch/providers/keenable.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderModule } from "./shared.ts";
+export declare const keenableProvider: ProviderModule;
+//# sourceMappingURL=keenable.d.ts.map

package/dist/core/extensions/builtin/websearch/websearch/providers/keenable.js

@@ -0,0 +1,55 @@
+import { APP_NAME } from "../../../../../../config.js";
+import { providerUrl } from "../provider-endpoints.js";
+import { appendDomainFilters, clamp, collect, contentHeaders, getArray, getObject, getString, result, } from "./shared.js";
+/** Keyless twin of the default endpoint; identified by `X-Keenable-Title` instead of a key. */
+const PUBLIC_SEARCH_URL = "https://api.keenable.ai/v1/search/public";
+/** Accepts only absolute http(s) URLs; control characters would let text merge into the URL on parse. */
+function httpUrl(value) {
+    if (!value || value.length > 2048 || /[\t\n\r]/.test(value))
+        return undefined;
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const keenableProvider = {
+    buildRequest({ config, request, maxResults, allowedDomains, blockedDomains }) {
+        // A lone allowed domain maps to the native host-only `site` field; anything else
+        // (multiple domains, exclusions) stays as `site:`/`-site:` terms in the query.
+        const site = allowedDomains?.length === 1 ? allowedDomains[0] : undefined;
+        const body = {
+            query: appendDomainFilters(request.query, site ? undefined : allowedDomains, blockedDomains),
+            max_results: clamp(maxResults, 1, 50),
+        };
+        if (site)
+            body.site = site;
+        const keyed = typeof config.apiKey === "string" && config.apiKey.length > 0;
+        return {
+            url: keyed || config.baseUrl ? providerUrl(config) : PUBLIC_SEARCH_URL,
+            init: {
+                method: "POST",
+                headers: contentHeaders(keyed ? { "X-API-Key": config.apiKey ?? "" } : { "X-Keenable-Title": APP_NAME }),
+            },
+            body,
+        };
+    },
+    normalizeResponse(data) {
+        return collect(getArray(data.results).map((raw) => {
+            const item = getObject(raw);
+            const url = httpUrl(getString(item?.url));
+            if (!item || !url)
+                return null;
+            const normalized = result(getString(item.title) ?? url, url, getString(item.snippet) ?? getString(item.description));
+            if (normalized) {
+                const publishedAt = getString(item.published_at);
+                if (publishedAt)
+                    normalized.publishedAt = publishedAt;
+            }
+            return normalized;
+        }));
+    },
+};
+//# sourceMappingURL=keenable.js.map

package/dist/core/extensions/builtin/websearch/websearch/providers.js

@@ -11,6 +11,7 @@ import { googleProvider } from "./providers/google.js";
 import { googleCseProvider } from "./providers/google-cse.js";
 import { googleHtmlProvider } from "./providers/google-html.js";
 import { kagiProvider } from "./providers/kagi.js";
+import { keenableProvider } from "./providers/keenable.js";
 import { kimiProvider } from "./providers/kimi.js";
 import { mojeekProvider } from "./providers/mojeek.js";
 import { openAiResponsesProvider } from "./providers/openai-responses.js";
@@ -48,6 +49,7 @@ const PROVIDER_MODULES = {
     "google-html": googleHtmlProvider,
     "exa-mcp": exaMcpProvider,
     searxng: searxngProvider,
+    keenable: keenableProvider,
 };
 function buildContext(config, request) {
     const { allowedDomains, blockedDomains } = resolveDomainFilters(config, request);

package/dist/core/extensions/builtin/websearch/websearch/types.d.ts

@@ -1,4 +1,4 @@
-export type SearchProvider = "exa" | "tavily" | "serpdive" | "brave" | "duckduckgo-html" | "deepseek" | "serper" | "google-cse" | "z-ai" | "openai" | "codex" | "chatgpt-subscription" | "google" | "anthropic" | "perplexity" | "xai" | "kimi" | "kagi" | "startpage" | "mojeek" | "ecosia" | "google-html" | "exa-mcp" | "searxng";
+export type SearchProvider = "exa" | "tavily" | "serpdive" | "brave" | "duckduckgo-html" | "deepseek" | "serper" | "google-cse" | "z-ai" | "openai" | "codex" | "chatgpt-subscription" | "google" | "anthropic" | "perplexity" | "xai" | "kimi" | "kagi" | "startpage" | "mojeek" | "ecosia" | "google-html" | "exa-mcp" | "searxng" | "keenable";
 /** Why a keyless engine refused a search; each reason puts the engine on a cooldown. */
 export type SearchBlockReason = "challenge" | "rate_limited" | "forbidden" | "network";
 export type SearchContextSize = "low" | "medium" | "high";

package/dist/core/model-config-schema.d.ts

@@ -454,6 +454,7 @@ declare const ProviderConfigSchema: Type.TObject<{
     authHeader: Type.TOptional<Type.TBoolean>;
     whitelist: Type.TOptional<Type.TArray<Type.TString>>;
     blacklist: Type.TOptional<Type.TArray<Type.TString>>;
+    hideFreeModels: Type.TOptional<Type.TBoolean>;
     models: Type.TOptional<Type.TArray<Type.TObject<{
         id: Type.TString;
         name: Type.TOptional<Type.TString>;
@@ -900,6 +901,7 @@ declare const ModelsConfigSchema: Type.TObject<{
         authHeader: Type.TOptional<Type.TBoolean>;
         whitelist: Type.TOptional<Type.TArray<Type.TString>>;
         blacklist: Type.TOptional<Type.TArray<Type.TString>>;
+        hideFreeModels: Type.TOptional<Type.TBoolean>;
         models: Type.TOptional<Type.TArray<Type.TObject<{
             id: Type.TString;
             name: Type.TOptional<Type.TString>;
@@ -1347,6 +1349,7 @@ export declare const validateModelsConfig: import("typebox/compile").Validator<{
         authHeader: Type.TOptional<Type.TBoolean>;
         whitelist: Type.TOptional<Type.TArray<Type.TString>>;
         blacklist: Type.TOptional<Type.TArray<Type.TString>>;
+        hideFreeModels: Type.TOptional<Type.TBoolean>;
         models: Type.TOptional<Type.TArray<Type.TObject<{
             id: Type.TString;
             name: Type.TOptional<Type.TString>;
@@ -1793,6 +1796,7 @@ export declare const validateModelsConfig: import("typebox/compile").Validator<{
         authHeader?: boolean | undefined;
         whitelist?: string[] | undefined;
         blacklist?: string[] | undefined;
+        hideFreeModels?: boolean | undefined;
         models?: {
             id: string;
             name?: string | undefined;
@@ -2239,6 +2243,7 @@ export declare const validateModelsConfig: import("typebox/compile").Validator<{
         authHeader?: boolean | undefined;
         whitelist?: string[] | undefined;
         blacklist?: string[] | undefined;
+        hideFreeModels?: boolean | undefined;
         models?: {
             id: string;
             name?: string | undefined;

package/dist/core/model-config-schema.js

@@ -232,6 +232,7 @@ const ProviderConfigSchema = Type.Object({
     authHeader: Type.Optional(Type.Boolean()),
     whitelist: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
     blacklist: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    hideFreeModels: Type.Optional(Type.Boolean()),
     models: Type.Optional(Type.Array(ModelDefinitionSchema)),
     modelOverrides: Type.Optional(Type.Record(Type.String(), ModelOverrideSchema)),
     credentials: Type.Optional(CredentialPolicySchema),

package/dist/core/provider-composer.js

@@ -165,6 +165,7 @@ function applyModelsJson(providerId, baseModels, config, extension) {
         !hasOverrides &&
         !config.whitelist &&
         !config.blacklist &&
+        config.hideFreeModels === undefined &&
         !config.apiKey &&
         config.authHeader === undefined) {
         throw new Error(`Provider ${providerId}: must specify "baseUrl", "headers", "extraBody", "compat", "modelOverrides", or "models".`);
@@ -197,7 +198,10 @@ function applyModelsJson(providerId, baseModels, config, extension) {
     }
     const whitelist = config.whitelist ? new Set(config.whitelist) : undefined;
     const blacklist = config.blacklist ? new Set(config.blacklist) : undefined;
-    return models.filter((model) => (whitelist === undefined || whitelist.has(model.id)) && (blacklist === undefined || !blacklist.has(model.id)));
+    const hideFree = config.hideFreeModels === true;
+    return models.filter((model) => (whitelist === undefined || whitelist.has(model.id)) &&
+        (blacklist === undefined || !blacklist.has(model.id)) &&
+        !(hideFree && model.cost.input === 0 && model.cost.output === 0));
 }
 function applyExtension(providerId, models, config, customModelIds) {
     if (!config)

package/dist/core/provider-timeout-retry.d.ts

@@ -15,7 +15,13 @@ export interface BoundedRetryContinuation {
     getActiveSignal(): AbortSignal | undefined;
     abortActive(): void;
     timeoutMs: number | undefined;
+    /**
+     * Subscribes to the retried request's first stream event (its assistant `message_start`); returns
+     * the unsubscribe. Once the request streams, the provider's own idle and stall guards govern the rest
+     * of the run, so the watchdog is cleared (senpi#2804).
+     */
+    onStreamStarted?(listener: () => void): () => void;
 }
 export declare function createProviderTimeoutRetryPlan({ message, streamRetryTimeoutMs, timeoutMs, streamStartTimeoutMs, }: ProviderTimeoutRetryPlanInput): ProviderTimeoutRetryPlan;
-export declare function runBoundedRetryContinuation({ continueRun, getActiveSignal, abortActive, timeoutMs, }: BoundedRetryContinuation): Promise<void>;
+export declare function runBoundedRetryContinuation({ continueRun, getActiveSignal, abortActive, timeoutMs, onStreamStarted, }: BoundedRetryContinuation): Promise<void>;
 //# sourceMappingURL=provider-timeout-retry.d.ts.map

package/dist/core/provider-timeout-retry.js

@@ -42,23 +42,34 @@ export function createProviderTimeoutRetryPlan({ message, streamRetryTimeoutMs,
         watchdogTimeoutMs: reconcileWatchdogTimeoutMs(streamRetryTimeoutMs, streamStartTimeoutMs),
     };
 }
-export async function runBoundedRetryContinuation({ continueRun, getActiveSignal, abortActive, timeoutMs, }) {
-    const continuation = continueRun();
-    const ownedSignal = getActiveSignal();
-    if (timeoutMs === undefined || ownedSignal === undefined) {
-        await continuation;
-        return;
-    }
-    const timer = setTimeout(() => {
-        if (getActiveSignal() === ownedSignal) {
-            abortActive();
-        }
-    }, timeoutMs);
+export async function runBoundedRetryContinuation({ continueRun, getActiveSignal, abortActive, timeoutMs, onStreamStarted, }) {
+    // The watchdog bounds only the wait for the retried request to start streaming: a retry that streams
+    // and then works for a long time (a long answer, tool calls, further turns) is not a wedged retry.
+    let streamStarted = false;
+    let timer;
+    const unsubscribe = timeoutMs === undefined
+        ? undefined
+        : onStreamStarted?.(() => {
+            streamStarted = true;
+            clearTimeout(timer);
+        });
     try {
+        const continuation = continueRun();
+        const ownedSignal = getActiveSignal();
+        if (timeoutMs === undefined || ownedSignal === undefined || streamStarted) {
+            await continuation;
+            return;
+        }
+        timer = setTimeout(() => {
+            if (!streamStarted && getActiveSignal() === ownedSignal) {
+                abortActive();
+            }
+        }, timeoutMs);
         await continuation;
     }
     finally {
         clearTimeout(timer);
+        unsubscribe?.();
     }
 }
 //# sourceMappingURL=provider-timeout-retry.js.map

package/dist/core/reload-veto.d.ts

@@ -1,4 +1,4 @@
 import type { ExtensionRunner } from "./extensions/runner.ts";
 import type { ReloadVetoDecision } from "./extensions/types.ts";
-export declare function checkSessionReloadVeto(runner: Pick<ExtensionRunner, "hasHandlers" | "emit">, isPromptStartPending: () => boolean): Promise<ReloadVetoDecision>;
+export declare function checkSessionReloadVeto(runner: Pick<ExtensionRunner, "hasHandlers" | "emit">, isPromptStartPending: () => boolean, isSessionStartDispatching?: () => boolean): Promise<ReloadVetoDecision>;
 //# sourceMappingURL=reload-veto.d.ts.map

package/dist/core/reload-veto.js

@@ -1,13 +1,19 @@
-export async function checkSessionReloadVeto(runner, isPromptStartPending) {
+export async function checkSessionReloadVeto(runner, isPromptStartPending, isSessionStartDispatching = () => false) {
     if (isPromptStartPending()) {
         return { cancelled: true, reason: "A prompt is being admitted." };
     }
+    if (isSessionStartDispatching()) {
+        return { cancelled: true, reason: "A session is starting." };
+    }
     const result = runner.hasHandlers("session_before_reload")
         ? await runner.emit({ type: "session_before_reload" })
         : undefined;
     if (isPromptStartPending()) {
         return { cancelled: true, reason: "A prompt is being admitted." };
     }
+    if (isSessionStartDispatching()) {
+        return { cancelled: true, reason: "A session is starting." };
+    }
     if (result?.cancel !== true)
         return { cancelled: false };
     return result.reason === undefined ? { cancelled: true } : { cancelled: true, reason: result.reason };

package/dist/core/retry-fallback/expansion.js

@@ -1,11 +1,17 @@
 import { isValidThinkingLevel } from "../../cli/args.js";
 /**
- * Providers that never receive a bare selector. OpenRouter re-publishes other
+ * Providers that never receive a bare selector. Gateways re-publish other
  * vendors' catalogs under namespaced ids, so family expansion would silently
  * route a shipped default through a third-party reseller the user never chose.
- * An explicit `openrouter/...` selector the user wrote is unaffected.
+ * An explicit provider-qualified selector the user wrote is unaffected.
  */
-const BARE_EXPANSION_DENYLIST = new Set(["cursor", "openrouter", "openrouter-images"]);
+const BARE_EXPANSION_DENYLIST = new Set([
+    "cursor",
+    "openrouter",
+    "openrouter-images",
+    "opengateway",
+    "vercel-ai-gateway",
+]);
 /**
  * Deterministic tie-break inside one auth tier. Earlier wins. Providers absent
  * from the table sort after every listed one, alphabetically.

package/dist/core/sdk.js

@@ -20,7 +20,7 @@ import { mergeProviderAttributionHeaders } from "./provider-attribution.js";
 import { DefaultResourceLoader } from "./resource-loader.js";
 import { getDefaultSessionDir, SessionManager } from "./session-manager.js";
 import { DEFAULT_TOOL_NAMES, SettingsManager } from "./settings-manager.js";
-import { getSupportedThinkingLevels } from "./thinking-levels.js";
+import { clampThinkingSelection, getSupportedThinkingLevels } from "./thinking-levels.js";
 import { time } from "./timings.js";
 import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createPowerShellTool, createReadOnlyTools, createReadTool, createWriteTool, withFileMutationQueue, } from "./tools/index.js";
 import { serviceTierForProvider } from "./ultrafast-lanes.js";
@@ -201,25 +201,29 @@ export async function createAgentSession(options = {}) {
     if (thinkingLevel === undefined && model?.defaultThinkingLevel !== undefined) {
         thinkingLevel = model.defaultThinkingLevel;
     }
+    let thinkingFromGlobalDefault = false;
     if (thinkingLevel === undefined) {
         const configuredDefault = settingsManager.getDefaultThinkingLevel();
         if (configuredDefault !== undefined) {
             thinkingLevel = configuredDefault;
             thinkingSelection = { level: configuredDefault, source: "explicit" };
+            thinkingFromGlobalDefault = true;
         }
         else {
             thinkingLevel = DEFAULT_THINKING_LEVEL;
         }
     }
     // Clamp to model capabilities without inventing provenance for a defaulted level.
+    const requestedThinkingLevel = thinkingLevel;
     if (!model) {
         thinkingLevel = "off";
     }
     else {
         thinkingLevel = clampThinkingLevelToModel(thinkingLevel, model);
     }
-    if (thinkingSelection)
-        thinkingSelection = { ...thinkingSelection, level: thinkingLevel };
+    // senpi#2395: an explicit request the clamp changed keeps the requested level and the reason. The global
+    // default is a default, not a request, so its clamp records no requested level and shows no warning.
+    thinkingSelection = clampThinkingSelection(thinkingSelection, thinkingFromGlobalDefault ? thinkingLevel : requestedThinkingLevel, thinkingLevel, model);
     const configuredDefaultToolNames = settingsManager.getDefaultTools();
     const sessionDefaultToolNames = options.tools === undefined && options.noTools === undefined ? configuredDefaultToolNames : undefined;
     const allowedToolNames = options.tools ?? (options.noTools === "all" ? [] : undefined);

package/dist/core/thinking-levels.d.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { Api, Model } from "@earendil-works/pi-ai";
+import type { Api, Model, ModelThinkingLevel, ThinkingSelection } from "@earendil-works/pi-ai";
 /**
  * Tier detection is owned by `packages/ai`, which already treats an explicit `thinkingLevelMap` as
  * authoritative and infers tiers from the model id only when no map is present. These wrappers keep
@@ -8,6 +8,28 @@ import type { Api, Model } from "@earendil-works/pi-ai";
 export declare function supportsXhigh(model: Model<Api>): boolean;
 export declare function supportsMax(model: Model<Api>): boolean;
 export declare function getSupportedThinkingLevels(model: Model<Api>): ThinkingLevel[];
+/** Why an explicit thinking selection runs at a lower level than the one requested (senpi#2395). */
+export type ThinkingClampReason = "model-not-reasoning" | "level-unsupported";
+/** An explicit selection that also records the requested level when a clamp changed it. */
+export interface ClampedThinkingSelection extends ThinkingSelection {
+    readonly requested?: ModelThinkingLevel;
+    readonly clampReason?: ThinkingClampReason;
+}
+/** One clamp of an explicit request, as shown to the user. */
+export interface ThinkingClampNotice {
+    provider: string;
+    modelId: string;
+    requestedLevel: ModelThinkingLevel;
+    appliedLevel: ModelThinkingLevel;
+    reason: ThinkingClampReason;
+}
+/**
+ * Apply the effective `level` to an explicit selection. When it differs from `requested`, the selection keeps
+ * the requested level and the clamp reason instead of reading as if `level` had been chosen.
+ */
+export declare function clampThinkingSelection(selection: ThinkingSelection | undefined, requested: ModelThinkingLevel, level: ModelThinkingLevel, model: Model<Api> | undefined): ThinkingSelection | undefined;
+export declare function getThinkingClampNotice(selection: ThinkingSelection | undefined, model: Model<Api> | undefined): ThinkingClampNotice | undefined;
+export declare function formatThinkingClampWarning(notice: ThinkingClampNotice): string;
 /** Capability classes used by capability-aware reasoning commands. */
 export type ReasoningCapabilityKind = "none" | "always-on" | "on-off" | "graded";
 export interface ReasoningCapability {