castle-web-cli 0.4.78 → 0.4.79

package/dist/agent.js

@@ -22,26 +22,129 @@ 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 { 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/";
 const DEFAULT_SETTINGS = {
     router: "claude",
     tasks: "claude",
-    claudeModel: "opus",
+    routerClaudeModel: "opus",
+    // Tasks default one tier down: task agents run long unattended builds, so
+    // sonnet's cost/speed wins by default; the conductor stays on opus.
+    tasksClaudeModel: "sonnet",
+    // Free-form -- change to any OpenRouter slug.
+    routerOpenrouterModel: "google/gemini-3.5-flash",
+    tasksOpenrouterModel: "google/gemini-3.5-flash",
 };
 function normalizeBackend(value) {
-    return value === "cursor" || value === "claude" ? value : null;
+    return value === "cursor" || value === "claude" || value === "smith"
+        ? value
+        : null;
+}
+// Settings written before the smith backend existed used "openrouter" as a
+// BACKEND value meaning "claude CLI routed at OpenRouter" -- exactly what
+// backend "claude" + that role's claude model "openrouter" means now. Used
+// only when loading persisted settings (normalizeBackend rejects it live) so
+// old decks keep their behavior across the upgrade.
+function migrateStoredBackend(value) {
+    if (value === "openrouter")
+        return "claude";
+    return normalizeBackend(value);
 }
 function normalizeClaudeModel(value) {
-    return value === "sonnet" || value === "opus" || value === "fable"
+    return value === "sonnet" ||
+        value === "opus" ||
+        value === "fable" ||
+        value === "openrouter"
         ? value
         : null;
 }
-// Build the headless CLI invocation for a backend/role. Cursor's router runs
-// in read-only ask mode; claude runs permission-mode auto for both roles (NOT
-// plan mode -- that makes it emit plan tool calls) at medium effort.
-function buildAgentInvocation(backend, role, prompt, claudeModel) {
+// Free-form, so validation is just "non-empty, not absurdly long" (guards
+// 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")
+        return null;
+    const trimmed = value.trim();
+    return trimmed && trimmed.length <= OPENROUTER_MODEL_MAX_LEN ? trimmed : null;
+}
+// OpenRouter's Anthropic-compatible endpoint (confirmed current, 2026: it
+// accepts the standard Anthropic Messages API shape -- text/tool-use/
+// extended-thinking -- for ANY OpenRouter model slug, not just Anthropic
+// ones). Using it directly means claude CLI's OWN stream-json + tool loop
+// talks to OpenRouter with zero translation layer -- no proxy needed.
+const OPENROUTER_BASE_URL = "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
+// Anthropic auth (verified live against the real `claude` binary while
+// building this):
+// - ANTHROPIC_AUTH_TOKEN (not ANTHROPIC_API_KEY) takes precedence over a
+//   saved claude.ai/Console login IMMEDIATELY, with no interactive approval
+//   prompt -- ANTHROPIC_API_KEY needs a one-time approval in interactive
+//   mode, which a headless `-p` run can never satisfy.
+// - ANTHROPIC_API_KEY is explicitly deleted so it's never ALSO sent (Claude
+//   Code warns "both a token and an API key are set" otherwise).
+// CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1 is required for a reason that
+// only showed up under live testing: without it, --model is validated
+// against claude CLI's own built-in model catalog client-side -- an unknown
+// slug like "openai/gpt-5.1" 404s with a synthetic "model_not_found" and
+// NEVER reaches the network. Setting it makes the CLI accept any --model
+// string and actually send the request upstream.
+function envForOpenrouterSpawn() {
+    const env = { ...process.env };
+    delete env.ANTHROPIC_API_KEY;
+    env.ANTHROPIC_BASE_URL = OPENROUTER_BASE_URL;
+    env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
+    const val = openrouterApiKey();
+    if (val)
+        env.ANTHROPIC_AUTH_TOKEN = val;
+    else
+        delete env.ANTHROPIC_AUTH_TOKEN;
+    return env;
+}
+// The one OpenRouter credential, shared by BOTH OpenRouter paths: smith's
+// native loop passes it as runAgentNative's apiKey (Bearer header), and the
+// 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";
+function openrouterApiKey() {
+    return castleKeys()[OPENROUTER_KEY_NAME] ?? process.env[OPENROUTER_KEY_NAME] ?? "";
+}
+// Build the headless CLI invocation for a spawning backend/role (smith never
+// comes through here -- it has no CLI process; see runAgentSmith). Cursor's
+// router runs in read-only ask mode; claude runs permission-mode auto for
+// both roles (NOT plan mode -- that makes it emit plan tool calls) at medium
+// effort. claudeModel "openrouter" keeps the SAME claude binary/flags and
+// swaps only the model slug and env (see envForOpenrouterSpawn) -- plus one
+// extra permission grant, see OPENROUTER_ALLOWED_TOOLS below.
+// claude CLI 2.1.198 SILENTLY resolves `--permission-mode auto` to "default"
+// whenever --model is not in its built-in catalog -- which is every free-form
+// OpenRouter slug (verified live: `--model sonnet` inits with
+// permissionMode "auto"; `--model anthropic/claude-sonnet-4.5` inits with
+// "default" under identical argv/env; the gateway env vars are irrelevant).
+// Headless (-p) default mode then denies every prompt-requiring tool with
+// "you haven't granted it yet", so OR-routed tasks could never edit files
+// (incident: task UmI8O3VR looped ~60 denials, then exited 0 having done
+// nothing). This explicit tool allowlist restores auto's effective headless
+// capability -- edits plus unrestricted Bash, network commands included
+// (acceptEdits was rejected: it survives the downgrade but still denies
+// network Bash like curl, which plain auto allows). Deliberately NOT passed
+// 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";
+function buildAgentInvocation(backend, role, prompt, claudeModel, 
+// Already resolved for this role by the caller (router turns pass
+// settings.routerOpenrouterModel, task spawns settings.tasksOpenrouterModel).
+openrouterModel) {
     if (backend === "claude") {
+        const viaOpenrouter = claudeModel === "openrouter";
         return {
             command: "claude",
             args: [
@@ -52,10 +155,18 @@ function buildAgentInvocation(backend, role, prompt, claudeModel) {
                 "--include-partial-messages",
                 "--permission-mode",
                 "auto",
+                ...(viaOpenrouter ? [OPENROUTER_ALLOWED_TOOLS] : []),
                 "--model",
-                claudeModel,
+                viaOpenrouter ? openrouterModel : claudeModel,
                 "--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",
                 // 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.
@@ -67,6 +178,7 @@ function buildAgentInvocation(backend, role, prompt, claudeModel) {
                     : []),
                 prompt,
             ],
+            env: viaOpenrouter ? envForOpenrouterSpawn() : envForAgentSpawn(backend),
         };
     }
     return {
@@ -82,8 +194,12 @@ function buildAgentInvocation(backend, role, prompt, claudeModel) {
             ...(role === "router" ? ["--mode", "ask"] : ["--force"]),
             prompt,
         ],
+        env: envForAgentSpawn(backend),
     };
 }
+function parserForBackend(backend) {
+    return backend === "cursor" ? "cursor" : "claude";
+}
 const ROUTER_TIMEOUT_MS = 3 * 60_000;
 const TASK_TIMEOUT_MS = 30 * 60_000;
 const MAX_TASK_ATTEMPTS = 3;
@@ -299,6 +415,22 @@ function humanizeAskBlocks(text) {
         }
     });
 }
