muonroi-cli 1.3.4 → 1.4.1

package/dist/src/mcp/__tests__/ee-tools.test.js

@@ -0,0 +1,198 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createRecallLedger, sessionRecallLedger } from "../../ee/recall-ledger.js";
+import { registerEETools } from "../ee-tools.js";
+// Minimal harness: register tools onto a real McpServer, then invoke a tool's
+// handler by reaching into the registered tool. We test the handler via the
+// public callTool path using an in-process client would be heavier; instead we
+// capture handlers through a thin fake that records registrations.
+function collectTools(register) {
+    const handlers = {};
+    const fake = {
+        registerTool(name, _def, handler) {
+            handlers[name] = handler;
+        },
+    };
+    register(fake);
+    return handlers;
+}
+function textOf(result) {
+    // result is { content: [{ type:"text", text }], isError? }
+    const r = result;
+    return { json: JSON.parse(r.content[0].text), isError: r.isError };
+}
+function rawTextOf(result) {
+    const r = result;
+    return { text: r.content[0].text, isError: r.isError };
+}
+describe("ee-tools", () => {
+    // Isolate the process-singleton ledger + gate env between tests so default-ledger
+    // tests never inherit pending debt or a gate mode from a prior test.
+    beforeEach(() => {
+        sessionRecallLedger.reset();
+        delete process.env.EXPERIENCE_RECALL_FEEDBACK_GATE;
+        delete process.env.EXPERIENCE_RECALL_FEEDBACK_THRESHOLD;
+    });
+    afterEach(() => {
+        sessionRecallLedger.reset();
+        delete process.env.EXPERIENCE_RECALL_FEEDBACK_GATE;
+        delete process.env.EXPERIENCE_RECALL_FEEDBACK_THRESHOLD;
+    });
+    it("ee_query returns the compact recall index (raw text + count footer, not JSON)", async () => {
+        const handlers = collectTools((s) => registerEETools(s, {
+            recall: async (q) => ({
+                text: `recall:${q} [id:abc col:experience-behavioral]`,
+                entries: [{ id: "abc", collection: "experience-behavioral" }],
+                count: 1,
+            }),
+            health: async () => ({ ok: true, status: 200 }),
+        }));
+        const out = rawTextOf(await handlers["ee_query"]({ query: "redactor" }));
+        expect(out.isError).toBeFalsy();
+        expect(out.text).toContain("recall:redactor");
+        expect(out.text).toContain("[id:abc col:experience-behavioral]"); // handle preserved for exp-feedback
+        expect(out.text).toContain("[recall: 1 entries"); // count footer
+        expect(() => JSON.parse(out.text)).toThrow(); // no longer a JSON dump
+    });
+    it("ee_query caps an oversized recall index so it cannot overflow the MCP token cap", async () => {
+        const handlers = collectTools((s) => registerEETools(s, {
+            recall: async () => ({ text: "x".repeat(50_000), entries: [], count: 42 }),
+            health: async () => ({ ok: true, status: 200 }),
+        }));
+        const out = rawTextOf(await handlers["ee_query"]({ query: "wide", maxChars: 6000 }));
+        expect(out.isError).toBeFalsy();
+        expect(out.text.length).toBeLessThan(7000); // capped, not the full 50k dump
+        expect(out.text).toContain("truncated");
+        expect(out.text).toContain("42 entries");
+    });
+    it("ee_query forwards the project scope to recall", async () => {
+        let seenProject;
+        const handlers = collectTools((s) => registerEETools(s, {
+            recall: async (_q, o) => {
+                seenProject = o.project;
+                return { text: null, entries: [], count: 0 };
+            },
+            health: async () => ({ ok: true, status: 200 }),
+        }));
+        await handlers["ee_query"]({ query: "scope filter", project: "storyflow" });
+        expect(seenProject).toBe("storyflow");
+    });
+    it("ee_query returns ee_unavailable when recall yields null", async () => {
+        const handlers = collectTools((s) => registerEETools(s, { recall: async () => null, health: async () => ({ ok: false, status: 0 }) }));
+        const out = textOf(await handlers["ee_query"]({ query: "x" }));
+        expect(out.isError).toBe(true);
+        expect(out.json.error).toBe("ee_unavailable");
+    });
+    it("ee_health returns the injected status", async () => {
+        const handlers = collectTools((s) => registerEETools(s, { recall: async () => null, health: async () => ({ ok: true, status: 200 }) }));
+        const out = textOf(await handlers["ee_health"]({}));
+        expect(out.json).toEqual({ ok: true, status: 200 });
+    });
+    it("ee_health returns ee_unavailable when health throws", async () => {
+        const handlers = collectTools((s) => registerEETools(s, {
+            recall: async () => null,
+            health: async () => {
+                throw new Error("boom");
+            },
+        }));
+        const out = textOf(await handlers["ee_health"]({}));
+        expect(out.isError).toBe(true);
+        expect(out.json.error).toBe("ee_unavailable");
+    });
+    // ─── feedback gate (Layer 2) + ee_feedback (Layer 1) ───────────────────────
+    it("ee_feedback maps followed→FOLLOWED, clears the ledger debt, reports remaining", async () => {
+        const ledger = createRecallLedger();
+        ledger.record([{ id: "abc", collection: "experience-behavioral" }], "redactor");
+        expect(ledger.pendingCount()).toBe(1);
+        let seen = null;
+        const handlers = collectTools((s) => registerEETools(s, {
+            ledger,
+            feedback: async (id, collection, verdict, reason) => {
+                seen = { id, collection, verdict, reason };
+                return { ok: true, resolvedId: id, verdict: verdict === "followed" ? "FOLLOWED" : verdict };
+            },
+        }));
+        const out = textOf(await handlers["ee_feedback"]({ id: "abc", collection: "experience-behavioral", verdict: "followed" }));
+        expect(out.isError).toBeFalsy();
+        expect(seen).toEqual({ id: "abc", collection: "experience-behavioral", verdict: "followed", reason: undefined });
+        expect(out.json.ok).toBe(true);
+        expect(out.json.pendingRemaining).toBe(0); // debt cleared
+        expect(ledger.pendingCount()).toBe(0);
+    });
+    it("ee_feedback requires a reason for verdict=noise", async () => {
+        const handlers = collectTools((s) => registerEETools(s, { feedback: async () => ({ ok: true }) }));
+        const out = textOf(await handlers["ee_feedback"]({ id: "x", collection: "experience-selfqa", verdict: "noise" }));
+        expect(out.isError).toBe(true);
+        expect(out.json.error).toBe("reason_required");
+    });
+    it("ee_feedback surfaces a feedback_failed error and keeps the debt unrated", async () => {
+        const ledger = createRecallLedger();
+        ledger.record([{ id: "abc", collection: "experience-behavioral" }], "q");
+        const handlers = collectTools((s) => registerEETools(s, { ledger, feedback: async () => ({ ok: false, error: "HTTP 500" }) }));
+        const out = textOf(await handlers["ee_feedback"]({ id: "abc", collection: "experience-behavioral", verdict: "ignored" }));
+        expect(out.isError).toBe(true);
+        expect(out.json.error).toBe("feedback_failed");
+        expect(ledger.pendingCount()).toBe(1); // NOT cleared on failure
+    });
+    it("ee_query soft gate: a later recall is prefixed with the prior unrated debt", async () => {
+        const ledger = createRecallLedger();
+        const handlers = collectTools((s) => registerEETools(s, {
+            ledger,
+            recall: async (q) => ({
+                text: `recall:${q} [id:dup col:experience-behavioral]`,
+                entries: [{ id: q === "first" ? "id1" : "id2", collection: "experience-behavioral" }],
+                count: 1,
+            }),
+            health: async () => ({ ok: true, status: 200 }),
+        }));
+        // First recall — no prior debt, so no gate prefix.
+        const first = rawTextOf(await handlers["ee_query"]({ query: "first" }));
+        expect(first.text).not.toContain("still unrated");
+        expect(ledger.pendingCount()).toBe(1);
+        // Second recall — the prior id1 is still unrated → soft prefix, but recall still returned.
+        const second = rawTextOf(await handlers["ee_query"]({ query: "second" }));
+        expect(second.isError).toBeFalsy();
+        expect(second.text).toContain("still unrated");
+        expect(second.text).toContain("id1");
+        expect(second.text).toContain("recall:second"); // the actual recall is still delivered
+        expect(ledger.pendingCount()).toBe(2);
+    });
+    it("ee_query hard gate: refuses a new recall once unrated debt hits the threshold", async () => {
+        process.env.EXPERIENCE_RECALL_FEEDBACK_GATE = "hard";
+        process.env.EXPERIENCE_RECALL_FEEDBACK_THRESHOLD = "2";
+        const ledger = createRecallLedger();
+        ledger.record([
+            { id: "a", collection: "experience-behavioral" },
+            { id: "b", collection: "experience-selfqa" },
+        ], "earlier");
+        let recallCalled = false;
+        const handlers = collectTools((s) => registerEETools(s, {
+            ledger,
+            recall: async () => {
+                recallCalled = true;
+                return { text: "should not run", entries: [], count: 0 };
+            },
+        }));
+        const out = textOf(await handlers["ee_query"]({ query: "blocked" }));
+        expect(out.isError).toBe(true);
+        expect(out.json.error).toBe("feedback_required");
+        expect(out.json.message).toContain("FEEDBACK GATE");
+        expect(recallCalled).toBe(false); // brain call NOT spent while debt unpaid
+    });
+    it("ee_query gate=off disables the ledger entirely", async () => {
+        process.env.EXPERIENCE_RECALL_FEEDBACK_GATE = "off";
+        const ledger = createRecallLedger();
+        const handlers = collectTools((s) => registerEETools(s, {
+            ledger,
+            recall: async (q) => ({
+                text: `r:${q}`,
+                entries: [{ id: "z", collection: "experience-behavioral" }],
+                count: 1,
+            }),
+            health: async () => ({ ok: true, status: 200 }),
+        }));
+        await handlers["ee_query"]({ query: "one" });
+        await handlers["ee_query"]({ query: "two" });
+        expect(ledger.pendingCount()).toBe(0); // nothing stamped when gate is off
+    });
+});
+//# sourceMappingURL=ee-tools.test.js.map

