@prestyj/cli 5.12.0 → 5.16.0

package/dist/app-sidecar.js

@@ -18,6 +18,7 @@ import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { parseArgs } from "node:util";
+import { spawn } from "node:child_process";
 import { environmentSecrets, formatError, redactValue } from "@prestyj/ai";
 import { runJsonMode } from "./modes/json-mode.js";
 import { runSubagentWorkerMode } from "./modes/subagent-worker-mode.js";
@@ -37,6 +38,7 @@ import { validateNolanModelPref, effectiveNolanModel, } from "./core/nolan-model
 import { normalizeAutopilotMarkersForHistory, normalizeAppMarkersForHistory, normalizeNolanTurnsForHistory, getHistoryMessageVisibility, replayMessagesInOrder, restoreUserRow, restoreAssistantTexts, resolveRestoredCommand, autopilotMarkerCopySeed, } from "./core/session-history.js";
 import { sessionToMarkdown, defaultExportFilename, } from "./core/session-export.js";
 import { AuthStorage } from "./core/auth-storage.js";
+import { advancesPhase, explainPullFailure, isGgufShard, isValidHfRepoId, parseOllamaPullLine, pickGgufQuant, SHARDED_MESSAGE, toHfSearchRow, } from "./hf-pull.js";
 import { cleanupToolOutputs } from "./tools/overflow.js";
 import { readCappedBody } from "./utils/http-body.js";
 import { fetchSubscriptionUsage, SubscriptionUsageError, XIAOMI_CREDITS_KEY, dualAuthProvider, oauthStorageKey, discoverLocalModels, findProbedModel, formatLocalModelId, parseLocalModelId, probeEndpoint, toModelInfo as localModelInfo, } from "@prestyj/core";
@@ -47,7 +49,7 @@ import { loginGemini } from "./core/oauth/gemini.js";
 import { loginKimi } from "./core/oauth/kimi.js";
 import { loginXai } from "./core/oauth/xai.js";
 import { AUTH_PROVIDERS, authPriorityNote, describeAuthMethods, } from "./core/auth-providers.js";
-import { ensureAppDirs, loadSavedSettings } from "./config.js";
+import { ensureAppDirs, loadSavedSettings, projectScopeAllowed } from "./config.js";
 import { SettingsManager } from "./core/settings-manager.js";
 import { installPlugin, listInstalledPlugins, removePlugin, } from "./core/extensions/plugin-bundles.js";
 import { getModel, getDefaultThinkingLevel, getContextWindow, getAllModels, clearRuntimeModels, registerRuntimeModels, } from "./core/model-registry.js";
