muonroi-cli 1.7.2 → 1.8.1

package/dist/src/lsp/client-normalize.test.js

@@ -0,0 +1,34 @@
+/**
+ * src/lsp/client-normalize.test.ts
+ *
+ * Regression guard for the Windows diagnostics-cache key mismatch: the LSP
+ * client stores publishDiagnostics under normalizeUriPath(uri) (a LOWERCASE
+ * drive, decoded from `file:///c%3A/…`) but retrieves under
+ * normalizeFsPath(path.resolve(...)) (the cwd's UPPERCASE drive). Without
+ * canonicalizing the drive letter the keys never matched, so diagnostics were
+ * permanently [] on Windows — silently breaking write-time LSP feedback AND the
+ * commit gate. normalizeFsPath must produce the SAME key for both casings.
+ */
+import { describe, expect, it } from "vitest";
+import { normalizeFsPath } from "./client.js";
+describe("normalizeFsPath", () => {
+    it("converts backslashes to forward slashes", () => {
+        expect(normalizeFsPath("C:\\Users\\x\\bug.ts")).toBe("c:/Users/x/bug.ts");
+    });
+    it("lowercases the Windows drive letter so store/retrieve keys converge", () => {
+        // The whole point: an UPPERCASE-drive query path and a LOWERCASE-drive
+        // publishDiagnostics URI path must normalize to the identical cache key.
+        expect(normalizeFsPath("C:/Users/x/bug.ts")).toBe(normalizeFsPath("c:/Users/x/bug.ts"));
+        expect(normalizeFsPath("C:/Users/x/bug.ts")).toBe("c:/Users/x/bug.ts");
+        expect(normalizeFsPath("D:\\proj\\a.ts")).toBe("d:/proj/a.ts");
+    });
+    it("leaves POSIX absolute paths untouched (no drive letter)", () => {
+        expect(normalizeFsPath("/home/u/bug.ts")).toBe("/home/u/bug.ts");
+    });
+    it("does not mangle a non-drive leading segment", () => {
+        // Only a single leading letter + ":/" is a drive; a path segment that
+        // merely starts with a letter must be preserved.
+        expect(normalizeFsPath("src/lsp/client.ts")).toBe("src/lsp/client.ts");
+    });
+});
+//# sourceMappingURL=client-normalize.test.js.map

package/dist/src/lsp/client.d.ts

@@ -18,3 +18,4 @@ export interface LspClientSession {
     stop(): Promise<void>;
 }
 export declare function createLspClientSession(options: LspClientOptions): Promise<LspClientSession>;
+export declare function normalizeFsPath(filePath: string): string;

package/dist/src/lsp/client.js

@@ -267,8 +267,16 @@ function normalizeUriPath(uri) {
     }
     return normalizeFsPath(uri);
 }
