castle-web-cli 0.4.59 → 0.4.61

package/dist/agent.js

@@ -14,64 +14,72 @@
 // Backend CLI: cursor-agent in headless print mode (stream-json). The router
 // runs with --mode ask (read-only at the CLI level); task agents run with
 // --force. Claude support can slot in later behind runAgentCli.
-import { execFileSync, spawn } from 'child_process';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { nanoid } from 'nanoid';
-import { WebSocketServer } from 'ws';
-import { rawDataToString } from './ide.js';
-import { buildRouterPrompt, buildTaskPrompt, userTurnInstruction, CLAUDE_TASK_SYSTEM_REMINDER, } from './agent-prompts.js';
-export const AGENT_WS_PATH = '/__castle/agent';
-export const AGENT_ATTACHMENT_PREFIX = '/__castle/agent/attachments/';
-const DEFAULT_SETTINGS = { router: 'claude', tasks: 'claude', claudeModel: 'opus' };
+import { execFileSync, spawn } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { nanoid } from "nanoid";
+import { WebSocketServer } from "ws";
+import { rawDataToString } from "./ide.js";
+import { buildRouterPrompt, buildTaskPrompt, userTurnInstruction, CLAUDE_TASK_SYSTEM_REMINDER, } from "./agent-prompts.js";
+export const AGENT_WS_PATH = "/__castle/agent";
+export const AGENT_ATTACHMENT_PREFIX = "/__castle/agent/attachments/";
+const DEFAULT_SETTINGS = {
+    router: "claude",
+    tasks: "claude",
+    claudeModel: "opus",
+};
 function normalizeBackend(value) {
-    return value === 'cursor' || value === 'claude' ? value : null;
+    return value === "cursor" || value === "claude" ? value : null;
 }
 function normalizeClaudeModel(value) {
-    return value === 'sonnet' || value === 'opus' || value === 'fable' ? value : null;
+    return value === "sonnet" || value === "opus" || value === "fable"
+        ? value
+        : null;
 }
 // Build the headless CLI invocation for a backend/role. Cursor's router runs
 // in read-only ask mode; claude runs permission-mode auto for both roles (NOT
 // plan mode -- that makes it emit plan tool calls) at medium effort.
 function buildAgentInvocation(backend, role, prompt, claudeModel) {
-    if (backend === 'claude') {
+    if (backend === "claude") {
         return {
-            command: 'claude',
+            command: "claude",
             args: [
-                '-p',
-                '--verbose',
-                '--output-format',
-                'stream-json',
-                '--include-partial-messages',
-                '--permission-mode',
-                'auto',
-                '--model',
+                "-p",
+                "--verbose",
+                "--output-format",
+                "stream-json",
+                "--include-partial-messages",
+                "--permission-mode",
+                "auto",
+                "--model",
                 claudeModel,
-                '--effort',
-                'medium',
+                "--effort",
+                "medium",
                 // Keep runs independent of the machine's user config: no user plugins
                 // (LSP servers etc.), no user MCP servers. CLAUDE.md auto-discovery
                 // and OAuth still work.
-                '--settings',
+                "--settings",
                 '{"enabledPlugins": {}}',
-                '--strict-mcp-config',
-                ...(role === 'task' ? ['--append-system-prompt', CLAUDE_TASK_SYSTEM_REMINDER] : []),
+                "--strict-mcp-config",
+                ...(role === "task"
+                    ? ["--append-system-prompt", CLAUDE_TASK_SYSTEM_REMINDER]
+                    : []),
                 prompt,
             ],
         };
     }
     return {
-        command: 'cursor-agent',
+        command: "cursor-agent",
         args: [
-            '-p',
-            '--output-format',
-            'stream-json',
-            '--stream-partial-output',
-            '--trust',
-            '--model',
-            'composer-2.5-fast',
-            ...(role === 'router' ? ['--mode', 'ask'] : ['--force']),
+            "-p",
+            "--output-format",
+            "stream-json",
+            "--stream-partial-output",
+            "--trust",
+            "--model",
+            "composer-2.5-fast",
+            ...(role === "router" ? ["--mode", "ask"] : ["--force"]),
             prompt,
         ],
     };
@@ -84,11 +92,11 @@ const MAX_TASK_ATTEMPTS = 3;
 // first, as running ones finish. Conservative default; override via env.
 const MAX_CONCURRENT_TASKS = Number(process.env.CASTLE_MAX_CONCURRENT_TASKS) || 4;
 const TASK_POLL_MS = 1_000;
-const FENCE_HOLDBACK = '```castle-';
+const FENCE_HOLDBACK = "```castle-";
 const RESULT_SUMMARY_CHARS = 600;
 const MAX_ATTACHMENTS = 6;
 const MAX_ATTACHMENT_BYTES = 8 * 1024 * 1024;
-const TERMINAL_STATUSES = ['done', 'failed', 'interrupted'];
+const TERMINAL_STATUSES = ["done", "failed", "interrupted"];
 function nowIso() {
     return new Date().toISOString();
 }
@@ -97,7 +105,7 @@ function isTerminal(status) {
 }
 function readJsonFile(filePath) {
     try {
-        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
     }
     catch {
         return null;
@@ -124,97 +132,113 @@ function extractDirectives(full) {
     const checkoffs = [];
     const stops = [];
     const listFence = (source, name, into) => {
-        const re = new RegExp('```' + name + '[ \\t]*\\r?\\n([\\s\\S]*?)```', 'g');
+        const re = new RegExp("```" + name + "[ \\t]*\\r?\\n([\\s\\S]*?)```", "g");
         return source.replace(re, (_match, body) => {
             for (const token of String(body).split(/[,\n]/)) {
                 const trimmed = token.trim();
                 if (trimmed)
                     into.push(trimmed);
             }
-            return '';
+            return "";
         });
     };
-    const withoutDone = listFence(listFence(full, 'castle-done', checkoffs), 'castle-stop', stops);
+    const withoutDone = listFence(listFence(full, "castle-done", checkoffs), "castle-stop", stops);
     const fenceRe = /```castle-task[ \t]*\r?\n([\s\S]*?)```/g;
     const cleaned = withoutDone.replace(fenceRe, (_match, body) => {
-        const lines = String(body).replace(/\r/g, '').split('\n');
-        const title = (lines.shift() ?? '').trim();
+        const lines = String(body).replace(/\r/g, "").split("\n");
+        const title = (lines.shift() ?? "").trim();
         const headers = { after: [] };
         while (lines.length > 0) {
-            const headerMatch = /^(after):\s*(.*)$/i.exec((lines[0] ?? '').trim());
+            const headerMatch = /^(after):\s*(.*)$/i.exec((lines[0] ?? "").trim());
             if (!headerMatch)
                 break;
             lines.shift();
             headers[headerMatch[1].toLowerCase()] = headerMatch[2]
-                .split(',')
+                .split(",")
                 .map((s) => s.trim())
                 .filter(Boolean);
         }
-        const prompt = lines.join('\n').trim();
+        const prompt = lines.join("\n").trim();
         if (title) {
             directives.push({ title, after: headers.after, prompt });
         }
-        return '';
+        return "";
     });
-    return { cleaned: cleaned.replace(/\n{3,}/g, '\n\n').trim(), directives, checkoffs, stops };
+    return {
+        cleaned: cleaned.replace(/\n{3,}/g, "\n\n").trim(),
+        directives,
+        checkoffs,
+        stops,
+    };
 }
-// Claude names tools directly (Read, Edit, Bash, ...).
-function claudeToolActivityLabel(name) {
+function baseName(p) {
+    const parts = p.split(/[\\/]/).filter(Boolean);
+    return parts[parts.length - 1] || p;
+}
+// Matches the per-task progress file an agent writes its 0-100 integer to. We
+// hide those writes from the live feed -- they're constant noise, not work.
+const PROGRESS_FILE_RE = /\.castle\/agent\/tasks\/[^/]+\/progress$/;
+// Feed label for a finished claude tool_use block. We surface ONLY file edits
+// and reads -- commands, searches, and globs are noise in the live feed.
+// Returns null to hide the action (progress-file writes + anything non-edit/read).
+function claudeToolFeedLabel(name, input) {
     const kind = name.toLowerCase();
-    if (['read', 'glob', 'grep', 'ls', 'webfetch', 'websearch'].some((p) => kind.startsWith(p))) {
-        return 'reading the deck';
+    if (["edit", "write", "notebookedit", "multiedit"].some((p) => kind.startsWith(p))) {
+        const file = String(input.file_path ?? input.path ?? input.notebook_path ?? "");
+        if (!file || PROGRESS_FILE_RE.test(file))
+            return null;
+        return `Editing ${baseName(file)}`;
     }
-    if (['edit', 'write', 'notebookedit', 'multiedit'].some((p) => kind.startsWith(p))) {
-        return 'editing files';
+    if (kind.startsWith("read") || kind.startsWith("notebookread")) {
+        const file = String(input.file_path ?? input.path ?? "");
+        return file ? `Reading ${baseName(file)}` : null;
     }
-    if (kind.startsWith('bash'))
-        return 'running a command';
-    if (kind.startsWith('task'))
-        return 'delegating';
-    return 'working';
+    return null;
 }
 // Human-readable label for a tool_call event, e.g. readToolCall -> "reading
 // the deck". Shown as the streaming message's activity line.
 function toolActivityLabel(ev) {
     const call = ev.tool_call;
-    const key = call ? Object.keys(call).find((k) => k.endsWith('ToolCall')) : undefined;
-    const kind = (key ?? '').slice(0, -'ToolCall'.length).toLowerCase();
-    if (['read', 'glob', 'grep', 'ls', 'list'].some((p) => kind.startsWith(p))) {
-        return 'reading the deck';
+    const key = call
+        ? Object.keys(call).find((k) => k.endsWith("ToolCall"))
+        : undefined;
+    const kind = (key ?? "").slice(0, -"ToolCall".length).toLowerCase();
+    if (["read", "glob", "grep", "ls", "list"].some((p) => kind.startsWith(p))) {
+        return "reading the deck";
     }
-    if (['write', 'edit', 'delete', 'mv'].some((p) => kind.startsWith(p)))
-        return 'editing files';
-    if (['shell', 'bash', 'terminal'].some((p) => kind.startsWith(p)))
-        return 'running a command';
-    return 'working';
+    if (["write", "edit", "delete", "mv"].some((p) => kind.startsWith(p)))
+        return "editing files";
+    if (["shell", "bash", "terminal"].some((p) => kind.startsWith(p)))
+        return "running a command";
+    return "working";
 }
 // Castle's agent CLI keys, delivered to the sandbox as a file
 // (~/.castle/keys.json) rather than sandbox-wide env -- so an ambient key can't
 // override a user's own subscription login. Falls back to process.env for
 // older sandboxes that still inject the keys as env.
-const CASTLE_KEYS_PATH = path.join(os.homedir(), '.castle', 'keys.json');
+const CASTLE_KEYS_PATH = path.join(os.homedir(), ".castle", "keys.json");
 function castleKeys() {
     try {
-        return JSON.parse(fs.readFileSync(CASTLE_KEYS_PATH, 'utf8'));
+        return JSON.parse(fs.readFileSync(CASTLE_KEYS_PATH, "utf8"));
     }
     catch {
         return {};
     }
 }
 const BACKEND_KEY_ENV = {
-    claude: 'ANTHROPIC_API_KEY',
-    cursor: 'CURSOR_API_KEY',
+    claude: "ANTHROPIC_API_KEY",
+    cursor: "CURSOR_API_KEY",
 };
 // True when the user has their OWN saved auth for this backend -- a /login, or
 // (for cursor, which reuses one auth.json) any saved creds. When so we do NOT
 // inject Castle's key, so their auth is used and billed to them.
 function backendHasSavedAuth(backend) {
     const home = os.homedir();
-    if (backend === 'claude') {
-        return fs.existsSync(path.join(home, '.claude', '.credentials.json'));
+    if (backend === "claude") {
+        return fs.existsSync(path.join(home, ".claude", ".credentials.json"));
     }
-    if (backend === 'cursor') {
-        return fs.existsSync(path.join(home, '.config', 'cursor', 'auth.json'));
+    if (backend === "cursor") {
+        return fs.existsSync(path.join(home, ".config", "cursor", "auth.json"));
     }
     return false;
 }
@@ -248,18 +272,20 @@ function runAgentCli(opts) {
         const child = spawn(opts.command, opts.args, {
             cwd: opts.cwd,
             env: envForAgentSpawn(opts.parser),
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: ["ignore", "pipe", "pipe"],
         });
         opts.children.add(child);
         opts.onSpawn?.(child.pid);
-        const log = opts.logPath ? fs.createWriteStream(opts.logPath, { flags: 'a' }) : null;
+        const log = opts.logPath
+            ? fs.createWriteStream(opts.logPath, { flags: "a" })
+            : null;
         let settled = false;
-        let accumulated = '';
-        let finalText = '';
+        let accumulated = "";
+        let finalText = "";
         let resultIsError = false;
         let sawResult = false;
-        let stderrTail = '';
-        let lineBuffer = '';
+        let stderrTail = "";
+        let lineBuffer = "";
         const settle = (result) => {
             if (settled)
                 return;
@@ -271,12 +297,16 @@ function runAgentCli(opts) {
         };
         const timeout = setTimeout(() => {
             try {
-                child.kill('SIGKILL');
+                child.kill("SIGKILL");
             }
             catch {
                 /* already gone */
             }
-            settle({ ok: false, finalText: finalText || accumulated, error: 'agent run timed out' });
+            settle({
+                ok: false,
+                finalText: finalText || accumulated,
+                error: "agent run timed out",
+            });
         }, opts.timeoutMs);
         // Cursor closes each text segment (e.g. right before a tool call) by
         // re-emitting the segment's full text as one more delta-shaped event;
@@ -284,14 +314,18 @@ function runAgentCli(opts) {
         // duplicating lines. Segment boundaries also need a paragraph gap --
         // cursor starts the next segment without one, which glues "Checking the
         // deck..." lines onto the previous paragraph.
-        let segmentText = '';
+        let segmentText = "";
         let needsGap = false;
+        // Accumulate each claude tool_use block's streamed input JSON by block
+        // index, so at content_block_stop we can label it with the real file /
+        // command (and drop progress-file writes).
+        const pendingTools = new Map();
         const emitDelta = (rawDelta) => {
             let delta = rawDelta;
             if (needsGap) {
                 needsGap = false;
-                if (accumulated && !accumulated.endsWith('\n\n')) {
-                    delta = (accumulated.endsWith('\n') ? '\n' : '\n\n') + delta;
+                if (accumulated && !accumulated.endsWith("\n\n")) {
+                    delta = (accumulated.endsWith("\n") ? "\n" : "\n\n") + delta;
                 }
             }
             segmentText += delta;
@@ -300,43 +334,75 @@ function runAgentCli(opts) {
             opts.onActivity?.(null);
         };
         const handleClaudeEvent = (ev) => {
-            if (ev.type === 'stream_event') {
+            if (ev.type === "stream_event") {
                 const e = ev.event;
-                if (e?.type === 'content_block_start') {
-                    if (e.content_block?.type === 'tool_use') {
+                if (e?.type === "content_block_start") {
+                    if (e.content_block?.type === "tool_use") {
                         needsGap = true;
-                        opts.onActivity?.(claudeToolActivityLabel(String(e.content_block.name ?? '')));
+                        // Hold the label until content_block_stop, once the input (file /
+                        // command) has streamed in, so we can name it concretely.
+                        pendingTools.set(e.index ?? -1, {
+                            name: String(e.content_block.name ?? ""),
+                            buf: "",
+                        });
                     }
-                    else if (e.content_block?.type === 'thinking') {
+                    else if (e.content_block?.type === "thinking") {
                         needsGap = true;
-                        opts.onActivity?.('thinking');
                     }
                 }
-                else if (e?.type === 'content_block_delta') {
-                    if (e.delta?.type === 'text_delta' && typeof e.delta.text === 'string' && e.delta.text) {
+                else if (e?.type === "content_block_delta") {
+                    if (e.delta?.type === "text_delta" &&
+                        typeof e.delta.text === "string" &&
+                        e.delta.text) {
                         emitDelta(e.delta.text);
                     }
-                    else if (e.delta?.type === 'thinking_delta') {
-                        opts.onActivity?.('thinking');
+                    else if (e.delta?.type === "thinking_delta" &&
+                        typeof e.delta.thinking === "string" &&
+                        e.delta.thinking) {
+                        opts.onThinking?.(e.delta.thinking);
+                    }
+                    else if (e.delta?.type === "input_json_delta" &&
+                        typeof e.delta.partial_json === "string") {
+                        const pending = pendingTools.get(e.index ?? -1);
+                        if (pending)
+                            pending.buf += e.delta.partial_json;
+                    }
+                }
+                else if (e?.type === "content_block_stop") {
+                    const pending = pendingTools.get(e.index ?? -1);
+                    if (pending) {
+                        pendingTools.delete(e.index ?? -1);
+                        let input = {};
+                        try {
+                            input = pending.buf
+                                ? JSON.parse(pending.buf)
+                                : {};
+                        }
+                        catch {
+                            /* input JSON arrived partial -- fall back to a generic label */
+                        }
+                        const label = claudeToolFeedLabel(pending.name, input);
+                        if (label)
+                            opts.onActivity?.(label);
                     }
                 }
             }
-            else if (ev.type === 'result') {
+            else if (ev.type === "result") {
                 sawResult = true;
-                finalText = typeof ev.result === 'string' ? ev.result : accumulated;
+                finalText = typeof ev.result === "string" ? ev.result : accumulated;
                 resultIsError = ev.is_error === true;
             }
         };
         const handleEvent = (ev) => {
-            if (opts.parser === 'claude') {
+            if (opts.parser === "claude") {
                 handleClaudeEvent(ev);
                 return;
             }
-            if (ev.type === 'assistant' && typeof ev.timestamp_ms === 'number') {
+            if (ev.type === "assistant" && typeof ev.timestamp_ms === "number") {
                 const message = ev.message;
                 const delta = (message?.content ?? [])
-                    .map((c) => (typeof c?.text === 'string' ? c.text : ''))
-                    .join('');
+                    .map((c) => (typeof c?.text === "string" ? c.text : ""))
+                    .join("");
                 if (!delta)
                     return;
                 const trimmed = delta.trim();
@@ -344,31 +410,31 @@ function runAgentCli(opts) {
                     return;
                 emitDelta(delta);
             }
-            else if (ev.type === 'tool_call') {
-                segmentText = '';
+            else if (ev.type === "tool_call") {
+                segmentText = "";
                 needsGap = true;
-                if (ev.subtype === 'started')
+                if (ev.subtype === "started")
                     opts.onActivity?.(toolActivityLabel(ev));
             }
-            else if (ev.type === 'thinking') {
-                segmentText = '';
+            else if (ev.type === "thinking") {
+                segmentText = "";
                 needsGap = true;
-                opts.onActivity?.('thinking');
+                opts.onActivity?.("thinking");
             }
-            else if (ev.type === 'result') {
+            else if (ev.type === "result") {
                 sawResult = true;
-                finalText = typeof ev.result === 'string' ? ev.result : accumulated;
+                finalText = typeof ev.result === "string" ? ev.result : accumulated;
                 resultIsError = ev.is_error === true;
             }
         };
-        child.stdout.on('data', (chunk) => {
-            lineBuffer += chunk.toString('utf8');
-            let nl = lineBuffer.indexOf('\n');
+        child.stdout.on("data", (chunk) => {
+            lineBuffer += chunk.toString("utf8");
+            let nl = lineBuffer.indexOf("\n");
             while (nl >= 0) {
                 const line = lineBuffer.slice(0, nl);
                 lineBuffer = lineBuffer.slice(nl + 1);
                 if (line.trim()) {
-                    log?.write(line + '\n');
+                    log?.write(line + "\n");
                     try {
                         handleEvent(JSON.parse(line));
                     }
@@ -376,39 +442,45 @@ function runAgentCli(opts) {
                         /* non-JSON noise on stdout -- ignore */
                     }
                 }
-                nl = lineBuffer.indexOf('\n');
+                nl = lineBuffer.indexOf("\n");
             }
         });
-        child.stderr.on('data', (chunk) => {
-            stderrTail = (stderrTail + chunk.toString('utf8')).slice(-2000);
+        child.stderr.on("data", (chunk) => {
+            stderrTail = (stderrTail + chunk.toString("utf8")).slice(-2000);
         });
-        child.on('error', (err) => {
-            settle({ ok: false, finalText: accumulated, error: `could not run cursor-agent: ${err.message}` });
+        child.on("error", (err) => {
+            settle({
+                ok: false,
+                finalText: accumulated,
+                error: `could not run cursor-agent: ${err.message}`,
+            });
         });
-        child.on('close', (code) => {
+        child.on("close", (code) => {
             const ok = code === 0 && !resultIsError && sawResult;
             settle({
                 ok,
                 finalText: finalText || accumulated,
                 crashed: !sawResult,
-                error: ok ? undefined : `agent exited ${code}${stderrTail ? `: ${stderrTail.slice(-300)}` : ''}`,
+                error: ok
+                    ? undefined
+                    : `agent exited ${code}${stderrTail ? `: ${stderrTail.slice(-300)}` : ""}`,
             });
         });
     });
 }
 // -- task store ---------------------------------------------------------------
 function persistTaskFile(tasksDir, task) {
-    fs.writeFileSync(path.join(tasksDir, task.id, 'task.json'), JSON.stringify(task, null, 2) + '\n');
+    fs.writeFileSync(path.join(tasksDir, task.id, "task.json"), JSON.stringify(task, null, 2) + "\n");
 }
 // Tasks left "running" by a dead serve are as finished as they will get.
 function loadTasks(tasksDir) {
     const tasks = new Map();
     for (const entry of fs.existsSync(tasksDir) ? fs.readdirSync(tasksDir) : []) {
-        const rec = readJsonFile(path.join(tasksDir, entry, 'task.json'));
+        const rec = readJsonFile(path.join(tasksDir, entry, "task.json"));
         if (!rec)
             continue;
-        if (rec.status === 'running') {
-            rec.status = 'interrupted';
+        if (rec.status === "running") {
+            rec.status = "interrupted";
             rec.updatedAt = nowIso();
             persistTaskFile(tasksDir, rec);
         }
@@ -422,7 +494,9 @@ function refreshTaskFiles(tasksDir, task) {
     const dir = path.join(tasksDir, task.id);
     let changed = false;
     try {
-        const rawProgress = fs.readFileSync(path.join(dir, 'progress'), 'utf8').trim();
+        const rawProgress = fs
+            .readFileSync(path.join(dir, "progress"), "utf8")
+            .trim();
         const value = Math.max(0, Math.min(100, parseInt(rawProgress, 10)));
         if (Number.isFinite(value) && value !== task.progress) {
             task.progress = value;
@@ -433,7 +507,7 @@ function refreshTaskFiles(tasksDir, task) {
         /* no progress file yet */
     }
     try {
-        const notes = fs.readFileSync(path.join(dir, 'notes.md'), 'utf8');
+        const notes = fs.readFileSync(path.join(dir, "notes.md"), "utf8");
         if (notes !== task.notes) {
             task.notes = notes;
             changed = true;
@@ -468,8 +542,8 @@ function depsSummaryFor(tasks, task) {
     const lines = task.after
         .map((id) => tasks.get(id))
         .filter((dep) => !!dep)
-        .map((dep) => `- "${dep.title}" finished ${dep.status}${dep.notes.trim() ? `; notes: ${dep.notes.trim()}` : ''}`);
-    return lines.join('\n') || undefined;
+        .map((dep) => `- "${dep.title}" finished ${dep.status}${dep.notes.trim() ? `; notes: ${dep.notes.trim()}` : ""}`);
+    return lines.join("\n") || undefined;
 }
 async function runTaskAgentIn(ctx, task) {
     const dir = path.join(ctx.tasksDir, task.id);
@@ -479,8 +553,8 @@ async function runTaskAgentIn(ctx, task) {
         taskId: task.id,
         title: task.title,
         prompt: task.prompt,
-        progressPath: path.join(relDir, 'progress'),
-        notesPath: path.join(relDir, 'notes.md'),
+        progressPath: path.join(relDir, "progress"),
+        notesPath: path.join(relDir, "notes.md"),
         depsSummary: ctx.depsSummary,
         backend: ctx.backend,
     });
@@ -490,18 +564,18 @@ async function runTaskAgentIn(ctx, task) {
     // can't-verify-live-play loop. A single message + the autonomy reminder
     // appended to the system prompt (CLAUDE_TASK_SYSTEM_REMINDER) is enough to
     // get the work done; the agent stops when the code is in, the user verifies.
-    const invocation = buildAgentInvocation(ctx.backend, 'task', taskPrompt, ctx.claudeModel);
-    let result = { ok: false, finalText: '', error: 'not run' };
-    let lineBuf = '';
+    const invocation = buildAgentInvocation(ctx.backend, "task", taskPrompt, ctx.claudeModel);
+    let result = { ok: false, finalText: "", error: "not run" };
+    let lineBuf = "";
     const flushFeedLines = (delta) => {
         lineBuf += delta;
-        let nl = lineBuf.indexOf('\n');
+        let nl = lineBuf.indexOf("\n");
         while (nl >= 0) {
             const line = lineBuf.slice(0, nl).trim();
             lineBuf = lineBuf.slice(nl + 1);
             if (line)
                 ctx.onFeed(line);
-            nl = lineBuf.indexOf('\n');
+            nl = lineBuf.indexOf("\n");
         }
     };
     for (let attempt = 1; attempt <= MAX_TASK_ATTEMPTS; attempt++) {
@@ -511,12 +585,13 @@ async function runTaskAgentIn(ctx, task) {
             args: invocation.args,
             parser: ctx.backend,
             timeoutMs: TASK_TIMEOUT_MS,
-            logPath: path.join(dir, 'log.jsonl'),
+            logPath: path.join(dir, "log.jsonl"),
             children: ctx.children,
             onSpawn: (pid) => {
                 task.pid = pid;
             },
             onDelta: (delta) => flushFeedLines(delta),
+            onThinking: (delta) => flushFeedLines(delta),
             onActivity: (activity) => {
                 if (activity)
                     ctx.onFeed(`[${activity}]`);
@@ -529,7 +604,7 @@ async function runTaskAgentIn(ctx, task) {
         if (attempt < MAX_TASK_ATTEMPTS)
             ctx.onRetry(attempt + 1);
     }
-    result.error = `agent process kept dying (${MAX_TASK_ATTEMPTS} attempts): ${result.error ?? ''}`;
+    result.error = `agent process kept dying (${MAX_TASK_ATTEMPTS} attempts): ${result.error ?? ""}`;
     return result;
 }
 function createTaskStore(opts) {
@@ -555,12 +630,12 @@ function createTaskStore(opts) {
     function runningCount() {
         let n = 0;
         for (const t of tasks.values())
-            if (t.status === 'running')
+            if (t.status === "running")
                 n++;
         return n;
     }
     function maybeStart(task) {
-        if (task.status !== 'waiting' || task.acknowledged || !depsAreSettled(task))
+        if (task.status !== "waiting" || task.acknowledged || !depsAreSettled(task))
             return;
         // Concurrency cap: at most MAX_CONCURRENT_TASKS agents run at once. Over-cap
         // tasks stay 'waiting' and are restarted -- earliest-created first -- by the
@@ -571,10 +646,10 @@ function createTaskStore(opts) {
     }
     function start(task) {
         const dir = path.join(tasksDir, task.id);
-        fs.writeFileSync(path.join(dir, 'progress'), '0\n');
-        if (!fs.existsSync(path.join(dir, 'notes.md')))
-            fs.writeFileSync(path.join(dir, 'notes.md'), '');
-        task.status = 'running';
+        fs.writeFileSync(path.join(dir, "progress"), "0\n");
+        if (!fs.existsSync(path.join(dir, "notes.md")))
+            fs.writeFileSync(path.join(dir, "notes.md"), "");
+        task.status = "running";
         task.startedAt = nowIso();
         touch(task);
         opts.onStarted(task);
@@ -593,7 +668,7 @@ function createTaskStore(opts) {
         void runTaskAgentIn(runCtx, task).then((result) => {
             refreshTaskFiles(tasksDir, task);
             const wasStopped = stopRequested.delete(task.id);
-            task.status = wasStopped ? 'interrupted' : result.ok ? 'done' : 'failed';
+            task.status = wasStopped ? "interrupted" : result.ok ? "done" : "failed";
             // A stopped task is cleared off the board (castle-stop = halt + remove).
             if (wasStopped)
                 task.acknowledged = true;
@@ -601,10 +676,10 @@ function createTaskStore(opts) {
                 task.progress = 100;
             task.finishedAt = nowIso();
             task.resultSummary = wasStopped
-                ? 'stopped by the router'
+                ? "stopped by the router"
                 : result.ok
                     ? result.finalText.slice(-RESULT_SUMMARY_CHARS)
-                    : `${result.error ?? 'failed'}\n${result.finalText.slice(-RESULT_SUMMARY_CHARS)}`;
+                    : `${result.error ?? "failed"}\n${result.finalText.slice(-RESULT_SUMMARY_CHARS)}`;
             touch(task);
             opts.onFinished(task);
             // A slot just freed -- restart eligible waiting tasks, earliest-created
@@ -619,9 +694,9 @@ function createTaskStore(opts) {
             title: directive.title,
             prompt: directive.prompt,
             after: resolveDeps(tasks, directive.after),
-            status: 'waiting',
+            status: "waiting",
             progress: 0,
-            notes: '',
+            notes: "",
             createdAt: nowIso(),
             updatedAt: nowIso(),
             originMessageId,
@@ -645,7 +720,7 @@ function createTaskStore(opts) {
     }
     const pollTimer = setInterval(() => {
         for (const task of tasks.values()) {
-            if (task.status !== 'running')
+            if (task.status !== "running")
                 continue;
             if (refreshTaskFiles(tasksDir, task))
                 touch(task);
@@ -654,8 +729,8 @@ function createTaskStore(opts) {
     function shutdown() {
         clearInterval(pollTimer);
         for (const task of tasks.values()) {
-            if (task.status === 'running' || task.status === 'waiting') {
-                task.status = 'interrupted';
+            if (task.status === "running" || task.status === "waiting") {
+                task.status = "interrupted";
                 task.updatedAt = nowIso();
                 persistTaskFile(tasksDir, task);
             }
@@ -664,13 +739,15 @@ function createTaskStore(opts) {
     // True when a fence body is the special token "all" / "*" (clear/stop
     // everything, no per-task enumeration).
     function meansAll(tokens) {
-        return tokens.some((t) => t.toLowerCase() === 'all' || t === '*');
+        return tokens.some((t) => t.toLowerCase() === "all" || t === "*");
     }
     // The router checks finished tasks off by title or id (castle-done fence),
     // or "all" to clear every finished row off the board at once.
     function checkOff(tokens) {
         const ids = meansAll(tokens)
-            ? [...tasks.values()].filter((t) => isTerminal(t.status) && !t.acknowledged).map((t) => t.id)
+            ? [...tasks.values()]
+                .filter((t) => isTerminal(t.status) && !t.acknowledged)
+                .map((t) => t.id)
             : resolveDeps(tasks, tokens);
         for (const id of ids)
             acknowledge(id, false);
@@ -684,17 +761,17 @@ function createTaskStore(opts) {
     // killed and is cleared when it finalizes (the stopRequested path acks it).
     // No-op on terminal tasks.
     function haltTask(task) {
-        if (task.status === 'waiting') {
-            task.status = 'interrupted';
+        if (task.status === "waiting") {
+            task.status = "interrupted";
             task.acknowledged = true;
             touch(task);
         }
-        else if (task.status === 'running') {
+        else if (task.status === "running") {
             stopRequested.add(task.id);
             for (const child of children) {
                 if (child.pid === task.pid) {
                     try {
-                        child.kill('SIGKILL');
+                        child.kill("SIGKILL");
                     }
                     catch {
                         /* already gone */
@@ -706,7 +783,7 @@ function createTaskStore(opts) {
     function stop(tokens) {
         const ids = meansAll(tokens)
             ? [...tasks.values()]
-                .filter((t) => t.status === 'running' || t.status === 'waiting')
+                .filter((t) => t.status === "running" || t.status === "waiting")
                 .map((t) => t.id)
             : resolveDeps(tasks, tokens);
         for (const id of ids) {
@@ -715,15 +792,23 @@ function createTaskStore(opts) {
                 haltTask(task);
         }
     }
-    return { sorted, get: (id) => tasks.get(id), spawnFromDirective, acknowledge, checkOff, stop, shutdown };
+    return {
+        sorted,
+        get: (id) => tasks.get(id),
+        spawnFromDirective,
+        acknowledge,
+        checkOff,
+        stop,
+        shutdown,
+    };
 }
 // -- attachments ----------------------------------------------------------------
 const ATTACHMENT_MIME = {
-    png: 'image/png',
-    jpg: 'image/jpeg',
-    jpeg: 'image/jpeg',
-    gif: 'image/gif',
-    webp: 'image/webp',
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
 };
 // Decode pasted/attached images (data URLs) into .castle/agent/attachments/.
 // Returns the saved file names.
@@ -733,16 +818,17 @@ function saveAttachments(attachmentsDir, messageId, images) {
     const saved = [];
     for (const [index, image] of images.slice(0, MAX_ATTACHMENTS).entries()) {
         const dataUrl = image?.dataUrl;
-        if (typeof dataUrl !== 'string' || dataUrl.length > MAX_ATTACHMENT_BYTES * 1.4)
+        if (typeof dataUrl !== "string" ||
+            dataUrl.length > MAX_ATTACHMENT_BYTES * 1.4)
             continue;
         const match = /^data:image\/(png|jpe?g|gif|webp);base64,([A-Za-z0-9+/=]+)$/.exec(dataUrl);
         if (!match)
             continue;
-        const ext = match[1] === 'jpeg' ? 'jpg' : match[1];
+        const ext = match[1] === "jpeg" ? "jpg" : match[1];
         const fileName = `${messageId}-${index}.${ext}`;
         try {
             fs.mkdirSync(attachmentsDir, { recursive: true });
-            fs.writeFileSync(path.join(attachmentsDir, fileName), Buffer.from(match[2], 'base64'));
+            fs.writeFileSync(path.join(attachmentsDir, fileName), Buffer.from(match[2], "base64"));
             saved.push(fileName);
         }
         catch {
@@ -755,7 +841,7 @@ function asPromptTask(task) {
     return {
         id: task.id,
         title: task.title,
-        status: task.rejected ? 'rejected by user' : task.status,
+        status: task.rejected ? "rejected by user" : task.status,
         progress: task.progress,
         notes: task.notes,
     };
@@ -773,33 +859,38 @@ function createTaskFeeds(broadcast) {
         feed.push(entry);
         if (feed.length > 80)
             feed.splice(0, feed.length - 80);
-        broadcast({ type: 'task-feed', id: task.id, entry });
+        broadcast({ type: "task-feed", id: task.id, entry });
     }
     return { map, push };
 }
 function createMessageLog(messagesPath, broadcast) {
     const loaded = readJsonFile(messagesPath) ?? [];
     const messages = loaded
-        .filter((m) => m.text.trim() !== '' || m.role === 'user')
-        .map((m) => (m.status === 'streaming' ? { ...m, status: 'done' } : m));
+        .filter((m) => m.text.trim() !== "" || m.role === "user")
+        .map((m) => m.status === "streaming" ? { ...m, status: "done" } : m);
     function persist() {
-        fs.writeFileSync(messagesPath, JSON.stringify(messages, null, 2) + '\n');
+        fs.writeFileSync(messagesPath, JSON.stringify(messages, null, 2) + "\n");
     }
     function add(message) {
         messages.push(message);
         persist();
-        broadcast({ type: 'message-add', message });
+        broadcast({ type: "message-add", message });
     }
     function addLog(text) {
-        add({ id: nanoid(8), role: 'log', text, at: nowIso(), status: 'done' });
+        add({ id: nanoid(8), role: "log", text, at: nowIso(), status: "done" });
     }
     // Consecutive same-prefix log lines collapse into one ("working on: A, B").
     function addGroupedLog(prefix, item) {
         const last = messages[messages.length - 1];
-        if (last && last.role === 'log' && last.text.startsWith(prefix)) {
+        if (last && last.role === "log" && last.text.startsWith(prefix)) {
             last.text += `, ${item}`;
             persist();
-            broadcast({ type: 'message-done', id: last.id, text: last.text, status: 'done' });
+            broadcast({
+                type: "message-done",
+                id: last.id,
+                text: last.text,
+                status: "done",
+            });
             return;
         }
         addLog(`${prefix}${item}`);
@@ -812,14 +903,14 @@ function makeAttachmentHandler(attachmentsDir) {
         if (!reqPath.startsWith(AGENT_ATTACHMENT_PREFIX))
             return false;
         const name = path.basename(reqPath.slice(AGENT_ATTACHMENT_PREFIX.length));
-        const ext = name.split('.').pop() ?? '';
+        const ext = name.split(".").pop() ?? "";
         const mime = ATTACHMENT_MIME[ext];
         const filePath = path.join(attachmentsDir, name);
         if (!mime || !fs.existsSync(filePath)) {
             res.writeHead(404).end();
             return true;
         }
-        res.writeHead(200, { 'content-type': mime, 'cache-control': 'no-store' });
+        res.writeHead(200, { "content-type": mime, "cache-control": "no-store" });
         fs.createReadStream(filePath).pipe(res);
         return true;
     };
@@ -830,20 +921,20 @@ function runRouterTurnIn(ctx, instruction) {
     const epoch = ctx.currentEpoch();
     const message = {
         id: nanoid(8),
-        role: 'assistant',
-        text: '',
+        role: "assistant",
+        text: "",
         at: nowIso(),
-        status: 'streaming',
+        status: "streaming",
     };
     ctx.log.messages.push(message);
-    ctx.broadcast({ type: 'message-add', message });
-    let raw = '';
+    ctx.broadcast({ type: "message-add", message });
+    let raw = "";
     let visibleSent = 0;
     let lastActivity = null;
     const prompt = buildRouterPrompt({
         deckLabel: ctx.deckLabel,
         messages: ctx.log.messages
-            .filter((m) => m.role !== 'log' && m.id !== message.id && m.status !== 'streaming')
+            .filter((m) => m.role !== "log" && m.id !== message.id && m.status !== "streaming")
             .map((m) => ({
             role: m.role,
             text: m.text,
@@ -859,14 +950,14 @@ function runRouterTurnIn(ctx, instruction) {
         instruction,
     });
     const backend = ctx.backend();
-    const invocation = buildAgentInvocation(backend, 'router', prompt, ctx.claudeModel());
+    const invocation = buildAgentInvocation(backend, "router", prompt, ctx.claudeModel());
     void runAgentCli({
         cwd: ctx.deckDir,
         command: invocation.command,
         args: invocation.args,
         parser: backend,
         timeoutMs: ROUTER_TIMEOUT_MS,
-        logPath: path.join(ctx.agentDir, 'router-log.jsonl'),
+        logPath: path.join(ctx.agentDir, "router-log.jsonl"),
         children: ctx.children,
         onDelta: (delta) => {
             raw += delta;
@@ -875,24 +966,24 @@ function runRouterTurnIn(ctx, instruction) {
                 const slice = raw.slice(visibleSent, visible);
                 visibleSent = visible;
                 message.text += slice;
-                ctx.broadcast({ type: 'message-delta', id: message.id, delta: slice });
+                ctx.broadcast({ type: "message-delta", id: message.id, delta: slice });
             }
         },
         onActivity: (activity) => {
             if (activity === lastActivity)
                 return;
             lastActivity = activity;
-            ctx.broadcast({ type: 'message-activity', id: message.id, activity });
+            ctx.broadcast({ type: "message-activity", id: message.id, activity });
         },
     }).then((result) => {
         const interrupted = epoch !== ctx.currentEpoch() && !result.ok;
         if (interrupted) {
             // Keep whatever streamed; the continuation turn carries the draft.
-            message.status = 'done';
+            message.status = "done";
             message.interrupted = true;
             ctx.log.persist();
             ctx.broadcast({
-                type: 'message-done',
+                type: "message-done",
                 id: message.id,
                 text: message.text,
                 status: message.status,
@@ -911,19 +1002,21 @@ function runRouterTurnIn(ctx, instruction) {
         const stale = epoch !== ctx.currentEpoch();
         const inFlight = new Set(ctx.taskStore
             .sorted()
-            .filter((t) => t.status === 'running' || t.status === 'waiting')
+            .filter((t) => t.status === "running" || t.status === "waiting")
             .map((t) => t.title.toLowerCase()));
-        const toSpawn = stale ? [] : directives.filter((d) => !inFlight.has(d.title.toLowerCase()));
+        const toSpawn = stale
+            ? []
+            : directives.filter((d) => !inFlight.has(d.title.toLowerCase()));
         const taskIds = toSpawn.map((d) => ctx.taskStore.spawnFromDirective(d, message.id));
         message.text = result.ok
             ? cleaned
-            : `${cleaned ? cleaned + '\n\n' : ''}[router error: ${result.error ?? 'unknown'}]`;
-        message.status = result.ok ? 'done' : 'error';
+            : `${cleaned ? cleaned + "\n\n" : ""}[router error: ${result.error ?? "unknown"}]`;
+        message.status = result.ok ? "done" : "error";
         if (taskIds.length > 0)
             message.taskIds = taskIds;
         ctx.log.persist();
         ctx.broadcast({
-            type: 'message-done',
+            type: "message-done",
             id: message.id,
             text: message.text,
             status: message.status,
@@ -935,7 +1028,7 @@ function runRouterTurnIn(ctx, instruction) {
 function applyAgentSettings(incoming, ctx) {
     const { settings } = ctx;
     const changes = [];
-    for (const key of ['router', 'tasks']) {
+    for (const key of ["router", "tasks"]) {
         const value = normalizeBackend(incoming[key]);
         if (value && value !== settings[key]) {
             settings[key] = value;
@@ -949,20 +1042,20 @@ function applyAgentSettings(incoming, ctx) {
     }
     if (changes.length === 0)
         return;
-    fs.writeFileSync(ctx.settingsPath, JSON.stringify(settings, null, 2) + '\n');
-    ctx.broadcast({ type: 'settings', settings });
+    fs.writeFileSync(ctx.settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    ctx.broadcast({ type: "settings", settings });
 }
 function killOrphanAgents(registryPath) {
     const recorded = readJsonFile(registryPath) ?? [];
     for (const entry of recorded) {
-        if (typeof entry?.pid !== 'number')
+        if (typeof entry?.pid !== "number")
             continue;
         try {
-            const cmd = execFileSync('ps', ['-p', String(entry.pid), '-o', 'command='], {
-                encoding: 'utf8',
+            const cmd = execFileSync("ps", ["-p", String(entry.pid), "-o", "command="], {
+                encoding: "utf8",
             }).trim();
-            if (cmd.includes('cursor-agent') || cmd.includes('claude')) {
-                process.kill(entry.pid, 'SIGKILL');
+            if (cmd.includes("cursor-agent") || cmd.includes("claude")) {
+                process.kill(entry.pid, "SIGKILL");
             }
         }
         catch {
@@ -970,19 +1063,19 @@ function killOrphanAgents(registryPath) {
         }
     }
     try {
-        fs.writeFileSync(registryPath, '[]\n');
+        fs.writeFileSync(registryPath, "[]\n");
     }
     catch {
         /* registry dir missing -- created later */
     }
 }
 function startChildRegistry(registryPath, groups) {
-    let last = '';
+    let last = "";
     const timer = setInterval(() => {
         const live = [];
         for (const group of groups) {
             for (const child of group) {
-                if (typeof child.pid === 'number' && child.exitCode === null) {
+                if (typeof child.pid === "number" && child.exitCode === null) {
                     live.push({ pid: child.pid, command: child.spawnfile });
                 }
             }
@@ -992,7 +1085,7 @@ function startChildRegistry(registryPath, groups) {
             return;
         last = snapshot;
         try {
-            fs.writeFileSync(registryPath, snapshot + '\n');
+            fs.writeFileSync(registryPath, snapshot + "\n");
         }
         catch {
             /* best effort */
@@ -1001,7 +1094,7 @@ function startChildRegistry(registryPath, groups) {
     return () => {
         clearInterval(timer);
         try {
-            fs.writeFileSync(registryPath, '[]\n');
+            fs.writeFileSync(registryPath, "[]\n");
         }
         catch {
             /* best effort */
@@ -1010,19 +1103,22 @@ function startChildRegistry(registryPath, groups) {
 }
 export function createAgentServer(opts) {
     const { deckDir, deckLabel } = opts;
-    const agentDir = path.join(deckDir, '.castle', 'agent');
-    const tasksDir = path.join(agentDir, 'tasks');
-    const attachmentsDir = path.join(agentDir, 'attachments');
-    const messagesPath = path.join(agentDir, 'messages.json');
+    const agentDir = path.join(deckDir, ".castle", "agent");
+    const tasksDir = path.join(agentDir, "tasks");
+    const attachmentsDir = path.join(agentDir, "attachments");
+    const messagesPath = path.join(agentDir, "messages.json");
     fs.mkdirSync(tasksDir, { recursive: true });
     const taskChildren = new Set();
     const routerChildren = new Set();
     const clients = new Set();
     // Kill agent processes orphaned by a previous serve that died uncleanly,
     // then start tracking this serve's own children.
-    const childRegistryPath = path.join(agentDir, 'children.json');
+    const childRegistryPath = path.join(agentDir, "children.json");
     killOrphanAgents(childRegistryPath);
-    const stopChildRegistry = startChildRegistry(childRegistryPath, [taskChildren, routerChildren]);
+    const stopChildRegistry = startChildRegistry(childRegistryPath, [
+        taskChildren,
+        routerChildren,
+    ]);
     function broadcast(body) {
         const payload = JSON.stringify(body);
         for (const socket of clients) {
@@ -1035,12 +1131,13 @@ export function createAgentServer(opts) {
     const addLog = (text) => log.addLog(text);
     // Which CLI backs the router and the task agents -- independently
     // switchable from the settings popover, persisted next to the chat state.
-    const settingsPath = path.join(agentDir, 'settings.json');
+    const settingsPath = path.join(agentDir, "settings.json");
     const storedSettings = readJsonFile(settingsPath);
     const settings = {
         router: normalizeBackend(storedSettings?.router) ?? DEFAULT_SETTINGS.router,
         tasks: normalizeBackend(storedSettings?.tasks) ?? DEFAULT_SETTINGS.tasks,
-        claudeModel: normalizeClaudeModel(storedSettings?.claudeModel) ?? DEFAULT_SETTINGS.claudeModel,
+        claudeModel: normalizeClaudeModel(storedSettings?.claudeModel) ??
+            DEFAULT_SETTINGS.claudeModel,
     };
     const applySettings = (incoming) => applyAgentSettings(incoming, { settings, settingsPath, broadcast });
     const taskFeeds = createTaskFeeds(broadcast);
@@ -1052,7 +1149,7 @@ export function createAgentServer(opts) {
         backend: () => settings.tasks,
         claudeModel: () => settings.claudeModel,
         // Task lifecycle stays on the board only -- log lines for it were spam.
-        onUpdate: (task) => broadcast({ type: 'task-update', task }),
+        onUpdate: (task) => broadcast({ type: "task-update", task }),
         onStarted: () => undefined,
         onRetry: (task, attempt) => addLog(`agent died, retrying (${attempt}/${MAX_TASK_ATTEMPTS}): ${task.title}`),
         onFinished: (task) => taskFeeds.map.delete(task.id),
@@ -1064,18 +1161,18 @@ export function createAgentServer(opts) {
     let userEpoch = 0;
     function interruptRouterRuns() {
         const drafts = messages
-            .filter((m) => m.role === 'assistant' && m.status === 'streaming')
+            .filter((m) => m.role === "assistant" && m.status === "streaming")
             .map((m) => m.text.trim())
             .filter(Boolean);
         for (const child of routerChildren) {
             try {
-                child.kill('SIGKILL');
+                child.kill("SIGKILL");
             }
             catch {
                 /* already gone */
             }
         }
-        return drafts.join('\n\n');
+        return drafts.join("\n\n");
     }
     function runRouterTurn(instruction) {
         runRouterTurnIn({
@@ -1098,12 +1195,12 @@ export function createAgentServer(opts) {
         let lastAnswered = -1;
         for (let i = messages.length - 1; i >= 0; i--) {
             const m = messages[i];
-            if (m.role === 'assistant' && m.status === 'done' && !m.interrupted) {
+            if (m.role === "assistant" && m.status === "done" && !m.interrupted) {
                 lastAnswered = i;
                 break;
             }
         }
-        return messages.slice(lastAnswered + 1).filter((m) => m.role === 'user');
+        return messages.slice(lastAnswered + 1).filter((m) => m.role === "user");
     }
     function handleUserMessage(text, images) {
         userEpoch += 1;
@@ -1112,10 +1209,10 @@ export function createAgentServer(opts) {
         const attachments = saveAttachments(attachmentsDir, messageId, images);
         const message = {
             id: messageId,
-            role: 'user',
+            role: "user",
             text,
             at: nowIso(),
-            status: 'done',
+            status: "done",
         };
         if (attachments.length > 0)
             message.attachments = attachments;
@@ -1128,7 +1225,7 @@ export function createAgentServer(opts) {
             interruptedDraft: interruptedDraft || undefined,
             attachments: pending
                 .flatMap((m) => m.attachments ?? [])
-                .map((name) => path.join('.castle', 'agent', 'attachments', name)),
+                .map((name) => path.join(".castle", "agent", "attachments", name)),
         }));
     }
     function handleTaskAck(id, rejected) {
@@ -1137,9 +1234,15 @@ export function createAgentServer(opts) {
     const wss = new WebSocketServer({ noServer: true });
     function attachClient(socket) {
         clients.add(socket);
-        const hello = { type: 'hello', messages, tasks: taskStore.sorted(), settings, feeds: Object.fromEntries(taskFeeds.map) };
+        const hello = {
+            type: "hello",
+            messages,
+            tasks: taskStore.sorted(),
+            settings,
+            feeds: Object.fromEntries(taskFeeds.map),
+        };
         socket.send(JSON.stringify(hello));
-        socket.on('message', (rawData) => {
+        socket.on("message", (rawData) => {
             let msg;
             try {
                 msg = JSON.parse(rawDataToString(rawData));
@@ -1147,24 +1250,24 @@ export function createAgentServer(opts) {
             catch {
                 return;
             }
-            const hasText = typeof msg.text === 'string' && msg.text.trim() !== '';
+            const hasText = typeof msg.text === "string" && msg.text.trim() !== "";
             const hasImages = Array.isArray(msg.images) && msg.images.length > 0;
-            if (msg.type === 'user-message' && (hasText || hasImages)) {
-                handleUserMessage(typeof msg.text === 'string' ? msg.text.trim() : '', msg.images);
+            if (msg.type === "user-message" && (hasText || hasImages)) {
+                handleUserMessage(typeof msg.text === "string" ? msg.text.trim() : "", msg.images);
             }
-            else if (msg.type === 'task-ack' && typeof msg.id === 'string') {
+            else if (msg.type === "task-ack" && typeof msg.id === "string") {
                 handleTaskAck(msg.id, msg.rejected === true);
             }
-            else if (msg.type === 'set-settings') {
+            else if (msg.type === "set-settings") {
                 applySettings(msg);
             }
         });
-        socket.on('close', () => {
+        socket.on("close", () => {
             clients.delete(socket);
         });
     }
     function handleUpgrade(req, socket, head) {
-        const url = new URL(req.url ?? '/', 'http://localhost');
+        const url = new URL(req.url ?? "/", "http://localhost");
         if (url.pathname !== AGENT_WS_PATH)
             return false;
         wss.handleUpgrade(req, socket, head, (ws) => attachClient(ws));
@@ -1175,7 +1278,7 @@ export function createAgentServer(opts) {
         taskStore.shutdown();
         for (const child of [...taskChildren, ...routerChildren]) {
             try {
-                child.kill('SIGKILL');
+                child.kill("SIGKILL");
             }
             catch {
                 /* already gone */