@prestyj/cli 5.9.0 → 5.11.0

package/dist/app-sidecar.js

@@ -21,8 +21,10 @@ import { parseArgs } from "node:util";
 import { environmentSecrets, formatError, redactValue } from "@prestyj/ai";
 import { runJsonMode } from "./modes/json-mode.js";
 import { runSubagentWorkerMode } from "./modes/subagent-worker-mode.js";
+import { setStreamDiagnostic } from "@prestyj/agent";
 import { AgentSession } from "./core/agent-session.js";
 import { RunLifecycle } from "./core/run-lifecycle.js";
+import { RunClaim } from "./core/run-claim.js";
 import { CHAT_AGENT_IDS, chatAgentSessionsDir, createChatAgent, parseChatAgentId, switchChatAgent, } from "./chat-agents/index.js";
 import { buildJiwaTools, JiwaStore } from "./chat-agents/jiwa.js";
 import { buildMemoryTools, MemoryStore } from "./chat-agents/memory.js";
@@ -32,11 +34,13 @@ import { parseAutopilotVerdict } from "./core/autopilot-verdict.js";
 import { isWorkflowCommandText, countAssistantMessages, shouldStartAutopilotCycle, extractTurnToolCalls, isMechanicalOnlyTurn, } from "./core/autopilot-gate.js";
 import { driveAutopilotCycle, frameAutopilotInjection } from "./core/autopilot-cycle.js";
 import { validateNolanModelPref, effectiveNolanModel, } from "./core/nolan-model.js";
-import { normalizeAutopilotMarkersForHistory, normalizeAppMarkersForHistory, normalizeNolanTurnsForHistory, restoreUserRow, restoreAssistantTexts, autopilotMarkerCopySeed, } from "./core/session-history.js";
+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 { cleanupToolOutputs } from "./tools/overflow.js";
 import { readCappedBody } from "./utils/http-body.js";
-import { fetchSubscriptionUsage, MOONSHOT_OAUTH_KEY, SubscriptionUsageError, XIAOMI_CREDITS_KEY, } from "@prestyj/core";
+import { fetchSubscriptionUsage, MOONSHOT_OAUTH_KEY, SubscriptionUsageError, XIAOMI_CREDITS_KEY, discoverLocalModels, findProbedModel, formatLocalModelId, parseLocalModelId, probeEndpoint, toModelInfo as localModelInfo, } from "@prestyj/core";
+import { LocalEndpointError, addCustomEndpoint, listAllEndpoints, removeCustomEndpoint, syncEndpointCredentials, } from "./core/local-endpoint-store.js";
 import { loginAnthropic } from "./core/oauth/anthropic.js";
 import { loginOpenAI } from "./core/oauth/openai.js";
 import { loginGemini } from "./core/oauth/gemini.js";
@@ -44,9 +48,11 @@ import { loginKimi } from "./core/oauth/kimi.js";
 import { AUTH_PROVIDERS } from "./core/auth-providers.js";
 import { ensureAppDirs, loadSavedSettings } from "./config.js";
 import { SettingsManager } from "./core/settings-manager.js";
-import { getModel, getDefaultThinkingLevel, getContextWindow, MODELS, } from "./core/model-registry.js";
+import { installPlugin, listInstalledPlugins, removePlugin, } from "./core/extensions/plugin-bundles.js";
+import { getModel, getDefaultThinkingLevel, getContextWindow, getAllModels, clearRuntimeModels, registerRuntimeModels, } from "./core/model-registry.js";
 import { resolveStartOrFallback } from "./core/resolve-start.js";
 import { getGitBranch, getGitDirtyFileCount, isGitRepo } from "./utils/git.js";
+import { getGitHubOpenCounts, getGitHubRepoSlug } from "./utils/github.js";
 import { extractPlanSteps } from "./utils/plan-steps.js";
 import { getNextThinkingLevel, getSupportedThinkingLevels, isThinkingLevelSupported, } from "./core/thinking-level.js";
 import { PROMPT_COMMANDS } from "./core/prompt-commands.js";
@@ -60,13 +66,18 @@ import { enrichProcessPath } from "./core/shell-path.js";
 import { downscaleForPreview, shrinkToFit, validateVisionImage } from "./utils/image.js";
 import { startServeMode } from "./modes/serve-mode.js";
 import { loadTelegramConfig, saveTelegramConfig, verifyBotToken } from "./core/telegram-config.js";
-import { loadServers, addServer, removeServer, getServer, parseMcpAddCommand, MCPClientManager, McpOAuthStore, } from "./core/mcp/index.js";
+import { loadServers, addServer, removeServer, getServer, parseMcpAddCommand, MCPClientManager, McpOAuthStore, createElicitationBridge, } from "./core/mcp/index.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",
+    visibility: "hidden",
+};
 const ALL_PROVIDERS = [
     // US
     "anthropic",
@@ -83,6 +94,12 @@ const ALL_PROVIDERS = [
     "sakana",
     "openrouter",
 ];
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = value.filter((v) => typeof v === "string" && v.trim().length > 0);
+    return out.length > 0 ? out : undefined;
+}
 function appSettingsFile() {
     return path.join(os.homedir(), ".ezcoder", "ezcoder-app.json");
 }
