@code-yeongyu/senpi 2026.10.25-2 → 2026.10.25-4

package/dist/cli/host-command-args.js

@@ -26,11 +26,16 @@ export function parseHostArgs(args) {
     let root;
     let agentDir;
     let keyRoot;
+    let presenterBootstrapFd;
     const handover = {};
     for (let index = 0; index < rest.length; index++) {
         const flag = rest[index];
         const value = rest[index + 1];
-        if (flag === "--rpc-key-root" && value !== undefined && !value.startsWith("--")) {
+        if (flag === "--mcp-presenter-fd" && value === "4" && (subcommand === "ensure" || subcommand === "handoff")) {
+            presenterBootstrapFd = 4;
+            index++;
+        }
+        else if (flag === "--rpc-key-root" && value !== undefined && !value.startsWith("--")) {
             keyRoot = resolve(value);
             index++;
         }
@@ -115,6 +120,7 @@ export function parseHostArgs(args) {
     if (typeof terms === "string")
         return terms;
     return {
+        ...(presenterBootstrapFd === undefined ? {} : { presenterBootstrapFd }),
         subcommand,
         ...(specPath !== undefined && { specPath }),
         policy,

package/dist/cli/host-command.js

@@ -28,6 +28,7 @@ import { DEFAULT_HOST_LAUNCH_SPEC, HostLaunchSpecError, loadHostLaunchSpec, } fr
 import { HOST_EXIT_ERROR, HOST_EXIT_USAGE, runHostRequest, } from "../modes/rpc/host-runner.js";
 import { parseHostArgs } from "./host-command-args.js";
 import { emit } from "./host-emit.js";
+import { presenterBootstrapStream } from "../modes/rpc/mcp-presenter-bootstrap.js";
 export { parseHostArgs } from "./host-command-args.js";
 const USAGE = `usage: ${APP_NAME} host <ensure|status|stop|handoff|shard-path|gc> [options]
 
@@ -55,7 +56,8 @@ export async function runHostCommand(args) {
     }
     try {
         const request = await hostRequest(parsed);
-        const outcome = await runHostRequest(request, parsed.keyRoot === undefined ? {} : { keyRoot: parsed.keyRoot });
+        const presenterBootstrap = parsed.presenterBootstrapFd === undefined ? undefined : presenterBootstrapStream(parsed.presenterBootstrapFd);
+        const outcome = await runHostRequest(request, { keyRoot: parsed.keyRoot, presenterBootstrap }).finally(() => presenterBootstrap?.destroy());
         if (parsed.subcommand === "shard-path" && !parsed.json)
             writeSync(1, `${String(outcome.payload.socket)}\n`);
         else

package/dist/core/agent-session.js

@@ -609,6 +609,9 @@ export class AgentSession {
         this._handleAgentEvent = (event, signal) => {
             if (event.type === "agent_start")
                 this._lifecycleBinding.startRun();
+            // Bound at emission: the core can start the next run before the queue reaches this end (senpi#3864).
+            if (event.type === "agent_end")
+                this._lifecycleBinding.bindTurnEnd(event);
             if (event.type === "message_start") {
                 try {
                     const entryId = this._lifecycleBinding.consume(event.message);
@@ -3113,8 +3116,9 @@ export class AgentSession {
         else if (event.type === "agent_end") {
             const extensionEvent = this._abortProvenance.beginAgentEnd(event.messages, agentEndWillRetry, this._findLastAssistantInMessages(event.messages)?.stopReason === "aborted");
             try {
+                const guardStartLeafId = this.sessionManager.getLeafId();
                 await this._extensionRunner.emit(extensionEvent);
-                await this._lifecycleBinding.turnEnded(extensionEvent);
+                await this._lifecycleBinding.turnEnded(extensionEvent, event, guardStartLeafId);
             }
             finally {
                 this._abortProvenance.endAgentEnd(extensionEvent);
@@ -3538,12 +3542,23 @@ export class AgentSession {
     }
     /** Record a deadline stop durably so the goal engine holds off until admitted user input. */
     _recordDeadlineStop(deadline) {
-        this._emitEntryAppended(this.sessionManager.appendCustomEntry(TURN_DEADLINE_ENTRY_TYPE, {
-            kind: deadline.kind,
-            limitMs: deadline.limitMs,
-            elapsedMs: deadline.elapsedMs,
-            at: Date.now(),
-        }));
+        const at = Date.now();
+        // The lifecycle stop is captured before the write, so a refused write keeps it for this run (senpi#3864).
+        this._lifecycleBinding.deadlineStopped(deadline.kind, at);
+        let entryId;
+        try {
+            entryId = this.sessionManager.appendCustomEntry(TURN_DEADLINE_ENTRY_TYPE, {
+                kind: deadline.kind,
+                limitMs: deadline.limitMs,
+                elapsedMs: deadline.elapsedMs,
+                at,
+            });
+        }
+        catch (error) {
+            this._lifecycleBinding.deadlineStopWriteFailed();
+            throw error;
+        }
+        this._emitEntryAppended(entryId);
     }
     /**
      * Get the names of currently active tools.

package/dist/core/extensions/builtin/goal/index.js

@@ -137,6 +137,7 @@ export default function goalExtension(pi) {
             const end = lastAgentEnd ?? restoredEnd;
             return {
                 goal,
+                ...(lastTodoOutcome === undefined ? {} : { todoOutcome: lastTodoOutcome }),
                 ...(end
                     ? {
                         input: collectTurnEndLivenessInput(ctx, end, {

package/dist/core/extensions/builtin/goal/lifecycle-facts.d.ts

@@ -1,9 +1,12 @@
 import type { AgentEndEvent } from "../../types.ts";
+import type { TodoOwedOutcome } from "./todo-owed-backstop.ts";
 import type { TurnEndLivenessInput } from "./turn-end-liveness.ts";
 import type { Goal } from "./types.ts";
 export interface GoalLifecycleFacts {
     readonly goal: Goal | null;
     readonly input?: TurnEndLivenessInput;
+    /** What the todo backstop returned at the last turn end; a repeated `cap` emits no event. */
+    readonly todoOutcome?: TodoOwedOutcome;
 }
 type Collector = (restoredEnd?: AgentEndEvent, goal?: Goal | null) => Promise<GoalLifecycleFacts>;
 export declare function onGoalLifecycleChange(owner: object, listener: (goal: Goal | null) => void): () => void;

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

@@ -5,8 +5,10 @@ import type { ServerConnection } from "./connection.ts";
 import type { McpOutputArtifacts } from "./guard/output-guard.ts";
 import type { McpEnsureFreshAuth } from "./health.ts";
 import type { McpInvocationResolver } from "./invocation.ts";
+import type { McpRequestOrigin } from "./request-origin.ts";
 type ListedTool = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
 export interface McpToolCatalogEntry {
+    requestOrigin?: () => McpRequestOrigin | undefined;
     server: string;
     tool: string;
     schema: ListedTool["inputSchema"];
@@ -21,7 +23,7 @@ export interface McpToolCatalogEntry {
     outputGuard?: McpSettings["outputGuard"];
     invocation?: McpInvocationResolver;
 }
-type McpToolCatalogOptions = Pick<McpToolCatalogEntry, "agentDir" | "artifacts" | "ensureFresh" | "outputGuard" | "invocation">;
+type McpToolCatalogOptions = Pick<McpToolCatalogEntry, "agentDir" | "artifacts" | "ensureFresh" | "outputGuard" | "invocation" | "requestOrigin">;
 export declare function collectToolCatalog(server: string, connection: ServerConnection, config: McpServerDeclaredConfig, options?: McpToolCatalogOptions): Promise<McpToolCatalogEntry[]>;
 /** What registering these tools with this catalog's resources and prompts exposes;
  * equal identities register identical definitions. */

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

@@ -2,6 +2,7 @@ import { collectAllPages } from "./expose/pagination.js";
 export async function collectToolCatalog(server, connection, config, options = {}) {
     const result = await collectAllPages((cursor) => connection.client.listTools(cursor === undefined ? {} : { cursor }, { timeout: config.requestTimeoutMs }));
     return result.items.map((tool) => ({
+        requestOrigin: options.requestOrigin,
         annotations: tool.annotations,
         agentDir: options.agentDir,
         artifacts: options.artifacts,
@@ -27,6 +28,7 @@ export function mcpRegistrationIdentity(tools, catalog) {
 }
 export function cachedToolsToCatalogEntries(server, catalog, connection, requestTimeoutMs, ensureConnected, options = {}) {
     return catalog.tools.map((tool) => ({
+        requestOrigin: options.requestOrigin,
         annotations: tool.annotations,
         agentDir: options.agentDir,
         artifacts: options.artifacts,

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

@@ -4,6 +4,7 @@ export type { ServerConnectionOptions, ServerConnectionState, ServerConnectionSt
 export declare class ServerConnection {
     #private;
     readonly serverName: string;
+    get requestLifetimeSignal(): AbortSignal;
     constructor(options: ServerConnectionOptions);
     get state(): ServerConnectionState;
     get declarationIdentity(): string | undefined;

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

@@ -2,6 +2,8 @@ import { dirname } from "node:path";
 import { resolveServerAuth } from "./auth/context.js";
 import { diagnoseCapturedMcpConnectFailure, diagnoseMcpConnectFailure } from "./diagnose.js";
 import { ConnectError } from "./errors.js";
+import { legacyMcpFormEligible } from "./elicitation.js";
+import { isModernMcpClient, legacyMcpFormsAdvertised } from "./modern/request.js";
 import { subscribeMcpServerLogging } from "./logging.js";
 import { isMcpNeedsAuthError } from "./needs-auth.js";
 import { subscribeMcpListChanged } from "./notifications.js";
@@ -18,12 +20,18 @@ export class ServerConnection {
     #resolveConfig;
     #projectPolicy;
     #policyAbort;
+    #requestLifetime = new AbortController();
+    get requestLifetimeSignal() {
+        return this.#requestLifetime.signal;
+    }
     #startedGrantNames = [];
     #state;
     #generation = 0;
     #connection;
     #pendingConnection;
     #pendingConnect;
+    #renegotiatingForms;
+    #stopFormReadiness;
     #lastError;
     #stateListeners = new Set();
     #toolsListeners = new Set();
@@ -87,9 +95,33 @@ export class ServerConnection {
         return this.#connection?.getRootPid() ?? null;
     }
     connect() {
+        return this.#renegotiatingForms ?? this.#connect();
+    }
+    #legacyFormsChanged(client) {
+        return (this.#elicitationUiProvider?.enforced?.() === true &&
+            !isModernMcpClient(client) &&
+            legacyMcpFormsAdvertised(client) !==
+                legacyMcpFormEligible(this.#elicitationUiProvider, this.#elicitationEnabled !== false));
+    }
+    #refreshLegacyForms() {
+        if (this.#state !== "connected" || this.#renegotiatingForms || !this.#legacyFormsChanged(this.client))
+            return;
+        // Publish the single flight before renewing: connect callers join it while the old transport closes.
+        this.#renegotiatingForms = Promise.resolve()
+            .then(() => this.renew())
+            .finally(() => {
+            this.#renegotiatingForms = undefined;
+        });
+        void this.#renegotiatingForms.catch((error) => {
+            this.markDegraded(error instanceof Error ? error : new Error(String(error)));
+        });
+    }
+    #connect() {
         if (this.#state === "disabled") {
             return Promise.reject(this.#connectError(`MCP server ${this.serverName} is disabled`, "connect"));
         }
+        if (this.#elicitationUiProvider?.enforced?.())
+            this.#stopFormReadiness ??= this.#elicitationUiProvider.subscribe?.(() => this.#refreshLegacyForms());
         if (this.#state === "connected")
             return Promise.resolve(this.client);
         if (this.#pendingConnect)
@@ -153,13 +185,17 @@ export class ServerConnection {
             throw this.#connectError(`MCP server ${this.serverName} is disabled`, "renew");
         }
         this.#policyAbort?.abort();
+        this.#requestLifetime.abort();
+        this.#requestLifetime = new AbortController();
         this.#generation++;
         this.#pendingConnect = undefined;
         this.#setState("idle");
         await this.#disposeOwnedConnections();
-        return this.connect();
+        return this.#connect();
     }
     bumpGeneration() {
+        this.#requestLifetime.abort();
+        this.#requestLifetime = new AbortController();
         this.#policyAbort?.abort();
         this.#generation++;
         this.#pendingConnect = undefined;
@@ -169,6 +205,9 @@ export class ServerConnection {
         return this.#disposeOwnedConnections();
     }
     disable() {
+        this.#stopFormReadiness?.();
+        this.#stopFormReadiness = undefined;
+        this.#requestLifetime.abort();
         this.#policyAbort?.abort();
         this.#generation++;
         this.#pendingConnect = undefined;
@@ -177,6 +216,9 @@ export class ServerConnection {
         return this.#disposeOwnedConnections();
     }
     async dispose() {
+        this.#stopFormReadiness?.();
+        this.#stopFormReadiness = undefined;
+        this.#requestLifetime.abort();
         this.#policyAbort?.abort();
         this.#generation++;
         this.#pendingConnect = undefined;
@@ -320,6 +362,9 @@ export class ServerConnection {
         // Server logging notifications (todo 42): RFC-5424 → the per-server
         // logger, filtered by config.logLevel, burst-capped.
         subscribeMcpServerLogging(connection.client, { logLevel: this.#config.logLevel, logger: this.#logger });
+        // Readiness can change while initialize is in flight; never publish that stale negotiation as connected.
+        if (this.#legacyFormsChanged(connection.client))
+            return this.renew();
         this.#setState("connected");
         this.markToolsChanged("connect");
         return connection.client;

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

@@ -9,7 +9,11 @@ export declare function mcpClientCapabilities(elicitationEnabled?: boolean): {
 };
 export declare const MCP_ELICITATION_TIMEOUT_MS: number;
 type ElicitationUi = Pick<ExtensionUIContext, "input" | "select">;
-export type McpElicitationUiProvider = () => ElicitationUi | undefined;
+export type McpElicitationUiProvider = (() => ElicitationUi | undefined) & {
+    readonly eligible?: () => boolean;
+    readonly enforced?: () => boolean;
+    readonly subscribe?: (listener: () => void) => () => void;
+};
 export interface McpElicitationUiOwner {
     getMcpElicitationUi(): ElicitationUi | undefined;
 }
@@ -26,6 +30,7 @@ interface ElicitProperty {
 }
 /** Legacy classic-session seam. Session-owned services pass themselves directly. */
 export declare function setMcpElicitationUiProvider(provider: McpElicitationUiProvider | undefined): void;
+export declare function legacyMcpFormEligible(provider: McpElicitationUiProvider | undefined, enabled: boolean): boolean;
 /**
  * Wire the elicitation/create handler onto a fresh client. Async because the
  * request schema comes from the lazily loaded SDK; the caller (`buildMcpClient`

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

@@ -9,6 +9,9 @@
 // The whole form is bounded by a timeout that resolves to cancel so a wedged
 // dialog can never wedge the tool-call pipeline. URL mode is deliberately not
 // implemented in v1.
+import { privateMcpForms } from "../../../mcp-form-types.js";
+import { legacyMcpOperation } from "./request-origin.js";
+import { isRecord, validateMrtrForm } from "./modern/form-schema.js";
 import { createMcpLogger } from "./log.js";
 import { loadMcpSdkTypes } from "./sdk.lazy.js";
 import { safeTimer } from "./wrap.js";
@@ -27,6 +30,46 @@ async function rejectElicitation() {
     const { ErrorCode, McpError } = await loadMcpSdkTypes();
     throw new McpError(ErrorCode.InternalError, "Elicitation cannot be processed");
 }
+export function legacyMcpFormEligible(provider, enabled) {
+    if (!enabled)
+        return false;
+    if (provider?.eligible)
+        return provider.eligible();
+    const ui = provider?.();
+    const binding = ui === undefined ? undefined : privateMcpForms(ui);
+    return binding === undefined || binding.capture()?.ready() === true;
+}
+async function rejectPrivateElicitation() {
+    const { ErrorCode, McpError } = await loadMcpSdkTypes();
+    throw new McpError(ErrorCode.InternalError, "Elicitation processing unavailable");
+}
+async function privateElicitation(client, params, signal, requestId, timeoutMs) {
+    const operation = legacyMcpOperation(client);
+    if (operation === "ambiguous")
+        return rejectPrivateElicitation();
+    const presenter = operation?.origin.privateForm;
+    if (!isRecord(params) ||
+        typeof params.message !== "string" ||
+        (params.mode !== undefined && params.mode !== "form") ||
+        !operation ||
+        !presenter?.ready() ||
+        !validateMrtrForm(params.requestedSchema))
+        return rejectPrivateElicitation();
+    const outcome = await presenter.present({
+        operationId: String(requestId),
+        inputId: String(requestId),
+        round: 0,
+        server: { label: operation.origin.serverLabel, source: operation.origin.serverSource ?? "user" },
+        message: params.message,
+        schema: params.requestedSchema,
+        operationSignal: AbortSignal.any([operation.signal, signal]),
+        presentationSignal: presenter.signal,
+        deadlineMs: timeoutMs,
+    });
+    if (outcome.kind !== "result" || operation.signal.aborted || !operation.origin.isCurrent())
+        return rejectPrivateElicitation();
+    return outcome.result;
+}
 /**
  * Wire the elicitation/create handler onto a fresh client. Async because the
  * request schema comes from the lazily loaded SDK; the caller (`buildMcpClient`
@@ -40,18 +83,27 @@ export async function configureMcpElicitation(client, owner = legacyUiProvider,
         const { ErrorCode, McpError } = await loadMcpSdkTypes();
         client.fallbackRequestHandler = async (request) => {
             if (request.method === "elicitation/create")
-                return rejectElicitation();
+                return typeof owner === "function" && owner.enforced?.() ? rejectPrivateElicitation() : rejectElicitation();
             throw new McpError(ErrorCode.MethodNotFound, "Method not found");
         };
         return;
     }
     const { ElicitRequestSchema } = await loadMcpSdkTypes();
-    client.setRequestHandler(ElicitRequestSchema, async (request) => {
+    if (typeof owner === "function" && owner.enforced?.()) {
+        // Private validation prevents SDK error.data from echoing malformed form bodies.
+        client.setRequestHandler(ElicitRequestSchema.omit({ params: true }).passthrough(), (request, extra) => privateElicitation(client, request.params, extra.signal, extra.requestId, timeoutMs));
+        return;
+    }
+    client.setRequestHandler(ElicitRequestSchema, async (request, extra) => {
         const params = request.params;
         // URL mode is deliberately unsupported in v1 (form mode only).
         if (!("requestedSchema" in params))
             return rejectElicitation();
         const ui = typeof owner === "function" ? owner() : owner?.getMcpElicitationUi();
+        const enforced = (typeof owner === "function" && owner.enforced?.()) || (ui !== undefined && privateMcpForms(ui) !== undefined);
+        if (enforced) {
+            return privateElicitation(client, params, extra.signal, extra.requestId, timeoutMs);
+        }
         if (ui === undefined)
             return rejectElicitation();
         return await runElicitationForm(ui, params.message, params.requestedSchema, timeoutMs);

package/dist/core/extensions/builtin/mcp/expose/call.js

@@ -2,6 +2,8 @@ import { redactResolvedReferenceData, redactResolvedReferenceValues } from "../.
 import { ToolExecError } from "../errors.js";
 import { ensureMcpToolCallConnection, withMcpRetriableFailedSendRetry, withMcpSessionExpiryRetry } from "../health.js";
 import { runMcpConnectionLifecycleCall } from "../idle.js";
+import { mcpRequestOptions } from "../request-origin.js";
+import { McpMrtrError } from "../modern/errors.js";
 export async function callMcpTool(entry, args, signal, onUpdate, label, invocation) {
     try {
         return await runMcpConnectionLifecycleCall(entry.connection, () => withMcpSessionExpiryRetry(entry.connection, async () => {
@@ -29,7 +31,7 @@ export async function callMcpTool(entry, args, signal, onUpdate, label, invocati
                     if (prepared !== undefined && !prepared.isCurrent())
                         continue;
                     const current = prepared?.entry ?? entry;
-                    const result = await current.connection.client.callTool({ name: current.tool, arguments: args }, undefined, {
+                    const result = await current.connection.client.callTool({ name: current.tool, arguments: args }, undefined, mcpRequestOptions(current.requestOrigin?.(), {
                         onprogress: (progress) => {
                             onUpdate?.(redactResolvedReferenceData({
                                 content: [{ type: "text", text: formatProgress(label, progress) }],
@@ -38,13 +40,15 @@ export async function callMcpTool(entry, args, signal, onUpdate, label, invocati
                         },
                         signal,
                         timeout: current.requestTimeoutMs,
-                    });
+                    }));
                     return { kind: "called", entry: current, result };
                 }
             });
         }));
     }
     catch (error) {
+        if (error instanceof McpMrtrError)
+            throw error;
         const label = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
         throw new ToolExecError(redactResolvedReferenceValues(`ToolExecError: ${label}`), {
             cause: error,

package/dist/core/extensions/builtin/mcp/expose/session.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "../../../types.ts";
+import type { ExtensionAPI, ExtensionUIContext } from "../../../types.ts";
 import type { ToolSearchService } from "../../tool-search/service.ts";
 import type { McpCachedServerCatalog } from "../catalog-cache.ts";
 import type { ResolvedMcpConfig } from "../config-schema.ts";
@@ -7,6 +7,7 @@ import type { McpOutputArtifacts } from "../guard/output-guard.ts";
 import type { McpInvocationResolver } from "../invocation.ts";
 import { type McpLogger } from "../log.ts";
 import type { McpPromptServer } from "../prompts.ts";
+import type { McpRequestOrigin } from "../request-origin.ts";
 import { type McpResourceServer } from "../resources.ts";
 import type { McpCatalogRegistrationOptions } from "./register.ts";
 import { type McpTierBRegistration } from "./tier-b.ts";
@@ -15,6 +16,8 @@ export type McpSessionRegistration = McpTierBRegistration & {
     promptServers: McpPromptServer[];
 };
 export interface McpDirectRegistrationEntry {
+    readonly requestOrigin?: () => McpRequestOrigin | undefined;
+    readonly bindPresentation?: (ui: ExtensionUIContext) => void;
     readonly name: string;
     readonly connection: ServerConnection;
     readonly logger: McpLogger;

package/dist/core/extensions/builtin/mcp/expose/session.js

@@ -24,6 +24,7 @@ export async function registerDirectMcpTools(pi, config, entries, toolSearchServ
                     artifacts: entry.artifacts,
                     ensureFresh: entry.ensureFresh,
                     invocation: entry.invocation,
+                    requestOrigin: entry.requestOrigin,
                     outputGuard: config.settings.outputGuard,
                 })
                 : []
@@ -32,6 +33,7 @@ export async function registerDirectMcpTools(pi, config, entries, toolSearchServ
                 artifacts: entry.artifacts,
                 ensureFresh: entry.ensureFresh,
                 invocation: entry.invocation,
+                requestOrigin: entry.requestOrigin,
                 outputGuard: config.settings.outputGuard,
             });
         const identity = mcpRegistrationIdentity(catalog, entry.cachedCatalog);
@@ -39,6 +41,9 @@ export async function registerDirectMcpTools(pi, config, entries, toolSearchServ
         const cachedPrompts = entry.cachedCatalog?.prompts ?? [];
         if (cachedPrompts.length > 0) {
             promptServers.push({
+                ensureFresh: entry.ensureFresh,
+                bindPresentation: entry.bindPresentation,
+                requestOrigin: entry.requestOrigin,
                 connection: entry.connection,
                 prompts: cachedPrompts,
                 requestTimeoutMs: server.config.requestTimeoutMs,
@@ -48,6 +53,8 @@ export async function registerDirectMcpTools(pi, config, entries, toolSearchServ
         const cachedResources = entry.cachedCatalog?.resources ?? [];
         if (cachedResources.length > 0) {
             resourceServers.push({
+                ensureFresh: entry.ensureFresh,
+                requestOrigin: entry.requestOrigin,
                 agentDir: entry.agentDir,
                 artifacts: entry.artifacts,
                 connection: entry.connection,

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

@@ -1,6 +1,7 @@
 import { AuthError, ConnectError, isMcpSessionExpiredError, isRetriableMcpError, SessionExpiredError, } from "./errors.js";
 import { isMcpNeedsAuthError } from "./needs-auth.js";
 import { reconnectMcpNow } from "./reconnect.js";
+import { McpMrtrError } from "./modern/errors.js";
 export const MCP_PING_STALE_MS = 30_000;
 export const MCP_PING_TIMEOUT_MS = 2_000;
 const healthByConnection = new WeakMap();
@@ -46,6 +47,8 @@ export async function withMcpSessionExpiryRetry(connection, operation) {
         return await operation();
     }
     catch (error) {
+        if (error instanceof McpMrtrError)
+            throw error;
         if (!isMcpSessionExpiredError(error))
             throw error;
         connection.markDegraded(sessionExpiredError(connection, error, true));
@@ -67,6 +70,8 @@ export async function withMcpRetriableFailedSendRetry(connection, operation) {
         return await operation();
     }
     catch (error) {
+        if (error instanceof McpMrtrError)
+            throw error;
         if (!isRetriableFailedSendError(error))
             throw error;
         connection.markDegraded(failedSendError(connection, error, true));

package/dist/core/extensions/builtin/mcp/host-registry.js

@@ -1,3 +1,4 @@
+import { legacyMcpFormEligible } from "./elicitation.js";
 import { observe } from "./env-grants-store.js";
 import { effectiveGrantNames } from "./project-skill-policy.js";
 import { SharedMcpConnection } from "./shared-connection.js";
@@ -17,7 +18,12 @@ export class HostMcpRegistry {
     #shared = new Map();
     #grantObservers = new Map();
     attachShared(key, owner, options) {
-        const identity = sharedMcpKey(options, options.agentDir);
+        const eligible = legacyMcpFormEligible(options.elicitationUiProvider, options.elicitationEnabled !== false);
+        // Enforced pools observe live readiness; it must not remain frozen in a creation-time key.
+        const formPolicy = options.elicitationUiProvider?.enforced?.() === true
+            ? `private:${options.elicitationEnabled !== false}`
+            : `${eligible}:false`;
+        const identity = `${sharedMcpKey(options, options.agentDir)}\0legacy-form:${formPolicy}`;
         let shared = this.#shared.get(identity);
         if (shared === undefined) {
             shared = new SharedMcpConnection(options, () => this.#shared.delete(identity));

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

@@ -61,6 +61,7 @@ export function createMcpExtension(service, sessionOwned = true) {
                 service.activateSkillMcpTools(targets, pi);
         };
         pi.on("input", async (event, ctx) => {
+            service.bindMcpMrtrPresentation(pi, ctx.ui);
             const match = /^\s*\/skill:([A-Za-z0-9._-]+)/.exec(event.text);
             if (match)
                 revealSkill(match[1]);
@@ -125,6 +126,7 @@ export function createMcpExtension(service, sessionOwned = true) {
                     // Elicitation (todo 41): point mid-call forms at this session's UI.
                     service.setMcpElicitationUiProvider(() => (ctx.hasUI ? ctx.ui : undefined));
                     await (attachPromise ?? attach({ type: "session_start", reason: "startup" }, ctx));
+                    service.bindMcpMrtrPresentation(pi, ctx.ui);
                 }
                 const skills = preview ? [] : (event.systemPromptOptions.skills ?? []);
                 if (skills.length > 0) {

package/dist/core/extensions/builtin/mcp/modern/client.d.ts

@@ -0,0 +1,5 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { type McpElicitationUiProvider } from "../elicitation.ts";
+import { type ModernProtocolState } from "./request.ts";
+export declare function createMcpRequestClient(protocol: ModernProtocolState, uiProvider: McpElicitationUiProvider | undefined, readCredential?: () => string | undefined, elicitationEnabled?: boolean): Promise<Client>;
+//# sourceMappingURL=client.d.ts.map

package/dist/core/extensions/builtin/mcp/modern/client.js

@@ -0,0 +1,15 @@
+import { configureMcpElicitation, legacyMcpFormEligible, mcpClientCapabilities, } from "../elicitation.js";
+import { loadMcpSdkClient } from "../sdk.lazy.js";
+import { mcpElapsedClock } from "../wrap.js";
+import { installModernRequestAdapter } from "./request.js";
+export async function createMcpRequestClient(protocol, uiProvider, readCredential = () => undefined, elicitationEnabled = true) {
+    const { Client } = await loadMcpSdkClient();
+    protocol.privateForms = uiProvider?.enforced?.() === true;
+    const legacyEligible = legacyMcpFormEligible(uiProvider, elicitationEnabled);
+    protocol.legacyFormEligible = legacyEligible;
+    const client = new Client({ name: "senpi-mcp-client", version: "0.0.0" }, { capabilities: mcpClientCapabilities(legacyEligible) });
+    await configureMcpElicitation(client, uiProvider, undefined, legacyEligible);
+    installModernRequestAdapter(client, protocol, mcpElapsedClock, readCredential);
+    return client;
+}
+//# sourceMappingURL=client.js.map

package/dist/core/extensions/builtin/mcp/modern/consent-queue.d.ts

@@ -0,0 +1,2 @@
+export declare function queuedForm<T>(binding: object, signal: AbortSignal, run: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=consent-queue.d.ts.map

package/dist/core/extensions/builtin/mcp/modern/consent-queue.js

@@ -0,0 +1,59 @@
+import { McpMrtrError } from "./errors.js";
+const queues = new WeakMap();
+export function queuedForm(binding, signal, run) {
+    let queue = queues.get(binding);
+    if (!queue) {
+        queue = { busy: false, jobs: [] };
+        queues.set(binding, queue);
+    }
+    const current = queue;
+    const pump = () => {
+        if (current.busy)
+            return;
+        const next = current.jobs.shift();
+        if (!next) {
+            queues.delete(binding);
+            return;
+        }
+        next.signal.removeEventListener("abort", next.abort);
+        if (next.signal.aborted) {
+            next.reject(new McpMrtrError("MCP_MRTR_PROCESSING_UNAVAILABLE"));
+            pump();
+            return;
+        }
+        current.busy = true;
+        void next.run().finally(() => {
+            current.busy = false;
+            pump();
+        });
+    };
+    return new Promise((resolve, reject) => {
+        const job = {
+            signal,
+            run: async () => {
+                try {
+                    resolve(await run());
+                }
+                catch (error) {
+                    reject(error);
+                }
+            },
+            reject,
+            abort: () => { },
+        };
+        job.abort = () => {
+            const index = current.jobs.indexOf(job);
+            if (index >= 0) {
+                current.jobs.splice(index, 1);
+                signal.removeEventListener("abort", job.abort);
+                reject(new McpMrtrError("MCP_MRTR_PROCESSING_UNAVAILABLE"));
+            }
+        };
+        current.jobs.push(job);
+        signal.addEventListener("abort", job.abort, { once: true });
+        if (signal.aborted)
+            job.abort();
+        pump();
+    });
+}
+//# sourceMappingURL=consent-queue.js.map

package/dist/core/extensions/builtin/mcp/modern/diagnostics.d.ts

@@ -0,0 +1,4 @@
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+/** Control/diagnostic payloads are private from admission, not merely after consent starts. */
+export declare function sanitizeModernMessage(message: JSONRPCMessage): JSONRPCMessage | undefined;
+//# sourceMappingURL=diagnostics.d.ts.map