muonroi-cli 1.8.1 → 1.8.4

package/dist/src/maintain/__tests__/task-runner.test.js

@@ -1,281 +0,0 @@
-/**
- * task-runner.test.ts — P15 unit tests.
- *
- * Covers:
- *   1. Happy path: 5 phase pairs emitted in order with stable phaseIds + startedAt
- *   2. Judge fail: yields phaseError and returns status="blocked"
- *   3. Review with concerns: surfaces concerns in result and as final chunk
- *   4. Missing verify recipe: returns status="failed" with clear reason
- *   5. Edit stage failure: returns status="failed"
- */
-import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { getTestModels } from "../../__test-helpers__/catalog-fixtures.js";
-import { loadCatalog } from "../../models/registry.js";
-beforeAll(async () => {
-    await loadCatalog();
-});
-// ── Mocks ──────────────────────────────────────────────────────────────────
-vi.mock("../../verify/orchestrator.js", () => ({
-    runVerifyOrchestration: vi.fn(),
-}));
-vi.mock("../../product-loop/done-gate.js", () => ({
-    evaluateDoneGate: vi.fn(),
-}));
-vi.mock("../../council/leader.js", () => ({
-    pickCouncilTaskModel: vi.fn((_task, leaderId) => leaderId),
-}));
-import { evaluateDoneGate } from "../../product-loop/done-gate.js";
-import { runVerifyOrchestration } from "../../verify/orchestrator.js";
-import { runMaintenanceTask } from "../task-runner.js";
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-function makeTask(overrides = {}) {
-    return {
-        id: "01HX1234",
-        kind: "bug",
-        title: "Fix login redirect",
-        description: "After login the user is redirected to /undefined instead of /dashboard",
-        acceptance_criteria: ["redirect to /dashboard after login", "no 404 on redirect"],
-        candidateFiles: ["src/auth/login.ts"],
-        impactRadius: ["src/app.tsx"],
-        regressionTestFiles: ["src/auth/__tests__/login.test.ts"],
-        status: "queued",
-        createdAtUtc: new Date().toISOString(),
-        updatedAtUtc: new Date().toISOString(),
-        ...overrides,
-    };
-}
-function makeIntel(overrides = {}) {
-    return {
-        cwd: "/tmp/proj",
-        repoMap: "src/\n  auth/\n    login.ts\n  app.tsx",
-        repoMapSource: "generated",
-        candidateFiles: [{ path: "src/auth/login.ts", reason: "filename match", matchScore: 0.9 }],
-        impactRadius: ["src/app.tsx"],
-        regressionTests: ["src/auth/__tests__/login.test.ts"],
-        detectedFrameworks: ["node", "react"],
-        capturedAtUtc: new Date().toISOString(),
-        ...overrides,
-    };
-}
-function makeCtx(overrides = {}) {
-    return {
-        runId: "run-maint-test",
-        sessionId: "sess-test",
-        cwd: "/tmp/proj",
-        llm: {
-            generate: vi.fn(async (_modelId, _system, _prompt) => "1. Fix redirect in login.ts\n2. Update router"),
-        },
-        processMessageFn: vi.fn(async function* () {
-            yield { type: "content", content: "applying fix..." };
-        }),
-        detectVerifyRecipe: vi.fn(async () => ({
-            ecosystem: "node",
-            appKind: "cli",
-            appLabel: "Test project",
-            shellInitCommands: [],
-            bootstrapCommands: [],
-            installCommands: [],
-            buildCommands: [],
-            testCommands: ["npm test"],
-            smokeKind: "none",
-            evidence: [],
-            notes: [],
-            coverage: 80,
-        })),
-        respondToPreflight: vi.fn(async () => true),
-        ...overrides,
-    };
-}
-function makeInput(ctxOverrides, taskOverrides) {
-    return {
-        task: makeTask(taskOverrides),
-        codebaseIntel: makeIntel(),
-        ctx: makeCtx(ctxOverrides),
-        leaderModelId: getTestModels().fast,
-        costAware: true,
-    };
-}
-async function drain(gen) {
-    const chunks = [];
-    let result;
-    while (true) {
-        const step = await gen.next();
-        if (step.done) {
-            result = step.value;
-            break;
-        }
-        chunks.push(step.value);
-    }
-    return { chunks, result: result };
-}
-// ─── Tests ────────────────────────────────────────────────────────────────────
-describe("runMaintenanceTask — happy path", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        runVerifyOrchestration.mockResolvedValue({
-            success: true,
-            output: "VERIFY_PASS\n2 tests passed",
-        });
-        evaluateDoneGate.mockResolvedValue({
-            pass: true,
-            score: 0.95,
-        });
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    it("emits 5 active+done phase pairs in order: design, edit, verify, judge, review", async () => {
-        const input = makeInput();
-        // review model returns no concerns (ok=true)
-        input.ctx.llm.generate
-            .mockResolvedValueOnce("1. Fix redirect\n2. Update router") // design
-            .mockResolvedValueOnce('{"ok": true, "concerns": []}'); // review
-        const { chunks, result } = await drain(runMaintenanceTask(input));
-        const phaseChunks = chunks.filter((c) => c.type === "council_phase");
-        const phases = phaseChunks.map((c) => c.councilPhase);
-        // Must have active+done for all 5 phases = 10 phase events
-        expect(phases.length).toBe(10);
-        const expectedPhaseIds = ["maint-design", "maint-edit", "maint-verify", "maint-judge", "maint-review"];
-        for (const id of expectedPhaseIds) {
-            const forId = phases.filter((p) => p.phaseId === id);
-            expect(forId).toHaveLength(2);
-            expect(forId[0].state).toBe("active");
-            expect(forId[1].state).toBe("done");
-            expect(typeof forId[0].startedAt).toBe("number");
-            expect(forId[0].startedAt).toBeGreaterThan(0);
-        }
-        // Verify ordering: design active must come before edit active
-        const actives = phases.filter((p) => p.state === "active").map((p) => p.phaseId);
-        expect(actives).toEqual(["maint-design", "maint-edit", "maint-verify", "maint-judge", "maint-review"]);
-        expect(result.status).toBe("done");
-        expect(result.judgeScore).toBe(0.95);
-        expect(result.designPlan).toContain("Fix redirect");
-    });
-    it("returns status=done with reviewConcerns=[] when review returns ok:true", async () => {
-        const input = makeInput();
-        input.ctx.llm.generate
-            .mockResolvedValueOnce("1. Fix redirect\n2. Update router")
-            .mockResolvedValueOnce('{"ok": true, "concerns": []}');
-        const { result } = await drain(runMaintenanceTask(input));
-        expect(result.status).toBe("done");
-        expect(result.reviewConcerns).toEqual([]);
-    });
-});
-describe("runMaintenanceTask — judge fail → blocked", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        runVerifyOrchestration.mockResolvedValue({
-            success: false,
-            output: "2 tests failed",
-            error: "AssertionError: expected /dashboard but got /undefined",
-        });
-        evaluateDoneGate.mockResolvedValue({
-            pass: false,
-            failedCondition: "engineering_floor",
-            reason: "verify_FAIL",
-            score: 0.3,
-        });
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    it("yields phaseError on judge phase and returns status=blocked", async () => {
-        const input = makeInput();
-        input.ctx.llm.generate.mockResolvedValue("1. Fix redirect");
-        const { chunks, result } = await drain(runMaintenanceTask(input));
-        // Judge phase must emit an error chunk
-        const phaseChunks = chunks
-            .filter((c) => c.type === "council_phase")
-            .map((c) => c.councilPhase);
-        const judgeErrorChunk = phaseChunks.find((p) => p.phaseId === "maint-judge" && p.state === "error");
-        expect(judgeErrorChunk).toBeDefined();
-        expect(typeof judgeErrorChunk.errorMessage).toBe("string");
-        // No review phase emitted when judge halts
-        const reviewPhase = phaseChunks.find((p) => p.phaseId === "maint-review");
-        expect(reviewPhase).toBeUndefined();
-        expect(result.status).toBe("blocked");
-        expect(result.judgeScore).toBe(0.3);
-        expect(result.failureReason).toBeTruthy();
-    });
-});
-describe("runMaintenanceTask — review with concerns", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        runVerifyOrchestration.mockResolvedValue({
-            success: true,
-            output: "VERIFY_PASS",
-        });
-        evaluateDoneGate.mockResolvedValue({
-            pass: true,
-            score: 0.9,
-        });
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    it("surfaces concerns in result.reviewConcerns and emits a content chunk listing them", async () => {
-        const input = makeInput();
-        const concernsList = ["No test for null user case", "Missing error boundary for failed fetch"];
-        input.ctx.llm.generate
-            .mockResolvedValueOnce("1. Fix redirect") // design
-            .mockResolvedValueOnce(JSON.stringify({ ok: false, concerns: concernsList })); // review
-        const { chunks, result } = await drain(runMaintenanceTask(input));
-        expect(result.status).toBe("done");
-        expect(result.reviewConcerns).toEqual(concernsList);
-        const contentChunks = chunks
-            .filter((c) => c.type === "content")
-            .map((c) => c.content);
-        const reviewContent = contentChunks.find((c) => c.includes("Review Concerns"));
-        expect(reviewContent).toBeDefined();
-        expect(reviewContent).toContain("No test for null user case");
-        expect(reviewContent).toContain("Missing error boundary for failed fetch");
-    });
-});
-describe("runMaintenanceTask — missing verify recipe", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    it("emits phaseError on verify and returns status=failed when detectVerifyRecipe returns null", async () => {
-        const input = makeInput({
-            detectVerifyRecipe: vi.fn(async () => null),
-        });
-        input.ctx.llm.generate.mockResolvedValue("1. Fix redirect");
-        const { chunks, result } = await drain(runMaintenanceTask(input));
-        const phaseChunks = chunks
-            .filter((c) => c.type === "council_phase")
-            .map((c) => c.councilPhase);
-        const verifyError = phaseChunks.find((p) => p.phaseId === "maint-verify" && p.state === "error");
-        expect(verifyError).toBeDefined();
-        expect(verifyError.errorMessage).toContain("no verify recipe");
-        expect(result.status).toBe("failed");
-        expect(result.failureReason).toContain("no verify recipe");
-        // runVerifyOrchestration should NOT have been called
-        expect(runVerifyOrchestration).not.toHaveBeenCalled();
-    });
-});
-describe("runMaintenanceTask — edit failure", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    it("returns status=failed when processMessageFn throws", async () => {
-        const input = makeInput({
-            processMessageFn: vi.fn(async function* () {
-                throw new Error("orchestrator exploded");
-                // biome-ignore lint/correctness/noUnreachable: needed for generator type inference
-                yield { type: "content", content: "" };
-            }),
-        });
-        input.ctx.llm.generate.mockResolvedValue("1. Fix redirect");
-        const { result } = await drain(runMaintenanceTask(input));
-        expect(result.status).toBe("failed");
-        expect(result.failureReason).toContain("orchestrator exploded");
-        expect(runVerifyOrchestration).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=task-runner.test.js.map

package/dist/src/mcp/__tests__/auto-setup.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/auto-setup.test.js

@@ -1,155 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-const tmpHome = path.join(os.tmpdir(), `muonroi-cli-auto-setup-${process.pid}`);
-describe("ensureDefaultMcpServers — research servers", () => {
-    let origHome;
-    let origUserProfile;
-    beforeEach(() => {
-        fs.mkdirSync(tmpHome, { recursive: true });
-        origHome = process.env.HOME;
-        origUserProfile = process.env.USERPROFILE;
-        process.env.HOME = tmpHome;
-        process.env.USERPROFILE = tmpHome;
-        vi.resetModules();
-    });
-    afterEach(() => {
-        fs.rmSync(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-        if (origHome === undefined)
-            delete process.env.HOME;
-        else
-            process.env.HOME = origHome;
-        if (origUserProfile === undefined)
-            delete process.env.USERPROFILE;
-        else
-            process.env.USERPROFILE = origUserProfile;
-    });
-    it("registers context7 + fetch + tavily for a fresh user", async () => {
-        const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-        const merged = ensureDefaultMcpServers();
-        const ids = merged.map((s) => s.id);
-        expect(ids).toContain("context7");
-        expect(ids).toContain("fetch");
-        expect(ids).toContain("tavily");
-    });
-    it("registers muonroi-docs as a default, enabled, http ecosystem source", async () => {
-        const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-        const merged = ensureDefaultMcpServers();
-        const docs = merged.find((s) => s.id === "muonroi-docs");
-        expect(docs).toBeDefined();
-        expect(docs?.enabled).toBe(true);
-        expect(docs?.transport).toBe("http");
-        expect(docs?.url).toContain("docs-mcp.muonroi.com");
-    });
-    it("does NOT register muonroi-tools (its tools are native in-process builtins now)", async () => {
-        // The CLI no longer self-spawns itself as an MCP server. ee_query/ee_feedback/
-        // ee_health/usage_forensics/lsp_query/setup_guide/selfverify_* are native
-        // builtins (src/tools/native-tools.ts) — strictly better than a per-turn
-        // subprocess cold-start. So muonroi-tools must NOT be seeded.
-        const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-        const merged = ensureDefaultMcpServers();
-        expect(merged.find((s) => s.id === "muonroi-tools")).toBeUndefined();
-    });
-    it("removes an existing self-spawned muonroi-tools entry (incl. an old vitest-worker-poisoned one)", async () => {
-        const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
-        fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-        fs.writeFileSync(settingsPath, JSON.stringify({
-            mcp: {
-                servers: [
-                    {
-                        id: "muonroi-tools",
-                        label: "muonroi-tools (Experience + Self-Diagnostics)",
-                        enabled: true,
-                        transport: "stdio",
-                        command: "C:\\Program Files\\nodejs\\node.exe",
-                        args: [
-                            "D:\\repo\\node_modules\\.bun\\vitest@4.1.5\\node_modules\\vitest\\dist\\workers\\forks.js",
-                            "tools-mcp",
-                        ],
-                    },
-                ],
-            },
-        }));
-        const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-        const merged = ensureDefaultMcpServers();
-        // Deprecated self-spawn stripped; no vitest worker path survives.
-        expect(merged.find((s) => s.id === "muonroi-tools")).toBeUndefined();
-        expect(JSON.stringify(merged)).not.toMatch(/vitest|forks\.js/);
-    });
-    it("removes a self-spawned muonroi-tools entry even with a valid bun-source command", async () => {
-        const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
-        fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-        fs.writeFileSync(settingsPath, JSON.stringify({
-            mcp: {
-                servers: [
-                    {
-                        id: "muonroi-tools",
-                        label: "muonroi-tools",
-                        enabled: true,
-                        transport: "stdio",
-                        command: "bun",
-                        args: ["/repo/src/index.ts", "tools-mcp"],
-                    },
-                    {
-                        id: "context7",
-                        label: "Context7",
-                        enabled: true,
-                        transport: "http",
-                        url: "https://mcp.context7.com/mcp",
-                    },
-                ],
-            },
-        }));
-        const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-        const merged = ensureDefaultMcpServers();
-        expect(merged.find((s) => s.id === "muonroi-tools")).toBeUndefined();
-        // Unrelated user server preserved.
-        expect(merged.find((s) => s.id === "context7")).toBeDefined();
-    });
-    it("context7 and fetch default to enabled", async () => {
-        const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-        const merged = ensureDefaultMcpServers();
-        const c7 = merged.find((s) => s.id === "context7");
-        const fetchEntry = merged.find((s) => s.id === "fetch");
-        expect(c7?.enabled).toBe(true);
-        expect(fetchEntry?.enabled).toBe(true);
-    });
-    it("tavily defaults to disabled (key not yet provided)", async () => {
-        const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-        const merged = ensureDefaultMcpServers();
-        const tavily = merged.find((s) => s.id === "tavily");
-        expect(tavily?.enabled).toBe(false);
-    });
-    it("does NOT overwrite an existing tavily entry already configured by user", async () => {
-        const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
-        fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-        fs.writeFileSync(settingsPath, JSON.stringify({
-            mcp: {
-                servers: [
-                    {
-                        id: "tavily",
-                        label: "Tavily Web Search",
-                        enabled: true,
-                        transport: "stdio",
-                        command: "npx",
-                        args: ["-y", "tavily-mcp"],
-                    },
-                ],
-            },
-        }));
-        const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-        const merged = ensureDefaultMcpServers();
-        const tavily = merged.find((s) => s.id === "tavily");
-        expect(tavily?.enabled).toBe(true); // user's setting preserved
-    });
-    it("is idempotent across repeated calls (no duplicate ids)", async () => {
-        const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-        const first = ensureDefaultMcpServers();
-        const second = ensureDefaultMcpServers();
-        expect(second.map((s) => s.id).sort()).toEqual(first.map((s) => s.id).sort());
-        const ids = second.map((s) => s.id);
-        expect(new Set(ids).size).toBe(ids.length);
-    });
-});
-//# sourceMappingURL=auto-setup.test.js.map

package/dist/src/mcp/__tests__/cap-tool-result.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/cap-tool-result.test.js

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { MAX_TOOL_OUTPUT_CHARS } from "../../tools/registry.js";
-import { capMcpToolResult } from "../cap-tool-result.js";
-const cap = 1_000;
-describe("capMcpToolResult()", () => {
-    it("truncates an over-cap string result", () => {
-        const big = "X".repeat(cap + 5_000);
-        const out = capMcpToolResult(big, cap);
-        expect(typeof out).toBe("string");
-        expect(out.length).toBeLessThan(big.length);
-        expect(out).toContain("truncated");
-    });
-    it("leaves an under-cap string result unchanged", () => {
-        const small = "hello world";
-        expect(capMcpToolResult(small, cap)).toBe(small);
-    });
-    it("truncates a huge text part inside a content result", () => {
-        const big = "Y".repeat(cap + 5_000);
-        const result = { type: "content", value: [{ type: "text", text: big }] };
-        const out = capMcpToolResult(result, cap);
-        expect(out.type).toBe("content");
-        expect(out.value[0].text.length).toBeLessThan(big.length);
-        expect(out.value[0].text).toContain("truncated");
-    });
-    it("leaves non-text parts (e.g. images) untouched", () => {
-        const image = { type: "image", data: "BASE64DATA", mediaType: "image/png" };
-        const result = { type: "content", value: [image] };
-        const out = capMcpToolResult(result, cap);
-        expect(out.value[0]).toEqual(image);
-    });
-    it("enforces a cumulative budget across multiple text parts", () => {
-        const partLen = cap; // each part alone is exactly the cap
-        const result = {
-            type: "content",
-            value: [
-                { type: "text", text: "A".repeat(partLen) },
-                { type: "text", text: "B".repeat(partLen) },
-                { type: "text", text: "C".repeat(partLen) },
-            ],
-        };
-        const out = capMcpToolResult(result, cap);
-        const total = out.value.reduce((n, p) => n + p.text.length, 0);
-        // First part consumes the budget; later parts are elided to short markers,
-        // so the combined text stays close to the cap (plus small marker overhead).
-        expect(total).toBeLessThan(cap * 2);
-        expect(out.value[2].text).toContain("omitted");
-    });
-    it("returns structured (non-content, non-string) results unchanged", () => {
-        const structured = { ok: true, rows: [1, 2, 3] };
-        expect(capMcpToolResult(structured, cap)).toEqual(structured);
-    });
-    it("defaults to MAX_TOOL_OUTPUT_CHARS when no cap is passed", () => {
-        const big = "Z".repeat(MAX_TOOL_OUTPUT_CHARS + 10_000);
-        const out = capMcpToolResult(big);
-        expect(out.length).toBeLessThan(big.length);
-    });
-});
-//# sourceMappingURL=cap-tool-result.test.js.map

package/dist/src/mcp/__tests__/client-pool.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/client-pool.spec.js

@@ -1,169 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// Pool reuse semantics: connect a server ONCE, reuse the live client across
-// turns, evict on failure (retry) and on a post-connect connection error
-// (reconnect), and tear everything down on closeAllMcpClients().
-vi.mock("../validate.js", () => ({ validateMcpServerConfig: () => ({ ok: true }) }));
-const connectOneServer = vi.fn();
-vi.mock("../runtime.js", () => ({
-    connectOneServer: (...args) => connectOneServer(...args),
-    getMcpBuildDeadlineMs: () => 500,
-}));
-import { __mcpClientPoolSize, __resetMcpClientPoolForTests, acquireMcpTools, closeAllMcpClients, warmMcpClients, } from "../client-pool.js";
-const srv = (id) => ({ id, label: id, enabled: true, transport: "stdio", command: "x", args: [] });
-const connected = (id, close = async () => { }) => ({
-    tools: { [`mcp_${id}__ping`]: { execute: async () => "pong" } },
-    client: { close },
-});
-describe("acquireMcpTools — cross-turn client pool", () => {
-    beforeEach(() => {
-        __resetMcpClientPoolForTests();
-        connectOneServer.mockReset();
-    });
-    afterEach(async () => {
-        await closeAllMcpClients();
-    });
-    it("connects a server once and reuses it across turns (no per-turn cold-spawn)", async () => {
-        connectOneServer.mockImplementation(async (s) => connected(s.id));
-        const b1 = await acquireMcpTools([srv("fs")]);
-        expect(Object.keys(b1.tools)).toContain("mcp_fs__ping");
-        await b1.close(); // release — must NOT kill the pooled client
-        const b2 = await acquireMcpTools([srv("fs")]);
-        expect(Object.keys(b2.tools)).toContain("mcp_fs__ping");
-        expect(connectOneServer).toHaveBeenCalledTimes(1); // reused, not re-spawned
-    });
-    it("evicts a failed connect so a later turn retries", async () => {
-        connectOneServer
-            .mockRejectedValueOnce(new Error("spawn failed"))
-            .mockImplementation(async (s) => connected(s.id));
-        const b1 = await acquireMcpTools([srv("fs")]);
-        expect(b1.errors.some((e) => e.includes("fs"))).toBe(true);
-        expect(Object.keys(b1.tools)).not.toContain("mcp_fs__ping");
-        const b2 = await acquireMcpTools([srv("fs")]);
-        expect(Object.keys(b2.tools)).toContain("mcp_fs__ping");
-        expect(connectOneServer).toHaveBeenCalledTimes(2); // retried after eviction
-    });
-    it("self-heals: a connection error reconnects ONCE in-turn; a permanently-dead server surfaces the error (no loop)", async () => {
-        connectOneServer.mockImplementation(async (s) => ({
-            tools: {
-                [`mcp_${s.id}__boom`]: {
-                    execute: async () => {
-                        throw new Error("MCP transport closed");
-                    },
-                },
-            },
-            client: { close: async () => { } },
-        }));
-        const b1 = await acquireMcpTools([srv("fs")]);
-        await expect(b1.tools.mcp_fs__boom.execute({}, {})).rejects.toThrow(/transport closed/);
-        // Initial connect + exactly ONE in-turn reconnect — the retry is not looped.
-        expect(connectOneServer).toHaveBeenCalledTimes(2);
-    });
-    it("in-turn reconnect: a mid-turn transport drop is reconnected and the call retried once — succeeds", async () => {
-        let gen = 0;
-        connectOneServer.mockImplementation(async (s) => {
-            gen += 1;
-            const dead = gen === 1; // first connect drops mid-call; the reconnect is healthy
-            return {
-                tools: {
-                    [`mcp_${s.id}__ping`]: {
-                        execute: async () => {
-                            if (dead)
-                                throw new Error("Attempted to send a request from a closed client");
-                            return "pong";
-                        },
-                    },
-                },
-                client: { close: async () => { } },
-            };
-        });
-        const b = await acquireMcpTools([srv("docs")]);
-        const result = await b.tools.mcp_docs__ping.execute({}, {});
-        expect(result).toBe("pong"); // recovered within the SAME turn
-        expect(connectOneServer).toHaveBeenCalledTimes(2); // drop + one reconnect
-    });
-    it("a parallel burst on a dropped client shares ONE reconnect; every call retries and succeeds", async () => {
-        // Repro of session 41ccfeb2ceee: a 14-call burst at muonroi-docs dropped the
-        // HTTP socket after the first calls; previously the rest all threw
-        // "Attempted to send a request from a closed client". They must now share a
-        // single reconnect and all recover.
-        let gen = 0;
-        connectOneServer.mockImplementation(async (s) => {
-            gen += 1;
-            const dead = gen === 1;
-            return {
-                tools: {
-                    [`mcp_${s.id}__ping`]: {
-                        execute: async () => {
-                            if (dead)
-                                throw new Error("The socket connection was closed unexpectedly");
-                            return "pong";
-                        },
-                    },
-                },
-                client: { close: async () => { } },
-            };
-        });
-        const b = await acquireMcpTools([srv("docs")]);
-        const tool = b.tools.mcp_docs__ping;
-        const results = await Promise.all(Array.from({ length: 14 }, () => tool.execute({}, {})));
-        expect(results.every((r) => r === "pong")).toBe(true);
-        expect(connectOneServer).toHaveBeenCalledTimes(2); // 14 failures → exactly ONE shared reconnect
-    });
-    it("waits for a criticalServerId past the normal deadline so it lands THIS turn (session 584ba476c07a)", async () => {
-        // Normal deadline is 500ms (mock). docs connects at ~700ms — past the normal
-        // deadline but within the critical window → must be included when critical.
-        connectOneServer.mockImplementation((s) => new Promise((res) => {
-            if (s.id === "docs")
-                setTimeout(() => res(connected(s.id)), 700);
-            else
-                res(connected(s.id));
-        }));
-        const b = await acquireMcpTools([srv("docs")], { criticalServerIds: ["docs"], criticalDeadlineMs: 3000 });
-        expect(Object.keys(b.tools)).toContain("mcp_docs__ping");
-        expect(b.errors).toHaveLength(0);
-    });
-    it("without criticalServerIds, a slow server is reported still-connecting (available next turn)", async () => {
-        connectOneServer.mockImplementation((s) => new Promise((res) => {
-            setTimeout(() => res(connected(s.id)), 700);
-        }));
-        const b = await acquireMcpTools([srv("docs")]);
-        expect(Object.keys(b.tools)).not.toContain("mcp_docs__ping");
-        expect(b.errors.some((e) => /still connecting/.test(e))).toBe(true);
-    });
-    it("keys by cwd/config — a different command reconnects rather than reusing", async () => {
-        connectOneServer.mockImplementation(async (s) => connected(s.id));
-        await acquireMcpTools([
-            { id: "fs", label: "fs", enabled: true, transport: "stdio", command: "a", args: [] },
-        ]);
-        await acquireMcpTools([
-            { id: "fs", label: "fs", enabled: true, transport: "stdio", command: "b", args: [] },
-        ]);
-        expect(connectOneServer).toHaveBeenCalledTimes(2);
-    });
-    it("warmMcpClients pre-connects so the first real turn reuses (no extra spawn)", async () => {
-        let resolveConnect = () => { };
-        connectOneServer.mockImplementation((s) => new Promise((res) => {
-            resolveConnect = () => res(connected(s.id));
-        }));
-        // Warm starts the connect in the background.
-        warmMcpClients([srv("fs")]);
-        expect(connectOneServer).toHaveBeenCalledTimes(1);
-        expect(__mcpClientPoolSize()).toBe(1);
-        // Let the warm connect finish, then a real turn reuses it.
-        resolveConnect();
-        await new Promise((r) => setTimeout(r, 0));
-        const b = await acquireMcpTools([srv("fs")]);
-        expect(Object.keys(b.tools)).toContain("mcp_fs__ping");
-        expect(connectOneServer).toHaveBeenCalledTimes(1); // warmed, not re-spawned
-    });
-    it("closeAllMcpClients tears down every pooled client", async () => {
-        const closeSpy = vi.fn(async () => { });
-        connectOneServer.mockImplementation(async (s) => connected(s.id, closeSpy));
-        await acquireMcpTools([srv("fs"), srv("mem")]);
-        expect(__mcpClientPoolSize()).toBe(2);
-        await closeAllMcpClients();
-        expect(closeSpy).toHaveBeenCalledTimes(2);
-        expect(__mcpClientPoolSize()).toBe(0);
-    });
-});
-//# sourceMappingURL=client-pool.spec.js.map