-function normalizeFsPath(filePath) {
-    return filePath.replace(/\\/g, "/");
+export function normalizeFsPath(filePath) {
+    const slashed = filePath.replace(/\\/g, "/");
+    // Windows drive letters are case-insensitive, but the two sides of the
+    // diagnostics cache disagree on case: publishDiagnostics URIs decode to a
+    // LOWERCASE drive (tsserver emits `file:///c%3A/…`), while query paths come
+    // from `path.resolve(cwd, …)` which yields the cwd's (usually UPPERCASE)
+    // drive. Without canonicalizing the drive, diagnostics stored under `c:/…`
+    // are never found under `C:/…` → the cache always returns [] on Windows
+    // (silently breaking both write-time LSP feedback and the commit gate).
+    return slashed.replace(/^([a-zA-Z]):\//, (_m, d) => `${d.toLowerCase()}:/`);
 }
 function ensureActive(stopped, serverId) {
     if (stopped) {

package/dist/src/lsp/manager.d.ts

@@ -11,7 +11,7 @@ interface WorkspaceLspManagerOptions {
 }
 export interface WorkspaceLspManager {
     touchFile(filePath: string, waitForDiagnostics?: boolean): Promise<LspDiagnosticFile[]>;
-    syncFile(filePath: string, content: string, save?: boolean, waitForDiagnostics?: boolean): Promise<LspDiagnosticFile[]>;
+    syncFile(filePath: string, content: string, save?: boolean, waitForDiagnostics?: boolean, diagnosticsTimeoutMs?: number): Promise<LspDiagnosticFile[]>;
     query(input: LspQueryInput): Promise<LspToolResponse>;
     close(): Promise<void>;
 }

package/dist/src/lsp/manager.js

@@ -64,10 +64,18 @@ export function createWorkspaceLspManager(cwd, settings, options = {}) {
         return resolved.filter((value) => value !== null);
     }
     async function touchFile(filePath, waitForDiagnostics = true) {
-        const content = await readFile(filePath, "utf8");
-        return syncFile(filePath, content, false, waitForDiagnostics);
+        try {
+            const content = await readFile(filePath, "utf8");
+            return await syncFile(filePath, content, false, waitForDiagnostics);
+        }
+        catch (err) {
+            if (err instanceof Error && err.code === "ENOENT") {
+                return [];
+            }
+            throw err;
+        }
     }
-    async function syncFile(filePath, content, save = true, waitForDiagnostics = true) {
+    async function syncFile(filePath, content, save = true, waitForDiagnostics = true, diagnosticsTimeoutMs) {
         const records = await getClientsForFile(filePath);
         if (records.length === 0)
             return [];
@@ -80,7 +88,7 @@ export function createWorkspaceLspManager(cwd, settings, options = {}) {
                     await client.saveFile(filePath);
                 }
                 if (waitForDiagnostics) {
-                    await client.waitForDiagnostics(filePath);
+                    await client.waitForDiagnostics(filePath, diagnosticsTimeoutMs);
                 }
                 return {
                     filePath,
@@ -104,7 +112,7 @@ export function createWorkspaceLspManager(cwd, settings, options = {}) {
                 output: `No LSP server available for ${path.extname(normalizedPath) || "this file type"}.`,
             };
         }
-        const lspDiagnostics = await touchFile(normalizedPath, true);
+        const lspDiagnostics = input.operation === "workspaceSymbol" ? [] : await touchFile(normalizedPath, true);
         const params = createOperationParams(input, normalizedPath);
         const timeoutMs = settings.requestTimeoutMs;
         const results = (await Promise.all(records.map(async ({ key, client }) => {

package/dist/src/lsp/manager.test.js

@@ -60,7 +60,7 @@ describe("createWorkspaceLspManager", () => {
         expect(result.success).toBe(true);
         expect(result.output).toContain("file:///demo.ts");
         expect(client.openOrChangeFile).toHaveBeenCalledWith(filePath, "typescript", "const demo = 1;\n");
-        expect(client.waitForDiagnostics).toHaveBeenCalledWith(filePath);
+        expect(client.waitForDiagnostics).toHaveBeenCalledWith(filePath, undefined);
         await manager.close();
         expect(client.stop).toHaveBeenCalled();
     });
@@ -92,7 +92,7 @@ describe("createWorkspaceLspManager", () => {
         const result = await manager.syncFile(filePath, "const broken = true;\n", true, true);
         expect(result).toEqual(diagnostics);
         expect(client.saveFile).toHaveBeenCalledWith(filePath);
-        expect(client.waitForDiagnostics).toHaveBeenCalledWith(filePath);
+        expect(client.waitForDiagnostics).toHaveBeenCalledWith(filePath, undefined);
         await manager.close();
     });
     it("times out a hanging request without dropping the client", async () => {
@@ -131,6 +131,45 @@ describe("createWorkspaceLspManager", () => {
         expect(result.output).toContain("No LSP server available");
         await manager.close();
     });
+    it("handles missing files gracefully and avoids touchFile on workspaceSymbol", async () => {
+        const root = await createTempWorkspace();
+        const filePath = path.join(root, "nonexistent.ts");
+        const sendRequest = vi.fn(async (method, params) => {
+            expect(method).toBe("workspace/symbol");
+            expect(params).toEqual({ query: "my-query" });
+            return [
+                {
+                    name: "MySymbol",
+                    kind: 1,
+                    location: {
+                        uri: "file:///demo.ts",
+                        range: { start: { line: 0, character: 0 }, end: { line: 0, character: 8 } },
+                    },
+                },
+            ];
+        });
+        const client = createFakeClient({ sendRequest });
+        const manager = createWorkspaceLspManager(root, BASE_SETTINGS, {
+            createClient: async () => client,
+        });
+        const result = await manager.query({
+            operation: "workspaceSymbol",
+            filePath,
+            query: "my-query",
+        });
+        expect(result.success).toBe(true);
+        expect(result.output).toContain("MySymbol");
+        expect(client.openOrChangeFile).not.toHaveBeenCalled();
+        const resultDef = await manager.query({
+            operation: "goToDefinition",
+            filePath,
+            line: 1,
+            character: 1,
+        });
+        expect(resultDef.success).toBe(true);
+        expect(resultDef.output).toContain("No results found");
+        await manager.close();
+    });
 });
 async function createTempWorkspace() {
     const root = await mkdtemp(path.join(os.tmpdir(), "muonroi-lsp-manager-"));

package/dist/src/lsp/runtime.d.ts

@@ -1,6 +1,6 @@
 import type { LspDiagnosticFile, LspQueryInput, LspToolResponse } from "./types.js";
 export declare function queryLsp(cwd: string, input: LspQueryInput): Promise<LspToolResponse>;
-export declare function syncFileWithLsp(cwd: string, filePath: string, content: string, save?: boolean, waitForDiagnostics?: boolean): Promise<LspDiagnosticFile[]>;
+export declare function syncFileWithLsp(cwd: string, filePath: string, content: string, save?: boolean, waitForDiagnostics?: boolean, diagnosticsTimeoutMs?: number): Promise<LspDiagnosticFile[]>;
 export declare function isLspToolEnabled(_cwd: string): boolean;
 export declare function summarizeDiagnostics(diagnostics: LspDiagnosticFile[]): string | null;
 export declare function shutdownWorkspaceLspManager(cwd: string): Promise<void>;

package/dist/src/lsp/runtime.js

@@ -10,9 +10,9 @@ export async function queryLsp(cwd, input) {
         filePath: path.isAbsolute(input.filePath) ? input.filePath : path.resolve(cwd, input.filePath),
     });
 }
-export async function syncFileWithLsp(cwd, filePath, content, save = true, waitForDiagnostics = true) {
+export async function syncFileWithLsp(cwd, filePath, content, save = true, waitForDiagnostics = true, diagnosticsTimeoutMs) {
     const manager = getOrCreateManager(cwd);
-    return manager.syncFile(path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath), content, save, waitForDiagnostics);
+    return manager.syncFile(path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath), content, save, waitForDiagnostics, diagnosticsTimeoutMs);
 }
 export function isLspToolEnabled(_cwd) {
     const settings = getCurrentLspSettings();

package/dist/src/maintain/__tests__/gh-create-pr.test.js

@@ -12,9 +12,13 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 // ── Mocks ──────────────────────────────────────────────────────────────────
 // vi.hoisted ensures the factory variable is available when vi.mock is hoisted.
 const { mockExecFile } = vi.hoisted(() => ({ mockExecFile: vi.fn() }));
-vi.mock("node:child_process", () => ({
-    execFile: mockExecFile,
-}));
+vi.mock("node:child_process", async () => {
+    const actual = await vi.importActual("node:child_process");
+    return {
+        ...actual,
+        execFile: mockExecFile,
+    };
+});
 vi.mock("node:fs", async (importOriginal) => {
     const actual = (await importOriginal());
     return {

package/dist/src/maintain/__tests__/pr-builder.test.js

@@ -11,9 +11,13 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 // ── Mocks ──────────────────────────────────────────────────────────────────
 // vi.hoisted ensures the factory variable is available when vi.mock is hoisted.
 const { mockExecFile } = vi.hoisted(() => ({ mockExecFile: vi.fn() }));
-vi.mock("node:child_process", () => ({
-    execFile: mockExecFile,
-}));
+vi.mock("node:child_process", async () => {
+    const actual = await vi.importActual("node:child_process");
+    return {
+        ...actual,
+        execFile: mockExecFile,
+    };
+});
 vi.mock("../../council/leader.js", () => ({
     pickCouncilTaskModel: vi.fn((_task, leaderId) => leaderId),
 }));

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

@@ -54,7 +54,7 @@ describe("acquireMcpTools — cross-turn client pool", () => {
             client: { close: async () => { } },
         }));
         const b1 = await acquireMcpTools([srv("fs")]);
-        await expect(b1.tools["mcp_fs__boom"].execute({}, {})).rejects.toThrow(/transport closed/);
+        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);
     });
@@ -77,7 +77,7 @@ describe("acquireMcpTools — cross-turn client pool", () => {
             };
         });
         const b = await acquireMcpTools([srv("docs")]);
-        const result = await b.tools["mcp_docs__ping"].execute({}, {});
+        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
     });
@@ -104,7 +104,7 @@ describe("acquireMcpTools — cross-turn client pool", () => {
             };
         });
         const b = await acquireMcpTools([srv("docs")]);
-        const tool = b.tools["mcp_docs__ping"];
+        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

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

@@ -46,7 +46,7 @@ describe("ee-tools", () => {
             }),
             health: async () => ({ ok: true, status: 200 }),
         }));
-        const out = rawTextOf(await handlers["ee_query"]({ query: "redactor" }));
+        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
@@ -58,7 +58,7 @@ describe("ee-tools", () => {
             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 }));
