@kenkaiiii/ggcoder 5.34.3 → 5.35.0

package/dist/core/mcp/session-elicitation-wiring.test.js

@@ -0,0 +1,138 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { SharedMcpPool } from "./shared-pool.js";
+/**
+ * Guards the wiring that makes one MCP process serve a whole window.
+ *
+ * A daemon window runs THREE sessions — the coding agent, Ken chat, and Ken
+ * autopilot — and every one of them connects to the same MCP servers. They only
+ * collapse onto a single child process if they agree on one thing: whether they
+ * can prompt the user.
+ *
+ * That is not a stylistic detail. A connection declares its elicitation
+ * capability once, at initialize, and servers use that declaration to decide
+ * whether to ask at all — so the pool cannot hand a prompting session and a
+ * headless one the same connection without lying to one of them. It keys them
+ * apart instead (see shared-pool.ts `keyFor`).
+ *
+ * The regression this file exists to catch: Ken's two factories originally
+ * omitted `onMcpElicit`, which made them headless, which split the pool, which
+ * produced a SECOND kencode-search process per daemon — measured, before the
+ * fix, as 2 processes for 6 sessions instead of 1. Nothing else failed, which is
+ * exactly why it needs a test.
+ */
+const APP_SIDECAR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../app-sidecar.ts");
+/**
+ * Extract the object literal passed to each `new AgentSession({ ... })`.
+ *
+ * Brace-balanced rather than regex-terminated: these literals contain nested
+ * callbacks with their own braces, so a non-greedy match would stop at the
+ * first inner `}` and silently "pass" by inspecting a fragment.
+ */
+function agentSessionOptionBlocks(source) {
+    const blocks = [];
+    const marker = "new AgentSession({";
+    let from = 0;
+    for (;;) {
+        const start = source.indexOf(marker, from);
+        if (start === -1)
+            return blocks;
+        let depth = 0;
+        let end = start + marker.length - 1;
+        for (; end < source.length; end++) {
+            const ch = source[end];
+            if (ch === "{")
+                depth++;
+            else if (ch === "}") {
+                depth--;
+                if (depth === 0)
+                    break;
+            }
+        }
+        blocks.push(source.slice(start, end + 1));
+        from = end + 1;
+    }
+}
+describe("app-sidecar wires every window session for elicitation", () => {
+    it("passes an elicit handler to all three session factories", async () => {
+        const source = await fs.readFile(APP_SIDECAR, "utf8");
+        const blocks = agentSessionOptionBlocks(source);
+        // Coding agent + Ken chat + Ken autopilot. If this count changes, a new
+        // session kind was added and it needs the same wiring decision made
+        // deliberately rather than inherited by accident.
+        expect(blocks).toHaveLength(3);
+        for (const block of blocks) {
+            // Either wired directly, or via the shared base options object that
+            // carries `onMcpElicit` for the coding session.
+            const wired = block.includes("onMcpElicit") || block.includes("...baseSessionOptions");
+            expect(wired).toBe(true);
+        }
+    });
+    /**
+     * Named factories specifically, so the assertion above cannot be satisfied by
+     * three blocks that happen to be the wrong three.
+     */
+    it("wires Ken chat and Ken autopilot specifically, not just the coding agent", async () => {
+        const source = await fs.readFile(APP_SIDECAR, "utf8");
+        for (const factory of ["ensureKenSession", "ensureKenAutoSession"]) {
+            const start = source.indexOf(`async function ${factory}(`);
+            expect(start, `${factory} should exist`).toBeGreaterThan(-1);
+            const [options] = agentSessionOptionBlocks(source.slice(start));
+            expect(options, `${factory} should construct an AgentSession`).toBeDefined();
+            expect(options).toContain("onMcpElicit");
+        }
+    });
+    /** `onMcpElicit` must still be the option AgentSession forwards to MCP. */
+    it("forwards that option into the MCP client as onElicit", async () => {
+        const agentSession = await fs.readFile(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../agent-session.ts"), "utf8");
+        expect(agentSession).toContain("onElicit: this.opts.onMcpElicit");
+    });
+});
+describe("pool keying for a window's three sessions", () => {
+    const config = { name: "kencode-search", command: "npx" };
+    function connector(spawns) {
+        spawns.count += 1;
+        return {
+            connect: async (target) => ({
+                name: target.name,
+                ok: true,
+                toolCount: 0,
+                tools: [],
+            }),
+            dispose: async () => { },
+        };
+    }
+    const handler = async () => ({ action: "cancel" });
+    /** The shipped arrangement: coding + Ken chat + Ken autopilot, all windowed. */
+    it("gives all three a single shared connection when each can prompt", async () => {
+        const pool = new SharedMcpPool();
+        const spawns = { count: 0 };
+        const coding = await pool.acquire(config, () => connector(spawns), { onElicit: handler });
+        const kenChat = await pool.acquire(config, () => connector(spawns), { onElicit: handler });
+        const kenAuto = await pool.acquire(config, () => connector(spawns), { onElicit: handler });
+        expect(spawns.count).toBe(1);
+        expect(pool.size).toBe(1);
+        expect(pool.refCount(config, { onElicit: handler })).toBe(3);
+        await coding.release();
+        await kenChat.release();
+        await kenAuto.release();
+        expect(pool.size).toBe(0);
+    });
+    /**
+     * The regression, reproduced: drop the handler from Ken's sessions and the
+     * pool splits — one connection for the coding agent, a second for the two
+     * headless Ken sessions. Two processes where there should be one.
+     */
+    it("splits into a second connection when Ken's sessions cannot prompt", async () => {
+        const pool = new SharedMcpPool();
+        const spawns = { count: 0 };
+        await pool.acquire(config, () => connector(spawns), { onElicit: handler });
+        await pool.acquire(config, () => connector(spawns), {});
+        await pool.acquire(config, () => connector(spawns), {});
+        expect(spawns.count).toBe(2);
+        expect(pool.size).toBe(2);
+    });
+});
+//# sourceMappingURL=session-elicitation-wiring.test.js.map

package/dist/core/mcp/session-elicitation-wiring.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-elicitation-wiring.test.js","sourceRoot":"","sources":["../../../src/core/mcp/session-elicitation-wiring.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAClC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,EAAE,aAAa,EAAwB,MAAM,kBAAkB,CAAC;AAGvE;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAC9B,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAC5C,sBAAsB,CACvB,CAAC;AAEF;;;;;;GAMG;AACH,SAAS,wBAAwB,CAAC,MAAc;IAC9C,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,MAAM,MAAM,GAAG,oBAAoB,CAAC;IACpC,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,SAAS,CAAC;QACR,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC3C,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,OAAO,MAAM,CAAC;QAChC,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,GAAG,GAAG,KAAK,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;QACpC,OAAO,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC;YAClC,MAAM,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YACvB,IAAI,EAAE,KAAK,GAAG;gBAAE,KAAK,EAAE,CAAC;iBACnB,IAAI,EAAE,KAAK,GAAG,EAAE,CAAC;gBACpB,KAAK,EAAE,CAAC;gBACR,IAAI,KAAK,KAAK,CAAC;oBAAE,MAAM;YACzB,CAAC;QACH,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QAC1C,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC;IACjB,CAAC;AACH,CAAC;AAED,QAAQ,CAAC,wDAAwD,EAAE,GAAG,EAAE;IACtE,EAAE,CAAC,yDAAyD,EAAE,KAAK,IAAI,EAAE;QACvE,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QACtD,MAAM,MAAM,GAAG,wBAAwB,CAAC,MAAM,CAAC,CAAC;QAEhD,wEAAwE;QACxE,oEAAoE;QACpE,kDAAkD;QAClD,MAAM,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAE/B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,oEAAoE;YACpE,gDAAgD;YAChD,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,uBAAuB,CAAC,CAAC;YACvF,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC,CAAC,CAAC;IAEH;;;OAGG;IACH,EAAE,CAAC,0EAA0E,EAAE,KAAK,IAAI,EAAE;QACxF,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QAEtD,KAAK,MAAM,OAAO,IAAI,CAAC,kBAAkB,EAAE,sBAAsB,CAAC,EAAE,CAAC;YACnE,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,kBAAkB,OAAO,GAAG,CAAC,CAAC;YAC3D,MAAM,CAAC,KAAK,EAAE,GAAG,OAAO,eAAe,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;YAC7D,MAAM,CAAC,OAAO,CAAC,GAAG,wBAAwB,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;YAChE,MAAM,CAAC,OAAO,EAAE,GAAG,OAAO,mCAAmC,CAAC,CAAC,WAAW,EAAE,CAAC;YAC7E,MAAM,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,2EAA2E;IAC3E,EAAE,CAAC,sDAAsD,EAAE,KAAK,IAAI,EAAE;QACpE,MAAM,YAAY,GAAG,MAAM,EAAE,CAAC,QAAQ,CACpC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,qBAAqB,CAAC,EACjF,MAAM,CACP,CAAC;QACF,MAAM,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,iCAAiC,CAAC,CAAC;IACpE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,2CAA2C,EAAE,GAAG,EAAE;IACzD,MAAM,MAAM,GAAoB,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAE3E,SAAS,SAAS,CAAC,MAAyB;QAC1C,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;QAClB,OAAO;YACL,OAAO,EAAE,KAAK,EAAE,MAAM,EAA6B,EAAE,CAAC,CAAC;gBACrD,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,EAAE,EAAE,IAAI;gBACR,SAAS,EAAE,CAAC;gBACZ,KAAK,EAAE,EAAE;aACV,CAAC;YACF,OAAO,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC;SACxB,CAAC;IACJ,CAAC;IAED,MAAM,OAAO,GAAqB,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IAErE,gFAAgF;IAChF,EAAE,CAAC,iEAAiE,EAAE,KAAK,IAAI,EAAE;QAC/E,MAAM,IAAI,GAAG,IAAI,aAAa,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;QAE5B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;QAC1F,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;QAC3F,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;QAE3F,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC7B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC1B,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAE7D,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;QACvB,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;QACxB,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;QACxB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC5B,CAAC,CAAC,CAAC;IAEH;;;;OAIG;IACH,EAAE,CAAC,mEAAmE,EAAE,KAAK,IAAI,EAAE;QACjF,MAAM,IAAI,GAAG,IAAI,aAAa,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;QAE5B,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;QAC3E,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC;QACxD,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC;QAExD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC7B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC5B,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/core/mcp/shared-pool.d.ts

@@ -0,0 +1,158 @@
+import type { McpCatalogCache } from "./catalog-cache.js";
+import type { MCPConnectResult, MCPElicitHandler } from "./client.js";
+import type { MCPServerConfig } from "./types.js";
+/**
+ * Process-wide pool of MCP connections that are safe for every session to
+ * share, so one stdio child serves the whole daemon instead of one per session.
+ *
+ * The daemon hosts many `AgentSession`s at once — one per window, plus Ken chat
+ * and Ken autopilot within each window — and each used to spawn its own child
+ * for every configured stdio server. For a stateless proxy such as
+ * `kencode-search` that is N identical processes doing identical work: measured
+ * at 7 live children, ~43 MB each, purely duplicated.
+ *
+ * Sharing is the DEFAULT for stdio servers. A stdio connection has nothing
+ * session-specific in it: every one is spawned with `cwd: os.homedir()`, so a
+ * server cannot observe which project the caller is in even in principle, and
+ * the pool key hashes command/args/env, so two configs differing in any way
+ * that changes behaviour already get their own process.
+ *
+ * The two concerns that sharing has to answer are handled rather than avoided:
+ *
+ *  - **Per-caller state.** Multiplexing many sessions over one connection would
+ *    let a server that remembers "the current project" leak one session's
+ *    context into another's answers. That is invisible from a config, so it
+ *    stays a declaration: `shared: false` opts such a server out and it keeps a
+ *    private child per session.
+ *  - **User prompting.** "Ask the user" has to name a window, so elicitation is
+ *    routed to the session with a tool call in flight (see `dispatchElicit`),
+ *    and cancelled rather than guessed when that is ambiguous. Because a
+ *    connection declares its elicitation capability once at initialize, callers
+ *    that can prompt and callers that cannot are keyed apart.
+ *
+ * The pool deliberately knows nothing about `MCPClientManager` — the connection
+ * is supplied as a `SharedConnector`. That keeps the dependency pointing one
+ * way (client → pool), and lets tests exercise refcounting against a fake.
+ */
+/**
+ * Is this server shared across sessions in this process?
+ *
+ * Sharing is the DEFAULT for stdio servers, because a stdio MCP connection has
+ * nothing session-specific in it: every one is spawned with `cwd:
+ * os.homedir()` (see client.ts), so a server cannot observe which project the
+ * caller is in even in principle, and the pool key hashes command/args/env, so
+ * two configs that differ in any way that changes behaviour already get their
+ * own process. What remained — elicitation, the one genuinely per-window
+ * concern — is routed back to the calling session rather than dropped.
+ *
+ * `shared: false` opts a server out. That exists for a server that keeps
+ * per-CALLER state across requests (a cursor, a selected workspace, an open
+ * handle), where multiplexing two sessions over one connection would let one
+ * session's state change the other's answers. That property is invisible from
+ * a config, so it stays a declaration rather than a guess.
+ *
+ * HTTP servers are never shared. Sharing exists to collapse duplicate child
+ * PROCESSES and an HTTP server has none, so it would save nothing while adding
+ * real risk: OAuth tokens and `Mcp-Session-Id` are per-connection, and pooling
+ * them would cross one session's authenticated identity with another's.
+ */
+export declare function isShareableServer(config: MCPServerConfig): boolean;
+/** One pooled connection, owned by the pool and torn down at zero references. */
+export interface SharedConnector {
+    connect(config: MCPServerConfig): Promise<MCPConnectResult>;
+    dispose(): Promise<void>;
+}
+export interface SharedAcquireOptions {
+    catalogCache?: McpCatalogCache;
+    modernProtocol?: boolean;
+    /** Invoked by the connection when its server exits on its own. */
+    onClosed?: () => void;
+    /**
+     * The acquiring session's elicitation handler. Invoked only while that
+     * session has a tool call in flight on this connection (see `dispatchElicit`).
+     */
+    onElicit?: MCPElicitHandler;
+}
+/**
+ * Builds the underlying connection the first time a config is pooled. The pool
+ * supplies its own `onElicit`: a dispatcher that routes each request to the
+ * session that asked for it, instead of any one session's handler.
+ */
+export type SharedConnectorFactory = (opts: SharedAcquireOptions) => SharedConnector;
+/** A session's claim on a shared connection. `release` is idempotent. */
+export interface SharedServerHandle {
+    result: MCPConnectResult;
+    release: () => Promise<void>;
+    /**
+     * Mark a tool call from this session as in flight, returning the function
+     * that ends it. Elicitation arriving during the call is routed to this
+     * session's window.
+     */
+    beginCall: () => () => void;
+}
+export declare class SharedMcpPool {
+    private entries;
+    /**
+     * Key on everything that changes what the connection IS, not merely what it
+     * exposes: `hashServerConfig` covers command/args/env/url/transport, the name
+     * keeps two differently-named aliases apart, and the protocol flag is
+     * included because it changes the handshake — a session that opted into the
+     * modern revision must not be handed a legacy-negotiated connection.
+     *
+     * Whether the caller can prompt is part of the key for the same reason. A
+     * connection declares its elicitation capability once, at initialize, and
+     * servers use that declaration to decide whether to ask at all — so a
+     * headless caller (CLI, JSON mode) must not be handed a connection that
+     * promises prompting nobody can deliver, and a windowed caller must not be
+     * handed one that forecloses it. Splitting the key keeps each connection's
+     * declaration honest; in practice a daemon's sessions are uniformly windowed
+     * and the CLI's uniformly headless, so this still means one process.
+     */
+    private keyFor;
+    /**
+     * Get-or-create the shared connection for `config` and claim a reference.
+     *
+     * Concurrent acquirers share one connect attempt: the entry and its pending
+     * promise are registered synchronously before the first `await`, so a second
+     * caller arriving mid-connect joins the in-flight attempt instead of spawning
+     * a rival child.
+     */
+    acquire(config: MCPServerConfig, createConnector: SharedConnectorFactory, opts?: SharedAcquireOptions): Promise<SharedServerHandle>;
+    /**
+     * Drop a connection whose server died, without touching its callers' claims.
+     *
+     * The entry is unregistered but NOT disposed: its transport is already gone,
+     * and the sessions still holding handles will release them normally on their
+     * own dispose. Guarded on identity so a death notice arriving after the entry
+     * was already replaced cannot evict its successor.
+     */
+    private evictDead;
+    /**
+     * Route an elicitation to the session that provoked it.
+     *
+     * A shared connection is held by many windows, so "ask the user" has to name
+     * one. Elicitation only happens while a server is servicing a tool call, so
+     * the session with a call in flight IS the one whose window should show the
+     * form. When that is ambiguous — no call in flight, or two windows calling
+     * the same server at once — the request is cancelled rather than guessed:
+     * showing one project's consent form in another project's window would be a
+     * worse failure than a declined prompt, and `cancel` is exactly what a server
+     * already handles for a user who dismissed the dialog.
+     */
+    private dispatchElicit;
+    /**
+     * Drop one session's claim. At zero the entry is unregistered SYNCHRONOUSLY
+     * before the disposal await, so an `acquire` landing mid-teardown builds a
+     * fresh connection instead of receiving a client that is already closing.
+     */
+    private releaseKey;
+    /** Live shared connections. Test/diagnostic use. */
+    get size(): number;
+    /** Reference count for one config, or 0 when nothing is pooled for it. */
+    refCount(config: MCPServerConfig, opts?: SharedAcquireOptions): number;
+    /** Tear every shared connection down regardless of refs (process shutdown). */
+    disposeAll(): Promise<void>;
+}
+/** The daemon-wide pool. One per process, which is exactly the sharing scope. */
+export declare const sharedMcpPool: SharedMcpPool;
+//# sourceMappingURL=shared-pool.d.ts.map

package/dist/core/mcp/shared-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-pool.d.ts","sourceRoot":"","sources":["../../../src/core/mcp/shared-pool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAElE;AAED,iFAAiF;AACjF,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC5D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,EAAE,eAAe,CAAC;IAC/B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CAC7B;AAED;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE,oBAAoB,KAAK,eAAe,CAAC;AAErF,yEAAyE;AACzE,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B;;;;OAIG;IACH,SAAS,EAAE,MAAM,MAAM,IAAI,CAAC;CAC7B;AAgBD,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAgC;IAE/C;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,MAAM;IAMd;;;;;;;OAOG;IACG,OAAO,CACX,MAAM,EAAE,eAAe,EACvB,eAAe,EAAE,sBAAsB,EACvC,IAAI,GAAE,oBAAyB,GAC9B,OAAO,CAAC,kBAAkB,CAAC;IAwE9B;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAMjB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,cAAc;IActB;;;;OAIG;YACW,UAAU;IAUxB,oDAAoD;IACpD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,eAAe,EAAE,IAAI,GAAE,oBAAyB,GAAG,MAAM;IAI1E,+EAA+E;IACzE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAKlC;AAED,iFAAiF;AACjF,eAAO,MAAM,aAAa,eAAsB,CAAC"}

package/dist/core/mcp/shared-pool.js

@@ -0,0 +1,235 @@
+import { hashServerConfig } from "./catalog-cache.js";
+import { log } from "../logger.js";
+/**
+ * Process-wide pool of MCP connections that are safe for every session to
+ * share, so one stdio child serves the whole daemon instead of one per session.
+ *
+ * The daemon hosts many `AgentSession`s at once — one per window, plus Ken chat
+ * and Ken autopilot within each window — and each used to spawn its own child
+ * for every configured stdio server. For a stateless proxy such as
+ * `kencode-search` that is N identical processes doing identical work: measured
+ * at 7 live children, ~43 MB each, purely duplicated.
+ *
+ * Sharing is the DEFAULT for stdio servers. A stdio connection has nothing
+ * session-specific in it: every one is spawned with `cwd: os.homedir()`, so a
+ * server cannot observe which project the caller is in even in principle, and
+ * the pool key hashes command/args/env, so two configs differing in any way
+ * that changes behaviour already get their own process.
+ *
+ * The two concerns that sharing has to answer are handled rather than avoided:
+ *
+ *  - **Per-caller state.** Multiplexing many sessions over one connection would
+ *    let a server that remembers "the current project" leak one session's
+ *    context into another's answers. That is invisible from a config, so it
+ *    stays a declaration: `shared: false` opts such a server out and it keeps a
+ *    private child per session.
+ *  - **User prompting.** "Ask the user" has to name a window, so elicitation is
+ *    routed to the session with a tool call in flight (see `dispatchElicit`),
+ *    and cancelled rather than guessed when that is ambiguous. Because a
+ *    connection declares its elicitation capability once at initialize, callers
+ *    that can prompt and callers that cannot are keyed apart.
+ *
+ * The pool deliberately knows nothing about `MCPClientManager` — the connection
+ * is supplied as a `SharedConnector`. That keeps the dependency pointing one
+ * way (client → pool), and lets tests exercise refcounting against a fake.
+ */
+/**
+ * Is this server shared across sessions in this process?
+ *
+ * Sharing is the DEFAULT for stdio servers, because a stdio MCP connection has
+ * nothing session-specific in it: every one is spawned with `cwd:
+ * os.homedir()` (see client.ts), so a server cannot observe which project the
+ * caller is in even in principle, and the pool key hashes command/args/env, so
+ * two configs that differ in any way that changes behaviour already get their
+ * own process. What remained — elicitation, the one genuinely per-window
+ * concern — is routed back to the calling session rather than dropped.
+ *
+ * `shared: false` opts a server out. That exists for a server that keeps
+ * per-CALLER state across requests (a cursor, a selected workspace, an open
+ * handle), where multiplexing two sessions over one connection would let one
+ * session's state change the other's answers. That property is invisible from
+ * a config, so it stays a declaration rather than a guess.
+ *
+ * HTTP servers are never shared. Sharing exists to collapse duplicate child
+ * PROCESSES and an HTTP server has none, so it would save nothing while adding
+ * real risk: OAuth tokens and `Mcp-Session-Id` are per-connection, and pooling
+ * them would cross one session's authenticated identity with another's.
+ */
+export function isShareableServer(config) {
+    return config.shared !== false && Boolean(config.command);
+}
+export class SharedMcpPool {
+    entries = new Map();
+    /**
+     * Key on everything that changes what the connection IS, not merely what it
+     * exposes: `hashServerConfig` covers command/args/env/url/transport, the name
+     * keeps two differently-named aliases apart, and the protocol flag is
+     * included because it changes the handshake — a session that opted into the
+     * modern revision must not be handed a legacy-negotiated connection.
+     *
+     * Whether the caller can prompt is part of the key for the same reason. A
+     * connection declares its elicitation capability once, at initialize, and
+     * servers use that declaration to decide whether to ask at all — so a
+     * headless caller (CLI, JSON mode) must not be handed a connection that
+     * promises prompting nobody can deliver, and a windowed caller must not be
+     * handed one that forecloses it. Splitting the key keeps each connection's
+     * declaration honest; in practice a daemon's sessions are uniformly windowed
+     * and the CLI's uniformly headless, so this still means one process.
+     */
+    keyFor(config, opts) {
+        const era = opts.modernProtocol ? "modern" : "legacy";
+        const prompting = opts.onElicit ? "interactive" : "headless";
+        return `${config.name}\u0000${hashServerConfig(config)}\u0000${era}\u0000${prompting}`;
+    }
+    /**
+     * Get-or-create the shared connection for `config` and claim a reference.
+     *
+     * Concurrent acquirers share one connect attempt: the entry and its pending
+     * promise are registered synchronously before the first `await`, so a second
+     * caller arriving mid-connect joins the in-flight attempt instead of spawning
+     * a rival child.
+     */
+    async acquire(config, createConnector, opts = {}) {
+        const key = this.keyFor(config, opts);
+        const caller = { onElicit: opts.onElicit, activeCalls: 0 };
+        let entry = this.entries.get(key);
+        if (!entry) {
+            // Built before the connector so the dispatcher can close over it: the
+            // connection needs an elicit handler at construction time, but which
+            // session that handler defers to is only knowable per request.
+            const created = {
+                connector: undefined,
+                callers: new Set(),
+                connected: undefined,
+            };
+            // A headless entry gets no dispatcher at all, so its connection declares
+            // no elicitation capability — matching what its callers can actually do.
+            created.connector = createConnector({
+                ...opts,
+                onElicit: opts.onElicit ? this.dispatchElicit(created) : undefined,
+                // A pooled child that dies would otherwise be handed to every session
+                // in the daemon, and to every session that connects later — one crash
+                // becoming a permanent outage. Unregister it so the next acquire builds
+                // a fresh connection. Sessions already holding it still see their calls
+                // fail, which is what a dead server means; they recover on reconnect.
+                onClosed: () => this.evictDead(key, created),
+            });
+            created.connected = created.connector.connect(config);
+            entry = created;
+            this.entries.set(key, entry);
+            log("INFO", "mcp", `Opening shared MCP connection for "${config.name}"`);
+        }
+        entry.callers.add(caller);
+        const claimed = entry;
+        let result;
+        try {
+            result = await claimed.connected;
+        }
+        catch (err) {
+            // The connector reports failure in-band, so a throw is unexpected. Drop
+            // the claim so a broken entry cannot outlive it.
+            await this.releaseKey(key, claimed, caller);
+            throw err;
+        }
+        if (!result.ok) {
+            // A failed connection is not worth pooling: keeping it would make every
+            // later session inherit this failure with no chance to retry. Release the
+            // claim (tearing the entry down at zero) and report the failure as-is.
+            await this.releaseKey(key, claimed, caller);
+            return { result, release: async () => { }, beginCall: () => () => { } };
+        }
+        let released = false;
+        return {
+            result,
+            release: async () => {
+                if (released)
+                    return;
+                released = true;
+                await this.releaseKey(key, claimed, caller);
+            },
+            beginCall: () => {
+                caller.activeCalls += 1;
+                let ended = false;
+                return () => {
+                    if (ended)
+                        return;
+                    ended = true;
+                    caller.activeCalls = Math.max(0, caller.activeCalls - 1);
+                };
+            },
+        };
+    }
+    /**
+     * Drop a connection whose server died, without touching its callers' claims.
+     *
+     * The entry is unregistered but NOT disposed: its transport is already gone,
+     * and the sessions still holding handles will release them normally on their
+     * own dispose. Guarded on identity so a death notice arriving after the entry
+     * was already replaced cannot evict its successor.
+     */
+    evictDead(key, entry) {
+        if (this.entries.get(key) !== entry)
+            return;
+        this.entries.delete(key);
+        log("WARN", "mcp", "shared MCP connection died; next session will reconnect");
+    }
+    /**
+     * Route an elicitation to the session that provoked it.
+     *
+     * A shared connection is held by many windows, so "ask the user" has to name
+     * one. Elicitation only happens while a server is servicing a tool call, so
+     * the session with a call in flight IS the one whose window should show the
+     * form. When that is ambiguous — no call in flight, or two windows calling
+     * the same server at once — the request is cancelled rather than guessed:
+     * showing one project's consent form in another project's window would be a
+     * worse failure than a declined prompt, and `cancel` is exactly what a server
+     * already handles for a user who dismissed the dialog.
+     */
+    dispatchElicit(entry) {
+        return async (request) => {
+            const candidates = [...entry.callers].filter((c) => c.activeCalls > 0 && c.onElicit);
+            if (candidates.length !== 1) {
+                log("WARN", "mcp", "cancelled a shared-server elicitation with no unique caller", {
+                    server: request.server,
+                    candidates: String(candidates.length),
+                });
+                return { action: "cancel" };
+            }
+            return candidates[0].onElicit(request);
+        };
+    }
+    /**
+     * Drop one session's claim. At zero the entry is unregistered SYNCHRONOUSLY
+     * before the disposal await, so an `acquire` landing mid-teardown builds a
+     * fresh connection instead of receiving a client that is already closing.
+     */
+    async releaseKey(key, entry, caller) {
+        if (!entry.callers.delete(caller))
+            return;
+        if (entry.callers.size > 0)
+            return;
+        // Only unregister when this entry is still the live one for the key: a
+        // teardown racing a fresh acquire must not evict its replacement.
+        if (this.entries.get(key) === entry)
+            this.entries.delete(key);
+        await entry.connector.dispose();
+        log("INFO", "mcp", "Closed shared MCP connection (last session released it)");
+    }
+    /** Live shared connections. Test/diagnostic use. */
+    get size() {
+        return this.entries.size;
+    }
+    /** Reference count for one config, or 0 when nothing is pooled for it. */
+    refCount(config, opts = {}) {
+        return this.entries.get(this.keyFor(config, opts))?.callers.size ?? 0;
+    }
+    /** Tear every shared connection down regardless of refs (process shutdown). */
+    async disposeAll() {
+        const entries = [...this.entries.values()];
+        this.entries.clear();
+        await Promise.all(entries.map((entry) => entry.connector.dispose()));
+    }
+}
+/** The daemon-wide pool. One per process, which is exactly the sharing scope. */
+export const sharedMcpPool = new SharedMcpPool();
+//# sourceMappingURL=shared-pool.js.map

package/dist/core/mcp/shared-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-pool.js","sourceRoot":"","sources":["../../../src/core/mcp/shared-pool.ts"],"names":[],"mappings":"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"}

package/dist/core/mcp/shared-pool.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shared-pool.test.d.ts.map

package/dist/core/mcp/shared-pool.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-pool.test.d.ts","sourceRoot":"","sources":["../../../src/core/mcp/shared-pool.test.ts"],"names":[],"mappings":""}