@code-yeongyu/senpi 2026.10.2 → 2026.10.3

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

@@ -1,5 +1,5 @@
 import { getAgentDir } from "../../../../config.js";
-import { getToolSearchService, getToolSearchServiceForExtension, resetToolSearchServiceForTests, } from "../tool-search/service.js";
+import { getToolSearchService, getToolSearchServiceForExtension, resetToolSearchServiceForTests, ToolSearchService, } from "../tool-search/service.js";
 import { resolveAuthMode } from "./auth/context.js";
 import { getValidCachedServer, readMcpCatalogCache } from "./catalog-cache.js";
 import { loadMcpConfig, mergeExtensionMcpServers, visitSpawnableMcpServers } from "./config.js";
@@ -7,6 +7,7 @@ import { collectAllPages } from "./expose/pagination.js";
 import { cleanupMcpOutputArtifacts, McpOutputArtifacts } from "./guard/output-guard.js";
 import { HostMcpRegistry } from "./host-registry.js";
 import { refreshMcpInstructionsForSession } from "./instructions.js";
+import { createMcpLogger } from "./log.js";
 import { reconnectMcpNow } from "./reconnect.js";
 import { createMcpSessionConnection, disposeEntryConnection } from "./service-connection.js";
 import { getMcpServiceExposureStatus } from "./service-exposure.js";
@@ -15,6 +16,7 @@ import { buildMcpServerSnapshot } from "./service-snapshot.js";
 import { refreshMcpToolsOnListChanged, subscribeMcpToolsChanged } from "./service-tools-changed.js";
 import { resolveSkillMcpServer } from "./skill-server.js";
 import { MCP_ATTACH_SETTLE_TIMEOUT_MS, McpDeferredAttach, raceMcpStartupConnect, resolveMcpStartupTimeoutMs, shouldRaceMcpStartup, } from "./startup-race.js";
