muonroi-cli 1.3.4 → 1.4.1

package/dist/src/hooks/index.js

@@ -62,10 +62,19 @@ export async function executeEventHooks(input, cwd, _signal) {
             const preInput = input;
             // Capture EE render output so warnings surface in the agent content stream
             // (yielded as content above the tool action) rather than going to console.warn.
+            // Also fan out to the previous sink so the active TUI render path (activeEeYield)
+            // receives the experience_warning chunks and renders the full [conf%] message + Why
+            // inline — without this fan-out the user only sees the count, not the detail.
             const capturedWarnings = [];
             const originalSink = getRenderSink();
             setRenderSink((chunk) => {
                 capturedWarnings.push(typeof chunk === "string" ? chunk : (chunk.content ?? ""));
+                try {
+                    originalSink(chunk);
+                }
+                catch {
+                    /* TUI sink fail-open — never block intercept */
+                }
             });
             let r;
             try {
@@ -246,39 +255,48 @@ export async function executeEventHooks(input, cwd, _signal) {
                 diffPresent: false,
                 tenantId: getTenantId(),
             };
-            // EE detail log: judge classification and agent feedback behavior
+            // EE detail log: judge classification and agent feedback behavior.
+            // Phase 5 F5 — skip the write when EE produced ZERO warnings for this
+            // tool call. 5-baseline measurements showed ~100% of ee_judge rows
+            // came from hadWarnings=false / agent_response_to_ee="no_warning_present"
+            // — pure logging noise, no signal. We only persist the judge event when
+            // there were warnings to evaluate against.
             try {
                 const sid = input.session_id;
                 if (sid) {
                     const classification = judge(judgeCtx);
                     const matches = _lastWarningResponse?.matches ?? [];
                     const hadWarnings = matches.length > 0;
-                    logInteraction(sid, "ee_judge", {
-                        eventSubtype: classification,
-                        data: {
-                            phase: "post_tool",
-                            role: "judge",
-                            toolName: input.tool_name,
-                            classification,
-                            hadWarnings,
-                            matchCount: matches.length,
-                            cwdMatched: judgeCtx.cwdMatchedAtPretool,
-                            outcomeSuccess: true,
-                            agent_response_to_ee: hadWarnings
-                                ? classification === "FOLLOWED"
-                                    ? "agent_complied"
-                                    : classification === "IGNORED"
-                                        ? "agent_overrode"
-                                        : "no_relevant_warning"
-                                : "no_warning_present",
-                            noise_analysis: hadWarnings
-                                ? {
-                                    all_low_confidence: matches.every((m) => m.confidence < 0.5),
-                                    forced_feedback_on_noise: matches.some((m) => m.confidence < 0.3) && classification !== "IRRELEVANT",
-                                }
-                                : null,
-                        },
-                    });
+                    if (!hadWarnings) {
+                        // F5 skip — no warnings, no judge row.
+                    }
+                    else
+                        logInteraction(sid, "ee_judge", {
+                            eventSubtype: classification,
+                            data: {
+                                phase: "post_tool",
+                                role: "judge",
+                                toolName: input.tool_name,
+                                classification,
+                                hadWarnings,
+                                matchCount: matches.length,
+                                cwdMatched: judgeCtx.cwdMatchedAtPretool,
+                                outcomeSuccess: true,
+                                agent_response_to_ee: hadWarnings
+                                    ? classification === "FOLLOWED"
+                                        ? "agent_complied"
+                                        : classification === "IGNORED"
+                                            ? "agent_overrode"
+                                            : "no_relevant_warning"
+                                    : "no_warning_present",
+                                noise_analysis: hadWarnings
+                                    ? {
+                                        all_low_confidence: matches.every((m) => m.confidence < 0.5),
+                                        forced_feedback_on_noise: matches.some((m) => m.confidence < 0.3) && classification !== "IRRELEVANT",
+                                    }
+                                    : null,
+                            },
+                        });
                 }
             }
             catch {
@@ -346,34 +364,41 @@ export async function executeEventHooks(input, cwd, _signal) {
                 diffPresent: false,
                 tenantId: getTenantId(),
             };
-            // EE detail log: judge classification on tool failure
+            // EE detail log: judge classification on tool failure.
+            // F5 — same suppression: skip when EE issued no warning. A tool failure
+            // without a pre-warning is signal for OTHER systems (verify-failure
+            // tracker etc.), not for the EE judge log.
             try {
                 const sid = failInput.session_id;
                 if (sid) {
                     const classification = judge(judgeCtx);
                     const matches = _lastWarningResponse?.matches ?? [];
                     const hadWarnings = matches.length > 0;
-                    logInteraction(sid, "ee_judge", {
-                        eventSubtype: classification,
-                        data: {
-                            phase: "post_tool_failure",
-                            role: "judge",
-                            toolName: failInput.tool_name,
-                            classification,
-                            hadWarnings,
-                            matchCount: matches.length,
-                            cwdMatched: judgeCtx.cwdMatchedAtPretool,
-                            outcomeSuccess: false,
-                            errorPreview: failInput.error?.slice(0, 120) ?? null,
-                            agent_response_to_ee: hadWarnings ? "tool_failed_after_warning" : "tool_failed_no_warning",
-                            noise_analysis: hadWarnings
-                                ? {
-                                    all_low_confidence: matches.every((m) => m.confidence < 0.5),
-                                    forced_feedback_on_noise: matches.some((m) => m.confidence < 0.3) && classification !== "IRRELEVANT",
-                                }
-                                : null,
-                        },
-                    });
+                    if (!hadWarnings) {
+                        // F5 skip
+                    }
+                    else
+                        logInteraction(sid, "ee_judge", {
+                            eventSubtype: classification,
+                            data: {
+                                phase: "post_tool_failure",
+                                role: "judge",
+                                toolName: failInput.tool_name,
+                                classification,
+                                hadWarnings,
+                                matchCount: matches.length,
+                                cwdMatched: judgeCtx.cwdMatchedAtPretool,
+                                outcomeSuccess: false,
+                                errorPreview: failInput.error?.slice(0, 120) ?? null,
+                                agent_response_to_ee: hadWarnings ? "tool_failed_after_warning" : "tool_failed_no_warning",
+                                noise_analysis: hadWarnings
+                                    ? {
+                                        all_low_confidence: matches.every((m) => m.confidence < 0.5),
+                                        forced_feedback_on_noise: matches.some((m) => m.confidence < 0.3) && classification !== "IRRELEVANT",
+                                    }
+                                    : null,
+                            },
+                        });
                 }
             }
             catch {

package/dist/src/index.js

@@ -16,7 +16,7 @@ import { PACKAGE_DESCRIPTION, PACKAGE_VERSION } from "./generated/version.js";
 const packageJson = { version: PACKAGE_VERSION, description: PACKAGE_DESCRIPTION };
 import { hydrateChatEnvFromKeychain } from "./chat/chat-keychain.js";
 import { setRenderSink } from "./ee/render.js";
-import { createCouncilAutoAnswerer, handleCouncilChunk, parseCouncilAnswersFile, } from "./headless/council-answers.js";
+import { createHeadlessCouncilAutoAnswerer, handleCouncilChunk, parseCouncilAnswersFile, } from "./headless/council-answers.js";
 import { createHeadlessJsonlEmitter, isHeadlessOutputFormat, renderHeadlessChunk, renderHeadlessPrelude, } from "./headless/output.js";
 import { loadCatalog, normalizeModelId } from "./models/registry.js";
 // Plan 00-07: boot-order modules — AbortContext + PendingCallsLog (TUI-01, TUI-03, TUI-04).
@@ -25,7 +25,7 @@ import { completeDelegation, failDelegation, loadDelegation } from "./orchestrat
 import { Agent } from "./orchestrator/orchestrator.js";
 import { createPendingCallsLog } from "./orchestrator/pending-calls.js";
 import { getProviderCapabilities } from "./providers/capabilities.js";
-import { listStoredProviders, loadKeyForProvider, setKeyForProvider, } from "./providers/keychain.js";
+import { listStoredProviders, loadKeyForProvider, setKeyForProvider } from "./providers/keychain.js";
 import { detectProviderForModel } from "./providers/runtime.js";
 import { loadConfig } from "./storage/config.js";
 import { loadUsage } from "./storage/usage-cap.js";
@@ -98,7 +98,7 @@ async function resolveKeyForModel(modelId) {
     // appearance (api-key.spec.ts) set MUONROI_TEST_NO_KEYCHAIN=1 to suppress
     // the dev machine's real keychain entry from masking the unauthenticated
     // boot path. Honoured ONLY in tests — never read in production flows.
-    if (process.env["MUONROI_TEST_NO_KEYCHAIN"] === "1")
+    if (process.env.MUONROI_TEST_NO_KEYCHAIN === "1")
         return null;
     const provider = detectProviderForModel(modelId);
     try {
@@ -118,7 +118,7 @@ async function resolveKeyForModel(modelId) {
  * subscription.
  */
 async function hasOAuthForModel(modelId) {
-    if (process.env["MUONROI_TEST_NO_KEYCHAIN"] === "1")
+    if (process.env.MUONROI_TEST_NO_KEYCHAIN === "1")
         return false;
     const provider = detectProviderForModel(modelId);
     try {
@@ -297,8 +297,10 @@ async function firstRunWizard(currentModel) {
                 }
             }
             else {
-                process.stderr.write("\nOS keychain unavailable on this platform. Key will be used for this session only.\n" +
-                    `For persistence, set env var: ${provider.toUpperCase()}_API_KEY\n`);
+                process.stderr.write("\nOS keychain unavailable (keytar or secret service backend).\n" +
+                    "Linux: sudo dnf install libsecret (Fedora) or sudo apt-get install libsecret-1-0 (Ubuntu).\n" +
+                    "Key will be used for this session only. For persistence across runs:\n" +
+                    `  export ${provider.toUpperCase()}_API_KEY=...\n`);
             }
         }
         catch (err) {
@@ -726,7 +728,13 @@ function resolveConfig(options) {
     const baseURL = stringOption(options.baseUrl) || getBaseURL();
     const explicitModel = stringOption(options.model);
     const model = explicitModel ? normalizeModelId(explicitModel) : undefined;
-    const maxToolRounds = parseInt(stringOption(options.maxToolRounds) || "400", 10) || 400;
+    // PIL-L6 v2 — default cap lowered 400 → 100 after session 127140a47b56
+    // (a single debug turn ran 275 LLM calls over 21 min, $0.63 cost, never
+    // converged). 100 rounds still covers legitimate multi-file refactor/debug
+    // work; runaway loops abort with the "Reached max tool rounds" error
+    // surface so the user can adjust scope. Override via --max-tool-rounds CLI
+    // flag or MUONROI_MAX_TOOL_ROUNDS env.
+    const maxToolRounds = parseInt(stringOption(options.maxToolRounds) || "12", 10) || 12;
     const sandboxMode = resolveCliSandboxMode(options.sandbox) || getCurrentSandboxMode();
     const cliOverrides = {};
     if (options.allowNet === true)
@@ -742,7 +750,7 @@ function resolveConfig(options) {
         cliOverrides.ports = portValue;
     }
     const sandboxSettings = mergeSandboxSettings(getCurrentSandboxSettings(), cliOverrides);
-    if (typeof options.apiKey === "string" && process.env["MUONROI_TEST_NO_PERSIST"] !== "1") {
+    if (typeof options.apiKey === "string" && process.env.MUONROI_TEST_NO_PERSIST !== "1") {
         // Persist to OS keychain (per-provider) instead of plaintext settings.json.
         // Fire-and-forget: keychain write is async; if it fails (no keytar), the key still
         // works for this run via `apiKey` above and the user can re-supply it next invocation.
@@ -750,6 +758,12 @@ function resolveConfig(options) {
     }
     if (typeof options.model === "string")
         saveUserSettings({ defaultModel: normalizeModelId(options.model) });
+    if (options.sandbox !== undefined) {
+        const resolved = resolveCliSandboxMode(options.sandbox);
+        if (resolved) {
+            saveUserSettings({ sandboxMode: resolved });
+        }
+    }
     return { apiKey, baseURL, model, maxToolRounds, sandboxMode, sandboxSettings };
 }
 function requireApiKey(apiKey) {
@@ -784,7 +798,7 @@ program
     .option("--port <mapping>", "Forward a host port to sandbox guest (HOST:GUEST, repeatable)", collect, [])
     .option("-s, --session <id>", "Continue a saved session by id, or use 'latest'")
     .option("--background-task-file <path>", "Run a persisted background delegation")
-    .option("--max-tool-rounds <n>", "Max tool execution rounds", "400")
+    .option("--max-tool-rounds <n>", "Max tool execution rounds (ultimate runaway safety net)", "120")
     .option("--batch-api", "Use xAI Batch API for model calls (async, lower cost)")
     .option("--permission <mode>", "Permission mode: safe (confirm all), auto-edit (auto-approve file ops), yolo (auto-approve all)", "safe")
     .option("-y, --yes", "Headless: auto-answer council askcards with their default option and approve preflights")
@@ -821,8 +835,32 @@ program
         // it is installed so `resolveModelRuntime` returns it instead of the
         // real provider model. This enables cost-leak verification (G1, F1,
         // B3/B4, C1) through the orchestrator's streamText path.
+        //
+        // Failure mode (silent until 2026-05-26): the original
+        // `.catch(() => null)` swallowed every load error — directory
+        // missing, JSON parse fail, no `model` block in any file — and
+        // the orchestrator silently fell back to the real provider, which
+        // failed because tests use a FAKE_KEY. The dump file then contained
+        // `[]`, producing the cryptic "expected 0 to be greater than or
+        // equal to 3" failures in cost-leak-b3/b4 TUI specs. Logging every
+        // failure path makes the root cause visible in CI stderr.
         const { loadMockModelFromDir } = await import("./agent-harness/mock-model.js");
-        const modelHandle = await loadMockModelFromDir(options.mockLlm).catch(() => null);
+        const modelHandle = await loadMockModelFromDir(options.mockLlm).catch((err) => {
+            process.stderr.write(`[muonroi-cli] mock-llm: loadMockModelFromDir(${options.mockLlm}) threw: ${err instanceof Error ? `${err.name}: ${err.message}` : String(err)}\n`);
+            return null;
+        });
+        if (!modelHandle) {
+            // The user explicitly passed `--mock-llm <dir>` — they EXPECT the
+            // mock to be installed. Silent fallback to the real provider is the
+            // wrong default for test environments. Refuse to continue so the
+            // failure is loud, not a dump full of zero calls.
+            process.stderr.write(`[muonroi-cli] mock-llm: no fixture in ${options.mockLlm} declared a {model:...} block — refusing to fall back to real provider. ` +
+                `Verify the fixture JSON has a top-level "model" key with a "stream" array.\n`);
+            // Exit code chosen to differ from the AI SDK's typical 1/2 so test
+            // harnesses can distinguish "mock didn't install" from "test
+            // assertion failed". 78 = EX_CONFIG per BSD sysexits.
+            process.exit(78);
+        }
         if (modelHandle) {
             // Install all three globals atomically so the runtime sees a
             // consistent picture: model + the OAuth-registry-equivalent
@@ -979,14 +1017,14 @@ program
                 "Update your key:\n" +
                 "  muonroi-cli -k YOUR_NEW_KEY\n" +
                 "  # or: export MUONROI_API_KEY=YOUR_NEW_KEY\n" +
-                `\nGet a key at: ${getProviderCapabilities("anthropic").consoleSignupURL()}`);
+                `\nGet a key at: https://docs.muonroi.com/docs/cli/providers`);
         }
         else {
             console.error("\x1b[31mNo API key configured and no models could be loaded.\x1b[0m\n" +
                 "Set your key:\n" +
                 "  muonroi-cli -k YOUR_API_KEY\n" +
                 "  # or: export MUONROI_API_KEY=YOUR_API_KEY\n" +
-                `\nGet a key at: ${getProviderCapabilities("anthropic").consoleSignupURL()}`);
+                `\nGet a key at: https://docs.muonroi.com/docs/cli/providers`);
         }
         process.exit(1);
     }
@@ -1011,8 +1049,11 @@ program
         }
     }
     const councilAnswersFile = typeof options.councilAnswers === "string" ? loadCouncilAnswersOrExit(options.councilAnswers) : undefined;
-    const councilAutoAnswer = createCouncilAutoAnswerer({
-        enabled: options.yes === true,
+    // Headless (`-p` / `--verify`) has no TUI to render council askcards, so the
+    // answerer is ALWAYS active (auto-proceeds with the recommended option). This
+    // is why a council-triggering prompt no longer hangs without `--yes`. A
+    // `--council-answers` file still customizes per-phase answers.
+    const councilAutoAnswer = createHeadlessCouncilAutoAnswerer({
         file: councilAnswersFile,
     });
     if (options.verify) {
@@ -1021,7 +1062,7 @@ program
             console.error(verifyError);
             process.exit(1);
         }
-        await runHeadless(buildVerifyPrompt(process.cwd()), requireApiKey(config.apiKey), config.baseURL, config.model, config.maxToolRounds, options.batchApi === true, config.sandboxMode, config.sandboxSettings, options.format, options.session, options.permission, councilAutoAnswer);
+        await runHeadless(buildVerifyPrompt(process.cwd(), config.sandboxMode), requireApiKey(config.apiKey), config.baseURL, config.model, config.maxToolRounds, options.batchApi === true, config.sandboxMode, config.sandboxSettings, options.format, options.session, options.permission, councilAutoAnswer);
         return;
     }
     if (options.prompt) {
@@ -1153,7 +1194,7 @@ keys
 });
 keys
     .command("login <provider>")
-    .description("Log in to a provider via OAuth subscription (currently supports: openai)")
+    .description("Log in to a provider via OAuth subscription (supported: openai, google, xai)")
     .action(async (provider) => {
     const { runKeysLogin } = await import("./cli/keys.js");
     await runKeysLogin(provider);
@@ -1259,6 +1300,25 @@ usage
     const { runCostForensics } = await import("./cli/cost-forensics.js");
     await runCostForensics({ prefix: sessionPrefix, json: opts.json });
 });
+usage
+    .command("security-audit")
+    .description("Security posture: yolo/permission overrides, high-risk cmds, shuru audits + cost (from decision-log events)")
+    .option("--since <date|7d|1h|30m>", "Restrict to UTC date or relative window")
+    .option("--json", "Emit as JSON")
+    .option("--format <fmt>", "table | json | md", "table")
+    .action(async (opts) => {
+    const { runSecurityAudit } = await import("./cli/usage-report.js");
+    await runSecurityAudit({ since: opts.since, json: opts.json, format: opts.format });
+});
+usage
+    .command("perf-regression")
+    .description("Perf snapshot + estimator drift (compare baseline stub for later)")
+    .option("--compare <file>", "Baseline file for delta")
+    .option("--json", "Emit JSON")
+    .action(async (opts) => {
+    const { runPerfRegression } = await import("./cli/usage-report.js");
+    await runPerfRegression({ compare: opts.compare, json: opts.json });
+});
 const mcp = program.command("mcp").description("Manage MCP server configuration");
 mcp
     .command("setup-research")
@@ -1304,6 +1364,93 @@ program
     const { opentuiSpawn } = await import("./mcp/opentui-spawn.js");
     await runHarnessDriver(opentuiSpawn);
 });
+program
+    .command("tools-mcp")
+    .description("Run the muonroi native-tools MCP server over stdio (self-verify; more tools later)")
+    .action(async () => {
+    const { runToolsMcpServer } = await import("./mcp/tools-server.js");
+    await runToolsMcpServer();
+});
+program
+    .command("self-verify")
+    .description("Harness-Verified Self-QA: spawn a child muonroi-cli, drive it through scenarios derived from git diff, and emit regression specs for every passing run")
+    .option("--since <ref>", "Git base ref for the diff window", "HEAD~1")
+    .option("--max <n>", "Maximum number of scenarios to run", "8")
+    .option("--no-emit", "Do not write tests/harness/auto/*.spec.ts on pass")
+    .option("--out <dir>", "Override the emitted-spec directory")
+    .option("--json", "Print machine-readable JSON report to stdout")
+    .option("--agentic", "Tier 2: outer LLM drives the child interactively (reads frame deltas + events, decides next step). Requires --goal and --model.")
+    .option("--goal <text>", "Free-form goal for agentic mode (e.g. 'open agents modal and add a researcher')")
+    .option("--llm <id>", "LLM model id for agentic mode (e.g. 'deepseek-v4-flash')")
+    .option("--turns <n>", "Max agentic turns", "20")
+    .action(async (opts) => {
+    const log = opts.json ? () => { } : (m) => console.log(m);
+    if (opts.agentic) {
+        if (!opts.goal || !opts.llm) {
+            console.error("--agentic requires both --goal and --llm");
+            process.exit(2);
+        }
+        const { runAgenticLoop, createLLMBrain } = await import("./self-qa/agentic-loop.js");
+        const brain = await createLLMBrain({ modelId: opts.llm });
+        const report = await runAgenticLoop({
+            goal: opts.goal,
+            brain,
+            maxTurns: Number.parseInt(opts.turns, 10) || 20,
+            log,
+        });
+        if (opts.json) {
+            process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+        }
+        else {
+            console.log(`\n[self-verify agentic] verdict=${report.verdict} | ${report.turns.length} turns | ${report.totalDurationMs}ms`);
+            console.log(`  reason: ${report.reason}`);
+        }
+        process.exit(report.verdict === "fail" ? 1 : 0);
+    }
+    const { runSelfVerify } = await import("./self-qa/index.js");
+    const report = await runSelfVerify({
+        baseRef: opts.since,
+        maxScenarios: Number.parseInt(opts.max, 10) || 8,
+        emitSpecs: opts.emit !== false,
+        specOutDir: opts.out,
+        log,
+    });
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    }
+    else {
+        const s = report.summary;
+        console.log(`\n[self-verify] ${s.passed}/${s.total} passed | ${s.failed} failed | ${s.inconclusive} inconclusive | ${report.durationMs}ms`);
+        if (report.emittedSpecs.length > 0) {
+            console.log(`[self-verify] Emitted ${report.emittedSpecs.length} regression spec(s):`);
+            for (const path of report.emittedSpecs)
+                console.log(`  ${path}`);
+        }
+    }
+    process.exit(report.summary.failed > 0 ? 1 : 0);
+});
+program
+    .command("export-transcripts")
+    .description("One-shot dump of SQLite session history → ~/.experience/muonroi-cli-sessions/ for EE backfill")
+    .option("--days <n>", "Only export sessions updated within N days (default 30)", "30")
+    .option("--min-messages <n>", "Skip sessions with fewer than N messages (default 4)", "4")
+    .option("--dry-run", "List sessions that would be exported without writing files")
+    .action(async (opts) => {
+    const { exportTranscripts } = await import("./ee/export-transcripts.js");
+    try {
+        const res = await exportTranscripts({
+            maxAgeDays: Number.parseInt(opts.days, 10),
+            minMessages: Number.parseInt(opts.minMessages, 10),
+            dryRun: !!opts.dryRun,
+        });
+        console.log(`[export-transcripts] sessions=${res.totalSessions}  written=${res.written}  skipped_empty=${res.skippedEmpty}  skipped_small=${res.skippedTooSmall}\n  output: ${res.outputRoot}`);
+        process.exit(0);
+    }
+    catch (e) {
+        console.error(`[export-transcripts] failed: ${e.message}`);
+        process.exit(1);
+    }
+});
 program
     .command("share <user>")
     .description("Add a stakeholder to the current product's Discord channel")
@@ -1346,6 +1493,23 @@ program
             break;
     }
 });
