@code-yeongyu/senpi 2026.10.24-3 → 2026.10.25-1

package/dist/core/extensions/builtin/anthropic-subscription/session-entry-annotations.d.ts

@@ -4,7 +4,7 @@ export type AnnotatableRegistry = {
     touch(entry: AnthropicSubscriptionSessionEntry): void;
 };
 export declare function switchEntryModel(registry: AnnotatableRegistry, senpiSessionId: string, modelId: string, sdkModel?: string): Promise<boolean>;
-export declare function annotatePendingFork(registry: AnnotatableRegistry, senpiSessionId: string, reason: string): void;
+export declare function annotatePendingFork(registry: AnnotatableRegistry, senpiSessionId: string, reason: string, divergedPath?: string): void;
 export declare function annotateTainted(registry: AnnotatableRegistry, senpiSessionId: string, reason: string): void;
 export declare function annotateBranchInfo(registry: AnnotatableRegistry, senpiSessionId: string, info: SessionBranchInfo): void;
 //# sourceMappingURL=session-entry-annotations.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/session-entry-annotations.js

@@ -8,11 +8,13 @@ export async function switchEntryModel(registry, senpiSessionId, modelId, sdkMod
     registry.touch(entry);
     return true;
 }
-export function annotatePendingFork(registry, senpiSessionId, reason) {
+export function annotatePendingFork(registry, senpiSessionId, reason, divergedPath) {
     const entry = registry.get(senpiSessionId);
     if (!entry)
         return;
     entry.pendingForkReason = reason;
+    // A fork recorded without a path (compaction, tree change) must not inherit an earlier rewrite's path.
+    entry.pendingForkDivergedPath = divergedPath ?? null;
     registry.touch(entry);
 }
 export function annotateTainted(registry, senpiSessionId, reason) {

package/dist/core/extensions/builtin/anthropic-subscription/session-observability.d.ts

@@ -27,6 +27,8 @@ export type ContinuityObservation = {
     seat?: string;
     /** The attempt runs on a different seat than the lineage's last one: its prompt cache is cold. */
     seatChanged?: boolean;
+    /** senpi#1975: first diverged field path behind an assistant_rewritten decision. Paths only, never values. */
+    divergedPath?: string;
 };
 export type ContinuityObservabilityBoundary = {
     emit: (observation: ContinuityObservation) => void;
@@ -62,6 +64,7 @@ export declare function observeSessionSyncDecision(input: {
     senpiSessionId: string;
     payloadBytes?: number;
     collapsedDirectives?: number;
+    divergedPath?: string;
 }): ContinuityObservation;
 export type StagedContinuityDecision = {
     observation: ContinuityObservation;

package/dist/core/extensions/builtin/anthropic-subscription/session-observability.js

@@ -133,6 +133,7 @@ export function consumePendingCloseCause(senpiSessionId) {
  * incremental→delta, resume→fork, cold-seed→flatten.
  */
 export function observeSessionSyncDecision(input) {
+    const diverged = input.divergedPath === undefined ? {} : { divergedPath: input.divergedPath };
     if (input.kind === "incremental") {
         return { kind: "delta", reason: "prefix_matched", deltaMessages: input.deltaMessages };
     }
@@ -142,6 +143,7 @@ export function observeSessionSyncDecision(input) {
             kind: "fork",
             reason: retainedCause ?? (input.reason === undefined ? "branch_resume" : sanitizeReason(input.reason)),
             deltaMessages: input.deltaMessages,
+            ...diverged,
         };
     }
     // Peek, not consume: the staged observation is emitted only when the
@@ -155,6 +157,7 @@ export function observeSessionSyncDecision(input) {
         deltaMessages: input.deltaMessages,
         ...(input.payloadBytes !== undefined ? { payloadBytes: input.payloadBytes } : {}),
         ...(input.collapsedDirectives !== undefined ? { collapsedDirectives: input.collapsedDirectives } : {}),
+        ...diverged,
     };
 }
 /** Stages an attempt's decision; `emit` fires only when the attempt is retained. */
@@ -181,6 +184,7 @@ export function emitContinuityObservation(observation, sessionId, onDecision) {
         ...(observation.settingSource === undefined ? {} : { settingSource: observation.settingSource }),
         ...(observation.seat === undefined ? {} : { seat: observation.seat }),
         ...(observation.seatChanged === undefined ? {} : { seatChanged: observation.seatChanged }),
+        ...(observation.divergedPath === undefined ? {} : { divergedPath: observation.divergedPath }),
         ...(sessionId === undefined ? {} : { sessionId }),
     });
 }

package/dist/core/extensions/builtin/anthropic-subscription/session-registry-wiring.js

@@ -9,17 +9,22 @@ import { bindingFromEntry, forgetBinding, getBinding, rememberBinding, rememberB
 import { closeSession, getSession, recordBranchInfo, recordPendingFork, switchSessionModel, } from "./session-registry.js";
 import { sentHashesForEntry, sentMessageHashes, sentMessages } from "./session-sync.js";
 const commitBoundary = new AssistantCommitBoundary();
-function persistBindingInvalidation(pi, sessionId, reason) {
-    pi.appendEntry?.(BINDING_ENTRY_TYPE, { schemaVersion: 1, invalidated: true, reason });
+function persistBindingInvalidation(pi, sessionId, reason, divergedPath) {
+    pi.appendEntry?.(BINDING_ENTRY_TYPE, {
+        schemaVersion: 1,
+        invalidated: true,
+        reason,
+        ...(divergedPath === undefined ? {} : { divergedPath }),
+    });
     rememberBindingInvalidation(sessionId, reason);
 }
-async function invalidateBinding(pi, ctx, reason) {
+async function invalidateBinding(pi, ctx, reason, divergedPath) {
     const sessionId = ctx.sessionManager.getSessionId();
     forgetBinding(sessionId);
     const sessionFile = ctx.sessionManager.getSessionFile?.();
     if (sessionFile)
         await deleteStoredBinding(sessionFile);
-    persistBindingInvalidation(pi, sessionId, reason);
+    persistBindingInvalidation(pi, sessionId, reason, divergedPath);
 }
 function keepBindingThenClose(sessionId, reason) {
     const entry = getSession(sessionId);
@@ -129,10 +134,10 @@ export function registerSessionRegistry(pi) {
             commitBoundary.forget(sessionId);
             return;
         }
-        const outcome = commitBoundary.commit(sessionId, event.message, modelId);
+        const { outcome, divergedPath } = commitBoundary.commit(sessionId, event.message, modelId);
         if (outcome === "rewritten") {
-            recordPendingFork(sessionId, "assistant_rewritten");
-            await invalidateBinding(pi, ctx, "assistant_rewritten");
+            recordPendingFork(sessionId, "assistant_rewritten", divergedPath);
+            await invalidateBinding(pi, ctx, "assistant_rewritten", divergedPath);
             return;
         }
         // Only an assistant this provider actually produced may anchor a record.

package/dist/core/extensions/builtin/anthropic-subscription/session-registry.d.ts

@@ -41,6 +41,8 @@ export interface AnthropicSubscriptionSessionEntry {
     taintedReason: string | null;
     /** Wave C seam: a divergence boundary recorded for the next continuity decision. */
     pendingForkReason: string | null;
+    /** senpi#1975: first diverged field path the commit boundary named for the pending fork, when it named one. */
+    pendingForkDivergedPath: string | null;
     lastUsedAt: number;
     /** Digest of the access token the resident subprocess was spawned with. */
     credentialDigest?: string;
@@ -91,7 +93,7 @@ export declare function closeSession(senpiSessionId: string, reason: string): vo
 export declare function isIdleExpired(entry: Pick<AnthropicSubscriptionSessionEntry, "lastUsedAt">): boolean;
 export declare function markTainted(senpiSessionId: string, reason: string): void;
 export declare function switchSessionModel(senpiSessionId: string, modelId: string, sdkModel?: string): Promise<boolean>;
-export declare function recordPendingFork(senpiSessionId: string, reason: string): void;
+export declare function recordPendingFork(senpiSessionId: string, reason: string, divergedPath?: string): void;
 export declare function recordBranchInfo(senpiSessionId: string, info: SessionBranchInfo): void;
 export declare function isCurrentGeneration(senpiSessionId: string, generation: number): boolean;
 export declare function isBoundAccountTokenExpiring(entry: Pick<AnthropicSubscriptionSessionEntry, "accountName">, accounts: readonly Pick<AccountSlot, "name" | "expires" | "source">[]): boolean;

package/dist/core/extensions/builtin/anthropic-subscription/session-registry.js

@@ -162,6 +162,7 @@ export class AnthropicSubscriptionSessionRegistry {
             branchInfo: null,
             taintedReason: null,
             pendingForkReason: null,
+            pendingForkDivergedPath: null,
             lastUsedAt: now,
         };
         // oxlint-disable-next-line eslint/prefer-const -- a closure reads it; const would throw in the TDZ if that closure ran before the assignment, so the rewrite is reviewed separately
@@ -250,8 +251,8 @@ export function markTainted(senpiSessionId, reason) {
 export async function switchSessionModel(senpiSessionId, modelId, sdkModel) {
     return switchEntryModel(sessionRegistry, senpiSessionId, modelId, sdkModel);
 }
-export function recordPendingFork(senpiSessionId, reason) {
-    annotatePendingFork(sessionRegistry, senpiSessionId, reason);
+export function recordPendingFork(senpiSessionId, reason, divergedPath) {
+    annotatePendingFork(sessionRegistry, senpiSessionId, reason, divergedPath);
 }
 export function recordBranchInfo(senpiSessionId, info) {
     annotateBranchInfo(sessionRegistry, senpiSessionId, info);

package/dist/core/extensions/builtin/anthropic-subscription/session-stream.js

@@ -155,6 +155,7 @@ async function createResidentAttempt(input, auth) {
         ? flattenResult.blocks
         : buildDeltaPromptBlocks(messages.slice(from), input.customToolNameToSdk);
     const payloadBytes = flattenResult ? serializedPayloadBytes(flattenResult.blocks) : undefined;
+    const divergedPath = observedReason === "assistant_rewritten" ? (existing?.pendingForkDivergedPath ?? undefined) : undefined;
     const staged = stageContinuityDecision({
         ...observeSessionSyncDecision({
             kind: observedKind,
@@ -166,6 +167,7 @@ async function createResidentAttempt(input, auth) {
             ...(flattenResult?.collapsedDirectives !== undefined
                 ? { collapsedDirectives: flattenResult.collapsedDirectives }
                 : {}),
+            ...(divergedPath === undefined ? {} : { divergedPath }),
         }),
         ...seat,
     }, sessionId, input.onContinuityDecision, 

package/dist/core/extensions/builtin/anthropic-subscription/settings.d.ts

@@ -42,6 +42,6 @@ export declare function resolveSystemPromptMode(settings: AnthropicSubscriptionP
 /** Load the provider block with env values taking precedence over project and global values. */
 export declare function loadAnthropicSubscriptionProviderSettings(settingsManager: SettingsManager, environment?: Environment): AnthropicSubscriptionProviderSettings;
 /** Load settings from Senpi's configured global and project settings.json paths. */
-export declare function loadAnthropicSubscriptionProviderSettingsFromDisk(cwd: string): AnthropicSubscriptionProviderSettings;
+export declare function loadAnthropicSubscriptionProviderSettingsFromDisk(sessionCwd: string): AnthropicSubscriptionProviderSettings;
 export {};
 //# sourceMappingURL=settings.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/settings.js

@@ -1,6 +1,7 @@
 import { getAgentDir } from "../../../../config.js";
 import { getFileContentRevision } from "../../../../utils/paths.js";
 import { getSettingsPath, SettingsManager } from "../../../settings-manager.js";
+import { requireAnthropicSubscriptionCwd } from "./session-cwd.js";
 /** The one place the default lives: senpi owns compaction unless `compactionOwner: "sdk"` opts out. */
 export function resolveCompactionOwner(settings) {
     return settings.compactionOwner ?? "senpi";
@@ -152,7 +153,8 @@ function settingsFingerprint(path) {
 }
 let cachedAnthropicSubscriptionManager;
 /** Load settings from Senpi's configured global and project settings.json paths. */
-export function loadAnthropicSubscriptionProviderSettingsFromDisk(cwd) {
+export function loadAnthropicSubscriptionProviderSettingsFromDisk(sessionCwd) {
+    const cwd = requireAnthropicSubscriptionCwd(sessionCwd);
     // fallbackEligible() calls this per candidate probe; cache the manager by
     // (cwd, settings content revision) and re-apply env live to avoid locked disk reads.
     const agentDir = getAgentDir();

package/dist/core/extensions/builtin/anthropic-subscription/stream.js

@@ -13,6 +13,7 @@ import { refusalError } from "./refusal.js";
 import { getSdkBoundary, loadClaudeAgentSdk } from "./sdk-boundary.js";
 import { emitContinuityObservation } from "./session-observability.js";
 import { forgetBinding } from "./session-reattach.js";
+import { requireAnthropicSubscriptionCwd } from "./session-cwd.js";
 import { residentSessionMessages } from "./session-stream.js";
 import { loadAnthropicSubscriptionProviderSettingsFromDisk, resolveCompactionOwner, resumeModeSource, } from "./settings.js";
 import { applyStreamEvent } from "./stream-events.js";
@@ -58,6 +59,7 @@ export function streamAnthropicSubscription(model, context, options) {
         let coldSeedEstimate;
         let nativeCompactionStopped = false;
         try {
+            const cwd = requireAnthropicSubscriptionCwd(options?.cwd);
             // Resident before the synchronous SDK member below (getSdkBoundary().query)
             // reads it - see sdk-boundary.lazy.ts.
             await loadClaudeAgentSdk();
@@ -67,7 +69,7 @@ export function streamAnthropicSubscription(model, context, options) {
             if (sessionKey)
                 toolWatch.reconcileWithContext(sessionKey, context);
             const toolWatchNote = toolWatch.buildPromptNote(sessionKey, context, resolvedTools.customToolNameToSdk);
-            const providerSettings = loadAnthropicSubscriptionProviderSettingsFromDisk(process.cwd());
+            const providerSettings = loadAnthropicSubscriptionProviderSettingsFromDisk(cwd);
             const senpiOwnsCompaction = resolveCompactionOwner(providerSettings) === "senpi";
             const toolLessRequest = options?.toolChoice === "none";
             const mcpServers = toolLessRequest ? undefined : await buildCustomToolServers(resolvedTools.customTools);
@@ -79,6 +81,7 @@ export function streamAnthropicSubscription(model, context, options) {
                     model,
                     context,
                     streamOptions: options,
+                    cwd,
                     providerSettings,
                     authLane,
                     tools: resolvedTools.sdkTools,

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

@@ -103,7 +103,10 @@ export default function btwExtension(pi) {
                     },
                     sessionId,
                     thinkingLevel: thinkingLevel === "off" ? undefined : thinkingLevel,
-                    streamFn: (streamModel, streamContext, options) => ctx.modelRegistry.modelRuntime.streamSimple(streamModel, streamContext, options),
+                    streamFn: (streamModel, streamContext, options) => ctx.modelRegistry.modelRuntime.streamSimple(streamModel, streamContext, {
+                        ...options,
+                        cwd: ctx.cwd,
+                    }),
                 }, context, {
                     signal: controller.signal,
                     onTextDelta: (delta) => {

package/dist/core/extensions/builtin/compaction/lane-policy.js

@@ -22,6 +22,7 @@
  */
 import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID } from "../anthropic-subscription/account-management.js";
 import { isColdSeedOverflowMessage } from "../anthropic-subscription/cold-seed-budget.js";
+import { requireAnthropicSubscriptionCwd } from "../anthropic-subscription/session-cwd.js";
 import { loadAnthropicSubscriptionProviderSettingsFromDisk, resolveCompactionOwner, } from "../anthropic-subscription/settings.js";
 /** Custom session entry type carrying a mirrored SDK compaction boundary. */
 export const ANTHROPIC_SUBSCRIPTION_COMPACT_ENTRY_TYPE = "claude-sdk-oauth-compact";
@@ -76,8 +77,9 @@ export function createCompactionLanePolicy(options = {}) {
     // undefined when the settings cannot be read, so callers fail closed to
     // senpi's full behavior.
     const readProviderSettings = (cwd) => {
+        const sessionCwd = requireAnthropicSubscriptionCwd(cwd);
         try {
-            return load(cwd);
+            return load(sessionCwd);
         }
         catch {
             return undefined;

package/dist/core/extensions/builtin/look-at/runner.js

@@ -33,6 +33,7 @@ export async function runLookAt(args, signal, ctx, store, dependencies = {}) {
             ((model, context, options) => ctx.modelRegistry.modelRuntime.streamSimple(model, context, options));
         const reasoning = toStreamReasoning(resolved.thinkingLevel);
         const response = await streamRunner(resolved.model, { systemPrompt: LOOK_AT_SYSTEM_PROMPT, messages: [userMessage] }, {
+            cwd: ctx.cwd,
             ...(reasoning === undefined ? {} : { reasoning }),
             maxTokens: 4096,
             signal: request.signal,

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

@@ -29,6 +29,8 @@ export interface ServerConnectionOptions {
     readonly env?: Record<string, string | undefined>;
     readonly authProvider?: McpOAuthProvider;
     readonly elicitationUiProvider?: McpElicitationUiProvider;
+    /** Print/json processes cannot present elicitation; UI-less lessees fail independently. */
+    readonly elicitationEnabled?: boolean;
     /** Present when the server declares references: every new transport re-reads them (senpi#3858). */
     readonly resolveConfig?: () => Promise<McpServerConfig>;
     /** Called when a shared renewal finds this owner's generation changed, so the owner re-keys. */

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

@@ -14,6 +14,7 @@ export class ServerConnection {
     #config;
     #authProvider;
     #elicitationUiProvider;
+    #elicitationEnabled;
     #resolveConfig;
     #projectPolicy;
     #policyAbort;
@@ -34,6 +35,7 @@ export class ServerConnection {
         this.#env = options.env;
         this.#authProvider = options.authProvider;
         this.#elicitationUiProvider = options.elicitationUiProvider;
+        this.#elicitationEnabled = options.elicitationEnabled;
         this.#resolveConfig = options.resolveConfig;
         this.#projectPolicy = options.projectPolicy;
         this.#startedGrantNames = options.projectPolicy?.initial.grantedNames ?? [];
@@ -239,6 +241,7 @@ export class ServerConnection {
                     return current;
                 },
             elicitationUiProvider: this.#elicitationUiProvider,
+            elicitationEnabled: this.#elicitationEnabled,
             logger: this.#logger,
             resolveConfig: this.#resolveConfig,
             serverName: this.serverName,

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

@@ -4,8 +4,11 @@ import type { ExtensionUIContext } from "../../types.ts";
 export declare const MCP_CLIENT_ELICITATION_CAPABILITY: {
     readonly elicitation: {};
 };
+export declare function mcpClientCapabilities(elicitationEnabled?: boolean): {
+    elicitation?: Record<string, never>;
+};
 export declare const MCP_ELICITATION_TIMEOUT_MS: number;
-type ElicitationUi = Pick<ExtensionUIContext, "input" | "select" | "confirm">;
+type ElicitationUi = Pick<ExtensionUIContext, "input" | "select">;
 export type McpElicitationUiProvider = () => ElicitationUi | undefined;
 export interface McpElicitationUiOwner {
     getMcpElicitationUi(): ElicitationUi | undefined;
@@ -29,7 +32,7 @@ export declare function setMcpElicitationUiProvider(provider: McpElicitationUiPr
  * in `transport-sdk.ts`) awaits it before any connect, so a mid-call
  * elicitation still cannot race registration.
  */
-export declare function configureMcpElicitation(client: Client, owner?: McpElicitationUiOwner | McpElicitationUiProvider | undefined, timeoutMs?: number): Promise<void>;
+export declare function configureMcpElicitation(client: Client, owner?: McpElicitationUiOwner | McpElicitationUiProvider | undefined, timeoutMs?: number, elicitationEnabled?: boolean): Promise<void>;
 /** Exported for tests: drive the form directly with a scripted UI. */
 export declare function runElicitationForm(ui: ElicitationUi, message: string, requestedSchema: {
     properties?: Record<string, ElicitProperty>;

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

@@ -3,9 +3,9 @@
 // The client declares the capability as an EMPTY object — Spring-AI servers
 // reject richer shapes (FieldCoding lesson from the comparison corpus) — and
 // answers elicitation/create requests mid tool-call by walking the requested
-// flat-primitive schema through sequential ctx.ui primitives (input/select/
-// confirm; NEVER ctx.ui.custom, which is undefined in RPC mode). Without a UI
-// (print mode) the request is declined immediately — spec-correct, no hang.
+// flat-primitive schema through sequential ctx.ui primitives (input/select;
+// NEVER ctx.ui.custom, which is undefined in RPC mode). Without a UI
+// (print mode) the request fails with a processing error, never a user refusal.
 // 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.
@@ -14,28 +14,46 @@ import { loadMcpSdkTypes } from "./sdk.lazy.js";
 import { safeTimer } from "./wrap.js";
 /** Declared empty on purpose: maximum server compatibility (form mode only). */
 export const MCP_CLIENT_ELICITATION_CAPABILITY = { elicitation: {} };
+export function mcpClientCapabilities(elicitationEnabled = true) {
+    return elicitationEnabled ? MCP_CLIENT_ELICITATION_CAPABILITY : {};
+}
 export const MCP_ELICITATION_TIMEOUT_MS = 5 * 60 * 1000;
 let legacyUiProvider;
 /** Legacy classic-session seam. Session-owned services pass themselves directly. */
 export function setMcpElicitationUiProvider(provider) {
     legacyUiProvider = provider;
 }
+async function rejectElicitation() {
+    const { ErrorCode, McpError } = await loadMcpSdkTypes();
+    throw new McpError(ErrorCode.InternalError, "Elicitation cannot be processed");
+}
 /**
  * Wire the elicitation/create handler onto a fresh client. Async because the
  * request schema comes from the lazily loaded SDK; the caller (`buildMcpClient`
  * in `transport-sdk.ts`) awaits it before any connect, so a mid-call
  * elicitation still cannot race registration.
  */
-export async function configureMcpElicitation(client, owner = legacyUiProvider, timeoutMs = MCP_ELICITATION_TIMEOUT_MS) {
+export async function configureMcpElicitation(client, owner = legacyUiProvider, timeoutMs = MCP_ELICITATION_TIMEOUT_MS, elicitationEnabled = true) {
+    if (!elicitationEnabled) {
+        // The SDK requires an advertised capability for setRequestHandler.
+        // Its public fallback handles unsolicited requests without claiming UI support.
+        const { ErrorCode, McpError } = await loadMcpSdkTypes();
+        client.fallbackRequestHandler = async (request) => {
+            if (request.method === "elicitation/create")
+                return rejectElicitation();
+            throw new McpError(ErrorCode.MethodNotFound, "Method not found");
+        };
+        return;
+    }
     const { ElicitRequestSchema } = await loadMcpSdkTypes();
     client.setRequestHandler(ElicitRequestSchema, async (request) => {
         const params = request.params;
         // URL mode is deliberately unsupported in v1 (form mode only).
         if (!("requestedSchema" in params))
-            return { action: "decline" };
+            return rejectElicitation();
         const ui = typeof owner === "function" ? owner() : owner?.getMcpElicitationUi();
         if (ui === undefined)
-            return { action: "decline" };
+            return rejectElicitation();
         return await runElicitationForm(ui, params.message, params.requestedSchema, timeoutMs);
     });
 }
@@ -61,31 +79,59 @@ async function collectForm(ui, message, requestedSchema) {
     for (const [name, property] of Object.entries(requestedSchema.properties ?? {})) {
         const title = `${message} - ${property.title ?? name}`;
         if (property.type === "boolean") {
-            content[name] = await ui.confirm(title, property.description ?? name);
+            // confirm collapses cancellation into false, including automated RPC replies.
+            // A selection preserves dismissal separately from a human's explicit No.
+            const picked = await ui.select(property.description ? `${title}\n${property.description}` : title, [
+                "Yes",
+                "No",
+            ]);
+            if (picked === undefined)
+                return { action: "cancel" };
+            // The thread gateway also accepts y/n and true/false, ignoring case and whitespace.
+            switch (picked.trim().toLowerCase()) {
+                case "yes":
+                case "y":
+                case "true":
+                    content[name] = true;
+                    break;
+                case "no":
+                case "n":
+                case "false":
+                    content[name] = false;
+                    break;
+                default:
+                    return rejectElicitation();
+            }
             continue;
         }
         if (Array.isArray(property.enum) && property.enum.length > 0) {
             const picked = await ui.select(title, property.enum.map(String));
             if (picked === undefined)
-                return { action: "decline" };
+                return { action: "cancel" };
             content[name] = picked;
             continue;
         }
         const answer = await ui.input(title, property.description);
-        if (answer === undefined || answer.length === 0) {
+        if (answer === undefined)
+            return { action: "cancel" };
+        if (answer.length === 0) {
             if (required.has(name))
-                return { action: "decline" };
+                return rejectElicitation();
             continue;
         }
         if (property.type === "number" || property.type === "integer") {
             const parsed = Number(answer);
             if (!Number.isFinite(parsed))
-                return { action: "decline" };
+                return rejectElicitation();
             content[name] = parsed;
             continue;
         }
         content[name] = answer;
     }
+    // Even a fieldless form needs an explicit submission rather than an automatic accept.
+    if (Object.keys(content).length === 0 && (await ui.select(message, ["Submit"])) !== "Submit") {
+        return { action: "cancel" };
+    }
     return { action: "accept", content };
 }
 //# sourceMappingURL=elicitation.js.map

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

@@ -123,7 +123,7 @@ export function createMcpExtension(service, sessionOwned = true) {
                 }
                 else {
                     // Elicitation (todo 41): point mid-call forms at this session's UI.
-                    service.setMcpElicitationUiProvider(() => ctx.ui);
+                    service.setMcpElicitationUiProvider(() => (ctx.hasUI ? ctx.ui : undefined));
                     await (attachPromise ?? attach({ type: "session_start", reason: "startup" }, ctx));
                 }
                 const skills = preview ? [] : (event.systemPromptOptions.skills ?? []);

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

@@ -1,4 +1,4 @@
-import { configureMcpElicitation, MCP_CLIENT_ELICITATION_CAPABILITY } from "../elicitation.js";
+import { configureMcpElicitation, mcpClientCapabilities } from "../elicitation.js";
 import { ConnectError } from "../errors.js";
 import { loadMcpSdkClient } from "../sdk.lazy.js";
 import { materializeMcpTransport, } from "../transport-sdk.js";
@@ -9,13 +9,10 @@ import { probeStdioTransport } from "./stdio-probe.js";
 import { ModernHttpTransport } from "./transport.js";
 import { MODERN_PROTOCOL_VERSION } from "./wire.js";
 const clientInfo = { name: "senpi-mcp-client", version: "0.0.0" };
-const probeOptions = {
-    clientInfo,
-    clientCapabilities: MCP_CLIENT_ELICITATION_CAPABILITY,
-    supportedVersions: [MODERN_PROTOCOL_VERSION],
-};
 export async function materializeNegotiatedTransport(options, serverName, timeoutMs, signal) {
     signal.throwIfAborted();
+    const clientCapabilities = mcpClientCapabilities(options.elicitationEnabled);
+    const probeOptions = { clientInfo, clientCapabilities, supportedVersions: [MODERN_PROTOCOL_VERSION] };
     const { spec, logger } = options;
     let outcome = { kind: "legacy-fallback" };
     if (spec.kind === "http") {
@@ -32,13 +29,13 @@ export async function materializeNegotiatedTransport(options, serverName, timeou
                 });
             }
             const { Client } = await loadMcpSdkClient();
-            const client = new Client(clientInfo, { capabilities: MCP_CLIENT_ELICITATION_CAPABILITY });
-            await configureMcpElicitation(client, options.elicitationUiProvider);
+            const client = new Client(clientInfo, { capabilities: clientCapabilities });
+            await configureMcpElicitation(client, options.elicitationUiProvider, undefined, options.elicitationEnabled);
             const transport = new ModernSdkBridge(new ModernHttpTransport({
                 url: spec.url,
                 fetch,
                 clientInfo,
-                clientCapabilities: MCP_CLIENT_ELICITATION_CAPABILITY,
+                clientCapabilities,
                 protocolVersion: outcome.version,
             }), outcome.discovery, outcome.version);
             const version = outcome.version;

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

@@ -14,6 +14,7 @@ interface SessionConnectionOptions {
     readonly generation: McpConfigGeneration;
     readonly declared: McpServerDeclaredConfig;
     readonly session: McpSessionOptions;
+    readonly elicitationEnabled: boolean;
     readonly cwd: string;
     readonly ui: McpElicitationUiProvider;
     readonly artifacts: McpOutputArtifacts;

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

@@ -38,6 +38,7 @@ export function createMcpSessionConnection(options) {
         config,
         env: projectPolicy?.initial.env ?? session.env,
         elicitationUiProvider: options.ui,
+        elicitationEnabled: options.elicitationEnabled,
         logger,
         serverName: name,
         ...(renewal === undefined ? {} : { resolveConfig: renewal.resolveConfig, onGenerationChanged: rekey }),

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

@@ -709,6 +709,7 @@ export class McpService {
                     await this.#resyncToLiveSessions(owner);
                 },
                 session: options,
+                elicitationEnabled: declarer.context.mode !== "print" && declarer.context.mode !== "json",
                 cwd: declarer.context.cwd,
                 ui: () => this.getMcpElicitationUi(),
                 artifacts: this.#outputArtifacts,

package/dist/core/extensions/builtin/mcp/transport-sdk.d.ts

@@ -44,6 +44,7 @@ export interface MaterializeMcpTransportOptions {
     readonly logger: McpLogger;
     readonly sink: McpAsyncErrorSink;
     readonly elicitationUiProvider: McpElicitationUiProvider | undefined;
+    readonly elicitationEnabled?: boolean;
     /** Invoked once the stdio child has started, so the caller can capture its pid. */
     readonly onStart: () => void;
 }

package/dist/core/extensions/builtin/mcp/transport-sdk.js

@@ -1,9 +1,9 @@
-import { configureMcpElicitation, MCP_CLIENT_ELICITATION_CAPABILITY, } from "./elicitation.js";
+import { configureMcpElicitation, mcpClientCapabilities } from "./elicitation.js";
 import { ProjectStdioTransport } from "./project-stdio-transport.js";
 import { loadMcpSdkClient, loadMcpSdkStdioTransport, loadMcpSdkStreamableHttpTransport } from "./sdk.lazy.js";
 import { safeOn } from "./wrap.js";
 export async function materializeMcpTransport(options) {
-    const client = await buildMcpClient(options.elicitationUiProvider);
+    const client = await buildMcpClient(options.elicitationUiProvider, options.elicitationEnabled);
     if (options.spec.kind === "stdio")
         return materializeStdio(options.spec, options, client);
     return materializeHttp(options.spec, client);
@@ -48,13 +48,13 @@ async function materializeHttp(spec, client) {
         transport,
     };
 }
-async function buildMcpClient(elicitationUiProvider) {
+async function buildMcpClient(elicitationUiProvider, elicitationEnabled = true) {
     // Elicitation capability is declared EMPTY on purpose (form mode only;
     // Spring-AI servers reject richer shapes) and the create-handler is wired
     // before any connect so mid-call requests never race registration.
     const { Client: McpClient } = await loadMcpSdkClient();
-    const client = new McpClient({ name: "senpi-mcp-client", version: "0.0.0" }, { capabilities: MCP_CLIENT_ELICITATION_CAPABILITY });
-    await configureMcpElicitation(client, elicitationUiProvider);
+    const client = new McpClient({ name: "senpi-mcp-client", version: "0.0.0" }, { capabilities: mcpClientCapabilities(elicitationEnabled) });
+    await configureMcpElicitation(client, elicitationUiProvider, undefined, elicitationEnabled);
     return client;
 }
 // OMP pattern: hand stdio OAuth servers the current access token via env.

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

@@ -32,6 +32,7 @@ export type CreateMcpTransportOptions = {
     readonly logger: McpLogger;
     readonly env?: Record<string, string | undefined>;
     readonly elicitationUiProvider?: McpElicitationUiProvider;
+    readonly elicitationEnabled?: boolean;
     readonly authProvider?: McpOAuthProvider;
     /** Re-reads a declaring server's references for this transport (senpi#3858). */
     readonly resolveConfig?: () => Promise<McpServerConfig>;

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

@@ -91,6 +91,7 @@ function createConnection(options, spec, connectTimeoutMs) {
         materialize: async () => {
             const materializeWith = (current) => import("./modern/dispatch.js").then(({ materializeNegotiatedTransport }) => materializeNegotiatedTransport({
                 elicitationUiProvider: options.elicitationUiProvider,
+                elicitationEnabled: options.elicitationEnabled,
                 logger: options.logger,
                 onStart: captureRootPid,
                 sink: asyncErrorSink,

package/dist/core/external-admission.d.ts

@@ -60,6 +60,8 @@ export declare class ExternalAdmission {
     }): InputHold;
     onInputsSettled(listener: () => void): () => void;
     onEmitted(listener: (deliveryId: string) => void): () => void;
+    /** Durable custody will replay this delivery: reserve its id before asynchronous recovery or gateway admission. */
+    restoreQueued(deliveryId: string, isOwned: () => boolean): void;
     /**
      * From here on every `admit` throws `reason` and changes nothing: the runtime is being handed to
      * another writer, so the delivery stays with its sender and is delivered there instead.
@@ -82,8 +84,9 @@ export declare class ExternalAdmission {
      * deliveries may be admitted again - unless the file's last write was refused too.
      */
     observeRunSettled(): void;
-    /** The runtime's queues were cleared: queued deliveries are no longer held. */
+    /** Cleared carriers are no longer held; custody not yet enqueued for recovery still owns its delivery. */
     dropQueued(): void;
+    private releaseRestored;
     private endHold;
     private isBusy;
 }