+        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");
@@ -73,18 +73,18 @@ describe("ee-tools", () => {
             },
             health: async () => ({ ok: true, status: 200 }),
         }));
-        await handlers["ee_query"]({ query: "scope filter", project: "storyflow" });
+        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" }));
+        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"]({}));
+        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 () => {
@@ -94,7 +94,7 @@ describe("ee-tools", () => {
                 throw new Error("boom");
             },
         }));
-        const out = textOf(await handlers["ee_health"]({}));
+        const out = textOf(await handlers.ee_health({}));
         expect(out.isError).toBe(true);
         expect(out.json.error).toBe("ee_unavailable");
     });
@@ -111,7 +111,7 @@ describe("ee-tools", () => {
                 return { ok: true, resolvedId: id, verdict: verdict === "followed" ? "FOLLOWED" : verdict };
             },
         }));
-        const out = textOf(await handlers["ee_feedback"]({ id: "abc", collection: "experience-behavioral", verdict: "followed" }));
+        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);
@@ -120,7 +120,7 @@ describe("ee-tools", () => {
     });
     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" }));
+        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");
     });
@@ -128,7 +128,7 @@ describe("ee-tools", () => {
         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" }));
+        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
@@ -145,11 +145,11 @@ describe("ee-tools", () => {
             health: async () => ({ ok: true, status: 200 }),
         }));
         // First recall — no prior debt, so no gate prefix.
-        const first = rawTextOf(await handlers["ee_query"]({ query: "first" }));
+        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" }));
+        const second = rawTextOf(await handlers.ee_query({ query: "second" }));
         expect(second.isError).toBeFalsy();
         expect(second.text).toContain("still unrated");
         expect(second.text).toContain("id1");
@@ -172,7 +172,7 @@ describe("ee-tools", () => {
                 return { text: "should not run", entries: [], count: 0 };
             },
         }));
