muonroi-cli 1.4.1 → 1.6.0

package/dist/src/ee/artifact-cache.js

@@ -0,0 +1,155 @@
+/**
+ * src/ee/artifact-cache.ts
+ *
+ * Durable fallback for compaction-elided tool outputs (issue #3 increment 2 /
+ * anti-mù durability).
+ *
+ * When B3/B4 compaction rewrites a low-value tool result into a ~200-char stub,
+ * the full content is shipped to the Experience Engine (source="tool-artifact")
+ * so a later `ee_query("tool-artifact id=X")` can rehydrate it. But that recovery
+ * depends on EE (Qdrant/HTTP) being reachable. This module is the EE-independent
+ * recovery path, in two tiers:
+ *   - in-process LRU (keyed by toolCallId): authoritative full content for THIS
+ *     session, instant, survives an EE outage mid-session;
+ *   - append-only disk spill (~/.muonroi-cli/artifact-cache.jsonl): survives a
+ *     PROCESS RESTART too, so a restart + EE-down double-failure can still
+ *     rehydrate. Disable with MUONROI_ARTIFACT_CACHE_DISK=0.
+ *
+ * ee_query reads in-memory first, then disk, then falls back to EE /api/search
+ * (the cross-session source). Both tiers are bounded; both are best-effort and
+ * fail-open (a disk error never breaks recall).
+ */
+import { appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const DEFAULT_MAX_ENTRIES = 100;
+/** Per-entry cap so one giant output can't dominate the footprint. */
+const MAX_CONTENT_CHARS = 200_000;
+/** Disk-file size cap; on overflow the file is reset (EE retains older artifacts). */
+const DISK_MAX_BYTES = 8 * 1024 * 1024;
+const store = new Map();
+let maxEntries = DEFAULT_MAX_ENTRIES;
+let diskPathOverride = null;
+const pendingWrites = new Set();
+function diskEnabled() {
+    return process.env.MUONROI_ARTIFACT_CACHE_DISK !== "0";
+}
+function diskPath() {
+    return diskPathOverride ?? path.join(os.homedir(), ".muonroi-cli", "artifact-cache.jsonl");
+}
+/** Extract the id from a "tool-artifact id=<id>" / "full tool result id=<id>" query. */
+function extractArtifactId(query) {
+    const m = /\bid\s*=\s*["']?([A-Za-z0-9_\-:.]+)/i.exec(query || "");
+    return m ? m[1] : null;
+}
+/**
+ * Record an elided tool output by toolCallId. In-memory set is synchronous;
+ * the disk append is fire-and-forget (tracked so tests can flush it). No-ops on
+ * empty id/content.
+ */
+export function recordArtifact(toolCallId, toolName, content) {
+    if (!toolCallId || typeof content !== "string" || content.length === 0)
+        return;
+    const capped = content.slice(0, MAX_CONTENT_CHARS);
+    if (store.has(toolCallId))
+        store.delete(toolCallId); // refresh recency
+    store.set(toolCallId, { toolName: toolName || "", content: capped });
+    while (store.size > maxEntries) {
+        const oldest = store.keys().next().value;
+        if (oldest === undefined)
+            break;
+        store.delete(oldest);
+    }
+    if (diskEnabled()) {
+        const w = appendArtifactToDisk(toolCallId, toolName || "", capped).catch((err) => {
+            console.error(`[artifact-cache] disk append failed: ${err?.message}`);
+        });
+        pendingWrites.add(w);
+        void w.finally(() => pendingWrites.delete(w));
+    }
+}
+/** The actual disk append (awaitable). Resets the file when it exceeds the size cap. */
+export async function appendArtifactToDisk(toolCallId, toolName, content) {
+    const p = diskPath();
+    await mkdir(path.dirname(p), { recursive: true });
+    try {
+        const s = await stat(p);
+        if (s.size > DISK_MAX_BYTES)
+            await writeFile(p, "");
+    }
+    catch {
+        /* file does not exist yet — nothing to cap */
+    }
+    await appendFile(p, `${JSON.stringify({ id: toolCallId, toolName, content })}\n`);
+}
+/** Exact in-memory lookup by toolCallId. */
+export function getArtifact(toolCallId) {
+    if (!toolCallId)
+        return null;
+    return store.get(toolCallId) ?? null;
+}
+/**
+ * Synchronous in-memory lookup from a contract query string. Returns null when
+ * the query has no id= or the id is not in the in-process LRU.
+ */
+export function findArtifactByQuery(query) {
+    const id = extractArtifactId(query);
+    if (!id)
+        return null;
+    const hit = store.get(id);
+    return hit ? { toolCallId: id, toolName: hit.toolName, content: hit.content } : null;
+}
+/**
+ * Disk-tier lookup (survives restart). Scans the spill file newest-first so the
+ * most recent record for an id wins. Fail-open: a missing/corrupt file yields
+ * null, never throws.
+ */
+export async function findArtifactOnDisk(query) {
+    if (!diskEnabled())
+        return null;
+    const id = extractArtifactId(query);
+    if (!id)
+        return null;
+    let text;
+    try {
+        text = await readFile(diskPath(), "utf8");
+    }
+    catch {
+        return null; // no spill file yet
+    }
+    const lines = text.split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        try {
+            const row = JSON.parse(line);
+            if (row.id === id)
+                return { toolCallId: id, toolName: row.toolName ?? "", content: row.content ?? "" };
+        }
+        catch {
+            /* skip a torn/partial append line */
+        }
+    }
+    return null;
+}
+// ─── Test hooks ──────────────────────────────────────────────────────────────
+export function __resetArtifactCacheForTests() {
+    store.clear();
+    maxEntries = DEFAULT_MAX_ENTRIES;
+    diskPathOverride = null;
+}
+export function __setArtifactCacheMaxForTests(n) {
+    maxEntries = Math.max(1, n);
+}
+export function __setArtifactCacheDiskPathForTests(p) {
+    diskPathOverride = p;
+}
+export function __artifactCacheSize() {
+    return store.size;
+}
+/** Await all in-flight fire-and-forget disk writes (deterministic tests). */
+export async function flushArtifactDiskWrites() {
+    await Promise.allSettled([...pendingWrites]);
+}
+//# sourceMappingURL=artifact-cache.js.map

package/dist/src/ee/artifact-cache.test.d.ts

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

package/dist/src/ee/artifact-cache.test.js

@@ -0,0 +1,69 @@
+import { rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { __artifactCacheSize, __resetArtifactCacheForTests, __setArtifactCacheDiskPathForTests, __setArtifactCacheMaxForTests, appendArtifactToDisk, findArtifactByQuery, findArtifactOnDisk, flushArtifactDiskWrites, getArtifact, recordArtifact, } from "./artifact-cache.js";
+// Redirect the disk spill to a temp file for EVERY test so recordArtifact never
+// writes the real ~/.muonroi-cli/artifact-cache.jsonl.
+const diskFile = path.join(os.tmpdir(), `muonroi-artifact-cache-test-${process.pid}.jsonl`);
+beforeEach(() => __setArtifactCacheDiskPathForTests(diskFile));
+afterEach(async () => {
+    __resetArtifactCacheForTests();
+    delete process.env.MUONROI_ARTIFACT_CACHE_DISK;
+    await rm(diskFile, { force: true });
+});
+describe("artifact-cache (in-memory tier — durable rehydrate when EE is down)", () => {
+    it("records and retrieves an elided output by toolCallId", () => {
+        recordArtifact("call_7", "read_file", "FULL CONTENT of src/auth.ts");
+        expect(getArtifact("call_7")).toEqual({ toolName: "read_file", content: "FULL CONTENT of src/auth.ts" });
+        expect(getArtifact("missing")).toBeNull();
+    });
+    it("no-ops on empty id or empty content", () => {
+        recordArtifact("", "read_file", "x");
+        recordArtifact("call_x", "read_file", "");
+        expect(__artifactCacheSize()).toBe(0);
+    });
+    it("findArtifactByQuery extracts the id from the contract query strings", () => {
+        recordArtifact("abc123", "grep", "GREP HITS");
+        expect(findArtifactByQuery("tool-artifact id=abc123")?.content).toBe("GREP HITS");
+        expect(findArtifactByQuery("full tool result id=abc123")?.toolCallId).toBe("abc123");
+        expect(findArtifactByQuery("tool-artifact  ID = abc123")?.content).toBe("GREP HITS"); // spacing/case
+        expect(findArtifactByQuery("tool-artifact id=nope")).toBeNull(); // not cached
+        expect(findArtifactByQuery("no id here")).toBeNull(); // no id=
+    });
+    it("evicts the oldest entries past the LRU cap; re-recording refreshes recency", () => {
+        __setArtifactCacheMaxForTests(2);
+        recordArtifact("a", "t", "A");
+        recordArtifact("b", "t", "B");
+        recordArtifact("a", "t", "A2"); // touch 'a' → now 'b' is oldest
+        recordArtifact("c", "t", "C"); // evicts 'b'
+        expect(getArtifact("a")?.content).toBe("A2");
+        expect(getArtifact("c")?.content).toBe("C");
+        expect(getArtifact("b")).toBeNull();
+        expect(__artifactCacheSize()).toBe(2);
+    });
+});
+describe("artifact-cache (disk spill — survives a process restart)", () => {
+    it("rehydrates from disk after the in-memory tier is gone (simulated restart)", async () => {
+        recordArtifact("call_disk", "read_file", "PERSISTED CONTENT");
+        await flushArtifactDiskWrites();
+        // Simulate a restart: in-memory tier cleared, but the disk file persists.
+        __resetArtifactCacheForTests();
+        __setArtifactCacheDiskPathForTests(diskFile);
+        expect(findArtifactByQuery("tool-artifact id=call_disk")).toBeNull(); // memory gone
+        const onDisk = await findArtifactOnDisk("tool-artifact id=call_disk");
+        expect(onDisk?.content).toBe("PERSISTED CONTENT");
+        expect(onDisk?.toolName).toBe("read_file");
+    });
+    it("newest record for an id wins on disk", async () => {
+        await appendArtifactToDisk("dup", "t", "OLD");
+        await appendArtifactToDisk("dup", "t", "NEW");
+        expect((await findArtifactOnDisk("tool-artifact id=dup"))?.content).toBe("NEW");
+    });
+    it("respects MUONROI_ARTIFACT_CACHE_DISK=0 (no disk read)", async () => {
+        await appendArtifactToDisk("x", "t", "C");
+        process.env.MUONROI_ARTIFACT_CACHE_DISK = "0";
+        expect(await findArtifactOnDisk("tool-artifact id=x")).toBeNull();
+    });
+});
+//# sourceMappingURL=artifact-cache.test.js.map

package/dist/src/ee/auth.d.ts

@@ -15,6 +15,15 @@ export declare function loadEEAuthToken(opts?: {
 export declare function refreshAuthToken(opts?: {
     home?: string;
 }): Promise<string | null>;
+/**
+ * Merge a partial config into ~/.experience/config.json (creating the file +
+ * directory if absent), preserving any fields the EE installer or the user
+ * already wrote. Used by the first-run EE setup step. Throws on write failure so
+ * the caller can surface it (never silently swallow — the user asked to set this up).
+ */
+export declare function writeExperienceConfig(patch: Partial<ExperienceConfig>, opts?: {
+    home?: string;
+}): Promise<void>;
 export declare function getCachedAuthToken(): string | null;
 export declare function getEmbeddingModelVersion(): string;
 export declare function getCachedServerBaseUrl(): string | null;

package/dist/src/ee/auth.js

@@ -39,6 +39,25 @@ export async function refreshAuthToken(opts = {}) {
     _token = null;
     return await loadEEAuthToken(opts);
 }
+/**
+ * Merge a partial config into ~/.experience/config.json (creating the file +
+ * directory if absent), preserving any fields the EE installer or the user
+ * already wrote. Used by the first-run EE setup step. Throws on write failure so
+ * the caller can surface it (never silently swallow — the user asked to set this up).
+ */
+export async function writeExperienceConfig(patch, opts = {}) {
+    const p = configPath(opts.home);
+    let existing = {};
+    try {
+        existing = JSON.parse(await fs.readFile(p, "utf8"));
+    }
+    catch {
+        // No existing config (or unreadable) — start fresh.
+    }
+    const merged = { ...existing, ...patch };
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    await fs.writeFile(p, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
+}
 export function getCachedAuthToken() {
     return _token;
 }

package/dist/src/ee/ee-onboarding.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns true when a config was written (so the caller can reload EE auth).
+ * Returns false when skipped or invalid.
+ */
+export declare function firstRunEESetup(): Promise<boolean>;

package/dist/src/ee/ee-onboarding.js

@@ -0,0 +1,76 @@
+/**
+ * First-run Experience Engine setup (interactive, readline — runs BEFORE any TUI
+ * code, same pattern as the credential wizard). Offers to connect an EE server
+ * and writes ~/.experience/config.json so the agent's record/recall/feedback
+ * loop (ee_query / ee_feedback via muonroi-tools) has a brain to talk to.
+ *
+ * Optional + skippable: a blank URL skips. No hardcoded fallback — a failed
+ * health probe is reported, not hidden, and never blocks setup.
+ */
+import { createInterface } from "node:readline";
+import { writeExperienceConfig } from "./auth.js";
+/** Best-effort reachability probe — returns true/false, never throws. */
+async function probeHealth(baseUrl, token) {
+    try {
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), 4000);
+        try {
+            const res = await fetch(`${baseUrl}/health`, {
+                signal: ac.signal,
+                headers: token ? { authorization: `Bearer ${token}` } : undefined,
+            });
+            return res.ok;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Returns true when a config was written (so the caller can reload EE auth).
+ * Returns false when skipped or invalid.
+ */
+export async function firstRunEESetup() {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    const ask = (q) => new Promise((resolve) => rl.question(q, (a) => resolve(a)));
+    try {
+        process.stderr.write("\nExperience Engine (optional) — a shared brain that recalls past decisions, gotchas,\n" +
+            "and recipes so the agent works like a senior on your stack. You can set this up later\n" +
+            "by editing ~/.experience/config.json or setting MUONROI_EE_BASE_URL.\n\n");
+        const url = (await ask("EE server URL (blank to skip): ")).trim();
+        if (!url) {
+            process.stderr.write("Skipped Experience Engine setup.\n");
+            return false;
+        }
+        let normalized;
+        try {
+            normalized = new URL(url).toString().replace(/\/$/, "");
+        }
+        catch {
+            process.stderr.write("That doesn't look like a valid URL — skipped EE setup.\n");
+            return false;
+        }
+        const token = (await ask("EE auth token (blank if the server needs none): ")).trim();
+        await writeExperienceConfig({
+            serverBaseUrl: normalized,
+            ...(token ? { serverAuthToken: token } : {}),
+        });
+        process.stderr.write(`Wrote Experience Engine config → ~/.experience/config.json (serverBaseUrl=${normalized}).\n`);
+        const reachable = await probeHealth(normalized, token || undefined);
+        process.stderr.write(reachable
+            ? "  ✓ EE server reachable.\n"
+            : "  ⚠ Could not reach the EE server right now (saved anyway — run 'muonroi-cli doctor' to recheck).\n");
+        return true;
+    }
+    catch (err) {
+        process.stderr.write(`\nEE setup failed: ${err?.message ?? String(err)} — skipped.\n`);
+        return false;
+    }
+    finally {
+        rl.close();
+    }
+}
+//# sourceMappingURL=ee-onboarding.js.map

package/dist/src/ee/search.js

@@ -97,11 +97,13 @@ export async function mirrorRecallLocally(query, meta, logPath) {
  * unavailability/timeout — never throws for transport errors.
  */
 export async function searchEE(query, opts = {}) {
-    const { createEEClient } = await import("./client.js");
-    const { loadEEAuthToken, getCachedServerBaseUrl } = await import("./auth.js");
-    const authToken = (await loadEEAuthToken()) ?? undefined;
-    const baseUrl = getCachedServerBaseUrl() ?? undefined;
-    return createEEClient({ baseUrl, authToken }).search(query, opts);
+    // Route through the shared injectable default client (same one the WRITE leg
+    // persistArtifact → getDefaultEEClient().extract uses), NOT a fresh per-call
+    // client. This unifies the anti-mù seam: setDefaultEEClient now intercepts BOTH
+    // the artifact write and the artifact READ leg, and the default client carries
+    // the boot-loaded token + 401 refresh maintained by intercept.ts.
+    const { getDefaultEEClient } = await import("./intercept.js");
+    return getDefaultEEClient().search(query, opts);
 }
 /**
  * Active recall over the EE brain via /api/recall (recallMode) — the fixed

package/dist/src/ee/search.test.d.ts

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

package/dist/src/ee/search.test.js

@@ -0,0 +1,23 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { setDefaultEEClient } from "./intercept.js";
+import { searchEE } from "./search.js";
+// Issue #3 seam: searchEE used to build a FRESH createEEClient, so the artifact
+// READ leg (ee_query "tool-artifact id=X") could not be intercepted by
+// setDefaultEEClient — while the WRITE leg (persistArtifact → getDefaultEEClient
+// .extract) could. Routing searchEE through getDefaultEEClient unifies the seam:
+// one injected client now intercepts both legs (testable end-to-end + the spot a
+// durability fallback can hook).
+describe("searchEE — routes through the injectable default EE client", () => {
+    afterEach(() => {
+        setDefaultEEClient(null); // teardown → next getDefaultEEClient lazy-inits a real one
+    });
+    it("uses getDefaultEEClient().search so the artifact READ leg is interceptable", async () => {
+        const fakeResp = { results: [{ id: "x", text: "REHYDRATED" }] };
+        const search = vi.fn().mockResolvedValue(fakeResp);
+        setDefaultEEClient({ search });
+        const out = await searchEE("tool-artifact id=x", { collections: ["experience-behavioral"], limit: 1 });
+        expect(search).toHaveBeenCalledWith("tool-artifact id=x", { collections: ["experience-behavioral"], limit: 1 });
+        expect(out).toBe(fakeResp);
+    });
+});
+//# sourceMappingURL=search.test.js.map

package/dist/src/generated/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.4.1";
+export declare const PACKAGE_VERSION = "1.6.0";
 export declare const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";

package/dist/src/generated/version.js

@@ -1,5 +1,5 @@
 // AUTO-GENERATED by scripts/sync-version.cjs. DO NOT EDIT BY HAND.
 // Sourced from package.json at build time so it survives bun --compile bundling.
-export const PACKAGE_VERSION = "1.4.1";
+export const PACKAGE_VERSION = "1.6.0";
 export const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";
 //# sourceMappingURL=version.js.map

package/dist/src/headless/output.js

@@ -5,10 +5,12 @@ export function renderHeadlessPrelude(format, sessionId) {
     if (format === "json") {
         return {};
     }
-    return {
-        stdout: "\x1b[36m⏳ Processing...\x1b[0m\n",
-        stderr: sessionId ? `\x1b[2mSession: ${sessionId}\x1b[0m\n` : undefined,
-    };
+    // Status indicator + session id are progress UX, not the reply. Keep stdout
+    // pure (only the model's answer) so `--format text` pipes cleanly. VERIFY F3.
+    const statusLines = ["\x1b[36m⏳ Processing...\x1b[0m"];
+    if (sessionId)
+        statusLines.push(`\x1b[2mSession: ${sessionId}\x1b[0m`);
+    return { stderr: `${statusLines.join("\n")}\n` };
 }
 /**
  * Headless text output only. JSON streaming uses {@link createHeadlessJsonlEmitter} + `Agent.processMessage` observer.

package/dist/src/headless/output.test.js

@@ -25,10 +25,11 @@ describe("headless output helpers", () => {
         expect(isHeadlessOutputFormat("json")).toBe(true);
         expect(isHeadlessOutputFormat("xml")).toBe(false);
     });
-    it("renders the text prelude with session metadata", () => {
+    it("renders the text prelude with status on stderr (stdout stays pure for piping)", () => {
+        // VERIFY F3: spinner + session id are progress UX, not the reply — both go
+        // to stderr so `--format text` stdout contains only the model's answer.
         expect(renderHeadlessPrelude("text", "session-123")).toEqual({
-            stdout: "\u001b[36m⏳ Processing...\u001b[0m\n",
-            stderr: "\u001b[2mSession: session-123\u001b[0m\n",
+            stderr: "⏳ Processing...\nSession: session-123\n",
         });
     });
     it("suppresses the prelude in json mode", () => {

package/dist/src/index.js

@@ -982,8 +982,27 @@ program
         }
     }
     // Bootstrap EE auth (loads serverBaseUrl + token from ~/.experience/config.json)
-    const { loadEEAuthToken } = await import("./ee/auth.js");
+    const { loadEEAuthToken, getCachedServerBaseUrl } = await import("./ee/auth.js");
     await loadEEAuthToken().catch(() => { });
+    // First-run EE setup (interactive, once per install): if no EE server is
+    // configured, offer to connect one + write ~/.experience/config.json so the
+    // agent's record/recall/feedback loop has a brain. One-time, flag-gated.
+    if (isInteractive) {
+        try {
+            const { loadUserSettings, saveUserSettings } = await import("./utils/settings.js");
+            if (loadUserSettings().eeSetupPrompted !== true && !getCachedServerBaseUrl()) {
+                const { firstRunEESetup } = await import("./ee/ee-onboarding.js");
+                const wrote = await firstRunEESetup();
+                if (wrote)
+                    await loadEEAuthToken().catch(() => { });
+                saveUserSettings({ eeSetupPrompted: true });
+            }
+        }
+        catch (err) {
+            if (process.env.MUONROI_DEBUG)
+                console.error(`[muonroi-cli] EE first-run setup skipped: ${err?.message}`);
+        }
+    }
     // Auto-detect EE client mode (thin / thin-degraded / fat / disabled).
     // Result is cached for downstream callsites (PIL layers, bridge.searchByText)
     // so each request doesn't re-probe.

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

@@ -33,6 +33,80 @@ describe("ensureDefaultMcpServers — research servers", () => {
         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();

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

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