@@ -106,6 +123,8 @@ async function loadAppSettings() {
             projectModels: raw.projectModels && typeof raw.projectModels === "object" ? raw.projectModels : undefined,
             autopilot: raw.autopilot && typeof raw.autopilot === "object" ? raw.autopilot : undefined,
             nolanModels: raw.nolanModels && typeof raw.nolanModels === "object" ? raw.nolanModels : undefined,
+            projectRoots: stringArray(raw.projectRoots),
+            hiddenProjects: stringArray(raw.hiddenProjects),
         };
     }
     catch {
@@ -344,6 +363,11 @@ async function searchProjectFiles(cwd, rawQuery) {
  * hook prompt, by its distinctive opening phrase. Returns the hook kind so the
  * webview can render the short notice line instead of the full prompt body.
  */
+/** `?tools=` on /export. Anything unrecognised (including absent) falls back to
+ *  the human-facing `summary` default rather than dumping every payload. */
+function parseToolDetail(value) {
+    return value === "none" || value === "full" ? value : "summary";
+}
 function detectHookKind(text) {
     const t = text.trimStart();
     if (t.startsWith("Ideal? Review the actual work"))
@@ -354,30 +378,6 @@ function detectHookKind(text) {
         return "regrounding";
     return null;
 }
-// Separator AgentSession.prompt() inserts between a command's prompt body and
-// the user's trailing args. Must stay in sync with the expansion there.
-const COMMAND_ARGS_SEP = "\n\n## User Instructions\n\n";
-/**
- * Reverse a prompt-template command's expansion. When a `/name` command runs,
- * the agent persists the FULL expanded prompt body as the user message — so on
- * resume the raw body would render instead of the short `/name` chip the user
- * saw live. Given the candidate commands (built-in + custom) and a restored
- * message body, recover the original `/name [args]` invocation. Returns null
- * when the text isn't a known command body (an ordinary user message).
- */
-function detectPromptCommand(text, candidates) {
-    for (const c of candidates) {
-        if (!c.prompt)
-            continue;
-        if (text === c.prompt)
-            return `/${c.name}`;
-        if (text.startsWith(c.prompt + COMMAND_ARGS_SEP)) {
-            const args = text.slice(c.prompt.length + COMMAND_ARGS_SEP.length).trim();
-            return args ? `/${c.name} ${args}` : `/${c.name}`;
-        }
-    }
-    return null;
-}
 /** A short transport summary for display (URL for http/sse, command+args for stdio). */
 function mcpRowSummary(config) {
     if (config.url)
@@ -451,6 +451,7 @@ async function runJsonModeIfRequested() {
             "max-turns": { type: "string" },
             "system-prompt": { type: "string" },
             tools: { type: "string" },
+            "mcp-servers": { type: "string" },
             "prompt-cache-key": { type: "string" },
         },
         allowPositionals: true,
@@ -467,14 +468,24 @@ async function runJsonModeIfRequested() {
             .filter(Boolean)
         : [];
     const allowedTools = parsedTools.length > 0 ? parsedTools : undefined;
+    // MCP servers the agent definition asked for. Without forwarding these, an
+    // allow-listed child connects no MCP at all and loses live code search.
+    const parsedMcpServers = values["mcp-servers"]
+        ? values["mcp-servers"]
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : [];
+    const allowedMcpServers = parsedMcpServers.length > 0 ? parsedMcpServers : undefined;
     await runJsonMode({
         message: positionals[0] ?? "",
         provider: (values.provider ?? "anthropic"),
-        model: values.model ?? "claude-opus-4-8",
+        model: values.model ?? "claude-opus-5",
         cwd: process.cwd(),
         systemPrompt: values["system-prompt"],
         maxTurns: maxTurnsRaw ? parseInt(maxTurnsRaw, 10) : undefined,
         allowedTools,
+        allowedMcpServers,
         promptCacheKey: values["prompt-cache-key"],
     }).catch(async (err) => {
         captureSidecarError(err, "app-sidecar.json-mode", {
@@ -518,6 +529,31 @@ async function main() {
     // ~/.ezcoder/debug.log (initLogger truncates on each start).
     const sidecarLog = path.join(paths.agentDir, "ezcoder-app-sidecar.log");
     initLogger(sidecarLog);
+    // The desktop sidecar previously omitted the stream diagnostic hook used by
+    // the CLI, leaving device-specific provider stalls impossible to distinguish from
+    // event-loop starvation or a broken streaming network path. Keep routine
+    // phases lightweight; timeout phases include non-sensitive runtime context.
+    setStreamDiagnostic((phase, data) => {
+        const includeRuntime = phase === "idle_timeout_fired" ||
+            phase === "hard_timeout_fired" ||
+            phase === "stall_exhausted";
+        log("INFO", "stream", phase, {
+            ...(data ?? {}),
+            ...(includeRuntime
+                ? {
+                    platform: process.platform,
+                    arch: process.arch,
+                    osRelease: os.release(),
+                    node: process.version,
+                    logicalCpus: os.cpus().length,
+                    totalMemoryMb: Math.round(os.totalmem() / 1024 / 1024),
+                    freeMemoryMb: Math.round(os.freemem() / 1024 / 1024),
+                    rssMb: Math.round(process.memoryUsage().rss / 1024 / 1024),
+                    processUptimeSec: Math.round(process.uptime()),
+                }
+                : {}),
+        });
+    });
     // Global last-resort guards, installed as early as the logger allows so they
     // cover the WHOLE lifecycle — including startup/initialize, the phase the
     // "sidecar did not start in time" bug lives in. The sidecar is a long-lived
@@ -553,6 +589,20 @@ async function main() {
     // request to its window's session via the `x-gg-session` header (and the
     // `?session=` query for the SSE /events stream).
     const sessions = new Map();
+    /**
+     * Fan one frame out to every window.
+     *
+     * For state that is genuinely global rather than per-session — `~/.ezcoder/auth.json`
+     * is shared by all windows, so connecting a provider in one must refresh the
+     * model picker in all of them. Mirrors the memory/jiwa/progress fan-outs.
+     */
+    const broadcastAll = (type, data) => {
+        for (const ctx of sessions.values())
+            ctx.broadcast(type, data);
+    };
+    // Providers currently mid-OAuth in some window. Daemon-level so two windows
+    // cannot race two browser flows for the same provider into one auth file.
+    const oauthInFlightProviders = new Set();
     const memoryStore = new MemoryStore({
         onChange: ({ memories }) => {
             for (const ctx of sessions.values()) {
@@ -576,6 +626,13 @@ async function main() {
     });
     const usageCache = new Map();
     const usageRequests = new Map();
+    // Last snapshot that actually carried windows, per provider. Replayed while a
+    // fetch is failing so the title meter never blinks out of existence. Bounded
+    // by USAGE_LAST_GOOD_MAX_AGE_MS — a provider that never recovers must stop
+    // reporting rather than freeze a percentage (and a long-past reset time) on
+    // screen forever. The 429 backoff alone runs to 24h, far past any usefulness.
+    const usageLastGood = new Map();
+    const USAGE_LAST_GOOD_MAX_AGE_MS = 30 * 60_000;
     // 429 backoff: quota endpoints are auxiliary UI data. Honor Retry-After when
     // provided; otherwise retain the unavailable snapshot for 30 minutes. Clamp
     // the provider value so a malformed header can neither hammer the endpoint
@@ -590,6 +647,9 @@ async function main() {
         // Moonshot platform API key is metered per-token, not per plan window.
         const authKey = provider === "moonshot" ? MOONSHOT_OAUTH_KEY : provider;
         if (!(await auth.hasProviderAuth(authKey))) {
+            // Logged out: drop the replay cache so a later login on a DIFFERENT
+            // account can never inherit the previous one's numbers.
+            usageLastGood.delete(provider);
             return { provider, displayName, connected: false, windows: [], fetchedAt: Date.now() };
         }
         try {
@@ -633,6 +693,18 @@ async function main() {
                 ...(backoffMs !== undefined && { backoffMs: String(backoffMs) }),
             });
             const connected = await auth.hasProviderAuth(authKey);
+            // Transient failures (notably the 429s these auxiliary quota endpoints
+            // hand out) must not blank the meter. Keep serving the last good
+            // snapshot, flagged `stale`, so the bar stays put instead of flickering
+            // out for the whole backoff window and back in on the next success.
+            // Past the max age it's dropped — no data beats confidently wrong data.
+            const lastGood = usageLastGood.get(provider);
+            if (lastGood && Date.now() - lastGood.fetchedAt >= USAGE_LAST_GOOD_MAX_AGE_MS) {
+                usageLastGood.delete(provider);
+            }
+            else if (connected && lastGood) {
+                return { ...lastGood, stale: true };
+            }
             return {
                 provider,
                 displayName,
@@ -654,6 +726,11 @@ async function main() {
         usageRequests.set(provider, request);
         try {
             const result = await request;
+            // Never re-store a replay — it would keep its original `fetchedAt`, but
+            // writing it back muddies the "last GOOD" contract for no gain.
+            if (result.connected && !result.error && !result.stale && result.windows.length > 0) {
+                usageLastGood.set(provider, result);
+            }
             // Anthropic can return utilization before it assigns reset timestamps
             // (notably before the account's first active request). Retry that partial
             // snapshot quickly; complete snapshots keep the normal one-minute cache.
@@ -721,7 +798,15 @@ async function main() {
                 const sessionPath = typeof body.sessionPath === "string" && body.sessionPath ? body.sessionPath : undefined;
                 const id = randomUUID();
                 try {
-                    const ctx = await createSession({ auth, paths, progress, memoryStore, jiwaStore }, { id, mode, chatAgent, cwd: sessionCwd, sessionPath });
+                    const ctx = await createSession({
+                        auth,
+                        paths,
+                        progress,
+                        memoryStore,
+                        jiwaStore,
+                        broadcastAll,
+                        oauthInFlightProviders,
+                    }, { id, mode, chatAgent, cwd: sessionCwd, sessionPath });
                     sessions.set(id, ctx);
                     log("INFO", "app-sidecar", "session created", {
                         id,
@@ -997,7 +1082,7 @@ async function createProgressManager(agentDir, broadcastAll) {
  * logger, PATH, shared auth file, and radio live at the daemon level.
  */
 async function createSession(deps, opts) {
-    const { auth, progress, memoryStore, jiwaStore } = deps;
+    const { auth, progress, memoryStore, jiwaStore, broadcastAll, oauthInFlightProviders } = deps;
     const paths = deps.paths;
     const mode = opts.mode;
     let chatAgent = opts.chatAgent;
@@ -1072,6 +1157,25 @@ async function createSession(deps, opts) {
             // /help
             .replaceAll(/see \/help/gi, "check the help menu"));
     }
+    /**
+     * Guidance for a connection failure against the ACTIVE local endpoint, or
+     * undefined when that isn't the situation (so the generic wording stands).
+     * "Disable your VPN / allow us through the firewall" is useless advice for a
+     * server running on this machine — name what the user has to restart.
+     */
+    function localNetworkGuidance(source) {
+        if (source !== "network")
+            return undefined;
+        const state = session.getState();
+        if (state.provider !== "local")
+            return undefined;
+        const parsed = parseLocalModelId(state.model);
+        const probe = localProbes.find((p) => p.endpoint.id === parsed?.endpointId);
+        if (!probe)
+            return undefined;
+        return (`${probe.endpoint.label} stopped responding at ${probe.endpoint.baseUrl}. ` +
+            "Start it again and retry, or pick another model.");
+    }
     // Turn any thrown value into the same clear headline/message/guidance shape
     // the TUI shows (see gg-ai's formatError) instead of a bare `err.message`, log
     // the full detail, and broadcast it under `type` ("error" or "nolan_error").
@@ -1081,7 +1185,7 @@ async function createSession(deps, opts) {
     function broadcastError(type, logLabel, err) {
         const f = formatError(err);
         const message = f.message ? desktopGuidance(f.message) : undefined;
-        const guidance = desktopGuidance(f.guidance);
+        const guidance = localNetworkGuidance(f.source) ?? desktopGuidance(f.guidance);
         captureSidecarError(err, `app-sidecar.${logLabel.replaceAll(" ", "-")}`, {
             scope: type,
             ...(f.provider ? { provider: f.provider } : {}),
@@ -1114,6 +1218,17 @@ async function createSession(deps, opts) {
         })
             .catch(() => { });
     }
+    // ── MCP elicitation bridge ─────────────────────────────────
+    // An MCP server can ask for user input in the middle of a tool call. The
+    // bridge parks the promise; we broadcast the prompt over SSE and resolve it
+    // when the webview POSTs /mcp/elicit/:id.
+    const elicitations = createElicitationBridge({
+        broadcast: (prompt) => broadcast("mcp_elicit", prompt),
+        onTimeout: (prompt) => log("WARN", "app-sidecar", "MCP elicitation timed out", {
+            id: prompt.id,
+            server: prompt.server,
+        }),
+    });
     // The session file path to resume (passed by the daemon's POST /session);
     // empty/unset starts a fresh session.
     const resumeSessionPath = opts.sessionPath;
@@ -1127,6 +1242,7 @@ async function createSession(deps, opts) {
         signal: abort.signal,
         // Keep MCP startup off the readiness path in both modes.
         backgroundMcpConnect: true,
+        onMcpElicit: elicitations.onElicit,
         // Keep restore-time auto-compaction off the readiness path too: its summary
         // LLM call (30s timeout) used to freeze waitForReady — and with it the whole
         // window (project picker, session list) — whenever a resumed session was
@@ -1197,17 +1313,116 @@ 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
+    // background (same shape as backgroundMcpConnect) and pushes a models_change
+    // frame when it lands.
+    let localProbes = [];
+    async function scanLocalModels(force) {
+        const endpoints = await listAllEndpoints();
+        const { probes, models } = await discoverLocalModels(endpoints, { force });
+        localProbes = probes;
+        // Only endpoints that answered get a credential: writing one for a server
+        // that isn't running would make `hasProviderAuth("local")` true forever.
+        await syncEndpointCredentials(probes.filter((probe) => probe.reachable).map((probe) => probe.endpoint));
+        clearRuntimeModels((m) => m.provider === "local");
+        registerRuntimeModels(models);
+        log("INFO", "app-sidecar", "local model scan", {
+            reachable: probes.filter((p) => p.reachable).length + "/" + probes.length,
+            models: String(models.length),
+        });
+        return probes;
+    }
+    /** Endpoint rows + models, in the shape the Local models UI renders. */
+    function localStatePayload() {
+        return {
+            endpoints: localProbes.map((probe) => ({
+                id: probe.endpoint.id,
+                label: probe.endpoint.label,
+                baseUrl: probe.endpoint.baseUrl,
+                kind: probe.endpoint.kind,
+                custom: probe.endpoint.custom === true,
+                reachable: probe.reachable,
+                ...(probe.reason ? { reason: probe.reason } : {}),
+                models: probe.models.map((m) => ({
+                    id: formatLocalModelId(probe.endpoint.id, m.rawId),
+                    rawId: m.rawId,
+                    contextWindow: m.contextWindow,
+                    contextWindowKnown: m.contextWindowKnown,
+                    supportsTools: m.supportsTools,
+                    supportsImages: m.supportsImages,
+                    supportsThinking: m.supportsThinking,
+                    ...(m.loaded === undefined ? {} : { loaded: m.loaded }),
+                })),
+            })),
+        };
+    }
+    /**
+     * 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:
+     * a model with no tool calling (can't drive the agent at all), and a server
+     * that has since been shut down.
+     */
+    async function localModelBlocker(modelId) {
+        const parsed = parseLocalModelId(modelId);
+        if (!parsed)
+            return undefined;
+        const endpoints = await listAllEndpoints();
+        const endpoint = endpoints.find((e) => e.id === parsed.endpointId);
+        if (!endpoint)
+            return `Unknown local endpoint "${parsed.endpointId}" — re-scan for local models.`;
+        const probe = await probeEndpoint(endpoint);
+        // Keep the cached view honest: this probe is fresher than the last scan.
+        localProbes = localProbes.map((p) => (p.endpoint.id === endpoint.id ? probe : p));
+        if (!probe.reachable) {
+            return `${endpoint.label} isn't running at ${endpoint.baseUrl}. Start it and scan again.`;
+        }
+        const model = probe.models.find((m) => m.rawId === parsed.rawId);
+        if (!model) {
+            return `${endpoint.label} no longer serves "${parsed.rawId}".`;
+        }
+        if (!model.supportsTools) {
+            return `${parsed.rawId} has no tool calling, so it can't run the agent. Pick a tool-capable model.`;
+        }
+        registerRuntimeModels(probe.models.map((m) => localModelInfo(m, endpoint)));
+        return undefined;
+    }
+    /**
+     * A restored per-project pref can ask for thinking on a local model that
+     * turns out not to reason (capabilities are only known after a probe). Drop
+     * the level once we know, so the first prompt doesn't carry a
+     * `reasoning_effort` the server rejects.
+     */
+    function clampLocalThinking() {
+        const st = session.getState();
+        const level = session.getThinkingLevel();
+        if (!level || st.provider !== "local")
+            return;
+        if (isThinkingLevelSupported(st.provider, st.model, level))
+            return;
+        session.setThinkingLevel(undefined);
+        broadcast("thinking_change", {
+            thinkingLevel: null,
+            supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
+        });
+    }
     // Workspace extras (context window, git status, background tasks). Git state
     // is resolved once at startup and refreshed after every run; the context
     // window follows the active model.
-    const [initialGitBranch, initialGitIsRepo, initialDirtyFileCount] = await Promise.all([
+    const [initialGitBranch, initialGitIsRepo, initialDirtyFileCount, initialGitHubSlug] = await Promise.all([
         getGitBranch(cwd).catch(() => null),
         isGitRepo(cwd).catch(() => false),
         getGitDirtyFileCount(cwd).catch(() => 0),
+        getGitHubRepoSlug(cwd).catch(() => null),
     ]);
     let gitBranch = initialGitBranch;
     let gitIsRepo = initialGitIsRepo;
     let gitDirtyFileCount = initialDirtyFileCount;
+    // Open issue/PR counts for the origin repo's GitHub slug, via the `gh` CLI's
+    // auth. null = unknown (gh missing/unauthed, non-GitHub origin) → chips hidden.
+    const gitHubSlug = initialGitHubSlug;
+    let gitHubIssues = null;
+    let gitHubPRs = null;
     function currentContextWindow() {
         const st = session.getState();
         return getContextWindow(st.model, { provider: st.provider, accountId: st.accountId });
@@ -1220,9 +1435,41 @@ async function createSession(deps, opts) {
             gitBranch,
             isGitRepo: gitIsRepo,
             gitDirtyFileCount,
+            gitHubIssues,
+            gitHubPRs,
+            gitHubRepoUrl: gitHubSlug ? `https://github.com/${gitHubSlug}` : null,
             tasks: session.listBackgroundProcesses(),
+            // Roots added with /add-dir — the header shows a badge when non-empty.
+            additionalRoots: session.getAdditionalRoots(),
         };
     }
+    void scanLocalModels(false)
+        .then(() => {
+        clampLocalThinking();
+        broadcast("extras", footerExtras());
+    })
+        .then(() => broadcast("models_change", { local: localStatePayload() }))
+        .catch((err) => {
+        // A discovery failure is never fatal — the user simply has no local
+        // models. Log it; don't push an error row into the transcript.
+        log("WARN", "app-sidecar", "local model scan failed", {
+            error: err instanceof Error ? err.message : String(err),
+        });
+    });
+    // Refresh the GitHub counts and broadcast only on change. Transient failures
+    // keep the last-known numbers so the chips don't flicker off on a timeout.
+    async function refreshGitHubCounts() {
+        if (!gitHubSlug)
+            return;
+        const counts = await getGitHubOpenCounts(gitHubSlug);
+        if (!counts)
+            return;
+        if (counts.issues !== gitHubIssues || counts.prs !== gitHubPRs) {
+            gitHubIssues = counts.issues;
+            gitHubPRs = counts.prs;
+            broadcast("extras", footerExtras());
+        }
+    }
     // tool_call_end carries no tool name (only the id), so remember each call's
     // name from tool_call_start to log a useful line on completion. Mirrors the
     // CLI's logging so the app sidecar's ~/.ezcoder/ezcoder-app-sidecar.log records tool
@@ -1318,6 +1565,10 @@ async function createSession(deps, opts) {
         recordApprovedPlanMarkers(d.text);
     });
     session.eventBus.on("thinking_delta", (d) => broadcast("thinking_delta", d));
+    // The agent consumed queued steering at a turn boundary. Re-broadcast as the
+    // usual `queued` depth update so the webview drops the pending affordance the
+    // moment the message lands in the loop, not at run_end.
+    session.eventBus.on("queue_drained", (d) => broadcast("queued", { count: d.count, messages: session.listQueuedMessages() }));
     session.eventBus.on("tool_call_start", (d) => {
         toolCallNames.set(d.toolCallId, d.name);
         broadcast("tool_call_start", d);
@@ -1369,10 +1620,29 @@ async function createSession(deps, opts) {
     session.eventBus.on("compaction_start", (d) => broadcast("compaction_start", d));
     session.eventBus.on("compaction_end", (d) => broadcast("compaction_end", d));
     let running = false;
+    // Closes the window between `/prompt` deciding to start a run and `runAgent`
+    // flipping `running` — that stretch awaits, so Node yields inside it. See
+    // RunClaim.
+    const runClaim = new RunClaim();
     const runLifecycle = new RunLifecycle((runState) => {
         running = runState !== "idle";
         if (runState === "cancelling")
             broadcast("run_cancelling", { runState });
+    }, 
+    // Durable run journal. Fire-and-forget on purpose: an unwritten journal
+    // entry is a missed crash hint, while a journal write that throws inside
+    // begin()/settle() would break run ownership itself.
+    {
+        started: (generation) => void session.persistRunStarted(generation).catch((err) => {
+            log("WARN", "app-sidecar", "failed to journal run start", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }),
+        finished: (generation, outcome) => void session.persistRunFinished(generation, outcome).catch((err) => {
+            log("WARN", "app-sidecar", "failed to journal run finish", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }),
     });
     const cancelledRunEndGenerations = new Set();
     let pendingCancelDrain = null;
@@ -1448,7 +1718,7 @@ async function createSession(deps, opts) {
     // with `@Nolan …`; he reads EZ Coder's transcript (one-way — EZ Coder never sees
     // Nolan's) and hands back runnable prompts + mentorship. Created lazily on the
     // first `@Nolan` so windows that never use Nolan pay zero cost. His events ride the
-    // SAME SSE stream with `ken_`-prefixed types, routed to the Nolan bubble.
+    // SAME SSE stream with `nolan_`-prefixed types, routed to the Nolan bubble.
     let nolanSession = null;
     let nolanAbort = new AbortController();
     let nolanRunning = false;
@@ -1478,7 +1748,7 @@ async function createSession(deps, opts) {
         return { provider: st.provider, model: st.model };
     }
     /** Footer payload: Nolan's effective model + whether it's a pin. Merged into
-     *  /state, the SSE ready frame, and every ken_model_change broadcast. */
+     *  /state, the SSE ready frame, and every nolan_model_change broadcast. */
     function nolanStatePayload() {
         const st = session.getState();
         return effectiveNolanModel(nolanModelOverride, { provider: st.provider, model: st.model });
@@ -1494,13 +1764,13 @@ async function createSession(deps, opts) {
         if (st.provider === provider && st.model === model)
             return;
         await nolanSession.switchModel(provider, model);
-        log("INFO", "app-sidecar", "ken session model synced", { provider, model });
+        log("INFO", "app-sidecar", "nolan session model synced", { provider, model });
     }
     async function ensureNolanSession() {
         if (nolanSession)
             return nolanSession;
         const target = nolanCurrentModel();
-        const ken = new AgentSession({
+        const nolanAgent = new AgentSession({
             provider: target.provider,
             model: target.model,
             cwd,
@@ -1509,38 +1779,41 @@ async function createSession(deps, opts) {
             allowedMcpServers: NOLAN_ALLOWED_MCP_SERVERS,
             transient: true,
             signal: nolanAbort.signal,
-            // Nolan's bursty, spread-out turns (chat) outlast the default 5-min cache
+            // Nolan belongs to this window, so route MCP elicitation prompts there.
+            // Keeping daemon sessions interactive also lets them share one pooled MCP connection.
+            onMcpElicit: elicitations.onElicit,
+            // Nolan's bursty, spread-out turns outlast the default cache
             // TTL regardless of the user's global speedProfile pick.
             forceLongCacheRetention: true,
         });
-        await ken.initialize();
-        // Bridge Nolan's bus to the shared SSE fan-out with ken_-prefixed types so the
+        await nolanAgent.initialize();
+        // Bridge Nolan's bus to the shared SSE fan-out with nolan_-prefixed types so the
         // webview routes them to the Nolan bubble, never EZ Coder's.
-        ken.eventBus.on("text_delta", (d) => broadcast("nolan_text_delta", d));
-        ken.eventBus.on("thinking_delta", (d) => broadcast("nolan_thinking_delta", d));
-        ken.eventBus.on("tool_call_start", (d) => {
+        nolanAgent.eventBus.on("text_delta", (d) => broadcast("nolan_text_delta", d));
+        nolanAgent.eventBus.on("thinking_delta", (d) => broadcast("nolan_thinking_delta", d));
+        nolanAgent.eventBus.on("tool_call_start", (d) => {
             nolanToolCallNames.set(d.toolCallId, d.name);
             broadcast("nolan_tool_call_start", d);
         });
-        ken.eventBus.on("tool_call_update", (d) => broadcast("nolan_tool_call_update", d));
-        ken.eventBus.on("tool_call_end", (d) => {
+        nolanAgent.eventBus.on("tool_call_update", (d) => broadcast("nolan_tool_call_update", d));
+        nolanAgent.eventBus.on("tool_call_end", (d) => {
             nolanToolCallNames.delete(d.toolCallId);
             broadcast("nolan_tool_call_end", d);
         });
         // Native server tools (Anthropic web_search) stream text both before AND
         // after them in the same turn; forward so the webview can break the bubble
         // (otherwise "...work.Local tools..." glues together). Mirrors the build bus.
-        ken.eventBus.on("server_tool_call", (d) => broadcast("nolan_server_tool_call", d));
-        ken.eventBus.on("turn_end", (d) => broadcast("nolan_turn_end", d));
-        ken.eventBus.on("error", (d) => {
-            broadcastError("nolan_error", "ken error", d.error);
+        nolanAgent.eventBus.on("server_tool_call", (d) => broadcast("nolan_server_tool_call", d));
+        nolanAgent.eventBus.on("turn_end", (d) => broadcast("nolan_turn_end", d));
+        nolanAgent.eventBus.on("error", (d) => {
+            broadcastError("nolan_error", "nolan error", d.error);
         });
-        nolanSession = ken;
-        log("INFO", "app-sidecar", "ken session ready", {
+        nolanSession = nolanAgent;
+        log("INFO", "app-sidecar", "nolan session ready", {
             provider: target.provider,
             model: target.model,
         });
-        return ken;
+        return nolanAgent;
     }
     // ── Autopilot Nolan (auto-reviewer) ──────────────────────────
     // A THIRD read-only AgentSession, separate from chat Nolan. In autopilot mode
@@ -1563,13 +1836,13 @@ async function createSession(deps, opts) {
         if (st.provider === provider && st.model === model)
             return;
         await nolanAutoSession.switchModel(provider, model);
-        log("INFO", "app-sidecar", "ken autopilot session model synced", { provider, model });
+        log("INFO", "app-sidecar", "nolan autopilot session model synced", { provider, model });
     }
     async function ensureNolanAutoSession() {
         if (nolanAutoSession)
             return nolanAutoSession;
         const target = nolanCurrentModel();
-        const ken = new AgentSession({
+        const nolanAgent = new AgentSession({
             provider: target.provider,
             model: target.model,
             cwd,
@@ -1578,26 +1851,32 @@ async function createSession(deps, opts) {
             allowedMcpServers: NOLAN_ALLOWED_MCP_SERVERS,
             transient: true,
             signal: nolanAutoAbort.signal,
+            // Route this window's MCP elicitation prompts through the shared bridge.
+            onMcpElicit: elicitations.onElicit,
             // Autopilot review rounds routinely span the injected EZ Coder run
             // (often >5 min) regardless of the user's global speedProfile pick.
             forceLongCacheRetention: true,
         });
         // Nolan is already the independent autopilot reviewer; recursively running
         // his own Ideal self-review adds latency and can corrupt the verdict shape.
-        ken.setIdealReviewSuppressed(true);
-        await ken.initialize();
+        nolanAgent.setIdealReviewSuppressed(true);
+        await nolanAgent.initialize();
         // Deliberately no bus bridge: the review is silent. Errors surface via the
         // runAutopilotReview try/catch as autopilot_error frames.
-        nolanAutoSession = ken;
-        log("INFO", "app-sidecar", "ken autopilot session ready", {
+        nolanAutoSession = nolanAgent;
+        log("INFO", "app-sidecar", "nolan autopilot session ready", {
             provider: target.provider,
             model: target.model,
         });
-        return ken;
+        return nolanAgent;
     }
     function abortOwnedWork() {
         cancelGeneration++;
         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.
+        elicitations.cancelAll();
         // Stop a run-all sweep and every async child through AgentSession's signal.
         taskRunAll = false;
         autopilotCancelled = true;
@@ -1609,9 +1888,9 @@ async function createSession(deps, opts) {
         nolanAutoAbort = new AbortController();
         nolanAutoSession?.setSignal(nolanAutoAbort.signal);
     }
-    function finishOwnedGeneration(generation, emitCancelledFallback) {
+    function finishOwnedGeneration(generation, emitCancelledFallback, outcome = "completed") {
         const cancelled = runLifecycle.isCancellationRequested(generation);
-        const settlement = runLifecycle.settle(generation);
+        const settlement = runLifecycle.settle(generation, outcome);
         if (!settlement.settled)
             return cancelled;
         // A replacement signal is safe only after the provider-backed owner settled.
@@ -1664,6 +1943,9 @@ async function createSession(deps, opts) {
                 isGitRepo(cwd).catch(() => gitIsRepo),
                 getGitDirtyFileCount(cwd).catch(() => gitDirtyFileCount),
             ]);
+            // A run may have opened/closed issues or PRs — refresh fire-and-forget so
+            // teardown isn't delayed by the network. Broadcasts itself on change.
+            void refreshGitHubCounts();
             // Serialize behind any marker/tool-triggered refresh so the terminal
             // progress snapshot uses the live plan file. Once every canonical step
             // is complete, remove the approved plan from future system prompts and
@@ -1686,8 +1968,9 @@ async function createSession(deps, opts) {
                     });
                 }
             }
-            if (ownsGeneration)
-                finishOwnedGeneration(generation, false);
+            if (ownsGeneration) {
+                finishOwnedGeneration(generation, false, runSucceeded ? "completed" : "failed");
+            }
             // A cancelled injected run is still owned by the surrounding autopilot
             // cycle; its outer finalizer emits the one terminal cancelled run_end.
             if (!(cancelled && !ownsGeneration)) {
@@ -1706,7 +1989,10 @@ async function createSession(deps, opts) {
             // completed ones so they drop out of the Tasks modal automatically (users
             // never have to delete finished tasks by hand).
             broadcast("tasks_list", { tasks: pruneDoneTasksSync(cwd) });
-            broadcast("queued", { count: session.getQueuedCount() });
+            broadcast("queued", {
+                count: session.getQueuedCount(),
+                messages: session.listQueuedMessages(),
+            });
             broadcast("extras", footerExtras());
         }
     }
@@ -1720,7 +2006,7 @@ async function createSession(deps, opts) {
         autopilotReviewing = true;
         broadcast("autopilot_review_start", {});
         try {
-            const ken = await ensureNolanAutoSession();
+            const nolanAgent = await ensureNolanAutoSession();
             const digest = buildNolanAutopilotContext({
                 cwd,
                 gitBranch,
@@ -1729,8 +2015,8 @@ async function createSession(deps, opts) {
                 injectedPrompts: [...injectedAutopilotPrompts],
                 workflowCommands: await loadWorkflowCommandSpecs(),
             });
-            await ken.prompt(digest);
-            return parseAutopilotVerdict(lastAssistantText(ken.getMessages()));
+            await nolanAgent.prompt(digest);
+            return parseAutopilotVerdict(lastAssistantText(nolanAgent.getMessages()));
         }
         catch (err) {
             if (!autopilotCancelled)
@@ -1760,7 +2046,7 @@ async function createSession(deps, opts) {
         autopilotReviewing = true;
         broadcast("autopilot_review_start", {});
         try {
-            const ken = await ensureNolanAutoSession();
+            const nolanAgent = await ensureNolanAutoSession();
             // Re-read the plan file (the run may have revised it in place); fall
             // back to the content captured at exit_plan time.
             const planContent = await fs.readFile(planPath, "utf-8").catch(() => pendingPlanContent);
@@ -1773,10 +2059,10 @@ async function createSession(deps, opts) {
                 workflowCommands: await loadWorkflowCommandSpecs(),
                 planContent,
             });
-            await ken.prompt(digest);
+            await nolanAgent.prompt(digest);
             if (autopilotCancelled || planGeneration !== genAtStart)
                 return null;
-            return parseAutopilotVerdict(lastAssistantText(ken.getMessages()));
+            return parseAutopilotVerdict(lastAssistantText(nolanAgent.getMessages()));
         }
         catch (err) {
             // User action mid-review (manual Accept aborts the nolanAuto run): drop
@@ -1802,7 +2088,7 @@ async function createSession(deps, opts) {
     const IMPLEMENT_PLAN_PROMPT = "The plan has been approved. Implement it now, following each step in order.";
     // Drive the review→prompt→review loop for one finished user turn. Only ever
     // called after shouldStartAutopilotCycle approves the turn (POST /prompt or
-    // the stranded-queue drain) — never from the task runner, resume, /ken, or
+    // the stranded-queue drain) — never from the task runner, resume, /nolan, or
     // error paths, so there's no recursion and no guard tangle. The loop's
     // control flow lives in driveAutopilotCycle (core/autopilot-cycle.ts) so
     // every exit path is unit-tested; this only wires the real dependencies.
@@ -1866,7 +2152,7 @@ async function createSession(deps, opts) {
                     // label stays the clean prompt.
                     const framed = frameAutopilotInjection(IMPLEMENT_PLAN_PROMPT);
                     injectedAutopilotPrompts.push(framed);
-                    return runAgent(IMPLEMENT_PLAN_PROMPT, () => session.prompt(framed));
+                    return runAgent(IMPLEMENT_PLAN_PROMPT, () => session.prompt(framed, AUTOMATION_PROVENANCE));
                 },
                 // Lean context per user turn: wipe prior review history so each new
                 // turn starts cheap, while within this cycle the few review messages
@@ -1895,19 +2181,21 @@ async function createSession(deps, opts) {
                 },
                 // Autopilot-injected run: EZ Coder receives the framed prompt (no human
                 // is watching this turn) while run_start keeps the clean label.
-                runPrompt: (body) => runAgent(body, () => session.prompt(frameAutopilotInjection(body))),
+                runPrompt: (body) => runAgent(body, () => session.prompt(frameAutopilotInjection(body), AUTOMATION_PROVENANCE)),
                 emit: (event) => {
                     // Persist the terminal verdict marker so a resumed session renders the
                     // same Nolan bubble the live run showed instead of dropping it or
                     // falling back to the raw verdict text (e.g. ALL_CLEAR).
                     if (event.type === "autopilot_done") {
                         // Broadcast the SAME copySeed the persisted marker will produce on
-                        // resume, so the live all-clear wording matches the resumed one
-                        // (computed before persist — same synchronous message count).
+                        // resume, so the live all-clear wording matches the resumed one.
+                        // Must use the PERSISTED count — that's what persistAutopilotMarker
+                        // anchors against, and it trails the in-memory list after a run
+                        // whose messages never made it to disk.
                         const seed = autopilotMarkerCopySeed({
                             version: 1,
                             phase: "done",
-                            afterMessageCount: session.getMessages().filter((m) => m.role !== "system").length,
+                            afterMessageCount: session.getPersistedTranscriptCount(),
                         });
                         broadcast(event.type, { ...event.data, copySeed: seed });
                         void session.persistAutopilotMarker("done");
@@ -1952,7 +2240,10 @@ async function createSession(deps, opts) {
                 const next = session.takeNextQueuedMessage();
                 if (!next)
                     return;
-                broadcast("queued", { count: session.getQueuedCount() });
+                broadcast("queued", {
+                    count: session.getQueuedCount(),
+                    messages: session.listQueuedMessages(),
+                });
                 if (!next.text.trim() && next.attachments.length === 0)
                     continue;
                 // A queued message draining as a fresh turn supersedes any pending
@@ -2038,7 +2329,7 @@ async function createSession(deps, opts) {
         const shortId = task.id.slice(0, 8);
         const completionHint = `\n\n---\nWhen you have fully completed this task, call the tasks tool to mark it done:\n` +
             `tasks({ action: "done", id: "${shortId}" })`;
-        await runAgent(task.title, () => session.prompt(task.prompt + completionHint));
+        await runAgent(task.title, () => session.prompt(task.prompt + completionHint, AUTOMATION_PROVENANCE));
         // The agent typically marks the task done via the tasks tool during the run;
         // prune completed tasks and push the refreshed list so the modal drops them.
         broadcast("tasks_list", { tasks: pruneDoneTasksSync(cwd) });
@@ -2136,6 +2427,20 @@ async function createSession(deps, opts) {
         gitPoll.unref?.();
     };
     scheduleGitPoll(5000);
+    // GitHub issue/PR counts change outside the app (web UI, teammates), so poll
+    // on a slow cadence. Network-bound, so keep it well under the search API's
+    // rate budget (2 calls per tick). No-op when the origin isn't a GitHub repo.
+    let gitHubPoll;
+    let gitHubPollStopped = false;
+    const scheduleGitHubPoll = (delay) => {
+        if (gitHubPollStopped)
+            return;
+        gitHubPoll = setTimeout(() => {
+            void refreshGitHubCounts().finally(() => scheduleGitHubPoll(60_000));
+        }, delay);
+        gitHubPoll.unref?.();
+    };
+    scheduleGitHubPoll(2000);
     function readBody(req, res) {
         return readCappedBody(req, res);
     }
@@ -2257,6 +2562,45 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        if (method === "GET" && url === "/plugins") {
+            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;
+        }
+        if (method === "POST" && url === "/plugins/install") {
+            void readBody(req, res).then(async (raw) => {
+                if (raw === null)
+                    return;
+                try {
+                    const bundlePath = JSON.parse(raw).bundlePath;
+                    if (typeof bundlePath !== "string" || !path.isAbsolute(bundlePath)) {
+                        json(res, 400, { error: "bundlePath must be an absolute path" });
+                        return;
+                    }
+                    const plugin = await installPlugin(bundlePath, paths.extensionsDir);
+                    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) });
+                }
+            });
+            return;
+        }
+        if (method === "DELETE" && url.startsWith("/plugins/")) {
+            const pluginId = decodeURIComponent(url.slice("/plugins/".length));
+            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;
+        }
         if (method === "GET" && url === "/settings") {
             // `configured` is true only when the user explicitly saved a projects root
             // (the ezcoder-app.json file exists with a value) — not when we fall back to the
@@ -2343,9 +2687,53 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // Dismiss a project from the picker (or restore it with hidden:false). The
+        // path is kept rather than the row: sessions in scratch dirs keep
+        // re-surfacing, so the user's decision has to outlive any one scan.
+        if (method === "POST" && url === "/projects/hidden") {
+            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 target = body.path?.trim();
+                if (!target) {
+                    json(res, 400, { error: "path is required" });
+                    return;
+                }
+                const key = path.resolve(target);
+                try {
+                    const settings = await loadAppSettings();
+                    const current = new Set((settings.hiddenProjects ?? []).map((p) => path.resolve(p)));
+                    if (body.hidden === false)
+                        current.delete(key);
+                    else
+                        current.add(key);
+                    settings.hiddenProjects = current.size > 0 ? Array.from(current) : undefined;
+                    await saveAppSettings(settings);
+                    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) });
+                }
+            });
+            return;
+        }
         if (method === "GET" && url === "/projects") {
-            // Scan ezcoder + Claude Code + Codex session stores for known projects.
-            void discoverProjects()
+            // Session stores plus configured project folders, including unopened projects.
+            void loadAppSettings()
+                .then(({ projectsRoot, projectRoots, hiddenProjects }) => discoverProjects({
+                projectsRoot,
+                extraRoots: projectRoots,
+                hiddenPaths: hiddenProjects,
+            }))
                 .then((projects) => json(res, 200, { projects }))
                 .catch((err) => {
                 captureSidecarError(err, "app-sidecar.projects.discover");
@@ -2386,6 +2774,30 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // Markdown transcript export for the app's download button. Serialized
+        // here rather than in the webview because the webview's transcript model
+        // deliberately keeps tool activity in the LiveToolPanel — exporting from
+        // there would hand the user a coding session with the coding missing.
+        // `?name=1` asks for the suggested filename only (the save dialog needs it
+        // before there is a path), so the markdown never crosses IPC twice.
+        if (method === "GET" && (url === "/export" || url.startsWith("/export?"))) {
+            const query = new URLSearchParams(url.slice(url.indexOf("?") + 1));
+            const st = session.getState();
+            const filename = defaultExportFilename(mode);
+            if (query.get("name") === "1") {
+                json(res, 200, { filename });
+                return;
+            }
+            const markdown = sessionToMarkdown({
+                mode,
+                cwd,
+                provider: st.provider,
+                model: st.model,
+                ...(st.sessionId ? { sessionId: st.sessionId } : {}),
+            }, session.getMessages(), { toolDetail: parseToolDetail(query.get("tools")) });
+            json(res, 200, { filename, markdown });
+            return;
+        }
         if (method === "GET" && url === "/history") {
             // Reconstruct the transcript from persisted messages so resume is 1:1 with
             // the live SSE stream. Walks ALL message types (not just user/assistant):
@@ -2431,7 +2843,7 @@ async function createSession(deps, opts) {
                 // Nolan (mentor) turns to interleave: group by the non-system message count
                 // they were recorded after, so each lands right after that message. A
                 // turn becomes two wire rows: the `@Nolan` question (user) + Nolan's reply
-                // (assistant), both flagged `ken` so the webview tints them.
+                // (assistant), both flagged `nolan` so the webview tints them.
                 // Deduped; stale anchors are clamped to the last message (Nolan turns
                 // carry real conversation, so they render at the end instead of
                 // vanishing).
@@ -2447,16 +2859,16 @@ async function createSession(deps, opts) {
                         return;
                     nolanByCount.delete(count);
                     for (const turn of turns) {
-                        history.push({ role: "user", text: `@Nolan ${turn.question}`, ken: true });
-                        history.push({ role: "assistant", text: turn.reply, ken: true });
+                        history.push({ role: "user", text: `@Nolan ${turn.question}`, nolan: true });
+                        history.push({ role: "assistant", text: turn.reply, nolan: true });
                     }
                 };
                 // Autopilot verdict markers to interleave, same anchor scheme as Nolan
                 // turns — each becomes a single assistant row the webview renders
                 // exactly like the live `autopilot` item (never a raw verdict string).
-                // Compact/continuation rewrites can carry old markers whose original
-                // afterMessageCount is beyond the restored message list; dropping those
-                // prevents stale all-clear bubbles from bunching at the bottom on resume.
+                // Normalization pulls anchors left over from an unrebased compaction
+                // back to where the marker was actually written, so stale all-clear
+                // bubbles no longer bunch at the bottom of a reopened session.
                 const restoredMessageCount = messages.filter((m) => m.role !== "system").length;
                 const autopilotByCount = new Map();
                 for (const marker of normalizeAutopilotMarkersForHistory(session.getAutopilotMarkers(), restoredMessageCount)) {
@@ -2540,6 +2952,21 @@ async function createSession(deps, opts) {
                                 },
                             });
                         }
+                        else if (marker.kind === "interrupted_run") {
+                            // Rendered as an error row: the run's tools already changed the
+                            // repo, so the user needs to see it and decide what to do. We
+                            // never replay it — that would duplicate those changes.
+                            history.push({
+                                role: "assistant",
+                                text: "",
+                                error: {
+                                    scope: "interrupted_run",
+                                    headline: "A run was interrupted",
+                                    message: "EZ Coder stopped mid-run, so this turn is incomplete. Any files its tools already changed are still on disk.",
+                                    guidance: "Review the working tree, then re-send the request if you still want it.",
+                                },
+                            });
+                        }
                     }
                 };
                 let nonSystemCount = 0;
@@ -2548,10 +2975,11 @@ async function createSession(deps, opts) {
                 flushNolan(0);
                 flushAutopilot(0);
                 flushAppMarkers(0);
-                for (const msg of messages) {
-                    if (msg.role === "system")
-                        continue;
-                    nonSystemCount++;
+                await replayMessagesInOrder(messages, async (msg, count) => {
+                    nonSystemCount = count;
+                    const visibility = getHistoryMessageVisibility(msg);
+                    if (visibility === "hidden")
+                        return;
                     if (msg.role === "tool") {
                         // Tool result messages: check for ImageContent blocks (screenshots,
                         // generated images) and emit a toolImages entry.
@@ -2595,20 +3023,39 @@ async function createSession(deps, opts) {
                                 });
                             }
                         }
-                        continue;
+                        return;
                     }
                     // User or assistant message — text/hook/command/compacted extraction,
                     // plus sub-agent group detection for assistant tool_calls.
                     if (msg.role === "user") {
                         // Rebuild the live bubble: strip the steering wrapper, drop
                         // attachment/file notes the model saw but the bubble never showed.
-                        const restored = restoreUserRow(msg.content);
+                        const restored = restoreUserRow(msg.content, msg.provenance);
                         const text = restored.text;
-                        const hook = detectHookKind(text);
-                        const compacted = !hook && text.startsWith("[Previous conversation summary]");
-                        const command = !hook && !compacted ? detectPromptCommand(text, commandCandidates) : null;
-                        if (text.trim() || restored.images.length > 0) {
-                            const hint = userHintByCount.get(nonSystemCount);
+                        const hook = msg.provenance ? null : detectHookKind(text);
+                        const compacted = visibility === "summary" ||
+                            (!msg.provenance && !hook && text.startsWith("[Previous conversation summary]"));
+                        const hint = userHintByCount.get(nonSystemCount);
+                        // The typed invocation persisted alongside the prompt is
+                        // authoritative. Reversing the expanded body only works while the
+                        // template is byte-identical, and templates drift (edited
+                        // `.ezcoder/commands/*.md`, reworded built-ins, app-vs-CLI phrasing) —
+                        // after which the resumed session dumped the raw multi-KB body
+                        // instead of the `/name` chip. Older sessions have no hint, so the
+                        // body match stays as the fallback.
+                        const command = !hook && !compacted
+                            ? resolveRestoredCommand(typeof hint?.command === "string" ? hint.command : null, text, commandCandidates)
+                            : null;
+                        // Autopilot injected this turn — live showed only the Nolan-tinted
+                        // marker for it, never a user bubble. Emitting one here would print
+                        // the injected instruction a second time, unstyled.
+                        //
+                        // Pushed background-status updates are skipped for the same reason:
+                        // the live run rendered no bubble for them, so showing them here
+                        // would fill a reopened session with machine-facing status lines
+                        // the user never saw while working.
+                        if ((!msg.provenance || (!restored.autopilotInjected && !restored.notification)) &&
+                            (text.trim() || restored.images.length > 0)) {
                             history.push({
                                 role: "user",
                                 text: command ?? text,
@@ -2671,12 +3118,13 @@ async function createSession(deps, opts) {
                             });
                         }
                     }
-                    // Interleave any Nolan turns / autopilot / app markers recorded right
-                    // after this message.
-                    flushNolan(nonSystemCount);
-                    flushAutopilot(nonSystemCount);
-                    flushAppMarkers(nonSystemCount);
-                }
+                }, (count) => {
+                    // Markers flush after every physical message, including tools and
+                    // provenance-hidden runtime context.
+                    flushNolan(count);
+                    flushAutopilot(count);
+                    flushAppMarkers(count);
+                });
                 // Flush remaining Nolan turns whose anchor is at/after the message count so
                 // none are dropped. Autopilot/app markers beyond the restored message
                 // count were already filtered above; any remaining marker here is valid.
@@ -2705,21 +3153,44 @@ async function createSession(deps, opts) {
                     description: c.description,
                     source: "built-in",
                 }));
+                // Desktop-safe registry actions belong in the same picker as workflows.
+                // Most registry commands have dedicated app controls or TUI-only flows;
+                // multi-root management has no other affordance, so expose only these.
+                const workspaceActions = [
+                    {
+                        name: "add-dir",
+                        aliases: ["adddir"],
+                        description: "Add another project folder to this workspace",
+                        source: "built-in",
+                    },
+                    {
+                        name: "remove-dir",
+                        aliases: ["removedir"],
+                        description: "Remove an added project folder from this workspace",
+                        source: "built-in",
+                    },
+                ];
                 const custom = (await loadCustomCommands(cwd))
-                    // A custom command can't shadow a built-in name.
-                    .filter((c) => !PROMPT_COMMANDS.some((b) => b.name === c.name))
+                    // A custom command can't shadow a built-in name or app action.
+                    .filter((c) => !PROMPT_COMMANDS.some((b) => b.name === c.name) &&
+                    !workspaceActions.some((action) => action.name === c.name))
                     .map((c) => ({
                     name: c.name,
                     aliases: [],
                     description: c.description,
                     source: "custom",
                 }));
-                json(res, 200, { commands: [...builtins, ...custom] });
+                json(res, 200, { commands: [...workspaceActions, ...builtins, ...custom] });
             })();
             return;
         }
         if (method === "POST" && url === "/prompt") {
-            void readBody(req, res).then(async (raw) => {
+            // Per-request: only the prompt that actually claimed the start may release
+            // it. A bare release would let an early-returning request (bad JSON, or a
+            // prompt that queued) clear a claim another request is still holding.
+            let claimedStart = false;
+            void readBody(req, res)
+                .then(async (raw) => {
                 if (raw === null)
                     return;
                 let text;
@@ -2739,14 +3210,17 @@ async function createSession(deps, opts) {
                     json(res, 400, { error: "empty prompt" });
                     return;
                 }
-                if (runLifecycle.running && runLifecycle.isCancellationRequested(runLifecycle.generation)) {
+                if (runLifecycle.running &&
+                    runLifecycle.isCancellationRequested(runLifecycle.generation)) {
                     json(res, 409, {
                         error: runLifecycle.state === "cancelling" ? "run_cancelling" : "cancel_failed",
                         runState: runLifecycle.state,
                     });
                     return;
                 }
-                if (running || autopilotActive) {
+                // `runClaim` covers the gap before `runAgent` flips `running`: a
+                // prompt arriving in that window must queue, not start a second run.
+                if (running || runClaim.active || autopilotActive) {
                     // Queue prompts as mid-run steering (mirrors the CLI). Also queue while
                     // an autopilot cycle is active but between injected runs (build idle,
                     // Nolan reviewing) so the message never starts a run that collides with
@@ -2755,20 +3229,47 @@ async function createSession(deps, opts) {
                     // path as a non-queued attachment prompt when it drains.
                     const prepared = attachments.length > 0 ? await prepareAttachments(cwd, attachments) : [];
                     const count = session.queueMessage(text, prepared);
-                    broadcast("queued", { count });
+                    broadcast("queued", { count, messages: session.listQueuedMessages() });
                     json(res, 202, { queued: true, count });
                     return;
                 }
+                // Claim the run NOW, synchronously. Everything below this line may
+                // yield, and `running` does not flip until runAgent begins.
+                claimedStart = runClaim.claim();
                 json(res, 202, { accepted: true });
+                // Gate inputs captured around the run: whether this turn is a workflow
+                // slash command (attachment prompts skip slash expansion entirely), and
+                // how many assistant messages the run actually adds. Computed even when
+                // autopilot is currently off — the toggle can flip ON mid-run, and the
+                // gate reads the post-run value.
+                const workflowCommand = attachments.length === 0 &&
+                    isWorkflowCommandText(text, await loadWorkflowCommandSpecs());
+                // Does this input actually expand into a persisted user message? Asked
+                // of the session itself, because only it knows whether the command
+                // resolves here (name/alias casing, custom `.ezcoder/commands`, non-coder
+                // agents that don't expand at all). A looser guess would anchor the
+                // hint at +1 with no message to land on — decorating an unrelated
+                // later bubble with the wrong `/name`.
+                const expandsToTemplate = attachments.length === 0 && (await session.willExpandPromptTemplate(text));
                 // Webview display hint for this prompt's user bubble (nolanSent shimmer
-                // label / enhancer highlight segments). Anchored +1 so it attaches to
-                // the user message the prompt below is about to push. Queued prompts
-                // skip this (their position in the run is unpredictable).
-                if (meta && (meta.nolanSent === true || Array.isArray(meta.enhancements))) {
+                // label / enhancer highlight segments / the `/name` a command was typed
+                // as). Anchored +1 so it attaches to the user message the prompt below
+                // is about to push. Queued prompts skip this (their position in the run
+                // is unpredictable).
+                //
+                // Recording the invocation matters because the agent persists the
+                // EXPANDED template as the user message. Resume used to recover
+                // `/name` by matching that body against the current templates, which
+                // silently fails the moment a template is edited or reworded — the
+                // reopened session then rendered the raw multi-KB prompt instead of
+                // the command chip.
+                if (expandsToTemplate ||
+                    (meta && (meta.nolanSent === true || Array.isArray(meta.enhancements)))) {
                     void session
                         .persistAppMarker("user_hint", {
-                        ...(meta.nolanSent === true ? { nolanSent: true } : {}),
-                        ...(Array.isArray(meta.enhancements) ? { enhancements: meta.enhancements } : {}),
+                        ...(expandsToTemplate ? { command: text.trim() } : {}),
+                        ...(meta?.nolanSent === true ? { nolanSent: true } : {}),
+                        ...(Array.isArray(meta?.enhancements) ? { enhancements: meta.enhancements } : {}),
                     }, 1)
                         .catch(() => { });
                 }
@@ -2779,12 +3280,6 @@ async function createSession(deps, opts) {
                 // feedback, anything) supersedes the pending plan — the bump also
                 // invalidates any in-flight Nolan plan review.
                 clearPendingPlan();
-                // Gate inputs captured around the run: whether this turn is a workflow
-                // slash command (attachment prompts skip slash expansion entirely), and
-                // how many assistant messages the run actually adds. Computed even when
-                // autopilot is currently off — the toggle can flip ON mid-run, and the
-                // gate reads the post-run value.
-                const workflowCommand = attachments.length === 0 && isWorkflowCommandText(text, await loadWorkflowCommandSpecs());
                 const assistantsBefore = countAssistantMessages(session.getMessages());
                 const messagesBefore = session.getMessages().length;
                 await runAgent(text, async () => {
@@ -2836,14 +3331,18 @@ async function createSession(deps, opts) {
                 // A prompt sent while Nolan was reviewing (build idle) queued but had no
                 // run to steer into — run it now as a fresh turn so it never strands.
                 await runStrandedQueue();
+            })
+                .finally(() => {
+                if (claimedStart)
+                    runClaim.release();
             });
             return;
         }
         // Nolan Grout (mentor): an independent read-only advisory run on the nolanSession.
-        // Runs concurrently with a build run — its events are ken_-prefixed so the
+        // Runs concurrently with a build run — its events are nolan_-prefixed so the
         // webview keeps the bubbles separate. The context digest is assembled fresh
         // from the BUILD session's transcript each turn (one-way mirror).
-        if (method === "POST" && url === "/ken/prompt") {
+        if (method === "POST" && url === "/nolan/prompt") {
             if (mode === "chat") {
                 json(res, 404, { error: "Nolan is not available in EZ Chat." });
                 return;
@@ -2871,18 +3370,18 @@ async function createSession(deps, opts) {
                 nolanRunning = true;
                 broadcast("nolan_run_start", { text });
                 try {
-                    const ken = await ensureNolanSession();
+                    const nolanAgent = await ensureNolanSession();
                     const digest = await buildNolanContext(session, cwd, gitBranch, text, await loadWorkflowCommandSpecs(), injectedAutopilotPrompts);
-                    await ken.prompt(digest);
+                    await nolanAgent.prompt(digest);
                     // Record the turn against the BUILD session so it persists + survives
                     // resume (advisory custom entry, never an LLM message). Reply is Nolan's
                     // last assistant message; skip persistence if he produced nothing.
-                    const reply = lastAssistantText(ken.getMessages());
+                    const reply = lastAssistantText(nolanAgent.getMessages());
                     if (reply.trim())
                         await session.persistNolanTurn(text, reply);
                 }
                 catch (err) {
-                    broadcastError("nolan_error", "ken run failed", err);
+                    broadcastError("nolan_error", "nolan run failed", err);
                 }
                 finally {
                     nolanRunning = false;
@@ -2895,7 +3394,7 @@ async function createSession(deps, opts) {
             });
             return;
         }
-        if (method === "POST" && url === "/ken/cancel") {
+        if (method === "POST" && url === "/nolan/cancel") {
             nolanAbort.abort();
             nolanAbort = new AbortController();
             nolanSession?.setSignal(nolanAbort.signal);
@@ -3173,12 +3672,30 @@ async function createSession(deps, opts) {
                         loggedIn.push(p);
                 }
                 // Just the names, grouped by provider in registry order — the UI shows
-                // a clean multi-column list of model ids.
-                const models = MODELS.filter((m) => loggedIn.includes(m.provider)).map((m) => ({
-                    id: m.id,
-                    name: m.name,
-                    provider: m.provider,
-                }));
+                // a clean multi-column list of model ids. Local models come from the
+                // runtime registry (populated by the background scan) and are always
+                // listed: their "login" is the endpoint answering a probe.
+                const models = getAllModels()
+                    .filter((m) => m.provider === "local" || loggedIn.includes(m.provider))
+                    .map((m) => {
+                    if (m.provider !== "local") {
+                        return { id: m.id, name: m.name, provider: m.provider };
+                    }
+                    const probed = findProbedModel(localProbes, m.id);
+                    return {
+                        id: m.id,
+                        name: m.name,
+                        provider: m.provider,
+                        local: true,
+                        endpoint: probed?.endpoint.label ?? parseLocalModelId(m.id)?.endpointId,
+                        // A local model that can't call tools can't run the agent — the UI
+                        // renders it disabled rather than hiding it, so the user learns why.
+                        supportsTools: probed?.model.supportsTools ?? true,
+                        contextWindow: m.contextWindow,
+                        contextWindowKnown: probed?.model.contextWindowKnown ?? false,
+                        supportsThinking: m.supportsThinking,
+                    };
+                });
                 json(res, 200, { models });
             })();
             return;
@@ -3207,6 +3724,13 @@ async function createSession(deps, opts) {
                 // Pick up any natively-written keys (desktop app) before resolving the
                 // new model's credentials, so switching to a just-added provider works.
                 await auth.reload();
+                if (target.provider === "local") {
+                    const problem = await localModelBlocker(target.id);
+                    if (problem) {
+                        json(res, 409, { error: problem });
+                        return;
+                    }
+                }
                 await session.switchModel(target.provider, target.id);
                 // Nolan follows EZ Coder's model only while un-pinned; a user-set Nolan
                 // override survives EZ Coder model switches untouched.
@@ -3245,7 +3769,7 @@ async function createSession(deps, opts) {
                 // no-op event (keeps footer/event tests from treating an EZ Coder
                 // switch as a Nolan switch).
                 if (!nolanModelOverride)
-                    broadcast("ken_model_change", nolanStatePayload());
+                    broadcast("nolan_model_change", nolanStatePayload());
                 // The new model usually has a different context window — push extras so
                 // the footer's context meter rescales immediately.
                 broadcast("extras", footerExtras());
@@ -3257,7 +3781,7 @@ async function createSession(deps, opts) {
         // { model: null } / "" to clear (Nolan resumes following EZ Coder). Applies
         // to BOTH Nolan sessions (chat + autopilot reviewer); a switch landing while
         // either is mid-run defers via the pending-model mechanics.
-        if (method === "POST" && url === "/ken/model") {
+        if (method === "POST" && url === "/nolan/model") {
             void readBody(req, res).then(async (raw) => {
                 if (raw === null)
                     return;
@@ -3292,17 +3816,49 @@ async function createSession(deps, opts) {
                     await saveNolanModelPref(cwd, nolanModelOverride);
                     await syncNolanModel(target.provider, target.id);
                     await syncNolanAutoModel(target.provider, target.id);
-                    log("INFO", "app-sidecar", "ken model pinned", {
+                    log("INFO", "app-sidecar", "nolan model pinned", {
                         provider: target.provider,
                         model: target.id,
                     });
                 }
                 const payload = nolanStatePayload();
-                broadcast("ken_model_change", payload);
+                broadcast("nolan_model_change", payload);
                 json(res, 200, payload);
             });
             return;
         }
+        // Pending queued steering, for the composer's cancel affordance.
+        if (method === "GET" && url === "/queued") {
+            json(res, 200, { queued: session.listQueuedMessages() });
+            return;
+        }
+        // Cancel one pending queued message by id.
+        if (method === "POST" && url === "/queued/cancel") {
+            void readBody(req, res).then((raw) => {
+                if (raw === null)
+                    return;
+                let id;
+                try {
+                    id = JSON.parse(raw).id ?? "";
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (!id.trim()) {
+                    json(res, 400, { error: "missing queued message id" });
+                    return;
+                }
+                // `false` means it already drained into the run between render and
+                // click. That is a race, not an error, so report it as a normal result
+                // and let the client reconcile from the fresh list.
+                const cancelled = session.cancelQueuedMessage(id);
+                const queued = session.listQueuedMessages();
+                broadcast("queued", { count: queued.length, messages: queued });
+                json(res, 200, { cancelled, queued });
+            });
+            return;
+        }
         if (method === "POST" && url === "/kill") {
             void readBody(req, res).then(async (raw) => {
                 if (raw === null)
@@ -3326,6 +3882,33 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // Import a Claude Code / Codex / Cursor transcript into a resumable GG
+        // Coder session. The importer never throws — it returns a typed failure so
+        // the app can show the reason verbatim.
+        if (method === "POST" && url === "/import-transcript") {
+            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 filePath = body.path?.trim();
+                if (!filePath) {
+                    json(res, 400, { error: "missing transcript path" });
+                    return;
+                }
+                const result = await session.importForeignTranscript(filePath, {
+                    ...(body.cwd ? { cwd: body.cwd } : {}),
+                });
+                json(res, result.ok ? 200 : 400, result);
+            });
+            return;
+        }
         if (method === "POST" && url === "/thinking") {
             const st = session.getState();
             const next = getNextThinkingLevel(st.provider, st.model, session.getThinkingLevel());
@@ -3360,7 +3943,7 @@ async function createSession(deps, opts) {
                 const generation = runLifecycle.generation;
                 if (!pendingCancelDrain || pendingCancelDrain.generation !== generation) {
                     pendingCancelDrain = { generation, text: session.drainQueue() };
-                    broadcast("queued", { count: 0 });
+                    broadcast("queued", { count: 0, messages: [] });
                 }
                 const result = await runLifecycle.cancel(CANCEL_TIMEOUT_MS);
                 const drained = pendingCancelDrain.text;
@@ -3520,7 +4103,17 @@ async function createSession(deps, opts) {
                     ...(baseUrl ? { baseUrl } : {}),
                 };
                 await auth.setCredentials(storageKey, creds);
-                broadcast("auth_done", { provider });
+                // auth.json is shared by every window, so this is a global change:
+                // close their login modals and refresh their provider lists too.
+                broadcastAll("auth_done", { provider });
+                // `auth_done` means "a login succeeded" (modals close on it).
+                // `auth_change` means "auth.json changed" — which a DISCONNECT also is,
+                // so connection state has one signal that covers both directions.
+                broadcastAll("auth_change", { provider });
+                // A newly connected provider unlocks its models. `/models` filters on
+                // who is logged in, so every window's picker is now stale — without
+                // this the new models don't appear until the session is reopened.
+                broadcastAll("models_change", {});
                 json(res, 200, { ok: true });
             });
             return;
@@ -3546,7 +4139,18 @@ async function createSession(deps, opts) {
                     json(res, 409, { error: "a login is already in progress" });
                     return;
                 }
+                // A login writes the shared ~/.ezcoder/auth.json, so two windows racing the
+                // same provider means two browser tabs and two token exchanges whose
+                // writes clobber each other. The per-session flag above cannot see
+                // that — guard the provider daemon-wide as well.
+                if (oauthInFlightProviders.has(provider)) {
+                    json(res, 409, {
+                        error: `a ${meta.label} login is already in progress in another window`,
+                    });
+                    return;
+                }
                 oauthInFlight = true;
+                oauthInFlightProviders.add(provider);
                 json(res, 202, { accepted: true });
                 void (async () => {
                     const cb = authCallbacks();
@@ -3567,10 +4171,19 @@ async function createSession(deps, opts) {
                             throw new Error(`OAuth not implemented for ${provider}`);
                         }
                         await auth.setCredentials(storageKey, creds);
-                        broadcast("auth_done", { provider });
+                        // Terminal outcome of a GLOBAL change: every window's login modal
+                        // should close and its provider list refresh, not just the one
+                        // that started the flow.
+                        broadcastAll("auth_done", { provider });
+                        broadcastAll("auth_change", { provider });
+                        // The OAuth provider's models just became selectable everywhere.
+                        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.
                         broadcast("auth_error", {
                             provider,
                             message: err instanceof Error ? err.message : String(err),
@@ -3578,6 +4191,7 @@ async function createSession(deps, opts) {
                     }
                     finally {
                         oauthInFlight = false;
+                        oauthInFlightProviders.delete(provider);
                         pendingCode = null;
                     }
                 })();
@@ -3606,6 +4220,39 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        if (method === "POST" && url.startsWith("/mcp/elicit/")) {
+            const id = decodeURIComponent(url.slice("/mcp/elicit/".length));
+            void readBody(req, res).then((raw) => {
+                if (raw === null)
+                    return;
+                let result;
+                try {
+                    const parsed = JSON.parse(raw);
+                    if (parsed.action !== "accept" &&
+                        parsed.action !== "decline" &&
+                        parsed.action !== "cancel") {
+                        json(res, 400, { error: "action must be accept, decline, or cancel" });
+                        return;
+                    }
+                    result =
+                        parsed.action === "accept"
+                            ? { action: "accept", content: parsed.content ?? {} }
+                            : { action: parsed.action };
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                // Unknown id means it already timed out or was cancelled by an abort —
+                // the tool call has moved on, so the answer has nowhere to go.
+                if (!elicitations.settle(id, result)) {
+                    json(res, 409, { error: "no elicitation is awaiting a response" });
+                    return;
+                }
+                json(res, 200, { ok: true });
+            });
+            return;
+        }
         if (method === "POST" && url === "/auth/logout") {
             void readBody(req, res).then(async (raw) => {
                 if (raw === null)
@@ -3632,6 +4279,84 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // ── Local models ──────────────────────────────────────
+        // GET returns the last scan (cheap, no probing) so opening the modal is
+        // instant; POST /local/scan is the explicit refresh.
+        if (method === "GET" && url === "/local") {
+            json(res, 200, localStatePayload());
+            return;
+        }
+        if (method === "POST" && url === "/local/scan") {
+            void scanLocalModels(true)
+                .then(() => {
+                broadcast("models_change", { local: localStatePayload() });
+                json(res, 200, localStatePayload());
+            })
+                .catch((err) => {
+                broadcastError("error", "local model scan failed", err);
+                json(res, 500, { error: "Local model scan failed — see the sidecar log." });
+            });
+            return;
+        }
+        if (method === "POST" && url === "/local/endpoints") {
+            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;
+                }
+                try {
+                    const endpoint = await addCustomEndpoint({
+                        baseUrl: body.baseUrl ?? "",
+                        ...(body.label ? { label: body.label } : {}),
+                        ...(body.apiKey ? { apiKey: body.apiKey } : {}),
+                    });
+                    await scanLocalModels(true);
+                    broadcast("models_change", { local: localStatePayload() });
+                    json(res, 200, {
+                        endpoint: { id: endpoint.id, label: endpoint.label },
+                        ...localStatePayload(),
+                    });
+                }
+                catch (err) {
+                    // Validation errors are the user's typo, not a system fault — 400 with
+                    // the exact reason, and nothing in the transcript.
+                    if (err instanceof LocalEndpointError) {
+                        json(res, 400, { error: err.message });
+                        return;
+                    }
+                    broadcastError("error", "add local endpoint failed", err);
+                    json(res, 500, { error: "Could not save the endpoint — see the sidecar log." });
+                }
+            });
+            return;
+        }
+        if (method === "DELETE" && url.startsWith("/local/endpoints/")) {
+            const id = decodeURIComponent(url.slice("/local/endpoints/".length));
+            void (async () => {
+                try {
+                    await removeCustomEndpoint(id);
+                    clearRuntimeModels((m) => m.provider === "local" && parseLocalModelId(m.id)?.endpointId === id);
+                    await scanLocalModels(true);
+                    broadcast("models_change", { local: localStatePayload() });
+                    json(res, 200, localStatePayload());
+                }
+                catch (err) {
+                    if (err instanceof LocalEndpointError) {
+                        json(res, 400, { error: err.message });
+                        return;
+                    }
+                    broadcastError("error", "remove local endpoint failed", err);
+                    json(res, 500, { error: "Could not remove the endpoint — see the sidecar log." });
+                }
+            })();
+            return;
+        }
         // ── Telegram config (mirrors `ezcoder telegram`) ─────────
         if (method === "GET" && url === "/telegram") {
             void loadTelegramConfig().then((cfg) => {
@@ -3913,12 +4638,16 @@ async function createSession(deps, opts) {
         json(res, 404, { error: "not found" });
     }
     async function dispose() {
+        elicitations.cancelAll();
         tasksPollStopped = true;
         if (tasksPoll)
             clearTimeout(tasksPoll);
         gitPollStopped = true;
         if (gitPoll)
             clearTimeout(gitPoll);
+        gitHubPollStopped = true;
+        if (gitHubPoll)
+            clearTimeout(gitHubPoll);
         // Stop the Telegram serve loop + dispose its per-chat sessions.
         if (serveController)
             await serveController.stop().catch(() => { });