castle-web-cli 0.4.81 → 0.4.83

package/dist/castle-host/host.js

@@ -28,6 +28,7 @@ const COMMAND_NAMES = [
     "pass.offer",
     "portal.open",
     "portal.prefetch",
+    "haptics.play",
 ];
 // Platform/capability commands: NOT serviced by graphqlFetch. They're dispatched
 // to the host's optional platformHandler (mobile renders native UI; web shows an
@@ -38,6 +39,7 @@ const PLATFORM_COMMAND_NAMES = [
     "pass.offer",
     "portal.open",
     "portal.prefetch",
+    "haptics.play",
 ];
 function isCommandName(value) {
     return (typeof value === "string" &&
@@ -106,6 +108,7 @@ function runCommand(ctx, command, params, caps) {
         case "pass.offer":
         case "portal.open":
         case "portal.prefetch":
+        case "haptics.play":
             return runPlatformCommand(ctx, command, params, caps);
     }
 }
@@ -122,6 +125,8 @@ async function runPlatformCommand(ctx, command, params, caps) {
             return portalOpen(ctx, params, caps);
         case "portal.prefetch":
             return portalPrefetch(ctx, params, caps);
+        case "haptics.play":
+            return hapticsPlay(ctx, params, caps);
         default:
             return unavailableOutcome();
     }
@@ -212,6 +217,29 @@ function normalizePortalPrefetchOutcome(value) {
     }
     return { status: "unavailable" };
 }
+// A haptic is a device effect, not deck-scoped state, so — unlike pass/portal —
+// no deckId is required; the style is validated and handed straight to the
+// host's platformHandler. Hosts that can't play a haptic (dev CLI — no handler;
+// a browser with no vibration API) get a normalized `unavailable`, never an
+// error.
+async function hapticsPlay(ctx, params, caps) {
+    const style = asString(params.style, "style", "haptics.play");
+    if (!caps.platformHandler)
+        return { status: "unavailable" };
+    const outcome = await caps.platformHandler("haptics.play", { style }, ctx);
+    return normalizeHapticsOutcome(outcome);
+}
+function normalizeHapticsOutcome(value) {
+    const record = typeof value === "object" && value !== null
+        ? value
+        : {};
+    const status = record.status;
+    const valid = ["triggered", "unavailable"];
+    if (typeof status === "string" && valid.includes(status)) {
+        return { status: status };
+    }
+    return { status: "unavailable" };
+}
 function unavailableOutcome() {
     return { status: "unavailable" };
 }

package/dist/ide.js

@@ -268,6 +268,136 @@ function handleFilesWrite(deckDir, req, res) {
         }
     })();
 }
