muonroi-cli 1.7.1 → 1.8.0

package/dist/src/hooks/index.js

@@ -33,10 +33,14 @@ let _cachedScope = null;
 // Latch: stores the last PreToolUse warning response so PostToolUse can build judgeCtx.
 // Follows the _cachedScope module-level variable pattern.
 let _lastWarningResponse = null;
+// Fix 2: throttle recall-feedback reminder to once per unique pending-set.
+// Tracks the sha of pending IDs so identical reminders don't repeat on every tool call.
+let _lastRecallReminderSha = null;
 /** Reset hook module state — for test teardown only. */
 export function resetHookState() {
     _lastWarningResponse = null;
     _cachedScope = null;
+    _lastRecallReminderSha = null;
 }
 function emptyResult() {
     return {
@@ -200,13 +204,51 @@ export async function executeEventHooks(input, cwd, _signal) {
                 why: m.why,
                 confidence: m.confidence,
             }));
+            // Hard EE recall-feedback gate: inject mandatory reminder when there are
+            // pending unrated hints. The agent MUST clear all pending ee_feedback before
+            // proceeding with the task — system prompt in message-processor.ts enforces
+            // this as a first-before-anything directive.
+            //
+            // Fix 2: throttle to once per unique pending-set. The same 9 hints repeating
+            // after each of 10+ tool calls is pure UI noise — the model can't even see
+            // yield-content, and the user must scroll past identical blocks. Show the
+            // reminder ONCE when the set first appears or changes (e.g. after ee_feedback
+            // clears some entries), then stay silent until the set changes again.
+            let recallReminder = null;
+            try {
+                const { sessionRecallLedger, isRecallLedgerEnabled, formatPendingReminder } = await import("../ee/recall-ledger.js");
+                if (isRecallLedgerEnabled()) {
+                    const pending = sessionRecallLedger.pending();
+                    if (pending.length > 0) {
+                        const pendingSha = pending
+                            .map((p) => p.id)
+                            .sort()
+                            .join(",");
+                        if (pendingSha !== _lastRecallReminderSha) {
+                            _lastRecallReminderSha = pendingSha;
+                            recallReminder = `⚠️ MANDATORY: ${pending.length} unrated EE recall(s) — call ee_feedback NOW before continuing.\n${formatPendingReminder(pending, { max: 5 })}`;
+                        }
+                    }
+                    else {
+                        // All cleared — reset so next batch shows fresh
+                        _lastRecallReminderSha = null;
+                    }
+                }
+            }
+            catch {
+                /* fail-open */
+            }
             if (r.decision === "block") {
                 return {
                     blocked: true,
                     blockingErrors: [{ command: "ee:intercept", stderr: r.reason ?? "ee-blocked" }],
                     preventContinuation: true,
                     stopReason: r.reason ?? "ee-blocked",
-                    additionalContexts: [...capturedWarnings, ...(r.suggestions ?? [])],
+                    additionalContexts: [
+                        ...capturedWarnings,
+                        ...(r.suggestions ?? []),
+                        ...(recallReminder ? [recallReminder] : []),
+                    ],
                     decision: "block",
                     results: [],
                     eeMatches,
@@ -216,7 +258,11 @@ export async function executeEventHooks(input, cwd, _signal) {
                 blocked: false,
                 blockingErrors: [],
                 preventContinuation: false,
-                additionalContexts: [...capturedWarnings, ...(r.suggestions ?? [])],
+                additionalContexts: [
+                    ...capturedWarnings,
+                    ...(r.suggestions ?? []),
+                    ...(recallReminder ? [recallReminder] : []),
+                ],
                 decision: "approve",
                 results: [],
                 eeMatches,

package/dist/src/index.d.ts

@@ -1,3 +1,5 @@
 #!/usr/bin/env bun
 import type { StreamChunk } from "./types/index.js";
+export declare function setTuiActive(active: boolean): void;
+export declare function appendCrashLog(label: string, msg: string): void;
 export declare function setActiveEeYield(fn: ((chunk: StreamChunk) => void) | null): void;

package/dist/src/index.js

@@ -17,7 +17,7 @@ const packageJson = { version: PACKAGE_VERSION, description: PACKAGE_DESCRIPTION
 import { hydrateChatEnvFromKeychain } from "./chat/chat-keychain.js";
 import { setRenderSink } from "./ee/render.js";
 import { createHeadlessCouncilAutoAnswerer, handleCouncilChunk, parseCouncilAnswersFile, } from "./headless/council-answers.js";
-import { createHeadlessJsonlEmitter, isHeadlessOutputFormat, renderHeadlessChunk, renderHeadlessPrelude, } from "./headless/output.js";
+import { createHeadlessJsonlEmitter, createHeadlessTextEmitter, isHeadlessOutputFormat, 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).
 import { createAbortContext } from "./orchestrator/abort.js";
@@ -32,7 +32,7 @@ import { loadUsage } from "./storage/usage-cap.js";
 import { startScheduleDaemon } from "./tools/schedule.js";
 import { processAtMentions } from "./utils/at-mentions.js";
 import { runScriptManagedUninstall } from "./utils/install-manager.js";
-import { getApiKey, getBaseURL, getCurrentModel, getCurrentSandboxMode, getCurrentSandboxSettings, mergeSandboxSettings, saveUserSettings, } from "./utils/settings.js";
+import { getApiKey, getBaseURL, getCurrentModel, saveUserSettings } from "./utils/settings.js";
 import { runUpdate } from "./utils/update-checker.js";
 import { buildVerifyPrompt, getVerifyCliError } from "./verify/entrypoint.js";
 // Hydrate chat secrets from OS keychain before CLI bootstrap
@@ -41,20 +41,40 @@ const exitCleanlyOnSigterm = () => {
     process.exit(0);
 };
 process.on("SIGTERM", exitCleanlyOnSigterm);
-process.on("uncaughtException", (err) => {
+// Set true while the interactive TUI owns the terminal (raw mode + alternate
+// screen). When it is mounted, writing to stdout/stderr corrupts OpenTUI's
+// framebuffer and a process.exit(1) tears the whole UI down — surfacing to the
+// user as "kicked out of the TUI". A single stray unhandledRejection (e.g. a
+// slash handler whose DB read throws and rejects with no .catch) must not be
+// allowed to do that; while _tuiActive is set we log to crash.log and keep the
+// process alive. Headless / CLI paths keep the original fail-fast behaviour.
+let _tuiActive = false;
+export function setTuiActive(active) {
+    _tuiActive = active;
+}
+export function appendCrashLog(label, msg) {
     try {
-        require("fs").appendFileSync(require("path").join(require("os").homedir(), ".muonroi-cli", "crash.log"), `[${new Date().toISOString()}] UNCAUGHT: ${err.stack || err.message}\n`);
+        require("fs").appendFileSync(require("path").join(require("os").homedir(), ".muonroi-cli", "crash.log"), `[${new Date().toISOString()}] ${label}: ${msg}\n`);
     }
-    catch { }
+    catch {
+        /* crash.log is best-effort diagnostics; the logger itself must never throw */
+    }
+}
+process.on("uncaughtException", (err) => {
+    appendCrashLog("UNCAUGHT", err.stack || err.message);
     console.error("Fatal:", err.message);
     process.exit(1);
 });
 process.on("unhandledRejection", (reason) => {
     const msg = reason instanceof Error ? reason.stack || reason.message : String(reason);
-    try {
-        require("fs").appendFileSync(require("path").join(require("os").homedir(), ".muonroi-cli", "crash.log"), `[${new Date().toISOString()}] REJECTION: ${msg}\n`);
+    appendCrashLog("REJECTION", msg);
+    // TUI mounted → do NOT corrupt the framebuffer with console.error and do NOT
+    // exit. The rejection is logged; the renderer stays up so the user keeps
+    // their session (see slash-dispatch .catch handlers in app.tsx, which also
+    // surface the failure in-band).
+    if (_tuiActive) {
+        return;
     }
-    catch { }
     if (reason instanceof Error) {
         console.error("Unhandled rejection:", reason.stack || reason.message);
     }
@@ -314,7 +334,7 @@ async function firstRunWizard(currentModel) {
         return null;
     }
 }
-async function startInteractive(apiKey, baseURL, model, maxToolRounds, batchApi, sandboxMode, sandboxSettings, session, initialMessage, permissionMode = "safe", injectHalt = false) {
+async function startInteractive(apiKey, baseURL, model, maxToolRounds, batchApi, session, initialMessage, permissionMode = "safe", injectHalt = false) {
     // ── Plan 00-07 boot order ──────────────────────────────────────────────────
     // 1. redactor.installGlobalPatches() — already at top of file (line 6).
     // 2. loadConfig + loadUsage (validates storage paths, logs usage cap state).
@@ -377,10 +397,11 @@ async function startInteractive(apiKey, baseURL, model, maxToolRounds, batchApi,
     if (reconciled.abandoned > 0) {
         console.warn(`[muonroi-cli] reconciled ${reconciled.abandoned} abandoned tool calls from prior session`);
     }
+    const { warmMcpClients } = await import("./mcp/client-pool.js");
+    const { loadMcpServers } = await import("./utils/settings.js");
+    await warmMcpClients(loadMcpServers(), !session);
     const agent = new Agent(apiKey, baseURL, model, maxToolRounds, {
         session,
-        sandboxMode,
-        sandboxSettings,
         batchApi,
         abortContext: orchestratorAbort,
         pendingCalls,
@@ -391,6 +412,7 @@ async function startInteractive(apiKey, baseURL, model, maxToolRounds, batchApi,
     const { createRoot } = await import("@opentui/react");
     const { createElement } = await import("react");
     const { App } = await import("./ui/app.js");
+    const { relaunchWithSession } = await import("./ui/utils/relaunch.js");
     const renderer = await createCliRenderer({
         exitOnCtrlC: false,
         // We manage SIGINT ourselves (orchestrator abort → agent cleanup → renderer destroy).
@@ -403,6 +425,10 @@ async function startInteractive(apiKey, baseURL, model, maxToolRounds, batchApi,
             alternateKeys: true,
         },
     });
+    // The TUI now owns the terminal — route fatal-handler behaviour away from
+    // process.exit(1) (see the unhandledRejection handler above). Cleared in
+    // restoreTerminalSync() the moment we begin tearing the terminal back down.
+    setTuiActive(true);
     /**
      * Restore terminal to main-screen mode before the process exits.
      *
@@ -417,6 +443,9 @@ async function startInteractive(apiKey, baseURL, model, maxToolRounds, batchApi,
      * flush delay before process.exit().
      */
     function restoreTerminalSync() {
+        // Terminal is being handed back — restore fail-fast crash behaviour so a
+        // throw during/after teardown still exits cleanly instead of hanging.
+        setTuiActive(false);
         try {
             // 1. Disable Kitty keyboard protocol if enabled.
             if (typeof renderer.disableKittyKeyboard === "function") {
@@ -441,64 +470,106 @@ async function startInteractive(apiKey, baseURL, model, maxToolRounds, batchApi,
         process.env.TERM_PROGRAM === "WezTerm" ||
         process.env.TERM_PROGRAM === "wezterm" ||
         process.env.MUONROI_FORCE_SHELL_HOLD === "1";
-    const onExit = () => {
-        void agent.cleanup().finally(() => {
-            // Restore terminal state from JS before the native destroyRenderer runs
-            restoreTerminalSync();
-            renderer.destroy();
-            // Restore terminal modes BEFORE spawning child shell. Use synchronous
-            // writes to stdout's underlying fd so escape codes flush before the
-            // child inherits stdin — async process.stdout.write() can buffer past
-            // the spawn() boundary, leaving the terminal in mouse-tracking mode.
-            const writeSync = (seq) => {
-                try {
-                    const fs = require("node:fs");
-                    fs.writeSync(1, seq);
-                }
-                catch {
-                    /* fall back to async */
-                    try {
-                        process.stdout.write(seq);
-                    }
-                    catch {
-                        /* noop */
-                    }
-                }
-            };
+    // Restore the terminal to a clean main-screen state: undo Kitty keyboard,
+    // raw mode, mouse tracking, bracketed paste, and alt-screen. Shared by the
+    // /exit path AND the session-resume relaunch — a relaunch that skips this
+    // leaves the child (and, once the parent exits, the shell) with a terminal
+    // still in mouse-tracking/alt-screen mode, so stray escape bytes get parsed
+    // by the shell as a bogus command ("'…' is not recognized … operable
+    // program or batch file").
+    function restoreTerminalForHandoff() {
+        // Restore terminal state from JS before the native destroyRenderer runs
+        restoreTerminalSync();
+        renderer.destroy();
+        // Use synchronous writes to stdout's underlying fd so escape codes flush
+        // before the child inherits stdin — async process.stdout.write() can buffer
+        // past the spawn() boundary, leaving the terminal in mouse-tracking mode.
+        const writeSync = (seq) => {
             try {
-                // 1. Take stdin out of raw mode + pause it so no buffered keystrokes
-                //    (or in-flight mouse-event bytes) hit the child shell.
-                if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
-                    try {
-                        process.stdin.setRawMode(false);
-                    }
-                    catch {
-                        /* noop */
-                    }
-                }
+                const fs = require("node:fs");
+                fs.writeSync(1, seq);
+            }
+            catch {
+                /* fall back to async */
                 try {
-                    process.stdin.pause();
+                    process.stdout.write(seq);
                 }
                 catch {
                     /* noop */
                 }
+            }
+        };
+        try {
+            // 1. Take stdin out of raw mode + pause it so no buffered keystrokes
+            //    (or in-flight mouse-event bytes) hit the child.
+            if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
                 try {
-                    process.stdin.unref?.();
+                    process.stdin.setRawMode(false);
                 }
                 catch {
                     /* noop */
                 }
-                // 2. Disable extended-coords first (1006/1015/1005), then the basic
-                //    tracking modes (1003→1002→1000). Wrong order leaves the terminal
-                //    emitting SGR-formatted events after the base modes are off.
-                writeSync("\x1B[?1006l\x1B[?1015l\x1B[?1005l");
-                writeSync("\x1B[?1003l\x1B[?1002l\x1B[?1000l");
-                writeSync("\x1B[?2004l\x1B[?25h"); // bracketed paste off, cursor on
-                writeSync("\x1B[?1049l\x1B[0m\x1B[!p"); // exit alt-screen, reset SGR, soft reset
+            }
+            try {
+                process.stdin.pause();
             }
             catch {
-                // best-effort
+                /* noop */
             }
+            try {
+                process.stdin.unref?.();
+            }
+            catch {
+                /* noop */
+            }
+            // 2. Disable extended-coords first (1006/1015/1005), then the basic
+            //    tracking modes (1003→1002→1000). Wrong order leaves the terminal
+            //    emitting SGR-formatted events after the base modes are off.
+            writeSync("\x1B[?1006l\x1B[?1015l\x1B[?1005l");
+            writeSync("\x1B[?1003l\x1B[?1002l\x1B[?1000l");
+            writeSync("\x1B[?2004l\x1B[?25h"); // bracketed paste off, cursor on
+            writeSync("\x1B[?1049l\x1B[0m\x1B[!p"); // exit alt-screen, reset SGR, soft reset
+        }
+        catch {
+            // best-effort
+        }
+    }
+    // Resume a different session by restarting the CLI bound to --session <id>.
+    // Routes through the SAME teardown as /exit, then supervises the child so the
+    // shell never reclaims the foreground mid-restart (which corrupted the
+    // terminal and dropped the user back to a broken prompt).
+    const onRelaunch = (sessionId) => {
+        void agent.cleanup().finally(() => {
+            restoreTerminalForHandoff();
+            // Let the terminal process the restore sequences before the child takes
+            // over stdin (mirrors the /exit shell-hold timing).
+            setTimeout(() => {
+                try {
+                    relaunchWithSession(sessionId, { supervise: true });
+                }
+                catch (err) {
+                    console.error(`[relaunch] failed: ${err?.message ?? err}`);
+                    process.exit(1);
+                }
+            }, 80);
+        });
+    };
+    const onExit = () => {
+        void agent.cleanup().finally(() => {
+            restoreTerminalForHandoff();
+            const writeSync = (seq) => {
+                try {
+                    require("node:fs").writeSync(1, seq);
+                }
+                catch {
+                    try {
+                        process.stdout.write(seq);
+                    }
+                    catch {
+                        /* noop */
+                    }
+                }
+            };
             // WezTerm (and similar single-pane terminals) closes the window when
             // the foreground process exits. To keep the pane usable after `/exit`,
             // we hand control over to an interactive shell instead of exiting.
@@ -539,21 +610,20 @@ async function startInteractive(apiKey, baseURL, model, maxToolRounds, batchApi,
             apiKey,
             baseURL,
             model: agent.getModel(),
+            sandboxMode: "off",
+            sandboxSettings: {},
             maxToolRounds,
-            sandboxMode,
-            sandboxSettings,
             version: packageJson.version,
             injectHalt,
         },
         initialMessage,
         onExit,
+        onRelaunch,
     }));
 }
-async function runHeadless(prompt, apiKey, baseURL, model, maxToolRounds, batchApi, sandboxMode, sandboxSettings, format, session, permissionMode = "safe", councilAutoAnswer) {
+async function runHeadless(prompt, apiKey, baseURL, model, maxToolRounds, batchApi, format, session, permissionMode = "safe", councilAutoAnswer) {
     const agent = new Agent(apiKey, baseURL, model, maxToolRounds, {
         session,
-        sandboxMode,
-        sandboxSettings,
         batchApi,
         permissionMode,
     });
@@ -603,14 +673,20 @@ async function runHeadless(prompt, apiKey, baseURL, model, maxToolRounds, batchA
                 writeSafe(process.stderr, tail.stderr ?? "");
             return;
         }
+        const textEmitter = createHeadlessTextEmitter();
         for await (const chunk of agent.processMessage(enhancedMessage)) {
             maybeAutoAnswer(chunk);
-            const writes = renderHeadlessChunk(chunk);
+            const writes = textEmitter.consumeChunk(chunk);
             if (writes.stdout)
                 writeSafe(process.stdout, writes.stdout);
             if (writes.stderr)
                 writeSafe(process.stderr, writes.stderr);
         }
+        const textTail = textEmitter.flush();
+        if (textTail.stdout)
+            writeSafe(process.stdout, textTail.stdout);
+        if (textTail.stderr)
+            writeSafe(process.stderr, textTail.stderr ?? "");
     }
     finally {
         await agent.cleanup();
@@ -646,13 +722,6 @@ function stringOption(value) {
 function collect(value, prev) {
     return [...prev, value];
 }
-function resolveCliSandboxMode(value) {
-    if (value === true)
-        return "shuru";
-    if (value === false)
-        return "off";
-    return undefined;
-}
 async function runBackgroundDelegation(jobPath, options) {
     let output = "";
     let agent;
@@ -680,12 +749,8 @@ async function runBackgroundDelegation(jobPath, options) {
                 "or run 'muonroi-cli keys login <provider>' for subscription OAuth.");
         }
         const maxToolRounds = parseInt(stringOption(options.maxToolRounds) || String(delegation.maxToolRounds), 10) || delegation.maxToolRounds;
-        const sandboxMode = resolveCliSandboxMode(options.sandbox) || delegation.sandboxMode || getCurrentSandboxMode();
-        const sandboxSettings = mergeSandboxSettings(getCurrentSandboxSettings(), delegation.sandboxSettings);
         agent = new Agent(apiKey, baseURL, model, maxToolRounds, {
             persistSession: false,
-            sandboxMode,
-            sandboxSettings,
             batchApi: Boolean(delegation.batchApi ?? options.batchApi === true),
         });
         const result = await agent.runTaskRequest({
@@ -734,22 +799,7 @@ function resolveConfig(options) {
     // 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)
-        cliOverrides.allowNet = true;
-    const allowHostValue = options.allowHost;
-    if (Array.isArray(allowHostValue) && allowHostValue.length > 0) {
-        cliOverrides.allowedHosts = allowHostValue;
-        if (!cliOverrides.allowNet)
-            cliOverrides.allowNet = true;
-    }
-    const portValue = options.port;
-    if (Array.isArray(portValue) && portValue.length > 0) {
-        cliOverrides.ports = portValue;
-    }
-    const sandboxSettings = mergeSandboxSettings(getCurrentSandboxSettings(), cliOverrides);
+    const maxToolRounds = parseInt(stringOption(options.maxToolRounds) || "100", 10) || 100;
     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
@@ -758,13 +808,7 @@ 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 };
+    return { apiKey, baseURL, model, maxToolRounds };
 }
 function requireApiKey(apiKey) {
     if (!apiKey) {
@@ -791,11 +835,6 @@ program
     .option("-p, --prompt <prompt>", "Run a single prompt headlessly")
     .option("--verify", "Run the built-in verify flow headlessly")
     .option("--format <format>", "Headless output format: text or json", parseHeadlessOutputFormat, "text")
-    .option("--sandbox", "Run agent shell commands inside a Shuru sandbox")
-    .option("--no-sandbox", "Run agent shell commands directly on the host")
-    .option("--allow-net", "Enable network access inside the Shuru sandbox")
-    .option("--allow-host <pattern>", "Restrict sandbox network to specific hosts (repeatable)", collect, [])
-    .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 (ultimate runaway safety net)", "120")
@@ -1081,15 +1120,15 @@ program
             console.error(verifyError);
             process.exit(1);
         }
-        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);
+        await runHeadless(buildVerifyPrompt(process.cwd()), requireApiKey(config.apiKey), config.baseURL, config.model, config.maxToolRounds, options.batchApi === true, options.format, options.session, options.permission, councilAutoAnswer);
         return;
     }
     if (options.prompt) {
-        await runHeadless(options.prompt, 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(options.prompt, requireApiKey(config.apiKey), config.baseURL, config.model, config.maxToolRounds, options.batchApi === true, options.format, options.session, options.permission, councilAutoAnswer);
         return;
     }
     const initialMessage = message.length > 0 ? message.join(" ") : undefined;
-    await startInteractive(config.apiKey, config.baseURL, config.model, config.maxToolRounds, options.batchApi === true, config.sandboxMode, config.sandboxSettings, options.session, initialMessage, options.permission, options.injectHalt === true);
+    await startInteractive(config.apiKey, config.baseURL, config.model, config.maxToolRounds, options.batchApi === true, options.session, initialMessage, options.permission, options.injectHalt === true);
 });
 program
     .command("models")
@@ -1213,7 +1252,7 @@ keys
 });
 keys
     .command("login <provider>")
-    .description("Log in to a provider via OAuth subscription (supported: openai, google, xai)")
+    .description("Log in to a provider via OAuth subscription (supported: openai, google/agy, xai). 'google'/'agy' now uses agy client creds.")
     .action(async (provider) => {
     const { runKeysLogin } = await import("./cli/keys.js");
     await runKeysLogin(provider);

package/dist/src/lsp/client-normalize.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ */
+export {};

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

@@ -67,7 +67,7 @@ export function createWorkspaceLspManager(cwd, settings, options = {}) {
         const content = await readFile(filePath, "utf8");
         return syncFile(filePath, content, false, waitForDiagnostics);
     }
-    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 +80,7 @@ export function createWorkspaceLspManager(cwd, settings, options = {}) {
                     await client.saveFile(filePath);
                 }
                 if (waitForDiagnostics) {
-                    await client.waitForDiagnostics(filePath);
+                    await client.waitForDiagnostics(filePath, diagnosticsTimeoutMs);
                 }
                 return {
                     filePath,

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 () => {

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>;