castle-web-cli 0.4.183 → 0.4.185

package/dist/agent.js

@@ -11,9 +11,8 @@
 // shows up as small log messages (started / ready for review / completed)
 // instead of extra router turns.
 //
-// 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.
+// Backend CLI: the claude CLI in headless print mode (stream-json), behind
+// runAgentCli.
 import { execFileSync, spawn } from 'child_process';
 import { quickReferenceFor } from './platformDoc.js';
 import { IMPORTS_DIR } from './imports.js';
@@ -30,25 +29,18 @@ import { atomicWriteFileSync } from './atomicFile.js';
 import { AGENT_ATTACHMENT_PREFIX, AGENT_PLAYTEST_PREFIX, PLAN_FILE } from './localPaths.js';
 import { applyPlanOps, buildRouterPromptParts, buildTaskPrompt, parsePlanOps, planOpenQuestionLines, truncateToBytes, userTurnInstruction, CLAUDE_TASK_SYSTEM_REMINDER, } from './agent-prompts.js';
 import { readCastleJson } from './castleJson.js';
-import { checkOpenrouterKey, checkOpenrouterModel, openrouterCatalogEntry, primeOpenrouterCatalog, } from './openrouter-catalog.js';
+import { checkOpenrouterKey, checkOpenrouterModel, primeOpenrouterCatalog, } from './openrouter-catalog.js';
 import { classifyProviderError, failureCopy, setReaderTimeZone, } from './agent-failures.js';