+// Add `<rel>/**` to the deck's editor.visiblePaths so files created in a
+// newly-made folder show in the curated Files tree. Only touches a deck that is
+// ALREADY curated (non-empty visiblePaths) -- when visiblePaths is empty
+// everything is visible, and adding a glob would wrongly start hiding things.
+// No-op if an existing glob already covers the folder. Returns whether it wrote.
+function ensureVisiblePath(deckDir, rel) {
+    const file = path.join(deckDir, "castle.json");
+    let data;
+    try {
+        data = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return false; // no castle.json yet (deck never saved) -> treat as not curated
+    }
+    const visible = data.editor && Array.isArray(data.editor.visiblePaths)
+        ? data.editor.visiblePaths.filter((v) => typeof v === "string")
+        : null;
+    if (!visible || visible.length === 0)
+        return false; // not curated -> all visible
+    const glob = `${rel}/**`;
+    if (visible.includes(glob))
+        return false;
+    if (picomatch(visible)(`${rel}/__probe__`))
+        return false; // already covered
+    visible.push(glob);
+    data.editor.visiblePaths = visible;
+    try {
+        fs.writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function handleFilesMkdir(deckDir, req, res) {
+    void (async () => {
+        let body;
+        try {
+            body = JSON.parse(await readRequestBody(req));
+        }
+        catch {
+            return sendJson(res, 400, { error: "Invalid JSON body." });
+        }
+        const resolved = resolveDeckPath(deckDir, body.path);
+        if (!resolved.ok)
+            return sendJson(res, 400, { error: resolved.error });
+        try {
+            fs.mkdirSync(resolved.abs, { recursive: true });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return sendJson(res, 500, { error: `Could not create folder ${resolved.rel}: ${message}` });
+        }
+        const visiblePathAdded = ensureVisiblePath(deckDir, resolved.rel);
+        sendJson(res, 200, { ok: true, path: resolved.rel, visiblePathAdded });
+    })();
+}
+// True when two paths resolve to the same underlying file (same inode+device) --
+// e.g. the source and target of a case-only rename on a case-insensitive FS.
+function isSameFile(a, b) {
+    try {
+        const sa = fs.statSync(a);
+        const sb = fs.statSync(b);
+        return sa.ino === sb.ino && sa.dev === sb.dev;
+    }
+    catch {
+        return false;
+    }
+}
+function handleFilesRename(deckDir, req, res) {
+    void (async () => {
+        let body;
+        try {
+            body = JSON.parse(await readRequestBody(req));
+        }
+        catch {
+            return sendJson(res, 400, { error: "Invalid JSON body." });
+        }
+        const from = resolveDeckPath(deckDir, body.from);
+        if (!from.ok)
+            return sendJson(res, 400, { error: from.error });
+        const to = resolveDeckPath(deckDir, body.to);
+        if (!to.ok)
+            return sendJson(res, 400, { error: to.error });
+        if (!fs.existsSync(from.abs)) {
+            return sendJson(res, 404, { error: `Not found: ${from.rel}` });
+        }
+        // Block a collision with a DIFFERENT existing file. On a case-insensitive
+        // filesystem (default on macOS/Windows) `to` can "exist" only because it is
+        // `from` under a different case -- a case-only rename like bounce.jsx ->
+        // Bounce.jsx. Allow that by treating same-inode as not-a-collision.
+        if (from.abs !== to.abs && fs.existsSync(to.abs) && !isSameFile(from.abs, to.abs)) {
+            return sendJson(res, 409, { error: `Already exists: ${to.rel}` });
+        }
+        try {
+            fs.mkdirSync(path.dirname(to.abs), { recursive: true });
+            fs.renameSync(from.abs, to.abs);
+            sendJson(res, 200, { ok: true, path: to.rel });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendJson(res, 500, { error: `Could not rename ${from.rel}: ${message}` });
+        }
+    })();
+}
+function handleFilesDelete(deckDir, req, res) {
+    void (async () => {
+        let body;
+        try {
+            body = JSON.parse(await readRequestBody(req));
+        }
+        catch {
+            return sendJson(res, 400, { error: "Invalid JSON body." });
+        }
+        const resolved = resolveDeckPath(deckDir, body.path);
+        if (!resolved.ok)
+            return sendJson(res, 400, { error: resolved.error });
+        if (!fs.existsSync(resolved.abs)) {
+            return sendJson(res, 404, { error: `Not found: ${resolved.rel}` });
+        }
+        try {
+            fs.rmSync(resolved.abs, { recursive: true, force: true });
+            sendJson(res, 200, { ok: true, path: resolved.rel });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendJson(res, 500, { error: `Could not delete ${resolved.rel}: ${message}` });
+        }
+    })();
+}
 // The builtin Files + code-editor backend: list / read / write deck files and
 // report kit-owned editor extensions. Paths are deck-relative; resolveDeckPath
 // rejects traversal and protected dirs.
@@ -286,7 +416,14 @@ function handleFilesApi(deckDir, req, res, reqPath) {
         return true;
     }
     if (action === "list") {
-        const files = filterDeckFiles(listDeckFiles(deckDir), readEditorConfig(deckDir));
+        // `?all=1` returns the unfiltered listing (the "show hidden files & folders"
+        // toggle) -- still minus the always-ignored dirs (node_modules/.castle/...),
+        // just without the deck's visible/hidden path curation.
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const listed = listDeckFiles(deckDir);
+        const files = url.searchParams.get("all") === "1"
+            ? listed
+            : filterDeckFiles(listed, readEditorConfig(deckDir));
         sendJson(res, 200, { files });
         return true;
     }
@@ -308,6 +445,18 @@ function handleFilesApi(deckDir, req, res, reqPath) {
         handleFilesWrite(deckDir, req, res);
         return true;
     }
+    if (action === "rename") {
+        handleFilesRename(deckDir, req, res);
+        return true;
+    }
+    if (action === "delete") {
+        handleFilesDelete(deckDir, req, res);
+        return true;
+    }
+    if (action === "mkdir") {
+        handleFilesMkdir(deckDir, req, res);
+        return true;
+    }
     return sendJson(res, 404, { error: `Unknown files action: ${action}` }), true;
 }
 function defaultShell() {

package/dist/init.js

@@ -35,7 +35,7 @@ const DEFAULT_KIT = "basic-2d";
 // Registry version of castle-web-sdk to inject when scaffolding from a
 // globally-installed castle-web (not from inside the workspace). Bumped
 // alongside cli/sdk version bumps.
-const PUBLISHED_SDK_VERSION = "0.4.9";
+const PUBLISHED_SDK_VERSION = "0.4.10";
 // Never copied into a fresh deck: build/dependency junk. castle.json IS copied
 // (the kit ships a config-only one with the editor layout / file filters), but
 // `scaffoldFromKit` strips any identity fields off it first -- a fresh deck has

package/dist/native/loop.js

@@ -21,16 +21,9 @@ import { toolSchemasForRole, executeTool, activityLabelForCall, } from "./tools.
 // Safety valve against a model that never stops calling tools -- distinct
 // from timeoutMs, which bounds wall-clock time regardless of iteration count.
 const MAX_ITERATIONS = 40;
-const TOUCHED_FILE_LIMIT = 10;
-function touchedFileList(files) {
-    const sorted = [...files].sort();
-    if (sorted.length <= TOUCHED_FILE_LIMIT)
-        return sorted;
-    return [...sorted.slice(0, TOUCHED_FILE_LIMIT), `+${sorted.length - TOUCHED_FILE_LIMIT} more`];
-}
-// playtest frames never hit the TOUCHED_FILE_LIMIT truncation above (a run
-// is capped at PLAYTEST_MAX_CALLS_PER_RUN calls x PLAYTEST_MAX_SHOTS frames
-// each -- at most 24 -- small enough to list in full for the task card).
+// playtest frames are capped at PLAYTEST_MAX_CALLS_PER_RUN calls x
+// PLAYTEST_MAX_SHOTS frames each -- at most 24 -- small enough to list in
+// full for the task card, with no truncation needed.
 function playtestFrameList(frames) {
     return [...frames].sort();
 }
@@ -399,11 +392,11 @@ function groupToolCalls(toolCalls) {
 // Executes one tool call and reports its own activity label -- everything
 // error handling and result-shape wise is identical to the old sequential
 // loop; only the caller (runToolCalls) changed, to run several of these
-// concurrently within a group. Bookkeeping shared across calls (filesTouched,
-// the labels map, the log) is intentionally NOT touched in here -- the
-// caller applies it after Promise.all resolves, walking the group in its
-// ORIGINAL order, so concurrent completion order never affects what lands in
-// the message array or the log.
+// concurrently within a group. Bookkeeping shared across calls (the labels
+// map, the log) is intentionally NOT touched in here -- the caller applies
+// it after Promise.all resolves, walking the group in its ORIGINAL order, so
+// concurrent completion order never affects what lands in the message array
+// or the log.
 async function runOneToolCall(call, role, ctx, onActivity) {
     const name = call.function?.name ?? "";
     const { args, error } = parseToolArgs(call.function?.arguments ?? "");
@@ -418,7 +411,7 @@ async function runOneToolCall(call, role, ctx, onActivity) {
     onActivity?.(null);
     return { call, name, args, result };
 }
-async function runToolCalls(toolCalls, role, ctx, filesTouched, playtestFrames, labels, imageLabels, log, onActivity) {
+async function runToolCalls(toolCalls, role, ctx, playtestFrames, labels, imageLabels, log, onActivity) {
     const results = [];
     // Images a call produced this batch (view_image, playtest, ...). Delivered
     // as synthetic role:"user" messages AFTER all the batch's tool results --
@@ -435,9 +428,6 @@ async function runToolCalls(toolCalls, role, ctx, filesTouched, playtestFrames,
         const resolved = await Promise.all(group.map((call) => runOneToolCall(call, role, ctx, onActivity)));
         for (const { call, name, args, result } of resolved) {
             labels.set(call.id, toolCallLabel(name, args));
-            if (result.filesTouched)
-                for (const f of result.filesTouched)
-                    filesTouched.add(f);
             if (result.playtestFrames)
                 for (const f of result.playtestFrames)
                     playtestFrames.add(f);
@@ -502,9 +492,6 @@ export async function runAgentNative(opts) {
             ...(result.error ? { error: result.error } : {}),
             ...(result.crashed ? { crashed: true } : {}),
             ...(result.usage ? { usage: result.usage } : {}),
-            ...(result.filesTouched && result.filesTouched.length > 0
-                ? { filesTouched: result.filesTouched }
-                : {}),
             ...(result.playtestFrames && result.playtestFrames.length > 0
                 ? { playtestFrames: result.playtestFrames }
                 : {}),
@@ -571,7 +558,6 @@ async function runLoop(opts, toolSchemas, log) {
             }
             : undefined,
     };
-    const filesTouched = new Set();
     const playtestFrames = new Set();
     const toolLabels = new Map();
     // Synthetic view_image carrier messages, by identity -- see runToolCalls
@@ -590,7 +576,6 @@ async function runLoop(opts, toolSchemas, log) {
             text: finalText,
             error: timeoutFired ? "agent run timed out" : "agent run stopped",
             usage: totalUsage,
-            filesTouched: touchedFileList(filesTouched),
             playtestFrames: playtestFrameList(playtestFrames),
         };
     };
@@ -613,7 +598,11 @@ async function runLoop(opts, toolSchemas, log) {
                 model: opts.model,
                 messages,
                 tools: toolSchemas,
-                reasoningEffort: REASONING_EFFORT[opts.role],
+                // Settings-driven per-role effort; falls back to the built-in table
+                // when a caller doesn't supply one (e.g. the QA harness).
+                reasoningEffort: opts.reasoningEffort ?? REASONING_EFFORT[opts.role],
+                routing: opts.routing,
+                providerTier: opts.providerTier,
                 maxTokens: MAX_COMPLETION_TOKENS,
                 signal: controller.signal,
                 onDelta: opts.onDelta,
@@ -647,7 +636,6 @@ async function runLoop(opts, toolSchemas, log) {
                     text: finalText,
                     error: streamResult.error ?? "openrouter stream ended without a final response",
                     usage: totalUsage,
-                    filesTouched: touchedFileList(filesTouched),
                     playtestFrames: playtestFrameList(playtestFrames),
                     crashed: streamResult.crashed,
                 };
@@ -672,7 +660,6 @@ async function runLoop(opts, toolSchemas, log) {
                 return {
                     text: finalText,
                     usage: totalUsage,
-                    filesTouched: touchedFileList(filesTouched),
                     playtestFrames: playtestFrameList(playtestFrames),
                 };
             }
@@ -681,7 +668,7 @@ async function runLoop(opts, toolSchemas, log) {
                 content: streamResult.message.content || null,
                 tool_calls: toolCalls,
             });
-            const toolResults = await runToolCalls(toolCalls, opts.role, toolCtx, filesTouched, playtestFrames, toolLabels, imageLabels, log, opts.onActivity);
+            const toolResults = await runToolCalls(toolCalls, opts.role, toolCtx, playtestFrames, toolLabels, imageLabels, log, opts.onActivity);
             messages.push(...toolResults);
         }
     }
@@ -692,7 +679,6 @@ async function runLoop(opts, toolSchemas, log) {
         text: finalText,
         error: "agent exceeded the maximum number of tool-call iterations",
         usage: totalUsage,
-        filesTouched: touchedFileList(filesTouched),
         playtestFrames: playtestFrameList(playtestFrames),
     };
 }

package/dist/native/openrouter.d.ts

@@ -27,13 +27,17 @@ export interface ORAssistantMessage {
     content: string;
     tool_calls?: ORToolCall[];
 }
-export type ORReasoningEffort = "low" | "medium";
+export type ORReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ORRoutingMode = "balanced" | "nitro" | "exacto" | "floor";
+export declare function applyRoutingMode(model: string, routing?: ORRoutingMode): string;
 export interface StreamChatOpts {
     apiKey: string;
     model: string;
     messages: ORMessage[];
     tools?: unknown[];
     reasoningEffort?: ORReasoningEffort;
+    routing?: ORRoutingMode;
+    providerTier?: string;
     maxTokens?: number;
     signal?: AbortSignal;
     onDelta?: (delta: string) => void;

package/dist/native/openrouter.js

@@ -24,6 +24,20 @@ function openrouterUrl() {
 const DEFAULT_MAX_RETRIES = 2; // -> 3 total connect attempts
 const RETRY_BASE_MS = 500;
 const RETRY_MAX_MS = 4_000;
+const ROUTING_SUFFIX = {
+    nitro: ":nitro",
+    exacto: ":exacto",
+    floor: ":floor",
+};
+// Append the routing-mode suffix to a model slug, first stripping any suffix
+// we might have added on a previous turn (or that the user typed into the
+// free-form slug field) so switching modes doesn't stack `:nitro:floor`.
+export function applyRoutingMode(model, routing) {
+    const base = model.replace(/:(nitro|exacto|floor)$/, "");
+    if (!routing || routing === "balanced")
+        return base;
+    return base + ROUTING_SUFFIX[routing];
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -188,7 +202,8 @@ function finalizeToolCalls(pending) {
 }
 export async function streamChatCompletion(opts) {
     const body = {
-        model: opts.model,
+        // Routing mode rides the slug as a suffix (see applyRoutingMode).
+        model: applyRoutingMode(opts.model, opts.routing),
         messages: opts.messages,
         stream: true,
         // Deprecated on OpenRouter's side (usage is always included now) but
@@ -199,6 +214,10 @@ export async function streamChatCompletion(opts) {
         // See ORReasoningEffort / StreamChatOpts.reasoningEffort above for the
         // doc reference and the graceful-degradation guarantee this relies on.
         ...(opts.reasoningEffort ? { reasoning: { effort: opts.reasoningEffort } } : {}),
+        // Pin a provider tier when requested (see StreamChatOpts.providerTier).
+        ...(opts.providerTier
+            ? { provider: { order: [opts.providerTier], allow_fallbacks: true } }
+            : {}),
         // See StreamChatOpts.maxTokens above -- bounds one completion call's
         // total output (content + tool-call arguments + reasoning).
         ...(opts.maxTokens !== undefined ? { max_tokens: opts.maxTokens } : {}),

package/dist/native/tools.d.ts

@@ -18,7 +18,6 @@ export interface ToolExecContext {
 export interface ToolCallResult {
     ok: boolean;
     output: string;
-    filesTouched?: string[];
     images?: Array<{
         label: string;
         dataUrl: string;

package/dist/native/tools.js

@@ -21,17 +21,6 @@ import { PLAYTEST_TOOL_DESCRIPTION, PLAYTEST_TOOL_PARAMETERS, runPlaytest, } fro
 function err(message) {
     return { ok: false, output: `Error: ${message}` };
 }
-// Mirrors PROGRESS_FILE_RE / the .castle/ exclusion in agent.ts's
-// normalizeTouchedPath, so a native task's filesTouched reads the same as a
-// CLI task's once wired together.
-const PROGRESS_FILE_RE = /\.castle\/agent\/tasks\/[^/]+\/progress$/;
-function isTrackedTouch(rel) {
-    if (rel.startsWith(".castle/"))
-        return false;
-    if (PROGRESS_FILE_RE.test(rel))
-        return false;
-    return true;
-}
 // Mirrors DECK_TREE_EXCLUDE in agent.ts.
 const IGNORED_DIRS = new Set(["node_modules", ".castle", ".git", "dist", ".DS_Store"]);
 const MAX_WALK_FILES = 20_000;
@@ -41,8 +30,7 @@ function baseName(p) {
 }
 // Resolves a tool-supplied path against the deck dir and rejects any escape
 // (absolute paths outside it, `..` traversal). Returns both the absolute path
-// and a deck-root-relative path (forward-slashed, for display and for
-// filesTouched entries).
+// and a deck-root-relative path (forward-slashed, for display in tool output).
 function resolveInDeck(deckDir, rawPath) {
     if (typeof rawPath !== "string" || rawPath.trim() === "")
         return null;
@@ -169,8 +157,8 @@ const VIEW_IMAGE_SIZE_CAP = 4 * 1024 * 1024;
 //
 // Path confinement is the same resolveInDeck as every file tool; note that
 // user attachments live at .castle/agent/attachments/ INSIDE the deck, so
-// they are reachable here (the .castle/ exclusions elsewhere apply to
-// filesTouched tracking and tree walks, never to reads).
+// they are reachable here (the .castle/ exclusions elsewhere apply to tree
+// walks, never to reads).
 function viewImageRun(args, ctx) {
     const resolved = resolveInDeck(ctx.deckDir, args.path);
     if (!resolved)
@@ -218,11 +206,9 @@ function writeFileRun(args, ctx) {
     catch (e) {
         return err(`could not write ${resolved.rel}: ${e instanceof Error ? e.message : String(e)}`);
     }
-    const filesTouched = isTrackedTouch(resolved.rel) ? [resolved.rel] : [];
     return {
         ok: true,
         output: `Wrote ${resolved.rel} (${Buffer.byteLength(args.content, "utf8")} bytes).`,
-        filesTouched,
     };
 }
 // -- edit_file ------------------------------------------------------------------
@@ -264,11 +250,9 @@ function editFileRun(args, ctx) {
     catch (e) {
         return err(`could not write ${resolved.rel}: ${e instanceof Error ? e.message : String(e)}`);
     }
-    const filesTouched = isTrackedTouch(resolved.rel) ? [resolved.rel] : [];
     return {
         ok: true,
         output: `Edited ${resolved.rel}${replaceAll ? ` (${count} replacements)` : ""}.`,
-        filesTouched,
     };
 }
 // -- list_files -----------------------------------------------------------------
@@ -366,61 +350,6 @@ function grepRun(args, ctx) {
         output: results.join("\n") + (truncated ? `\n... (capped at ${GREP_MAX_RESULTS} matches)` : ""),
     };
 }
-// -- bash filesTouched heuristic ---------------------------------------------
-// Mirrors shellTouchedCandidates/drawingPathForDrawArg/looksLikeTouchedPath in
-// agent.ts's CLI stream parser, so a smith task's bash-redirect writes are
-// tracked the same way a cursor/claude task's shell-tool writes are. Before
-// this, bash had NO filesTouched signal at all here -- a smith task that
-// wrote its result via a shell redirect (heredoc, `>`, `npm run draw --`,
-// etc.) instead of write_file/edit_file still landed with an empty
-// filesTouched and tripped the false "no changes" caution despite genuinely
-// writing to disk. (This is the gap agent-prompts.ts's renderTasks used to
-// paper over with a "bash side effects aren't tracked" caveat.)
-const SHELL_REDIRECT_RE = /(?:^|[\s;|])(?:\d*)>>?\s*(?!&)(?:"([^"]+)"|'([^']+)'|([^\s;&|]+))/g;
-const DRAW_RE = /npm\s+run\s+draw\s+--\s+([^\s;&|]+)/g;
-function drawingPathForDrawArg(raw) {
-    const name = raw.replace(/^['"]|['"]$/g, "").trim();
-    if (!name || name.startsWith("-") || name.includes("\n"))
-        return null;
-    if (name.startsWith("drawings/")) {
-        return name.endsWith(".pxart") ? name : `${name}.pxart`;
-    }
-    return `drawings/${name.endsWith(".pxart") ? name : `${name}.pxart`}`;
-}
-// Guards every redirect candidate against junk that isn't plausibly a path --
-// the redirect regex treats any `>`-plus-token as a write target, so e.g. a
-// numeric comparison inside a quoted inline script (`>=5`) false-matches.
-function looksLikeTouchedPath(raw) {
-    return /[a-zA-Z0-9]/.test(raw) && raw[0] !== "-" && raw[0] !== "=";
-}
-function shellTouchedCandidates(command) {
-    const out = [];
-    for (const match of command.matchAll(SHELL_REDIRECT_RE)) {
-        const target = match[1] ?? match[2] ?? match[3];
-        if (target)
-            out.push(target);
-    }
-    for (const match of command.matchAll(DRAW_RE)) {
-        const drawing = drawingPathForDrawArg(match[1] ?? "");
-        if (drawing)
-            out.push(drawing);
-    }
-    return out;
-}
-// Resolves each shell-redirect candidate against the deck dir the same way
-// write_file/edit_file do (path escapes rejected, .castle/ and the progress
-// file excluded) -- see resolveInDeck/isTrackedTouch above.
-function bashFilesTouched(deckDir, command) {
-    const out = [];
-    for (const candidate of shellTouchedCandidates(command)) {
-        if (!looksLikeTouchedPath(candidate) || candidate.includes("\n"))
-            continue;
-        const resolved = resolveInDeck(deckDir, candidate);
-        if (resolved && isTrackedTouch(resolved.rel))
-            out.push(resolved.rel);
-    }
-    return out;
-}
 // -- bash -------------------------------------------------------------------
 // Full shell, trusted -- matches today's --force trust level for task agents
 // (ratified; not revisited here). cwd is always the deck dir; per-call
@@ -480,14 +409,9 @@ function bashRun(args, ctx) {
             // the assistant's own tool_call (which, unlike this result, is never
             // evicted from context -- see evictOldToolResults in loop.ts), so
             // repeating it would just be the same bytes twice on every later turn.
-            // filesTouched is derived from the command text itself (not gated on
-            // `ok`): a shell redirect creates/truncates its target as soon as the
-            // shell sets it up, before the command even runs, so the write already
-            // landed even if the command that followed the redirect then failed.
             resolve({
                 ok,
                 output: `(exit ${code ?? "null"})\n${capped}${timedOutNote}`,
-                filesTouched: bashFilesTouched(ctx.deckDir, command),
             });
         });
     });

package/dist/native/types.d.ts

@@ -1,4 +1,5 @@
 import type { PlaytestExecutor } from "./playtest.js";
+import type { ORReasoningEffort, ORRoutingMode } from "./openrouter.js";
 export type NativeRole = "router" | "task";
 export interface NativePlaytestOpts {
     executor: PlaytestExecutor;
@@ -16,6 +17,9 @@ export interface NativeRunOpts {
     role: NativeRole;
     model: string;
     apiKey: string;
+    reasoningEffort?: ORReasoningEffort;
+    routing?: ORRoutingMode;
+    providerTier?: string;
     prompt: string;
     systemReminder?: string;
     attachments?: string[];
@@ -34,7 +38,6 @@ export interface NativeRunResult {
     text: string;
     error?: string;
     usage?: NativeUsage;
-    filesTouched?: string[];
     playtestFrames?: string[];
     crashed?: boolean;
 }

package/dist/native/types.js

@@ -4,8 +4,8 @@
 // These MIRROR the non-exported CliRunOpts / CliRunResult / CliUsage
 // interfaces in cli/src/agent.ts (see runAgentCli there), which normalize
 // the headless `claude` / `cursor-agent` CLI backends into onDelta/onActivity/
-// onThinking hooks plus a { finalText, error, usage, filesTouched, crashed }
-// result. This file is a SEPARATE set of types for now (new-files-only
+// onThinking hooks plus a { finalText, error, usage, crashed } result. This
+// file is a SEPARATE set of types for now (new-files-only
 // constraint -- agent.ts is being edited concurrently by a sibling change),
 // not a re-export, so field names differ in a few places. When the native
 // backend is wired into agent.ts, expect one of these two outcomes:
@@ -14,7 +14,7 @@
 //      (command/args/parser and children become backend-specific extras), or
 //   2. the call site maps between the two shapes directly:
 //        - NativeRunResult.text            -> CliRunResult.finalText
-//        - NativeRunResult.error/usage/filesTouched/crashed -> same names
+//        - NativeRunResult.error/usage/crashed -> same names
 //        - CliRunResult.ok                 <- derived as
 //              `!result.error && !result.crashed` (no native equivalent of
 //              a process exit code -- "ok" always follows from the other