muonroi-cli 1.7.2 → 1.8.1

package/dist/src/headless/output.js

@@ -39,6 +39,11 @@ export function renderHeadlessChunk(chunk) {
             const stderr = [`${color}${icon} ${label}\x1b[0m`, ...mediaLines].join("\n");
             return { stderr: `${stderr}\n` };
         }
+        case "structured_response":
+            // A respond_* terminal answer arrives ONLY as this chunk (never as
+            // `content`). Without this case it hit the no-op default below and the
+            // answer was silently dropped from `--format text` stdout.
+            return chunk.structuredResponse ? { stdout: `${formatStructuredResponseText(chunk.structuredResponse)}\n` } : {};
         case "error":
             return chunk.content ? { stderr: `\x1b[31m${chunk.content}\x1b[0m\n` } : {};
         case "done":
@@ -52,6 +57,119 @@ export function renderHeadlessChunk(chunk) {
 function truncate(text, max) {
     return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
+/**
+ * Plain-text rendering of a respond_* terminal answer for headless `--format
+ * text`. Mirrors the per-taskType layout of {@link StructuredResponseView}
+ * (src/ui/components/structured-response-view.tsx) but emits flat text (no ANSI
+ * box-drawing) so the answer pipes cleanly. Falls back to the primary text
+ * field, then raw JSON, for taskTypes without a dedicated layout.
+ */
+export function formatStructuredResponseText(sr) {
+    const d = (sr.data ?? {});
+    const str = (v) => (typeof v === "string" ? v : "");
+    const arr = (v) => (Array.isArray(v) ? v : []);
+    switch (sr.taskType) {
+        case "general":
+            return str(d.response) || JSON.stringify(d, null, 2);
+        case "documentation": {
+            const examples = arr(d.examples);
+            const parts = [str(d.content)];
+            for (const ex of examples) {
+                if (ex.description)
+                    parts.push(`\n${ex.description}`);
+                if (ex.code)
+                    parts.push(ex.code);
+            }
+            const out = parts.filter(Boolean).join("\n");
+            return out || JSON.stringify(d, null, 2);
+        }
+        case "analyze": {
+            const findings = arr(d.findings);
+            if (findings.length === 0)
+                return JSON.stringify(d, null, 2);
+            return findings
+                .map((f) => {
+                const sev = (f.severity ?? "").toUpperCase();
+                const head = sev ? `[${sev}] ${f.text ?? ""}` : (f.text ?? "");
+                return f.evidence ? `${head}\n  evidence: ${f.evidence}` : head;
+            })
+                .join("\n");
+        }
+        case "plan": {
+            const steps = arr(d.steps);
+            const lines = [];
+            steps.forEach((s, i) => {
+                lines.push(`${i + 1}. ${s.action ?? ""}`);
+                if (s.criterion)
+                    lines.push(`   done when: ${s.criterion}`);
+                if (s.rationale)
+                    lines.push(`   why: ${s.rationale}`);
+            });
+            const assumptions = arr(d.assumptions);
+            const risks = arr(d.risks);
+            if (assumptions.length > 0) {
+                lines.push("", "assumptions:");
+                for (const a of assumptions)
+                    lines.push(`  - ${a}`);
+            }
+            if (risks.length > 0) {
+                lines.push("", "risks:");
+                for (const rk of risks)
+                    lines.push(`  - ${rk}`);
+            }
+            return lines.length > 0 ? lines.join("\n") : JSON.stringify(d, null, 2);
+        }
+        case "debug": {
+            const r = d;
+            const lines = [];
+            if (r.hypothesis)
+                lines.push(`hypothesis: ${r.hypothesis}`);
+            if (r.root_cause)
+                lines.push(`root cause: ${r.root_cause}`);
+            if (r.fix?.file)
+                lines.push(`fix: ${r.fix.file}`);
+            if (r.fix?.diff)
+                lines.push(r.fix.diff);
+            if (r.verify_command)
+                lines.push(`verify: ${r.verify_command}`);
+            return lines.length > 0 ? lines.join("\n") : JSON.stringify(d, null, 2);
+        }
+        case "refactor": {
+            const r = d;
+            const lines = [];
+            if (r.summary)
+                lines.push(r.summary);
+            for (const c of r.changes ?? []) {
+                if (c.file)
+                    lines.push(`\n── ${c.file} ──`);
+                if (c.diff)
+                    lines.push(c.diff);
+            }
+            if (r.verify_command)
+                lines.push(`verify: ${r.verify_command}`);
+            return lines.length > 0 ? lines.join("\n") : JSON.stringify(d, null, 2);
+        }
+        case "generate": {
+            const r = d;
+            const lines = [];
+            if (r.explanation)
+                lines.push(r.explanation);
+            for (const f of r.files ?? []) {
+                const lang = f.language ? ` (${f.language})` : "";
+                if (f.path)
+                    lines.push(`\n── ${f.path}${lang} ──`);
+                if (f.content)
+                    lines.push(f.content);
+            }
+            return lines.length > 0 ? lines.join("\n") : JSON.stringify(d, null, 2);
+        }
+        default: {
+            // Renderer-missing taskType: probe common text-bearing fields, then JSON.
+            const primary = str(d.response) || str(d.summary) || str(d.content) || str(d.text);
+            return primary || JSON.stringify(d, null, 2);
+        }
+    }
+}
 function formatToolCallLabel(tc) {
     const name = tc.function.name;
     try {
@@ -74,6 +192,45 @@ function formatToolCallLabel(tc) {
     catch { }
     return name;
 }
+/**
+ * Stateful headless TEXT consumer. Streams tool/error progress to stderr (via
+ * {@link renderHeadlessChunk}) but BUFFERS assistant `content` so that a
+ * terminal `respond_*` answer ({@link StructuredResponse}) supersedes any
+ * preamble the model leaked before calling the response tool — otherwise the
+ * answer would print twice (once as raw leaked content, once formatted). For a
+ * normal chat turn with no structured answer, the buffered content is flushed
+ * verbatim at the end. Mirrors the buffer-and-supersede design of
+ * {@link createHeadlessJsonlEmitter}.
+ */
+export function createHeadlessTextEmitter() {
+    let pendingContent = "";
+    let structuredEmitted = false;
+    function consumeChunk(chunk) {
+        switch (chunk.type) {
+            case "content":
+                pendingContent += chunk.content ?? "";
+                return {};
+            case "structured_response":
+                if (!chunk.structuredResponse)
+                    return {};
+                // Terminal answer is authoritative — drop any buffered preamble.
+                pendingContent = "";
+                structuredEmitted = true;
+                return { stdout: `${formatStructuredResponseText(chunk.structuredResponse)}\n` };
+            case "done":
+                // Trailing newline is emitted by flush() alongside the final answer.
+                return {};
+            default:
+                return renderHeadlessChunk(chunk);
+        }
+    }
+    function flush() {
+        if (structuredEmitted || pendingContent.length === 0)
+            return {};
+        return { stdout: `${pendingContent}\n` };
+    }
+    return { consumeChunk, flush };
+}
 function jsonLine(event) {
     return `${JSON.stringify(event)}\n`;
 }
@@ -188,6 +345,29 @@ export function createHeadlessJsonlEmitter(sessionId) {
                 }
                 break;
             }
+            case "structured_response": {
+                if (chunk.structuredResponse) {
+                    // Flush any buffered preamble text first so ordering is preserved,
+                    // then emit the typed terminal answer (previously dropped entirely).
+                    if (textBuffer.length > 0) {
+                        stdout += jsonLine(withSession({
+                            type: "text",
+                            stepNumber: currentStep,
+                            text: textBuffer,
+                            timestamp: Date.now(),
+                        }));
+                        textBuffer = "";
+                    }
+                    stdout += jsonLine(withSession({
+                        type: "structured_response",
+                        stepNumber: currentStep,
+                        timestamp: Date.now(),
+                        taskType: chunk.structuredResponse.taskType,
+                        data: chunk.structuredResponse.data,
+                    }));
+                }
+                break;
+            }
             case "error":
                 stdout += jsonLine(withSession({
                     type: "error",

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createHeadlessJsonlEmitter, isHeadlessOutputFormat, renderHeadlessChunk, renderHeadlessPrelude, } from "./output.js";
+import { createHeadlessJsonlEmitter, createHeadlessTextEmitter, formatStructuredResponseText, isHeadlessOutputFormat, renderHeadlessChunk, renderHeadlessPrelude, } from "./output.js";
 function toolCall(name) {
     return {
         id: "tc-1",
@@ -175,5 +175,65 @@ describe("headless output helpers", () => {
         });
         expectSessionAndTimestamp(parsed, sessionId);
     });
+    // Regression backstop for G5: a respond_* terminal answer arrives ONLY as a
+    // `structured_response` chunk. Both headless renderers used to drop it
+    // (no-op default branch), so `--format text` produced empty stdout and
+    // `--format json` emitted no answer payload on a preamble-free turn.
+    describe("structured_response (respond_* terminal answer)", () => {
+        const generalChunk = {
+            type: "structured_response",
+            structuredResponse: { taskType: "general", data: { response: "The answer." } },
+        };
+        it("renderHeadlessChunk renders the answer to stdout (no longer dropped)", () => {
+            const w = renderHeadlessChunk(generalChunk);
+            expect(w.stdout).toBe("The answer.\n");
+            expect(w.stderr).toBeUndefined();
+        });
+        it("formatStructuredResponseText lays out each taskType as flat text", () => {
+            expect(formatStructuredResponseText({
+                taskType: "analyze",
+                data: { findings: [{ text: "Bug X", evidence: "file:1", severity: "high" }] },
+            })).toBe("[HIGH] Bug X\n  evidence: file:1");
+            expect(formatStructuredResponseText({
+                taskType: "plan",
+                data: { steps: [{ action: "Do A", criterion: "A done", rationale: "because" }] },
+            })).toBe("1. Do A\n   done when: A done\n   why: because");
+            // Unknown taskType falls back to a primary text field, then JSON.
+            expect(formatStructuredResponseText({ taskType: "mystery", data: { summary: "hi" } })).toBe("hi");
+            expect(formatStructuredResponseText({ taskType: "mystery", data: { n: 1 } })).toBe('{\n  "n": 1\n}');
+        });
+        it("text emitter: a structured answer SUPERSEDES leaked preamble content (no duplicate)", () => {
+            const e = createHeadlessTextEmitter();
+            // Model leaks the raw answer as content, then delivers it via respond_*.
+            expect(e.consumeChunk({ type: "content", content: '```json\n{"x":1}\n```' }).stdout).toBeUndefined();
+            const out = e.consumeChunk(generalChunk).stdout;
+            expect(out).toBe("The answer.\n");
+            // Nothing buffered remains to flush — the answer is not printed twice.
+            expect(e.flush().stdout).toBeUndefined();
+        });
+        it("text emitter: a normal content-only turn flushes its buffered answer", () => {
+            const e = createHeadlessTextEmitter();
+            expect(e.consumeChunk({ type: "content", content: "PONG" }).stdout).toBeUndefined();
+            expect(e.consumeChunk({ type: "done" }).stdout).toBeUndefined();
+            expect(e.flush().stdout).toBe("PONG\n");
+        });
+        it("text emitter: tool/error progress still streams to stderr immediately", () => {
+            const e = createHeadlessTextEmitter();
+            const w = e.consumeChunk({ type: "tool_calls", toolCalls: [toolCall("bash")] });
+            expect(w.stderr).toContain("bash");
+            expect(w.stdout).toBeUndefined();
+        });
+        it("json emitter: emits a typed structured_response event carrying the payload", () => {
+            const { consumeChunk } = createHeadlessJsonlEmitter("sess-sr");
+            const out = consumeChunk(generalChunk).stdout ?? "";
+            const events = out
+                .trim()
+                .split("\n")
+                .map((l) => JSON.parse(l));
+            const sr = events.find((ev) => ev.type === "structured_response");
+            expect(sr).toMatchObject({ type: "structured_response", taskType: "general", data: { response: "The answer." } });
+            expectSessionAndTimestamp(sr, "sess-sr");
+        });
+    });
 });
 //# sourceMappingURL=output.test.js.map

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,41 @@ 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;
+    globalThis.__muonroiTuiActive = 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 {
+        /* crash.log is best-effort diagnostics; the logger itself must never throw */
     }
-    catch { }
+}
+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 +335,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 +398,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,
@@ -404,6 +426,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.
      *
@@ -418,6 +444,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") {
@@ -582,9 +611,9 @@ async function startInteractive(apiKey, baseURL, model, maxToolRounds, batchApi,
             apiKey,
             baseURL,
             model: agent.getModel(),
+            sandboxMode: "off",
+            sandboxSettings: {},
             maxToolRounds,
-            sandboxMode,
-            sandboxSettings,
             version: packageJson.version,
             injectHalt,
         },
@@ -593,11 +622,9 @@ async function startInteractive(apiKey, baseURL, model, maxToolRounds, batchApi,
         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,
     });
@@ -647,14 +674,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();
@@ -690,13 +723,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;
@@ -724,12 +750,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({
@@ -778,22 +800,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
@@ -802,13 +809,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) {
@@ -835,11 +836,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")
@@ -977,7 +973,8 @@ program
         console.log("Checking for updates...");
         const result = await runUpdate(packageJson.version);
         console.log(result.output);
-        process.exit(result.success ? 0 : 1);
+        process.exitCode = result.success ? 0 : 1;
+        return;
     }
     changeDirectoryOrExit(options.directory);
     // Boot model registry BEFORE any key resolution path runs —
@@ -1125,15 +1122,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")
@@ -1164,7 +1161,7 @@ program
     console.log("Checking for updates...");
     const result = await runUpdate(packageJson.version);
     console.log(result.output);
-    process.exit(result.success ? 0 : 1);
+    process.exitCode = result.success ? 0 : 1;
 });
 program
     .command("uninstall")
@@ -1257,7 +1254,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 {};