-        const out = textOf(await handlers["ee_query"]({ query: "blocked" }));
+        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");
@@ -190,9 +190,37 @@ describe("ee-tools", () => {
             }),
             health: async () => ({ ok: true, status: 200 }),
         }));
-        await handlers["ee_query"]({ query: "one" });
-        await handlers["ee_query"]({ query: "two" });
+        await handlers.ee_query({ query: "one" });
+        await handlers.ee_query({ query: "two" });
         expect(ledger.pendingCount()).toBe(0); // nothing stamped when gate is off
     });
+    // ─── ee_write (Layer 1 — agent records a new lesson) ───────────────────────
+    it("ee_write forwards the lesson to the write helper and returns the new id", async () => {
+        let seen = null;
+        const handlers = collectTools((s) => registerEETools(s, {
+            write: async (lesson, opts) => {
+                seen = { lesson, opts };
+                return { ok: true, id: "new-point-1" };
+            },
+        }));
+        const out = textOf(await handlers.ee_write({
+            lesson: "always call flushFrob() before reindex or reads go stale",
+            title: "reindex pitfall",
+            project: "experience-engine",
+        }));
+        expect(out.isError).toBeFalsy();
+        expect(out.json.ok).toBe(true);
+        expect(out.json.id).toBe("new-point-1");
+        expect(out.json.collection).toBe("experience-behavioral");
+        expect(seen.lesson).toContain("flushFrob");
+        expect(seen.opts.collection).toBe("experience-behavioral");
+        expect(seen.opts.projectSlug).toBe("experience-engine");
+    });
+    it("ee_write surfaces write_failed when the write helper fails", async () => {
+        const handlers = collectTools((s) => registerEETools(s, { write: async () => ({ ok: false, error: "import-memory HTTP 500" }) }));
+        const out = textOf(await handlers.ee_write({ lesson: "a sufficiently long lesson body here" }));
+        expect(out.isError).toBe(true);
+        expect(out.json.error).toBe("write_failed");
+    });
 });
 //# sourceMappingURL=ee-tools.test.js.map

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