-import { castleCreditsExhausted, createRefreshQueue, fetchAiCredits, fetchBudget, meteringHeaders, newAgentSessionId, reportCursorRun, spendableMicros, 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 { castleCreditsExhausted, createRefreshQueue, fetchAiCredits, fetchBudget, freeRolesFor, freeTierForRoles, meteringHeaders, modelIsFree, newAgentSessionId, spendableMicros, withCustomHeaders, } from './metering.js';
+import { anthropicKeyHelperCommand, 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';
 import { createRemotePlaytestExecutor } from './native/playtest-remote.js';
 import { runPlaytest, } from './native/playtest.js';
 export const AGENT_WS_PATH = '/__castle/agent';
-// 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';
 const DEFAULT_SETTINGS = {
-    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
@@ -56,27 +48,13 @@ const DEFAULT_SETTINGS = {
     // exactly why a user who HAS one defaults to ANTHROPIC_DEFAULT_MODELS below.
     routerClaudeModel: 'openrouter',
     tasksClaudeModel: 'openrouter',
-    // Free-form -- change to any OpenRouter slug.
-    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',
-    // 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',
-    // 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: '',
+    // Free-form -- change to any OpenRouter slug. Both roles default to the
+    // model Castle pays for (the proxy's freeModelPrefixes list), so an editor
+    // that has never touched settings costs the user nothing and never runs into
+    // a credit balance -- see freeTierForRoles / the free-model skip in
+    // castleSpendRefusal. Picking any other slug puts that role back on credits.
+    routerOpenrouterModel: 'meta/muse-spark-1.3-contributor',
+    tasksOpenrouterModel: 'meta/muse-spark-1.3-contributor',
 };
 // What the two claude-model defaults become once the user has an Anthropic
 // credential of their own -- a key or a claude.ai login, which
@@ -97,9 +75,6 @@ function defaultSettings() {
         ? { ...DEFAULT_SETTINGS }
         : { ...DEFAULT_SETTINGS, ...ANTHROPIC_DEFAULT_MODELS };
 }
-function normalizeBackend(value) {
-    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
 // fields dropped on load (see loadAgentSettings). Bump ONLY when a default
@@ -107,7 +82,13 @@ function normalizeBackend(value) {
 // bump, since sparse storage already reaches anyone who never set that field.
 // The wipe is also what retires older file shapes, so a migration for one is
 // only worth writing if it must survive the epoch that introduces it.
-const SETTINGS_EPOCH = 1;
+//
+// 2: the OpenRouter default moved to the model Castle pays for. Deliberately a
+// bump rather than an ordinary default change -- decks that had already stored
+// a slug (including the one that was the default when they stored it) would
+// otherwise keep spending credits on a metered model while every user around
+// them runs free.
+const SETTINGS_EPOCH = 2;
 function normalizeClaudeModel(value) {
     return value === 'sonnet' || value === 'opus' || value === 'fable' || value === 'openrouter'
         ? value
@@ -139,62 +120,19 @@ function normalizeOpenrouterModel(value) {
     const trimmed = value.trim();
     return trimmed && trimmed.length <= OPENROUTER_MODEL_MAX_LEN ? trimmed : null;
 }
-// OpenRouter's full effort superset -- validated against the union rather than
-// a per-model list because supported efforts are model-specific (the client
-// 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',
-];
-function normalizeReasoningEffort(value) {
-    return REASONING_EFFORTS.includes(value)
-        ? value
-        : null;
-}
-const ROUTING_MODES = ['balanced', 'nitro', 'exacto', 'floor'];
-function normalizeRoutingMode(value) {
-    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.
-// Unlike the slug, empty string is VALID and meaningful: "auto" (no pin), so
-// this returns "" rather than null for the clear case -- callers must treat
-// null (invalid) and "" (clear) differently.
-function normalizeProviderTier(value) {
-    if (typeof value !== 'string')
-        return null;
-    const trimmed = value.trim();
-    if (trimmed.length > OPENROUTER_MODEL_MAX_LEN)
-        return null;
-    return trimmed;
-}
 // Every setting's validator, keyed the same as AgentSettings, so load and save
 // iterate one list rather than repeating the field names per direction.
 const SETTING_NORMALIZERS = {
-    router: normalizeBackend,
-    tasks: normalizeBackend,
     routerClaudeModel: normalizeClaudeModel,
     tasksClaudeModel: normalizeClaudeModel,
     routerOpenrouterModel: normalizeOpenrouterModel,
     tasksOpenrouterModel: normalizeOpenrouterModel,
-    routerReasoningEffort: normalizeReasoningEffort,
-    tasksReasoningEffort: normalizeReasoningEffort,
-    routerRouting: normalizeRoutingMode,
-    tasksRouting: normalizeRoutingMode,
-    routerProviderTier: normalizeProviderTier,
-    tasksProviderTier: normalizeProviderTier,
 };
 const SETTING_KEYS = Object.keys(SETTING_NORMALIZERS);
 // Sparse ON PURPOSE: only fields that DIFFER from the current defaults are
 // stored, so "absent" means "follow the default" and a later default change
 // reaches every deck that never set that field. Writing the full object
-// instead (as this once did) froze all 12 settings the first time a user
+// instead (as this once did) froze every setting the first time a user
 // touched any one of them, pinning models nobody had chosen.
 //
 // The flip side, accepted: re-selecting the value that is currently the
@@ -294,9 +232,6 @@ function openrouterAnthropicBase() {
 // (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';
-// 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';
 function envForOpenrouterSpawn(auth) {
     if (!auth.key) {
         // Unreachable via runAgentTurn (pre-flight rejects a keyless run before
@@ -320,121 +255,16 @@ function envForOpenrouterSpawn(auth) {
     env.ANTHROPIC_AUTH_TOKEN = auth.key;
     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.
+// The OpenRouter credential the claude-via-OpenRouter spawn sends as
+// ANTHROPIC_AUTH_TOKEN (see envForOpenrouterSpawn). Castle-provided key file
+// first, env fallback.
 const OPENROUTER_KEY_NAME = 'OPENROUTER_API_KEY';
 function openrouterApiKey() {
     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 modelCapsCache = new Map();
-function asRecord(v) {
-    return v && typeof v === 'object' ? v : null;
-}
-async function openrouterProviderTiers(slug) {
-    const res = await fetch(`${OPENROUTER_API_BASE}/models/${slug}/endpoints`);
-    if (!res.ok)
-        return [];
-    const json = asRecord(await res.json());
-    const data = asRecord(json?.data);
-    const endpoints = data && Array.isArray(data.endpoints) ? data.endpoints : [];
-    const tags = [];
-    for (const ep of endpoints) {
-        const rec = asRecord(ep);
-        const tag = rec && typeof rec.tag === 'string' ? rec.tag : null;
-        if (tag && !tags.includes(tag))
-            tags.push(tag);
-    }
-    return tags;
-}
-async function fetchModelCaps(slug) {
-    const cached = modelCapsCache.get(slug);
-    if (cached && Date.now() - cached.at < MODEL_CAPS_TTL_MS)
-        return cached.caps;
-    // Best-effort per source: a failure in either leaves that half empty rather
-    // than failing the whole lookup, so a bad slug still yields a usable (empty)
-    // caps object the client can render as "no dynamic options".
-    let reasoningEfforts = null;
-    let defaultEffort = null;
-    try {
-        // Shared catalog (openrouter-catalog.ts) rather than a second /models
-        // fetch: it's the same list the pre-flight slug check reads, and it brings
-        // a disk-backed stale-while-revalidate cache with it.
-        const entry = await openrouterCatalogEntry(slug);
-        const reasoning = asRecord(entry?.reasoning);
-        const efforts = reasoning?.supported_efforts;
-        const supportedParams = entry?.supportedParameters;
-        const acceptsEffort = Array.isArray(supportedParams) &&
-            (supportedParams.includes('reasoning_effort') || supportedParams.includes('reasoning'));
-        if (acceptsEffort && Array.isArray(efforts) && efforts.length > 0) {
-            reasoningEfforts = efforts.filter((e) => typeof e === 'string');
-            defaultEffort =
-                typeof reasoning?.default_effort === 'string' ? reasoning.default_effort : null;
-        }
-    }
-    catch {
-        // leave reasoning fields null
-    }
-    let providerTiers = [];
-    try {
-        providerTiers = await openrouterProviderTiers(slug);
-    }
-    catch {
-        // leave providerTiers empty
-    }
-    const caps = {
-        model: slug,
-        reasoningEfforts,
-        defaultEffort,
-        providerTiers,
-    };
-    modelCapsCache.set(slug, { caps, at: Date.now() });
-    return caps;
-}
-// GET AGENT_MODEL_CAPS_PREFIX?model=<slug>. Returns 400 for a missing/oversized
-// slug, 200 ModelCaps otherwise (empty caps on upstream failure -- see
-// fetchModelCaps). reqPath is already query-stripped; parse req.url for it.
-function handleModelCaps(req, res) {
-    const send = (status, body) => {
-        res.writeHead(status, {
-            'content-type': 'application/json',
-            'cache-control': 'no-store',
-        });
-        res.end(JSON.stringify(body));
-        return true;
-    };
-    let slug = '';
-    try {
-        slug = (new URL(req.url ?? '', 'http://localhost').searchParams.get('model') ?? '').trim();
-    }
-    catch {
-        slug = '';
-    }
-    if (!slug || slug.length > OPENROUTER_MODEL_MAX_LEN) {
-        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)$/, '');
-    fetchModelCaps(baseSlug)
-        .then((caps) => send(200, caps))
-        .catch(() => send(200, {
-        model: baseSlug,
-        reasoningEfforts: null,
-        defaultEffort: null,
-        providerTiers: [],
-    }));
-    return true;
-}
-// 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; hosted claude runs bypassPermissions for
-// both roles because the container is already the permission boundary. Local
-// claude stays on auto (NOT plan mode -- that makes it emit plan tool calls)
+// Build the headless CLI invocation for a role. Hosted claude runs
+// bypassPermissions for both roles because the container is already the
+// permission boundary. Local claude stays on auto (NOT plan mode -- that makes it emit plan tool calls)
 // at medium effort. claudeModel "openrouter" keeps the SAME claude binary and
 // swaps only the model slug and env (see envForOpenrouterSpawn).
 // claude CLI 2.1.198 SILENTLY resolves `--permission-mode auto` to "default"
@@ -453,8 +283,8 @@ function handleModelCaps(req, res) {
 const OPENROUTER_ALLOWED_TOOLS = ['Edit', 'Write', 'NotebookEdit', 'Bash'];
 // The tool id claude assigns our MCP server's `playtest` tool: mcp__<server>__<tool>,
 // where <server> is the key under mcpServers in --mcp-config (see mcpConfigArg).
-// Task-only, matching smith (native/tools.ts) -- a router turn has no deck to
-// play and no frames dir to write into.
+// Task-only -- a router turn has no deck to play and no frames dir to write
+// into.
 const CLAUDE_PLAYTEST_TOOL = 'mcp__castle__playtest';
 // Single `=` token because --allowedTools is variadic and would otherwise
 // swallow the trailing prompt positional.
@@ -489,9 +319,6 @@ function mcpConfigArg(deckDir, taskId) {
     });
     return `--mcp-config=${config}`;
 }
-// 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';
 // 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
@@ -517,96 +344,73 @@ const ROUTER_CLAUDE_ENV = {
     CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS: '1',
     CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1',
 };
-function buildAgentInvocation(backend, role, prompt, claudeModel, 
+function buildAgentInvocation(role, prompt, claudeModel, 
 // Already resolved for this role by the caller (router turns pass
 // settings.routerOpenrouterModel, task spawns settings.tasksOpenrouterModel).
 openrouterModel, 
 // This run's ledger identity, and the deck dir its castle.json is read from.
-// Only the claude branch can carry it: cursor-agent runs on its own key and
-// never traverses the llm-proxy.
 metering, 
 // The task this spawn belongs to, so its playtest frames land under
 // tasks/<id>/playtest/ and count against that task's call budget. Absent for
 // router turns, which get no playtest tool at all.
 taskId, 
-// The stable part of a router prompt. claude takes it as appended system
-// text, which its own cache breakpoints cover; cursor has no such flag and
-// gets it ahead of the prompt.
+// The stable part of a router prompt, passed as appended system text so the
+// CLI's own cache breakpoints cover it.
 systemPrompt) {
     const systemText = [systemPrompt, role === 'task' ? CLAUDE_TASK_SYSTEM_REMINDER : undefined]
         .filter((text) => Boolean(text))
         .join('\n\n');
-    if (backend === 'claude') {
-        const hosted = Boolean(process.env.CASTLE_SANDBOX_ID);
-        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';
-        return {
-            command: 'claude',
-            args: [
-                '-p',
-                '--verbose',
-                '--output-format',
-                'stream-json',
-                '--include-partial-messages',
-                '--permission-mode',
-                hosted ? 'bypassPermissions' : 'auto',
-                ...(!hosted && viaOpenrouter ? [openrouterAllowedToolsArg(role)] : []),
-                '--model',
-                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',
-                '--settings',
-                claudeSettingsArg(anAuth),
-                '--strict-mcp-config',
-                ...(role === 'task' ? [mcpConfigArg(metering.deckDir, taskId)] : []),
-                ...(systemText ? ['--append-system-prompt', systemText] : []),
-                prompt,
-            ],
-            env: {
-                ...withCustomHeaders(viaOpenrouter ? envForOpenrouterSpawn(orAuth) : envForClaudeSpawn(anAuth), meteringHeaders({
-                    deckDir: metering.deckDir,
-                    sessionId: metering.sessionId,
-                    route: viaOpenrouter ? 'openrouter' : 'anthropic',
-                    direct,
-                })),
-                ...(role === 'router' ? ROUTER_CLAUDE_ENV : {}),
-                // Claude Code 2.1.258 refuses bypassPermissions as root unless the
-                // child explicitly identifies itself as running in a sandbox.
-                ...(hosted ? { IS_SANDBOX: '1' } : {}),
-            },
-        };
-    }
+    const hosted = Boolean(process.env.CASTLE_SANDBOX_ID);
+    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';
     return {
-        command: 'cursor-agent',
+        command: 'claude',
         args: [
             '-p',
+            '--verbose',
             '--output-format',
             'stream-json',
-            '--stream-partial-output',
-            '--trust',
+            '--include-partial-messages',
+            '--permission-mode',
+            hosted ? 'bypassPermissions' : 'auto',
+            ...(!hosted && viaOpenrouter ? [openrouterAllowedToolsArg(role)] : []),
             '--model',
-            CURSOR_MODEL,
-            ...(role === 'router' ? ['--mode', 'ask'] : ['--force']),
-            systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt,
+            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',
+            '--settings',
+            claudeSettingsArg(anAuth),
+            '--strict-mcp-config',
+            ...(role === 'task' ? [mcpConfigArg(metering.deckDir, taskId)] : []),
+            ...(systemText ? ['--append-system-prompt', systemText] : []),
+            prompt,
         ],
-        env: envForAgentSpawn(backend),
+        env: {
+            ...withCustomHeaders(viaOpenrouter ? envForOpenrouterSpawn(orAuth) : envForClaudeSpawn(anAuth), meteringHeaders({
+                deckDir: metering.deckDir,
+                sessionId: metering.sessionId,
+                route: viaOpenrouter ? 'openrouter' : 'anthropic',
+                direct,
+            })),
+            ...(role === 'router' ? ROUTER_CLAUDE_ENV : {}),
+            // Claude Code 2.1.258 refuses bypassPermissions as root unless the
+            // child explicitly identifies itself as running in a sandbox.
+            ...(hosted ? { IS_SANDBOX: '1' } : {}),
+        },
     };
 }
-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;
@@ -616,10 +420,10 @@ const MAX_TASK_ATTEMPTS = 3;
 const MAX_CONCURRENT_TASKS = Number(process.env.CASTLE_MAX_CONCURRENT_TASKS) || 4;
 // Base backoff (ms) before a crashed task agent is relaunched, scaled by
 // attempt number and jittered (see waitBeforeTaskRetry). Incident (2026-07):
-// the router spawned 4 parallel tasks whose cursor-agent processes all
+// the router spawned 4 parallel tasks whose agent CLI processes all
 // crashed at startup within ~1.3s with a macOS keychain error ("Security
 // command failed: Security process exited with code: 44" -- credential
-// lookup contention when many cursor-agent processes start at once). The old
+// lookup contention when many agent CLI processes start at once). The old
 // instant retry burned all 3 attempts of every task inside that same ~6s
 // contention window (11 agent processes launched in ~7s); the one retry that
 // happened to land ~2s later succeeded, so growing + jittered spacing
@@ -774,11 +578,8 @@ function planDefault() {
 // The playtest steering: one router rule plus the task prompt's carve-out
 // (PLAYTEST_ROUTER_RULE in agent-prompts.ts). On unless the serve was told
 // `CASTLE_AGENT_PLAYTEST=off` (the only env value that does anything; no
-// per-deck switch), and never for cursor tasks, which are the one backend
-// spawned without a playtest tool.
-function playtestSteering(tasksBackend) {
-    if (tasksBackend === 'cursor')
-        return false;
+// per-deck switch).
+function playtestSteering() {
     return process.env.CASTLE_AGENT_PLAYTEST !== 'off';
 }
 function planSession(deckDir) {
@@ -1019,22 +820,6 @@ 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;
@@ -1082,7 +867,6 @@ function claudeToolFeedLabel(name, input) {
 // content_block_start, before the input JSON streams in). Router-only fallback
 // so the streaming reply's activity line reflects EVERY tool -- including the
 // commands/searches claudeToolFeedLabel intentionally drops from task feeds.
-// Mirrors the cursor toolActivityLabel verbs so the two backends read alike.
 function genericClaudeToolLabel(name) {
     const kind = name.toLowerCase();
     if (kind === CLAUDE_PLAYTEST_TOOL)
@@ -1099,21 +883,6 @@ function genericClaudeToolLabel(name) {
         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';
-    }
-    if (['write', 'edit', 'delete', 'mv'].some((p) => kind.startsWith(p)))
-        return 'Editing files';
-    if (['shell', 'bash', 'terminal'].some((p) => kind.startsWith(p)))
-        return 'Running a command';
-    return 'Working';
-}
 // Castle's agent CLI keys, delivered to the sandbox as a file
 // (~/.castle/keys.json) rather than sandbox-wide env -- so an ambient key can't
 // override a user's own subscription login. Falls back to process.env for
@@ -1139,41 +908,6 @@ function resolveOpenrouterAuth() {
         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',
-};
-// 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
-// dead weight: cursor re-auths from the injected env key and ignores it. Leaving
-// it means a stale API key sits on the sandbox fs, so drop it and keep only the
-// live key cached. Best-effort; an absent file is the normal case. An OAuth login
-// (no apiKey field) is never reached here -- that path withholds the key instead.
-function purgeStaleCursorAuth(home, injectedKey) {
-    try {
-        const authPath = cursorAuthPath(home);
-        const auth = JSON.parse(fs.readFileSync(authPath, 'utf8'));
-        if (auth.apiKey && auth.apiKey !== injectedKey) {
-            fs.rmSync(authPath, { force: true });
-        }
-    }
-    catch {
-        // no auth.json, or unreadable/unparseable -- nothing to purge
-    }
-}
-// True when the user has their OWN saved auth for this backend -- a login we
-// 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')
-        return claudeHasSavedLogin();
-    if (backend === 'cursor')
-        return cursorHasUserLogin(os.homedir());
-    return false;
-}
 // Env for the plain claude CLI path (NOT claude-via-OpenRouter -- that's
 // envForOpenrouterSpawn). resolveAnthropicAuth decides the routing:
 //   - proxy: inherit the host-injected ANTHROPIC_BASE_URL + ANTHROPIC_AUTH_TOKEN
@@ -1195,32 +929,6 @@ function envForClaudeSpawn(auth) {
         delete env[name];
     return env;
 }
-// Env for a cursor-agent spawn: inject Castle's key ONLY when the backend has no
-// saved auth of the user's own. This is what lets internal testers run on their
-// own subscription (log in once in the terminal) instead of Castle's key. The
-// claude path no longer routes through here -- see envForClaudeSpawn /
-// resolveAnthropicAuth (this stays generic but is only ever called for cursor).
-function envForAgentSpawn(backend) {
-    const env = { ...process.env };
-    const keyName = BACKEND_KEY_ENV[backend];
-    if (!keyName)
-        return env;
-    if (backendHasSavedAuth(backend)) {
-        delete env[keyName];
-    }
-    else {
-        const val = castleKeys()[keyName] ?? process.env[keyName];
-        if (val) {
-            env[keyName] = val;
-            if (backend === 'cursor')
-                purgeStaleCursorAuth(os.homedir(), val);
-        }
-        else {
-            delete env[keyName];
-        }
-    }
-    return env;
-}
 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
@@ -1229,22 +937,11 @@ 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. `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;
+// filesystem hiccups should cost context, not fail an agent turn.
+function buildDeckTree(deckDir) {
+    const maxEntries = DECK_TREE_MAX_ENTRIES;
+    const perDir = DECK_TREE_PER_DIR;
     const lines = [];
     const walk = (dir, prefix, depth) => {
         let entries;
@@ -1284,153 +981,6 @@ function buildDeckTree(deckDir, caps) {
     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
-// 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');
@@ -1525,7 +1075,6 @@ function createAgentStreamState() {
         resultIsError: false,
         usage: undefined,
         sawResult: false,
-        segmentText: '',
         needsGap: false,
         pendingTools: new Map(),
     };
@@ -1554,32 +1103,24 @@ function formatTokenCount(value) {
         return `${(value / 1000).toFixed(1)}k`;
     return String(value);
 }
-// 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) {
+// One usage line per finished agent run 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 with its own
+// usage).
+function logAgentUsage(label, 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] ${label} ${backend}: input=${input} cache_read=${read} cache_created=${created} output=${output}`);
+    console.error(`[agent usage] ${label}: 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
-// within the max-lines budget; behavior is identical (same delta/activity/
-// result hooks and dedupe/segment-gap handling).
-//
-// Cursor closes each text segment (e.g. right before a tool call) by
-// re-emitting the segment's full text as one more delta-shaped event; track the
-// current segment so those re-emissions are dropped instead of duplicating
-// lines. Segment boundaries also need a paragraph gap -- cursor starts the next
-// segment without one, which glues "Checking the deck..." lines onto the
-// previous paragraph. Claude tool_use blocks stream their input JSON by block
-// index, accumulated in pendingTools so content_block_stop can label them with
-// the real file / command (and drop progress-file writes).
+// Splitting the stream decoding out of runAgentCli keeps each within the
+// max-lines budget. A tool_use block streams its input JSON by block index,
+// accumulated in pendingTools so content_block_stop can label it with the
+// real file / command (and drop progress-file writes).
 function makeAgentEventHandler(opts, state) {
     const emitDelta = (rawDelta) => {
         let delta = rawDelta;
@@ -1589,7 +1130,6 @@ function makeAgentEventHandler(opts, state) {
                 delta = (state.accumulated.endsWith('\n') ? '\n' : '\n\n') + delta;
             }
         }
-        state.segmentText += delta;
         state.accumulated += delta;
         opts.onDelta?.(delta);
         opts.onActivity?.(null);
@@ -1612,9 +1152,8 @@ function makeAgentEventHandler(opts, state) {
                 }
                 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.
+                    // Surface extended thinking as the activity line. The next text delta
+                    // clears it via emitDelta's onActivity(null); a tool block relabels it.
                     opts.onActivity?.('Thinking');
                 }
             }
@@ -1662,51 +1201,11 @@ function makeAgentEventHandler(opts, state) {
             state.usage = parseCliUsage(ev.usage);
         }
     };
-    return (ev) => {
-        if (opts.parser === 'claude') {
-            handleClaudeEvent(ev);
-            return;
-        }
-        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('');
-            if (!delta)
-                return;
-            const trimmed = delta.trim();
-            if (trimmed.length >= 16 && state.segmentText.trim().endsWith(trimmed))
-                return;
-            emitDelta(delta);
-        }
-        else if (ev.type === 'tool_call') {
-            state.segmentText = '';
-            state.needsGap = true;
-            if (ev.subtype === 'started')
-                opts.onActivity?.(toolActivityLabel(ev));
-        }
-        else if (ev.type === 'thinking') {
-            state.segmentText = '';
-            state.needsGap = true;
-            opts.onActivity?.('Thinking');
-        }
-        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.resultIsError = ev.is_error === true;
-            state.usage = parseCliUsage(ev.usage);
-        }
-    };
+    return handleClaudeEvent;
 }
-// One headless agent CLI run (cursor or claude), normalized to the same
-// delta/activity/result hooks. Cursor: assistant events carrying timestamp_ms
-// are text deltas; the trailing assistant event without one repeats the whole
-// message (skipped). Claude: stream_event wraps anthropic SSE deltas. Both
-// end with a result event carrying the canonical final text.
+// One headless claude CLI run, normalized to delta/activity/result hooks:
+// stream_event wraps anthropic SSE deltas, and a result event carries the
+// canonical final text.
 function runAgentCli(opts) {
     return new Promise((resolve) => {
         // spawn() throws SYNCHRONOUSLY for the failures the OS rejects at exec
@@ -1792,9 +1291,7 @@ function runAgentCli(opts) {
             settle({
                 ok: false,
                 finalText: state.accumulated,
-                // The binary itself wouldn't start (ENOENT, EACCES). Names the command
-                // actually being spawned -- this used to say "cursor-agent" for every
-                // backend, so a missing `claude` reported the wrong tool.
+                // The binary itself wouldn't start (ENOENT, EACCES).
                 error: `could not run ${opts.command}: ${err.message}`,
                 failure: { kind: 'spawn', detail: `${opts.command}: ${err.message}` },
             });
@@ -1808,8 +1305,9 @@ function runAgentCli(opts) {
             // do write there. Both are read BEFORE the 300-char truncation below.
             //
             // ONLY for OpenRouter-routed runs (opts.openrouterModel is set only when
-            // roleUsesOpenrouter): the classifier's copy is OpenRouter-branded, so a
-            // plain claude/cursor failure must NOT run through it -- an Anthropic 529
+            // the role's model is "openrouter"): the classifier's copy is
+            // OpenRouter-branded, so a
+            // plain claude failure must NOT run through it -- an Anthropic 529
             // would otherwise read as "OpenRouter is busy", naming the wrong
             // provider. Plain runs keep their provider-neutral "exit" copy, exactly
             // as before this feature.
@@ -1837,94 +1335,6 @@ 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/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,
-            extraHeaders: opts.extraHeaders,
-            model: opts.model,
-            apiKey: opts.apiKey,
-            baseUrl: opts.baseUrl,
-            reasoningEffort: opts.openrouterTuning?.reasoningEffort,
-            routing: opts.openrouterTuning?.routing,
-            // "" (auto) becomes undefined so no provider.order is sent.
-            providerTier: opts.openrouterTuning?.providerTier || undefined,
-            prompt: opts.prompt,
-            system: opts.system,
-            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,
-            failure: result.failure,
-            usage: result.usage,
-            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);
-    }
-}
-// True when a role's path goes through OpenRouter: the smith native loop, or
-// the claude CLI routed at OpenRouter. The client has a twin of this in
-// 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');
-}
 function configFailure(reason, detail, extra) {
     return { kind: 'config', reason, detail, ...extra };
 }
@@ -1938,7 +1348,7 @@ function configFailure(reason, detail, extra) {
 // resolve "unavailable" on any network trouble, and we allow the run rather
 // than invent a verdict.
 async function preflightOpenrouterRun(opts) {
-    if (!roleUsesOpenrouter(opts.backend, opts.claudeModel))
+    if (opts.claudeModel !== 'openrouter')
         return null;
     const auth = opts.orAuth ?? resolveOpenrouterAuth();
     const apiKey = auth.key;
@@ -1989,37 +1399,37 @@ function notifyAgentRunFinished() {
         listener();
 }
 // True when THIS run spends Castle's credential rather than the user's own.
-// Resolves exactly as buildAgentInvocation / runAgentSmith will, one step
-// earlier, so the gate and the run can never disagree about who is paying.
-//
-// Cursor asks the same question as the others, just from a different file:
-// envForAgentSpawn withholds Castle's key when the user has an OAuth login, so
-// a run with one is already going to their account and the daily limit is not
-// Castle's to enforce over it. It used to answer `true` unconditionally, which
-// refused a user on their own subscription once Castle's budget ran out --
-// while the editor offered them that sign-in and promised it bypassed the
-// limit. Deferring only to a LOGIN is what keeps this from being a hole: a
-// 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')
-        return !cursorHasUserLogin(os.homedir());
-    return roleUsesOpenrouter(backend, claudeModel)
+// Resolves exactly as buildAgentInvocation will, one step earlier, so the
+// gate and the run can never disagree about who is paying.
+function runIsCastlePaid(claudeModel, orAuth) {
+    return claudeModel === 'openrouter'
         ? (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
-// Anthropic login covers the claude roles while a cursor role on Castle's key
-// still spends Castle's. Re-read per refresh, so adding or removing a
-// credential (or switching a role's backend) moves the bar on the next one.
-//
-// A cursor role on Castle's key does draw a bar its own runs never move --
-// cursor is unmetered by contract. That is a display question, not a payment
-// one, and it is not settled here.
+// Anthropic login covers a role on a claude alias while a role routed through
+// OpenRouter still spends Castle's key. Re-read per refresh, so adding or
+// removing a credential (or switching a role's model) moves the bar on the
+// next one.
 function anyRoleIsCastlePaid(settings) {
-    return (runIsCastlePaid(settings.router, settings.routerClaudeModel, null) ||
-        runIsCastlePaid(settings.tasks, settings.tasksClaudeModel, null));
+    return roleSpends(settings).some((role) => role.castlePaid);
+}
+// The two roles as the spend questions see them: who pays, and -- when the
+// path goes through OpenRouter at all -- which slug the payment is for. Both
+// halves are answered the way the RUN answers them (runIsCastlePaid), so "this
+// editor is free" can never disagree with what the proxy actually bills. A role
+// that doesn't reach OpenRouter carries no slug: the fixed claude aliases are
+// metered whatever is free.
+function roleSpends(settings) {
+    return ['router', 'tasks'].map((role) => {
+        const claudeModel = role === 'router' ? settings.routerClaudeModel : settings.tasksClaudeModel;
+        const slug = role === 'router' ? settings.routerOpenrouterModel : settings.tasksOpenrouterModel;
+        return {
+            castlePaid: runIsCastlePaid(claudeModel, null),
+            slug: claudeModel === 'openrouter' ? slug : null,
+        };
+    });
 }
 // The proxy 403s a spent-out user -- or one who asked for a model they don't
 // have -- mid-stream, which a CLI surfaces as a generic provider error after a
@@ -2029,13 +1439,16 @@ function anyRoleIsCastlePaid(settings) {
 // Only the claude aliases are checked, which is exactly what the picker offers.
 // A free-form OpenRouter slug naming a restricted model is left to the proxy:
 // resolving an arbitrary slug to what it bills as is its job, not the editor's.
-async function castleSpendRefusal(backend, claudeModel, orAuth) {
-    if (!runIsCastlePaid(backend, claudeModel, orAuth))
+async function castleSpendRefusal(claudeModel, openrouterModel, orAuth) {
+    if (!runIsCastlePaid(claudeModel, orAuth))
         return null;
     const budget = await fetchBudget();
     if (!budget)
         return null;
-    if (claudeModelBlocked(claudeModel, budget)) {
+    // Only a run on a fixed alias reaches the proxy as that alias; on
+    // claude-via-OpenRouter the stored alias is an inactive leftover, and
+    // refusing on it would block a run that never asks for it.
+    if (claudeModel !== 'openrouter' && claudeModelBlocked(claudeModel, budget)) {
         return {
             kind: 'config',
             reason: 'model-not-allowed',
@@ -2043,6 +1456,15 @@ async function castleSpendRefusal(backend, claudeModel, orAuth) {
             model: claudeModel,
         };
     }
+    // Credit state cannot pre-empt a model Castle pays for: an empty balance and
+    // a reached daily cap both describe budget this run will not touch, and
+    // refusing here would strand a user on the free default with no way to keep
+    // working. The free model has its own (invisible) daily cap, enforced where
+    // every other spend rule is -- at the proxy, whose 403 carries copy of its
+    // own (castleFreeModelLimit in agent-failures).
+    if (claudeModel === 'openrouter' && modelIsFree(openrouterModel, budget.freeModelPrefixes)) {
+        return null;
+    }
     if (!budget.blocked)
         return null;
     const credits = await fetchAiCredits();
@@ -2068,8 +1490,8 @@ 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
  * the usage bar): those two disagree exactly when one role runs on Castle's
- * OpenRouter key -- or on Castle's cursor key -- while the user's own Anthropic
- * key or login covers every claude run. Those runs never reach the proxy, so
+ * OpenRouter key while the user's own Anthropic key or login covers every
+ * claude run. Those runs never reach the proxy, so
  * nothing about them is Castle's to restrict, and the picker must keep offering
  * the model. A claude run on a fixed alias always resolves through
  * resolveAnthropicAuth, so no role's settings enter into this.
@@ -2079,7 +1501,7 @@ function blockedClaudeModels(budget) {
         return [];
     return PICKER_CLAUDE_MODELS.filter((m) => claudeModelBlocked(m, budget));
 }
-function usageFrame(budget, credits) {
+function usageFrame(budget, credits, settings) {
     if (!budget)
         return null;
     return {
@@ -2091,6 +1513,11 @@ function usageFrame(budget, credits) {
         credits,
         creditsExhausted: castleCreditsExhausted(budget, credits),
         blockedClaudeModels: blockedClaudeModels(budget),
+        freeTier: freeTierForRoles(roleSpends(settings), budget.freeModelPrefixes),
+        freeModel: runIsCastlePaid('openrouter', null)
+            ? (budget.freeModelPrefixes[0] ?? null)
+            : null,
+        freeRoles: freeRolesFor(roleSpends(settings), budget.freeModelPrefixes),
     };
 }
 /**
@@ -2111,7 +1538,8 @@ function createUsageFeed(opts) {
     let credits = null;
     let budgetPolls = 0;
     async function readUsage(refreshCredits = false) {
-        if (!opts.castlePaid()) {
+        const settings = opts.settings();
+        if (!anyRoleIsCastlePaid(settings)) {
             credits = null;
             return null;
         }
@@ -2127,7 +1555,7 @@ function createUsageFeed(opts) {
             if (nextCredits)
                 credits = nextCredits;
         }
-        return usageFrame(budget, credits);
+        return usageFrame(budget, credits, settings);
     }
     function publishUsage(next) {
         if (JSON.stringify(next ?? null) === JSON.stringify(latest ?? null))
@@ -2159,17 +1587,13 @@ function createUsageFeed(opts) {
         },
     };
 }
-// 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.
+// One agent turn: buildAgentInvocation -> runAgentCli, with the pre-flight
+// refusals that stop a run before it spawns.
 async function runAgentTurn(opts) {
     // Resolve the OpenRouter credential ONCE and reuse it for pre-flight, the run,
     // and metering, so validation, spend, and the direct/proxy routing decision
     // can never diverge. Null on a non-OpenRouter path.
-    const orAuth = roleUsesOpenrouter(opts.backend, opts.claudeModel)
-        ? resolveOpenrouterAuth()
-        : null;
+    const orAuth = opts.claudeModel === 'openrouter' ? resolveOpenrouterAuth() : null;
     // Deterministic config errors stop here: nothing spawned, no request issued,
     // nothing billed. Returned (not thrown) because the callers' catch paths
     // emit generic "something went wrong" copy, which would bury the specific
@@ -2177,7 +1601,7 @@ async function runAgentTurn(opts) {
     // refuses is the same shape of answer, and comes second so a misconfigured
     // run is still reported as misconfigured.
     const failure = (await preflightOpenrouterRun({ ...opts, orAuth })) ??
-        (await castleSpendRefusal(opts.backend, opts.claudeModel, orAuth));
+        (await castleSpendRefusal(opts.claudeModel, opts.openrouterModel, orAuth));
     if (failure) {
         return {
             ok: false,
@@ -2194,46 +1618,11 @@ async function runAgentTurn(opts) {
     // conversation -- nothing is resumed).
     const sessionId = newAgentSessionId(opts.role);
     const settled = (run) => run.finally(() => notifyAgentRunFinished());
-    if (opts.backend === 'smith') {
-        // roleUsesOpenrouter is true for smith, so orAuth is non-null here.
-        const direct = orAuth.mode === 'user-key';
-        return settled(runAgentSmith({
-            cwd: opts.cwd,
-            role: opts.role,
-            apiKey: orAuth.key,
-            baseUrl: direct ? OPENROUTER_DIRECT_CHAT_BASE : undefined,
-            extraHeaders: meteringHeaders({
-                deckDir: opts.cwd,
-                sessionId,
-                route: 'openrouter',
-                direct,
-            }),
-            model: opts.openrouterModel,
-            prompt: opts.prompt,
-            system: opts.systemPrompt,
-            // 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,
-            openrouterTuning: opts.openrouterTuning,
-            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, { sessionId, deckDir: opts.cwd }, opts.taskId, opts.systemPrompt);
-    const startedMs = Date.now();
+    const invocation = buildAgentInvocation(opts.role, opts.prompt, opts.claudeModel, opts.openrouterModel, { sessionId, deckDir: opts.cwd }, opts.taskId, opts.systemPrompt);
     const run = runAgentCli({
         cwd: opts.cwd,
         command: invocation.command,
         args: invocation.args,
-        parser: parserForBackend(opts.backend),
         env: invocation.env,
         timeoutMs: opts.timeoutMs,
         logPath: opts.logPath,
@@ -2243,25 +1632,9 @@ async function runAgentTurn(opts) {
         onThinking: opts.onThinking,
         onSpawn: opts.onSpawn,
         labelUnknownTools: opts.labelUnknownTools,
-        openrouterModel: roleUsesOpenrouter(opts.backend, opts.claudeModel)
-            ? opts.openrouterModel
-            : undefined,
+        openrouterModel: opts.claudeModel === 'openrouter' ? opts.openrouterModel : undefined,
     });
-    // 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')
-        return settled(run);
-    return settled(run.then((result) => {
-        reportCursorRun({
-            deckDir: opts.cwd,
-            sessionId,
-            model: CURSOR_MODEL,
-            durationMs: Date.now() - startedMs,
-            ok: result.ok,
-        });
-        return result;
-    }));
+    return settled(run);
 }
 // -- task store ---------------------------------------------------------------
 function persistTaskFile(tasksDir, task) {
@@ -2513,7 +1886,7 @@ function sleep(ms) {
 // Chained-promise gate spacing out task-agent PROCESS LAUNCHES -- deliberately
 // NOT a queue class, just a promise each launch chains onto. Why: the
 // 2026-07 keychain-contention incident (see TASK_SPAWN_STAGGER_MS above) was
-// triggered by several cursor-agent processes starting at the exact same
+// triggered by several agent CLI processes starting at the exact same
 // instant; spacing consecutive launches out by TASK_SPAWN_STAGGER_MS avoids
 // that without limiting how many can run concurrently once they're up.
 let taskSpawnGate = Promise.resolve();
@@ -2536,13 +1909,6 @@ 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,
@@ -2552,14 +1918,9 @@ async function runTaskAgentIn(ctx, task) {
         notesPath: path.join(relDir, 'notes.md'),
         handoffPath: path.join(relDir, 'handoff'),
         depsSummary: ctx.depsSummary,
-        backend: ctx.backend,
-        playtest: playtestSteering(ctx.backend),
-        // 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: quickReferenceFor(ctx.deckDir, ctx.quickReference, ctx.backend),
+        playtest: playtestSteering(),
+        deckTree: buildDeckTree(ctx.deckDir),
+        quickReference: quickReferenceFor(ctx.deckDir, ctx.quickReference),
         plan: taskPlanOpts(ctx.deckDir, task.item, ctx.finishedWork),
         siblings: ctx.siblings,
     });
@@ -2569,14 +1930,6 @@ 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.
-    // 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:
@@ -2616,24 +1969,14 @@ async function runTaskAgentIn(ctx, task) {
     for (let attempt = 1; attempt <= MAX_TASK_ATTEMPTS; attempt++) {
         await staggerTaskSpawn();
         result = await runAgentTurn({
-            backend: ctx.backend,
             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'),
-            playtest: ctx.playtest
-                ? {
-                    executor: ctx.playtest.executor,
-                    serveUrl: ctx.playtest.serveUrl,
-                    framesDir: path.join(dir, 'playtest'),
-                }
-                : undefined,
             taskId: task.id,
-            restart: ctx.restart,
             children: ctx.children,
             onSpawn: (pid) => {
                 task.pid = pid;
@@ -2645,7 +1988,7 @@ async function runTaskAgentIn(ctx, task) {
                     ctx.onFeed(`[${activity}]`);
             },
         });
-        logAgentUsage(`task ${task.id}`, ctx.backend, result.usage);
+        logAgentUsage(`task ${task.id}`, result.usage);
         if (ctx.stopRequested.has(task.id))
             return result;
         if (!result.crashed)
@@ -2684,14 +2027,11 @@ function startTask(ctx, task) {
         deckLabel: ctx.deckLabel,
         tasksDir: ctx.tasksDir,
         children: ctx.children,
-        backend: ctx.backend(),
         claudeModel: ctx.claudeModel(),
         openrouterModel: ctx.openrouterModel(),
-        openrouterTuning: ctx.openrouterTuning(),
         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
@@ -2737,12 +2077,6 @@ function startTask(ctx, task) {
                 task.acknowledged = true;
             if (result.ok && !wasStopped)
                 task.progress = 100;
-            // Smith reports its frames on the run result; a claude agent's reach
-            // the record through runPlaytestFor as each call lands. Overwriting
-            // with `?? []` would erase the latter, since a CLI backend's result
-            // never carries them.
-            if (result.playtestFrames)
-                task.playtestFrames = result.playtestFrames;
             task.finishedAt = nowIso();
             task.resultSummary = wasStopped
                 ? 'stopped by the router'
@@ -2900,12 +2234,9 @@ function createTaskStore(opts) {
         tasks,
         stopRequested,
         quickReference: opts.quickReference,
-        backend: opts.backend,
         claudeModel: opts.claudeModel,
         openrouterModel: opts.openrouterModel,
-        openrouterTuning: opts.openrouterTuning,
         playtest: opts.playtest,
-        restart: opts.restart,
         onStarted: opts.onStarted,
         onFinished: opts.onFinished,
         onRetry: opts.onRetry,
@@ -3160,7 +2491,7 @@ const ERROR_PREVIEW_CHARS = 200;
 // tracing to '/var/folders/.../cursor_retrieval....log'" while the real
 // "Error: Security command failed: Security process exited with code: 44"
 // sat right below it. Only these two wrapper shapes get this treatment --
-// "agent run timed out" and "could not run cursor-agent: <message>" (the
+// "agent run timed out" and "could not run claude: <message>" (the
 // other two runAgentCli error strings) are already the whole story on line 1
 // and are left alone, same as before.
 const EXIT_WRAPPER_RE = /^agent (exited \d+|process kept dying)/;
@@ -3398,18 +2729,11 @@ function resolveFailure(result) {
 // context + transcript replay (minus log lines and the in-flight reply) +
 // the live board + this turn's instruction.
 function routerTurnPrompt(ctx, instruction, selfMessageId, plan) {
-    // 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 buildRouterPromptParts({
         deckLabel: ctx.deckLabel,
-        quickReference: quickReferenceFor(ctx.deckDir, ctx.quickReference, ctx.backend()),
-        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,
-        playtest: playtestSteering(ctx.tasksBackend()),
+        quickReference: quickReferenceFor(ctx.deckDir, ctx.quickReference),
+        deckTree: buildDeckTree(ctx.deckDir),
+        playtest: playtestSteering(),
         messages: ctx.log.messages
             .filter((m) => m.role !== 'log' && m.id !== selfMessageId && m.status !== 'streaming')
             .map((m) => ({
@@ -3508,10 +2832,7 @@ 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).
-// `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 = []) {
+function runRouterTurnIn(ctx, instruction) {
     const epoch = ctx.currentEpoch();
     const message = {
         id: nanoid(8),
@@ -3534,20 +2855,14 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
     let lastActivity = 'Thinking';
     ctx.broadcast({ type: 'message-activity', id: message.id, activity: 'Thinking' });
     const prompt = routerTurnPrompt(ctx, instruction, message.id, readPlanSnapshot(ctx.deckDir));
-    const backend = ctx.backend();
     void runAgentTurn({
-        backend,
         role: 'router',
         prompt: prompt.user,
         systemPrompt: prompt.system,
         claudeModel: ctx.claudeModel(),
         openrouterModel: ctx.openrouterModel(),
-        openrouterTuning: ctx.openrouterTuning(),
-        attachments,
         cwd: ctx.deckDir,
         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,
@@ -3575,7 +2890,7 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
         },
     })
         .then((result) => {
-        logAgentUsage('router', backend, result.usage);
+        logAgentUsage('router', 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;
@@ -3726,13 +3041,6 @@ function runRouterTurnIn(ctx, instruction, attachments = []) {
 function applyAgentSettings(incoming, ctx) {
     const { settings } = ctx;
     const changes = [];
-    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']) {
         const value = normalizeClaudeModel(incoming[key]);
         if (value && value !== settings[key]) {
@@ -3747,29 +3055,6 @@ function applyAgentSettings(incoming, ctx) {
             changes.push(`${key === 'routerOpenrouterModel' ? 'operator' : 'tasks'} openrouter model -> ${value}`);
         }
     }
-    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}`);
-        }
-    }
-    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}`);
-        }
-    }
-    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'}`);
-        }
-    }
     if (changes.length === 0)
         return;
     atomicWriteFileSync(ctx.settingsPath, serializeAgentSettings(settings));
@@ -3784,8 +3069,8 @@ function applyAgentSettings(incoming, ctx) {
 const ACCOUNTS_POLL_MS = 15_000;
 // The editor's view of which credentials exist, kept live. Unlike settings --
 // which nothing outside this process writes -- a credential changes behind the
-// editor's back all the time: `claude /login` or `cursor-agent logout` in the
-// terminal panel, a hand-edited user-keys.json, an agent run that refreshes an
+// editor's back all the time: `claude /login` in the terminal panel, a
+// hand-edited user-keys.json, an agent run that refreshes an
 // OAuth token. Push those, or the popover reports whatever was true when the
 // page loaded and a terminal sign-in reads as having done nothing.
 //
@@ -3853,12 +3138,10 @@ function applyCredentialChange(msg, ctx) {
 // set at all.
 function slugKeysToValidate(settings) {
     const keys = [];
-    if (roleUsesOpenrouter(settings.router ?? 'claude', settings.routerClaudeModel ?? 'opus') &&
-        settings.routerOpenrouterModel) {
+    if (settings.routerClaudeModel === 'openrouter' && settings.routerOpenrouterModel) {
         keys.push('routerOpenrouterModel');
     }
-    if (roleUsesOpenrouter(settings.tasks ?? 'claude', settings.tasksClaudeModel ?? 'sonnet') &&
-        settings.tasksOpenrouterModel) {
+    if (settings.tasksClaudeModel === 'openrouter' && settings.tasksOpenrouterModel) {
         keys.push('tasksOpenrouterModel');
     }
     return keys;
@@ -3908,7 +3191,7 @@ function killOrphanAgents(registryPath) {
             const cmd = execFileSync('ps', ['-p', String(entry.pid), '-o', 'command='], {
                 encoding: 'utf8',
             }).trim();
-            if (cmd.includes('cursor-agent') || cmd.includes('claude')) {
+            if (cmd.includes('claude')) {
                 process.kill(entry.pid, 'SIGKILL');
             }
         }
@@ -3929,9 +3212,7 @@ function startChildRegistry(registryPath, groups) {
         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.exitCode === null) {
                     live.push({ pid: child.pid, command: child.spawnfile });
                 }
             }
@@ -4042,9 +3323,8 @@ function killRouterChildren(ctx) {
     }
     return drafts.join('\n\n');
 }
-function startRouterTurn(ctx, instruction, attachments = []) {
+function startRouterTurn(ctx, instruction) {
     ctx.state.lastInstruction = instruction;
-    ctx.state.lastAttachments = attachments;
     runRouterTurnIn({
         deckDir: ctx.deckDir,
         deckLabel: ctx.deckLabel,
@@ -4056,18 +3336,11 @@ function startRouterTurn(ctx, instruction, attachments = []) {
         taskStore: ctx.taskStore,
         messageThinking: ctx.messageThinking,
         currentEpoch: () => ctx.state.userEpoch,
-        backend: () => ctx.settings.router,
-        tasksBackend: () => ctx.settings.tasks,
         claudeModel: () => ctx.settings.routerClaudeModel,
         openrouterModel: () => ctx.settings.routerOpenrouterModel,
-        openrouterTuning: () => ({
-            reasoningEffort: ctx.settings.routerReasoningEffort,
-            routing: ctx.settings.routerRouting,
-            providerTier: ctx.settings.routerProviderTier,
-        }),
         canAutoRetry: () => !ctx.state.autoRetryUsed && ctx.state.pendingSends.length === 0,
         onSettled: (retryable) => onRouterQueueSettled(ctx, retryable),
-    }, instruction, attachments);
+    }, instruction);
 }
 // 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
@@ -4127,7 +3400,7 @@ function maybeStartRouterQueueTurn(ctx) {
         interruptedDraft: draft || undefined,
         attachments: attachmentPaths,
         refs,
-    }), 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
@@ -4144,7 +3417,7 @@ function onRouterQueueSettled(ctx, retryable) {
         state.autoRetryUsed = true;
         state.routerRunning = true;
         broadcastQueueState(ctx);
-        startRouterTurn(ctx, state.lastInstruction, state.lastAttachments);
+        startRouterTurn(ctx, state.lastInstruction);
         return;
     }
     broadcastQueueState(ctx);
@@ -4279,7 +3552,6 @@ function createRouterQueue(deps) {
             autoRetryUsed: false,
             autoFoldUsed: false,
             lastInstruction: '',
-            lastAttachments: [],
         },
     };
     // Restart recovery: re-enqueue sends that never reached the message log,
@@ -4298,12 +3570,10 @@ function createRouterQueue(deps) {
 // The serve-side half of the claude backend's playtest tool: resolve which
 // task's frames dir and call budget a request belongs to, run it on the shared
 // warm Chromium, and record the frames on the task so its card shows them.
-// Smith never comes through here -- native/loop.ts builds its own ctx.
 function makePlaytestRunner(deps) {
-    // Per-TASK playtest budget, so PLAYTEST_MAX_CALLS_PER_RUN means the same
-    // thing to a claude agent as to smith. Stricter than smith's, which resets
-    // per attempt (one runAgentNative invocation): a retried claude task keeps
-    // spending the same four calls.
+    // Per-TASK playtest budget: a retried task keeps spending the same
+    // PLAYTEST_MAX_CALLS_PER_RUN calls rather than getting a fresh set per
+    // attempt.
     const callCounts = new Map();
     return async function runPlaytestFor(req) {
         const task = req.taskId ? deps.taskStore.get(req.taskId) : undefined;
@@ -4374,12 +3644,6 @@ export function createAgentServer(opts) {
             // with a navigation error. `localhost` resolves correctly under
             // every binding mode (default ::1, --host 0.0.0.0, explicit IPs).
             serveUrl: opts.playtestServeUrl ?? `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
-                ? () => playtestBrowserManager.prewarm()
-                : undefined,
         }
         : undefined;
     const taskChildren = new Set();
@@ -4407,7 +3671,7 @@ export function createAgentServer(opts) {
     const usageFeed = createUsageFeed({
         broadcast,
         hasClients: () => clients.size > 0,
-        castlePaid: () => anyRoleIsCastlePaid(settings),
+        settings: () => settings,
     });
     const accountsFeed = createAccountsFeed({
         broadcast,
@@ -4424,8 +3688,8 @@ export function createAgentServer(opts) {
     });
     const applySettings = (incoming) => {
         applyAgentSettings(incoming, { settings, settingsPath, broadcast });
-        // A backend switch can change who pays (a cursor role always spends
-        // Castle's), so the bar follows the change instead of the poll.
+        // A model switch can change who pays, and whether that spend is free at
+        // all (usage.freeTier), so the bar follows the change instead of the poll.
         usageFeed.refresh();
     };
     const taskFeeds = createTaskFeeds(broadcast, tasksDir);
@@ -4436,16 +3700,9 @@ export function createAgentServer(opts) {
         tasksDir,
         children: taskChildren,
         quickReference,
-        backend: () => settings.tasks,
         openrouterModel: () => settings.tasksOpenrouterModel,
         claudeModel: () => settings.tasksClaudeModel,
-        openrouterTuning: () => ({
-            reasoningEffort: settings.tasksReasoningEffort,
-            routing: settings.tasksRouting,
-            providerTier: settings.tasksProviderTier,
-        }),
         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, opts.signPath) }),
         onStarted: () => undefined,
@@ -4600,9 +3857,8 @@ export function createAgentServer(opts) {
                 applyCredentialChange(msg, { pushAccounts: accountsFeed.push });
             }
             else if (msg.type === 'account-login') {
-                const provider = loginProviderFor(msg.id);
-                if (provider)
-                    startLogin(provider, () => accountsFeed.push());
+                if (loginProviderFor(msg.id))
+                    startLogin(() => accountsFeed.push());
             }
             else if (msg.type === 'account-login-code' && typeof msg.value === 'string') {
                 submitLoginCode(msg.value);
@@ -4611,9 +3867,8 @@ export function createAgentServer(opts) {
                 cancelLogin();
             }
             else if (msg.type === 'account-logout') {
-                const provider = loginProviderFor(msg.id);
-                if (provider)
-                    logout(provider, () => accountsFeed.push());
+                if (loginProviderFor(msg.id))
+                    logout(() => accountsFeed.push());
             }
             else if (msg.type === 'client-timezone' && typeof msg.timeZone === 'string') {
                 setReaderTimeZone(msg.timeZone);
@@ -4642,8 +3897,6 @@ export function createAgentServer(opts) {
     const handleAttachment = makeAttachmentHandler(attachmentsDir);
     const handlePlaytestFrame = makePlaytestFrameHandler(tasksDir);
     function handleHttpRequest(req, res, reqPath) {
-        if (reqPath === AGENT_MODEL_CAPS_PREFIX)
-            return handleModelCaps(req, res);
         return handleAttachment(req, res, reqPath) || handlePlaytestFrame(req, res, reqPath);
     }
     function shutdown() {