@@ -67,14 +69,16 @@ import { RADIO_STATIONS, getCurrentStation, getRadioVolume, playRadio, setRadioV
 import { enrichProcessPath } from "./core/shell-path.js";
 import { downscaleForPreview, shrinkToFit, validateVisionImage } from "./utils/image.js";
 import { startServeMode } from "./modes/serve-mode.js";
+import { installSteroids, probeSteroids } from "./core/steroids.js";
 import { loadTelegramConfig, saveTelegramConfig, verifyBotToken } from "./core/telegram-config.js";
 import { loadServers, addServer, removeServer, getServer, parseMcpAddCommand, MCPClientManager, McpOAuthStore, createElicitationBridge, } from "./core/mcp/index.js";
+import { createAskUserBridge } from "./core/ask-user.js";
+import { createAskUserTool } from "./tools/ask-user.js";
 import { buildSnapshot, levelForXp, rankForLevel } from "./core/progress/ranks.js";
 import { loadProgress, peekProgress, updateProgress } from "./core/progress/store.js";
 import { awardPrompt, awardCommits } from "./core/progress/engine.js";
 import { detectNewCommits, repoKey } from "./core/progress/git-xp.js";
 import { rebuildFromSessions } from "./core/progress/rebuild.js";
-import { captureSidecarError, flushSidecarErrors, shouldCaptureToolFailure, shouldCaptureUsagePollingError, wrapSidecarHandler, } from "./core/sidecar-error-reporter.js";
 const AUTOMATION_PROVENANCE = {
     source: "runtime",
     kind: "automation",
@@ -92,6 +96,8 @@ const ALL_PROVIDERS = [
     "minimax",
     "xiaomi",
     "deepseek",
+    // Open-community gateway, before the provider-agnostic one
+    "huggingface",
     // Japan, then provider-agnostic gateway last
     "sakana",
     "openrouter",
@@ -193,7 +199,6 @@ async function persistModelSelection(settingsFile, provider, model) {
         await sm.set("defaultModel", model);
     }
     catch (err) {
-        captureSidecarError(err, "app-sidecar.settings.persist-model");
         log("WARN", "app-sidecar", "failed to persist model selection", { err: String(err) });
     }
 }
@@ -210,7 +215,6 @@ async function persistThinkingLevel(settingsFile, level) {
             await sm.set("thinkingLevel", level);
     }
     catch (err) {
-        captureSidecarError(err, "app-sidecar.settings.persist-thinking");
         log("WARN", "app-sidecar", "failed to persist thinking level", { err: String(err) });
     }
 }
@@ -388,27 +392,49 @@ function mcpRowSummary(config) {
 }
 /** Load + connect every server, returning one wire row per server. Mirrors the
  *  CLI dashboard's buildRows (connectAllDetailed, then dispose). Empty list
- *  short-circuits before spawning any stdio process / opening any HTTP conn. */
-async function buildMcpRows(cwd) {
+ *  short-circuits before spawning any stdio process / opening any HTTP conn.
+ *  Project-scope servers run repo-controlled commands, so unless the user
+ *  trusts them (trustProjectMcpServers) they are reported blocked WITHOUT
+ *  being connected — even a status probe would spawn the process. */
+async function buildMcpRows(cwd, settingsFile) {
     const scoped = await loadServers(cwd);
     if (scoped.length === 0)
         return [];
+    const settings = loadSavedSettings(settingsFile);
+    const allowProject = projectScopeAllowed(settings.trustProjectMcpServers, settings.trustedProjects, cwd);
+    const connectable = scoped.filter((s) => allowProject || s.scope !== "project");
+    const blocked = scoped.filter((s) => !allowProject && s.scope === "project");
     const manager = new MCPClientManager();
     try {
-        const results = await manager.connectAllDetailed(scoped.map((s) => s.config));
-        return scoped.map((s) => {
-            const result = results.find((r) => r.name === s.config.name);
-            return {
+        const results = connectable.length > 0
+            ? await manager.connectAllDetailed(connectable.map((s) => s.config))
+            : [];
+        return [
+            ...connectable.map((s) => {
+                const result = results.find((r) => r.name === s.config.name);
+                return {
+                    name: s.config.name,
+                    scope: s.scope,
+                    ok: result?.ok ?? false,
+                    toolCount: result?.toolCount ?? 0,
+                    error: result?.error,
+                    kind: s.config.url ? "http" : "stdio",
+                    summary: mcpRowSummary(s.config),
+                    requiresAuth: result?.requiresAuth,
+                };
+            }),
+            ...blocked.map((s) => ({
                 name: s.config.name,
                 scope: s.scope,
-                ok: result?.ok ?? false,
-                toolCount: result?.toolCount ?? 0,
-                error: result?.error,
-                kind: s.config.url ? "http" : "stdio",
+                ok: false,
+                toolCount: 0,
+                error: "Project-scope server not connected — this repo's .ezcoder/mcp.json runs " +
+                    "repo-controlled commands. Add or re-add a server in this project via " +
+                    "the MCP modal to trust it.",
+                kind: (s.config.url ? "http" : "stdio"),
                 summary: mcpRowSummary(s.config),
-                requiresAuth: result?.requiresAuth,
-            };
-        });
+            })),
+        ];
     }
     finally {
         await manager.dispose();
@@ -494,10 +520,6 @@ async function runJsonModeIfRequested() {
         allowedMcpServers,
         promptCacheKey: values["prompt-cache-key"],
     }).catch(async (err) => {
-        captureSidecarError(err, "app-sidecar.json-mode", {
-            provider: String(values.provider ?? "anthropic"),
-        });
-        await flushSidecarErrors();
         process.stderr.write((err instanceof Error ? err.message : String(err)) + "\n");
         process.exit(1);
     });
@@ -510,9 +532,10 @@ function daemonReadBody(req, res) {
     return readCappedBody(req, res);
 }
 function daemonJson(res, status, body) {
+    // No CORS headers: only the Rust proxy (no Origin) should call this daemon.
+    // Granting origins would let any web page read responses from loopback.
     res.writeHead(status, {
         "content-type": "application/json",
-        "access-control-allow-origin": "*",
     });
     res.end(JSON.stringify(body));
 }
@@ -530,6 +553,13 @@ async function main() {
     // GG_APP_LISTENING handshake and consumed by the shell.
     const port = Number(process.env.GG_APP_PORT ?? 0);
     const host = "127.0.0.1";
+    // Per-launch bearer token. The Rust shell generates one and passes it via
+    // GG_APP_TOKEN; spawned any other way (dev, tests, smoke) we mint our own
+    // and report it on the GG_APP_LISTENING line. Every request must carry it
+    // as x-ez-token: this daemon creates sessions for arbitrary cwds, runs
+    // prompts, and installs plugins, so an unauthenticated loopback port lets
+    // any local process drive the agent as the user.
+    const authToken = process.env.GG_APP_TOKEN ?? randomUUID();
     const paths = await ensureAppDirs();
     // Own log file so the app sidecar never clobbers the interactive CLI's
     // ~/.ezcoder/debug.log (initLogger truncates on each start).
@@ -543,7 +573,9 @@ async function main() {
         const includeRuntime = phase === "idle_timeout_fired" ||
             phase === "hard_timeout_fired" ||
             phase === "stall_exhausted";
-        log("INFO", "stream", phase, {
+        // A session stuck on the non-streaming fallback costs real money and real
+        // latency; it does not belong in the INFO noise floor.
+        log(phase === "non_streaming_session" ? "WARN" : "INFO", "stream", phase, {
             ...(data ?? {}),
             ...(includeRuntime
                 ? {
@@ -692,9 +724,6 @@ async function main() {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            if (shouldCaptureUsagePollingError(error)) {
-                captureSidecarError(error, "app-sidecar.usage.fetch", { provider });
-            }
             let backoffMs;
             if (error instanceof SubscriptionUsageError && error.status === 429) {
                 backoffMs = Math.min(USAGE_RATE_LIMIT_MAX_BACKOFF_MS, Math.max(USAGE_RATE_LIMIT_MIN_BACKOFF_MS, error.retryAfterMs ?? USAGE_RATE_LIMIT_FALLBACK_BACKOFF_MS));
@@ -777,19 +806,29 @@ async function main() {
             return null;
         }
     }
-    const server = http.createServer(wrapSidecarHandler((req, res) => {
+    const server = http.createServer((req, res) => {
         const url = req.url ?? "/";
         const method = req.method ?? "GET";
-        // CORS preflight — the webview origin differs from 127.0.0.1.
+        // Answer preflights with a bare 204 but grant NO origins — the webview
+        // reaches the daemon through the Rust proxy, never cross-origin, so any
+        // browser page's preflight must fail here.
         if (method === "OPTIONS") {
-            res.writeHead(204, {
-                "access-control-allow-origin": "*",
-                "access-control-allow-methods": "GET, POST, DELETE, OPTIONS",
-                "access-control-allow-headers": "content-type, x-ez-session",
-            });
+            res.writeHead(204);
             res.end();
             return;
         }
+        // Host allowlist. The daemon binds 127.0.0.1 only; rejecting any other
+        // Host blocks DNS rebinding, where a web page's request arrives with
+        // the attacker's hostname (browsers cannot spoof Host).
+        const reqHost = req.headers.host ?? "";
+        if (!/^(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/i.test(reqHost)) {
+            daemonJson(res, 403, { error: "forbidden host" });
+            return;
+        }
+        if (req.headers["x-ez-token"] !== authToken) {
+            daemonJson(res, 401, { error: "unauthorized" });
+            return;
+        }
         // ── Daemon-level routes (session lifecycle) ──────────────────────────
         // Create a session for a window: { mode?, cwd, sessionPath? } → { sessionId }.
         if (method === "POST" && url === "/session") {
@@ -831,7 +870,6 @@ async function main() {
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
-                    captureSidecarError(err, "app-sidecar.session.create");
                     log("ERROR", "app-sidecar", "session create failed", { message });
                     daemonJson(res, 500, { error: message });
                 }
@@ -868,7 +906,6 @@ async function main() {
                 }
                 daemonJson(res, 200, await subscriptionUsage(provider));
             })().catch((error) => {
-                captureSidecarError(error, "app-sidecar.usage.request");
                 log("ERROR", "app-sidecar", "subscription usage request failed", {
                     message: error instanceof Error ? error.message : String(error),
                 });
@@ -884,11 +921,12 @@ async function main() {
             return;
         }
         ctx.handle(req, res, url, method);
-    }, "app-sidecar.http"));
+    });
     server.listen(port, host, () => {
         const addr = server.address();
-        // The Rust shell reads this line to learn the daemon port.
-        process.stdout.write(`GG_APP_LISTENING ${addr.port}\n`);
+        // The Rust shell reads this line to learn the daemon port (it already
+        // knows the token — it set GG_APP_TOKEN; the field serves other spawners).
+        process.stdout.write(`GG_APP_LISTENING ${addr.port} ${authToken}\n`);
         log("INFO", "app-sidecar", "daemon listening", { port: String(addr.port), host });
     });
     const shellPid = process.ppid;
@@ -945,11 +983,10 @@ const NOLAN_ALLOWED_TOOLS = [
     "web_fetch",
     "web_search",
     "screenshot",
+    // Local corpus of real repos: lets Nolan verify against code that ships
+    // instead of assuming — core to how he's meant to work. Read-only.
+    "steroids",
 ];
-/** MCP servers Nolan is allowed to use. kencode-search lets him look into real
- *  public repos / verify against actual code instead of assuming — core to how
- *  he's meant to work. Read-only research; no other MCP server is connected. */
-const NOLAN_ALLOWED_MCP_SERVERS = ["kencode-search"];
 /** Extract the plain text of the most recent assistant message (Nolan's reply).
  *  Strips tool-call / image blocks, returning just the prose Nolan streamed. */
 function lastAssistantText(messages) {
@@ -1036,7 +1073,6 @@ async function createProgressManager(agentDir, broadcastAll) {
             broadcastAll(buildSnapshot(updated), originId);
         }
         catch (err) {
-            captureSidecarError(err, "app-sidecar.progress.award");
             log("DEBUG", "app-sidecar", "progress award failed", {
                 message: err instanceof Error ? err.message : String(err),
             });
@@ -1070,7 +1106,6 @@ async function createProgressManager(agentDir, broadcastAll) {
         progressWatcher = watcher;
     }
     catch (err) {
-        captureSidecarError(err, "app-sidecar.progress.watch");
         log("DEBUG", "app-sidecar", "progress watch unavailable", {
             message: err instanceof Error ? err.message : String(err),
         });
@@ -1168,7 +1203,7 @@ async function createSession(deps, opts) {
             // command that doesn't exist in the app.
             .replaceAll(/Run \/compact to shrink history, or start a new session\./gi, "Start a new session to reset the context.")
             // /model: handle each phrasing pattern
-            .replaceAll(/switch to claude-fable-5 with \/model/gi, "switch to claude-fable-5 using the model selector")
+            .replaceAll(/switch to (\S+) with \/model/gi, "switch to $1 using the model selector")
             .replaceAll(/Switch with \/model\./gi, "Switch using the model selector.")
             .replaceAll(/try a different model with \/model\./gi, "try a different model using the model selector.")
             .replaceAll(/Use \/model to switch/gi, "Use the model selector to switch")
@@ -1204,11 +1239,6 @@ async function createSession(deps, opts) {
         const f = formatError(err);
         const message = f.message ? desktopGuidance(f.message) : undefined;
         const guidance = localNetworkGuidance(f.source) ?? desktopGuidance(f.guidance);
-        captureSidecarError(err, `app-sidecar.${logLabel.replaceAll(" ", "-")}`, {
-            scope: type,
-            ...(f.provider ? { provider: f.provider } : {}),
-            ...(f.statusCode != null ? { status: String(f.statusCode) } : {}),
-        });
         log("ERROR", "app-sidecar", logLabel, {
             headline: f.headline,
             source: f.source,
@@ -1247,6 +1277,16 @@ async function createSession(deps, opts) {
             server: prompt.server,
         }),
     });
+    // ── ask_user bridge ────────────────────────────────────────
+    // The `ask_user` tool parks the turn on a human answer. Same shape as the
+    // MCP bridge above: broadcast over SSE, resolved when the webview POSTs
+    // /ask/:id. Registered ONLY here — a TUI/headless/subagent run has nobody to
+    // answer, so the tool is absent there rather than hanging on a dead channel.
+    const asks = createAskUserBridge({
+        broadcast: (prompt) => broadcast("ask_user", prompt),
+        onTimeout: (prompt) => log("WARN", "app-sidecar", "ask_user timed out", { id: prompt.id }),
+    });
+    const askUserTool = createAskUserTool(asks.park);
     // The session file path to resume (passed by the daemon's POST /session);
     // empty/unset starts a fresh session.
     const resumeSessionPath = opts.sessionPath;
@@ -1272,13 +1312,16 @@ async function createSession(deps, opts) {
         session = createChatAgent(chatAgent, {
             ...baseSessionOptions,
             sessionsDir: paths.sessionsDir,
-            additionalTools: [...buildMemoryTools(memoryStore), ...buildJiwaTools(jiwaStore)],
+            additionalTools: [
+                askUserTool,
+                ...buildMemoryTools(memoryStore),
+                ...buildJiwaTools(jiwaStore),
+            ],
             getSystemPromptTail: () => `${memoryStore.renderForPrompt()}\n\n${jiwaStore.renderForPrompt()}`,
             onAgentChange: async (nextAgent) => {
                 chatAgent = nextAgent;
                 broadcast("chat_agent_change", { chatAgent: nextAgent });
                 await session.persistAppMarker("agent_handoff", { chatAgent: nextAgent }).catch((error) => {
-                    captureSidecarError(error, "app-sidecar.chat-agent.persist-handoff");
                     log("WARN", "app-sidecar", "agent handoff marker persist failed", {
                         message: error instanceof Error ? error.message : String(error),
                     });
@@ -1289,6 +1332,7 @@ async function createSession(deps, opts) {
     else {
         session = new AgentSession({
             ...baseSessionOptions,
+            additionalTools: [askUserTool],
             // Plan mode belongs only to the coding agent.
             onEnterPlan: async (reason) => {
                 // Unattended task runs cannot approve plans; implement directly instead.
@@ -1331,8 +1375,8 @@ async function createSession(deps, opts) {
         }
     }
     log("INFO", "app-sidecar", "session ready", { provider, model, mode, chatAgent, cwd });
-    // ── Local models (Ollama / LM Studio / llama.cpp / vLLM) ──
-    // Probing four HTTP endpoints must never delay readiness, so this runs in the
+    // ── Local models (Ollama, plus user-added custom endpoints) ──
+    // Probing endpoints must never delay readiness, so this runs in the
     // background (same shape as backgroundMcpConnect) and pushes a models_change
     // frame when it lands.
     let localProbes = [];
@@ -1375,6 +1419,204 @@ async function createSession(deps, opts) {
             })),
         };
     }
+    let hfPull = null;
+    const hfPullPayload = (s) => ({
+        repo: s.repo,
+        model: s.model,
+        tag: s.tag,
+        file: s.file,
+        sizeBytes: s.sizeBytes,
+        phase: s.phase,
+        percent: s.percent,
+        ...(s.detail ? { detail: s.detail } : {}),
+        ...(s.error ? { error: s.error } : {}),
+    });
+    /** Stored HF token, if the user connected the huggingface provider. */
+    async function hfToken() {
+        try {
+            const auth = new AuthStorage(paths.authFile);
+            const creds = await auth.resolveCredentials("huggingface");
+            return creds.accessToken || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async function hfHubJson(pathname) {
+        const token = await hfToken();
+        const res = await fetch(`https://huggingface.co${pathname}`, {
+            headers: token ? { authorization: `Bearer ${token}` } : {},
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok)
+            throw new Error(`Hugging Face responded ${res.status}`);
+        return res.json();
+    }
+    /** Search the Hub for GGUF repos (what Ollama can pull). */
+    async function hfSearch(query) {
+        // `filter=gguf` (the tag the Hub applies to repos that actually contain
+        // GGUF files) — `library=gguf` also matches safetensors-only base repos,
+        // which then fail at pull time. `expand[]=gguf` confirms per row.
+        const params = new URLSearchParams({
+            search: query,
+            filter: "gguf",
+            sort: "downloads",
+            direction: "-1",
+            limit: "12",
+        });
+        for (const field of ["gguf", "downloads", "likes", "lastModified"]) {
+            params.append("expand[]", field);
+        }
+        const data = (await hfHubJson(`/api/models?${params.toString()}`));
+        return (Array.isArray(data) ? data : [])
+            .map(toHfSearchRow)
+            .filter((r) => r !== null);
+    }
+    /**
+     * Start `ollama pull hf.co/<repo>[:quant]`. Resolves once the child is
+     * spawned; progress streams as `hf_pull` events. The chosen quant comes from
+     * the repo's real file list — the client only ever sends a repo id, so there
+     * is no injection surface into argv.
+     */
+    async function startHfPull(repo) {
+        if (hfPull?.child) {
+            throw Object.assign(new Error("A download is already running."), { status: 409 });
+        }
+        // `recursive=true`: many repos (unsloth, mradermacher) keep quants in
+        // per-quant subfolders, and a flat listing reports them as GGUF-less.
+        const tree = (await hfHubJson(`/api/models/${repo}/tree/main?recursive=true`));
+        const files = (Array.isArray(tree) ? tree : []).flatMap((entry) => {
+            const e = entry;
+            // `type` guards a directory entry (size 0) from beating real files in the
+            // size fallback; the Hub marks folders as "directory".
+            if (e.type !== undefined && e.type !== "file")
+                return [];
+            if (typeof e.path !== "string" || !e.path.toLowerCase().endsWith(".gguf"))
+                return [];
+            const size = Number(e.lfs?.size ?? e.size ?? 0);
+            return [{ path: e.path, sizeBytes: Number.isFinite(size) ? size : 0 }];
+        });
+        const choice = pickGgufQuant(files);
+        if (!choice) {
+            const sharded = files.some((f) => isGgufShard(f.path));
+            throw Object.assign(new Error(sharded ? SHARDED_MESSAGE : "That repo has no GGUF file for Ollama to pull."), { status: 400 });
+        }
+        const model = `hf.co/${repo}${choice.tag ? `:${choice.tag}` : ""}`;
+        const token = await hfToken();
+        const state = {
+            repo,
+            model,
+            tag: choice.tag,
+            file: choice.file.path,
+            sizeBytes: choice.file.sizeBytes,
+            phase: "preparing",
+            percent: 0,
+            child: null,
+        };
+        hfPull = state;
+        broadcast("hf_pull", hfPullPayload(state));
+        // ollama prints progress to stderr (stdout on some builds); parse both.
+        let stderrTail = "";
+        let lastBroadcast = "";
+        const feed = (chunk) => {
+            // Once the pull is terminal (success, failure, or user cancel) stop
+            // parsing: a killed ollama dumps a burst of stderr that would otherwise
+            // spam the modal with garbage frames after the outcome is already shown.
+            if (state.phase === "success" || state.phase === "error")
+                return;
+            for (const line of chunk.split(/\r\n|\r|\n/)) {
+                const parsed = parseOllamaPullLine(line);
+                if (!parsed)
+                    continue;
+                // A redrawn frame repeats `pulling manifest` next to live progress; it
+                // must not drag the modal back to "Contacting Ollama…".
+                if (!advancesPhase(state.phase, parsed.phase))
+                    continue;
+                if (parsed.phase !== "error") {
+                    state.phase = parsed.phase;
+                    if (parsed.percent !== undefined)
+                        state.percent = parsed.percent;
+                    state.detail = parsed.detail;
+                }
+                // ollama redraws its TUI frame several times a second, mostly with
+                // identical numbers. Broadcasting each one re-rendered the modal for no
+                // visible change; only a frame that actually reads differently ships.
+                const next = JSON.stringify(hfPullPayload(state));
+                if (next === lastBroadcast)
+                    continue;
+                lastBroadcast = next;
+                broadcast("hf_pull", hfPullPayload(state));
+            }
+        };
+        try {
+            const child = spawn("ollama", ["pull", model], {
+                env: { ...process.env, ...(token ? { HF_TOKEN: token } : {}) },
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            state.child = child;
+            child.stdout?.setEncoding("utf8");
+            child.stderr?.setEncoding("utf8");
+            child.stdout?.on("data", feed);
+            child.stderr?.on("data", (d) => {
+                stderrTail = (stderrTail + d).slice(-2000);
+                feed(d);
+            });
+            child.on("error", (err) => {
+                state.child = null;
+                state.phase = "error";
+                state.error =
+                    err.code === "ENOENT"
+                        ? "Ollama isn't installed (or isn't on PATH). Install it from ollama.com, then retry."
+                        : `Could not start Ollama: ${err.message}`;
+                broadcast("hf_pull", hfPullPayload(state));
+            });
+            child.on("close", (code) => {
+                state.child = null;
+                if (state.phase === "success" || state.phase === "error")
+                    return; // cancelled
+                if (code === 0) {
+                    state.phase = "success";
+                    state.percent = 100;
+                    state.detail = undefined;
+                    broadcast("hf_pull", hfPullPayload(state));
+                    // The new model only exists to the app once Ollama lists it. Ollama's
+                    // library is machine-wide, like the shared auth file, so every window
+                    // gets the refresh — not just the one that ran the download.
+                    void scanLocalModels(true)
+                        .then(() => broadcastAll("models_change", { local: localStatePayload() }))
+                        .catch(() => undefined);
+                }
+                else {
+                    state.phase = "error";
+                    state.error = state.error ?? explainPullFailure(stderrTail);
+                    broadcast("hf_pull", hfPullPayload(state));
+                }
+            });
+        }
+        catch (err) {
+            state.child = null;
+            state.phase = "error";
+            state.error = `Could not start Ollama: ${err instanceof Error ? err.message : String(err)}`;
+            broadcast("hf_pull", hfPullPayload(state));
+        }
+        return hfPullPayload(state);
+    }
+    function cancelHfPull() {
+        const child = hfPull?.child;
+        if (!child)
+            return false;
+        // Terminal state FIRST, then the kill: the child's death rattle must not
+        // overwrite the clean "cancelled" outcome with raw stderr.
+        if (hfPull) {
+            hfPull.phase = "error";
+            hfPull.error = "Download cancelled.";
+            hfPull.detail = undefined;
+            hfPull.child = null;
+            broadcast("hf_pull", hfPullPayload(hfPull));
+        }
+        child.kill("SIGTERM");
+        return true;
+    }
     /**
      * Why `modelId` can't be selected right now, or `undefined` when it can.
      * Two real footguns get a clear answer instead of a mid-run provider error:
@@ -1536,7 +1778,6 @@ async function createSession(deps, opts) {
             .catch(() => false)
             .then(() => syncApprovedPlanProgress(generation))
             .catch((error) => {
-            captureSidecarError(error, "app-sidecar.plan.refresh-progress");
             log("WARN", "app-sidecar", "plan progress refresh failed", {
                 message: error instanceof Error ? error.message : String(error),
             });
@@ -1595,16 +1836,17 @@ async function createSession(deps, opts) {
     session.eventBus.on("tool_call_end", (d) => {
         const name = toolCallNames.get(d.toolCallId) ?? "unknown";
         toolCallNames.delete(d.toolCallId);
-        if (d.isError && shouldCaptureToolFailure(name, d.result)) {
-            // Expected model-correctable validation failures stay in the local log and
-            // conversation. Unexpected failures are reported without private result data.
-            captureSidecarError(new Error(`Tool ${name} failed`), `tool.${name}`, { tool: name });
-        }
         log(d.isError ? "ERROR" : "INFO", "tool", `Tool call ended: ${name}`, {
             id: d.toolCallId,
             durationMs: String(d.durationMs),
             isError: String(d.isError),
             ...(d.isError ? { result: d.result.slice(0, 500) } : {}),
+            // Consecutive-failure count for schema rejections. Attempt 1 followed by
+            // a success means the model self-corrected; reaching 3 means it looped
+            // and the turn was ended. Grep this to tell the two apart.
+            ...(d.invalidArgAttempt === undefined
+                ? {}
+                : { invalidArgAttempt: String(d.invalidArgAttempt) }),
         });
         broadcast("tool_call_end", d);
         // The agent can add/done/remove project tasks via the `tasks` tool during a
@@ -1628,12 +1870,25 @@ async function createSession(deps, opts) {
     session.eventBus.on("agent_done", (d) => broadcast("agent_done", d));
     // Non-clean stop (max_tokens/refusal/provider error) — info-style frame so
     // the webview can warn instead of presenting truncated output as complete.
-    session.eventBus.on("truncated", (d) => broadcast("truncated", d));
+    // empty_response is a hard failure (no output at all): route it through
+    // broadcastError so the app renders an error row — the webview does not
+    // render bare "truncated" frames.
+    session.eventBus.on("truncated", (d) => {
+        if (d.reason === "empty_response") {
+            broadcastError("error", "empty response", new Error("The model returned an empty response after retries — try sending again."));
+            return;
+        }
+        broadcast("truncated", d);
+    });
     session.eventBus.on("error", (d) => {
         broadcastError("error", "agent error", d.error);
     });
     session.eventBus.on("model_change", (d) => broadcast("model_change", d));
     session.eventBus.on("hook", (d) => broadcast("hook", d));
+    // Fires BEFORE the candidate final answer streams. The webview holds assistant
+    // text back while armed, so an Ideal review supersedes a draft that was never
+    // painted instead of deleting one the user already started reading.
+    session.eventBus.on("hook_armed", (d) => broadcast("hook_armed", d));
     session.eventBus.on("subagent_state", (d) => broadcast("subagent_state", d));
     session.eventBus.on("compaction_start", (d) => broadcast("compaction_start", d));
     session.eventBus.on("compaction_end", (d) => broadcast("compaction_end", d));
@@ -1794,7 +2049,6 @@ async function createSession(deps, opts) {
             cwd,
             systemPrompt: await buildNolanSystemPrompt(cwd),
             allowedTools: NOLAN_ALLOWED_TOOLS,
-            allowedMcpServers: NOLAN_ALLOWED_MCP_SERVERS,
             transient: true,
             signal: nolanAbort.signal,
             // Nolan belongs to this window, so route MCP elicitation prompts there.
@@ -1866,7 +2120,6 @@ async function createSession(deps, opts) {
             cwd,
             systemPrompt: await buildNolanAutopilotSystemPrompt(cwd),
             allowedTools: NOLAN_ALLOWED_TOOLS,
-            allowedMcpServers: NOLAN_ALLOWED_MCP_SERVERS,
             transient: true,
             signal: nolanAutoAbort.signal,
             // Route this window's MCP elicitation prompts through the shared bridge.
@@ -1893,8 +2146,9 @@ async function createSession(deps, opts) {
         abort.abort();
         // An MCP tool call parked on user input is not cancelled by the signal —
         // the promise lives in the bridge. Release it, or the aborted turn's tool
-        // call never returns.
+        // call never returns. Same for a question parked on the user.
         elicitations.cancelAll();
+        asks.cancelAll();
         // Stop a run-all sweep and every async child through AgentSession's signal.
         taskRunAll = false;
         autopilotCancelled = true;
@@ -1980,7 +2234,6 @@ async function createSession(deps, opts) {
                 catch (error) {
                     // Keep tracking when prompt cleanup fails; hiding the widget here
                     // would claim completion while the approved-plan contract remained.
-                    captureSidecarError(error, "app-sidecar.plan.cleanup");
                     log("WARN", "app-sidecar", "completed plan cleanup failed", {
                         message: error instanceof Error ? error.message : String(error),
                     });
@@ -2508,7 +2761,6 @@ async function createSession(deps, opts) {
         const payload = JSON.stringify(redactValue(body, { secrets: environmentSecrets(process.env) }));
         res.writeHead(status, {
             "content-type": "application/json",
-            "access-control-allow-origin": "*",
         });
         res.end(payload);
     }
@@ -2541,7 +2793,6 @@ async function createSession(deps, opts) {
                 .snapshot()
                 .then((snapshot) => json(res, 200, snapshot))
                 .catch((error) => {
-                captureSidecarError(error, "app-sidecar.memory.snapshot");
                 json(res, 500, { error: error instanceof Error ? error.message : String(error) });
             });
             return;
@@ -2557,7 +2808,6 @@ async function createSession(deps, opts) {
                 .then(() => memoryStore.snapshot())
                 .then((snapshot) => json(res, 200, snapshot))
                 .catch((error) => {
-                captureSidecarError(error, "app-sidecar.memory.forget");
                 json(res, 500, { error: error instanceof Error ? error.message : String(error) });
             });
             return;
@@ -2567,7 +2817,6 @@ async function createSession(deps, opts) {
                 .snapshot()
                 .then((snapshot) => json(res, 200, snapshot))
                 .catch((error) => {
-                captureSidecarError(error, "app-sidecar.jiwa.snapshot");
                 json(res, 500, { error: error instanceof Error ? error.message : String(error) });
             });
             return;
@@ -2583,7 +2832,6 @@ async function createSession(deps, opts) {
                 .then(() => jiwaStore.snapshot())
                 .then((snapshot) => json(res, 200, snapshot))
                 .catch((error) => {
-                captureSidecarError(error, "app-sidecar.jiwa.forget");
                 json(res, 500, { error: error instanceof Error ? error.message : String(error) });
             });
             return;
@@ -2593,7 +2841,6 @@ async function createSession(deps, opts) {
                 "content-type": "text/event-stream",
                 "cache-control": "no-cache",
                 connection: "keep-alive",
-                "access-control-allow-origin": "*",
             });
             res.write(`retry: 1000\n\n`);
             const client = { id: ++clientSeq, res };
@@ -2626,7 +2873,6 @@ async function createSession(deps, opts) {
             void listInstalledPlugins(paths.extensionsDir)
                 .then((plugins) => json(res, 200, { plugins }))
                 .catch((error) => {
-                captureSidecarError(error, "app-sidecar.plugins.list");
                 json(res, 500, { error: error instanceof Error ? error.message : String(error) });
             });
             return;
@@ -2645,7 +2891,6 @@ async function createSession(deps, opts) {
                     json(res, 200, { plugin, restartRequired: true });
                 }
                 catch (error) {
-                    captureSidecarError(error, "app-sidecar.plugins.install");
                     json(res, 400, { error: error instanceof Error ? error.message : String(error) });
                 }
             });
@@ -2656,7 +2901,6 @@ async function createSession(deps, opts) {
             void removePlugin(pluginId, paths.extensionsDir)
                 .then(() => json(res, 200, { removed: pluginId, restartRequired: true }))
                 .catch((error) => {
-                captureSidecarError(error, "app-sidecar.plugins.remove");
                 json(res, 400, { error: error instanceof Error ? error.message : String(error) });
             });
             return;
@@ -2741,7 +2985,6 @@ async function createSession(deps, opts) {
                     json(res, 200, { path: dir });
                 }
                 catch (err) {
-                    captureSidecarError(err, "app-sidecar.project.create");
                     json(res, 500, { error: err instanceof Error ? err.message : String(err) });
                 }
             });
@@ -2780,7 +3023,6 @@ async function createSession(deps, opts) {
                     json(res, 200, { hidden: Array.from(current) });
                 }
                 catch (err) {
-                    captureSidecarError(err, "app-sidecar.projects.hidden");
                     json(res, 500, { error: err instanceof Error ? err.message : String(err) });
                 }
             });
@@ -2796,7 +3038,6 @@ async function createSession(deps, opts) {
             }))
                 .then((projects) => json(res, 200, { projects }))
                 .catch((err) => {
-                captureSidecarError(err, "app-sidecar.projects.discover");
                 log("ERROR", "app-sidecar", "discoverProjects failed", {
                     message: err instanceof Error ? err.message : String(err),
                 });
@@ -2815,10 +3056,7 @@ async function createSession(deps, opts) {
             // agent or request the combined, recency-sorted "all" listing.
             void listSidecarSessions(target, requestedAgent, paths.sessionsDir)
                 .then((sessions) => json(res, 200, { sessions }))
-                .catch((error) => {
-                captureSidecarError(error, "app-sidecar.sessions.list");
-                json(res, 200, { sessions: [] });
-            });
+                .catch(() => json(res, 200, { sessions: [] }));
             return;
         }
         if (method === "GET" && url.startsWith("/files")) {
@@ -2826,7 +3064,6 @@ async function createSession(deps, opts) {
             void searchProjectFiles(cwd, q)
                 .then((files) => json(res, 200, { files }))
                 .catch((err) => {
-                captureSidecarError(err, "app-sidecar.files.search");
                 log("ERROR", "app-sidecar", "searchProjectFiles failed", {
                     message: err instanceof Error ? err.message : String(err),
                 });
@@ -3270,6 +3507,13 @@ async function createSession(deps, opts) {
                     json(res, 400, { error: "empty prompt" });
                     return;
                 }
+                // A typed prompt supersedes any question parked on the user: they
+                // answered with a message of their own. Release the blocked tool call
+                // NOW — otherwise it waits out its ten-minute timeout while this very
+                // message sits behind it as steering that only drains once the tool
+                // returns, so the turn looks frozen. The webview closes the band on
+                // send; a racing /ask POST just 409s.
+                asks.cancelAll({ action: "cancel", superseded: true });
                 if (runLifecycle.running &&
                     runLifecycle.isCancellationRequested(runLifecycle.generation)) {
                     json(res, 409, {
@@ -3359,7 +3603,7 @@ async function createSession(deps, opts) {
                 });
                 // After the user's run settles, kick off Nolan's auto-review loop — but
                 // only when the turn is actually reviewable (shouldStartAutopilotCycle):
-                // workflow commands (/compare, /bullet-proof, …) end with reports or
+                // workflow commands (/compare, /expand, …) end with reports or
                 // A/B/C choices reserved for the USER; registry commands (/help) and
                 // failed runs add no assistant work to judge; a turn that ended in plan
                 // mode has a pending Accept/Reject modal Nolan must not preempt. This is
@@ -3514,7 +3758,6 @@ async function createSession(deps, opts) {
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
-                    captureSidecarError(err, "app-sidecar.prompt-enhancer");
                     log("ERROR", "app-sidecar", "enhance failed", { message });
                     json(res, 500, { error: message });
                 }
@@ -3854,6 +4097,14 @@ async function createSession(deps, opts) {
                     json(res, 400, { error: "invalid JSON body" });
                     return;
                 }
+                // Same lock as POST /model, for the same reason: this retargets Nolan's
+                // chat session AND the autopilot reviewer, and `switchModel` on a
+                // session mid-turn races the stream it is already consuming. The
+                // footer picker is disabled to match; this is the enforcement.
+                if (running || nolanRunning || autopilotReviewing) {
+                    json(res, 409, { error: "cannot switch Nolan's model while running" });
+                    return;
+                }
                 if (modelId === null) {
                     // Clear the pin → follow EZ Coder again, syncing both sessions back.
                     nolanModelOverride = null;
@@ -3970,6 +4221,14 @@ async function createSession(deps, opts) {
             return;
         }
         if (method === "POST" && url === "/thinking") {
+            // The in-flight request already carries its reasoning config, so a
+            // mid-run cycle cannot affect the turn the user is watching — it just
+            // persists a level the footer then reports for a run that never used it.
+            // Locked like POST /model; the footer button is disabled to match.
+            if (running) {
+                json(res, 409, { error: "cannot change reasoning level while running" });
+                return;
+            }
             const st = session.getState();
             const next = getNextThinkingLevel(st.provider, st.model, session.getThinkingLevel());
             session.setThinkingLevel(next);
@@ -4027,7 +4286,6 @@ async function createSession(deps, opts) {
                     drained,
                 });
             })().catch((error) => {
-                captureSidecarError(error, "app-sidecar.run.cancel");
                 broadcast("cancel_failed", { error: "cancel_failed", runState: runLifecycle.state });
                 json(res, 500, {
                     error: "cancel_failed",
@@ -4055,7 +4313,6 @@ async function createSession(deps, opts) {
                 json(res, 200, { ok: true });
             })
                 .catch((err) => {
-                captureSidecarError(err, "app-sidecar.session.new");
                 json(res, 500, { error: err instanceof Error ? err.message : String(err) });
             });
             return;
@@ -4112,7 +4369,6 @@ async function createSession(deps, opts) {
                     json(res, 200, { ok: true, planTotal });
                 }
                 catch (err) {
-                    captureSidecarError(err, "app-sidecar.plan.accept");
                     json(res, 500, { error: err instanceof Error ? err.message : String(err) });
                 }
             });
@@ -4242,7 +4498,6 @@ async function createSession(deps, opts) {
                         broadcastAll("models_change", {});
                     }
                     catch (err) {
-                        captureSidecarError(err, "app-sidecar.auth.oauth", { provider });
                         // Deliberately session-scoped: this is the outcome of ONE window's
                         // attempt. Another window that never pressed Connect has nothing to
                         // show an error about, and its modal correctly still offers login.
@@ -4315,6 +4570,50 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // Answer (or dismiss) an `ask_user` question band. The turn is blocked on
+        // this, so both paths must land: "answer" carries the picked values,
+        // "cancel" releases the tool call with no answer.
+        if (method === "POST" && url.startsWith("/ask/")) {
+            const id = decodeURIComponent(url.slice("/ask/".length));
+            void readBody(req, res).then((raw) => {
+                if (raw === null)
+                    return;
+                let result;
+                try {
+                    const parsed = JSON.parse(raw);
+                    if (parsed.action !== "answer" && parsed.action !== "cancel") {
+                        json(res, 400, { error: "action must be answer or cancel" });
+                        return;
+                    }
+                    if (parsed.action === "cancel") {
+                        result = { action: "cancel" };
+                    }
+                    else {
+                        // Only strings and string arrays are answers; anything else is a
+                        // malformed client, not a value to hand the model.
+                        const answers = {};
+                        for (const [key, value] of Object.entries(parsed.answers ?? {})) {
+                            if (typeof value === "string")
+                                answers[key] = value;
+                            else if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
+                                answers[key] = value;
+                            }
+                        }
+                        result = { action: "answer", answers };
+                    }
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (!asks.settle(id, result)) {
+                    json(res, 409, { error: "no question is awaiting an answer" });
+                    return;
+                }
+                json(res, 200, { ok: true });
+            });
+            return;
+        }
         if (method === "POST" && url === "/auth/logout") {
             void readBody(req, res).then(async (raw) => {
                 if (raw === null)
@@ -4431,6 +4730,80 @@ async function createSession(deps, opts) {
             })();
             return;
         }
+        // ── Hugging Face search & pull (the "Add from Hugging Face" modal) ──
+        if (method === "GET" && url === "/hf/pull") {
+            json(res, 200, hfPull ? { active: hfPullPayload(hfPull) } : { active: null });
+            return;
+        }
+        if (method === "POST" && url === "/hf/search") {
+            void readBody(req, res).then(async (raw) => {
+                if (raw === null)
+                    return;
+                let body;
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                // Strip control characters and cap length — this goes into a URL query.
+                const query = String(body.query ?? "")
+                    // eslint-disable-next-line no-control-regex -- stripping control characters is the point
+                    .replace(/[\u0000-\u001f]/g, "")
+                    .trim()
+                    .slice(0, 100);
+                if (!query) {
+                    json(res, 400, { error: "Type something to search for." });
+                    return;
+                }
+                try {
+                    json(res, 200, { models: await hfSearch(query) });
+                }
+                catch (err) {
+                    broadcastError("error", "hugging face search failed", err);
+                    json(res, 502, {
+                        error: `Hugging Face search failed — ${err instanceof Error ? err.message : "network error"}.`,
+                    });
+                }
+            });
+            return;
+        }
+        if (method === "POST" && url === "/hf/pull") {
+            void readBody(req, res).then(async (raw) => {
+                if (raw === null)
+                    return;
+                let body;
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                const repo = String(body.repo ?? "").trim();
+                if (!isValidHfRepoId(repo)) {
+                    json(res, 400, { error: 'Expected a Hugging Face repo like "org/model".' });
+                    return;
+                }
+                try {
+                    json(res, 200, await startHfPull(repo));
+                }
+                catch (err) {
+                    const status = err instanceof Error && "status" in err && typeof err.status === "number"
+                        ? err.status
+                        : 502;
+                    if (status >= 500)
+                        broadcastError("error", "hugging face pull failed", err);
+                    json(res, status, { error: err instanceof Error ? err.message : "Pull failed." });
+                }
+            });
+            return;
+        }
+        if (method === "POST" && url === "/hf/pull/cancel") {
+            json(res, 200, { ok: cancelHfPull() });
+            return;
+        }
         // ── Telegram config (mirrors `ezcoder telegram`) ─────────
         if (method === "GET" && url === "/telegram") {
             void loadTelegramConfig().then((cfg) => {
@@ -4517,7 +4890,6 @@ async function createSession(deps, opts) {
                 }
                 catch (err) {
                     serveController = null;
-                    captureSidecarError(err, "app-sidecar.serve.start", { provider: st.provider });
                     json(res, 400, { error: err instanceof Error ? err.message : String(err) });
                 }
             })();
@@ -4535,16 +4907,32 @@ async function createSession(deps, opts) {
             })();
             return;
         }
+        // ── Agent Steroids (local code corpus) ───────────────────────────────
+        if (method === "GET" && url === "/steroids") {
+            void probeSteroids().then((status) => json(res, 200, status));
+            return;
+        }
+        if (method === "POST" && url === "/steroids/install") {
+            void installSteroids()
+                .then((status) => {
+                broadcast("steroids_change", status);
+                log("INFO", "app-sidecar", "steroids installed", { version: status.version });
+                json(res, 200, status);
+            })
+                .catch((err) => {
+                json(res, 400, { error: err instanceof Error ? err.message : String(err) });
+            });
+            return;
+        }
         // ── MCP server management (mirrors `ezcoder mcp`) ──────────────────
         // `targetCwd` (project scope) overrides the window cwd so a server can be
         // added/removed for ANY discovered project, not just this window's. Global
         // scope ignores it (always ~/.ezcoder/mcp.json).
         if (method === "GET" && (url === "/mcp" || url.startsWith("/mcp?"))) {
             const targetCwd = new URL(url, `http://${host}`).searchParams.get("cwd") ?? cwd;
-            void buildMcpRows(targetCwd)
+            void buildMcpRows(targetCwd, paths.settingsFile)
                 .then((servers) => json(res, 200, { servers }))
                 .catch((err) => {
-                captureSidecarError(err, "app-sidecar.mcp.list");
                 log("ERROR", "app-sidecar", "buildMcpRows failed", {
                     message: err instanceof Error ? err.message : String(err),
                 });
@@ -4593,6 +4981,12 @@ async function createSession(deps, opts) {
                         json(res, 400, { error: saved.error });
                         return;
                     }
+                    // Adding a project-scope server is an explicit trust signal — the
+                    // user chose to put a server in this repo's .ezcoder/mcp.json. Auto-trust
+                    // the project so all project-scope servers connect on next load.
+                    if (scope === "project") {
+                        await session.trustProject(targetCwd);
+                    }
                     json(res, 200, {
                         ok: true,
                         name: config.name,
@@ -4603,7 +4997,6 @@ async function createSession(deps, opts) {
                     });
                 }
                 catch (err) {
-                    captureSidecarError(err, "app-sidecar.mcp.add", { server: config.name });
                     json(res, 500, {
                         error: err instanceof Error ? err.message : String(err),
                     });
@@ -4697,7 +5090,6 @@ async function createSession(deps, opts) {
                     }
                 }
                 catch (err) {
-                    captureSidecarError(err, "app-sidecar.mcp.login", { server: name });
                     broadcast("mcp_auth_error", {
                         name,
                         message: err instanceof Error ? err.message : String(err),
@@ -4713,6 +5105,7 @@ async function createSession(deps, opts) {
     }
     async function dispose() {
         elicitations.cancelAll();
+        asks.cancelAll();
         tasksPollStopped = true;
         if (tasksPoll)
             clearTimeout(tasksPoll);
@@ -4749,8 +5142,6 @@ async function createSession(deps, opts) {
     };
 }
 main().catch(async (err) => {
-    captureSidecarError(err, "app-sidecar.main", { severity: "fatal" });
-    await flushSidecarErrors();
     const message = err instanceof Error ? err.message : String(err);
     process.stderr.write(`GG_APP_FATAL ${message}\n`);
     process.exit(1);