+import { safeTimer } from "./wrap.js";
 export { registerToolsPreservingActiveSet } from "./active-set.js";
 export class McpService {
     #disposed = false;
@@ -23,7 +25,6 @@ export class McpService {
     #sessionContext = null;
     #sessionStartCount = 0;
     #lastSessionStartReason = null;
-    #toolRefreshGeneration = 0;
     #config = null;
     #authAgentDir;
     #authEnv;
@@ -36,11 +37,15 @@ export class McpService {
     #wireStatusListeners = new Set();
     #wireStatusRefreshQueue = Promise.resolve();
     #refreshActiveSetWhenNoTools = false;
-    #tierBRegistration;
-    #toolSearchService;
+    #bindings = new Map();
+    #pendingAttaches = 0;
+    // Sessions that quit while their own attach was still queued: the attach must not bind them (#2524 review).
+    #releasedSessions = new WeakSet();
+    #deferredDisposeReason;
+    // Releases waiting for the attaches that deferred their dispose: they settle once the last one does.
+    #deferredDisposeWaiters = [];
     #sessionOptions = {};
     #skillServerWarnings = new Set();
-    #pi;
     #attachQueue = Promise.resolve();
     #deferredAttach = new McpDeferredAttach();
     #latestWireStatus = { servers: [] };
@@ -50,12 +55,21 @@ export class McpService {
     #outputArtifacts = new McpOutputArtifacts();
     #registry;
     #shareConnections;
+    #servesManySessions;
+    /** `servesManySessions` marks the process-wide service every classic session attaches to. */
     constructor(options = {}) {
         this.#registry = options.mcpRegistry ?? new HostMcpRegistry();
         this.#shareConnections = options.mcpRegistry !== undefined;
+        this.#servesManySessions = options.servesManySessions === true;
     }
     async attachSession(event, ctx, _pi, options = {}) {
+        // Counted from the moment it queues, so a session's release cannot dispose the service
+        // under an attach that has not bound yet.
+        this.#pendingAttaches += 1;
         const attach = this.#attachQueue.then(async () => {
+            if (this.#disposed) {
+                throw new Error("The MCP service is disposed; attach the session to a live service instead.");
+            }
             this.#sessionContext = ctx;
             this.#skillServerWarnings.clear();
             this.#sessionStartCount += 1;
@@ -73,47 +87,154 @@ export class McpService {
             });
             mergeExtensionMcpServers(config, ctx.getRegisteredMcpServers?.() ?? []);
             this.#config = config;
-            this.#pi = _pi;
-            if (_pi !== undefined) {
-                const activationRuntime = {
-                    getActiveTools: () => _pi.getActiveTools(),
-                    setActiveTools: (names) => _pi.setActiveTools([...names]),
-                };
-                const sessionToolSearch = getToolSearchServiceForExtension(_pi);
-                if (sessionToolSearch !== undefined) {
-                    this.#toolSearchService = sessionToolSearch;
-                    sessionToolSearch.bindActivationRuntime(activationRuntime);
-                }
-                else {
-                    try {
-                        this.#toolSearchService = getToolSearchService();
-                        this.#toolSearchService.bindActivationRuntime(activationRuntime);
-                    }
-                    catch {
-                        this.#toolSearchService = getToolSearchService({ getAllTools: () => [], ...activationRuntime });
-                    }
-                }
-            }
+            const binding = _pi === undefined || this.#releasedSessions.has(_pi) ? undefined : this.#bind(_pi, ctx);
             this.#authAgentDir = sessionOptions.agentDir;
             this.#authEnv = sessionOptions.env;
             this.#sessionOptions = sessionOptions;
-            const toolRefreshGeneration = this.#toolRefreshGeneration + 1;
-            this.#toolRefreshGeneration = toolRefreshGeneration;
-            await this.#syncFromConfig(config, sessionOptions, event.reason !== "reload", _pi, toolRefreshGeneration);
-            if (_pi !== undefined)
-                await this.#registerDirectTools(_pi);
+            await this.#syncFromConfig(config, sessionOptions, event.reason !== "reload", binding);
+            if (binding !== undefined)
+                await this.#registerDirectTools(binding);
             // Replay promotion markers from the (possibly resumed) session history
             // BEFORE the first turn: the request tool snapshot is taken before the
             // per-turn context event fires, so the context-event replay alone lands
             // one turn late. Doing it here puts restored tools on the very first
             // wire payload after a --continue/resume.
-            if (_pi !== undefined)
-                this.#rehydrateFromSessionHistory(ctx);
+            if (binding !== undefined)
+                this.#rehydrateFromSessionHistory(binding);
             if (shouldCaptureWireStatus(ctx))
                 await this.refreshWireStatusSnapshot(ctx.sessionManager?.getSessionId?.());
         });
         this.#attachQueue = attach.then(() => undefined, () => undefined);
-        await attach;
+        try {
+            await attach;
+        }
+        finally {
+            this.#pendingAttaches -= 1;
+            await this.#disposeIfDeferredAndIdle();
+        }
+    }
+    /** A release that found attaches still pending leaves the dispose to the last of them, once no session is bound. */
+    async #disposeIfDeferredAndIdle() {
+        const reason = this.#deferredDisposeReason;
+        if (reason === undefined || this.#pendingAttaches > 0)
+            return;
+        this.#deferredDisposeReason = undefined;
+        // A session that attached meanwhile keeps the service; otherwise the deferred dispose runs now.
+        if (this.#liveBindings().length === 0)
+            await this.dispose(reason);
+        for (const settle of this.#deferredDisposeWaiters.splice(0))
+            settle();
+    }
+    #bind(pi, ctx) {
+        const activationRuntime = {
+            getActiveTools: () => pi.getActiveTools(),
+            setActiveTools: (names) => pi.setActiveTools([...names]),
+        };
+        const previous = this.#bindings.get(pi);
+        // A session-owned service serves exactly one session: a new attach takes over its binding.
+        if (!this.#servesManySessions)
+            this.#bindings.clear();
+        let fallbackToolSearch;
+        let holdsProcessFallback = false;
+        const sessionToolSearch = getToolSearchServiceForExtension(pi);
+        if (sessionToolSearch !== undefined) {
+            sessionToolSearch.bindActivationRuntime(activationRuntime);
+        }
+        else if (this.#liveBindings().some((other) => other.pi !== pi && other.holdsProcessFallback)) {
+            // The process-wide fallback already serves another live session; rebinding it would move that
+            // session's activation runtime and catalog hook here, so this session gets its own (#2514).
+            fallbackToolSearch = new ToolSearchService({ getAllTools: () => [], ...activationRuntime });
+        }
+        else {
+            holdsProcessFallback = true;
+            try {
+                fallbackToolSearch = getToolSearchService();
+                fallbackToolSearch.bindActivationRuntime(activationRuntime);
+            }
+            catch {
+                fallbackToolSearch = getToolSearchService({ getAllTools: () => [], ...activationRuntime });
+            }
+        }
+        const binding = {
+            pi,
+            fallbackToolSearch,
+            holdsProcessFallback,
+            context: ctx,
+            registeredIdentities: previous?.registeredIdentities ?? new Map(),
+            registration: previous?.registration,
+        };
+        // Re-inserting keeps the most recent attach last, which is what a caller naming no session gets.
+        this.#bindings.delete(pi);
+        this.#bindings.set(pi, binding);
+        return binding;
+    }
+    #toolSearchFor(binding) {
+        return getToolSearchServiceForExtension(binding.pi) ?? binding.fallbackToolSearch;
+    }
+    #liveBindings() {
+        for (const [pi, binding] of this.#bindings) {
+            // A disposed session retires its own tool-search service; its binding goes with it.
+            if (getToolSearchServiceForExtension(binding.pi)?.isDisposed === true)
+                this.#bindings.delete(pi);
+        }
+        return [...this.#bindings.values()];
+    }
+    /** The binding of the session that owns `pi`; without one, the most recently attached live session. */
+    #bindingFor(pi) {
+        return pi === undefined ? this.#liveBindings().at(-1) : this.#bindings.get(pi);
+    }
+    /**
+     * Release the binding of the session that owns `pi` (#2514). The shared connections keep
+     * serving every other live session; once none is left, `disposeReason` disposes the service
+     * the way that last session's own exit would.
+     */
+    async releaseSession(pi, disposeReason) {
+        const released = this.#bindings.get(pi);
+        this.#bindings.delete(pi);
+        if (disposeReason !== undefined)
+            this.#releasedSessions.add(pi);
+        const live = this.#liveBindings();
+        const latest = live.at(-1);
+        if (latest !== undefined) {
+            if (released !== undefined && this.#sessionContext === released.context)
+                this.#sessionContext = latest.context;
+            return;
+        }
+        // A session whose attach is still queued has not bound yet but will use this service.
+        if (disposeReason === undefined)
+            return;
+        if (this.#pendingAttaches === 0) {
+            await this.dispose(disposeReason);
+            return;
+        }
+        // The release settles only once the pending attaches have, so a caller that awaits it
+        // (session shutdown, builtin removal) sees the service disposed, not a dispose scheduled later.
+        this.#deferredDisposeReason = disposeReason;
+        const settled = new Promise((settle) => this.#deferredDisposeWaiters.push(() => settle("settled")));
+        const deadlineMs = resolveMcpDeferredDisposeTimeoutMs();
+        let timer;
+        const outcome = await Promise.race([
+            settled,
+            new Promise((expire) => {
+                timer = safeTimer("deferred-dispose", deadlineMs, () => expire("timeout"), {
+                    logger: createMcpLogger("service"),
+                });
+            }),
+        ]);
+        clearTimeout(timer);
+        if (outcome === "settled" || this.#deferredDisposeReason === undefined)
+            return;
+        // A hung attach must not hold a reload or a quit forever: dispose anyway once the
+        // deadline passes, unless a session bound in the meantime, and say so.
+        this.#deferredDisposeReason = undefined;
+        createMcpLogger("service").warn("MCP attach still pending at the dispose deadline; disposing anyway", {
+            timeoutMs: deadlineMs,
+            reason: disposeReason,
+        });
+        if (this.#liveBindings().length === 0)
+            await this.dispose(disposeReason);
+        for (const settle of this.#deferredDisposeWaiters.splice(0))
+            settle();
     }
     /**
      * Register skill-declared MCP servers (todo 37). Skill servers are forced
@@ -123,10 +244,10 @@ export class McpService {
      * returns a warning (system wins). `${VAR}` expansion follows the declaring
      * skill's trust (skill-server.ts); each trust warning is returned once per session.
      */
-    async attachSkillMcpServers(declared) {
+    async attachSkillMcpServers(declared, pi) {
         const config = this.#config;
-        const pi = this.#pi;
-        if (config === null || pi === undefined)
+        const binding = this.#bindingFor(pi);
+        if (config === null || binding === undefined)
             return [];
         const warnings = [];
         const projectTrusted = this.#sessionOptions.projectTrusted ?? this.#sessionContext?.isProjectTrusted() ?? false;
@@ -154,10 +275,8 @@ export class McpService {
             added += 1;
         }
         if (added > 0) {
-            const toolRefreshGeneration = this.#toolRefreshGeneration + 1;
-            this.#toolRefreshGeneration = toolRefreshGeneration;
-            await this.#syncFromConfig(config, this.#sessionOptions, false, pi, toolRefreshGeneration);
-            await this.#registerDirectTools(pi);
+            await this.#syncFromConfig(config, this.#sessionOptions, false, binding);
+            await this.#registerDirectTools(binding);
             if (this.#sessionContext !== null && shouldCaptureWireStatus(this.#sessionContext)) {
                 await this.refreshWireStatusSnapshot(this.#sessionContext.sessionManager?.getSessionId?.());
             }
@@ -166,16 +285,16 @@ export class McpService {
     }
     /** Registered searchable catalog (mapped name + server-side tool name),
      * used by the skills loader to compute activation targets. */
-    getTierBSearchable() {
-        return this.#tierBRegistration?.searchable ?? [];
+    getTierBSearchable(pi) {
+        return this.#bindingFor(pi)?.registration?.searchable ?? [];
     }
     /** Connected servers that list prompts (todo 40), for slash registration. */
-    getMcpPromptServers() {
-        return this.#tierBRegistration?.promptServers ?? [];
+    getMcpPromptServers(pi) {
+        return this.#bindingFor(pi)?.registration?.promptServers ?? [];
     }
     /** Connected servers that list resources (todo 39), for mention expansion. */
-    getMcpResourceServers() {
-        return this.#tierBRegistration?.resourceServers ?? [];
+    getMcpResourceServers(pi) {
+        return this.#bindingFor(pi)?.registration?.resourceServers ?? [];
     }
     /** Subscribe to completed catalog registrations. Consumers must inspect the
      * resulting snapshot because tool, resource, and prompt catalogs can become
@@ -208,14 +327,14 @@ export class McpService {
     }
     /** Reveal skill-owned tools (todo 37): activation is effective the next
      * turn, exactly like an tool_search promotion. Unknown names are ignored. */
-    activateSkillMcpTools(names) {
-        this.#tierBRegistration?.activate(names);
+    activateSkillMcpTools(names, pi) {
+        this.#bindingFor(pi)?.registration?.activate(names);
     }
-    #rehydrateFromSessionHistory(ctx) {
-        const entries = ctx.sessionManager?.getEntries() ?? [];
+    #rehydrateFromSessionHistory(binding) {
+        const entries = binding.context.sessionManager?.getEntries() ?? [];
         if (entries.length === 0)
             return;
-        this.rehydrateActiveToolsFromHistory(entries);
+        this.#toolSearchFor(binding)?.maybeRehydrateFromHistory(entries);
     }
     async handleSessionShutdown(event) {
         if (shouldDisposeMcpService(event.reason))
@@ -227,6 +346,7 @@ export class McpService {
         this.#disposed = true;
         this.#disposeCount += 1;
         this.#lastDisposeReason = reason;
+        this.#bindings.clear();
         this.#sessionContext = null;
         this.#config = null;
         this.#elicitationUiProvider = undefined;
@@ -306,7 +426,7 @@ export class McpService {
             ? this.#latestWireStatus
             : (this.#wireStatusBySession.get(sessionId) ?? { servers: [] });
     }
-    async #syncFromConfig(config, options, useCache, pi, toolRefreshGeneration) {
+    async #syncFromConfig(config, options, useCache, binding) {
         const cache = await readMcpCatalogCache(options.agentDir);
         const hadConnectionsBeforeSync = this.#connections.size > 0;
         this.#refreshActiveSetWhenNoTools = Object.keys(config.servers).length > 0 || hadConnectionsBeforeSync;
@@ -360,21 +480,36 @@ export class McpService {
             if (shouldRaceMcpStartup(server.config.lifecycle) || cachedCatalog === undefined) {
                 connects.push(raceMcpStartupConnect({
                     entry,
-                    pi,
-                    registerDirectTools: async (targetPi) => {
-                        await this.#registerDirectTools(targetPi);
-                        // A raced attach ran its history replay before this catalog
-                        // existed; replay now so restored tools still land on the
-                        // first turn's payload (idempotent: already-active names skip).
-                        if (this.#sessionContext !== null)
-                            this.#rehydrateFromSessionHistory(this.#sessionContext);
+                    pi: binding?.pi,
+                    registerDirectTools: async () => {
+                        // The catalog is shared, so it lands in every live session, not only the one that
+                        // started the connect (#2514). One session's failure must not starve the others:
+                        // each registers on its own, and the failures are reported together afterwards.
+                        const failures = [];
+                        for (const live of this.#liveBindings()) {
+                            try {
+                                await this.#registerDirectTools(live);
+                                // A raced attach ran its history replay before this catalog
+                                // existed; replay now so restored tools still land on the
+                                // first turn's payload (idempotent: already-active names skip).
+                                this.#rehydrateFromSessionHistory(live);
+                            }
+                            catch (error) {
+                                failures.push(error);
+                            }
+                        }
                         // The session instructions block was likewise captured at attach
                         // time, before this server connected; rebuild it so the first
                         // turn carries this server's instructions after a raced connect.
                         refreshMcpInstructionsForSession(this);
+                        if (failures.length > 0) {
+                            throw new AggregateError(failures, `MCP ${name} catalog failed to register in ${failures.length} session(s)`);
+                        }
                     },
                     serverConfig: server.config,
-                    shouldRefreshTools: () => !this.#disposed && this.#toolRefreshGeneration === toolRefreshGeneration,
+                    // A later attach does not supersede this catalog: it registers in every live session. Skip it only
+                    // once the service is gone or this connection was replaced (#2524 review).
+                    shouldRefreshTools: () => !this.#disposed && this.#entryForName(name) === entry,
                     deadlineMs: resolveMcpStartupTimeoutMs(server.config.startupTimeoutMs),
                     onDeferred: (settled) => this.#deferredAttach.track(settled),
                 }));
@@ -396,36 +531,44 @@ export class McpService {
         entry.disposeWireStatus = unsubscribeState;
     }
     async #handleServerToolsChanged(entry, connectOnly) {
-        const pi = this.#pi;
         const config = this.#config;
-        if (pi === undefined || config === null)
+        if (config === null || this.#liveBindings().length === 0)
             return;
-        await refreshMcpToolsOnListChanged(entry, pi, config, (target) => this.#registerDirectTools(target), connectOnly);
-    }
-    async #registerDirectTools(pi) {
+        // Resolved when the refresh registers, not when it starts: a session that attaches while the
+        // refresh is still listing tools must receive the refreshed catalog too.
+        const targets = () => this.#liveBindings().map((binding) => ({
+            pi: binding.pi,
+            registeredIdentity: () => binding.registeredIdentities.get(entry.key),
+            register: () => this.#registerDirectTools(binding),
+        }));
+        await refreshMcpToolsOnListChanged(entry, targets, config, connectOnly);
+    }
+    async #registerDirectTools(binding) {
         const config = this.#config;
         if (config === null)
             return;
-        const toolSearchService = this.#toolSearchService;
+        const toolSearchService = this.#toolSearchFor(binding);
         if (toolSearchService === undefined)
             return;
-        this.#tierBRegistration = await registerMcpServiceDirectTools(pi, config, this.#connections.values(), toolSearchService, {
+        binding.registration = await registerMcpServiceDirectTools(binding.pi, config, this.#connections.values(), toolSearchService, {
             refreshActiveSetWhenEmpty: this.#refreshActiveSetWhenNoTools,
+            onRegistered: (entry, identity) => binding.registeredIdentities.set(entry.key, identity),
         });
-        const ctx = this.#sessionContext;
-        if (ctx?.mode === "rpc") {
+        const ctx = binding.context;
+        if (ctx.mode === "rpc") {
             await this.refreshWireStatusSnapshot(ctx.sessionManager?.getSessionId?.());
         }
         for (const listener of this.#registrationListeners)
             listener();
     }
     /** Route compatibility callers through the shared ownership-aware scanner. */
-    rehydrateActiveToolsFromHistory(messages) {
-        return this.#toolSearchService?.maybeRehydrateFromHistory(messages) ?? [];
+    rehydrateActiveToolsFromHistory(messages, pi) {
+        return this.maybeRehydrateFromHistory(messages, pi);
     }
     /** Shared service memoization keeps this scan once-per-catalog-generation. */
-    maybeRehydrateFromHistory(messages) {
-        return this.#toolSearchService?.maybeRehydrateFromHistory(messages) ?? [];
+    maybeRehydrateFromHistory(messages, pi) {
+        const binding = this.#bindingFor(pi);
+        return ((binding === undefined ? undefined : this.#toolSearchFor(binding)?.maybeRehydrateFromHistory(messages)) ?? []);
     }
     #serverSnapshot(name) {
         const connection = this.getConnection(name);
@@ -640,7 +783,7 @@ function assertNever(value) {
 let service = null;
 export function getMcpService() {
     if (service === null || service.isDisposed()) {
-        service = new McpService();
+        service = new McpService({ servesManySessions: true });
     }
     return service;
 }
@@ -651,4 +794,16 @@ export function resetMcpServiceForTests() {
     service = null;
     resetToolSearchServiceForTests();
 }
+export const MCP_DEFERRED_DISPOSE_TIMEOUT_ENV = "SENPI_MCP_DEFERRED_DISPOSE_TIMEOUT_MS";
+const MCP_DEFERRED_DISPOSE_TIMEOUT_MS = 15_000;
+/** How long a release waits for pending attaches before it disposes anyway. */
+function resolveMcpDeferredDisposeTimeoutMs() {
+    const raw = process.env[MCP_DEFERRED_DISPOSE_TIMEOUT_ENV]?.trim();
+    if (raw !== undefined && raw.length > 0) {
+        const value = Number(raw);
+        if (Number.isFinite(value) && value >= 0)
+            return value;
+    }
+    return MCP_DEFERRED_DISPOSE_TIMEOUT_MS;
+}
 //# sourceMappingURL=service.js.map

package/dist/core/settings-manager.d.ts

@@ -97,6 +97,7 @@ export interface Settings {
     themes?: string[];
     hooks?: string[];
     enableSkillCommands?: boolean;
+    maxSkillExpansionsPerPrompt?: number;
     terminal?: TerminalSettings;
     promptCache?: PromptCacheSettings;
     images?: ImageSettings;
@@ -483,6 +484,7 @@ export declare class SettingsManager {
     setThemePaths(paths: string[]): void;
     setProjectThemePaths(paths: string[]): void;
     getEnableSkillCommands(): boolean;
+    getMaxSkillExpansionsPerPrompt(): number;
     setEnableSkillCommands(enabled: boolean): void;
     getThinkingBudgets(): ThinkingBudgetsSettings | undefined;
     getTerminalCapabilityOverrides(): Partial<TerminalCapabilities>;

package/dist/core/settings-manager.js

@@ -21,6 +21,7 @@ import { parseSettingsJson } from "./settings-json.js";
 import { withoutOverride } from "./settings-overrides.js";
 import { removeRetiredSettingsKeys, writeRawScopedSettings } from "./settings-retired-keys.js";
 import { ASK_USER_DEFAULT_TIMEOUT_MINUTES, ASK_USER_MAX_TIMEOUT_MINUTES, ASK_USER_MIN_TIMEOUT_MINUTES, } from "./settings-shapes.js";
+import { MAX_SKILL_EXPANSIONS_PER_PROMPT } from "./skill-invocation.js";
 import { isTerminalMouseMode, } from "./terminal-settings.js";
 export const DEFAULT_STREAM_START_TIMEOUT_MS = 300_000;
 export const DEFAULT_PROVIDER_STREAM_RETRY_TIMEOUT_MS = 30_000;
@@ -1605,6 +1606,12 @@ export class SettingsManager {
     getEnableSkillCommands() {
         return this.settings.enableSkillCommands ?? true;
     }
+    getMaxSkillExpansionsPerPrompt() {
+        const value = this.settings.maxSkillExpansionsPerPrompt;
+        return typeof value === "number" && Number.isInteger(value) && value > 0
+            ? value
+            : MAX_SKILL_EXPANSIONS_PER_PROMPT;
+    }
     setEnableSkillCommands(enabled) {
         this.globalSettings.enableSkillCommands = enabled;
         this.markModified("enableSkillCommands");

package/dist/core/skill-invocation.d.ts

@@ -44,7 +44,15 @@ export interface ParseSkillInvocationOptions {
  * `$name` is executable when it names a loaded skill.
  */
 export declare function parseSkillInvocationTokens(text: string, options?: ParseSkillInvocationOptions): SkillInvocationToken[];
-export declare function removeSkillInvocationTokens(text: string, tokens: readonly SkillInvocationToken[]): string;
-/** Caps explicit skill expansion so one prompt cannot consume unbounded context. */
+/**
+ * Remove expanded invocation tokens, leaving `[skill: name]` where an inline one stood. Tokens in
+ * `unloaded` were not expanded (per-prompt cap) and leave `[skill not loaded: name]` in either position,
+ * so the model is told it does not have that skill instead of seeing a bare command.
+ */
+export declare function removeSkillInvocationTokens(text: string, tokens: readonly SkillInvocationToken[], unloaded?: ReadonlySet<SkillInvocationToken>): string;
+/**
+ * Default cap on explicit skill expansion so one prompt cannot consume unbounded context.
+ * Users who compose more skills raise it with the `maxSkillExpansionsPerPrompt` setting.
+ */
 export declare const MAX_SKILL_EXPANSIONS_PER_PROMPT = 5;
 //# sourceMappingURL=skill-invocation.d.ts.map

package/dist/core/skill-invocation.js

@@ -121,12 +121,19 @@ function stripLeadingInvocationSeparators(text) {
     }
     return text.slice(cursor);
 }
-export function removeSkillInvocationTokens(text, tokens) {
+/**
+ * Remove expanded invocation tokens, leaving `[skill: name]` where an inline one stood. Tokens in
+ * `unloaded` were not expanded (per-prompt cap) and leave `[skill not loaded: name]` in either position,
+ * so the model is told it does not have that skill instead of seeing a bare command.
+ */
+export function removeSkillInvocationTokens(text, tokens, unloaded = new Set()) {
     let cursor = 0;
     let result = "";
     for (const token of tokens) {
         result += text.slice(cursor, token.start);
-        if (token.position === "inline")
+        if (unloaded.has(token))
+            result += `[skill not loaded: ${token.name}]`;
+        else if (token.position === "inline")
             result += `[skill: ${token.name}]`;
         cursor = token.end;
         if (token.position === "inline" &&
@@ -138,6 +145,9 @@ export function removeSkillInvocationTokens(text, tokens) {
     result += text.slice(cursor);
     return tokens.some((token) => token.position === "leading") ? stripLeadingInvocationSeparators(result) : result;
 }
-/** Caps explicit skill expansion so one prompt cannot consume unbounded context. */
+/**
+ * Default cap on explicit skill expansion so one prompt cannot consume unbounded context.
+ * Users who compose more skills raise it with the `maxSkillExpansionsPerPrompt` setting.
+ */
 export const MAX_SKILL_EXPANSIONS_PER_PROMPT = 5;
 //# sourceMappingURL=skill-invocation.js.map

package/dist/core/webview/native-webview.d.ts

@@ -5,6 +5,7 @@ export interface NativeWebView extends EventTarget {
     readonly loading: boolean;
     onNavigated: ((url: string, title: string) => void) | null;
     onNavigationFailed: ((error: Error) => void) | null;
+    navigate(url: string): Promise<void>;
     close(): void;
 }
 export interface NativeWebViewClass {

package/dist/core/webview/webview-client.d.ts

@@ -1,8 +1,11 @@
 import type { MessagePort } from "node:worker_threads";
 import type { NativeWebView } from "./native-webview.ts";
 export interface WebViewClientHost {
-    /** Launches a view; `adopt` runs in the launch's own turn and returns false once the client is released. */
-    createView(options: Readonly<Record<string, unknown>>, onConsole: ((...args: unknown[]) => void) | undefined, adopt: (view: NativeWebView) => boolean): Promise<NativeWebView>;
+    /**
+     * Launches a view; `adopt` runs in the launch's own turn and returns false once the client is released,
+     * and `wanted` tells a launch about to be retried whether anyone still waits for it.
+     */
+    createView(options: Readonly<Record<string, unknown>>, onConsole: ((...args: unknown[]) => void) | undefined, adopt: (view: NativeWebView) => boolean, wanted: () => boolean): Promise<NativeWebView>;
     onClientClosed(client: WebViewServiceClient): void;
 }
 export declare function closeQuietly(view: NativeWebView): void;

package/dist/core/webview/webview-client.js

@@ -94,7 +94,7 @@ export class WebViewServiceClient {
         const onConsole = captureConsole
             ? (...args) => this.#emit(viewId, { type: "console", args })
             : undefined;
-        const launch = this.#host.createView(options, onConsole, (view) => this.#adopt(viewId, view));
+        const launch = this.#host.createView(options, onConsole, (view) => this.#adopt(viewId, view), () => !this.#released);
         this.#launches.add(launch);
         try {
             return await launch;

package/dist/core/webview/webview-readiness.d.ts

@@ -0,0 +1,41 @@
+import type { NativeWebView } from "./native-webview.ts";
+/**
+ * A Chrome-backed `Bun.WebView` is usable only once a navigation has attached a CDP session to its
+ * target, and Bun reports that attach through nothing but the navigation settling. On Windows a
+ * freshly launched Chrome sometimes never finishes it (senpi#2353), so the service drives each view's
+ * first navigation itself, to `about:blank` (no network, nothing but the launch and the attach), and
+ * replies to `create` only once it settled.
+ */
+export interface WebViewReadinessPolicy {
+    /** How long the readiness navigation may take before the launch counts as stalled. */
+    readonly attachBoundMs: number;
+    /** Launches per view, the first included, before the stall is reported to the cell. */
+    readonly launchAttempts: number;
+}
+export declare const DEFAULT_READINESS: WebViewReadinessPolicy;
+export declare const READINESS_URL = "about:blank";
+export type ReadinessEvent = {
+    readonly type: "ready";
+    readonly launch: number;
+    readonly attachMs: number;
+} | {
+    readonly type: "stalled";
+    readonly phase: "cdp-target-attach";
+    readonly launch: number;
+};
+/** Appends one line per launch outcome to the file `SENPI_WEBVIEW_READINESS_LOG` names (CI diagnostics). */
+export declare function readinessLogFromEnvironment(): ((event: ReadinessEvent) => void) | undefined;
+export declare class WebViewNotReadyError extends Error {
+    readonly code = "ERR_WEBVIEW_NOT_READY";
+    readonly phase = "cdp-target-attach";
+    constructor(launches: number, policy: WebViewReadinessPolicy);
+}
+/** Resolves once the readiness bound of one launch is reached; `cancel` stops it when the launch settled first. */
+export interface AttachDeadline {
+    readonly reached: Promise<void>;
+    cancel(): void;
+}
+export declare function timedDeadline(boundMs: number): AttachDeadline;
+/** Resolves the readiness navigation's duration once it settled, undefined when the deadline came first. */
+export declare function attachedWithin(view: NativeWebView, deadline: AttachDeadline): Promise<number | undefined>;
+//# sourceMappingURL=webview-readiness.d.ts.map