@@ -32,20 +32,20 @@ const fakeSummary = (id) => ({
 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" }));
+        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" }));
+        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" }));
+        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"]);

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

@@ -18,13 +18,13 @@ 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 }));
+        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 }));
+        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");
     });
@@ -35,7 +35,7 @@ describe("lsp-tools", () => {
                 throw new Error("server launch failed");
             },
         }));
-        const out = parse(await handlers["lsp_query"]({ operation: "findReferences", filePath: "a.ts", line: 3, character: 4 }));
+        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");
@@ -47,7 +47,7 @@ describe("lsp-tools", () => {
             },
             query: async () => ({ success: true, output: "x" }),
         }));
-        const out = parse(await handlers["lsp_query"]({ operation: "hover", filePath: "a.ts", line: 0, character: 0 }));
+        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");

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

@@ -39,14 +39,6 @@ const DEFAULT_CONFIGS = [
         transport: "http",
         url: "https://docs-mcp.muonroi.com/mcp",
     },
-    {
-        id: "filesystem",
-        label: "Filesystem",
-        enabled: true,
-        transport: "stdio",
-        command: "npx",
-        args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
-    },
     {
         id: "playwright",
         label: "Playwright",

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

@@ -44,7 +44,7 @@ export declare function acquireMcpTools(servers: McpServerConfig[], opts?: McpBu
  * has connected. Idempotent (cached entries are reused); a failed connect is
  * evicted by getOrConnect so a real turn retries.
  */
-export declare function warmMcpClients(servers: McpServerConfig[]): void;
+export declare function warmMcpClients(servers: McpServerConfig[], syncAndLog?: boolean): Promise<void>;
 /** Tear down every pooled client. Call on orchestrator/process shutdown. */
 export declare function closeAllMcpClients(): Promise<void>;
 /** Test-only: reset pool state between cases. */

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

@@ -236,15 +236,31 @@ export async function acquireMcpTools(servers, opts) {
  * has connected. Idempotent (cached entries are reused); a failed connect is
  * evicted by getOrConnect so a real turn retries.
  */
-export function warmMcpClients(servers) {
-    for (const s of servers) {
-        if (!s.enabled)
-            continue;
-        if (!validateMcpServerConfig(s).ok)
-            continue;
-        void getOrConnect(s).catch(() => {
-            /* warm is best-effort — the eviction in getOrConnect lets a real turn retry */
-        });
+export async function warmMcpClients(servers, syncAndLog = false) {
+    const validServers = servers.filter(s => s.enabled && validateMcpServerConfig(s).ok);
+    if (syncAndLog && validServers.length > 0) {
+        console.log(`[MCP] Warming up ${validServers.length} server(s)...`);
+    }
+    const promises = validServers.map(async (s) => {
+        try {
+            await getOrConnect(s);
+            if (syncAndLog) {
+                console.log(`[MCP] ✅ ${s.id}: healthy`);
+            }
+        }
+        catch (e) {
+            if (syncAndLog) {
+                const msg = e instanceof Error ? e.message : String(e);
+                console.log(`[MCP] ❌ ${s.id}: failed - ${msg}`);
+            }
+        }
+    });
+    if (syncAndLog) {
+        await Promise.all(promises);
+    }
+    else {
+        // Fire-and-forget for background warmup
+        void Promise.all(promises);
     }
 }
 /** Tear down every pooled client. Call on orchestrator/process shutdown. */

package/dist/src/mcp/ee-tools.d.ts

@@ -30,6 +30,16 @@ export interface EEToolDeps {
         status: number;
     }>;
     feedback?: (pointId: string, collection: string, verdict: FeedbackVerdict, reason?: NoiseReason) => Promise<FeedbackResult>;
+    write?: (lesson: string, opts: {
+        collection?: string;
+        title?: string;
+        projectSlug?: string;
+        confidence?: number;
+    }) => Promise<{
+        ok: boolean;
+        id?: string;
+        error?: string;
+    }>;
     /** Session pending-recall ledger. Defaults to the process singleton. */
     ledger?: RecallLedger;
 }

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

@@ -155,5 +155,39 @@ export function registerEETools(server, deps = {}) {
             return fail("ee_unavailable", e instanceof Error ? e.message : String(e));
         }
     });
+    server.registerTool("ee_write", {
+        description: "Save a NEW lesson to the Experience Engine brain so you and future sessions recall it. Call the MOMENT you " +
+            "hit a mistake / error / dead-end and find the working fix: record the pitfall AND the fix in one concise, " +
+            "generalizable lesson (1-3 sentences — what to do or avoid next time, NOT a play-by-play of this turn). The " +
+            "lesson is embedded immediately (via /api/import-memory: dense + sparse) and becomes recallable via ee_query " +
+            "in this and future sessions. Use ee_query first if unsure a lesson already exists. collection defaults to " +
+            "experience-behavioral (use experience-principles only for a broad, project-independent principle); project " +
+            "scopes the lesson.",
+        inputSchema: {
+            lesson: z.string().min(12).max(4000),
+            title: z.string().max(200).optional(),
+            collection: z.enum(["experience-behavioral", "experience-principles"]).optional(),
+            project: z.string().max(200).optional(),
+        },
+    }, async ({ lesson, title, collection, project }) => {
+        const trimmed = lesson.trim();
+        const text = trimmed.length > 1500 ? `${trimmed.slice(0, 1497)}...` : trimmed;
+        const targetCollection = collection ?? "experience-behavioral";
+        const write = deps.write ?? ((l, o) => import("../ee/search.js").then((m) => m.writeExperienceEE(l, o)));
+        try {
+            const result = await write(text, {
+                collection: targetCollection,
+                title,
+                projectSlug: project,
+                confidence: 0.65,
+            });
+            if (!result.ok)
+                return fail("write_failed", result.error ?? "import-memory POST failed");
+            return ok({ ok: true, id: result.id, collection: targetCollection, recallable: "now via ee_query" });
+        }
+        catch (e) {
+            return fail("write_failed", e instanceof Error ? e.message : String(e));
+        }
+    });
 }
 //# sourceMappingURL=ee-tools.js.map

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

@@ -21,6 +21,7 @@ export interface StartAgenticOpts {
     goal: string;
     llm: string;
     turns?: number;
+    mockLlmDir?: string;
 }
 export type StartOpts = StartTier1Opts | StartAgenticOpts;
 export interface Job {

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

@@ -34,9 +34,7 @@ export class JobManager {
                 job.logBuffer.splice(0, job.logBuffer.length - LOG_CAP);
             }
         };
-        const run = opts.kind === "tier1"
-            ? this.runner.tier1(opts, log, ctrl.signal)
-            : this.runner.agentic(opts, log, ctrl.signal);
+        const run = opts.kind === "tier1" ? this.runner.tier1(opts, log, ctrl.signal) : this.runner.agentic(opts, log, ctrl.signal);
         run.then((report) => {
             this.controllers.delete(runId); // I2: keep maps symmetric after natural completion
             if (job.status === "cancelled")

package/dist/src/mcp/self-verify-runner.js

@@ -25,7 +25,7 @@ export const defaultRunner = {
     async agentic(opts, log) {
         const { createLLMBrain, runAgenticLoop } = await import("../self-qa/agentic-loop.js");
         const brain = await createLLMBrain({ modelId: opts.llm });
-        return runAgenticLoop({ goal: opts.goal, brain, maxTurns: opts.turns ?? 20, log });
+        return runAgenticLoop({ goal: opts.goal, brain, maxTurns: opts.turns ?? 20, mockLlmDir: opts.mockLlmDir, log });
     },
 };
 let shared = null;