package/dist/src/mcp/__tests__/forensics-tools.test.d.ts

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

package/dist/src/mcp/__tests__/forensics-tools.test.js

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { registerForensicsTools } from "../forensics-tools.js";
+function collectTools(register) {
+    const handlers = {};
+    const fake = {
+        registerTool(name, _def, handler) {
+            handlers[name] = handler;
+        },
+    };
+    register(fake);
+    return handlers;
+}
+function parse(result) {
+    const r = result;
+    return { json: JSON.parse(r.content[0].text), isError: r.isError };
+}
+const fakeSummary = (id) => ({
+    sessionId: id,
+    rowCount: 1,
+    userPromptCount: 1,
+    toolCallCount: 0,
+    totalInput: 100,
+    totalOutput: 50,
+    totalCacheRead: 0,
+    totalCacheCreation: 0,
+    totalCostUsd: 0.01,
+    cacheHitRatio: 0,
+    peakSingleCallInput: 100,
+    events: [],
+});
+describe("forensics-tools", () => {
+    it("usage_forensics returns the summary for a unique prefix", async () => {
+        const handlers = collectTools((s) => registerForensicsTools(s, { resolve: () => ["sess123"], collect: (id) => fakeSummary(id) }));
+        const out = parse(await handlers["usage_forensics"]({ prefix: "sess" }));
+        expect(out.isError).toBeFalsy();
+        expect(out.json.sessionId).toBe("sess123");
+        expect(out.json.peakSingleCallInput).toBe(100);
+    });
+    it("usage_forensics returns not_found for zero matches", async () => {
+        const handlers = collectTools((s) => registerForensicsTools(s, { resolve: () => [], collect: () => fakeSummary("x") }));
+        const out = parse(await handlers["usage_forensics"]({ prefix: "nope" }));
+        expect(out.isError).toBe(true);
+        expect(out.json.error).toBe("not_found");
+    });
+    it("usage_forensics returns ambiguous for multiple matches", async () => {
+        const handlers = collectTools((s) => registerForensicsTools(s, { resolve: () => ["a1", "a2"], collect: () => fakeSummary("a1") }));
+        const out = parse(await handlers["usage_forensics"]({ prefix: "a" }));
+        expect(out.isError).toBe(true);
+        expect(out.json.error).toBe("ambiguous");
+        expect(out.json.matches).toEqual(["a1", "a2"]);
+    });
+});
+//# sourceMappingURL=forensics-tools.test.js.map

