castle-web-cli 0.4.115 → 0.4.116

package/dist/agent.js

@@ -14,67 +14,66 @@
 // 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";
-import { checkOpenrouterKey, checkOpenrouterModel, openrouterCatalogEntry, primeOpenrouterCatalog, } from "./openrouter-catalog.js";
-import { classifyProviderError, failureCopy, setReaderTimeZone, } from "./agent-failures.js";
-import { fetchBudget, meteringHeaders, newAgentSessionId, reportCursorRun, withCustomHeaders, } from "./metering.js";
-import { anthropicKeyHelperCommand, claudeHasSavedLogin, cursorAuthPath, cursorHasUserLogin, resolveAnthropicAuth, userKey, ANTHROPIC_CREDENTIAL_ENV, ANTHROPIC_PROXY_ENV, CASTLE_USER_KEYS_PATH, } from "./byo-auth.js";
-import { accountsSnapshot, loginProviderFor, watchCredentials, writeCredential, } from "./byo-accounts.js";
-import { cancelLogin, logout, startLogin, submitLoginCode, } from "./byo-login.js";
-import { runAgentNative } from "./native/loop.js";
-import { createPlaytestBrowserManager } from "./native/playtest-browser.js";
-import { createPlaywrightPlaytestExecutor } from "./native/playtest-executor.js";
-export const AGENT_WS_PATH = "/__castle/agent";
-export const AGENT_ATTACHMENT_PREFIX = "/__castle/agent/attachments/";
+import { execFileSync, spawn } from 'child_process';
+import { IMPORTS_DIR } from './imports.js';
+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';
+import { checkOpenrouterKey, checkOpenrouterModel, openrouterCatalogEntry, primeOpenrouterCatalog, } from './openrouter-catalog.js';
+import { classifyProviderError, failureCopy, setReaderTimeZone, } from './agent-failures.js';
+import { fetchBudget, meteringHeaders, newAgentSessionId, reportCursorRun, withCustomHeaders, } from './metering.js';
+import { anthropicKeyHelperCommand, claudeHasSavedLogin, cursorAuthPath, cursorHasUserLogin, resolveAnthropicAuth, userKey, ANTHROPIC_CREDENTIAL_ENV, ANTHROPIC_PROXY_ENV, CASTLE_USER_KEYS_PATH, } from './byo-auth.js';
+import { accountsSnapshot, loginProviderFor, watchCredentials, writeCredential, } from './byo-accounts.js';
+import { cancelLogin, logout, startLogin, submitLoginCode } from './byo-login.js';
+import { runAgentNative } from './native/loop.js';
+import { createPlaytestBrowserManager, } from './native/playtest-browser.js';
+import { createPlaywrightPlaytestExecutor } from './native/playtest-executor.js';
+export const AGENT_WS_PATH = '/__castle/agent';
+export const AGENT_ATTACHMENT_PREFIX = '/__castle/agent/attachments/';
 // Playtest frame PNGs (tasks/<id>/playtest/<file>.png), served for the
 // finished-task card's thumbnails -- see makePlaytestFrameHandler.
-export const AGENT_PLAYTEST_PREFIX = "/__castle/agent/playtest/";
+export const AGENT_PLAYTEST_PREFIX = '/__castle/agent/playtest/';
 // Same-origin proxy for OpenRouter model capabilities (avoids browser CORS
 // against openrouter.ai). GET ?model=<slug> -> ModelCaps JSON. Powers the
 // settings popover's dynamic reasoning-effort / provider-tier pickers.
-export const AGENT_MODEL_CAPS_PREFIX = "/__castle/agent/model-caps";
+export const AGENT_MODEL_CAPS_PREFIX = '/__castle/agent/model-caps';
 const DEFAULT_SETTINGS = {
-    router: "claude",
-    tasks: "claude",
+    router: 'claude',
+    tasks: 'claude',
     // Both roles run the claude CLI routed through OpenRouter at the slug below.
     // Note this takes the Anthropic credential out of play entirely: a role on
     // "openrouter" resolves OpenRouter auth, so a user's `claude /login` or
     // ANTHROPIC_API_KEY no longer applies (see buildAgentInvocation).
-    routerClaudeModel: "openrouter",
-    tasksClaudeModel: "openrouter",
+    routerClaudeModel: 'openrouter',
+    tasksClaudeModel: 'openrouter',
     // Free-form -- change to any OpenRouter slug.
-    routerOpenrouterModel: "openai/gpt-5.6-terra",
-    tasksOpenrouterModel: "openai/gpt-5.6-terra",
+    routerOpenrouterModel: 'openai/gpt-5.6-terra',
+    tasksOpenrouterModel: 'openai/gpt-5.6-terra',
     // Both roles think at "medium": the operator stays snappy (the user waits
     // on every operator turn), and task agents' multi-turn tool loops don't pay
     // reasoning tax on mechanical read/edit/run turns. Deep decomposition
     // quality comes from the operator prompt, not a higher effort default.
-    routerReasoningEffort: "medium",
-    tasksReasoningEffort: "medium",
+    routerReasoningEffort: 'medium',
+    tasksReasoningEffort: 'medium',
     // Routing splits by what each role optimizes for: the interactive operator
     // routes for speed (nitro = throughput-sorted endpoints), unattended task
     // agents route for correctness (exacto = benchmark-accurate endpoints,
     // which matters for tool-calling fidelity over long loops).
-    routerRouting: "nitro",
-    tasksRouting: "exacto",
+    routerRouting: 'nitro',
+    tasksRouting: 'exacto',
     // Operator pins OpenAI's priority (low-latency SLA) tier; harmless with a
     // slug that lacks it since the pin falls back when the tag doesn't exist
     // (allow_fallbacks). Tasks stay on auto: high-volume background turns
     // should ride the cheapest available capacity.
-    routerProviderTier: "openai/priority",
-    tasksProviderTier: "",
+    routerProviderTier: 'openai/priority',
+    tasksProviderTier: '',
 };
 function normalizeBackend(value) {
-    return value === "cursor" || value === "claude" || value === "smith"
-        ? value
-        : null;
+    return value === 'cursor' || value === 'claude' || value === 'smith' ? value : null;
 }
 // Bump to force every deck onto the current DEFAULT_SETTINGS once, discarding
 // what users had chosen: a stored file below this epoch has ALL of its setting
