@prestyj/cli 5.10.0 → 5.11.0

package/dist/app-sidecar.js

@@ -24,6 +24,7 @@ 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";
@@ -33,7 +34,7 @@ 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";
@@ -47,6 +48,7 @@ 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 { 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";
@@ -64,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",
@@ -87,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");
 }
@@ -110,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 {
@@ -363,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)
@@ -598,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()) {
@@ -621,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
@@ -635,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 {
@@ -678,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,
@@ -699,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.
@@ -766,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,
@@ -1042,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;
@@ -1178,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;
@@ -1191,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
@@ -1513,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);
@@ -1564,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;
@@ -1643,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;
@@ -1673,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 });
@@ -1689,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,
@@ -1704,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
@@ -1758,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,
@@ -1773,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;
@@ -1804,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.
@@ -1884,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)) {
@@ -1904,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());
         }
     }
@@ -1918,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,
@@ -1927,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)
@@ -1958,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);
@@ -1971,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
@@ -2000,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.
@@ -2064,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
@@ -2093,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");
@@ -2150,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
@@ -2236,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) });
@@ -2469,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
@@ -2555,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");
@@ -2667,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).
@@ -2683,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)) {
@@ -2776,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;
@@ -2784,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.
@@ -2831,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,
@@ -2907,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.
@@ -2973,7 +3185,12 @@ async function createSession(deps, opts) {
             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;
@@ -2993,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
@@ -3009,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(() => { });
                 }
@@ -3033,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 () => {
@@ -3090,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;
@@ -3125,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;
@@ -3149,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);
@@ -3524,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());
@@ -3536,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;
@@ -3571,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)
@@ -3605,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());
@@ -3639,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;
@@ -3799,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;
@@ -3825,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();
@@ -3846,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),
@@ -3857,6 +4191,7 @@ async function createSession(deps, opts) {
                     }
                     finally {
                         oauthInFlight = false;
+                        oauthInFlightProviders.delete(provider);
                         pendingCode = null;
                     }
                 })();
@@ -3885,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)
@@ -4270,6 +4638,7 @@ async function createSession(deps, opts) {
         json(res, 404, { error: "not found" });
     }
     async function dispose() {
+        elicitations.cancelAll();
         tasksPollStopped = true;
         if (tasksPoll)
             clearTimeout(tasksPoll);