+// Monotonic source of smith pseudo-pids (see AgentRunHandle.pid).
+let smithRunSeq = 0;
+function makeSmithRunHandle(controller) {
+    smithRunSeq += 1;
+    return {
+        pid: -smithRunSeq,
+        // 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",
+        kill: () => {
+            controller.abort();
+            return true;
+        },
+    };
+}
 function baseName(p) {
     const parts = p.split(/[\\/]/).filter(Boolean);
     return parts[parts.length - 1] || p;
@@ -381,6 +513,9 @@ function castleKeys() {
         return {};
     }
 }
+// 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",
@@ -432,9 +567,22 @@ const DECK_TREE_MAX_ENTRIES = 200;
 // from the snapshot entirely. Summarizing the overflow as "(+N more .pxart)"
 // keeps every directory visible and turns the count itself into signal.
 const DECK_TREE_PER_DIR = 15;
+// Smith-only slimmed caps for the tree section on a turn where
+// buildDeckContents (below) already inlined the deck's actual source -- the
+// tree's job shrinks from "the listing" to "orientation for whatever isn't
+// inlined" (art/binaries, and any overflow buildDeckContents had to list
+// instead of inline), so it doesn't need the full 200-entry/15-per-dir detail
+// the CLI backends still get (they have no contents section to lean on).
+const DECK_TREE_SLIM_MAX_ENTRIES = 60;
+const DECK_TREE_SLIM_PER_DIR = 8;
 // Shallow orientation snapshot for router/task prompts. Best-effort by design:
