castle-web-cli 0.4.108 → 0.4.109

package/dist/agent-prompts.js

@@ -6,6 +6,20 @@
 // Router calls are stateless (a fresh cursor-agent print run each time) so the
 // transcript is the only memory.
 const TRANSCRIPT_LIMIT = 40;
+// Byte ceiling on the replayed transcript, applied AFTER TRANSCRIPT_LIMIT.
+// The count cap above bounds how many messages replay, not how big they are --
+// forty long ones clear 128KB easily. That matters because the whole prompt is
+// handed to the backend CLI as a single argv entry, and Linux caps one argument
+// at MAX_ARG_STRLEN (128KB): past it, spawn() throws E2BIG and the turn dies
+// before it starts. Since the transcript is the only term here that grows
+// without bound (it accumulates for the life of the deck), it's the one that
+// needs a byte budget.
+//
+// Sized to leave room for everything else the prompt carries: the rules
+// (~10KB), the deck's quick reference (~13KB), the file tree, the smith-only
+// deck contents (ROUTER_DECK_CONTENTS_BUDGET, 40KB), the task board, and this
+// turn's instruction.
+const TRANSCRIPT_BYTE_BUDGET = 32 * 1024;
 const ROUTER_RULES = `You are Castle's create assistant: the fast conversational router for a game-making session. The deck (game project) lives in the current directory and runs live in a pane right next to this chat.
 
 What a deck is: a normal web project served by vite -- index.html plus plain JS/JSX modules, with real npm dependencies (more can be installed), the castle-web-sdk package, and usually a kit framework whose engine, behaviors, scenes, editors, and drawings are ordinary files in this directory. The web platform is fully available (DOM, canvas, npm libraries like react, three, etc.). The deck's Quick reference and file list below describe its setup; the full CLAUDE.md / AGENTS.md has deeper detail. NEVER claim something is impossible or unsupported on the platform without checking that context (or, for specifics it doesn't cover, the deck's files) first.
@@ -66,20 +80,55 @@ Conversation style:
 - The user sees a live task board above the chat -- never re-announce task status yourself.
 - Spawning a task does NOT apply the change -- tasks run for minutes and finish on the board. Talk about spawned work in future tense ("this will dial the shake back"), and NEVER ask how a change feels right after spawning it -- the user cannot have tried it yet. Save "how is it?" for things whose task already finished.
 - The user playtests in the pane beside this chat; finished work shows up there after a reload.`;
+function renderTranscriptLine(m) {
+    if (m.role === "user")
+        return `user: ${m.text}`;
+    const label = m.interrupted
+        ? "you (interrupted draft -- not a complete reply)"
+        : "you";
+    return `${label}: ${m.text}`;
+}
+// Cut a line to fit `budget` BYTES without splitting a multi-byte character
+// (a half-written character would render as a replacement glyph mid-sentence).
+function truncateToBytes(line, budget) {
+    const buf = Buffer.from(line, "utf8");
+    if (buf.byteLength <= budget)
+        return line;
+    return new TextDecoder("utf8", { fatal: false, ignoreBOM: true })
+        .decode(buf.subarray(0, budget))
+        .replace(/�+$/, "");
+}
 function renderTranscript(messages) {
     const recent = messages.slice(-TRANSCRIPT_LIMIT);
     if (recent.length === 0)
         return "(no conversation yet)";
-    return recent
-        .map((m) => {
-        if (m.role === "user")
-            return `user: ${m.text}`;
-        const label = m.interrupted
-            ? "you (interrupted draft -- not a complete reply)"
-            : "you";
-        return `${label}: ${m.text}`;
-    })
-        .join("\n\n");
+    // Newest-first, keeping WHOLE messages until the budget is spent: the recent
+    // exchanges are the ones a reply actually depends on, and half-including a
+    // message would read as the user having said something they didn't.
+    const kept = [];
+    let bytes = 0;
+    for (let i = recent.length - 1; i >= 0; i -= 1) {
+        const line = renderTranscriptLine(recent[i]);
+        // +2 for the "\n\n" this line will be joined with.
+        const size = Buffer.byteLength(line, "utf8") + 2;
+        if (bytes + size > TRANSCRIPT_BYTE_BUDGET) {
+            // One message bigger than the whole budget (a huge paste) still has to
+            // yield something -- an empty transcript would strand the router with no
+            // idea what was just asked. Truncate that one rather than drop it, so the
+            // bound genuinely holds no matter what a single message contains.
+            if (kept.length === 0) {
+                kept.push(truncateToBytes(line, TRANSCRIPT_BYTE_BUDGET));
+            }
+            break;
+        }
+        kept.unshift(line);
+        bytes += size;
+    }
+    const elided = recent.length - kept.length;
+    if (elided <= 0)
+        return kept.join("\n\n");
+    const plural = elided === 1 ? "message" : "messages";
+    return `(${elided} earlier ${plural} trimmed to keep this prompt within its size limit)\n\n${kept.join("\n\n")}`;
 }
 function renderTasks(tasks) {
     if (tasks.length === 0)

package/dist/agent.js

@@ -14,7 +14,7 @@
 // Backend CLI: cursor-agent in headless print mode (stream-json). The router
 // runs with --mode ask (read-only at the CLI level); task agents run with
 // --force. Claude support can slot in later behind runAgentCli.
-import { execFileSync, spawn } from "child_process";
+import { execFileSync, spawn, } from "child_process";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
@@ -1341,11 +1341,33 @@ function makeAgentEventHandler(opts, state) {
 // end with a result event carrying the canonical final text.
 function runAgentCli(opts) {
     return new Promise((resolve) => {
-        const child = spawn(opts.command, opts.args, {
-            cwd: opts.cwd,
-            env: opts.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
+        // spawn() throws SYNCHRONOUSLY for the failures the OS rejects at exec
+        // time -- in practice E2BIG, when the prompt argv exceeds Linux's
+        // MAX_ARG_STRLEN (128KB per argument). That throw escapes this executor
+        // and rejects the promise, so it never reaches the child.on("error")
+        // handler below and never becomes an AgentFailure: the turn dies
+        // unclassified and the composer spins forever with nothing shown. Settle
+        // it here in the same shape that handler uses so it lands on the normal
+        // "spawn" copy instead. The declared type mirrors the stdio tuple below:
+        // stdin ignored, stdout/stderr piped.
+        let child;
+        try {
+            child = spawn(opts.command, opts.args, {
+                cwd: opts.cwd,
+                env: opts.env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            resolve({
+                ok: false,
+                finalText: "",
+                error: `could not run ${opts.command}: ${message}`,
+                failure: { kind: "spawn", detail: `${opts.command}: ${message}` },
+            });
+            return;
+        }
         opts.children.add(child);
         opts.onSpawn?.(child.pid);
         const log = opts.logPath