@@ -85,10 +84,7 @@ function normalizeBackend(value) {
 // only worth writing if it must survive the epoch that introduces it.
 const SETTINGS_EPOCH = 1;
 function normalizeClaudeModel(value) {
-    return value === "sonnet" ||
-        value === "opus" ||
-        value === "fable" ||
-        value === "openrouter"
+    return value === 'sonnet' || value === 'opus' || value === 'fable' || value === 'openrouter'
         ? value
         : null;
 }
@@ -97,9 +93,9 @@ function normalizeClaudeModel(value) {
 // is the one place that knows both, so the model picker and the pre-flight
 // refusal can't disagree about which models a user actually has.
 const CLAUDE_MODEL_ID_PREFIXES = {
-    sonnet: "claude-sonnet-",
-    opus: "claude-opus-",
-    fable: "claude-fable-",
+    sonnet: 'claude-sonnet-',
+    opus: 'claude-opus-',
+    fable: 'claude-fable-',
 };
 // Blocked when the two prefixes agree as far as the shorter one goes: the proxy
 // may name a family ("claude-fable-") or one model within it.
@@ -113,7 +109,7 @@ function claudeModelBlocked(model, budget) {
 // against a stray huge paste landing in settings.json / the CLI argv).
 const OPENROUTER_MODEL_MAX_LEN = 200;
 function normalizeOpenrouterModel(value) {
-    if (typeof value !== "string")
+    if (typeof value !== 'string')
         return null;
     const trimmed = value.trim();
     return trimmed && trimmed.length <= OPENROUTER_MODEL_MAX_LEN ? trimmed : null;
@@ -123,29 +119,22 @@ function normalizeOpenrouterModel(value) {
 // fetches them from the model-caps endpoint to build the picker) and
 // OpenRouter maps an unsupported level to the nearest one anyway.
 const REASONING_EFFORTS = [
-    "none",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max",
+    'none',
+    'minimal',
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max',
 ];
 function normalizeReasoningEffort(value) {
     return REASONING_EFFORTS.includes(value)
         ? value
         : null;
 }
-const ROUTING_MODES = [
-    "balanced",
-    "nitro",
-    "exacto",
-    "floor",
-];
+const ROUTING_MODES = ['balanced', 'nitro', 'exacto', 'floor'];
 function normalizeRoutingMode(value) {
-    return ROUTING_MODES.includes(value)
-        ? value
-        : null;
+    return ROUTING_MODES.includes(value) ? value : null;
 }
 // Provider tier is an OpenRouter endpoint `tag` ("openai/flex", "azure/eu",
 // ...) which is model-specific, so validation is loose like the model slug.
@@ -153,7 +142,7 @@ function normalizeRoutingMode(value) {
 // this returns "" rather than null for the clear case -- callers must treat
 // null (invalid) and "" (clear) differently.
 function normalizeProviderTier(value) {
-    if (typeof value !== "string")
+    if (typeof value !== 'string')
         return null;
     const trimmed = value.trim();
     if (trimmed.length > OPENROUTER_MODEL_MAX_LEN)
@@ -193,11 +182,11 @@ function serializeAgentSettings(settings) {
         if (settings[key] !== DEFAULT_SETTINGS[key])
             out[key] = settings[key];
     }
-    return JSON.stringify(out, null, 2) + "\n";
+    return JSON.stringify(out, null, 2) + '\n';
 }
 function loadAgentSettings(settingsPath) {
     const stored = readJsonFile(settingsPath);
-    const storedEpoch = typeof stored?.settingsEpoch === "number" ? stored.settingsEpoch : 0;
+    const storedEpoch = typeof stored?.settingsEpoch === 'number' ? stored.settingsEpoch : 0;
     // A stale file is ignored, not rewritten: leaving it means the wipe is a
     // pure read-side decision that repeats harmlessly until the user's next real
     // change overwrites it in the sparse shape. A newer epoch (a downgraded CLI
@@ -225,7 +214,7 @@ function loadAgentSettings(settingsPath) {
 // the /v1 the CLI re-adds. Otherwise openrouter.ai directly.
 function openrouterAnthropicBase() {
     const injected = process.env.OPENROUTER_BASE_URL;
-    return injected ? injected.replace(/\/v1\/?$/, "") : "https://openrouter.ai/api";
+    return injected ? injected.replace(/\/v1\/?$/, '') : 'https://openrouter.ai/api';
 }
 // Env for a claude CLI spawn routed at OpenRouter (claudeModel "openrouter",
 // Path A). Two things make this deterministic regardless of the user's own
@@ -256,21 +245,21 @@ function openrouterAnthropicBase() {
 // ANTHROPIC_BASE_URL for a user's OWN OpenRouter key -- straight to openrouter.ai
 // (the CLI appends /v1/messages), bypassing the proxy. The proxy branch instead
 // uses openrouterAnthropicBase() (the injected OPENROUTER_BASE_URL origin).
-const OPENROUTER_DIRECT_ANTHROPIC_BASE = "https://openrouter.ai/api";
+const OPENROUTER_DIRECT_ANTHROPIC_BASE = 'https://openrouter.ai/api';
 // OpenAI-shaped chat-completions ORIGIN for the smith native loop on a user's
 // own OpenRouter key (native/openrouter.ts appends /chat/completions).
-const OPENROUTER_DIRECT_CHAT_BASE = "https://openrouter.ai/api/v1";
+const OPENROUTER_DIRECT_CHAT_BASE = 'https://openrouter.ai/api/v1';
 function envForOpenrouterSpawn(auth) {
     if (!auth.key) {
         // Unreachable via runAgentTurn (pre-flight rejects a keyless run before
         // any spawn). A backstop, so a future caller that skips pre-flight fails
         // loudly instead of quietly leaking.
-        throw new Error("envForOpenrouterSpawn: refusing to spawn without an OpenRouter key");
+        throw new Error('envForOpenrouterSpawn: refusing to spawn without an OpenRouter key');
     }
     const env = { ...process.env };
     for (const name of ANTHROPIC_CREDENTIAL_ENV)
         delete env[name];
-    if (auth.mode === "user-key") {
+    if (auth.mode === 'user-key') {
         env.ANTHROPIC_BASE_URL = OPENROUTER_DIRECT_ANTHROPIC_BASE;
         // An inherited ANTHROPIC_CUSTOM_HEADERS can carry x-castle-* metering
         // lines (see ANTHROPIC_PROXY_ENV) -- never forward those on a direct run.
@@ -279,7 +268,7 @@ function envForOpenrouterSpawn(auth) {
     else {
         env.ANTHROPIC_BASE_URL = openrouterAnthropicBase();
     }
-    env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
+    env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = '1';
     env.ANTHROPIC_AUTH_TOKEN = auth.key;
     return env;
 }
@@ -288,15 +277,15 @@ function envForOpenrouterSpawn(auth) {
 // claude-via-OpenRouter spawn sends it as ANTHROPIC_AUTH_TOKEN (see
 // envForOpenrouterSpawn). Castle-provided key file first, env fallback --
 // same sourcing order as envForAgentSpawn.
-const OPENROUTER_KEY_NAME = "OPENROUTER_API_KEY";
+const OPENROUTER_KEY_NAME = 'OPENROUTER_API_KEY';
 function openrouterApiKey() {
-    return castleKeys()[OPENROUTER_KEY_NAME] ?? process.env[OPENROUTER_KEY_NAME] ?? "";
+    return castleKeys()[OPENROUTER_KEY_NAME] ?? process.env[OPENROUTER_KEY_NAME] ?? '';
 }
 const MODEL_CAPS_TTL_MS = 10 * 60_000;
-const OPENROUTER_API_BASE = "https://openrouter.ai/api/v1";
+const OPENROUTER_API_BASE = 'https://openrouter.ai/api/v1';
 const modelCapsCache = new Map();
 function asRecord(v) {
-    return v && typeof v === "object" ? v : null;
+    return v && typeof v === 'object' ? v : null;
 }
 async function openrouterProviderTiers(slug) {
     const res = await fetch(`${OPENROUTER_API_BASE}/models/${slug}/endpoints`);
@@ -308,7 +297,7 @@ async function openrouterProviderTiers(slug) {
     const tags = [];
     for (const ep of endpoints) {
         const rec = asRecord(ep);
-        const tag = rec && typeof rec.tag === "string" ? rec.tag : null;
+        const tag = rec && typeof rec.tag === 'string' ? rec.tag : null;
         if (tag && !tags.includes(tag))
             tags.push(tag);
     }
@@ -332,14 +321,11 @@ async function fetchModelCaps(slug) {
         const efforts = reasoning?.supported_efforts;
         const supportedParams = entry?.supportedParameters;
         const acceptsEffort = Array.isArray(supportedParams) &&
-            (supportedParams.includes("reasoning_effort") ||
-                supportedParams.includes("reasoning"));
+            (supportedParams.includes('reasoning_effort') || supportedParams.includes('reasoning'));
         if (acceptsEffort && Array.isArray(efforts) && efforts.length > 0) {
-            reasoningEfforts = efforts.filter((e) => typeof e === "string");
+            reasoningEfforts = efforts.filter((e) => typeof e === 'string');
             defaultEffort =
-                typeof reasoning?.default_effort === "string"
-                    ? reasoning.default_effort
-                    : null;
+                typeof reasoning?.default_effort === 'string' ? reasoning.default_effort : null;
         }
     }
     catch {
@@ -367,25 +353,25 @@ async function fetchModelCaps(slug) {
 function handleModelCaps(req, res) {
     const send = (status, body) => {
         res.writeHead(status, {
-            "content-type": "application/json",
-            "cache-control": "no-store",
+            'content-type': 'application/json',
+            'cache-control': 'no-store',
         });
         res.end(JSON.stringify(body));
         return true;
     };
-    let slug = "";
+    let slug = '';
     try {
-        slug = (new URL(req.url ?? "", "http://localhost").searchParams.get("model") ?? "").trim();
+        slug = (new URL(req.url ?? '', 'http://localhost').searchParams.get('model') ?? '').trim();
     }
     catch {
-        slug = "";
+        slug = '';
     }
     if (!slug || slug.length > OPENROUTER_MODEL_MAX_LEN) {
-        return send(400, { error: "missing or invalid model" });
+        return send(400, { error: 'missing or invalid model' });
     }
     // Strip any routing suffix the client may have on the displayed slug so the
     // OpenRouter lookup hits the base model id.
-    const baseSlug = slug.replace(/:(nitro|exacto|floor)$/, "");
+    const baseSlug = slug.replace(/:(nitro|exacto|floor)$/, '');
     fetchModelCaps(baseSlug)
         .then((caps) => send(200, caps))
         .catch(() => send(200, {
@@ -418,10 +404,10 @@ function handleModelCaps(req, res) {
 // to plain-claude spawns, where auto still resolves correctly.
 // Single `=` token because --allowedTools is variadic and would otherwise
 // swallow the trailing prompt positional.
-const OPENROUTER_ALLOWED_TOOLS = "--allowedTools=Edit,Write,NotebookEdit,Bash";
+const OPENROUTER_ALLOWED_TOOLS = '--allowedTools=Edit,Write,NotebookEdit,Bash';
 // Cursor's proprietary model. Also the slug reported to the metering ledger, so
 // the two can never drift into disagreeing about what a cursor row ran on.
-const CURSOR_MODEL = "composer-2.5-fast";
+const CURSOR_MODEL = 'composer-2.5-fast';
 // 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. On a user's own Anthropic KEY this also carries the apiKeyHelper that
@@ -429,9 +415,7 @@ const CURSOR_MODEL = "composer-2.5-fast";
 function claudeSettingsArg(auth) {
     return JSON.stringify({
         enabledPlugins: {},
-        ...(auth?.mode === "user-key"
-            ? { apiKeyHelper: anthropicKeyHelperCommand() }
-            : {}),
+        ...(auth?.mode === 'user-key' ? { apiKeyHelper: anthropicKeyHelperCommand() } : {}),
     });
 }
 function buildAgentInvocation(backend, role, prompt, claudeModel, 
@@ -442,74 +426,68 @@ openrouterModel,
 // Only the claude branch can carry it: cursor-agent runs on its own key and
 // never traverses the llm-proxy.
 metering) {
-    if (backend === "claude") {
-        const viaOpenrouter = claudeModel === "openrouter";
+    if (backend === 'claude') {
+        const viaOpenrouter = claudeModel === 'openrouter';
         const orAuth = viaOpenrouter ? resolveOpenrouterAuth() : null;
         const anAuth = viaOpenrouter ? null : resolveAnthropicAuth();
         // Direct = the user's own credential/login is in play, so this run bypasses
         // the proxy and must NOT carry metering headers (metering.ts would otherwise
         // attach them off process.env and the direct spawn would leak them upstream).
-        const direct = viaOpenrouter
-            ? orAuth.mode === "user-key"
-            : anAuth.mode !== "proxy";
+        const direct = viaOpenrouter ? orAuth.mode === 'user-key' : anAuth.mode !== 'proxy';
         return {
-            command: "claude",
+            command: 'claude',
             args: [
-                "-p",
-                "--verbose",
-                "--output-format",
-                "stream-json",
-                "--include-partial-messages",
-                "--permission-mode",
-                "auto",
+                '-p',
+                '--verbose',
+                '--output-format',
+                'stream-json',
+                '--include-partial-messages',
+                '--permission-mode',
+                'auto',
                 ...(viaOpenrouter ? [OPENROUTER_ALLOWED_TOOLS] : []),
-                "--model",
+                '--model',
                 viaOpenrouter ? openrouterModel : claudeModel,
-                "--effort",
-                "medium",
+                '--effort',
+                'medium',
                 // Newer claude models default thinking display to "omitted" (empty
                 // thinking_delta text, signature only); "summarized" restores actual
                 // summary text so the shell's expandable thinking transcript has
                 // content. Slight time-to-first-text cost (the API streams the
                 // summary before prose). Undocumented in --help but honored.
-                "--thinking-display",
-                "summarized",
-                "--settings",
+                '--thinking-display',
+                'summarized',
+                '--settings',
                 claudeSettingsArg(anAuth),
-                "--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,
             ],
-            env: withCustomHeaders(viaOpenrouter
-                ? envForOpenrouterSpawn(orAuth)
-                : envForClaudeSpawn(anAuth), meteringHeaders({
+            env: withCustomHeaders(viaOpenrouter ? envForOpenrouterSpawn(orAuth) : envForClaudeSpawn(anAuth), meteringHeaders({
                 deckDir: metering.deckDir,
                 sessionId: metering.sessionId,
-                route: viaOpenrouter ? "openrouter" : "anthropic",
+                route: viaOpenrouter ? 'openrouter' : 'anthropic',
                 direct,
             })),
         };
     }
     return {
-        command: "cursor-agent",
+        command: 'cursor-agent',
         args: [
-            "-p",
-            "--output-format",
-            "stream-json",
-            "--stream-partial-output",
-            "--trust",
-            "--model",
+            '-p',
+            '--output-format',
+            'stream-json',
+            '--stream-partial-output',
+            '--trust',
+            '--model',
             CURSOR_MODEL,
-            ...(role === "router" ? ["--mode", "ask"] : ["--force"]),
+            ...(role === 'router' ? ['--mode', 'ask'] : ['--force']),
             prompt,
         ],
         env: envForAgentSpawn(backend),
     };
 }
 function parserForBackend(backend) {
-    return backend === "cursor" ? "cursor" : "claude";
+    return backend === 'cursor' ? 'cursor' : 'claude';
 }
 const ROUTER_TIMEOUT_MS = 3 * 60_000;
 const TASK_TIMEOUT_MS = 30 * 60_000;
@@ -537,11 +515,11 @@ const TASK_RETRY_BACKOFF_BASE_MS = Number(process.env.CASTLE_TASK_RETRY_BACKOFF_
 // tests / impatient devs.
 const TASK_SPAWN_STAGGER_MS = Number(process.env.CASTLE_TASK_SPAWN_STAGGER_MS) || 400;
 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();
 }
@@ -550,7 +528,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;
@@ -575,22 +553,22 @@ function visibleLength(raw) {
 // extraction below and the mid-stream incremental scanner (runRouterTurnIn),
 // so a fence spawned early behaves identically to one spawned at settle.
 function parseTaskFenceBody(body) {
-    const lines = body.replace(/\r/g, "").split("\n");
-    const title = (lines.shift() ?? "").trim();
+    const lines = body.replace(/\r/g, '').split('\n');
+    const title = (lines.shift() ?? '').trim();
     if (!title)
         return null;
     const 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();
         after.push(...headerMatch[2]
-            .split(",")
+            .split(',')
             .map((s) => s.trim())
             .filter(Boolean));
     }
-    return { title, after, prompt: lines.join("\n").trim() };
+    return { title, after, prompt: lines.join('\n').trim() };
 }
 // A fresh RegExp per call -- this is matched with manual .exec() loops in
 // TWO independent call sites (settle-time extractDirectives via .replace, and
@@ -606,25 +584,25 @@ 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 cleaned = withoutDone.replace(taskFenceRegex(), (_match, body) => {
         const directive = parseTaskFenceBody(String(body));
         if (directive)
             directives.push(directive);
-        return "";
+        return '';
     });
     return {
-        cleaned: cleaned.replace(/\n{3,}/g, "\n\n").trim(),
+        cleaned: cleaned.replace(/\n{3,}/g, '\n\n').trim(),
         directives,
         checkoffs,
         stops,
@@ -658,19 +636,13 @@ function scanNewTaskFences(raw, fromIndex) {
 // parse it out of the live stream to drive the task card's avatar/phase (and
 // optionally progress), and strip it from the feed so the raw block never
 // shows. The enumerated activity avatars must match the prompt + the client.
-const SIGNAL_AVATARS = new Set([
-    "thinking",
-    "reading",
-    "building",
-    "painting",
-    "playing",
-]);
+const SIGNAL_AVATARS = new Set(['thinking', 'reading', 'building', 'painting', 'playing']);
 // Parse the `key: value` body of a ```signal block, fail-soft: unknown keys are
 // ignored, progress is clamped 0-100, avatar must be in the enum or it's
 // dropped. `note` and `phase` are aliases for the phase line.
 function parseSignalBody(raw) {
     const sig = {};
-    for (const line of raw.split("\n")) {
+    for (const line of raw.split('\n')) {
         const m = /^\s*([a-zA-Z]+)\s*:\s*(.*)$/.exec(line);
         if (!m)
             continue;
@@ -678,16 +650,16 @@ function parseSignalBody(raw) {
         const value = m[2].trim();
         if (!value)
             continue;
-        if (key === "progress") {
+        if (key === 'progress') {
             const n = parseInt(value, 10);
             if (Number.isFinite(n))
                 sig.progress = Math.max(0, Math.min(100, n));
         }
-        else if (key === "avatar") {
+        else if (key === 'avatar') {
             if (SIGNAL_AVATARS.has(value))
                 sig.avatar = value;
         }
-        else if (key === "note" || key === "phase") {
+        else if (key === 'note' || key === 'phase') {
             sig.phase = value;
         }
     }
@@ -706,20 +678,20 @@ function humanizeAskBlocks(text) {
                 return whole;
             const lines = data.questions
                 .map((q) => {
-                if (!q || typeof q.q !== "string" || !Array.isArray(q.options))
+                if (!q || typeof q.q !== 'string' || !Array.isArray(q.options))
                     return null;
                 const opts = q.options
-                    .filter((o) => typeof o === "string" && o.trim() !== "")
-                    .join(" / ");
+                    .filter((o) => typeof o === 'string' && o.trim() !== '')
+                    .join(' / ');
                 if (!opts)
                     return null;
-                const mode = q.multi === true ? "pick any" : "pick one";
+                const mode = q.multi === true ? 'pick any' : 'pick one';
                 return `- ${q.q} (${mode}): ${opts}`;
             })
                 .filter((l) => l !== null);
             if (lines.length === 0)
                 return whole;
-            return `[You asked the user to choose:\n${lines.join("\n")}]`;
+            return `[You asked the user to choose:\n${lines.join('\n')}]`;
         }
         catch {
             return whole;
@@ -735,7 +707,7 @@ function makeSmithRunHandle(controller) {
         // Reads as "still running" for symmetry, but nothing consumes it for
         // smith runs: the registry already excludes them by pid sign.
         exitCode: null,
-        spawnfile: "castle-smith",
+        spawnfile: 'castle-smith',
         kill: () => {
             controller.abort();
             return true;
@@ -749,19 +721,19 @@ function baseName(p) {
 // First non-blank line, capped -- the one-line technical reason shown in the
 // UI's collapsed error disclosure. The full text goes to the consoles.
 function firstLine(text, max = 200) {
-    const line = (text ?? "")
-        .split("\n")
+    const line = (text ?? '')
+        .split('\n')
         .map((l) => l.trim())
         .find((l) => l.length > 0);
-    return (line ?? "").slice(0, max);
+    return (line ?? '').slice(0, max);
 }
 // First string-typed value among loosely-typed tool inputs, or "" when none is
 // a string (avoids "[object Object]" from String()-ing an object/array value).
 function firstString(...vals) {
     for (const v of vals)
-        if (typeof v === "string")
+        if (typeof v === 'string')
             return v;
-    return "";
+    return '';
 }
 // 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.
@@ -771,13 +743,13 @@ const PROGRESS_FILE_RE = /\.castle\/agent\/tasks\/[^/]+\/progress$/;
 // Returns null to hide the action (progress-file writes + anything non-edit/read).
 function claudeToolFeedLabel(name, input) {
     const kind = name.toLowerCase();
-    if (["edit", "write", "notebookedit", "multiedit"].some((p) => kind.startsWith(p))) {
+    if (['edit', 'write', 'notebookedit', 'multiedit'].some((p) => kind.startsWith(p))) {
         const file = firstString(input.file_path, input.path, input.notebook_path);
         if (!file || PROGRESS_FILE_RE.test(file))
             return null;
         return `Editing ${baseName(file)}`;
     }
-    if (kind.startsWith("read") || kind.startsWith("notebookread")) {
+    if (kind.startsWith('read') || kind.startsWith('notebookread')) {
         const file = firstString(input.file_path, input.path);
         return file ? `Reading ${baseName(file)}` : null;
     }
@@ -790,35 +762,32 @@ function claudeToolFeedLabel(name, input) {
 // Mirrors the cursor toolActivityLabel verbs so the two backends read alike.
 function genericClaudeToolLabel(name) {
     const kind = name.toLowerCase();
-    if (kind.startsWith("read") || kind.startsWith("notebookread"))
-        return "Reading the deck";
-    if (["edit", "write", "notebook", "multiedit"].some((p) => kind.startsWith(p)))
-        return "Editing files";
-    if (kind.startsWith("bash") || kind.includes("terminal"))
-        return "Running a command";
-    if (["grep", "glob", "ls"].some((p) => kind.startsWith(p)) ||
-        kind.includes("search"))
-        return "Searching the deck";
-    if (kind.startsWith("web"))
-        return "Searching the web";
-    return "Working";
+    if (kind.startsWith('read') || kind.startsWith('notebookread'))
+        return 'Reading the deck';
+    if (['edit', 'write', 'notebook', 'multiedit'].some((p) => kind.startsWith(p)))
+        return 'Editing files';
+    if (kind.startsWith('bash') || kind.includes('terminal'))
+        return 'Running a command';
+    if (['grep', 'glob', 'ls'].some((p) => kind.startsWith(p)) || kind.includes('search'))
+        return 'Searching the deck';
+    if (kind.startsWith('web'))
+        return 'Searching the web';
+    return 'Working';
 }
 // 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
@@ -830,27 +799,27 @@ function toolActivityLabel(ev) {
 // openrouterApiKey), which breaks the keyless and injected-key scenarios in
 // exactly the way that is hard to reproduce on CI. Mirrors the other
 // CASTLE_OPENROUTER_* test overrides.
-const CASTLE_KEYS_PATH = process.env.CASTLE_KEYS_PATH ?? path.join(os.homedir(), ".castle", "keys.json");
+const CASTLE_KEYS_PATH = process.env.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 {};
     }
 }
 function resolveOpenrouterAuth() {
-    const k = userKey("OPENROUTER_API_KEY");
+    const k = userKey('OPENROUTER_API_KEY');
     if (k)
-        return { mode: "user-key", key: k };
-    return { mode: "proxy", key: openrouterApiKey() };
+        return { mode: 'user-key', key: k };
+    return { mode: 'proxy', key: openrouterApiKey() };
 }
 // Keys for the SPAWNING backends' env injection (envForAgentSpawn). Smith is
 // absent by design: it never spawns a CLI -- its OpenRouter key flows through
 // openrouterApiKey() into runAgentNative's Authorization header instead.
 const BACKEND_KEY_ENV = {
-    claude: "ANTHROPIC_API_KEY",
-    cursor: "CURSOR_API_KEY",
+    claude: 'ANTHROPIC_API_KEY',
+    cursor: 'CURSOR_API_KEY',
 };
 // When we inject Castle's key, any auth.json cursor cached from a DIFFERENT key
 // -- a rotated-out old key, or a tester's own key we've chosen to override -- is
@@ -861,7 +830,7 @@ const BACKEND_KEY_ENV = {
 function purgeStaleCursorAuth(home, injectedKey) {
     try {
         const authPath = cursorAuthPath(home);
-        const auth = JSON.parse(fs.readFileSync(authPath, "utf8"));
+        const auth = JSON.parse(fs.readFileSync(authPath, 'utf8'));
         if (auth.apiKey && auth.apiKey !== injectedKey) {
             fs.rmSync(authPath, { force: true });
         }
@@ -874,9 +843,9 @@ function purgeStaleCursorAuth(home, injectedKey) {
 // route to directly (and bill to them) instead of Castle's proxy / key. The
 // claude side lives in byo-auth.ts, which the editor terminal shares.
 function backendHasSavedAuth(backend) {
-    if (backend === "claude")
+    if (backend === 'claude')
         return claudeHasSavedLogin();
-    if (backend === "cursor")
+    if (backend === 'cursor')
         return cursorHasUserLogin(os.homedir());
     return false;
 }
@@ -895,7 +864,7 @@ function backendHasSavedAuth(backend) {
 //     credential while doing nothing.
 function envForClaudeSpawn(auth) {
     const env = { ...process.env };
-    if (auth.mode === "proxy")
+    if (auth.mode === 'proxy')
         return env;
     for (const name of ANTHROPIC_PROXY_ENV)
         delete env[name];
@@ -918,7 +887,7 @@ function envForAgentSpawn(backend) {
         const val = castleKeys()[keyName] ?? process.env[keyName];
         if (val) {
             env[keyName] = val;
-            if (backend === "cursor")
+            if (backend === 'cursor')
                 purgeStaleCursorAuth(os.homedir(), val);
         }
         else {
@@ -927,13 +896,7 @@ function envForAgentSpawn(backend) {
     }
     return env;
 }
-const DECK_TREE_EXCLUDE = new Set([
-    "node_modules",
-    ".castle",
-    ".git",
-    "dist",
-    ".DS_Store",
-]);
+const DECK_TREE_EXCLUDE = new Set(['node_modules', '.castle', '.git', 'dist', '.DS_Store']);
 const DECK_TREE_MAX_ENTRIES = 200;
 // Per-directory listing cap. A successful deck accumulates hundreds of
 // drawings; without this, one big directory exhausts the global budget
@@ -978,23 +941,23 @@ function buildDeckTree(deckDir, caps) {
                 return;
             }
             const isDir = entry.isDirectory();
-            lines.push(`${prefix}${entry.name}${isDir ? "/" : ""}`);
+            lines.push(`${prefix}${entry.name}${isDir ? '/' : ''}`);
             if (isDir && depth < 1) {
-                walk(path.join(dir, entry.name), prefix + "  ", depth + 1);
+                walk(path.join(dir, entry.name), prefix + '  ', depth + 1);
             }
         }
         const rest = visible.slice(perDir);
         if (rest.length > 0 && lines.length < maxEntries) {
             // Name the overflow's extension when it's uniform ("+214 more .pxart"),
             // since that tells the reader what kind of files dominate the directory.
-            const exts = new Set(rest.map((e) => (e.isDirectory() ? "/" : path.extname(e.name))));
+            const exts = new Set(rest.map((e) => (e.isDirectory() ? '/' : path.extname(e.name))));
             const [only] = exts;
-            const suffix = exts.size === 1 && only && only !== "/" ? ` ${only}` : "";
+            const suffix = exts.size === 1 && only && only !== '/' ? ` ${only}` : '';
             lines.push(`${prefix}(+${rest.length} more${suffix})`);
         }
     };
-    walk(deckDir, "", 0);
-    return lines.join("\n");
+    walk(deckDir, '', 0);
+    return lines.join('\n');
 }
 // Text source extensions buildDeckContents will inline. Deliberately an
 // allowlist (not "everything readable") -- decks are small web projects, so
@@ -1015,17 +978,28 @@ function buildDeckTree(deckDir, caps) {
 // anything else outside this list are skipped for the more obvious reason
 // that they're unreadable as text.
 const DECK_CONTENTS_TEXT_EXTS = new Set([
-    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts",
-    ".json", ".css", ".html", ".md", ".txt", ".svg", ".yml", ".yaml", ".scene",
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.mts',
+    '.cts',
+    '.json',
+    '.css',
+    '.html',
+    '.md',
+    '.txt',
+    '.svg',
+    '.yml',
+    '.yaml',
+    '.scene',
 ]);
 // Generated/lockfiles that happen to match the extension allowlist but are
 // never hand-edited -- inlining a lockfile would just spend budget other
 // files need for zero benefit (nobody reads a lockfile to plan an edit).
-const DECK_CONTENTS_SKIP_NAMES = new Set([
-    "package-lock.json",
-    "pnpm-lock.yaml",
-    "yarn.lock",
-]);
+const DECK_CONTENTS_SKIP_NAMES = new Set(['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock']);
 // Per-file cap: keeps one unusually large source file (a generated bundle
 // accidentally left in the tree, a huge scene) from eating the whole budget
 // by itself. 16KB comfortably covers real hand-written deck files (kit engine
@@ -1091,7 +1065,7 @@ function buildDeckContents(deckDir, budget) {
     const listed = [];
     let used = 0;
     for (const abs of files) {
-        const rel = path.relative(deckDir, abs).split(path.sep).join("/");
+        const rel = path.relative(deckDir, abs).split(path.sep).join('/');
         if (DECK_CONTENTS_SKIP_NAMES.has(path.basename(rel)))
             continue;
         if (!DECK_CONTENTS_TEXT_EXTS.has(path.extname(rel).toLowerCase()))
@@ -1109,13 +1083,13 @@ function buildDeckContents(deckDir, budget) {
         }
         let content;
         try {
-            content = fs.readFileSync(abs, "utf8");
+            content = fs.readFileSync(abs, 'utf8');
         }
         catch {
             listed.push(`${rel} (not inlined -- use read tool)`);
             continue;
         }
-        if (content.includes("\u0000")) {
+        if (content.includes('\u0000')) {
             // Looks binary despite the extension allowlist (e.g. a mislabeled
             // asset) -- skip it exactly like read_file's own NUL sniff would.
             listed.push(`${rel} (not inlined -- use read tool)`);
@@ -1126,19 +1100,19 @@ function buildDeckContents(deckDir, budget) {
     }
     const parts = [];
     if (inlined.length > 0)
-        parts.push(inlined.join("\n\n"));
+        parts.push(inlined.join('\n\n'));
     if (listed.length > 0) {
-        parts.push(`(not inlined -- binary/generated, over the per-file cap, or past the total budget; read these yourself if you need them):\n${listed.join("\n")}`);
+        parts.push(`(not inlined -- binary/generated, over the per-file cap, or past the total budget; read these yourself if you need them):\n${listed.join('\n')}`);
     }
-    return parts.join("\n\n");
+    return parts.join('\n\n');
 }
 const DEFAULT_WELCOME_MESSAGE = "Welcome to an early test of Castle's new engine! You're starting with a blank deck, without the official art or scene editors, but if HTML and JavaScript can do it then I can help you build it.\n\nDo you already know what you want to make, or do you want to figure it out together?";
 function readClaudeSection(deckDir, section) {
-    const headingRe = new RegExp(`^## ${section}\\s*$`, "im");
-    for (const name of ["CLAUDE.md", "AGENTS.md"]) {
-        let raw = "";
+    const headingRe = new RegExp(`^## ${section}\\s*$`, 'im');
+    for (const name of ['CLAUDE.md', 'AGENTS.md']) {
+        let raw = '';
         try {
-            raw = fs.readFileSync(path.join(deckDir, name), "utf8");
+            raw = fs.readFileSync(path.join(deckDir, name), 'utf8');
         }
         catch {
             continue;
@@ -1146,53 +1120,108 @@ function readClaudeSection(deckDir, section) {
         const heading = headingRe.exec(raw);
         if (!heading || heading.index === undefined)
             continue;
-        const bodyStart = raw.indexOf("\n", heading.index);
+        const bodyStart = raw.indexOf('\n', heading.index);
         if (bodyStart < 0)
-            return "";
+            return '';
         const rest = raw.slice(bodyStart + 1);
         const nextHeading = /^##\s+/m.exec(rest);
         return (nextHeading ? rest.slice(0, nextHeading.index) : rest).trim();
     }
-    return "";
+    return '';
+}
+// Which import the deck's entry actually runs, read off index.html. The kit that
+// is MOUNTED is the one whose vocabulary applies, so its docs lead.
+function entryImportAlias(deckDir) {
+    try {
+        const html = fs.readFileSync(path.join(deckDir, 'index.html'), 'utf8');
+        const match = new RegExp(`src="/?${IMPORTS_DIR}/([^/"]+)/`).exec(html);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+function importAliases(deckDir) {
+    try {
+        return fs.readdirSync(path.join(deckDir, IMPORTS_DIR)).sort();
+    }
+    catch {
+        return [];
+    }
+}
+// A deck built on a kit holds almost no docs of its own -- `init` writes it a
+// CLAUDE.md that POINTS at the kit's. Reading only the deck's own file therefore
+// found nothing, and the agent was then told "there is no documentation, do not
+// search for one", so it never learned the kit's vocabulary at all. Gather the
+// deck's own section plus every import's, entry kit first.
+function readClaudeSectionWithImports(deckDir, section) {
+    const parts = [];
+    const own = readClaudeSection(deckDir, section);
+    if (own)
+        parts.push(own);
+    const entry = entryImportAlias(deckDir);
+    const aliases = importAliases(deckDir);
+    const ordered = entry ? [entry, ...aliases.filter((a) => a !== entry)] : aliases;
+    for (const alias of ordered) {
+        const text = readClaudeSection(path.join(deckDir, IMPORTS_DIR, alias), section);
+        if (!text)
+            continue;
+        const role = alias === entry ? 'this deck runs on it' : 'imported, not the entry';
+        parts.push(`### from the ${alias} kit (${role})\n\n${text}`);
+    }
+    return parts.join('\n\n');
 }
 function readQuickReference(deckDir) {
-    return readClaudeSection(deckDir, "Quick reference");
+    return readClaudeSectionWithImports(deckDir, 'Quick reference');
 }
+// One greeting, not a pile of them: the mounted kit's welcome is the deck's.
 function readWelcomeMessage(deckDir) {
-    return readClaudeSection(deckDir, "Welcome message");
+    const own = readClaudeSection(deckDir, 'Welcome message');
+    if (own)
+        return own;
+    const entry = entryImportAlias(deckDir);
+    const ordered = entry
+        ? [entry, ...importAliases(deckDir).filter((a) => a !== entry)]
+        : importAliases(deckDir);
+    for (const alias of ordered) {
+        const text = readClaudeSection(path.join(deckDir, IMPORTS_DIR, alias), 'Welcome message');
+        if (text)
+            return text;
+    }
+    return '';
 }
 function createAgentStreamState() {
     return {
-        accumulated: "",
-        finalText: "",
+        accumulated: '',
+        finalText: '',
         resultIsError: false,
         usage: undefined,
         sawResult: false,
-        segmentText: "",
+        segmentText: '',
         needsGap: false,
         pendingTools: new Map(),
     };
 }
 function parseCliUsage(raw) {
-    if (!raw || typeof raw !== "object")
+    if (!raw || typeof raw !== 'object')
         return undefined;
     const src = raw;
     const usage = {};
     for (const key of [
-        "input_tokens",
-        "output_tokens",
-        "cache_creation_input_tokens",
-        "cache_read_input_tokens",
+        'input_tokens',
+        'output_tokens',
+        'cache_creation_input_tokens',
+        'cache_read_input_tokens',
     ]) {
         const value = src[key];
-        if (typeof value === "number")
+        if (typeof value === 'number')
             usage[key] = value;
     }
     return Object.keys(usage).length > 0 ? usage : undefined;
 }
 function formatTokenCount(value) {
-    if (typeof value !== "number")
-        return "?";
+    if (typeof value !== 'number')
+        return '?';
     if (value >= 1000)
         return `${(value / 1000).toFixed(1)}k`;
     return String(value);
@@ -1228,8 +1257,8 @@ function makeAgentEventHandler(opts, state) {
         let delta = rawDelta;
         if (state.needsGap) {
             state.needsGap = false;
-            if (state.accumulated && !state.accumulated.endsWith("\n\n")) {
-                delta = (state.accumulated.endsWith("\n") ? "\n" : "\n\n") + delta;
+            if (state.accumulated && !state.accumulated.endsWith('\n\n')) {
+                delta = (state.accumulated.endsWith('\n') ? '\n' : '\n\n') + delta;
             }
         }
         state.segmentText += delta;
@@ -1238,12 +1267,12 @@ function makeAgentEventHandler(opts, state) {
         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') {
                     state.needsGap = true;
-                    const name = String(e.content_block.name ?? "");
+                    const name = String(e.content_block.name ?? '');
                     // Router: show a coarse label NOW (name is known) so the activity
                     // line isn't stuck on the prior state while the tool runs; the
                     // concrete label (with the file) refines it at content_block_stop.
@@ -1251,43 +1280,39 @@ function makeAgentEventHandler(opts, state) {
                         opts.onActivity?.(genericClaudeToolLabel(name));
                     // Hold the concrete label until content_block_stop, once the input
                     // (file / command) has streamed in, so we can name it concretely.
-                    state.pendingTools.set(e.index ?? -1, { name, buf: "" });
+                    state.pendingTools.set(e.index ?? -1, { name, buf: '' });
                 }
-                else if (e.content_block?.type === "thinking") {
+                else if (e.content_block?.type === 'thinking') {
                     state.needsGap = true;
                     // Surface extended thinking as the activity line (mirrors the cursor
                     // path's `thinking` signal). The next text delta clears it via
                     // emitDelta's onActivity(null); a tool block relabels it.
-                    opts.onActivity?.("Thinking");
+                    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" &&
-                    typeof e.delta.thinking === "string" &&
+                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") {
+                else if (e.delta?.type === 'input_json_delta' &&
+                    typeof e.delta.partial_json === 'string') {
                     const pending = state.pendingTools.get(e.index ?? -1);
                     if (pending)
                         pending.buf += e.delta.partial_json;
                 }
             }
-            else if (e?.type === "content_block_stop") {
+            else if (e?.type === 'content_block_stop') {
                 const pending = state.pendingTools.get(e.index ?? -1);
                 if (pending) {
                     state.pendingTools.delete(e.index ?? -1);
                     let input = {};
                     try {
-                        input = pending.buf
-                            ? JSON.parse(pending.buf)
-                            : {};
+                        input = pending.buf ? JSON.parse(pending.buf) : {};
                     }
                     catch {
                         /* input JSON arrived partial -- fall back to a generic label */
@@ -1298,28 +1323,27 @@ function makeAgentEventHandler(opts, state) {
                 }
             }
         }
-        else if (ev.type === "result") {
+        else if (ev.type === 'result') {
             state.sawResult = true;
             // An EMPTY string result falls back to the streamed text. Models that
             // return their blocks as `text, thinking` (gemini through OpenRouter's
             // anthropic-compatible endpoint) end the turn on an empty thinking block,
             // and the CLI reports `result: ""` even though the answer streamed fine.
-            state.finalText =
-                typeof ev.result === "string" && ev.result ? ev.result : state.accumulated;
+            state.finalText = typeof ev.result === 'string' && ev.result ? ev.result : state.accumulated;
             state.resultIsError = ev.is_error === true;
             state.usage = parseCliUsage(ev.usage);
         }
     };
     return (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();
@@ -1327,25 +1351,24 @@ function makeAgentEventHandler(opts, state) {
                 return;
             emitDelta(delta);
         }
-        else if (ev.type === "tool_call") {
-            state.segmentText = "";
+        else if (ev.type === 'tool_call') {
+            state.segmentText = '';
             state.needsGap = true;
-            if (ev.subtype === "started")
+            if (ev.subtype === 'started')
                 opts.onActivity?.(toolActivityLabel(ev));
         }
-        else if (ev.type === "thinking") {
-            state.segmentText = "";
+        else if (ev.type === 'thinking') {
+            state.segmentText = '';
             state.needsGap = true;
-            opts.onActivity?.("Thinking");
+            opts.onActivity?.('Thinking');
         }
-        else if (ev.type === "result") {
+        else if (ev.type === 'result') {
             state.sawResult = true;
             // An EMPTY string result falls back to the streamed text. Models that
             // return their blocks as `text, thinking` (gemini through OpenRouter's
             // anthropic-compatible endpoint) end the turn on an empty thinking block,
             // and the CLI reports `result: ""` even though the answer streamed fine.
-            state.finalText =
-                typeof ev.result === "string" && ev.result ? ev.result : state.accumulated;
+            state.finalText = typeof ev.result === 'string' && ev.result ? ev.result : state.accumulated;
             state.resultIsError = ev.is_error === true;
             state.usage = parseCliUsage(ev.usage);
         }
@@ -1372,27 +1395,25 @@ function runAgentCli(opts) {
             child = spawn(opts.command, opts.args, {
                 cwd: opts.cwd,
                 env: opts.env,
-                stdio: ["ignore", "pipe", "pipe"],
+                stdio: ['ignore', 'pipe', 'pipe'],
             });
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             resolve({
                 ok: false,
-                finalText: "",
+                finalText: '',
                 error: `could not run ${opts.command}: ${message}`,
-                failure: { kind: "spawn", detail: `${opts.command}: ${message}` },
+                failure: { kind: 'spawn', detail: `${opts.command}: ${message}` },
             });
             return;
         }
         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 stderrTail = "";
-        let lineBuffer = "";
+        let stderrTail = '';
+        let lineBuffer = '';
         const state = createAgentStreamState();
         const settle = (result) => {
             if (settled)
@@ -1405,7 +1426,7 @@ function runAgentCli(opts) {
         };
         const timeout = setTimeout(() => {
             try {
-                child.kill("SIGKILL");
+                child.kill('SIGKILL');
             }
             catch {
                 /* already gone */
@@ -1413,19 +1434,19 @@ function runAgentCli(opts) {
             settle({
                 ok: false,
                 finalText: state.finalText || state.accumulated,
-                error: "agent run timed out",
+                error: 'agent run timed out',
                 usage: state.usage,
             });
         }, opts.timeoutMs);
         const handleEvent = makeAgentEventHandler(opts, state);
-        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));
                     }
@@ -1433,13 +1454,13 @@ 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) => {
+        child.on('error', (err) => {
             settle({
                 ok: false,
                 finalText: state.accumulated,
@@ -1447,10 +1468,10 @@ function runAgentCli(opts) {
                 // actually being spawned -- this used to say "cursor-agent" for every
                 // backend, so a missing `claude` reported the wrong tool.
                 error: `could not run ${opts.command}: ${err.message}`,
-                failure: { kind: "spawn", detail: `${opts.command}: ${err.message}` },
+                failure: { kind: 'spawn', detail: `${opts.command}: ${err.message}` },
             });
         });
-        child.on("close", (code) => {
+        child.on('close', (code) => {
             const ok = code === 0 && !state.resultIsError && state.sawResult;
             // A provider error does NOT arrive on stderr: the claude CLI reports it
             // in the stream-json result event (is_error:true) and exits 0, leaving
@@ -1466,11 +1487,11 @@ function runAgentCli(opts) {
             // as before this feature.
             const classified = ok || !opts.openrouterModel
                 ? undefined
-                : classifyProviderError(state.finalText, opts.openrouterModel) ??
-                    classifyProviderError(stderrTail, opts.openrouterModel);
+                : (classifyProviderError(state.finalText, opts.openrouterModel) ??
+                    classifyProviderError(stderrTail, opts.openrouterModel));
             const error = ok
                 ? undefined
-                : `agent exited ${code}${stderrTail ? `: ${stderrTail.slice(-300)}` : ""}`;
+                : `agent exited ${code}${stderrTail ? `: ${stderrTail.slice(-300)}` : ''}`;
             settle({
                 ok,
                 finalText: state.finalText || state.accumulated,
@@ -1481,7 +1502,7 @@ function runAgentCli(opts) {
                     ? {
                         ...classified,
                         detail: firstLine(state.finalText) || classified.detail,
-                        verbose: [state.finalText, stderrTail].filter(Boolean).join("\n"),
+                        verbose: [state.finalText, stderrTail].filter(Boolean).join('\n'),
                     }
                     : undefined,
             });
@@ -1560,7 +1581,7 @@ async function runAgentSmith(opts) {
         // instead of rejecting through startTask's catch.
         return {
             ok: false,
-            finalText: "",
+            finalText: '',
             error: `could not run openrouter: ${err instanceof Error ? err.message : String(err)}`,
         };
     }
@@ -1573,10 +1594,10 @@ async function runAgentSmith(opts) {
 // conductor.tsx (it decides whether to show the slug field) -- keep them in
 // step; this one decides whether the slug is worth validating at all.
 export function roleUsesOpenrouter(backend, claudeModel) {
-    return backend === "smith" || (backend === "claude" && claudeModel === "openrouter");
+    return backend === 'smith' || (backend === 'claude' && claudeModel === 'openrouter');
 }
 function configFailure(reason, detail, extra) {
-    return { kind: "config", reason, detail, ...extra };
+    return { kind: 'config', reason, detail, ...extra };
 }
 // Everything decidable about an OpenRouter run BEFORE spending anything on it.
 // Returns a failure to surface as-is, or null to proceed.
@@ -1593,32 +1614,32 @@ async function preflightOpenrouterRun(opts) {
     const auth = opts.orAuth ?? resolveOpenrouterAuth();
     const apiKey = auth.key;
     if (!apiKey) {
-        return configFailure("no-key", `no ${OPENROUTER_KEY_NAME} is set (checked ${CASTLE_USER_KEYS_PATH}, ${CASTLE_KEYS_PATH}, and the environment)`);
+        return configFailure('no-key', `no ${OPENROUTER_KEY_NAME} is set (checked ${CASTLE_USER_KEYS_PATH}, ${CASTLE_KEYS_PATH}, and the environment)`);
     }
     const model = opts.openrouterModel.trim();
     if (!model) {
-        return configFailure("unknown-model", "no OpenRouter model is set for this role");
+        return configFailure('unknown-model', 'no OpenRouter model is set for this role');
     }
     // Key and slug checks are independent, so overlap them rather than paying
     // both round-trips in series. Both are cached and single-flighted.
     const [key, slug] = await Promise.all([
-        checkOpenrouterKey(apiKey, { direct: auth.mode === "user-key" }),
+        checkOpenrouterKey(apiKey, { direct: auth.mode === 'user-key' }),
         checkOpenrouterModel(model),
     ]);
-    if (key.status === "bad-key") {
-        return configFailure("bad-key", `OpenRouter rejected ${OPENROUTER_KEY_NAME}`);
+    if (key.status === 'bad-key') {
+        return configFailure('bad-key', `OpenRouter rejected ${OPENROUTER_KEY_NAME}`);
     }
-    if (key.status === "no-credits") {
-        return configFailure("no-credits", "the OpenRouter key is out of credits");
+    if (key.status === 'no-credits') {
+        return configFailure('no-credits', 'the OpenRouter key is out of credits');
     }
-    if (slug.status === "unknown-model") {
-        return configFailure("unknown-model", `OpenRouter has no model "${model}"`, {
+    if (slug.status === 'unknown-model') {
+        return configFailure('unknown-model', `OpenRouter has no model "${model}"`, {
             model,
             suggestion: slug.suggestions[0],
         });
     }
-    if (slug.status === "no-tools") {
-        return configFailure("no-tools", `"${model}" does not support tool calling`, {
+    if (slug.status === 'no-tools') {
+        return configFailure('no-tools', `"${model}" does not support tool calling`, {
             model,
         });
     }
@@ -1652,11 +1673,11 @@ function notifyAgentRunFinished() {
 // cursor run on Castle's key stays gated, and cursor is unmetered (its traffic
 // never reaches the proxy), so an ungated one would be a free ride.
 function runIsCastlePaid(backend, claudeModel, orAuth) {
-    if (backend === "cursor")
+    if (backend === 'cursor')
         return !cursorHasUserLogin(os.homedir());
     return roleUsesOpenrouter(backend, claudeModel)
-        ? (orAuth ?? resolveOpenrouterAuth()).mode === "proxy"
-        : resolveAnthropicAuth().mode === "proxy";
+        ? (orAuth ?? resolveOpenrouterAuth()).mode === 'proxy'
+        : resolveAnthropicAuth().mode === 'proxy';
 }
 // Whether Castle's budget is this editor's to spend at all, which is what makes
 // the usage bar worth drawing. Both roles count, and they can disagree: an
@@ -1687,8 +1708,8 @@ async function castleSpendRefusal(backend, claudeModel, orAuth) {
         return null;
     if (claudeModelBlocked(claudeModel, budget)) {
         return {
-            kind: "config",
-            reason: "model-not-allowed",
+            kind: 'config',
+            reason: 'model-not-allowed',
             detail: `${claudeModel} is not available on this Castle account`,
             model: claudeModel,
         };
@@ -1696,8 +1717,8 @@ async function castleSpendRefusal(backend, claudeModel, orAuth) {
     if (!budget.blocked)
         return null;
     return {
-        kind: "limit",
-        detail: "daily Castle AI limit reached",
+        kind: 'limit',
+        detail: 'daily Castle AI limit reached',
         resetAtMs: budget.resetAtMs || undefined,
     };
 }
@@ -1705,7 +1726,7 @@ async function castleSpendRefusal(backend, claudeModel, orAuth) {
 // finished run already refreshes. This is for the spend this serve never sees
 // -- a `claude` invoked straight from the sandbox terminal.
 const USAGE_POLL_MS = 60_000;
-const PICKER_CLAUDE_MODELS = ["sonnet", "opus", "fable"];
+const PICKER_CLAUDE_MODELS = ['sonnet', 'opus', 'fable'];
 /**
  * Which of the picker's claude models this editor can't use. Gated on the
  * ANTHROPIC credential specifically, not on `anyRoleIsCastlePaid` (which draws
@@ -1717,7 +1738,7 @@ const PICKER_CLAUDE_MODELS = ["sonnet", "opus", "fable"];
  * resolveAnthropicAuth, so no role's settings enter into this.
  */
 function blockedClaudeModels(budget) {
-    if (resolveAnthropicAuth().mode !== "proxy")
+    if (resolveAnthropicAuth().mode !== 'proxy')
         return [];
     return PICKER_CLAUDE_MODELS.filter((m) => claudeModelBlocked(m, budget));
 }
@@ -1752,7 +1773,7 @@ function createUsageFeed(opts) {
         if (JSON.stringify(next ?? null) === JSON.stringify(latest ?? null))
             return;
         latest = next;
-        opts.broadcast({ type: "usage", usage: next });
+        opts.broadcast({ type: 'usage', usage: next });
     }
     const refresh = () => void refreshAsync();
     const stopRunWatch = onAgentRunFinished(refresh);
@@ -1792,7 +1813,7 @@ async function runAgentTurn(opts) {
     if (failure) {
         return {
             ok: false,
-            finalText: "",
+            finalText: '',
             error: failure.detail,
             failure,
             // NOT "crashed": nothing ran. crashed drives the task retry loop, and a
@@ -1805,9 +1826,9 @@ async function runAgentTurn(opts) {
     // conversation -- nothing is resumed).
     const sessionId = newAgentSessionId(opts.role);
     const settled = (run) => run.finally(() => notifyAgentRunFinished());
-    if (opts.backend === "smith") {
+    if (opts.backend === 'smith') {
         // roleUsesOpenrouter is true for smith, so orAuth is non-null here.
-        const direct = orAuth.mode === "user-key";
+        const direct = orAuth.mode === 'user-key';
         return settled(runAgentSmith({
             cwd: opts.cwd,
             role: opts.role,
@@ -1816,14 +1837,14 @@ async function runAgentTurn(opts) {
             extraHeaders: meteringHeaders({
                 deckDir: opts.cwd,
                 sessionId,
-                route: "openrouter",
+                route: 'openrouter',
                 direct,
             }),
             model: opts.openrouterModel,
             prompt: opts.prompt,
             // Mirrors claude's --append-system-prompt for tasks (the native loop
             // appends it to its own system framing).
-            systemReminder: opts.role === "task" ? CLAUDE_TASK_SYSTEM_REMINDER : undefined,
+            systemReminder: opts.role === 'task' ? CLAUDE_TASK_SYSTEM_REMINDER : undefined,
             attachments: opts.attachments,
             openrouterTuning: opts.openrouterTuning,
             timeoutMs: opts.timeoutMs,
@@ -1860,7 +1881,7 @@ async function runAgentTurn(opts) {
     // Cursor is the only backend whose traffic never reaches the llm-proxy, so its
     // run is reported from here. Every other backend is already recorded upstream,
     // and reporting them here too would double-count them in the same table.
-    if (opts.backend !== "cursor")
+    if (opts.backend !== 'cursor')
         return settled(run);
     return settled(run.then((result) => {
         reportCursorRun({
@@ -1875,7 +1896,7 @@ async function runAgentTurn(opts) {
 }
 // -- 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. A
 // persisted "blocked" task is left as-is: it is not "waiting", so maybeStart
@@ -1884,11 +1905,11 @@ function persistTaskFile(tasksDir, task) {
 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);
         }
@@ -1902,9 +1923,7 @@ 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;
@@ -1915,7 +1934,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;
@@ -1951,9 +1970,9 @@ export function classifyDeps(tasks, task) {
         const dep = tasks.get(id);
         // A dep id that no longer resolves to a task (its row was cleared) or one
         // that finished "done" is satisfied -- nothing left to wait on.
-        if (!dep || dep.status === "done")
+        if (!dep || dep.status === 'done')
             continue;
-        if (dep.status === "failed" || dep.status === "interrupted") {
+        if (dep.status === 'failed' || dep.status === 'interrupted') {
             blockedBy.push(dep.title);
         }
         else {
@@ -1961,8 +1980,8 @@ export function classifyDeps(tasks, task) {
         }
     }
     if (blockedBy.length > 0)
-        return { kind: "blocked", blockedBy };
-    return { kind: waiting ? "waiting" : "ready" };
+        return { kind: 'blocked', blockedBy };
+    return { kind: waiting ? 'waiting' : 'ready' };
 }
 // Cap on how much of an upstream task's wrap-up prose rides into a dependent's
 // prompt. resultSummary is already capped at RESULT_SUMMARY_CHARS; this trims
@@ -1981,12 +2000,12 @@ function depsSummaryFor(tasks, task) {
         // and deliberately stripped of that detail.
         const summary = dep.resultSummary?.trim();
         if (summary)
-            parts.push(`  its wrap-up: ${summary.slice(-DEP_SUMMARY_CHARS).replace(/\n+/g, " ")}`);
+            parts.push(`  its wrap-up: ${summary.slice(-DEP_SUMMARY_CHARS).replace(/\n+/g, ' ')}`);
         if (dep.notes.trim())
             parts.push(`  player notes: ${dep.notes.trim()}`);
-        return parts.join("\n");
+        return parts.join('\n');
     });
-    return lines.join("\n") || undefined;
+    return lines.join('\n') || undefined;
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -2020,7 +2039,7 @@ async function runTaskAgentIn(ctx, task) {
     // Deck source inlining is smith-only (see buildDeckContents): cursor/claude
     // read files themselves turn over turn, so computing and sending this
     // would be pure prompt bloat for them with no offsetting benefit.
-    const isSmith = ctx.backend === "smith";
+    const isSmith = ctx.backend === 'smith';
     const deckContents = isSmith
         ? buildDeckContents(ctx.deckDir, TASK_DECK_CONTENTS_BUDGET)
         : undefined;
@@ -2029,8 +2048,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,
         // Slimmed once contents are inlined -- see DECK_TREE_SLIM_* above.
@@ -2053,38 +2072,38 @@ async function runTaskAgentIn(ctx, task) {
     // read/plan turns instead of stalling its first playtest. Smith-only:
     // playtest is a native-loop tool, so CLI-backend tasks would download a
     // browser they can never use.
-    if (ctx.backend === "smith")
+    if (ctx.backend === 'smith')
         ctx.playtest?.prewarm?.();
-    let result = { ok: false, finalText: "", error: "not run" };
-    let lineBuf = "";
+    let result = { ok: false, finalText: '', error: 'not run' };
+    let lineBuf = '';
     // ```signal blocks span multiple lines and must NOT show in the live feed:
     // track whether we're inside one (line-state machine). Lines arrive complete
     // (flushFeedLines only emits up to a newline), so a partial fence never
     // flashes. On close we parse the body and hand it to ctx.onSignal.
     let inSignal = false;
-    let signalBody = "";
+    let signalBody = '';
     const flushFeedLines = (delta) => {
         lineBuf += delta;
-        let nl = lineBuf.indexOf("\n");
+        let nl = lineBuf.indexOf('\n');
         while (nl >= 0) {
             const rawLine = lineBuf.slice(0, nl);
             lineBuf = lineBuf.slice(nl + 1);
-            nl = lineBuf.indexOf("\n");
+            nl = lineBuf.indexOf('\n');
             const line = rawLine.trim();
             if (inSignal) {
-                if (line === "```") {
+                if (line === '```') {
                     inSignal = false;
                     ctx.onSignal(parseSignalBody(signalBody));
-                    signalBody = "";
+                    signalBody = '';
                 }
                 else {
-                    signalBody += rawLine + "\n";
+                    signalBody += rawLine + '\n';
                 }
                 continue;
             }
-            if (line === "```signal") {
+            if (line === '```signal') {
                 inSignal = true;
-                signalBody = "";
+                signalBody = '';
                 continue;
             }
             if (line)
@@ -2095,16 +2114,20 @@ async function runTaskAgentIn(ctx, task) {
         await staggerTaskSpawn();
         result = await runAgentTurn({
             backend: ctx.backend,
-            role: "task",
+            role: 'task',
             prompt: taskPrompt,
             claudeModel: ctx.claudeModel,
             openrouterModel: ctx.openrouterModel,
             openrouterTuning: ctx.openrouterTuning,
             cwd: ctx.deckDir,
             timeoutMs: TASK_TIMEOUT_MS,
-            logPath: path.join(dir, "log.jsonl"),
+            logPath: path.join(dir, 'log.jsonl'),
             playtest: ctx.playtest
-                ? { executor: ctx.playtest.executor, serveUrl: ctx.playtest.serveUrl, framesDir: path.join(dir, "playtest") }
+                ? {
+                    executor: ctx.playtest.executor,
+                    serveUrl: ctx.playtest.serveUrl,
+                    framesDir: path.join(dir, 'playtest'),
+                }
                 : undefined,
             restart: ctx.restart,
             children: ctx.children,
@@ -2128,7 +2151,7 @@ async function runTaskAgentIn(ctx, task) {
         // lands here (crashed = never saw a result), and retrying that burns all
         // three attempts, backoff included, on config that cannot change between
         // them. Deterministic failures get exactly one attempt.
-        if (result.failure?.kind === "config")
+        if (result.failure?.kind === 'config')
             return result;
         if (attempt < MAX_TASK_ATTEMPTS) {
             ctx.onRetry(attempt + 1);
@@ -2136,7 +2159,7 @@ async function runTaskAgentIn(ctx, task) {
                 return result;
         }
     }
-    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;
 }
 // Launch a task's agent run and wire up its finalization. The settle path is
@@ -2145,10 +2168,10 @@ async function runTaskAgentIn(ctx, task) {
 // (by skipping the slot free) nor crash the serve.
 function startTask(ctx, task) {
     const dir = path.join(ctx.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();
     ctx.touch(task);
     ctx.onStarted(task);
@@ -2177,8 +2200,7 @@ function startTask(ctx, task) {
         onRetry: (attempt) => ctx.onRetry(task, attempt),
         onSignal: (signal) => {
             let changed = false;
-            if (typeof signal.progress === "number" &&
-                signal.progress !== task.progress) {
+            if (typeof signal.progress === 'number' && signal.progress !== task.progress) {
                 task.progress = signal.progress;
                 changed = true;
             }
@@ -2202,11 +2224,7 @@ function startTask(ctx, task) {
         try {
             refreshTaskFiles(ctx.tasksDir, task);
             const wasStopped = ctx.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;
@@ -2215,10 +2233,10 @@ function startTask(ctx, task) {
             task.playtestFrames = result.playtestFrames ?? [];
             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)}`;
             if (!wasStopped && !result.ok) {
                 const failure = resolveFailure(result);
                 // spawnedTasks/willRetry are router-turn concepts; a task card has
@@ -2235,11 +2253,11 @@ function startTask(ctx, task) {
             ctx.touch(task);
         }
         catch (err) {
-            console.error(`[task ${task.id}] finalization threw: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
+            console.error(`[task ${task.id}] finalization threw: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
             // Best-effort: still mark the task terminal so it can't hang forever.
             try {
                 ctx.stopRequested.delete(task.id);
-                task.status = "failed";
+                task.status = 'failed';
                 task.finishedAt = nowIso();
                 task.resultSummary = `internal error finalizing task: ${err instanceof Error ? err.message : String(err)}`;
                 ctx.touch(task);
@@ -2254,17 +2272,17 @@ function startTask(ctx, task) {
                 ctx.onFinished(task);
             }
             catch (err) {
-                console.error(`[task ${task.id}] onFinished threw: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
+                console.error(`[task ${task.id}] onFinished threw: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
             }
             ctx.rescheduleAll();
         }
     })
         .catch((err) => {
         // runTaskAgentIn itself rejected. Free the slot so the board keeps moving.
-        console.error(`[task ${task.id}] run promise rejected: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
+        console.error(`[task ${task.id}] run promise rejected: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
         try {
             ctx.stopRequested.delete(task.id);
-            task.status = "failed";
+            task.status = 'failed';
             task.finishedAt = nowIso();
             task.resultSummary = `task run failed: ${err instanceof Error ? err.message : String(err)}`;
             ctx.touch(task);
@@ -2283,17 +2301,17 @@ function startTask(ctx, task) {
 // process, so it collapses the same way "waiting" does -- this is the only
 // way a blocked row ever clears (see ROUTER_RULES).
 function haltTask(task, children, stopRequested, touch) {
-    if (task.status === "waiting" || task.status === "blocked") {
-        task.status = "interrupted";
+    if (task.status === 'waiting' || task.status === 'blocked') {
+        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 */
@@ -2319,21 +2337,21 @@ 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)
+        if (task.status !== 'waiting' || task.acknowledged)
             return;
         const deps = classifyDeps(tasks, task);
-        if (deps.kind === "waiting")
+        if (deps.kind === 'waiting')
             return;
         // A dep finalized failed/interrupted -- this task can never do its job
         // (the output it needed never materialized), so it flips to "blocked"
         // instead of ever starting. Only the router clears it (castle-stop).
-        if (deps.kind === "blocked") {
-            task.status = "blocked";
+        if (deps.kind === 'blocked') {
+            task.status = 'blocked';
             task.blockedBy = deps.blockedBy;
             touch(task);
             return;
@@ -2354,7 +2372,7 @@ function createTaskStore(opts) {
                 maybeStart(waiting);
             }
             catch (err) {
-                console.error(`[task ${waiting.id}] maybeStart threw: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
+                console.error(`[task ${waiting.id}] maybeStart threw: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
             }
         }
     }
@@ -2386,9 +2404,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,
@@ -2412,7 +2430,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);
@@ -2421,8 +2439,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);
             }
@@ -2431,15 +2449,13 @@ 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);
@@ -2452,9 +2468,7 @@ function createTaskStore(opts) {
     function stop(tokens) {
         const ids = meansAll(tokens)
             ? [...tasks.values()]
-                .filter((t) => t.status === "running" ||
-                t.status === "waiting" ||
-                t.status === "blocked")
+                .filter((t) => t.status === 'running' || t.status === 'waiting' || t.status === 'blocked')
                 .map((t) => t.id)
             : resolveDeps(tasks, tokens);
         for (const id of ids) {
@@ -2475,11 +2489,11 @@ function createTaskStore(opts) {
 }
 // -- 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.
@@ -2489,17 +2503,16 @@ 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 {
@@ -2539,13 +2552,13 @@ function looksLikeErrorLine(line) {
 }
 function firstErrorLine(resultSummary) {
     const lines = resultSummary
-        ?.split("\n")
+        ?.split('\n')
         .map((l) => l.trim())
         .filter((l) => l.length > 0) ?? [];
     if (lines.length === 0)
         return undefined;
     const first = lines[0];
-    if (first === "agent exited 0") {
+    if (first === 'agent exited 0') {
         return (lines[1] ?? first).slice(0, ERROR_PREVIEW_CHARS);
     }
     if (!EXIT_WRAPPER_RE.test(first) || looksLikeErrorLine(first)) {
@@ -2563,11 +2576,11 @@ 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,
-        error: task.status === "failed" ? firstErrorLine(task.resultSummary) : undefined,
-        blockedBy: task.status === "blocked" ? task.blockedBy : undefined,
+        error: task.status === 'failed' ? firstErrorLine(task.resultSummary) : undefined,
+        blockedBy: task.status === 'blocked' ? task.blockedBy : undefined,
     };
 }
 function asClientTask(task) {
@@ -2603,7 +2616,7 @@ 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 };
 }
@@ -2619,7 +2632,7 @@ function createMessageThinking(broadcast) {
         else {
             map.set(id, { text: delta, firstAt: now, lastAt: now });
         }
-        broadcast({ type: "message-thinking-delta", id, delta });
+        broadcast({ type: 'message-thinking-delta', id, delta });
     }
     function snapshot() {
         return Object.fromEntries([...map].map(([id, e]) => [id, { text: e.text, ms: e.lastAt - e.firstAt }]));
@@ -2629,40 +2642,40 @@ function createMessageThinking(broadcast) {
 function createMessageLog(messagesPath, broadcast, welcomeMessage) {
     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');
     }
     if (messages.length === 0) {
         messages.push({
             id: nanoid(8),
-            role: "assistant",
+            role: 'assistant',
             text: welcomeMessage,
             at: nowIso(),
-            status: "done",
+            status: 'done',
         });
         persist();
     }
     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",
+                type: 'message-done',
                 id: last.id,
                 text: last.text,
-                status: "done",
+                status: 'done',
             });
             return;
         }
@@ -2676,14 +2689,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;
     };
@@ -2696,15 +2709,15 @@ function makePlaytestFrameHandler(tasksDir) {
         if (!reqPath.startsWith(AGENT_PLAYTEST_PREFIX))
             return false;
         const rest = reqPath.slice(AGENT_PLAYTEST_PREFIX.length);
-        const slash = rest.indexOf("/");
-        const taskId = slash >= 0 ? path.basename(rest.slice(0, slash)) : "";
-        const name = slash >= 0 ? path.basename(rest.slice(slash + 1)) : "";
-        const filePath = path.join(tasksDir, taskId, "playtest", name);
-        if (!taskId || !name || !name.endsWith(".png") || !fs.existsSync(filePath)) {
+        const slash = rest.indexOf('/');
+        const taskId = slash >= 0 ? path.basename(rest.slice(0, slash)) : '';
+        const name = slash >= 0 ? path.basename(rest.slice(slash + 1)) : '';
+        const filePath = path.join(tasksDir, taskId, 'playtest', name);
+        if (!taskId || !name || !name.endsWith('.png') || !fs.existsSync(filePath)) {
             res.writeHead(404).end();
             return true;
         }
-        res.writeHead(200, { "content-type": "image/png", "cache-control": "no-store" });
+        res.writeHead(200, { 'content-type': 'image/png', 'cache-control': 'no-store' });
         fs.createReadStream(filePath).pipe(res);
         return true;
     };
@@ -2724,12 +2737,12 @@ function resolveFailure(result) {
     if (result.failure)
         return result.failure;
     const error = result.error;
-    const kind = error?.startsWith("could not run")
-        ? "spawn"
-        : error === "agent run timed out"
-            ? "timeout"
-            : "exit";
-    return { kind, detail: error ?? "unknown failure" };
+    const kind = error?.startsWith('could not run')
+        ? 'spawn'
+        : error === 'agent run timed out'
+            ? 'timeout'
+            : 'exit';
+    return { kind, detail: error ?? 'unknown failure' };
 }
 // Assemble the full stateless prompt for one router turn: rules + deck
 // context + transcript replay (minus log lines and the in-flight reply) +
@@ -2738,25 +2751,21 @@ function routerTurnPrompt(ctx, instruction, selfMessageId) {
     // Smith-only, smaller budget than a task's -- see TASK_DECK_CONTENTS_BUDGET/
     // ROUTER_DECK_CONTENTS_BUDGET's comment (the router prompt is already the
     // largest one this serve builds).
-    const isSmith = ctx.backend() === "smith";
+    const isSmith = ctx.backend() === 'smith';
     return buildRouterPrompt({
         deckLabel: ctx.deckLabel,
         quickReference: ctx.quickReference,
         deckTree: buildDeckTree(ctx.deckDir, isSmith
             ? { maxEntries: DECK_TREE_SLIM_MAX_ENTRIES, perDir: DECK_TREE_SLIM_PER_DIR }
             : undefined),
-        deckContents: isSmith
-            ? buildDeckContents(ctx.deckDir, ROUTER_DECK_CONTENTS_BUDGET)
-            : undefined,
+        deckContents: isSmith ? buildDeckContents(ctx.deckDir, ROUTER_DECK_CONTENTS_BUDGET) : undefined,
         messages: ctx.log.messages
-            .filter((m) => m.role !== "log" &&
-            m.id !== selfMessageId &&
-            m.status !== "streaming")
+            .filter((m) => m.role !== 'log' && m.id !== selfMessageId && m.status !== 'streaming')
             .map((m) => ({
             role: m.role,
             // Replace a prior turn's raw ```ask JSON with a readable question list
             // so the model doesn't re-echo the block verbatim.
-            text: m.role === "assistant" ? humanizeAskBlocks(m.text) : m.text,
+            text: m.role === 'assistant' ? humanizeAskBlocks(m.text) : m.text,
             interrupted: m.interrupted,
         })),
         // Only the live board -- match what the user sees. Hide tasks that are
@@ -2781,26 +2790,26 @@ function routerTurnPrompt(ctx, instruction, selfMessageId) {
 // anchor, so it always takes the interrupted-draft (kept) path instead.
 function settleInterruptedTurn(ctx, message) {
     const hasSpawnedTasks = (message.taskIds?.length ?? 0) > 0;
-    if (message.text.trim() === "" && !hasSpawnedTasks) {
+    if (message.text.trim() === '' && !hasSpawnedTasks) {
         const idx = ctx.log.messages.indexOf(message);
         if (idx >= 0)
             ctx.log.messages.splice(idx, 1);
         ctx.log.persist();
         ctx.broadcast({
-            type: "message-done",
+            type: 'message-done',
             id: message.id,
-            text: "",
-            status: "done",
+            text: '',
+            status: 'done',
         });
         return;
     }
     // Keep whatever streamed and/or spawned; the continuation turn carries the
     // text draft (tasks already launched by this turn just stay on the board).
-    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,
@@ -2822,7 +2831,7 @@ function spawnCompletedTaskFences(ctx, message, midStream, raw) {
         return;
     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 newIds = [];
     for (const directive of directives) {
@@ -2839,9 +2848,9 @@ function spawnCompletedTaskFences(ctx, message, midStream, raw) {
     // ends) -- this delta only carries the updated taskIds so connected clients
     // can react (e.g. show task chips) before the turn finishes.
     ctx.broadcast({
-        type: "message-delta",
+        type: 'message-delta',
         id: message.id,
-        delta: "",
+        delta: '',
         taskIds: message.taskIds,
     });
 }
@@ -2854,14 +2863,14 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
     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;
     const midStream = { scannedUpTo: 0, spawnedTitles: new Set() };
     // Seed the activity line to "thinking" immediately -- covers the otherwise
@@ -2870,13 +2879,13 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
     // overrides it: a tool relabels it, the first text delta clears it. Seeding
     // lastActivity too dedups the redundant broadcast when the claude thinking
     // block later re-emits "thinking".
-    let lastActivity = "Thinking";
-    ctx.broadcast({ type: "message-activity", id: message.id, activity: "Thinking" });
+    let lastActivity = 'Thinking';
+    ctx.broadcast({ type: 'message-activity', id: message.id, activity: 'Thinking' });
     const prompt = routerTurnPrompt(ctx, instruction, message.id);
     const backend = ctx.backend();
     void runAgentTurn({
         backend,
-        role: "router",
+        role: 'router',
         prompt,
         claudeModel: ctx.claudeModel(),
         openrouterModel: ctx.openrouterModel(),
@@ -2886,7 +2895,7 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
         timeoutMs: ROUTER_TIMEOUT_MS,
         // CLI backends append raw stream-json; smith appends structured run
         // events (see createRunLogger in native/loop.ts). Same file either way.
-        logPath: path.join(ctx.agentDir, "router-log.jsonl"),
+        logPath: path.join(ctx.agentDir, 'router-log.jsonl'),
         children: ctx.children,
         labelUnknownTools: true,
         onDelta: (delta) => {
@@ -2896,7 +2905,7 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
                 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 });
             }
             // Spawning changes WHEN a fence is acted on, not what is displayed --
             // the holdback above still hides fenced text until the reply ends.
@@ -2906,14 +2915,14 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
             if (activity === lastActivity)
                 return;
             lastActivity = activity;
-            ctx.broadcast({ type: "message-activity", id: message.id, activity });
+            ctx.broadcast({ type: 'message-activity', id: message.id, activity });
         },
         onThinking: (delta) => {
             ctx.messageThinking.append(message.id, delta);
         },
     })
         .then((result) => {
-        logAgentUsage("router", backend, result.usage);
+        logAgentUsage('router', backend, result.usage);
         // Signals the finally -> onSettled(retryable): the turn failed cleanly
         // enough (transient, nothing salvaged) that the queue may re-run it.
         let retryable = false;
@@ -2943,7 +2952,7 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
             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
                 ? []
@@ -2953,7 +2962,7 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
             const taskIds = [...(message.taskIds ?? []), ...newlySpawnedIds];
             if (result.ok) {
                 message.text = cleaned;
-                message.status = "done";
+                message.status = 'done';
             }
             else {
                 const failure = resolveFailure(result);
@@ -2970,27 +2979,25 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
                 // different reason: it has ALREADY been retried at the transport
                 // layer (3 backed-off connects), and a turn-level retry on top just
                 // doubles the wait with the composer frozen.
-                const salvaged = cleaned !== "" || taskIds.length > 0;
-                retryable = failure.kind === "exit" && !salvaged;
+                const salvaged = cleaned !== '' || taskIds.length > 0;
+                retryable = failure.kind === 'exit' && !salvaged;
                 const copy = failureCopy({
                     failure,
                     spawnedTasks: taskIds.length > 0,
                     willRetry: retryable && ctx.canAutoRetry(),
                 });
                 message.text = cleaned ? `${cleaned}\n\n${copy}` : copy;
-                message.status = "error";
-                message.errorDetail = failure.detail || result.error || "unknown failure";
+                message.status = 'error';
+                message.errorDetail = failure.detail || result.error || 'unknown failure';
                 errorVerbose = failure.verbose;
-                const label = failure.reason
-                    ? `${failure.kind}/${failure.reason}`
-                    : failure.kind;
+                const label = failure.reason ? `${failure.kind}/${failure.reason}` : failure.kind;
                 console.error(`[router] turn failed (${label}): ${failure.verbose ?? message.errorDetail}`);
             }
             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,
@@ -3012,13 +3019,13 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
             const short = err instanceof Error ? err.message : String(err);
             console.error(`[router] turn callback threw: ${detail}`);
             try {
-                message.status = "error";
+                message.status = 'error';
                 const copy = "Something went wrong on my end partway through. Send another message and I'll pick it back up.";
-                message.text = `${message.text ? message.text + "\n\n" : ""}${copy}`;
+                message.text = `${message.text ? message.text + '\n\n' : ''}${copy}`;
                 message.errorDetail = short;
                 ctx.log.persist();
                 ctx.broadcast({
-                    type: "message-done",
+                    type: 'message-done',
                     id: message.id,
                     text: message.text,
                     status: message.status,
@@ -3027,7 +3034,7 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
                 });
             }
             catch (inner) {
-                console.error(`[router] failed to surface turn error: ${inner instanceof Error ? inner.stack ?? inner.message : String(inner)}`);
+                console.error(`[router] failed to surface turn error: ${inner instanceof Error ? (inner.stack ?? inner.message) : String(inner)}`);
             }
         }
         finally {
@@ -3038,12 +3045,12 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
         // runAgentCli itself rejected (it normally resolves with result.ok=false,
         // so this is the rare hard-failure path). Still settle so routerRunning
         // can't stick true and freeze the composer.
-        console.error(`[router] turn promise rejected: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
+        console.error(`[router] turn promise rejected: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
         try {
             ctx.onSettled();
         }
         catch (inner) {
-            console.error(`[router] onSettled threw during rejection recovery: ${inner instanceof Error ? inner.stack ?? inner.message : String(inner)}`);
+            console.error(`[router] onSettled threw during rejection recovery: ${inner instanceof Error ? (inner.stack ?? inner.message) : String(inner)}`);
         }
     });
 }
@@ -3051,48 +3058,48 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
 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;
             changes.push(`${key} agent -> ${value}`);
         }
     }
-    for (const key of ["routerClaudeModel", "tasksClaudeModel"]) {
+    for (const key of ['routerClaudeModel', 'tasksClaudeModel']) {
         const value = normalizeClaudeModel(incoming[key]);
         if (value && value !== settings[key]) {
             settings[key] = value;
-            changes.push(`${key === "routerClaudeModel" ? "operator" : "tasks"} claude model -> ${value}`);
+            changes.push(`${key === 'routerClaudeModel' ? 'operator' : 'tasks'} claude model -> ${value}`);
         }
     }
-    for (const key of ["routerOpenrouterModel", "tasksOpenrouterModel"]) {
+    for (const key of ['routerOpenrouterModel', 'tasksOpenrouterModel']) {
         const value = normalizeOpenrouterModel(incoming[key]);
         if (value && value !== settings[key]) {
             settings[key] = value;
-            changes.push(`${key === "routerOpenrouterModel" ? "operator" : "tasks"} openrouter model -> ${value}`);
+            changes.push(`${key === 'routerOpenrouterModel' ? 'operator' : 'tasks'} openrouter model -> ${value}`);
         }
     }
-    for (const key of ["routerReasoningEffort", "tasksReasoningEffort"]) {
+    for (const key of ['routerReasoningEffort', 'tasksReasoningEffort']) {
         const value = normalizeReasoningEffort(incoming[key]);
         if (value && value !== settings[key]) {
             settings[key] = value;
-            changes.push(`${key === "routerReasoningEffort" ? "operator" : "tasks"} reasoning effort -> ${value}`);
+            changes.push(`${key === 'routerReasoningEffort' ? 'operator' : 'tasks'} reasoning effort -> ${value}`);
         }
     }
-    for (const key of ["routerRouting", "tasksRouting"]) {
+    for (const key of ['routerRouting', 'tasksRouting']) {
         const value = normalizeRoutingMode(incoming[key]);
         if (value && value !== settings[key]) {
             settings[key] = value;
-            changes.push(`${key === "routerRouting" ? "operator" : "tasks"} routing -> ${value}`);
+            changes.push(`${key === 'routerRouting' ? 'operator' : 'tasks'} routing -> ${value}`);
         }
     }
-    for (const key of ["routerProviderTier", "tasksProviderTier"]) {
+    for (const key of ['routerProviderTier', 'tasksProviderTier']) {
         // "" is a valid value (auto), so check for null (invalid) explicitly
         // rather than truthiness -- otherwise the tier could never be cleared.
         const value = normalizeProviderTier(incoming[key]);
         if (value !== null && value !== settings[key]) {
             settings[key] = value;
-            changes.push(`${key === "routerProviderTier" ? "operator" : "tasks"} provider tier -> ${value || "auto"}`);
+            changes.push(`${key === 'routerProviderTier' ? 'operator' : 'tasks'} provider tier -> ${value || 'auto'}`);
         }
     }
     if (changes.length === 0)
@@ -3100,7 +3107,7 @@ function applyAgentSettings(incoming, ctx) {
     fs.writeFileSync(ctx.settingsPath, serializeAgentSettings(settings));
     // The value is saved and broadcast IMMEDIATELY -- validation never gates a
     // write. The verdict follows in a second frame once the catalog answers.
-    ctx.broadcast({ type: "settings", settings });
+    ctx.broadcast({ type: 'settings', settings });
     void broadcastSettingsWarnings(ctx);
 }
 // Belt to watchCredentials' braces: a directory that didn't exist at boot has
@@ -3117,11 +3124,11 @@ const ACCOUNTS_POLL_MS = 15_000;
 // The snapshot carries presence and a hint only; no frame from here ever moves
 // a key value toward a browser.
 function createAccountsFeed(opts) {
-    let last = "";
+    let last = '';
     // Tracked apart from the whole snapshot so a sign-in's phase transitions
     // (starting -> awaiting-code -> ...) don't each cost a budget fetch: they
     // move `login`, never a credential.
-    let lastProviders = "";
+    let lastProviders = '';
     function push(error) {
         const accounts = accountsSnapshot();
         const serialized = JSON.stringify(accounts);
@@ -3138,7 +3145,7 @@ function createAccountsFeed(opts) {
             return;
         last = serialized;
         opts.broadcast({
-            type: "accounts",
+            type: 'accounts',
             accounts,
             ...(error ? { accountsError: error } : {}),
         });
@@ -3165,26 +3172,26 @@ function createAccountsFeed(opts) {
     };
 }
 function applyCredentialChange(msg, ctx) {
-    const clearing = msg.type === "clear-credential";
-    if (!clearing && typeof msg.value !== "string")
+    const clearing = msg.type === 'clear-credential';
+    if (!clearing && typeof msg.value !== 'string')
         return;
     const result = writeCredential(msg.id, clearing ? null : msg.value);
     ctx.pushAccounts(result.ok
         ? undefined
-        : { id: typeof msg.id === "string" ? msg.id : "", message: result.message });
+        : { id: typeof msg.id === 'string' ? msg.id : '', message: result.message });
 }
 // Which slugs are worth a verdict: only roles actually routed at OpenRouter
 // (otherwise we'd warn about an inert leftover value), and only when a slug is
 // set at all.
 function slugKeysToValidate(settings) {
     const keys = [];
-    if (roleUsesOpenrouter(settings.router ?? "claude", settings.routerClaudeModel ?? "opus") &&
+    if (roleUsesOpenrouter(settings.router ?? 'claude', settings.routerClaudeModel ?? 'opus') &&
         settings.routerOpenrouterModel) {
-        keys.push("routerOpenrouterModel");
+        keys.push('routerOpenrouterModel');
     }
-    if (roleUsesOpenrouter(settings.tasks ?? "claude", settings.tasksClaudeModel ?? "sonnet") &&
+    if (roleUsesOpenrouter(settings.tasks ?? 'claude', settings.tasksClaudeModel ?? 'sonnet') &&
         settings.tasksOpenrouterModel) {
-        keys.push("tasksOpenrouterModel");
+        keys.push('tasksOpenrouterModel');
     }
     return keys;
 }
@@ -3200,20 +3207,20 @@ export async function computeSettingsWarnings(settings) {
         if (!model)
             return;
         const check = await checkOpenrouterModel(model);
-        if (check.status === "unknown-model") {
+        if (check.status === 'unknown-model') {
             // suggestion is carried SEPARATELY (not baked into message) so the
             // client can render it as a one-click fix rather than plain text.
             out[key] = {
                 model,
-                status: "unknown-model",
-                message: "No such model on OpenRouter.",
+                status: 'unknown-model',
+                message: 'No such model on OpenRouter.',
                 suggestion: check.suggestions[0],
             };
         }
-        else if (check.status === "no-tools") {
+        else if (check.status === 'no-tools') {
             out[key] = {
                 model,
-                status: "no-tools",
+                status: 'no-tools',
                 message: "This model can't use tools, so it can't do work. Pick another.",
             };
         }
@@ -3222,19 +3229,19 @@ export async function computeSettingsWarnings(settings) {
 }
 async function broadcastSettingsWarnings(ctx) {
     const settingsWarnings = await computeSettingsWarnings(ctx.settings);
-    ctx.broadcast({ type: "settings", settings: ctx.settings, settingsWarnings });
+    ctx.broadcast({ type: 'settings', settings: ctx.settings, settingsWarnings });
 }
 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 {
@@ -3242,23 +3249,21 @@ 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) {
                 // pid > 0 excludes smith runs (negative pseudo-pids, no OS process
                 // for the orphan sweep to kill -- see AgentRunHandle).
-                if (typeof child.pid === "number" &&
-                    child.pid > 0 &&
-                    child.exitCode === null) {
+                if (typeof child.pid === 'number' && child.pid > 0 && child.exitCode === null) {
                     live.push({ pid: child.pid, command: child.spawnfile });
                 }
             }
@@ -3268,7 +3273,7 @@ function startChildRegistry(registryPath, groups) {
             return;
         last = snapshot;
         try {
-            fs.writeFileSync(registryPath, snapshot + "\n");
+            fs.writeFileSync(registryPath, snapshot + '\n');
         }
         catch {
             /* best effort */
@@ -3277,7 +3282,7 @@ function startChildRegistry(registryPath, groups) {
     return () => {
         clearInterval(timer);
         try {
-            fs.writeFileSync(registryPath, "[]\n");
+            fs.writeFileSync(registryPath, '[]\n');
         }
         catch {
             /* best effort */
@@ -3296,14 +3301,14 @@ function loadRecoverableSends(pendingPath, committedIds) {
     const recovered = [];
     for (const item of stored) {
         if (item &&
-            typeof item.id === "string" &&
-            typeof item.text === "string" &&
+            typeof item.id === 'string' &&
+            typeof item.text === 'string' &&
             Array.isArray(item.attachments) &&
             !committedIds.has(item.id)) {
             recovered.push({
                 id: item.id,
                 text: item.text,
-                attachments: item.attachments.filter((a) => typeof a === "string"),
+                attachments: item.attachments.filter((a) => typeof a === 'string'),
             });
         }
     }
@@ -3317,9 +3322,9 @@ function loadRecoverableSends(pendingPath, committedIds) {
 // cannot be un-launched, so folding it away would abandon in-flight work, not
 // just discard stale intent.
 function turnHasVisibleOutput(messages) {
-    return messages.some((m) => m.role === "assistant" &&
-        m.status === "streaming" &&
-        (m.text.trim() !== "" || (m.taskIds?.length ?? 0) > 0));
+    return messages.some((m) => m.role === 'assistant' &&
+        m.status === 'streaming' &&
+        (m.text.trim() !== '' || (m.taskIds?.length ?? 0) > 0));
 }
 // Re-queue a turn's already-logged user messages (its `inFlightSends`) onto
 // the front of the pending queue, marked `logged` so the next drain composes
@@ -3335,14 +3340,14 @@ function reclaimInFlightSends(pendingSends, inFlightSends) {
 // Mirror the in-memory queue to disk. Called on every mutation (enqueue,
 // drain, cancel, recover) so a restart never loses an unsent queued message.
 function persistPendingSends(ctx) {
-    fs.writeFileSync(ctx.pendingPath, JSON.stringify(ctx.state.pendingSends, null, 2) + "\n");
+    fs.writeFileSync(ctx.pendingPath, JSON.stringify(ctx.state.pendingSends, null, 2) + '\n');
 }
 function computeQueuedSnippets(pendingSends) {
     return pendingSends.map((p) => p.text.trim()).filter(Boolean);
 }
 function broadcastQueueState(ctx) {
     ctx.broadcast({
-        type: "router-state",
+        type: 'router-state',
         running: ctx.state.routerRunning,
         queued: computeQueuedSnippets(ctx.state.pendingSends),
     });
@@ -3351,18 +3356,18 @@ function broadcastQueueState(ctx) {
 // they had streamed (joined) so a manual interrupt can carry it forward.
 function killRouterChildren(ctx) {
     const drafts = ctx.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 ctx.routerChildren) {
         try {
-            child.kill("SIGKILL");
+            child.kill('SIGKILL');
         }
         catch {
             /* already gone */
         }
     }
-    return drafts.join("\n\n");
+    return drafts.join('\n\n');
 }
 function startRouterTurn(ctx, instruction, attachments = []) {
     ctx.state.lastInstruction = instruction;
@@ -3401,10 +3406,10 @@ function commitDrainedSends(drained, log) {
         if (!item.logged) {
             const message = {
                 id: item.id,
-                role: "user",
+                role: 'user',
                 text: item.text,
                 at: nowIso(),
-                status: "done",
+                status: 'done',
             };
             if (item.attachments.length > 0)
                 message.attachments = item.attachments;
@@ -3413,7 +3418,7 @@ function commitDrainedSends(drained, log) {
         if (item.text.trim())
             texts.push(item.text);
         for (const name of item.attachments) {
-            attachmentPaths.push(path.join(".castle", "agent", "attachments", name));
+            attachmentPaths.push(path.join('.castle', 'agent', 'attachments', name));
         }
     }
     return { texts, attachmentPaths };
@@ -3436,7 +3441,7 @@ function maybeStartRouterQueueTurn(ctx) {
     // The queue is now committed to messages.json; clear its durable mirror.
     persistPendingSends(ctx);
     const draft = state.pendingInterruptedDraft;
-    state.pendingInterruptedDraft = "";
+    state.pendingInterruptedDraft = '';
     state.routerRunning = true;
     broadcastQueueState(ctx);
     startRouterTurn(ctx, userTurnInstruction({
@@ -3534,7 +3539,7 @@ function interruptRouterQueue(ctx) {
         // Only carry the partial draft forward when a queued message will consume
         // it imminently ("Send now"). A bare Stop (empty composer) must not park
         // the draft, or it leaks into the next unrelated message.
-        state.pendingInterruptedDraft = hasFollowUp ? draft : "";
+        state.pendingInterruptedDraft = hasFollowUp ? draft : '';
     }
     else {
         maybeStartRouterQueueTurn(ctx);
@@ -3558,16 +3563,16 @@ function cancelQueuedSend(ctx, index) {
 function createRouterQueue(deps) {
     const ctx = {
         ...deps,
-        pendingPath: path.join(deps.agentDir, "pending-sends.json"),
+        pendingPath: path.join(deps.agentDir, 'pending-sends.json'),
         state: {
             userEpoch: 0,
             routerRunning: false,
             pendingSends: [],
             inFlightSends: [],
-            pendingInterruptedDraft: "",
+            pendingInterruptedDraft: '',
             autoRetryUsed: false,
             autoFoldUsed: false,
-            lastInstruction: "",
+            lastInstruction: '',
             lastAttachments: [],
         },
     };
@@ -3588,10 +3593,10 @@ export function createAgentServer(opts) {
     const { deckDir, deckLabel } = opts;
     const quickReference = readQuickReference(deckDir);
     const welcomeMessage = readWelcomeMessage(deckDir) || DEFAULT_WELCOME_MESSAGE;
-    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 });
     // Warm the OpenRouter catalog now so the first pre-flight and the first
     // popover open read a cache instead of paying for the fetch. Fire-and-forget
@@ -3622,12 +3627,9 @@ export function createAgentServer(opts) {
     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) {
@@ -3640,7 +3642,7 @@ 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 settings = loadAgentSettings(settingsPath);
     const usageFeed = createUsageFeed({
         broadcast,
@@ -3677,7 +3679,7 @@ export function createAgentServer(opts) {
         playtest,
         restart: opts.restart,
         // Task lifecycle stays on the board only -- log lines for it were spam.
-        onUpdate: (task) => broadcast({ type: "task-update", task: asClientTask(task) }),
+        onUpdate: (task) => broadcast({ type: 'task-update', task: asClientTask(task) }),
         onStarted: () => undefined,
         onRetry: (task, attempt) => addLog(`agent died, retrying (${attempt}/${MAX_TASK_ATTEMPTS}): ${task.title}`),
         onFinished: (task) => taskFeeds.map.delete(task.id),
@@ -3705,10 +3707,10 @@ export function createAgentServer(opts) {
     // (so it respects the send queue).
     function handlePickerChoice(id, answers, text) {
         const msg = messages.find((m) => m.id === id);
-        if (msg && msg.role === "assistant" && answers && typeof answers === "object") {
+        if (msg && msg.role === 'assistant' && answers && typeof answers === 'object') {
             msg.pickerAnswers = answers;
             log.persist();
-            broadcast({ type: "message-picker", id, pickerAnswers: msg.pickerAnswers });
+            broadcast({ type: 'message-picker', id, pickerAnswers: msg.pickerAnswers });
         }
         if (text.trim())
             routerQueue.handleUserMessage(text.trim(), undefined);
@@ -3720,7 +3722,7 @@ export function createAgentServer(opts) {
     function attachClient(socket) {
         clients.add(socket);
         const hello = {
-            type: "hello",
+            type: 'hello',
             messages,
             tasks: taskStore.sorted().map(asClientTask),
             settings,
@@ -3742,7 +3744,7 @@ export function createAgentServer(opts) {
         // nothing changed), so a migrated or hand-edited slug would stay silent.
         // The catalog is primed at boot, so in practice this lands immediately.
         void broadcastSettingsWarnings({ settings, broadcast });
-        socket.on("message", (rawData) => {
+        socket.on('message', (rawData) => {
             let msg;
             try {
                 msg = JSON.parse(rawDataToString(rawData));
@@ -3750,56 +3752,55 @@ 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)) {
-                routerQueue.handleUserMessage(typeof msg.text === "string" ? msg.text.trim() : "", msg.images);
+            if (msg.type === 'user-message' && (hasText || hasImages)) {
+                routerQueue.handleUserMessage(typeof msg.text === 'string' ? msg.text.trim() : '', msg.images);
             }
-            else if (msg.type === "interrupt") {
+            else if (msg.type === 'interrupt') {
                 routerQueue.interruptRouter();
             }
-            else if (msg.type === "cancel-queued" && typeof msg.index === "number") {
+            else if (msg.type === 'cancel-queued' && typeof msg.index === 'number') {
                 routerQueue.cancelQueued(msg.index);
             }
-            else if (msg.type === "picker-choice" && typeof msg.id === "string") {
-                handlePickerChoice(msg.id, msg.answers, typeof msg.text === "string" ? msg.text : "");
+            else if (msg.type === 'picker-choice' && typeof msg.id === 'string') {
+                handlePickerChoice(msg.id, msg.answers, typeof msg.text === 'string' ? msg.text : '');
             }
-            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);
             }
-            else if (msg.type === "set-credential" ||
-                msg.type === "clear-credential") {
+            else if (msg.type === 'set-credential' || msg.type === 'clear-credential') {
                 applyCredentialChange(msg, { pushAccounts: accountsFeed.push });
             }
-            else if (msg.type === "account-login") {
+            else if (msg.type === 'account-login') {
                 const provider = loginProviderFor(msg.id);
                 if (provider)
                     startLogin(provider, () => accountsFeed.push());
             }
-            else if (msg.type === "account-login-code" && typeof msg.value === "string") {
+            else if (msg.type === 'account-login-code' && typeof msg.value === 'string') {
                 submitLoginCode(msg.value);
             }
-            else if (msg.type === "account-login-cancel") {
+            else if (msg.type === 'account-login-cancel') {
                 cancelLogin();
             }
-            else if (msg.type === "account-logout") {
+            else if (msg.type === 'account-logout') {
                 const provider = loginProviderFor(msg.id);
                 if (provider)
                     logout(provider, () => accountsFeed.push());
             }
-            else if (msg.type === "client-timezone" && typeof msg.timeZone === "string") {
+            else if (msg.type === 'client-timezone' && typeof msg.timeZone === 'string') {
                 setReaderTimeZone(msg.timeZone);
             }
         });
-        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));
@@ -3816,7 +3817,7 @@ export function createAgentServer(opts) {
         taskStore.shutdown();
         for (const child of [...taskChildren, ...routerChildren]) {
             try {
-                child.kill("SIGKILL");
+                child.kill('SIGKILL');
             }
             catch {
                 /* already gone */