-// filesystem hiccups should cost context, not fail an agent turn.
-function buildDeckTree(deckDir) {
+// filesystem hiccups should cost context, not fail an agent turn. `caps` lets
+// a smith turn ask for the slimmed version above once deck contents are
+// already inlined; omitted (the CLI backends) keeps today's byte-identical
+// output.
+function buildDeckTree(deckDir, caps) {
+    const maxEntries = caps?.maxEntries ?? DECK_TREE_MAX_ENTRIES;
+    const perDir = caps?.perDir ?? DECK_TREE_PER_DIR;
     const lines = [];
     const walk = (dir, prefix, depth) => {
         let entries;
@@ -450,8 +598,8 @@ function buildDeckTree(deckDir) {
             return a.name.localeCompare(b.name);
         });
         const visible = entries.filter((e) => !DECK_TREE_EXCLUDE.has(e.name));
-        for (const entry of visible.slice(0, DECK_TREE_PER_DIR)) {
-            if (lines.length >= DECK_TREE_MAX_ENTRIES) {
+        for (const entry of visible.slice(0, perDir)) {
+            if (lines.length >= maxEntries) {
                 lines.push(`${prefix}...`);
                 return;
             }
@@ -461,8 +609,8 @@ function buildDeckTree(deckDir) {
                 walk(path.join(dir, entry.name), prefix + "  ", depth + 1);
             }
         }
-        const rest = visible.slice(DECK_TREE_PER_DIR);
-        if (rest.length > 0 && lines.length < DECK_TREE_MAX_ENTRIES) {
+        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))));
@@ -474,7 +622,145 @@ function buildDeckTree(deckDir) {
     walk(deckDir, "", 0);
     return lines.join("\n");
 }
-function readQuickReference(deckDir) {
+// Text source extensions buildDeckContents will inline. Deliberately an
+// allowlist (not "everything readable") -- decks are small web projects, so
+// this covers what an agent actually hand-edits. SVG is included: it's a text
+// format read_file already treats as source (view_image explicitly excludes
+// it for the same reason). .scene is included too, and deliberately not
+// filtered out despite looking like data: scenes/*.scene and
+// blueprints/*.scene are JSON (actors, behaviors, layout), and they are
+// exactly what a router/task agent orients on first when it opens a kit deck
+// -- leaving them out just forces the hand-read this inlining exists to
+// avoid (castle.json needs no separate entry -- it's already covered by
+// `.json`). .pxart is deliberately NOT added even though it's also
+// JSON-ish text: pixel-art drawings are bulky per-pixel grid data, not
+// orientation material an agent reads to understand the deck, and they're
+// meant to be produced by a tool/command, not hand-typed -- inlining them
+// would just burn budget for content the agent isn't meant to
+// read-then-copy-edit. True binary/art formats (images, audio, fonts) and
+// 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",
+]);
+// 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",
+]);
+// 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
+// modules run a few KB each) while still being small next to the total budget
+// below.
+const DECK_CONTENTS_PER_FILE_CAP = 16 * 1024;
+// Safety valve against a pathological tree (mirrors tools.ts's
+// MAX_WALK_FILES) -- decks are modest-sized web projects, this is not a
+// normal limit.
+const DECK_CONTENTS_MAX_WALK_FILES = 5_000;
+// Smith-only total budgets (bytes), passed by the call sites below. The
+// router's prompt is already the largest (rules + full transcript + the
+// whole task board), so it gets a tighter ceiling than a task's -- a task
+// prompt is comparatively lean and can afford to carry more of the deck.
+const TASK_DECK_CONTENTS_BUDGET = 80 * 1024;
+const ROUTER_DECK_CONTENTS_BUDGET = 40 * 1024;
+// Full-content inlining for smith prompts (buildTaskPrompt/buildRouterPrompt's
+// `deckContents`): unlike buildDeckTree (shallow, name-only, same for every
+// backend), this walks the ENTIRE file set the tree covers -- no depth limit
+// -- because the point is to hand smith the deck's actual code, not just its
+// shape. Only smith needs this: cursor/claude read files with their own tools
+// turn over turn, but smith's native loop pays a full round-trip (a tool call
+// + its result re-entering context on every later iteration) for every read,
+// and Castle decks are tiny enough that this rarely costs more than one
+// inlining would anyway -- so front-loading it removes those round trips
+// entirely for the common small/greenfield deck.
+//
+// `budget` (bytes) is the caller's total ceiling (tasks get more room than
+// the router -- see the call sites in runTaskAgentIn / routerTurnPrompt).
+// Degrades gracefully under both caps: a file over DECK_CONTENTS_PER_FILE_CAP,
+// or one that would push the running total over `budget`, is listed by name
+// instead of inlined (deterministic order -- once the budget is spent every
+// later file lists too, it never back-fills a smaller one out of order).
+function buildDeckContents(deckDir, budget) {
+    const files = [];
+    const walk = (dir) => {
+        if (files.length >= DECK_CONTENTS_MAX_WALK_FILES)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (DECK_TREE_EXCLUDE.has(entry.name))
+                continue;
+            const abs = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(abs);
+            }
+            else if (entry.isFile()) {
+                files.push(abs);
+                if (files.length >= DECK_CONTENTS_MAX_WALK_FILES)
+                    return;
+            }
+        }
+    };
+    walk(deckDir);
+    const inlined = [];
+    const listed = [];
+    let used = 0;
+    for (const abs of files) {
+        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()))
+            continue;
+        let stat;
+        try {
+            stat = fs.statSync(abs);
+        }
+        catch {
+            continue;
+        }
+        if (stat.size > DECK_CONTENTS_PER_FILE_CAP || used + stat.size > budget) {
+            listed.push(`${rel} (${stat.size}b, not inlined -- use read tool)`);
+            continue;
+        }
+        let content;
+        try {
+            content = fs.readFileSync(abs, "utf8");
+        }
+        catch {
+            listed.push(`${rel} (not inlined -- use read tool)`);
+            continue;
+        }
+        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)`);
+            continue;
+        }
+        inlined.push(`--- ${rel} ---\n${content}`);
+        used += stat.size;
+    }
+    const parts = [];
+    if (inlined.length > 0)
+        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")}`);
+    }
+    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 = "";
         try {
@@ -483,7 +769,7 @@ function readQuickReference(deckDir) {
         catch {
             continue;
         }
-        const heading = /^## Quick reference\s*$/im.exec(raw);
+        const heading = headingRe.exec(raw);
         if (!heading || heading.index === undefined)
             continue;
         const bodyStart = raw.indexOf("\n", heading.index);
@@ -495,6 +781,12 @@ function readQuickReference(deckDir) {
     }
     return "";
 }
+function readQuickReference(deckDir) {
+    return readClaudeSection(deckDir, "Quick reference");
+}
+function readWelcomeMessage(deckDir) {
+    return readClaudeSection(deckDir, "Welcome message");
+}
 const TOUCHED_FILE_LIMIT = 10;
 function collectStrings(value, out) {
     if (typeof value === "string") {
@@ -656,14 +948,18 @@ function formatTokenCount(value) {
         return `${(value / 1000).toFixed(1)}k`;
     return String(value);
 }
-function logRouterUsage(backend, usage) {
+// One usage line per finished agent run, labeled per role/backend so the
+// serve's stderr is a running cost ledger for BOTH roles: `label` is
+// "router" or "task <id>". Task runs log once per attempt (each attempt is
+// its own CLI process / native run with its own usage).
+function logAgentUsage(label, backend, usage) {
     if (!usage)
         return;
     const input = formatTokenCount(usage.input_tokens);
     const read = formatTokenCount(usage.cache_read_input_tokens);
     const created = formatTokenCount(usage.cache_creation_input_tokens);
     const output = formatTokenCount(usage.output_tokens);
-    console.error(`[agent usage] router ${backend}: input=${input} cache_read=${read} cache_created=${created} output=${output}`);
+    console.error(`[agent usage] ${label} ${backend}: input=${input} cache_read=${read} cache_created=${created} output=${output}`);
 }
 // Build the per-run stdout event handler over a shared mutable parser state.
 // Splitting the cursor + claude stream decoding out of runAgentCli keeps each
@@ -811,7 +1107,7 @@ function runAgentCli(opts) {
     return new Promise((resolve) => {
         const child = spawn(opts.command, opts.args, {
             cwd: opts.cwd,
-            env: envForAgentSpawn(opts.parser),
+            env: opts.env,
             stdio: ["ignore", "pipe", "pipe"],
         });
         opts.children.add(child);
@@ -891,6 +1187,123 @@ function runAgentCli(opts) {
         });
     });
 }
+// One smith (native castle agent) run, adapted to runAgentCli's contract so
+// every caller downstream of runAgentTurn is backend-agnostic:
+// - NativeRunResult.text -> finalText; error/usage/filesTouched/crashed pass
+//   through by name. `ok` is derived as !error && !crashed -- there is no
+//   process exit code; those two fields are the whole story.
+// - Cancellation: one AbortController per run, registered in the same
+//   `children` set the CLI runs use, via a handle whose kill() aborts it
+//   (see AgentRunHandle). Interrupts (killRouterChildren), task halts
+//   (haltTask), and serve shutdown all just work. An aborted run resolves
+//   with error "agent run stopped" and NO crashed flag -- same downstream
+//   behavior as a SIGKILLed CLI child (router: the epoch check routes to
+//   settleInterruptedTurn; tasks: stopRequested returns before the retry
+//   check).
+// - Timeout is enforced INSIDE runAgentNative (same "agent run timed out"
+//   error string runAgentCli produces, so classifyRouterFailure's buckets
+//   hold); connect failures surface as "could not run openrouter: ..."
+//   matching the "could not run" spawn bucket.
+// - logPath appends structured JSONL run events to the SAME files the CLI
+//   backends stream their raw log into (tasks/<id>/log.jsonl,
+//   .castle/agent/router-log.jsonl) -- see createRunLogger in native/loop.ts
+//   for the line shapes.
+// - attachments (router turns): deck-relative image paths that become
+//   image_url content parts in the run's initial user message -- the native
+//   tool set can't read image bytes (read_file rejects binaries), unlike the
+//   CLI agents which re-read attachment files themselves.
+async function runAgentSmith(opts) {
+    const controller = new AbortController();
+    const handle = makeSmithRunHandle(controller);
+    opts.children.add(handle);
+    // The pseudo-pid lands in task.pid so haltTask can find this run's handle
+    // in the shared children set, exactly like a CLI child's real pid.
+    opts.onSpawn?.(handle.pid);
+    try {
+        const result = await runAgentNative({
+            cwd: opts.cwd,
+            role: opts.role,
+            model: opts.model,
+            apiKey: openrouterApiKey(),
+            prompt: opts.prompt,
+            systemReminder: opts.systemReminder,
+            attachments: opts.attachments,
+            timeoutMs: opts.timeoutMs,
+            logPath: opts.logPath,
+            playtest: opts.playtest,
+            restart: opts.restart,
+            signal: controller.signal,
+            onDelta: opts.onDelta,
+            onActivity: opts.onActivity,
+            onThinking: opts.onThinking,
+        });
+        return {
+            ok: !result.error && !result.crashed,
+            finalText: result.text,
+            error: result.error,
+            usage: result.usage,
+            filesTouched: result.filesTouched,
+            playtestFrames: result.playtestFrames,
+            crashed: result.crashed,
+        };
+    }
+    catch (err) {
+        // runAgentNative resolves (never rejects) by contract; this is pure
+        // belt-and-braces so an unexpected throw degrades like a spawn failure
+        // instead of rejecting through startTask's catch.
+        return {
+            ok: false,
+            finalText: "",
+            error: `could not run openrouter: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    finally {
+        opts.children.delete(handle);
+    }
+}
+// The one backend dispatch point for running an agent turn: smith runs
+// in-process (runAgentSmith -> runAgentNative); cursor/claude spawn a CLI
+// (buildAgentInvocation -> runAgentCli). Everything downstream consumes the
+// same CliRunResult contract either way.
+function runAgentTurn(opts) {
+    if (opts.backend === "smith") {
+        return runAgentSmith({
+            cwd: opts.cwd,
+            role: opts.role,
+            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,
+            attachments: opts.attachments,
+            timeoutMs: opts.timeoutMs,
+            logPath: opts.logPath,
+            playtest: opts.playtest,
+            restart: opts.restart,
+            children: opts.children,
+            onDelta: opts.onDelta,
+            onActivity: opts.onActivity,
+            onThinking: opts.onThinking,
+            onSpawn: opts.onSpawn,
+        });
+    }
+    const invocation = buildAgentInvocation(opts.backend, opts.role, opts.prompt, opts.claudeModel, opts.openrouterModel);
+    return runAgentCli({
+        cwd: opts.cwd,
+        command: invocation.command,
+        args: invocation.args,
+        parser: parserForBackend(opts.backend),
+        env: invocation.env,
+        timeoutMs: opts.timeoutMs,
+        logPath: opts.logPath,
+        children: opts.children,
+        onDelta: opts.onDelta,
+        onActivity: opts.onActivity,
+        onThinking: opts.onThinking,
+        onSpawn: opts.onSpawn,
+        labelUnknownTools: opts.labelUnknownTools,
+    });
+}
 // -- task store ---------------------------------------------------------------
 function persistTaskFile(tasksDir, task) {
     fs.writeFileSync(path.join(tasksDir, task.id, "task.json"), JSON.stringify(task, null, 2) + "\n");
@@ -996,6 +1409,8 @@ function depsSummaryFor(tasks, task) {
         const parts = [`- "${dep.title}" finished ${dep.status}`];
         if (dep.files && dep.files.length > 0)
             parts.push(`  files it touched: ${dep.files.join(", ")}`);
+        if (dep.suspectNoChanges)
+            parts.push("  caution: it finished without touching any tracked files (bash side effects aren't tracked) -- verify its work actually landed before building on it");
         // The agent's own closing prose is the real handoff -- names it created,
         // what it wired, what it left undone. The notes file is player-facing
         // and deliberately stripped of that detail.
@@ -1037,6 +1452,13 @@ async function waitBeforeTaskRetry(attempt, stopRequested, taskId) {
 async function runTaskAgentIn(ctx, task) {
     const dir = path.join(ctx.tasksDir, task.id);
     const relDir = path.relative(ctx.deckDir, dir);
+    // 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 deckContents = isSmith
+        ? buildDeckContents(ctx.deckDir, TASK_DECK_CONTENTS_BUDGET)
+        : undefined;
     const taskPrompt = buildTaskPrompt({
         deckLabel: ctx.deckLabel,
         taskId: task.id,
@@ -1046,7 +1468,11 @@ async function runTaskAgentIn(ctx, task) {
         notesPath: path.join(relDir, "notes.md"),
         depsSummary: ctx.depsSummary,
         backend: ctx.backend,
-        deckTree: buildDeckTree(ctx.deckDir),
+        // Slimmed once contents are inlined -- see DECK_TREE_SLIM_* above.
+        deckTree: buildDeckTree(ctx.deckDir, isSmith
+            ? { maxEntries: DECK_TREE_SLIM_MAX_ENTRIES, perDir: DECK_TREE_SLIM_PER_DIR }
+            : undefined),
+        deckContents,
         quickReference: ctx.quickReference,
         siblings: ctx.siblings,
     });
@@ -1056,7 +1482,14 @@ async function runTaskAgentIn(ctx, task) {
     // can't-verify-live-play loop. A single message + the autonomy reminder
     // appended to the system prompt (CLAUDE_TASK_SYSTEM_REMINDER) is enough to
     // get the work done; the agent stops when the code is in, the user verifies.
-    const invocation = buildAgentInvocation(ctx.backend, "task", taskPrompt, ctx.claudeModel);
+    // Pre-warm the playtest browser download as soon as a smith task starts
+    // (fire-and-forget; single-flight shared with any real playtest call), so
+    // the ~250MB one-time install usually completes during the agent's early
+    // 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")
+        ctx.playtest?.prewarm?.();
     let result = { ok: false, finalText: "", error: "not run" };
     let lineBuf = "";
     // ```signal blocks span multiple lines and must NOT show in the live feed:
@@ -1095,13 +1528,19 @@ async function runTaskAgentIn(ctx, task) {
     };
     for (let attempt = 1; attempt <= MAX_TASK_ATTEMPTS; attempt++) {
         await staggerTaskSpawn();
-        result = await runAgentCli({
+        result = await runAgentTurn({
+            backend: ctx.backend,
+            role: "task",
+            prompt: taskPrompt,
+            claudeModel: ctx.claudeModel,
+            openrouterModel: ctx.openrouterModel,
             cwd: ctx.deckDir,
-            command: invocation.command,
-            args: invocation.args,
-            parser: ctx.backend,
             timeoutMs: TASK_TIMEOUT_MS,
             logPath: path.join(dir, "log.jsonl"),
+            playtest: ctx.playtest
+                ? { executor: ctx.playtest.executor, serveUrl: ctx.playtest.serveUrl, framesDir: path.join(dir, "playtest") }
+                : undefined,
+            restart: ctx.restart,
             children: ctx.children,
             onSpawn: (pid) => {
                 task.pid = pid;
@@ -1113,6 +1552,7 @@ async function runTaskAgentIn(ctx, task) {
                     ctx.onFeed(`[${activity}]`);
             },
         });
+        logAgentUsage(`task ${task.id}`, ctx.backend, result.usage);
         if (ctx.stopRequested.has(task.id))
             return result;
         if (!result.crashed)
@@ -1146,8 +1586,11 @@ function startTask(ctx, task) {
         children: ctx.children,
         backend: ctx.backend(),
         claudeModel: ctx.claudeModel(),
+        openrouterModel: ctx.openrouterModel(),
         stopRequested: ctx.stopRequested,
         quickReference: ctx.quickReference,
+        playtest: ctx.playtest,
+        restart: ctx.restart,
         depsSummary: depsSummaryFor(ctx.tasks, task),
         // Same visibility rule as the router's board (hide acked+finished rows),
         // minus this task itself. Snapshot at start -- consistent with the deck
@@ -1196,6 +1639,11 @@ function startTask(ctx, task) {
             if (result.ok && !wasStopped)
                 task.progress = 100;
             task.files = result.filesTouched ?? [];
+            task.playtestFrames = result.playtestFrames ?? [];
+            // Flag, don't fail: see the TaskRecord.suspectNoChanges comment.
+            if (task.status === "done" && task.files.length === 0) {
+                task.suspectNoChanges = true;
+            }
             task.finishedAt = nowIso();
             task.resultSummary = wasStopped
                 ? "stopped by the router"
@@ -1338,6 +1786,9 @@ function createTaskStore(opts) {
         quickReference: opts.quickReference,
         backend: opts.backend,
         claudeModel: opts.claudeModel,
+        openrouterModel: opts.openrouterModel,
+        playtest: opts.playtest,
+        restart: opts.restart,
         onStarted: opts.onStarted,
         onFinished: opts.onFinished,
         onRetry: opts.onRetry,
@@ -1535,6 +1986,7 @@ function asPromptTask(task) {
         files: task.files,
         error: task.status === "failed" ? firstErrorLine(task.resultSummary) : undefined,
         blockedBy: task.status === "blocked" ? task.blockedBy : undefined,
+        suspectNoChanges: task.suspectNoChanges,
     };
 }
 function asClientTask(task) {
@@ -1552,6 +2004,8 @@ function asClientTask(task) {
         phase: task.phase,
         acknowledged: task.acknowledged,
         rejected: task.rejected,
+        suspectNoChanges: task.suspectNoChanges,
+        playtestFrames: (task.playtestFrames ?? []).map((rel) => `${AGENT_PLAYTEST_PREFIX}${task.id}/${path.basename(rel)}`),
     };
 }
 function createTaskFeeds(broadcast) {
@@ -1571,7 +2025,26 @@ function createTaskFeeds(broadcast) {
     }
     return { map, push };
 }
-function createMessageLog(messagesPath, broadcast) {
+function createMessageThinking(broadcast) {
+    const map = new Map();
+    function append(id, delta) {
+        const now = Date.now();
+        const entry = map.get(id);
+        if (entry) {
+            entry.text += delta;
+            entry.lastAt = now;
+        }
+        else {
+            map.set(id, { text: delta, firstAt: now, lastAt: now });
+        }
+        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 }]));
+    }
+    return { append, snapshot };
+}
+function createMessageLog(messagesPath, broadcast, welcomeMessage) {
     const loaded = readJsonFile(messagesPath) ?? [];
     const messages = loaded
         .filter((m) => m.text.trim() !== "" || m.role === "user")
@@ -1579,6 +2052,16 @@ function createMessageLog(messagesPath, broadcast) {
     function persist() {
         fs.writeFileSync(messagesPath, JSON.stringify(messages, null, 2) + "\n");
     }
+    if (messages.length === 0) {
+        messages.push({
+            id: nanoid(8),
+            role: "assistant",
+            text: welcomeMessage,
+            at: nowIso(),
+            status: "done",
+        });
+        persist();
+    }
     function add(message) {
         messages.push(message);
         persist();
@@ -1623,6 +2106,27 @@ function makeAttachmentHandler(attachmentsDir) {
         return true;
     };
 }
+// Serve playtest frame PNGs saved under tasks/<id>/playtest/ -- path is
+// AGENT_PLAYTEST_PREFIX + taskId + "/" + filename; both segments are reduced
+// to path.basename before joining, so neither can escape tasksDir.
+function makePlaytestFrameHandler(tasksDir) {
+    return (_req, res, reqPath) => {
+        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)) {
+            res.writeHead(404).end();
+            return true;
+        }
+        res.writeHead(200, { "content-type": "image/png", "cache-control": "no-store" });
+        fs.createReadStream(filePath).pipe(res);
+        return true;
+    };
+}
 // Classify from the error strings runAgentCli actually produces (see its
 // child.on("error"), timeout, and close handlers).
 function classifyRouterFailure(error) {
@@ -1656,10 +2160,19 @@ function routerFailureCopy(opts) {
 // context + transcript replay (minus log lines and the in-flight reply) +
 // the live board + this turn's instruction.
 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";
     return buildRouterPrompt({
         deckLabel: ctx.deckLabel,
         quickReference: ctx.quickReference,
-        deckTree: buildDeckTree(ctx.deckDir),
+        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,
         messages: ctx.log.messages
             .filter((m) => m.role !== "log" &&
             m.id !== selfMessageId &&
@@ -1759,7 +2272,10 @@ function spawnCompletedTaskFences(ctx, message, midStream, raw) {
 }
 // One router turn: stream a reply message, then spawn the directives it
 // emitted (unless a newer user message superseded this turn).
-function runRouterTurnIn(ctx, instruction) {
+// `attachments` = deck-relative image paths from the drained sends; only
+// smith consumes them (image content blocks), the CLI backends read the
+// files themselves via the paths already named in the instruction text.
+function runRouterTurnIn(ctx, instruction, attachments = []) {
     const epoch = ctx.currentEpoch();
     const message = {
         id: nanoid(8),
@@ -1783,13 +2299,17 @@ function runRouterTurnIn(ctx, instruction) {
     ctx.broadcast({ type: "message-activity", id: message.id, activity: "Thinking" });
     const prompt = routerTurnPrompt(ctx, instruction, message.id);
     const backend = ctx.backend();
-    const invocation = buildAgentInvocation(backend, "router", prompt, ctx.claudeModel());
-    void runAgentCli({
+    void runAgentTurn({
+        backend,
+        role: "router",
+        prompt,
+        claudeModel: ctx.claudeModel(),
+        openrouterModel: ctx.openrouterModel(),
+        attachments,
         cwd: ctx.deckDir,
-        command: invocation.command,
-        args: invocation.args,
-        parser: backend,
         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"),
         children: ctx.children,
         labelUnknownTools: true,
@@ -1812,9 +2332,12 @@ function runRouterTurnIn(ctx, instruction) {
             lastActivity = activity;
             ctx.broadcast({ type: "message-activity", id: message.id, activity });
         },
+        onThinking: (delta) => {
+            ctx.messageThinking.append(message.id, delta);
+        },
     })
         .then((result) => {
-        logRouterUsage(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;
@@ -1940,10 +2463,19 @@ function applyAgentSettings(incoming, ctx) {
             changes.push(`${key} agent -> ${value}`);
         }
     }
-    const model = normalizeClaudeModel(incoming.claudeModel);
-    if (model && model !== settings.claudeModel) {
-        settings.claudeModel = model;
-        changes.push(`claude model -> ${model}`);
+    for (const key of ["routerClaudeModel", "tasksClaudeModel"]) {
+        const value = normalizeClaudeModel(incoming[key]);
+        if (value && value !== settings[key]) {
+            settings[key] = value;
+            changes.push(`${key === "routerClaudeModel" ? "conductor" : "tasks"} claude model -> ${value}`);
+        }
+    }
+    for (const key of ["routerOpenrouterModel", "tasksOpenrouterModel"]) {
+        const value = normalizeOpenrouterModel(incoming[key]);
+        if (value && value !== settings[key]) {
+            settings[key] = value;
+            changes.push(`${key === "routerOpenrouterModel" ? "conductor" : "tasks"} openrouter model -> ${value}`);
+        }
     }
     if (changes.length === 0)
         return;
@@ -1980,7 +2512,11 @@ function startChildRegistry(registryPath, groups) {
         const live = [];
         for (const group of groups) {
             for (const child of group) {
-                if (typeof child.pid === "number" && child.exitCode === null) {
+                // 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) {
                     live.push({ pid: child.pid, command: child.spawnfile });
                 }
             }
@@ -2086,8 +2622,9 @@ function killRouterChildren(ctx) {
     }
     return drafts.join("\n\n");
 }
-function startRouterTurn(ctx, instruction) {
+function startRouterTurn(ctx, instruction, attachments = []) {
     ctx.state.lastInstruction = instruction;
+    ctx.state.lastAttachments = attachments;
     runRouterTurnIn({
         deckDir: ctx.deckDir,
         deckLabel: ctx.deckLabel,
@@ -2097,12 +2634,14 @@ function startRouterTurn(ctx, instruction) {
         log: ctx.log,
         broadcast: ctx.broadcast,
         taskStore: ctx.taskStore,
+        messageThinking: ctx.messageThinking,
         currentEpoch: () => ctx.state.userEpoch,
         backend: () => ctx.settings.router,
-        claudeModel: () => ctx.settings.claudeModel,
+        claudeModel: () => ctx.settings.routerClaudeModel,
+        openrouterModel: () => ctx.settings.routerOpenrouterModel,
         canAutoRetry: () => !ctx.state.autoRetryUsed && ctx.state.pendingSends.length === 0,
         onSettled: (retryable) => onRouterQueueSettled(ctx, retryable),
-    }, instruction);
+    }, instruction, attachments);
 }
 // Commit each drained send to the message log (skipping ones already logged
 // -- see PendingSend.logged -- so a re-carried send doesn't double its user
@@ -2157,7 +2696,7 @@ function maybeStartRouterQueueTurn(ctx) {
         messages: texts,
         interruptedDraft: draft || undefined,
         attachments: attachmentPaths,
-    }));
+    }), attachmentPaths);
 }
 // The turn settled: clear the busy flag, broadcast it, then flush anything
 // that queued mid-turn (a clean end and an interrupt take the same path). A
@@ -2174,7 +2713,7 @@ function onRouterQueueSettled(ctx, retryable) {
         state.autoRetryUsed = true;
         state.routerRunning = true;
         broadcastQueueState(ctx);
-        startRouterTurn(ctx, state.lastInstruction);
+        startRouterTurn(ctx, state.lastInstruction, state.lastAttachments);
         return;
     }
     broadcastQueueState(ctx);
@@ -2282,6 +2821,7 @@ function createRouterQueue(deps) {
             autoRetryUsed: false,
             autoFoldUsed: false,
             lastInstruction: "",
+            lastAttachments: [],
         },
     };
     // Restart recovery: re-enqueue sends that never reached the message log,
@@ -2300,11 +2840,32 @@ function createRouterQueue(deps) {
 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");
     fs.mkdirSync(tasksDir, { recursive: true });
+    // ONE warm Chromium for the serve's entire lifetime, shared by every
+    // playtest call (each call still gets its own fresh browser context +
+    // page -- see playtest-executor.ts). Lazily launched on first use; never
+    // touched at all if no task ever calls playtest.
+    const playtestBrowserManager = createPlaytestBrowserManager();
+    const playtest = opts.port
+        ? {
+            executor: createPlaywrightPlaytestExecutor(playtestBrowserManager),
+            // `localhost`, NOT 127.0.0.1: a serve started without --host leaves
+            // Vite on its default host, which binds ONLY [::1] on macOS --
+            // 127.0.0.1 never answers there, and playtest would fail every call
+            // with a navigation error. `localhost` resolves correctly under
+            // every binding mode (default ::1, --host 0.0.0.0, explicit IPs).
+            serveUrl: `http://localhost:${opts.port}`,
+            // Kicks off the one-time Chromium download in the background at
+            // smith-task start (see runTaskAgentIn) -- single-flight with any
+            // real playtest call, silent on every failure path.
+            prewarm: () => playtestBrowserManager.prewarm(),
+        }
+        : undefined;
     const taskChildren = new Set();
     const routerChildren = new Set();
     const clients = new Set();
@@ -2323,21 +2884,54 @@ export function createAgentServer(opts) {
                 socket.send(payload);
         }
     }
-    const log = createMessageLog(messagesPath, broadcast);
+    const log = createMessageLog(messagesPath, broadcast, welcomeMessage);
     const messages = log.messages;
     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");
+    // Loosely typed on purpose: the file may carry legacy values the current
+    // types no longer admit (backend "openrouter", single openrouterModel /
+    // claudeModel) -- every field goes through a normalizer/migrator below.
     const storedSettings = readJsonFile(settingsPath);
+    // Three legacy shapes migrate on load, chained oldest-first (rewritten in
+    // the new shape on the next settings change):
+    // - a single `openrouterModel` (pre per-role split) seeds BOTH per-role
+    //   slug fields;
+    // - a single shared `claudeModel` (pre per-role split) seeds BOTH per-role
+    //   claude-model fields;
+    // - backend value "openrouter" ON A ROLE (pre-smith: it meant that role
+    //   ran claude-via-OpenRouter) becomes backend "claude" + THAT role's
+    //   claude model "openrouter" -- exactly that behavior today, and now
+    //   per-role: one legacy openrouter role no longer drags the other role's
+    //   model along.
+    const legacyOpenrouterModel = normalizeOpenrouterModel(storedSettings?.openrouterModel);
+    const legacySharedClaudeModel = normalizeClaudeModel(storedSettings?.claudeModel);
+    const roleClaudeModel = (role) => {
+        // A stored per-role value wins; a legacy openrouter BACKEND on this role
+        // forces "openrouter" (those two never coexist in one file -- per-role
+        // fields postdate the openrouter backend's removal); else the legacy
+        // shared claudeModel, else the default.
+        return (normalizeClaudeModel(storedSettings?.[`${role}ClaudeModel`]) ??
+            (storedSettings?.[role] === "openrouter"
+                ? "openrouter"
+                : (legacySharedClaudeModel ?? DEFAULT_SETTINGS[`${role}ClaudeModel`])));
+    };
     const settings = {
-        router: normalizeBackend(storedSettings?.router) ?? DEFAULT_SETTINGS.router,
-        tasks: normalizeBackend(storedSettings?.tasks) ?? DEFAULT_SETTINGS.tasks,
-        claudeModel: normalizeClaudeModel(storedSettings?.claudeModel) ??
-            DEFAULT_SETTINGS.claudeModel,
+        router: migrateStoredBackend(storedSettings?.router) ?? DEFAULT_SETTINGS.router,
+        tasks: migrateStoredBackend(storedSettings?.tasks) ?? DEFAULT_SETTINGS.tasks,
+        routerClaudeModel: roleClaudeModel("router"),
+        tasksClaudeModel: roleClaudeModel("tasks"),
+        routerOpenrouterModel: normalizeOpenrouterModel(storedSettings?.routerOpenrouterModel) ??
+            legacyOpenrouterModel ??
+            DEFAULT_SETTINGS.routerOpenrouterModel,
+        tasksOpenrouterModel: normalizeOpenrouterModel(storedSettings?.tasksOpenrouterModel) ??
+            legacyOpenrouterModel ??
+            DEFAULT_SETTINGS.tasksOpenrouterModel,
     };
     const applySettings = (incoming) => applyAgentSettings(incoming, { settings, settingsPath, broadcast });
     const taskFeeds = createTaskFeeds(broadcast);
+    const messageThinking = createMessageThinking(broadcast);
     const taskStore = createTaskStore({
         deckDir,
         deckLabel,
@@ -2345,7 +2939,10 @@ export function createAgentServer(opts) {
         children: taskChildren,
         quickReference,
         backend: () => settings.tasks,
-        claudeModel: () => settings.claudeModel,
+        openrouterModel: () => settings.tasksOpenrouterModel,
+        claudeModel: () => settings.tasksClaudeModel,
+        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) }),
         onStarted: () => undefined,
@@ -2365,6 +2962,7 @@ export function createAgentServer(opts) {
         log,
         broadcast,
         taskStore,
+        messageThinking,
         messages,
         settings,
     });
@@ -2394,6 +2992,7 @@ export function createAgentServer(opts) {
             tasks: taskStore.sorted().map(asClientTask),
             settings,
             feeds: Object.fromEntries(taskFeeds.map),
+            thinking: messageThinking.snapshot(),
             running: routerQueue.isRunning(),
             queued: routerQueue.queuedSnippets(),
         };
@@ -2438,7 +3037,11 @@ export function createAgentServer(opts) {
         wss.handleUpgrade(req, socket, head, (ws) => attachClient(ws));
         return true;
     }
-    const handleHttpRequest = makeAttachmentHandler(attachmentsDir);
+    const handleAttachment = makeAttachmentHandler(attachmentsDir);
+    const handlePlaytestFrame = makePlaytestFrameHandler(tasksDir);
+    function handleHttpRequest(req, res, reqPath) {
+        return handleAttachment(req, res, reqPath) || handlePlaytestFrame(req, res, reqPath);
+    }
     function shutdown() {
         taskStore.shutdown();
         for (const child of [...taskChildren, ...routerChildren]) {
@@ -2451,6 +3054,7 @@ export function createAgentServer(opts) {
         }
         stopChildRegistry();
         wss.close();
+        void playtestBrowserManager.shutdown();
     }
     return { handleUpgrade, handleHttpRequest, shutdown };
 }