+program
+    .command("reporter")
+    .description("Run the P8 reporter agent — polls Discord and serves progress queries")
+    .requiredOption("--run <runId>", "Run ID to observe")
+    .option("--product-slug <slug>", "Product slug (inferred from run manifest if omitted)")
+    .option("--daily-budget <usd>", "Daily LLM budget in USD (default 0.50)", "0.50")
+    .action(async (opts) => {
+    const { runReporterCmd } = await import("./cli/reporter-cmd.js");
+    try {
+        await runReporterCmd({ run: opts.run, productSlug: opts.productSlug, dailyBudget: opts.dailyBudget });
+        process.exit(0);
+    }
+    catch (e) {
+        console.error(`muonroi reporter: ${e.message}`);
+        process.exit(1);
+    }
+});
 program.parse();
 function formatContext(tokens) {
     if (tokens >= 1_000_000)

package/dist/src/lsp/builtins.js

@@ -195,6 +195,33 @@ const BUILT_IN_DEFINITIONS = {
             };
         },
     },
+    "csharp-ls": {
+        id: "csharp-ls",
+        extensions: [".cs"],
+        languageIds: {
+            ".cs": "csharp",
+        },
+        // csharp-ls auto-discovers a .sln/.csproj from the root; match the fixed-name
+        // files that sit at a .NET repo root (solution/csproj names vary and the root
+        // matcher can't glob), falling back to .git.
+        rootMarkers: ["global.json", "Directory.Build.props", "Directory.Packages.props", ".git"],
+        async resolveLaunch(root, settings) {
+            const override = settings.builtins["csharp-ls"];
+            // csharp-ls is distributed as a dotnet global tool (`dotnet tool install -g csharp-ls`),
+            // resolved from PATH like gopls/clangd/rust-analyzer. Default stdio launch, no args.
+            // Fallback: the dotnet global-tools dir (~/.dotnet/tools) is frequently NOT on
+            // PATH for spawned processes, so probe its well-known location directly.
+            const command = override?.command || (await resolveCommand(root, "csharp-ls")) || (await resolveDotnetGlobalTool("csharp-ls"));
+            if (!command)
+                return null;
+            return {
+                command,
+                args: override?.args ?? [],
+                env: override?.env,
+                initializationOptions: override?.initialization,
+            };
+        },
+    },
     "sourcekit-lsp": {
         id: "sourcekit-lsp",
         extensions: [".swift"],
@@ -272,6 +299,23 @@ async function resolveCommand(root, binary) {
         return localBinary;
     return findCommandOnPath(binary);
 }
+/**
+ * Resolve a dotnet global tool by its well-known install location, independent of
+ * PATH. `dotnet tool install -g <tool>` drops binaries into ~/.dotnet/tools (or
+ * $DOTNET_CLI_HOME/.dotnet/tools), which is often NOT on a spawned process's PATH —
+ * so PATH-only resolution misses tools the user clearly has installed.
+ */
+async function resolveDotnetGlobalTool(binary) {
+    const os = await import("os");
+    const home = process.env.DOTNET_CLI_HOME || os.homedir();
+    const suffixes = process.platform === "win32" ? [".exe", ".cmd", ""] : [""];
+    for (const suffix of suffixes) {
+        const candidate = path.join(home, ".dotnet", "tools", `${binary}${suffix}`);
+        if (await pathExists(candidate))
+            return candidate;
+    }
+    return null;
+}
 async function resolveTypeScriptServer(root) {
     const modulePath = path.join("node_modules", "typescript", "lib", "tsserver.js");
     let current = root;

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

@@ -8,7 +8,7 @@ vi.mock("./npm-cache", () => ({
 const { createRuntimeLspDefinitions } = await import("./builtins.js");
 const tempDirs = [];
 afterEach(async () => {
-    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 })));
 });
 describe("createRuntimeLspDefinitions", () => {
     it("includes all built-in definitions when no overrides are set", () => {
@@ -17,6 +17,7 @@ describe("createRuntimeLspDefinitions", () => {
             tool: true,
             autoInstall: false,
             startupTimeoutMs: 5000,
+            requestTimeoutMs: 5000,
             diagnosticsDebounceMs: 0,
             builtins: {},
             servers: [],
@@ -26,6 +27,23 @@ describe("createRuntimeLspDefinitions", () => {
         expect(ids).toContain("pyright");
         expect(ids).toContain("gopls");
         expect(ids).toContain("rust-analyzer");
+        expect(ids).toContain("csharp-ls");
+    });
+    it("maps the .cs extension to the csharp-ls built-in (csharp languageId)", () => {
+        const defs = createRuntimeLspDefinitions("/tmp", {
+            enabled: true,
+            tool: true,
+            autoInstall: false,
+            startupTimeoutMs: 5000,
+            requestTimeoutMs: 5000,
+            diagnosticsDebounceMs: 0,
+            builtins: {},
+            servers: [],
+        });
+        const csharp = defs.find((d) => d.id === "csharp-ls");
+        expect(csharp).toBeDefined();
+        expect(csharp.extensions).toContain(".cs");
+        expect(csharp.languageIds[".cs"]).toBe("csharp");
     });
     it("excludes a built-in when disabled via settings", () => {
         const defs = createRuntimeLspDefinitions("/tmp", {
@@ -33,6 +51,7 @@ describe("createRuntimeLspDefinitions", () => {
             tool: true,
             autoInstall: false,
             startupTimeoutMs: 5000,
+            requestTimeoutMs: 5000,
             diagnosticsDebounceMs: 0,
             builtins: {
                 typescript: { enabled: false },
@@ -49,6 +68,7 @@ describe("createRuntimeLspDefinitions", () => {
             tool: true,
             autoInstall: false,
             startupTimeoutMs: 5000,
+            requestTimeoutMs: 5000,
             diagnosticsDebounceMs: 0,
             builtins: {},
             servers: [
@@ -73,6 +93,7 @@ describe("createRuntimeLspDefinitions", () => {
             tool: true,
             autoInstall: false,
             startupTimeoutMs: 5000,
+            requestTimeoutMs: 5000,
             diagnosticsDebounceMs: 0,
             builtins: {},
             servers: [],