castle-web-cli 0.4.81 → 0.4.82

package/dist/agent-prompts.d.ts

@@ -9,15 +9,12 @@ export interface PromptTask {
     status: string;
     progress: number;
     notes: string;
-    files?: string[];
     error?: string;
     blockedBy?: string[];
-    suspectNoChanges?: boolean;
 }
 export interface PromptSibling {
     title: string;
     status: string;
-    files?: string[];
 }
 export declare function buildRouterPrompt(opts: {
     deckLabel: string;

package/dist/agent-prompts.js

@@ -48,7 +48,6 @@ comma-separated active-task titles or ids, or \`all\`
 - Never claim the board is cleared without actually emitting the fence.
 - Tasks are one-and-done -- when the user gives feedback on a finished task, spawn a new fix task (and \`castle-done\` the old row) rather than reopening it.
 - Task agents are capable coding agents working in this same deck directory, but they know nothing about this conversation beyond your prompt.
-- Board rows may include \`files:\` for finished work. Use those touched-file lists to aim follow-up/fix tasks and to keep shared names consistent without rereading the deck.
 
 Asking with options (the \`\`\`ask block). When you need the user to settle a few choices at once, emit ONE fenced block tagged \`ask\` containing JSON -- it renders inline in the chat as grouped options they tap and submit together (far better than stacking questions they can only half-answer). Reach for it to pin a direction fast when their ask is vague ("make me a game" -> ask what kind), NOT to interrogate. Options only, no free text.
 
@@ -88,15 +87,11 @@ function renderTasks(tasks) {
     return tasks
         .map((t) => {
         const notes = t.notes.trim() ? ` -- notes: ${t.notes.trim()}` : "";
-        const files = t.files && t.files.length > 0 ? ` -- files: ${t.files.join(", ")}` : "";
         const error = t.error ? ` -- error: ${t.error}` : "";
         const blockedBy = t.blockedBy && t.blockedBy.length > 0
             ? ` -- blocked by: ${t.blockedBy.join(", ")}`
             : "";
-        const suspect = t.suspectNoChanges
-            ? " -- caution: done but touched no tracked files (bash side effects aren't tracked); verify the work actually landed"
-            : "";
-        return `- [${t.status} ${t.progress}%] ${t.title} (${t.id})${notes}${files}${error}${blockedBy}${suspect}`;
+        return `- [${t.status} ${t.progress}%] ${t.title} (${t.id})${notes}${error}${blockedBy}`;
     })
         .join("\n");
 }
@@ -163,10 +158,10 @@ export function buildTaskPrompt(opts) {
         ? `\n\nThis task waited on earlier tasks:\n${opts.depsSummary}\n`
         : "";
     const siblingRows = (opts.siblings ?? [])
-        .map((s) => `- [${s.status}] ${s.title}${s.files && s.files.length > 0 ? ` -- files: ${s.files.join(", ")}` : ""}`)
+        .map((s) => `- [${s.status}] ${s.title}`)
         .join("\n");
     const siblings = siblingRows
-        ? `\n\nOther tasks on this deck's board (snapshot at your start):\n${siblingRows}\nRunning and waiting rows are sibling agents working in this same directory. If a sibling plainly owns something your prompt only references (art, a scene, a behavior), leave it to them -- create only what YOUR prompt says to create. Finished rows' file lists show where recent work landed.\n`
+        ? `\n\nOther tasks on this deck's board (snapshot at your start):\n${siblingRows}\nRunning and waiting rows are sibling agents working in this same directory. If a sibling plainly owns something your prompt only references (art, a scene, a behavior), leave it to them -- create only what YOUR prompt says to create.\n`
         : "";
     // Same "say there are no docs" reasoning as buildRouterPrompt's
     // quickReference above -- a task agent wastes turns the same way a router

package/dist/agent.d.ts

@@ -20,7 +20,6 @@ interface TaskRecord {
     finishedAt?: string;
     pid?: number;
     originMessageId?: string;
-    files?: string[];
     playtestFrames?: string[];
     resultSummary?: string;
     avatar?: string;
@@ -28,7 +27,6 @@ interface TaskRecord {
     acknowledged?: boolean;
     rejected?: boolean;
     blockedBy?: string[];
-    suspectNoChanges?: boolean;
 }
 export interface DepsState {
     kind: "ready" | "waiting" | "blocked";

package/dist/agent.js

@@ -787,137 +787,12 @@ function readQuickReference(deckDir) {
 function readWelcomeMessage(deckDir) {
     return readClaudeSection(deckDir, "Welcome message");
 }
-const TOUCHED_FILE_LIMIT = 10;
-function collectStrings(value, out) {
-    if (typeof value === "string") {
-        out.push(value);
-    }
-    else if (Array.isArray(value)) {
-        for (const item of value)
-            collectStrings(item, out);
-    }
-    else if (value && typeof value === "object") {
-        for (const item of Object.values(value)) {
-            collectStrings(item, out);
-        }
-    }
-}
-function toolWritesFiles(name) {
-    const kind = name.toLowerCase();
-    return ["edit", "write", "notebookedit", "multiedit", "delete"].some((p) => kind.startsWith(p));
-}
-function toolRunsShell(name) {
-    const kind = name.toLowerCase();
-    return (kind.startsWith("bash") ||
-        kind.startsWith("shell") ||
-        kind.includes("terminal"));
-}
-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`}`;
-}
-function shellTouchedCandidates(command) {
-    const out = [];
-    const redirectRe = /(?:^|[\s;|])(?:\d*)>>?\s*(?!&)(?:"([^"]+)"|'([^']+)'|([^\s;&|]+))/g;
-    for (const match of command.matchAll(redirectRe)) {
-        const target = match[1] ?? match[2] ?? match[3];
-        if (target)
-            out.push(target);
-    }
-    const drawRe = /npm\s+run\s+draw\s+--\s+([^\s;&|]+)/g;
-    for (const match of command.matchAll(drawRe)) {
-        const drawing = drawingPathForDrawArg(match[1] ?? "");
-        if (drawing)
-            out.push(drawing);
-    }
-    return out;
-}
-// Guards every touched-file candidate (shell redirects AND tool file-path
-// args) against junk that isn't plausibly a path. Added because
-// shellTouchedCandidates' redirect regex treats any `>`-plus-token as a
-// write target, so a command merely CONTAINING `>=` (e.g. a numeric
-// comparison inside a quoted inline JS/awk script) false-matches as a
-// redirect to "=" (or "=5" with no space around the `>=`) -- neither looks
-// like a real file. A leading "-" is rejected too, mirroring
-// drawingPathForDrawArg's flag guard above.
-function looksLikeTouchedPath(raw) {
-    return /[a-zA-Z0-9]/.test(raw) && raw[0] !== "-" && raw[0] !== "=";
-}
-function normalizeTouchedPath(cwd, raw) {
-    if (!raw || raw.includes("\n") || !looksLikeTouchedPath(raw))
-        return null;
-    const abs = path.isAbsolute(raw) ? raw : path.resolve(cwd, raw);
-    const rel = path.relative(cwd, abs);
-    if (!rel || rel.startsWith("..") || path.isAbsolute(rel))
-        return null;
-    const normalized = rel.split(path.sep).join("/");
-    if (normalized.startsWith(".castle/") || PROGRESS_FILE_RE.test(normalized)) {
-        return null;
-    }
-    return normalized;
-}
-function addTouchedFiles(files, cwd, toolName, input) {
-    const candidates = [];
-    if (toolWritesFiles(toolName)) {
-        collectStrings([
-            input.file_path,
-            input.path,
-            input.notebook_path,
-            input.old_path,
-            input.new_path,
-        ], candidates);
-    }
-    else if (toolRunsShell(toolName) && typeof input.command === "string") {
-        candidates.push(...shellTouchedCandidates(input.command));
-    }
-    else {
-        return;
-    }
-    for (const candidate of candidates) {
-        const normalized = normalizeTouchedPath(cwd, candidate);
-        if (normalized)
-            files.add(normalized);
-    }
-}
-function cursorToolNameAndInput(ev) {
-    const call = ev.tool_call;
-    const key = call ? Object.keys(call).find((k) => k.endsWith("ToolCall")) : undefined;
-    if (!call || !key)
-        return null;
-    const input = call[key];
-    const args = input && typeof input === "object"
-        ? input.args
-        : undefined;
-    return {
-        name: key.slice(0, -"ToolCall".length),
-        input: args && typeof args === "object"
-            ? args
-            : input && typeof input === "object"
-                ? input
-                : {},
-    };
-}
-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`,
-    ];
-}
 function createAgentStreamState() {
     return {
         accumulated: "",
         finalText: "",
         resultIsError: false,
         usage: undefined,
-        filesTouched: new Set(),
         sawResult: false,
         segmentText: "",
         needsGap: false,
@@ -1043,7 +918,6 @@ function makeAgentEventHandler(opts, state) {
                     catch {
                         /* input JSON arrived partial -- fall back to a generic label */
                     }
-                    addTouchedFiles(state.filesTouched, opts.cwd, pending.name, input);
                     const label = claudeToolFeedLabel(pending.name, input);
                     if (label)
                         opts.onActivity?.(label);
@@ -1078,9 +952,6 @@ function makeAgentEventHandler(opts, state) {
         else if (ev.type === "tool_call") {
             state.segmentText = "";
             state.needsGap = true;
-            const tool = cursorToolNameAndInput(ev);
-            if (tool)
-                addTouchedFiles(state.filesTouched, opts.cwd, tool.name, tool.input);
             if (ev.subtype === "started")
                 opts.onActivity?.(toolActivityLabel(ev));
         }
@@ -1140,7 +1011,6 @@ function runAgentCli(opts) {
                 finalText: state.finalText || state.accumulated,
                 error: "agent run timed out",
                 usage: state.usage,
-                filesTouched: touchedFileList(state.filesTouched),
             });
         }, opts.timeoutMs);
         const handleEvent = makeAgentEventHandler(opts, state);
@@ -1178,7 +1048,6 @@ function runAgentCli(opts) {
                 ok,
                 finalText: state.finalText || state.accumulated,
                 usage: state.usage,
-                filesTouched: touchedFileList(state.filesTouched),
                 crashed: !state.sawResult,
                 error: ok
                     ? undefined
@@ -1189,9 +1058,9 @@ function runAgentCli(opts) {
 }
 // One smith (native castle agent) run, adapted to runAgentCli's contract so
 // every caller downstream of runAgentTurn is backend-agnostic:
-// - NativeRunResult.text -> finalText; error/usage/filesTouched/crashed pass
-//   through by name. `ok` is derived as !error && !crashed -- there is no
-//   process exit code; those two fields are the whole story.
+// - 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
@@ -1242,7 +1111,6 @@ async function runAgentSmith(opts) {
             finalText: result.text,
             error: result.error,
             usage: result.usage,
-            filesTouched: result.filesTouched,
             playtestFrames: result.playtestFrames,
             crashed: result.crashed,
         };
@@ -1407,10 +1275,6 @@ function depsSummaryFor(tasks, task) {
         .filter((dep) => !!dep)
         .map((dep) => {
         const parts = [`- "${dep.title}" finished ${dep.status}`];
-        if (dep.files && dep.files.length > 0)
-            parts.push(`  files it touched: ${dep.files.join(", ")}`);
-        if (dep.suspectNoChanges)
-            parts.push("  caution: it finished without touching any tracked files (bash side effects aren't tracked) -- verify its work actually landed before building on it");
         // The agent's own closing prose is the real handoff -- names it created,
         // what it wired, what it left undone. The notes file is player-facing
         // and deliberately stripped of that detail.
@@ -1598,7 +1462,7 @@ function startTask(ctx, task) {
         siblings: ctx
             .sorted()
             .filter((t) => t.id !== task.id && !(t.acknowledged && isTerminal(t.status)))
-            .map((t) => ({ title: t.title, status: t.status, files: t.files })),
+            .map((t) => ({ title: t.title, status: t.status })),
         onFeed: (entry) => ctx.onFeed(task, entry),
         onRetry: (attempt) => ctx.onRetry(task, attempt),
         onSignal: (signal) => {
@@ -1638,12 +1502,7 @@ function startTask(ctx, task) {
                 task.acknowledged = true;
             if (result.ok && !wasStopped)
                 task.progress = 100;
-            task.files = result.filesTouched ?? [];
             task.playtestFrames = result.playtestFrames ?? [];
-            // Flag, don't fail: see the TaskRecord.suspectNoChanges comment.
-            if (task.status === "done" && task.files.length === 0) {
-                task.suspectNoChanges = true;
-            }
             task.finishedAt = nowIso();
             task.resultSummary = wasStopped
                 ? "stopped by the router"
@@ -1983,10 +1842,8 @@ function asPromptTask(task) {
         status: task.rejected ? "rejected by user" : task.status,
         progress: task.progress,
         notes: task.notes,
-        files: task.files,
         error: task.status === "failed" ? firstErrorLine(task.resultSummary) : undefined,
         blockedBy: task.status === "blocked" ? task.blockedBy : undefined,
-        suspectNoChanges: task.suspectNoChanges,
     };
 }
 function asClientTask(task) {
@@ -2004,7 +1861,6 @@ function asClientTask(task) {
         phase: task.phase,
         acknowledged: task.acknowledged,
         rejected: task.rejected,
-        suspectNoChanges: task.suspectNoChanges,
         playtestFrames: (task.playtestFrames ?? []).map((rel) => `${AGENT_PLAYTEST_PREFIX}${task.id}/${path.basename(rel)}`),
     };
 }

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/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),
         };
     };
@@ -647,7 +632,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 +656,6 @@ async function runLoop(opts, toolSchemas, log) {
                 return {
                     text: finalText,
                     usage: totalUsage,
-                    filesTouched: touchedFileList(filesTouched),
                     playtestFrames: playtestFrameList(playtestFrames),
                 };
             }
@@ -681,7 +664,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 +675,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/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

@@ -34,7 +34,6 @@ export interface NativeRunResult {
     text: string;
     error?: string;
     usage?: NativeUsage;
-    filesTouched?: string[];
     playtestFrames?: string[];
     crashed?: boolean;
 }