muonroi-cli 1.7.1 → 1.8.0

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/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/oauth-callback.js

@@ -1,7 +1,7 @@
 import http from "node:http";
 import { URL } from "node:url";
-const SUCCESS_HTML = `<!DOCTYPE html><html><body style="font-family:system-ui;text-align:center;padding:60px">
-<h2>Authorization successful</h2><p>You can close this tab and return to the terminal.</p>
+const SUCCESS_HTML = `<!DOCTYPE html><html><body style="font-family:system-ui;text-align:center;padding:60px">
+<h2>Authorization successful</h2><p>You can close this tab and return to the terminal.</p>
 </body></html>`;
 export function startOAuthCallbackServer(opts) {
     const callbackPath = opts.path ?? "/callback";

package/dist/src/mcp/parse-headers.test.js

@@ -2,19 +2,19 @@ import { describe, expect, it } from "vitest";
 import { parseEnvLines, parseHeaderLines } from "./parse-headers.js";
 describe("parseHeaderLines", () => {
     it("parses colon-separated headers and trims whitespace", () => {
-        expect(parseHeaderLines(`
-        Authorization: Bearer token
-        X-Trace-Id:  abc123
+        expect(parseHeaderLines(`
+        Authorization: Bearer token
+        X-Trace-Id:  abc123
       `)).toEqual({
             Authorization: "Bearer token",
             "X-Trace-Id": "abc123",
         });
     });
     it("ignores blank and malformed lines while preserving later colons in values", () => {
-        expect(parseHeaderLines(`
-        invalid
-        : missing-name
-        Host: example.com:443
+        expect(parseHeaderLines(`
+        invalid
+        : missing-name
+        Host: example.com:443
       `)).toEqual({
             Host: "example.com:443",
         });
@@ -22,19 +22,19 @@ describe("parseHeaderLines", () => {
 });
 describe("parseEnvLines", () => {
     it("parses equals-separated env assignments and trims whitespace", () => {
-        expect(parseEnvLines(`
-        API_KEY = secret
-        MODE= production
+        expect(parseEnvLines(`
+        API_KEY = secret
+        MODE= production
       `)).toEqual({
             API_KEY: "secret",
             MODE: "production",
         });
     });
     it("ignores blank and malformed lines while preserving later equals in values", () => {
-        expect(parseEnvLines(`
-        missing
-        = no-name
-        URL=https://example.com?a=b
+        expect(parseEnvLines(`
+        missing
+        = no-name
+        URL=https://example.com?a=b
       `)).toEqual({
             URL: "https://example.com?a=b",
         });

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/setup-guide-text.js

@@ -6,79 +6,79 @@
  * and the muonroi-tools MCP server (src/mcp/tools-server.ts, for external agents).
  * Keeping it here avoids duplicating ~70 lines across the two.
  */
-export const SETUP_GUIDE_TEXT = `# muonroi-cli Setup Guide
-
-## Install (zero runtime deps — recommended)
-Linux / macOS:
-  curl -fsSL https://raw.githubusercontent.com/muonroi/muonroi-cli/master/install.sh | bash
-
-Windows PowerShell:
-  irm https://raw.githubusercontent.com/muonroi/muonroi-cli/master/install.ps1 | iex
-
-Bun (requires Bun >= 1.3):
-  bun add -g muonroi-cli
-  # (npm install -g is NOT supported — TUI engine uses Bun-only ESM features)
-
-The installers fetch a pre-compiled single binary from GitHub Releases.
-
-## First run
-- Wizard appears automatically.
-- Lists supported providers (DeepSeek + SiliconFlow ready; others via BYOK).
-- Four credential options: paste key, Bitwarden sync (B in /providers), keys export/import (encrypted bundle), or skip for later.
-- Keys land in OS keychain (keytar). Settings written to ~/.muonroi-cli/user-settings.json.
-- Role routing (leader/implement/verify/research) is configured for you.
-
-After setup: run \`muonroi-cli doctor\` to validate.
-
-## Essential commands
-- Interactive TUI: \`muonroi-cli\` (or \`node dist/index.js\` after build)
-- Headless one-shot: \`muonroi-cli --prompt "your task" --max-tool-rounds 8\`
-- Health + MCP nudge: \`muonroi-cli doctor\`
-- Update: \`muonroi-cli update\` (or set "autoUpdate": true in user-settings)
-- Keys move between machines: \`muonroi-cli keys export file.json\` then import on target
-- Native tools MCP (for external agents): \`muonroi-cli tools-mcp\` (stdio)
-- Harness driver MCP: \`muonroi-cli mcp-driver\`
-
-## MCP integration (for Claude Desktop, Cursor, other agents)
-Add to your MCP client config:
-
-{
-  "mcpServers": {
-    "muonroi-tools": {
-      "command": "bun",
-      "args": ["run", "/absolute/path/to/muonroi-cli/src/index.ts", "tools-mcp"]
-    }
-  }
-}
-
-(Use absolute path. After \`bun run build\`: "node", "dist/index.js", "tools-mcp")
-
-The CLI's OWN inner agent exposes these as NATIVE in-process tools (no MCP self-spawn):
-- setup_guide (this document)
-- ee_query / ee_health / ee_feedback — Experience Engine semantic recall + compaction checkpoints + feedback for learning
-- usage_forensics <id-prefix> — per-session cost/token forensics (peak input, cache hits, anomalies)
-- lsp_query — goToDefinition, findReferences, hover, symbols, call hierarchy etc.
-- selfverify_* — Tier-1 heuristic + Tier-2 agentic self-QA harness runs (start/poll/result/cancel/list)
-
-For BB/.NET template recipes and package docs, also connect an external "muonroi-docs" MCP server if available (provides docs_search + setup_guide for the templates).
-
-## Development
-git clone https://github.com/muonroi/muonroi-cli.git
-cd muonroi-cli && bun install
-
-bun run dev                 # run from source (TUI)
-bun run typecheck           # tsc --noEmit
-bun run test                # vitest (unit + headless)
-bunx vitest -c vitest.harness.config.ts run tests/harness/   # TUI E2E (named-pipes on Win, fd3/4 on POSIX)
-bun run build               # or build:binary for standalone exe
-
-See AGENTS.md (quick ref + rules), CLAUDE.md (harness verification), README.md.
-
-## Verify
-muonroi-cli doctor
-# Checks runtimes, catalog load, keychain, MCP servers enabled, council research MCP nudge, EE reachability, recent error rate.
-# Any "warn" entries tell you exactly what to enable (e.g. tavily for web research in council).
-
-For BB-aware scaffolding (/ideal on a muonroi-building-block target): ensure dotnet SDK + the three Muonroi.*.Template packages are installed via NuGet; doctor surfaces missing feed/template cases.
+export const SETUP_GUIDE_TEXT = `# muonroi-cli Setup Guide
+
+## Install (zero runtime deps — recommended)
+Linux / macOS:
+  curl -fsSL https://raw.githubusercontent.com/muonroi/muonroi-cli/master/install.sh | bash
+
+Windows PowerShell:
+  irm https://raw.githubusercontent.com/muonroi/muonroi-cli/master/install.ps1 | iex
+
+Bun (requires Bun >= 1.3):
+  bun add -g muonroi-cli
+  # (npm install -g is NOT supported — TUI engine uses Bun-only ESM features)
+
+The installers fetch a pre-compiled single binary from GitHub Releases.
+
+## First run
+- Wizard appears automatically.
+- Lists supported providers (DeepSeek + SiliconFlow ready; others via BYOK).
+- Four credential options: paste key, Bitwarden sync (B in /providers), keys export/import (encrypted bundle), or skip for later.
+- Keys land in OS keychain (keytar). Settings written to ~/.muonroi-cli/user-settings.json.
+- Role routing (leader/implement/verify/research) is configured for you.
+
+After setup: run \`muonroi-cli doctor\` to validate.
+
+## Essential commands
+- Interactive TUI: \`muonroi-cli\` (or \`node dist/index.js\` after build)
+- Headless one-shot: \`muonroi-cli --prompt "your task" --max-tool-rounds 8\`
+- Health + MCP nudge: \`muonroi-cli doctor\`
+- Update: \`muonroi-cli update\` (or set "autoUpdate": true in user-settings)
+- Keys move between machines: \`muonroi-cli keys export file.json\` then import on target
+- Native tools MCP (for external agents): \`muonroi-cli tools-mcp\` (stdio)
+- Harness driver MCP: \`muonroi-cli mcp-driver\`
+
+## MCP integration (for Claude Desktop, Cursor, other agents)
+Add to your MCP client config:
+
+{
+  "mcpServers": {
+    "muonroi-tools": {
+      "command": "bun",
+      "args": ["run", "/absolute/path/to/muonroi-cli/src/index.ts", "tools-mcp"]
+    }
+  }
+}
+
+(Use absolute path. After \`bun run build\`: "node", "dist/index.js", "tools-mcp")
+
+The CLI's OWN inner agent exposes these as NATIVE in-process tools (no MCP self-spawn):
+- setup_guide (this document)
+- ee_query / ee_health / ee_feedback — Experience Engine semantic recall + compaction checkpoints + feedback for learning
+- usage_forensics <id-prefix> — per-session cost/token forensics (peak input, cache hits, anomalies)
+- lsp_query — goToDefinition, findReferences, hover, symbols, call hierarchy etc.
+- selfverify_* — Tier-1 heuristic + Tier-2 agentic self-QA harness runs (start/poll/result/cancel/list)
+
+For BB/.NET template recipes and package docs, also connect an external "muonroi-docs" MCP server if available (provides docs_search + setup_guide for the templates).
+
+## Development
+git clone https://github.com/muonroi/muonroi-cli.git
+cd muonroi-cli && bun install
+
+bun run dev                 # run from source (TUI)
+bun run typecheck           # tsc --noEmit
+bun run test                # vitest (unit + headless)
+bunx vitest -c vitest.harness.config.ts run tests/harness/   # TUI E2E (named-pipes on Win, fd3/4 on POSIX)
+bun run build               # or build:binary for standalone exe
+
+See AGENTS.md (quick ref + rules), CLAUDE.md (harness verification), README.md.
+
+## Verify
+muonroi-cli doctor
+# Checks runtimes, catalog load, keychain, MCP servers enabled, council research MCP nudge, EE reachability, recent error rate.
+# Any "warn" entries tell you exactly what to enable (e.g. tavily for web research in council).
+
+For BB-aware scaffolding (/ideal on a muonroi-building-block target): ensure dotnet SDK + the three Muonroi.*.Template packages are installed via NuGet; doctor surfaces missing feed/template cases.
 `;
 //# sourceMappingURL=setup-guide-text.js.map