package/dist/src/mcp/__tests__/harness-driver-action-tools.spec.js

@@ -42,7 +42,9 @@ function makeStubDriver(calls, opts = {}) {
         count: () => 0,
         expect: () => true,
         last_event: () => null,
-        events: () => ({ [Symbol.asyncIterator]: () => ({ next: async () => ({ value: undefined, done: true }) }) }),
+        events: () => ({
+            [Symbol.asyncIterator]: () => ({ next: async () => ({ value: undefined, done: true }) }),
+        }),
         render_text: () => "",
         _ingest: () => { },
         _closeAllSubscribers: () => { },

package/dist/src/mcp/__tests__/harness-driver-async-tools.spec.js

@@ -34,7 +34,9 @@ function makeStubDriver(opts = {}) {
         count: () => 0,
         expect: () => opts.expectResult ?? true,
         last_event: (() => opts.lastEvent ?? null),
-        events: () => ({ [Symbol.asyncIterator]: () => ({ next: async () => ({ value: undefined, done: true }) }) }),
+        events: () => ({
+            [Symbol.asyncIterator]: () => ({ next: async () => ({ value: undefined, done: true }) }),
+        }),
         render_text: () => "",
         _ingest: () => { },
         _closeAllSubscribers: () => { },

package/dist/src/mcp/__tests__/lsp-tools.test.d.ts

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

package/dist/src/mcp/__tests__/lsp-tools.test.js

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { registerLspTools } from "../lsp-tools.js";
+function collectTools(register) {
+    const handlers = {};
+    const fake = {
+        registerTool(name, _def, handler) {
+            handlers[name] = handler;
+        },
+    };
+    register(fake);
+    return handlers;
+}
+function parse(result) {
+    const r = result;
+    return { json: JSON.parse(r.content[0].text), isError: r.isError };
+}
+describe("lsp-tools", () => {
+    it("lsp_query passes through the LspToolResponse when enabled", async () => {
+        const resp = { success: true, output: "def at file.ts:10" };
+        const handlers = collectTools((s) => registerLspTools(s, { enabled: () => true, query: async () => resp }));
+        const out = parse(await handlers["lsp_query"]({ operation: "goToDefinition", filePath: "a.ts", line: 1, character: 2 }));
+        expect(out.isError).toBeFalsy();
+        expect(out.json).toEqual(resp);
+    });
+    it("lsp_query returns lsp_disabled when LSP is off", async () => {
+        const handlers = collectTools((s) => registerLspTools(s, { enabled: () => false, query: async () => ({ success: true, output: "x" }) }));
+        const out = parse(await handlers["lsp_query"]({ operation: "hover", filePath: "a.ts", line: 0, character: 0 }));
+        expect(out.isError).toBe(true);
+        expect(out.json.error).toBe("lsp_disabled");
+    });
+    it("lsp_query returns lsp_error when the query throws", async () => {
+        const handlers = collectTools((s) => registerLspTools(s, {
+            enabled: () => true,
+            query: async () => {
+                throw new Error("server launch failed");
+            },
+        }));
+        const out = parse(await handlers["lsp_query"]({ operation: "findReferences", filePath: "a.ts", line: 3, character: 4 }));
+        expect(out.isError).toBe(true);
+        expect(out.json.error).toBe("lsp_error");
+        expect(out.json.message).toContain("server launch failed");
+    });
+    it("lsp_query returns lsp_error when the enabled check throws", async () => {
+        const handlers = collectTools((s) => registerLspTools(s, {
+            enabled: () => {
+                throw new Error("settings read failed");
+            },
+            query: async () => ({ success: true, output: "x" }),
+        }));
+        const out = parse(await handlers["lsp_query"]({ operation: "hover", filePath: "a.ts", line: 0, character: 0 }));
+        expect(out.isError).toBe(true);
+        expect(out.json.error).toBe("lsp_error");
+        expect(out.json.message).toContain("settings read failed");
+    });
+});
+//# sourceMappingURL=lsp-tools.test.js.map

package/dist/src/mcp/__tests__/runtime-output-cap.test.d.ts

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

package/dist/src/mcp/__tests__/runtime-output-cap.test.js

@@ -0,0 +1,42 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { MAX_TOOL_OUTPUT_CHARS } from "../../tools/registry.js";
+vi.mock("@modelcontextprotocol/sdk/client/stdio.js", () => ({
+    StdioClientTransport: vi.fn(function (opts) {
+        Object.assign(this, opts);
+    }),
+    getDefaultEnvironment: () => ({}),
+}));
+// MCP client returns a single tool whose execute emits an over-cap payload.
+const huge = "X".repeat(MAX_TOOL_OUTPUT_CHARS + 50_000);
+vi.mock("@ai-sdk/mcp", () => ({
+    createMCPClient: vi.fn(async () => ({
+        tools: async () => ({
+            big_query: {
+                description: "returns a huge blob",
+                inputSchema: { type: "object", properties: {} },
+                execute: async () => ({ type: "content", value: [{ type: "text", text: huge }] }),
+            },
+        }),
+        close: async () => { },
+    })),
+}));
+vi.mock("../validate.js", () => ({
+    validateMcpServerConfig: () => ({ ok: true }),
+}));
+import { buildMcpToolSet } from "../runtime.js";
+describe("buildMcpToolSet — MCP output is capped", () => {
+    beforeEach(() => vi.clearAllMocks());
+    it("truncates an over-cap MCP tool result through the wrapped execute", async () => {
+        const bundle = await buildMcpToolSet([
+            { id: "demo", label: "Demo", enabled: true, transport: "stdio", command: "x", args: [] },
+        ]);
+        const tool = bundle.tools.mcp_demo__big_query;
+        expect(tool).toBeDefined();
+        const out = await tool.execute({}, {});
+        const text = out.value[0].text;
+        expect(text.length).toBeLessThan(huge.length);
+        expect(text).toContain("truncated");
+        await bundle.close();
+    });
+});
+//# sourceMappingURL=runtime-output-cap.test.js.map

package/dist/src/mcp/__tests__/self-verify-jobs.test.d.ts

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

package/dist/src/mcp/__tests__/self-verify-jobs.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import { JobManager } from "../self-verify-jobs.js";
+// A controllable stub runner: tier1 resolves/rejects on demand.
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+function makeRunner(opts) {
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        tier1: (_o, log) => {
+            log("tier1 started");
+            return (opts.tier1?.() ?? Promise.resolve({ summary: { passed: 1 } }));
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        agentic: (_o, log) => {
+            log("agentic started");
+            return (opts.agentic?.() ?? Promise.resolve({ verdict: "pass" }));
+        },
+    };
+}
+describe("JobManager", () => {
+    it("start returns a runId and job is initially running", () => {
+        const jm = new JobManager(makeRunner({ tier1: () => deferred().promise }));
+        const runId = jm.start({ kind: "tier1" });
+        expect(typeof runId).toBe("string");
+        expect(jm.status(runId)?.status).toBe("running");
+    });
+    it("transitions to done and stores the report", async () => {
+        const d = deferred();
+        const jm = new JobManager(makeRunner({ tier1: () => d.promise }));
+        const runId = jm.start({ kind: "tier1" });
+        d.resolve({ summary: { passed: 2 } });
+        await d.promise;
+        await Promise.resolve(); // let the .then microtask run
+        const job = jm.status(runId);
+        expect(job.status).toBe("done");
+        expect(job.report).toEqual({ summary: { passed: 2 } });
+        expect(job.finishedAt).toBeGreaterThan(0);
+    });
+    it("transitions to error on rejection", async () => {
+        const d = deferred();
+        const jm = new JobManager(makeRunner({ tier1: () => d.promise }));
+        const runId = jm.start({ kind: "tier1" });
+        d.reject(new Error("boom"));
+        await d.promise.catch(() => { });
+        await Promise.resolve();
+        const job = jm.status(runId);
+        expect(job.status).toBe("error");
+        expect(job.error).toBe("boom");
+    });
+    it("cancel marks a running job cancelled and discards a late result", async () => {
+        const d = deferred();
+        const jm = new JobManager(makeRunner({ tier1: () => d.promise }));
+        const runId = jm.start({ kind: "tier1" });
+        expect(jm.cancel(runId)).toBe(true);
+        expect(jm.status(runId)?.status).toBe("cancelled");
+        d.resolve({ summary: { passed: 9 } });
+        await d.promise;
+        await Promise.resolve();
+        expect(jm.status(runId)?.status).toBe("cancelled"); // late resolve ignored
+    });
+    it("captures log lines from the runner", async () => {
+        const jm = new JobManager(makeRunner({}));
+        const runId = jm.start({ kind: "tier1" });
+        await Promise.resolve();
+        expect(jm.status(runId)?.logBuffer).toContain("tier1 started");
+    });
+    it("evicts oldest jobs beyond the cap of 20", () => {
+        const jm = new JobManager(makeRunner({ tier1: () => new Promise(() => { }) }));
+        const ids = [];
+        for (let i = 0; i < 25; i++)
+            ids.push(jm.start({ kind: "tier1" }));
+        expect(jm.list().length).toBe(20);
+        expect(jm.status(ids[0])).toBeUndefined(); // oldest evicted
+        expect(jm.status(ids[24])).toBeDefined();
+    });
+    it("cancel returns false for a non-running job", async () => {
+        const d = deferred();
+        const jm = new JobManager(makeRunner({ tier1: () => d.promise }));
+        const runId = jm.start({ kind: "tier1" });
+        expect(jm.cancel(runId)).toBe(true); // first cancel succeeds
+        expect(jm.cancel(runId)).toBe(false); // second cancel: not running
+        expect(jm.cancel("nonexistent")).toBe(false);
+    });
+});
+//# sourceMappingURL=self-verify-jobs.test.js.map

package/dist/src/mcp/__tests__/smart-filter.test.d.ts

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

package/dist/src/mcp/__tests__/smart-filter.test.js

@@ -0,0 +1,121 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { dropRedundantFsMcpTools, filterMcpServersByMessage } from "../smart-filter.js";
+// Minimal shape — the real McpServerConfig has more fields, but the filter only
+// reads `.id`. Using a structural stub keeps the test independent of config.
+const servers = [
+    { id: "filesystem" },
+    { id: "muonroi-tools" },
+    { id: "muonroi-harness" },
+    { id: "context7" },
+    { id: "fetch" },
+    { id: "tavily" },
+    { id: "chrome-devtools" },
+    { id: "playwright" },
+    { id: "figma" },
+];
+const ids = (s) => s.map((x) => x.id);
+describe("filterMcpServersByMessage", () => {
+    it("drops browser AND docs/web servers when the message signals neither", () => {
+        // A pure code prompt with no docs/web/browser vocabulary should not pay for
+        // context7/fetch (docs/web lookup) or chrome/playwright/figma (browser).
+        const out = filterMcpServersByMessage(servers, "fix the auth bug in src/auth/login.ts");
+        expect(ids(out)).toEqual(["filesystem", "muonroi-tools", "muonroi-harness"]);
+    });
+    it("keeps browser servers when a browser signal is present", () => {
+        const out = filterMcpServersByMessage(servers, "take a screenshot of the dashboard");
+        expect(ids(out)).toContain("chrome-devtools");
+        expect(ids(out)).toContain("playwright");
+        expect(ids(out)).toContain("figma");
+    });
+    it("keeps docs/web servers when a docs signal is present", () => {
+        const out = filterMcpServersByMessage(servers, "how do I use the zod library API?");
+        expect(ids(out)).toContain("context7");
+        expect(ids(out)).toContain("fetch");
+        // web-search server is also an external-lookup server → kept on a docs signal.
+        expect(ids(out)).toContain("tavily");
+    });
+    it("drops the web-search server on a pure code prompt (no external-info signal)", () => {
+        const out = filterMcpServersByMessage(servers, "fix the auth bug in src/auth/login.ts");
+        expect(ids(out)).not.toContain("tavily");
+    });
+    it("keeps the web-search server on web-search intent (low-collision terms)", () => {
+        for (const msg of [
+            "search the web for the release date",
+            "look up the latest news on this",
+            "what's the weather today",
+            "find this online",
+            "check the internet for outages",
+        ]) {
+            const out = filterMcpServersByMessage(servers, msg);
+            expect(ids(out), msg).toContain("tavily");
+        }
+    });
+    it("keeps both browser and docs servers when the message has a URL", () => {
+        const out = filterMcpServersByMessage(servers, "summarize https://example.com/article");
+        expect(ids(out)).toContain("context7");
+        expect(ids(out)).toContain("fetch");
+        expect(ids(out)).toContain("chrome-devtools");
+    });
+    it("NEVER drops non-optional domain servers (filesystem / tools / harness)", () => {
+        const out = filterMcpServersByMessage(servers, "Reply with exactly one word: PONG");
+        expect(ids(out)).toContain("filesystem");
+        expect(ids(out)).toContain("muonroi-tools");
+        expect(ids(out)).toContain("muonroi-harness");
+    });
+    it("returns every server unchanged when disabled (MUONROI_DISABLE_SMART_MCP=1)", () => {
+        const out = filterMcpServersByMessage(servers, "Reply PONG", { disabled: true });
+        expect(ids(out)).toEqual(ids(servers));
+    });
+    it("preserves the existing browser-gate vocabulary exactly", () => {
+        // Regression guard: each token that the original inline regex recognised
+        // must still keep browser servers.
+        for (const word of ["browser", "playwright", "chrome", "figma", "canva", "render", "navigate", "click", "scrape"]) {
+            const out = filterMcpServersByMessage(servers, `please ${word} something`);
+            expect(ids(out)).toContain("chrome-devtools");
+        }
+    });
+});
+describe("dropRedundantFsMcpTools", () => {
+    const fn = () => ({});
+    afterEach(() => {
+        delete process.env.MUONROI_KEEP_REDUNDANT_FS_MCP;
+    });
+    it("drops filesystem-MCP read/write/edit tools when the builtin equivalent is present", () => {
+        // Live waste (grok session f5dfab0ce0ca): files re-read via both read_file
+        // and mcp_filesystem__read_text_file.
+        const mcp = {
+            mcp_filesystem__read_text_file: fn,
+            mcp_filesystem__read_file: fn,
+            mcp_filesystem__read_multiple_files: fn,
+            mcp_filesystem__write_file: fn,
+            mcp_filesystem__edit_file: fn,
+            mcp_filesystem__directory_tree: fn, // NOT a builtin dup — keep
+            mcp_filesystem__search_files: fn, // keep
+            mcp_other__read_text_file: fn, // different server — keep
+        };
+        const builtins = new Set(["read_file", "write_file", "edit_file", "bash", "grep", "glob"]);
+        const { tools, dropped } = dropRedundantFsMcpTools(mcp, builtins);
+        expect(dropped.sort()).toEqual([
+            "mcp_filesystem__edit_file",
+            "mcp_filesystem__read_file",
+            "mcp_filesystem__read_multiple_files",
+            "mcp_filesystem__read_text_file",
+            "mcp_filesystem__write_file",
+        ].sort());
+        expect(Object.keys(tools).sort()).toEqual(["mcp_filesystem__directory_tree", "mcp_filesystem__search_files", "mcp_other__read_text_file"].sort());
+    });
+    it("keeps the MCP tool when the builtin equivalent is NOT present (no silent capability loss)", () => {
+        const mcp = { mcp_filesystem__read_text_file: fn };
+        const { tools, dropped } = dropRedundantFsMcpTools(mcp, new Set(["bash"])); // no builtin read_file
+        expect(dropped).toEqual([]);
+        expect(Object.keys(tools)).toEqual(["mcp_filesystem__read_text_file"]);
+    });
+    it("respects MUONROI_KEEP_REDUNDANT_FS_MCP=1 override", () => {
+        process.env.MUONROI_KEEP_REDUNDANT_FS_MCP = "1";
+        const mcp = { mcp_filesystem__read_text_file: fn };
+        const { tools, dropped } = dropRedundantFsMcpTools(mcp, new Set(["read_file"]));
+        expect(dropped).toEqual([]);
+        expect(Object.keys(tools)).toEqual(["mcp_filesystem__read_text_file"]);
+    });
+});
+//# sourceMappingURL=smart-filter.test.js.map

package/dist/src/mcp/__tests__/tools-server.smoke.test.d.ts

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

package/dist/src/mcp/__tests__/tools-server.smoke.test.js

@@ -0,0 +1,42 @@
+/**
+ * tools-server.smoke.test.ts
+ *
+ * Windows note: unlike src/mcp/smoke.test.ts (which skips its stdio handshake on
+ * Windows+Bun citing StdioClientTransport closing stdin immediately), this test runs
+ * fully on Windows with the current MCP SDK. Verified stable across 3 consecutive
+ * native Windows runs (all passed, ~12-22s each). No platform guard needed here.
+ * If this test starts hanging on a future SDK upgrade, add:
+ *   describe.skipIf(process.platform === "win32" || !!process.env.CI)(...)
+ * matching the precedent in the older smoke.test.ts.
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { describe, expect, it } from "vitest";
+describe("tools-mcp server smoke", () => {
+    it("advertises the selfverify_* tools over stdio", async () => {
+        const transport = new StdioClientTransport({
+            command: "bun",
+            args: ["run", "src/index.ts", "tools-mcp"],
+        });
+        const client = new Client({ name: "smoke-test", version: "0" }, { capabilities: {} });
+        await client.connect(transport);
+        try {
+            const { tools } = await client.listTools();
+            const names = tools.map((t) => t.name);
+            expect(names).toContain("selfverify_start");
+            expect(names).toContain("selfverify_status");
+            expect(names).toContain("selfverify_result");
+            expect(names).toContain("selfverify_list");
+            expect(names).toContain("selfverify_cancel");
+            expect(names).toContain("ee_query");
+            expect(names).toContain("ee_feedback");
+            expect(names).toContain("ee_health");
+            expect(names).toContain("usage_forensics");
+            expect(names).toContain("lsp_query");
+        }
+        finally {
+            await client.close();
+        }
+    }, 60_000);
+});
+//# sourceMappingURL=tools-server.smoke.test.js.map

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

@@ -0,0 +1 @@
+export declare function capMcpToolResult(result: unknown, maxChars?: number): unknown;