howtofixcli 0.7.13 → 0.7.15

package/dist/lsp.js

@@ -1,429 +0,0 @@
-/**
- * LSP over stdio: `Content-Length` framing, a stream-driven client, the server
- * table, and `askLsp`.
- *
- * Client lifecycle is process-wide: one client per server command, shared by
- * every session and subagent — two agents on one TS project must not spawn two
- * `typescript-language-server`s. Clients are killed when the main session
- * disposes (`disposeAllLsp` from `openSession` in `session.ts`) and on process
- * `exit`, which is registered here. Because the pool is keyed by command, the
- * first spawn's root wins for the process; HowToFix runs one project per
- * process, so that is the common case by design.
- */
-import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { delimiter, isAbsolute, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-export function encodeMessage(message) {
-    const body = JSON.stringify(message);
-    return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
-}
-/**
- * The largest frame a language server may send.
- *
- * A server that announces a body this big is not sending a message, it is
- * desynchronised or hostile. Waiting for the rest of it would grow the buffer
- * until the process dies, so the frame is refused instead.
- */
-export const MAX_FRAME_BYTES = 32 * 1024 * 1024;
-export function decodeMessages(buffer) {
-    const messages = [];
-    let offset = 0;
-    while (offset < buffer.length) {
-        const headerEnd = buffer.indexOf("\r\n\r\n", offset);
-        if (headerEnd === -1)
-            break;
-        const header = buffer.subarray(offset, headerEnd).toString("utf8");
-        const lengthMatch = /Content-Length:\s*(\d+)/i.exec(header);
-        if (!lengthMatch)
-            break;
-        const length = Number(lengthMatch[1]);
-        if (!Number.isSafeInteger(length) || length < 0 || length > MAX_FRAME_BYTES) {
-            throw new Error(`lsp frame of ${lengthMatch[1]} bytes refused`);
-        }
-        const bodyStart = headerEnd + 4;
-        const bodyEnd = bodyStart + length;
-        if (bodyEnd > buffer.length)
-            break;
-        const body = buffer.subarray(bodyStart, bodyEnd).toString("utf8");
-        // One malformed frame is skipped, not fatal: a language server that emits a
-        // bad message must not take the CLI down in the middle of a session.
-        try {
-            const parsed = JSON.parse(body);
-            if (parsed && typeof parsed === "object")
-                messages.push(parsed);
-        }
-        catch {
-            // dropped on purpose; the stream stays aligned because the length was read
-        }
-        offset = bodyEnd;
-    }
-    return { messages, rest: buffer.subarray(offset) };
-}
-export class LspClient {
-    io;
-    nextId = 1;
-    pending = new Map();
-    buffer = Buffer.alloc(0);
-    broken = null;
-    opened = new Set();
-    diagnosticsByUri = new Map();
-    diagnosticsWaiters = new Map();
-    constructor(io) {
-        this.io = io;
-        io.stdout.on("data", (chunk) => {
-            if (this.broken)
-                return;
-            this.buffer = Buffer.concat([this.buffer, chunk]);
-            let decoded;
-            try {
-                decoded = decodeMessages(this.buffer);
-            }
-            catch (error) {
-                // A stream we cannot trust is dropped whole. Keeping it would let a
-                // desynchronised server grow the buffer without bound, and every
-                // request queued behind it would wait out its timeout for nothing.
-                this.buffer = Buffer.alloc(0);
-                this.fail(error instanceof Error ? error : new Error(String(error)));
-                return;
-            }
-            this.buffer = decoded.rest;
-            for (const message of decoded.messages)
-                this.dispatch(message);
-        });
-        // A server that dies leaves the pipe behind: the next write raises EPIPE on
-        // the stream, and with no listener that becomes an uncaught exception and
-        // takes the CLI down. Failing the client turns it into a normal error.
-        io.stdin.on("error", (error) => {
-            this.fail(error instanceof Error ? error : new Error(String(error)));
-        });
-    }
-    /** Mark the stream unusable and answer every queued request with the reason. */
-    fail(error) {
-        if (this.broken)
-            return;
-        this.broken = error;
-        for (const [id, waiter] of this.pending) {
-            this.pending.delete(id);
-            waiter.reject(error);
-        }
-    }
-    dispatch(message) {
-        if (message.method === "textDocument/publishDiagnostics") {
-            const params = message.params;
-            if (params?.uri) {
-                const list = Array.isArray(params.diagnostics) ? params.diagnostics : [];
-                this.diagnosticsByUri.set(params.uri, list);
-                const waiters = this.diagnosticsWaiters.get(params.uri);
-                if (waiters) {
-                    this.diagnosticsWaiters.delete(params.uri);
-                    for (const waiter of waiters)
-                        waiter(list);
-                }
-            }
-            return;
-        }
-        if (message.id === undefined)
-            return; // other notifications ignored in v1
-        const waiter = this.pending.get(Number(message.id));
-        if (!waiter)
-            return;
-        this.pending.delete(Number(message.id));
-        if (message.error)
-            waiter.reject(new Error(message.error.message));
-        else
-            waiter.resolve(message.result);
-    }
-    request(method, params, timeoutMs = 10_000) {
-        if (this.broken)
-            return Promise.reject(this.broken);
-        const id = this.nextId++;
-        const payload = encodeMessage({ jsonrpc: "2.0", id, method, params });
-        const { promise, resolve, reject } = Promise.withResolvers();
-        const timer = setTimeout(() => {
-            this.pending.delete(id);
-            reject(new Error(`lsp ${method} timed out`));
-        }, timeoutMs);
-        this.pending.set(id, {
-            resolve: (value) => {
-                clearTimeout(timer);
-                resolve(value);
-            },
-            reject: (error) => {
-                clearTimeout(timer);
-                reject(error);
-            },
-        });
-        try {
-            this.io.stdin.write(payload);
-        }
-        catch (error) {
-            // A pipe that is already gone throws here instead of emitting; the caller
-            // must see a failure, not a request that waits out its timeout.
-            const reason = error instanceof Error ? error : new Error(String(error));
-            this.pending.delete(id);
-            clearTimeout(timer);
-            reject(reason);
-            this.fail(reason);
-        }
-        return promise;
-    }
-    notify(method, params) {
-        if (this.broken)
-            return;
-        try {
-            this.io.stdin.write(encodeMessage({ jsonrpc: "2.0", method, params }));
-        }
-        catch (error) {
-            // Notifications have no caller waiting, so a dead pipe would surface as an
-            // uncaught exception from a fire-and-forget write. Record it instead.
-            this.fail(error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    async initialize() {
-        await this.request("initialize", {
-            processId: null,
-            rootUri: pathToFileURL(this.io.root).toString(),
-            capabilities: { textDocument: { hover: {}, definition: {}, references: {}, documentSymbol: {}, publishDiagnostics: {} } },
-        });
-        this.notify("initialized", {});
-    }
-    // Positions are 0-based on the wire; callers that take editor-style 1-based lines subtract one before calling.
-    async hover(file, line, character) {
-        const result = (await this.request("textDocument/hover", {
-            textDocument: { uri: pathToFileURL(file).toString() },
-            position: { line, character },
-        }));
-        return result?.contents?.value;
-    }
-    async definition(file, line, character) {
-        const result = (await this.request("textDocument/definition", {
-            textDocument: { uri: pathToFileURL(file).toString() },
-            position: { line, character },
-        }));
-        if (Array.isArray(result))
-            return result[0];
-        return result ?? undefined;
-    }
-    async references(file, line, character) {
-        const result = await this.request("textDocument/references", {
-            textDocument: { uri: pathToFileURL(file).toString() },
-            position: { line, character },
-            context: { includeDeclaration: true },
-        });
-        return Array.isArray(result) ? result : [];
-    }
-    async documentSymbols(file) {
-        const result = await this.request("textDocument/documentSymbol", {
-            textDocument: { uri: pathToFileURL(file).toString() },
-        });
-        return Array.isArray(result) ? result : [];
-    }
-    /**
-     * Stored `publishDiagnostics` for the file, waiting up to `timeoutMs` for the
-     * first publish. A server that never publishes gets `[]`, never a hang.
-     */
-    diagnostics(file, timeoutMs = 2_000) {
-        const uri = pathToFileURL(file).toString();
-        const stored = this.diagnosticsByUri.get(uri);
-        if (stored)
-            return Promise.resolve(stored);
-        const { promise, resolve } = Promise.withResolvers();
-        const timer = setTimeout(() => {
-            const waiters = this.diagnosticsWaiters.get(uri);
-            if (waiters) {
-                this.diagnosticsWaiters.delete(uri);
-                for (const waiter of waiters)
-                    waiter(this.diagnosticsByUri.get(uri) ?? []);
-            }
-        }, timeoutMs);
-        const waiters = this.diagnosticsWaiters.get(uri) ?? [];
-        waiters.push((value) => {
-            clearTimeout(timer);
-            resolve(value);
-        });
-        this.diagnosticsWaiters.set(uri, waiters);
-        return promise;
-    }
-    async ensureOpen(file, text, languageId) {
-        const uri = pathToFileURL(file).toString();
-        if (this.opened.has(uri))
-            return;
-        this.notify("textDocument/didOpen", {
-            textDocument: { uri, languageId, version: 1, text },
-        });
-        this.opened.add(uri);
-    }
-    dispose() {
-        for (const [id, waiter] of this.pending) {
-            waiter.reject(new Error("lsp client disposed"));
-            this.pending.delete(id);
-        }
-        // Flush diagnostic waiters so a dispose mid-query answers [] instead of
-        // leaving the timer to fire into a dead client.
-        for (const [uri, waiters] of this.diagnosticsWaiters) {
-            const stored = this.diagnosticsByUri.get(uri) ?? [];
-            this.diagnosticsWaiters.delete(uri);
-            for (const waiter of waiters)
-                waiter(stored);
-        }
-    }
-}
-export const SERVERS = [
-    {
-        command: "typescript-language-server",
-        args: ["--stdio"],
-        languageId: "typescript",
-        match: (file) => /\.(ts|tsx|js|jsx|mts|cts)$/.test(file),
-    },
-    { command: "rust-analyzer", args: [], languageId: "rust", match: (file) => file.endsWith(".rs") },
-    { command: "gopls", args: [], languageId: "go", match: (file) => file.endsWith(".go") },
-    { command: "pylsp", args: [], languageId: "python", match: (file) => file.endsWith(".py") },
-];
-export function specFor(file) {
-    return SERVERS.find((spec) => spec.match(file));
-}
-/** Process-wide, keyed by server command (see the header): every session and
- *  subagent shares one server per language. */
-const clients = new Map();
-async function clientFor(spec, root) {
-    const existing = clients.get(spec.command);
-    if (existing) {
-        await existing.ready;
-        return existing.client;
-    }
-    // cwd is the session's project root, not the file's directory: gopls and
-    // rust-analyzer want the module root, and `rootUri` is set from it too.
-    const child = spawn(spec.command, spec.args, { cwd: root, stdio: ["pipe", "pipe", "ignore"] });
-    const stdin = child.stdin;
-    const stdout = child.stdout;
-    if (!stdin || !stdout) {
-        child.kill();
-        throw new Error(`${spec.command}: stdio pipes unavailable`);
-    }
-    const client = new LspClient({ stdin, stdout, root });
-    // A spawn that fails after the PATH check (EACCES, a stale symlink) must not
-    // crash the process on an unhandled 'error' event or leave a corpse pooled.
-    child.on("error", () => {
-        const pooled = clients.get(spec.command);
-        if (pooled?.child === child)
-            clients.delete(spec.command);
-        pooled?.client.dispose();
-    });
-    // A server that dies on its own has to leave the pool, or every later query
-    // for this language talks to a client whose pipes are gone and waits out a
-    // timeout before failing.
-    child.on("exit", () => {
-        const pooled = clients.get(spec.command);
-        if (pooled?.child === child)
-            clients.delete(spec.command);
-        client.dispose();
-    });
-    const ready = client.initialize().catch((error) => {
-        clients.delete(spec.command);
-        child.kill();
-        throw error;
-    });
-    clients.set(spec.command, { client, child, ready });
-    await ready;
-    return client;
-}
-/**
- * Kill every pooled server. Called from the main session's `dispose`
- * (`openSession` in `session.ts`) and on process `exit` — subagent sessions
- * share the pool, so only the process-wide teardown kills it (see the header).
- */
-export function disposeAllLsp() {
-    for (const [command, pooled] of clients) {
-        clients.delete(command);
-        pooled.client.dispose();
-        pooled.child.kill();
-    }
-}
-process.on("exit", disposeAllLsp);
-const SEVERITY_NAME = { 1: "error", 2: "warning", 3: "info", 4: "hint" };
-function locationText(location) {
-    let file = location.uri;
-    try {
-        file = fileURLToPath(location.uri);
-    }
-    catch {
-        // Not a file:// uri — a workspace or virtual scheme; show it as it came.
-    }
-    const start = location.range?.start;
-    return start ? `${file}:${start.line + 1}:${start.character + 1}` : file;
-}
-function symbolRows(symbols, depth = 0) {
-    const rows = [];
-    for (const symbol of symbols) {
-        const line = (symbol.selectionRange ?? symbol.range)?.start.line;
-        rows.push(`${"  ".repeat(depth)}${symbol.name}${line === undefined ? "" : ` :${line + 1}`}`);
-        if (symbol.children)
-            rows.push(...symbolRows(symbol.children, depth + 1));
-    }
-    return rows;
-}
-/**
- * Run one language-server query. Every failure mode — no server for this file,
- * a missing binary, no line, an unreadable file, a dead child — comes back as
- * `{ ok: false, error }`; the tool contract is results, never throws.
- */
-export async function askLsp(query) {
-    try {
-        const spec = specFor(query.file);
-        if (!spec)
-            return { ok: false, error: `no language server configured for ${query.file}` };
-        const needsLine = query.action === "definition" || query.action === "references" || query.action === "hover";
-        if (needsLine && (query.line === undefined || !Number.isInteger(query.line) || query.line < 1)) {
-            return { ok: false, error: `line required (1-based) for ${query.action}` };
-        }
-        // PATH presence is checked by scanning, not by spawning: a missing binary
-        // has to become a tool result, and a probe child would cost a fork per call.
-        const onPath = spec.command.includes("/") ? existsSync(spec.command) : (process.env.PATH ?? "").split(delimiter).some((dir) => existsSync(join(dir, spec.command)));
-        if (!onPath) {
-            return { ok: false, error: `${spec.command} is not on PATH. Install it to use lsp on ${query.file}.` };
-        }
-        const file = isAbsolute(query.file) ? query.file : join(query.root, query.file);
-        const text = readFileSync(file, "utf8");
-        const client = await clientFor(spec, query.root);
-        await client.ensureOpen(file, text, spec.languageId);
-        // The tool takes 1-based lines (editor habit); LSP positions on the wire
-        // are 0-based — this is that conversion.
-        const wireLine = (query.line ?? 1) - 1;
-        let character = 0;
-        if (query.symbol) {
-            const at = (text.split("\n")[wireLine] ?? "").indexOf(query.symbol);
-            if (at >= 0)
-                character = at;
-        }
-        switch (query.action) {
-            case "definition": {
-                const location = await client.definition(file, wireLine, character);
-                if (!location)
-                    return { ok: true, text: "no definition found", count: 0 };
-                return { ok: true, text: locationText(location), count: 1 };
-            }
-            case "references": {
-                const locations = await client.references(file, wireLine, character);
-                const lines = locations.map(locationText);
-                return { ok: true, text: lines.length > 0 ? lines.join("\n") : "no references found", count: lines.length };
-            }
-            case "hover": {
-                const hover = (await client.hover(file, wireLine, character))?.trim();
-                return { ok: true, text: hover ? hover : "no hover at that position" };
-            }
-            case "symbols": {
-                const rows = symbolRows(await client.documentSymbols(file));
-                return { ok: true, text: rows.length > 0 ? rows.join("\n") : "no symbols in this file", count: rows.length };
-            }
-            case "diagnostics": {
-                const diagnostics = await client.diagnostics(file);
-                const rows = diagnostics.map((d) => `${d.range.start.line + 1}:${d.range.start.character + 1} ${SEVERITY_NAME[d.severity ?? 3] ?? "info"} ${d.message}`);
-                return { ok: true, text: rows.length > 0 ? rows.join("\n") : "no diagnostics", count: rows.length };
-            }
-        }
-    }
-    catch (error) {
-        return { ok: false, error: error instanceof Error ? error.message : String(error) };
-    }
-}

package/dist/mcp-config.js

@@ -1,85 +0,0 @@
-/**
- * The MCP configuration the session should load, read at the moment the SDK asks.
- *
- * The SDK's MCP extension reads `mcp.json` exactly once, on `session_start`. A
- * server removed from the menu afterwards stays configured as far as that
- * extension is concerned, so nothing closes its transport and the process keeps
- * running for the life of the CLI — the leak the preset menu could not see,
- * because the menu only ever edited the file.
- *
- * The extension's teardown is correct and already exists: it closes every server
- * whose config changed when `loadConfig` returns a set that no longer names it.
- * What it needed was a loader that re-reads the file each time it is called, so
- * that a change made mid-session is visible to it. That is all this is.
- *
- * The shape mirrors what the SDK's own loader produces, because the extension
- * consumes it directly: `servers`, `errors`, and the project path. Entries keep
- * whatever keys the file holds, since the SDK reads `command`, `args`, `env`,
- * `url`, `enabled`, and `exposure` from them.
- */
-import { existsSync, readFileSync } from "node:fs";
-import { AGENT_DIR } from "./paths.js";
-import { mcpConfigPath } from "./preset-mcp.js";
-/** The project's own `mcp.json`, which takes precedence when the project is trusted. */
-export function projectMcpConfigPath(cwd) {
-    return `${cwd}/.howtofix/mcp.json`;
-}
-/**
- * Read one `mcp.json`. A missing file is an empty config; an unparseable one is
- * an error, never a crash — a broken file must not stop the session from
- * starting, and the user needs to be told which file is broken.
- */
-function readOne(path, errors) {
-    if (!existsSync(path))
-        return {};
-    try {
-        const parsed = JSON.parse(readFileSync(path, "utf8"));
-        const servers = parsed?.mcpServers;
-        if (!servers || typeof servers !== "object" || Array.isArray(servers))
-            return {};
-        return servers;
-    }
-    catch (error) {
-        errors.push(`${path}: ${error instanceof Error ? error.message : String(error)}`);
-        return {};
-    }
-}
-/**
- * Load global and (when trusted) project MCP configuration.
- *
- * Re-read on every call. The extension calls this on each `session_start`, and
- * the session's own reload path re-emits it, so this is what turns "the file
- * changed" into "the running session changed".
- */
-/**
- * The global `mcp.json` as the menu needs it: names and specs, no merging.
- *
- * The menu shows what a removal will act on, so it must read the same file the
- * loader reads. A second reader here would be a second opinion about a config
- * file, and the two would disagree the first time either changed.
- */
-export function readGlobalMcpServers(agentDir) {
-    const errors = [];
-    return readOne(mcpConfigPath(agentDir ?? AGENT_DIR), errors);
-}
-export function loadMcpConfiguration(options) {
-    const errors = [];
-    const globalServers = readOne(mcpConfigPath(options.agentDir ?? AGENT_DIR), errors);
-    const projectPath = projectMcpConfigPath(options.cwd);
-    const projectConfig = options.projectTrusted && existsSync(projectPath) ? projectPath : undefined;
-    const projectServers = projectConfig ? readOne(projectConfig, errors) : {};
-    // The project overrides the global entry of the same name, which is the same
-    // precedence the SDK applies and the reason `/mcp` saves project overrides to
-    // this file.
-    const globalPath = mcpConfigPath(options.agentDir ?? AGENT_DIR);
-    const merged = new Map();
-    for (const [name, spec] of Object.entries(globalServers)) {
-        merged.set(name, { name, config: spec, source: globalPath, scope: "global" });
-    }
-    for (const [name, spec] of Object.entries(projectServers)) {
-        // A project entry of the same name overrides the global one, and takes over
-        // as the file `/mcp` writes to.
-        merged.set(name, { name, config: spec, source: projectConfig, scope: "project" });
-    }
-    return { servers: [...merged.values()], errors, projectConfig };
-}

package/dist/mcp-lifecycle.js

@@ -1,147 +0,0 @@
-/**
- * One lifecycle seam for MCP configuration changes.
- *
- * Editing `mcp.json` and making the running session match it are two different
- * things, and only the first was ever done. Removing a server from the preset
- * menu wrote the file and stopped: the live transport, its child process, and the
- * `mcp__<server>__<tool>` registrations stayed in the session until the CLI
- * exited, so a server the user had just removed was still reachable by the agent.
- * Installing had the mirror-image problem — the reload was a `void` call, so two
- * quick presses could overlap a config write with a session reload and land in
- * either order.
- *
- * This module owns the second half. Every path that changes MCP configuration
- * funnels through `reconcile`, which:
- *
- *   - treats the on-disk configuration as the desired state and the active server
- *     set as the actual state, then moves one toward the other;
- *   - runs single-flight: a second request joins the one in progress rather than
- *     starting another, and the *latest* desired state is what gets applied, so a
- *     change made during a run is not lost;
- *   - never lets a failure escape as an unhandled rejection, because every caller
- *     reaches it from a `void` inside a picker handler.
- *
- * It deliberately does not know how the SDK starts or stops a server. The caller
- * supplies that through `apply`, which keeps this testable without a live
- * transport and keeps the SDK's MCP surface in one place.
- */
-/** Raised names that could not be released. Reported, never thrown onward. */
-function describeError(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-export class McpLifecycle {
-    /** Names currently active in the session. */
-    active;
-    apply;
-    report;
-    /** The newest desired set seen while a reconciliation was running. */
-    pending;
-    /** The in-flight reconciliation, if any. Callers join this instead of starting one. */
-    running;
-    constructor(options) {
-        this.active = new Set(options.initial ?? []);
-        this.apply = options.apply;
-        this.report = options.report ?? ((message) => console.error(message));
-    }
-    /** Names the session currently holds. A copy, so a caller cannot mutate the state. */
-    activeServers() {
-        return [...this.active];
-    }
-    /**
-     * Move the active set toward `desired`.
-     *
-     * Concurrent callers join the run in progress; the desired set is replaced
-     * before joining, so the last request wins and no edit is dropped. That is the
-     * difference between coalescing and dropping: an install that arrives while a
-     * removal is running is applied by the time the shared promise settles, not
-     * discarded because the slot was taken.
-     */
-    reconcile(desired) {
-        this.pending = new Set(desired);
-        if (this.running)
-            return this.running;
-        this.running = this.drain().finally(() => {
-            this.running = undefined;
-        });
-        return this.running;
-    }
-    /**
-     * Apply desired sets until the newest one has been applied.
-     *
-     * A single pass would leave the last request unapplied whenever a change
-     * arrived mid-run, which is exactly the case this exists for.
-     */
-    async drain() {
-        const total = { added: [], removed: [], unchanged: [], problems: [] };
-        while (this.pending !== undefined) {
-            const desired = this.pending;
-            this.pending = undefined;
-            const pass = await this.applyOnce(desired);
-            total.added.push(...pass.added);
-            total.removed.push(...pass.removed);
-            total.unchanged.push(...pass.unchanged);
-            total.problems.push(...pass.problems);
-        }
-        // Names can appear in both an add and a later remove within one reconcile
-        // call; report each name once, with the final state deciding which list.
-        const finalActive = this.active;
-        total.added = total.added.filter((name) => finalActive.has(name));
-        total.removed = [...new Set(total.removed.filter((name) => !finalActive.has(name)))];
-        total.added = [...new Set(total.added)];
-        total.unchanged = [...new Set(total.unchanged.filter((name) => finalActive.has(name)))];
-        return total;
-    }
-    async applyOnce(desired) {
-        const added = [...desired].filter((name) => !this.active.has(name));
-        const removed = [...this.active].filter((name) => !desired.has(name));
-        const unchanged = [...desired].filter((name) => this.active.has(name));
-        if (added.length === 0 && removed.length === 0) {
-            return { added: [], removed: [], unchanged, problems: [] };
-        }
-        try {
-            await this.apply(added, removed);
-        }
-        catch (error) {
-            // The session may be partly reconciled. Report which half failed rather
-            // than claiming the configuration and the session agree.
-            const message = `mcp reconciliation failed: ${describeError(error)}`;
-            this.report(message);
-            return { added: [], removed: [], unchanged: [], problems: [message] };
-        }
-        // Recorded only after `apply` resolves: a teardown that threw has not
-        // released the server, so the active set must still name it or the next
-        // reconcile would skip the release it still owes.
-        for (const name of added)
-            this.active.add(name);
-        for (const name of removed)
-            this.active.delete(name);
-        return { added, removed, unchanged, problems: [] };
-    }
-    /**
-     * Release everything this session owns.
-     *
-     * Called when the session is replaced or the CLI exits. Without it, repeated
-     * `/new` and `/resume` accumulate one set of server processes per session,
-     * which is the leak the picker path could not see because it never disposes a
-     * session at all.
-     */
-    async dispose() {
-        // A reconcile still in flight owns the transports; wait for it so we do not
-        // dispose a set it is in the middle of mutating.
-        if (this.running)
-            await this.running.catch(() => undefined);
-        const names = [...this.active];
-        if (names.length === 0)
-            return { added: [], removed: [], unchanged: [], problems: [] };
-        try {
-            await this.apply([], names);
-            this.active.clear();
-            return { added: [], removed: names, unchanged: [], problems: [] };
-        }
-        catch (error) {
-            const message = `mcp teardown failed: ${describeError(error)}`;
-            this.report(message);
-            return { added: [], removed: [], unchanged: [], problems: [message] };
-        }
-    }
-}