castle-web-cli 0.4.56 → 0.4.58

package/dist/agent-prompts.d.ts

@@ -1,6 +1,7 @@
 export interface PromptMessage {
     role: "user" | "assistant";
     text: string;
+    interrupted?: boolean;
 }
 export interface PromptTask {
     id: string;
@@ -16,7 +17,7 @@ export declare function buildRouterPrompt(opts: {
     instruction: string;
 }): string;
 export declare function userTurnInstruction(opts: {
-    text: string;
+    messages: string[];
     interruptedDraft?: string;
     attachments?: string[];
 }): string;

package/dist/agent-prompts.js

@@ -61,7 +61,14 @@ function renderTranscript(messages) {
     if (recent.length === 0)
         return "(no conversation yet)";
     return recent
-        .map((m) => `${m.role === "user" ? "user" : "you"}: ${m.text}`)
+        .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");
 }
 function renderTasks(tasks) {
@@ -94,9 +101,17 @@ Reply now, as "you" in the conversation. Plain reply text only -- no role prefix
 export function userTurnInstruction(opts) {
     const parts = [];
     if (opts.interruptedDraft?.trim()) {
-        parts.push(`Your previous reply was interrupted mid-stream by the user's new message. Its draft so far (already shown to the user; NO tasks were spawned from it):\n\n${opts.interruptedDraft.trim()}\n\nContinue that line of work AND address the new message -- do both in this one reply, spawning whatever tasks are needed for either.`);
+        parts.push(`Your previous reply was interrupted mid-stream by the user's new message. Its draft so far (already shown to the user; NO tasks were spawned from it):\n\n${opts.interruptedDraft.trim()}\n\nContinue that line of work AND address the new message(s) -- do it all in this one reply, spawning whatever tasks are needed.`);
+    }
+    const msgs = opts.messages.filter((m) => m.trim());
+    if (msgs.length <= 1) {
+        parts.push(`The user just said:\n\n${msgs[0] ?? ""}`);
+    }
+    else {
+        parts.push(`The user sent these messages -- the earlier ones arrived while you were mid-reply and have NOT been answered yet. Address ALL of them in this one reply, in order. Exception: if a later message clearly clarifies, corrects, or takes back an earlier one, follow the later intent and don't redo work the user reversed. By default, cover every message:\n\n${msgs
+            .map((t, i) => `${i + 1}. ${t}`)
+            .join("\n\n")}`);
     }
-    parts.push(`The user just said:\n\n${opts.text}`);
     if (opts.attachments && opts.attachments.length > 0) {
         parts.push(`The user attached image file(s), saved in the deck at: ${opts.attachments.join(", ")}. Open them with your read tool and take them into account; pass the paths along to task agents that need them.`);
     }

package/dist/agent.js

@@ -78,6 +78,10 @@ function buildAgentInvocation(backend, role, prompt, claudeModel) {
 const ROUTER_TIMEOUT_MS = 3 * 60_000;
 const TASK_TIMEOUT_MS = 30 * 60_000;
 const MAX_TASK_ATTEMPTS = 3;
+// Cap on task agents running at once -- keeps us under e2b / provider rate
+// limits. Over-cap tasks stay queued ('waiting') and start, earliest-created
+// first, as running ones finish. Conservative default; override via env.
+const MAX_CONCURRENT_TASKS = Number(process.env.CASTLE_MAX_CONCURRENT_TASKS) || 4;
 const TASK_POLL_MS = 1_000;
 const FENCE_HOLDBACK = '```castle-';
 const RESULT_SUMMARY_CHARS = 600;
@@ -497,9 +501,21 @@ function createTaskStore(opts) {
             return !dep || isTerminal(dep.status);
         });
     }
+    function runningCount() {
+        let n = 0;
+        for (const t of tasks.values())
+            if (t.status === 'running')
+                n++;
+        return n;
+    }
     function maybeStart(task) {
         if (task.status !== 'waiting' || task.acknowledged || !depsAreSettled(task))
             return;
+        // Concurrency cap: at most MAX_CONCURRENT_TASKS agents run at once. Over-cap
+        // tasks stay 'waiting' and are restarted -- earliest-created first -- by the
+        // onFinished sweep below when a running task frees a slot.
+        if (runningCount() >= MAX_CONCURRENT_TASKS)
+            return;
         start(task);
     }
     function start(task) {
@@ -540,7 +556,9 @@ function createTaskStore(opts) {
                     : `${result.error ?? 'failed'}\n${result.finalText.slice(-RESULT_SUMMARY_CHARS)}`;
             touch(task);
             opts.onFinished(task);
-            for (const waiting of tasks.values())
+            // A slot just freed -- restart eligible waiting tasks, earliest-created
+            // first, up to the concurrency cap.
+            for (const waiting of sorted())
                 maybeStart(waiting);
         });
     }
@@ -775,7 +793,11 @@ function runRouterTurnIn(ctx, instruction) {
         deckLabel: ctx.deckLabel,
         messages: ctx.log.messages
             .filter((m) => m.role !== 'log' && m.id !== message.id && m.status !== 'streaming')
-            .map((m) => ({ role: m.role, text: m.text })),
+            .map((m) => ({
+            role: m.role,
+            text: m.text,
+            interrupted: m.interrupted,
+        })),
         // Only the live board -- match what the user sees. Hide tasks that are
         // BOTH acknowledged AND finished; an active (running/waiting) task always
         // shows even if somehow acked, so nothing can ever go invisible mid-work.
@@ -1018,6 +1040,20 @@ export function createAgentServer(opts) {
             claudeModel: () => settings.claudeModel,
         }, instruction);
     }
+    // User messages awaiting a reply: everything since the last COMPLETED (done,
+    // not interrupted) assistant message. Usually just the latest, but a rapid
+    // burst leaves several queued -- all must be addressed, not only the last.
+    function pendingUserMessages() {
+        let lastAnswered = -1;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const m = messages[i];
+            if (m.role === 'assistant' && m.status === 'done' && !m.interrupted) {
+                lastAnswered = i;
+                break;
+            }
+        }
+        return messages.slice(lastAnswered + 1).filter((m) => m.role === 'user');
+    }
     function handleUserMessage(text, images) {
         userEpoch += 1;
         const interruptedDraft = interruptRouterRuns();
@@ -1033,10 +1069,15 @@ export function createAgentServer(opts) {
         if (attachments.length > 0)
             message.attachments = attachments;
         log.add(message);
+        // Address every still-unanswered user message (this one plus any earlier
+        // burst messages that interrupted prior turns), not just the latest.
+        const pending = pendingUserMessages();
         runRouterTurn(userTurnInstruction({
-            text,
+            messages: pending.map((m) => m.text),
             interruptedDraft: interruptedDraft || undefined,
-            attachments: attachments.map((name) => path.join('.castle', 'agent', 'attachments', name)),
+            attachments: pending
+                .flatMap((m) => m.attachments ?? [])
+                .map((name) => path.join('.castle', 'agent', 'attachments', name)),
         }));
     }
     function handleTaskAck(id, rejected) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castle-web-cli",
-  "version": "0.4.56",
+  "version": "0.4.58",
   "type": "module",
   "bin": {
     "castle-web": "./dist/index.js"