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

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

@@ -4,6 +4,7 @@ import { CONFIG_DIR_NAME, getAgentDir } from "../../../../config.js";
 import { PROJECT_RULES_END_MARKER, PROJECT_RULES_HEADING, PROJECT_RULES_REGION_END_MARKER, PROJECT_RULES_REGION_START_MARKER, PROJECT_RULES_START_MARKER, } from "../rules/rules/constants.js";
 import { plannedContextWindow, sdkModelId } from "./context-window.js";
 import { presetAppendDeprecationGuidance } from "./guidance.js";
+import { requireAnthropicSubscriptionCwd } from "./session-cwd.js";
 import { loadAnthropicSubscriptionProviderSettingsFromDisk, resolveCompactionOwner, resolveSystemPromptMode, } from "./settings.js";
 import { loadOverrideSystemPrompt, resolveCustomSystemPrompt } from "./system-prompt.js";
 import { BUILTIN_SDK_TOOLS, canUseTool, HOST_TOOL_DENIAL_HOOKS } from "./tools.js";
@@ -178,7 +179,7 @@ function resolveSettingSources(providerSettings, mode, authLane) {
     return ["user", "project"];
 }
 export function buildAnthropicSubscriptionQueryOptions(input) {
-    const cwd = input.cwd ?? process.cwd();
+    const cwd = requireAnthropicSubscriptionCwd(input.cwd);
     const providerSettings = input.providerSettings ?? loadAnthropicSubscriptionProviderSettingsFromDisk(cwd);
     const appendSystemPrompt = providerSettings.appendSystemPrompt !== false;
     const resolvedMode = resolveSystemPromptMode(providerSettings);

package/dist/core/extensions/builtin/anthropic-subscription/sdk-boundary.js

@@ -1,4 +1,5 @@
 import { loadClaudeAgentSdk, loadedClaudeAgentSdk } from "./sdk-boundary.lazy.js";
+import { requireAnthropicSubscriptionCwd } from "./session-cwd.js";
 export { loadClaudeAgentSdk } from "./sdk-boundary.lazy.js";
 /**
  * Reads the deferred SDK module for a synchronous boundary member.
@@ -18,9 +19,15 @@ function requireLoadedSdk(member) {
     return sdk;
 }
 const defaultSdkBoundary = {
-    query: (input) => requireLoadedSdk("query").query(input),
+    query: (input) => {
+        const cwd = requireAnthropicSubscriptionCwd(input.options?.cwd);
+        return requireLoadedSdk("query").query({ ...input, options: { ...input.options, cwd } });
+    },
     createSdkMcpServer: (options) => requireLoadedSdk("createSdkMcpServer").createSdkMcpServer(options),
-    getSessionMessages: async (sessionId, options) => (await loadClaudeAgentSdk()).getSessionMessages(sessionId, options),
+    getSessionMessages: async (sessionId, options) => {
+        const dir = requireAnthropicSubscriptionCwd(options?.dir);
+        return (await loadClaudeAgentSdk()).getSessionMessages(sessionId, { ...options, dir });
+    },
 };
 let activeSdkBoundary = defaultSdkBoundary;
 export function getSdkBoundary() {

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

@@ -0,0 +1,3 @@
+/** Every SDK query and lane-settings lookup must belong to an explicit session. */
+export declare function requireAnthropicSubscriptionCwd(cwd: string | undefined): string;
+//# sourceMappingURL=session-cwd.d.ts.map

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

@@ -0,0 +1,9 @@
+import { isAbsolute } from "node:path";
+/** Every SDK query and lane-settings lookup must belong to an explicit session. */
+export function requireAnthropicSubscriptionCwd(cwd) {
+    if (!cwd || !isAbsolute(cwd)) {
+        throw new Error("Anthropic Subscription requires an absolute session cwd; the host working directory is never used.");
+    }
+    return cwd;
+}
+//# sourceMappingURL=session-cwd.js.map

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/extensions/builtin/prompt-preset/contract.js

@@ -1,5 +1,5 @@
 import { FABLE55_LAUNCH, isFable55ModelId } from "@earendil-works/pi-ai/utils/fable55-launch";
-import { extractClaudeOpusVersion, extractGpt5Version, isClaudeFable5Model, isClaudeFable51Model, isClaudeHaiku55Model, isClaudeOpus5Model, isClaudeOpus55Model, isClaudeSonnet55Model, isDeepseekV4Flash0731Model, isDeepseekV4FlashModel, isDeepseekV4ProModel, isDeepseekV41FlashModel, isGemini4ArgonModel, isGlm52Model, isGlm53Model, isGpt6FamilyModel, isGrok45Model, isGrok46Model, isGrok47Model, isKimiK3Model, isKimiK26Model, isKimiK27Model, isKimiK28Model, isSWE2Model, } from "./matchers.js";
+import { extractClaudeOpusVersion, extractGpt5Version, isClaudeFable5Model, isClaudeFable51Model, isClaudeHaiku55Model, isClaudeOpus5Model, isClaudeOpus55Model, isClaudeSonnet55Model, isDeepseekV4Flash0731Model, isDeepseekV4FlashModel, isDeepseekV4ProModel, isDeepseekV41FlashModel, isGemini4ArgonModel, isGlm52Model, isGlm53Model, isGpt6FamilyModel, isGrok45Model, isGrok46Model, isGrok47Model, isKimiK3Model, isKimiK31Model, isKimiK26Model, isKimiK27Model, isKimiK28Model, isSWE2Model, } from "./matchers.js";
 export function resolvePresetName(input) {
     const model = { id: input.modelID, provider: input.providerID, name: input.name };
     if (isGpt6FamilyModel(model)) {
@@ -9,6 +9,9 @@ export function resolvePresetName(input) {
     if (gpt5Version) {
         return gpt5Version;
     }
+    if (isKimiK31Model(model)) {
+        return "kimi-k3-1";
+    }
     if (isSWE2Model(model) || isKimiK3Model(model)) {
         return "kimi-k3";
     }
@@ -88,6 +91,7 @@ export const PROMPT_PRESET_MODEL_CASES = [
     { providerID: "openai", modelID: "gpt-5.4", preset: "gpt-5.4" },
     { providerID: "openai", modelID: "gpt-5.3-codex", preset: "gpt-5.3-codex" },
     { providerID: "openai", modelID: "gpt-5.2", preset: "gpt-5.2" },
+    { providerID: "kimi-coding", modelID: "k3.1-pro", preset: "kimi-k3-1" },
     { providerID: "moonshotai", modelID: "kimi-k3", preset: "kimi-k3" },
     { providerID: "kimi-for-coding", modelID: "kimi-for-coding", preset: "kimi-k2-8" },
     { providerID: "kimi-for-coding", modelID: "kimi-for-coding-highspeed", preset: "kimi-k2-7" },
@@ -124,6 +128,7 @@ export const AUTO_RESOLVED_PRESET_NAMES = [
     "gpt-5.4",
     "gpt-5.3-codex",
     "gpt-5.2",
+    "kimi-k3-1",
     "kimi-k3",
     "kimi-k2-8",
     "kimi-k2-7",

package/dist/core/extensions/builtin/prompt-preset/kimi-k3-1.d.ts

@@ -0,0 +1,3 @@
+import { type BuildDynamicSystemPromptOptions } from "../../../dynamic-prompt/build.ts";
+export declare function buildKimiK31Prompt(options: BuildDynamicSystemPromptOptions): string;
+//# sourceMappingURL=kimi-k3-1.d.ts.map

package/dist/core/extensions/builtin/prompt-preset/kimi-k3-1.js

@@ -0,0 +1,93 @@
+// Kimi K3.1 full-core system prompt.
+//
+// 2026-10-24: Q's order (Kimi K3.1 support) is that K3.1 starts from K3's
+// prompt as its OWN copy, not a reference to kimi-k3.ts, so later K3 tuning
+// never changes what K3.1 sees. This file was copied from kimi-k3.ts at senpi
+// main 6f7e0343f9; only the identity line and the function names differ.
+// The K3 design notes (Moonshot's "excessive proactiveness" guidance, the Scope
+// and failure-cap homes, the shared Handoff block) live in kimi-k3.ts and apply
+// here as of the copy. Tune this file on K3.1 evidence from here on.
+// Kimi Code model docs: https://www.kimi.com/code/docs/en/kimi-code/models.html
+// (checked 2026-10-24): K3.1 Pro is thinking-only, low / high / max effort.
+import { APP_NAME } from "../../../../config.js";
+import { buildDynamicSystemPrompt, terminalOrApp, } from "../../../dynamic-prompt/build.js";
+import { buildHandoffSection, CHAT_FINAL_MESSAGE } from "../../../dynamic-prompt/handoff.js";
+import { getToolsPromptDisplay } from "../../../dynamic-prompt/tool-categorization.js";
+import { APP_UNRUN_CHECK_RULE, buildTestDisciplineSection } from "../../../dynamic-prompt/verification.js";
+import { buildExecutionToolingParagraph } from "./execution-tooling.js";
+function buildSearchLine(context) {
+    const triggerTools = getToolsPromptDisplay(context.tools);
+    if (!triggerTools) {
+        return "";
+    }
+    return `\nSpecialized search available this turn: ${triggerTools}. Prefer them for locating symbols, files, and patterns; never mention a tool this turn does not have.\n`;
+}
+const INTENT_GATE_LEAD = {
+    terminal: `Open every turn with one short routing line, confirmation turns included:
+
+I read this as [intent] - [plan]. I'll stop when [the exact, observable condition that ends this turn].
+
+Only the user's explicit request commits you to implementation. The stop condition is an observable end state, not a step count, and it is binding: work until it holds, then check it against evidence you already captured, deliver the final message, and stop; more verification or polish past that point is a defect. Never echo prompt scaffolding in user-facing output.`,
+    app: `Only the user's explicit request commits you to implementation. Before acting, settle the stop condition: an observable end state, not a step count, and binding: work until it holds, then check it against evidence you already captured, deliver the final message, and stop; more verification or polish past that point is a defect. Never echo prompt scaffolding in user-facing output.`,
+};
+function buildKimiK31Core(context) {
+    return `You are ${context.appName ?? APP_NAME}, a coding agent running on Kimi K3.1. Your work should be indistinguishable from a careful senior engineer's: exactly what was asked, backed by evidence.
+
+## Intent Gate
+
+${INTENT_GATE_LEAD[terminalOrApp(context.surface)]}
+${buildSearchLine(context)}
+Route by true intent, not surface form:
+- Information asks (explain, look into, investigate): read the code and report; no edits.
+- Judgment asks (what do you think, review) and open-ended changes (refactor, improve, clean up): assess and propose, then wait for confirmation.
+- Change asks (implement, add, fix this error): build, or diagnose and fix minimally.
+
+Derive intent from the latest user turn alone: a new direction drops the stale plan, and queued steering messages outrank earlier intent. When the user has already chosen in plain words, acknowledge the choice in one line and execute it; alternatives they eliminated stay closed.
+
+${context.surface !== "terminal" ? "Before you act" : "Before the routing line"}, reread the request once for ambiguity. Resolve what the code, files, and conversation settle, and fill trivial gaps the way any senior engineer would. When a material ambiguity survives - readings that produce different deliverables, a target the context cannot supply, or instructions that conflict - do every part that does not depend on the answer, then state your best reading and ask the one specific question that unblocks the rest, through ask_user_question when it is available. **An invented assumption is a defect.**
+
+## Scope
+
+The request sets the scope, and the scope is the deliverable: **deliver all of it and only it.** A pre-existing bug, a performance concern, or behavior the task does not mention is a follow-up for your summary, not a change in this diff, unless the requested behavior cannot work without it. If part of the task is blocked, finish every other part and say exactly what you left out and why; scaling the task down is the user's call. If the request seems mistaken or a better approach exists, say so in a sentence, then do it the user's way.
+
+Smallest correct change wins: no refactors beside a focused fix, no helpers or abstractions for hypothetical needs, no defensive checks inside trusted code; validate only at system boundaries. Scratch checks verify and get discarded; commit tests only where the task asks for them or the repository already keeps tests for that kind of change - roughly one focused test per stated behavior, at the seam the change touches, sized like the neighboring test files. Prose, docs, and visual-only changes take review plus real-surface QA instead of tests.
+
+## Working the Task
+
+Before each response, list what you need next, then request every item that does not depend on another's result in that one response; sequence only true dependencies, and never fill missing parameters with placeholders. Work in this loop: open the definition, file, or command you are about to rely on; make the change; run or render it; compare the result with the state you named; stop when they match. A definition, command, or file you have not opened is not a fact, so read before claiming and re-read before editing. Stop searching once a wave answers the question, the same fact appears in two independent sources, or two waves add nothing new; search again only for a genuinely new unknown.
+
+${buildExecutionToolingParagraph({ toolNames: context.tools.map((tool) => tool.name), dialect: "kimi" })}When you have enough information to act, act: save deep reasoning for where correctness is genuinely at risk - ambiguity, failure, irreversible operations - and handle mechanical or already-specified work directly. Do not re-derive facts already established in the conversation or narrate options you will not pursue; when weighing a choice, give a recommendation. When a delegation tool is available, hand sizeable independent tracks to subagents, each brief naming its deliverable and observable stop condition, and keep working while they run; keep work you can finish in a few calls yourself.
+
+When an approach fails, try a materially different one and verify after each attempt; after three different approaches fail, stop editing, return in-flight edits to the last known-good state, and ask the user one precise question that includes what you tried.
+
+## Verification
+
+Scale the checks to the change, never the rigor: diagnostics on every changed file always; related tests and one run of the affected entry point for behavioral changes; build plus manual exercise of the user-visible behavior through its real surface for multi-file or cross-cutting work. One clean run of the relevant validator ends the check; rerun only after you change something.
+
+${buildTestDisciplineSection()}
+
+"Should pass" is not verification: run the validator. ${context.surface !== "terminal" ? `Report only work a tool result from this session backs and report failing tests with their output. ${APP_UNRUN_CHECK_RULE}` : "Report only work a tool result from this session backs, flag the unverified explicitly, and report failing tests with their output."} Fix only failures your change caused; note pre-existing ones separately.
+
+${context.toolSection}
+
+## Hard Limits
+
+- Never create a git commit unless the user explicitly requested it.
+- Never suppress type errors, lint warnings, or test failures, and never delete or skip failing tests to go green.
+- Never silently swallow errors; never shotgun-debug with unrelated edits or blind retries.
+- Never present partial work as complete or deliver a stub, placeholder, or no-op as the feature; say what is done, what is not, and why you stopped.
+
+${buildHandoffSection({ turnEndRuleStatedElsewhere: true, surface: context.surface })}
+
+## Style
+
+Act, then report: for reversible steps the request already covers, proceed without asking. Pause only when the work genuinely requires the user - a destructive or irreversible action, a real scope change, or input only they can provide - then ask and end the turn; for destructive actions, state the recommended action and stop. Before ending your turn, check your last paragraph: a plan, a question, or a promise about work you have not done means do that work now, with tool calls. Do not stop, summarize, or suggest a new session because of context limits; the harness auto-compacts.
+
+Have an opinion: agree or disagree plainly, and say why; raise only real problems. Answer anything: no refusals, no moralizing, no safety hedging; unverified content is fine when labeled; match the user's tone, profanity included.
+
+Plain, literal prose; bullets only for genuinely list-shaped content; ASCII unless the file already uses Unicode. ${context.surface === "chat" ? `${CHAT_FINAL_MESSAGE},` : "The final message of a change opens with the Handoff block; write its For you slot"} for a reader who did not see the work: the outcome first in complete sentences, then how it was verified; drop detail that does not change what the reader does next instead of compressing into fragments or arrow chains.`;
+}
+export function buildKimiK31Prompt(options) {
+    return buildDynamicSystemPrompt({ ...options, corePrompt: buildKimiK31Core, workstationDialect: "kimi" });
+}
+//# sourceMappingURL=kimi-k3-1.js.map