@prestyj/cli 5.4.1 → 5.5.0

package/README.md

@@ -151,23 +151,36 @@ Plus built-in workflows that ship with the binary:
 
 EZ Coder comes with a focused set of tools. Each one is small, well-described, and earns its place in the prompt.
 
-| Tool | What it does |
-|---|---|
-| `bash` | Run shell commands |
-| `read` | Read file contents |
-| `write` | Write files |
-| `edit` | Surgical string replacements |
-| `grep` | Search file contents (regex) |
-| `find` | Find files by glob pattern |
-| `ls` | List directory contents |
-| `web_fetch` | Fetch URL content |
-| `screenshot` | Open a URL / dev server in a headless browser and capture a PNG so the agent can see the rendered page |
-| `subagent` | Spawn parallel sub-agents |
+| Tool                              | What it does                                                                                           |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `bash`                            | Run shell commands                                                                                     |
+| `read`                            | Read file contents                                                                                     |
+| `write`                           | Write files                                                                                            |
+| `edit`                            | Surgical string replacements                                                                           |
+| `grep`                            | Search file contents (regex)                                                                           |
+| `find`                            | Find files by glob pattern                                                                             |
+| `ls`                              | List directory contents                                                                                |
+| `web_fetch`                       | Fetch URL content                                                                                      |
+| `screenshot`                      | Open a URL / dev server in a headless browser and capture a PNG so the agent can see the rendered page |
+| `subagent`                        | Run one blocking, isolated child task (backward-compatible)                                            |
+| `spawn_agent` / `wait_agent`      | Launch persistent child turns concurrently and collect results                                         |
+| `send_message` / `followup_task`  | Steer a running child or reuse an idle child's context                                                 |
+| `list_agents` / `interrupt_agent` | Inspect or interrupt persistent children                                                               |
 
 The `screenshot` tool needs the optional `playwright` dependency plus a one-time `npx playwright install chromium`. Without it the tool returns an install hint instead of failing the turn. Captured images render inline in graphics-capable terminals (kitty, Ghostty, WezTerm, iTerm2); other terminals show a text line.
 
 Plus the [Grep MCP](https://grep.dev) for searching across 1M+ public GitHub repos. Add your own MCPs in settings if you need more — but start lean.
 
+### Async subagent lifecycle
+
+`subagent` remains blocking. The async suite launches persistent NDJSON worker processes, so a parent can start up to four active child turns, keep working, steer them, and wait for any or all results. Up to eight idle workers remain available for follow-up; bounded snapshots retain the latest 20 agents.
+
+Only GPT-5.6 Sol/Terra at **Ultra** delegates proactively. Lower Sol/Terra levels use async agents only when the user or project/skill instructions request delegation; other models receive no proactive policy.
+
+Children share the parent working directory, not isolated worktrees. Parallel writes must target disjoint files or subsystems. Async fan-out is one level deep, child output is bounded, idle workers reap after 10 minutes, and workers are not resumable after a CLI/app restart.
+
+Parent cancellation interrupts active children. Session disposal shuts down every worker process alongside background commands, LSP servers, and MCP connections.
+
 ---
 
 ## 🪄 Custom commands

package/dist/app-sidecar.js

@@ -20,7 +20,10 @@ import { randomUUID } from "node:crypto";
 import { parseArgs } from "node:util";
 import { formatError } from "@prestyj/ai";
 import { runJsonMode } from "./modes/json-mode.js";
+import { runSubagentWorkerMode } from "./modes/subagent-worker-mode.js";
 import { AgentSession } from "./core/agent-session.js";
+import { CHAT_AGENT_IDS, chatAgentSessionsDir, createChatAgent, parseChatAgentId, sessionsDirForChatAgent, switchChatAgent, } from "./chat-agents/index.js";
+import { buildMemoryTools, MemoryStore } from "./chat-agents/memory.js";
 import { buildNolanSystemPrompt, buildNolanAutopilotSystemPrompt } from "./core/nolan-prompt.js";
 import { buildNolanDigest, buildNolanAutopilotContext, buildNolanAutopilotPlanContext, } from "./core/nolan-context.js";
 import { parseAutopilotVerdict } from "./core/autopilot-verdict.js";
@@ -46,7 +49,7 @@ import { loadCustomCommands } from "./core/custom-commands.js";
 import { discoverProjects, listRecentSessions } from "./core/project-discovery.js";
 import { loadTasksSync, saveTasksSync, pruneDoneTasksSync, getNextPendingTask, markTaskInProgress, } from "./core/task-store.js";
 import { initLogger, log } from "./core/logger.js";
-import { RADIO_STATIONS, getCurrentStation, playRadio, stopRadio } from "./core/radio.js";
+import { RADIO_STATIONS, getCurrentStation, getRadioVolume, playRadio, setRadioVolume, stopRadio, } from "./core/radio.js";
 import { enrichProcessPath } from "./core/shell-path.js";
 import { downscaleForPreview, validateVisionImage } from "./utils/image.js";
 import { startServeMode } from "./modes/serve-mode.js";
@@ -457,6 +460,11 @@ function daemonJson(res, status, body) {
     res.end(JSON.stringify(body));
 }
 async function main() {
+    // Hidden persistent-worker dispatch must win before strict JSON/server parsing.
+    if (process.argv.includes("--subagent-worker")) {
+        await runSubagentWorkerMode();
+        return;
+    }
     // Sub-agent JSON-mode dispatch must win before any sidecar/server setup.
     if (await runJsonModeIfRequested())
         return;
@@ -502,6 +510,13 @@ 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();
+    const memoryStore = new MemoryStore({
+        onChange: ({ memories }) => {
+            for (const ctx of sessions.values()) {
+                ctx.broadcast("memory_change", { count: memories.length });
+            }
+        },
+    });
     // XP/rank progress — loaded once per daemon; awards fan out to every window.
     // Each frame is tagged `origin: true` only for the session that earned the
     // XP, so that window alone plays sounds/chips while the rest just re-render.
@@ -600,7 +615,7 @@ async function main() {
             return;
         }
         // ── Daemon-level routes (session lifecycle) ──────────────────────────
-        // Create a session for a window: { cwd, sessionPath? } → { sessionId }.
+        // Create a session for a window: { mode?, cwd, sessionPath? } → { sessionId }.
         if (method === "POST" && url === "/session") {
             void daemonReadBody(req).then(async (raw) => {
                 let body = {};
@@ -610,15 +625,22 @@ async function main() {
                 catch {
                     /* empty/invalid body → defaults below */
                 }
+                const mode = body.mode === "chat" ? "chat" : "code";
+                const chatAgent = parseChatAgentId(body.chatAgent);
                 const sessionCwd = typeof body.cwd === "string" && body.cwd
                     ? body.cwd
                     : (process.env.GG_APP_CWD ?? process.cwd());
                 const sessionPath = typeof body.sessionPath === "string" && body.sessionPath ? body.sessionPath : undefined;
                 const id = randomUUID();
                 try {
-                    const ctx = await createSession({ auth, paths, progress }, { id, cwd: sessionCwd, sessionPath });
+                    const ctx = await createSession({ auth, paths, progress, memoryStore }, { id, mode, chatAgent, cwd: sessionCwd, sessionPath });
                     sessions.set(id, ctx);
-                    log("INFO", "app-sidecar", "session created", { id, cwd: sessionCwd });
+                    log("INFO", "app-sidecar", "session created", {
+                        id,
+                        mode,
+                        chatAgent,
+                        cwd: sessionCwd,
+                    });
                     daemonJson(res, 200, { sessionId: id });
                 }
                 catch (err) {
@@ -681,16 +703,40 @@ async function main() {
         process.stdout.write(`GG_APP_LISTENING ${addr.port}\n`);
         log("INFO", "app-sidecar", "daemon listening", { port: String(addr.port), host });
     });
-    const shutdown = async () => {
+    const shellPid = process.ppid;
+    let shuttingDown = false;
+    async function shutdown() {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        clearInterval(parentWatch);
         // Radio playback is app-wide (one stream across all windows), so it stops
         // at the daemon level, not per session.
         stopRadio();
         await Promise.all([...sessions.values()].map((c) => c.dispose().catch(() => { })));
         server.close();
         process.exit(0);
-    };
+    }
     process.on("SIGINT", () => void shutdown());
     process.on("SIGTERM", () => void shutdown());
+    process.once("exit", stopRadio);
+    // Tauri can disappear without delivering a signal (force-quit, dev runner
+    // teardown, crash). Detect reparenting or a dead shell so the daemon and its
+    // radio player do not survive as audible orphans.
+    const parentWatch = setInterval(() => {
+        let parentAlive = process.ppid === shellPid;
+        if (parentAlive && shellPid > 1) {
+            try {
+                process.kill(shellPid, 0);
+            }
+            catch (error) {
+                parentAlive = error.code === "EPERM";
+            }
+        }
+        if (!parentAlive)
+            void shutdown();
+    }, 1_000);
+    parentWatch.unref?.();
 }
 /** Nolan's read-only tool allow-list. Excludes every mutating tool (write/edit/
  *  bash/tasks/subagent/generate_image/enter_plan/exit_plan/task_*) so the mentor
@@ -745,8 +791,14 @@ function buildNolanContext(buildSession, cwd, gitBranch, question, workflowComma
     });
 }
 async function createProgressManager(agentDir, broadcastAll) {
-    // Boot: recovery chain main → backup → one-time session-history rebuild → empty.
-    let file = await loadProgress({ rebuild: () => rebuildFromSessions() });
+    // Boot: recovery chain main → backup → coding + chat session rebuild → empty.
+    const coderSessionsDir = path.join(agentDir, "sessions");
+    let file = await loadProgress({
+        rebuild: () => rebuildFromSessions([
+            coderSessionsDir,
+            ...CHAT_AGENT_IDS.map((agentId) => chatAgentSessionsDir(coderSessionsDir, agentId)),
+        ]),
+    });
     // Don't re-celebrate an old levelUp event on boot.
     let lastSeenNonce = file.lastEvent?.nonce ?? null;
     log("INFO", "app-sidecar", "progress loaded", {
@@ -794,7 +846,7 @@ async function createProgressManager(agentDir, broadcastAll) {
             });
         }
     }
-    // Watch ~/.gg (dir watch survives the atomic tmp+rename) for progress.json
+    // Watch ~/.ezcoder (dir watch survives the atomic tmp+rename) for progress.json
     // writes from other daemon processes; debounce, reload read-only, dedupe by nonce.
     let watchDebounce = null;
     try {
@@ -834,8 +886,10 @@ 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 } = deps;
+    const { auth, progress, memoryStore } = deps;
     const paths = deps.paths;
+    const mode = opts.mode;
+    let chatAgent = opts.chatAgent;
     const cwd = opts.cwd;
     // Base host for parsing request-URL query params (value is irrelevant to
     // parsing); the daemon owns the real listen host.
@@ -938,66 +992,77 @@ async function createSession(deps, opts) {
     // empty/unset starts a fresh session.
     const resumeSessionPath = opts.sessionPath;
     let abort = new AbortController();
-    const session = new AgentSession({
+    const baseSessionOptions = {
         provider,
         model,
         cwd,
         thinkingLevel,
         sessionId: resumeSessionPath,
         signal: abort.signal,
-        // The shell gates window readiness on the GG_APP_LISTENING handshake, which
-        // can't fire until initialize() resolves. Connect MCP in the background so a
-        // slow or hanging stdio server (e.g. a first-run `npx -y @playwright/mcp`
-        // download) can't delay the sidecar past the webview's startup timeout
-        // ("sidecar did not start in time"). Tools attach when the servers come up.
+        // Keep MCP startup off the readiness path in both modes.
         backgroundMcpConnect: true,
-        // Plan mode: the agent's enter_plan/exit_plan tools drive these. We flip
-        // session plan state (rebuilds the system prompt + enforces read-only
-        // tools) and surface the transition to the webview.
-        onEnterPlan: async (reason) => {
-            // During a task run there is no human present to approve a plan, and a
-            // submitted plan would strand the task in-progress while the run-all loop
-            // advances to the next one. Decline plan mode so the agent implements the
-            // task directly — mirrors the TUI's isUnattendedRun guard (App.tsx). The
-            // enter_plan tool turns a false return into an "implement directly" hint.
-            if (taskRunActive)
-                return false;
-            await session.setPlanMode(true);
-            broadcast("plan_enter", { reason: reason ?? "" });
-            // Persist the plan-mode banner so a resumed session still shows it.
-            void session.persistAppMarker("plan", { reason: reason ?? "" }).catch(() => { });
-        },
-        onExitPlan: async (planPath) => {
-            // A model can call exit_plan even when enter_plan was declined. During a
-            // task run, never route the plan into review (no approver) — that would
-            // hang the task and stall run-all. Leave plan mode and tell it to build.
-            if (taskRunActive) {
+    };
+    let session;
+    if (mode === "chat") {
+        session = createChatAgent(chatAgent, {
+            ...baseSessionOptions,
+            sessionsDir: paths.sessionsDir,
+            additionalTools: buildMemoryTools(memoryStore),
+            getSystemPromptTail: () => memoryStore.renderForPrompt(),
+            onAgentChange: async (nextAgent) => {
+                chatAgent = nextAgent;
+                broadcast("chat_agent_change", { chatAgent: nextAgent });
+                await session.persistAppMarker("agent_handoff", { chatAgent: nextAgent }).catch((error) => {
+                    log("WARN", "app-sidecar", "agent handoff marker persist failed", {
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                });
+            },
+        });
+    }
+    else {
+        session = new AgentSession({
+            ...baseSessionOptions,
+            // Plan mode belongs only to the coding agent.
+            onEnterPlan: async (reason) => {
+                // Unattended task runs cannot approve plans; implement directly instead.
+                if (taskRunActive)
+                    return false;
+                await session.setPlanMode(true);
+                broadcast("plan_enter", { reason: reason ?? "" });
+                void session.persistAppMarker("plan", { reason: reason ?? "" }).catch(() => { });
+            },
+            onExitPlan: async (planPath) => {
+                if (taskRunActive) {
+                    await session.setPlanMode(false);
+                    return ("Plan review is unavailable during a task run. Skip review and implement " +
+                        "the plan directly now: make the changes, verify them, then mark the task done.");
+                }
                 await session.setPlanMode(false);
-                return ("Plan review is unavailable during a task run. Skip review and implement " +
-                    "the plan directly now: make the changes, verify them, then mark the task done.");
-            }
-            await session.setPlanMode(false);
-            // Surface the plan's path + markdown so the webview can show the review
-            // modal (Accept / Feedback / Reject). Best-effort content read.
-            let content;
-            try {
-                content = await fs.readFile(planPath, "utf-8");
-            }
-            catch {
-                content = "";
-            }
-            // Record the submitted plan so the autopilot gate can route this turn
-            // into a PLAN review instead of a stale work review (plan mode is
-            // already false here, so the gate's planMode check alone never catches
-            // a submission). setPendingPlan bumps planGeneration, which invalidates
-            // any in-flight Nolan plan review racing a user action.
-            setPendingPlan(planPath, content);
-            broadcast("plan_exit", { planPath, content });
-            return "Plan submitted for user review. Wait for the user to approve, reject, or dismiss it before implementing.";
-        },
-    });
+                let content;
+                try {
+                    content = await fs.readFile(planPath, "utf-8");
+                }
+                catch {
+                    content = "";
+                }
+                setPendingPlan(planPath, content);
+                broadcast("plan_exit", { planPath, content });
+                return "Plan submitted for user review. Wait for the user to approve, reject, or dismiss it before implementing.";
+            },
+        });
+    }
     await session.initialize();
-    log("INFO", "app-sidecar", "session ready", { provider, model, cwd });
+    if (mode === "chat") {
+        const restoredAgent = [...session.getAppMarkers()]
+            .reverse()
+            .find((marker) => marker.kind === "agent_handoff")?.data.chatAgent;
+        if (typeof restoredAgent === "string") {
+            chatAgent = parseChatAgentId(restoredAgent);
+            await switchChatAgent(session, chatAgent, false);
+        }
+    }
+    log("INFO", "app-sidecar", "session ready", { provider, model, mode, chatAgent, cwd });
     // Footer extras (context window, git branch, background tasks). The git
     // branch is resolved once at startup and refreshed lazily; the context
     // window follows the active model.
@@ -1060,6 +1125,7 @@ async function createSession(deps, opts) {
     });
     session.eventBus.on("model_change", (d) => broadcast("model_change", d));
     session.eventBus.on("hook", (d) => broadcast("hook", d));
+    session.eventBus.on("subagent_state", (d) => broadcast("subagent_state", d));
     session.eventBus.on("compaction_start", (d) => broadcast("compaction_start", d));
     session.eventBus.on("compaction_end", (d) => broadcast("compaction_end", d));
     let running = false;
@@ -1071,7 +1137,7 @@ async function createSession(deps, opts) {
     // ezcoder-app.json on boot; flipped via POST /autopilot. When on, POST /prompt runs
     // runAutopilotCycle after the user's turn settles — Nolan auto-reviews the work
     // and drives the review→prompt→review loop.
-    let autopilot = await loadAutopilot(cwd);
+    let autopilot = mode === "code" && (await loadAutopilot(cwd));
     // True while an autopilot review is in flight (used to defer nolanAuto model
     // switches, like nolanRunning does for chat Nolan, and to drive the spinner).
     let autopilotReviewing = false;
@@ -1139,7 +1205,7 @@ async function createSession(deps, opts) {
     let nolanRunning = false;
     let pendingNolanModel = null;
     const nolanToolCallNames = new Map();
-    // Nolan's per-project model override. null → Nolan (chat + autopilot) follows GG
+    // Nolan's per-project model override. null → Nolan (chat + autopilot) follows EZ
     // Coder's model, including live switches (the historical behavior). Set → Nolan
     // is pinned to his own model and EZ Coder switches no longer touch him. A
     // stale persisted pin (model dropped from the registry / provider logged
@@ -1149,7 +1215,7 @@ async function createSession(deps, opts) {
         providerConnected: () => true, // async auth checked below
     });
     if (nolanModelOverride && !(await auth.hasProviderAuth(nolanModelOverride.provider))) {
-        log("WARN", "app-sidecar", "ken model override provider not connected — following GG", {
+        log("WARN", "app-sidecar", "Nolan model override provider not connected — following EZ Coder", {
             provider: nolanModelOverride.provider,
             model: nolanModelOverride.model,
         });
@@ -1764,6 +1830,8 @@ async function createSession(deps, opts) {
             const st = session.getState();
             json(res, 200, {
                 ...st,
+                mode,
+                chatAgent,
                 running,
                 ready: true,
                 thinkingLevel: session.getThinkingLevel() ?? null,
@@ -1779,6 +1847,26 @@ async function createSession(deps, opts) {
             json(res, 200, progress.snapshot());
             return;
         }
+        if (method === "GET" && url === "/memories") {
+            void memoryStore
+                .snapshot()
+                .then((snapshot) => json(res, 200, snapshot))
+                .catch((error) => json(res, 500, { error: error instanceof Error ? error.message : String(error) }));
+            return;
+        }
+        if (method === "DELETE" && url.startsWith("/memories/")) {
+            const id = decodeURIComponent(url.slice("/memories/".length));
+            if (!id) {
+                json(res, 400, { error: "memory id is required" });
+                return;
+            }
+            void memoryStore
+                .forget(id)
+                .then(() => memoryStore.snapshot())
+                .then((snapshot) => json(res, 200, snapshot))
+                .catch((error) => json(res, 500, { error: error instanceof Error ? error.message : String(error) }));
+            return;
+        }
         if (method === "GET" && (url === "/events" || url.startsWith("/events?"))) {
             res.writeHead(200, {
                 "content-type": "text/event-stream",
@@ -1794,6 +1882,8 @@ async function createSession(deps, opts) {
                 type: "ready",
                 data: {
                     ...st,
+                    mode,
+                    chatAgent,
                     running,
                     thinkingLevel: session.getThinkingLevel() ?? null,
                     supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
@@ -1909,7 +1999,36 @@ async function createSession(deps, opts) {
                 json(res, 400, { error: "missing cwd query param" });
                 return;
             }
-            void listRecentSessions(target, 5)
+            const requestedAgent = new URL(url, `http://${host}`).searchParams.get("chatAgent");
+            if (requestedAgent === "all") {
+                void Promise.all(CHAT_AGENT_IDS.map(async (agentId) => {
+                    const agentSessions = await listRecentSessions(target, 5, chatAgentSessionsDir(paths.sessionsDir, agentId));
+                    return agentSessions.map((item) => ({ ...item, chatAgent: agentId }));
+                }))
+                    .then(async (groups) => {
+                    const dated = await Promise.all(groups.flat().map(async (item) => ({
+                        item,
+                        mtime: await fs
+                            .stat(item.path)
+                            .then((stat) => stat.mtimeMs)
+                            .catch(() => 0),
+                    })));
+                    const recent = dated
+                        .sort((left, right) => right.mtime - left.mtime)
+                        .slice(0, 5)
+                        .map(({ item }) => item);
+                    json(res, 200, { sessions: recent });
+                })
+                    .catch(() => json(res, 200, { sessions: [] }));
+                return;
+            }
+            // The picker may be served by a sidecar currently running in Chat mode.
+            // An omitted chatAgent always means coding history; chat callers identify
+            // their namespace explicitly (one agent or "all").
+            const sessionsDir = requestedAgent
+                ? sessionsDirForChatAgent(paths.sessionsDir, requestedAgent)
+                : paths.sessionsDir;
+            void listRecentSessions(target, 5, sessionsDir)
                 .then((sessions) => json(res, 200, { sessions }))
                 .catch(() => json(res, 200, { sessions: [] }));
             return;
@@ -2174,12 +2293,17 @@ async function createSession(deps, opts) {
                     }
                     // Assistant tool_call blocks: detect sub-agent delegations.
                     if (msg.role === "assistant" && typeof msg.content !== "string") {
-                        const subagentCalls = msg.content.filter((c) => c.type === "tool_call" && c.name === "subagent");
+                        const subagentCalls = msg.content.filter((c) => c.type === "tool_call" && (c.name === "subagent" || c.name === "spawn_agent"));
                         if (subagentCalls.length > 0) {
                             const agents = subagentCalls.map((c) => {
                                 const result = toolResultMap.get(c.id);
                                 return {
-                                    agentName: typeof c.args?.agent === "string" ? c.args.agent : undefined,
+                                    agentName: c.name === "spawn_agent" && typeof c.args?.task_name === "string"
+                                        ? c.args.task_name
+                                        : typeof c.args?.agent === "string"
+                                            ? c.args.agent
+                                            : undefined,
+                                    // Async workers are intentionally non-resumable; restored rows are historical.
                                     status: result?.isError ? "error" : "done",
                                     toolUseCount: 0,
                                 };
@@ -2211,6 +2335,10 @@ async function createSession(deps, opts) {
             return;
         }
         if (method === "GET" && url === "/commands") {
+            if (mode === "chat") {
+                json(res, 200, { commands: [] });
+                return;
+            }
             // Workflow commands with agent functionality: built-in prompt templates +
             // the user's own `.ezcoder/commands/*.md`. UI commands (model/quit/etc.) are
             // handled webview-side and intentionally excluded.
@@ -2258,7 +2386,7 @@ async function createSession(deps, opts) {
                     // an autopilot cycle is active but between injected runs (build idle,
                     // Nolan reviewing) so the message never starts a run that collides with
                     // an injected one on the same session. Attachments are persisted to
-                    // .gg/uploads first so the queued media rides the same native-block
+                    // .ezcoder/uploads first so the queued media rides the same native-block
                     // 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);
@@ -2351,6 +2479,10 @@ async function createSession(deps, opts) {
         // 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 (mode === "chat") {
+                json(res, 404, { error: "Nolan is not available in EZ Chat." });
+                return;
+            }
             void readBody(req).then(async (raw) => {
                 let text;
                 try {
@@ -2406,6 +2538,10 @@ async function createSession(deps, opts) {
             return;
         }
         if (method === "POST" && url === "/autopilot") {
+            if (mode === "chat") {
+                json(res, 404, { error: "Autopilot is not available in EZ Chat." });
+                return;
+            }
             void readBody(req).then(async (raw) => {
                 let enabled;
                 try {
@@ -2464,7 +2600,34 @@ async function createSession(deps, opts) {
         // duplicate audio across windows (the original per-window goal), now for
         // free. (To restore per-window radio, key playback by sessionId.)
         if (method === "GET" && url === "/radio") {
-            json(res, 200, { stations: RADIO_STATIONS, current: getCurrentStation() });
+            json(res, 200, {
+                stations: RADIO_STATIONS,
+                current: getCurrentStation(),
+                volume: getRadioVolume(),
+            });
+            return;
+        }
+        if (method === "POST" && url === "/radio/volume") {
+            void readBody(req).then((raw) => {
+                let volume;
+                try {
+                    volume = Number(JSON.parse(raw).volume);
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (!Number.isFinite(volume)) {
+                    json(res, 400, { error: "volume must be a number" });
+                    return;
+                }
+                const result = setRadioVolume(volume);
+                if (!result.ok) {
+                    json(res, 400, { error: result.error ?? "Radio volume failed to update." });
+                    return;
+                }
+                json(res, 200, { current: getCurrentStation(), volume: getRadioVolume() });
+            });
             return;
         }
         if (method === "POST" && url === "/radio") {
@@ -2657,7 +2820,7 @@ async function createSession(deps, opts) {
                 await auth.reload();
                 await session.switchModel(target.provider, target.id);
                 // Nolan follows EZ Coder's model only while un-pinned; a user-set Nolan
-                // override survives GG model switches untouched.
+                // override survives EZ Coder model switches untouched.
                 if (!nolanModelOverride) {
                     await syncNolanModel(target.provider, target.id);
                     await syncNolanAutoModel(target.provider, target.id);
@@ -2690,8 +2853,8 @@ async function createSession(deps, opts) {
                 broadcast("thinking_change", payload);
                 // Un-pinned Nolan just followed the switch — update his footer chip too.
                 // When Nolan is pinned, his effective model did not change, so skip the
-                // no-op event (keeps footer/event tests from treating a GG switch as a
-                // Nolan switch).
+                // no-op event (keeps footer/event tests from treating an EZ Coder
+                // switch as a Nolan switch).
                 if (!nolanModelOverride)
                     broadcast("ken_model_change", nolanStatePayload());
                 // The new model usually has a different context window — push extras so
@@ -2723,7 +2886,7 @@ async function createSession(deps, opts) {
                     const st = session.getState();
                     await syncNolanModel(st.provider, st.model);
                     await syncNolanAutoModel(st.provider, st.model);
-                    log("INFO", "app-sidecar", "ken model pin cleared — following GG", {
+                    log("INFO", "app-sidecar", "Nolan model pin cleared — following EZ Coder", {
                         provider: st.provider,
                         model: st.model,
                     });
@@ -2821,7 +2984,10 @@ async function createSession(deps, opts) {
             }
             void session
                 .newSession()
-                .then(() => {
+                .then(async () => {
+                if (mode === "chat") {
+                    await session.persistAppMarker("agent_handoff", { chatAgent });
+                }
                 injectedAutopilotPrompts = [];
                 clearPendingPlan();
                 broadcast("session_reset", {});
@@ -3320,6 +3486,10 @@ async function createSession(deps, opts) {
     }
     return {
         id: opts.id,
+        mode,
+        get chatAgent() {
+            return chatAgent;
+        },
         cwd,
         sessionPath: opts.sessionPath,
         session,