wayang-ai 0.6.2 → 0.6.3

package/dist/cli.js

@@ -1104,14 +1104,17 @@ function summarizeWorkerMessage(argsJson, width, result, maxLines = 3) {
   const message = args ? str(args.message) ?? "" : argsJson;
   const { lines, hidden } = previewLines(message, maxLines, width);
   const failed = result !== void 0 && (result.isError === true || /^\[ERROR\]/.test(result.text));
+  let delivery;
+  if (result !== void 0 && !failed) {
+    delivery = /\bqueued\b/i.test(result.text) ? "queued" : /\bdelivered\b/i.test(result.text) ? "delivered" : void 0;
+  }
   return {
     ...workerId && { workerId },
     lines,
     hiddenLines: hidden,
     outcome: result === void 0 ? "pending" : failed ? "failed" : "ok",
     failure: failed ? failureText(result.text, width) : "",
-    ...result !== void 0 && !failed && /\bqueued\b/.test(result.text) && { delivery: "queued" },
-    ...result !== void 0 && !failed && /\bdelivered\b/.test(result.text) && { delivery: "delivered" }
+    ...delivery && { delivery }
   };
 }
 var TASK_ID_RE = /^Task (\S+) (?:added|assigned)/;
@@ -2448,7 +2451,7 @@ function AppContent() {
 // package.json
 var package_default = {
   name: "wayang-ai",
-  version: "0.6.2",
+  version: "0.6.3",
   description: "Multi-agent orchestration platform",
   type: "module",
   license: "MIT",
@@ -4537,18 +4540,39 @@ function controllerMessageContent(content) {
   return `[Controller message] ${content}`;
 }
 function createInboxInjection(deps) {
+  let baseLength = null;
   const injected = [];
   return {
     prepareStep({ messages }) {
       const fresh = deps.drainInbox();
       if (fresh.length === 0 && injected.length === 0) return void 0;
+      if (baseLength === null) baseLength = messages.length;
+      const responseCount = Math.max(0, messages.length - baseLength);
       for (const m of fresh) {
-        injected.push({ role: "user", content: controllerMessageContent(m.content) });
+        injected.push({
+          message: { role: "user", content: controllerMessageContent(m.content) },
+          // After the response messages that exist NOW — i.e. at the tail of
+          // the conversation as this step sees it, before this step's reply.
+          insertAfter: responseCount
+        });
         deps.onInject(m.content);
       }
-      return { messages: [...messages, ...injected] };
+      const merged = messages.slice(0, baseLength);
+      let cursor = 0;
+      for (const inj of injected) {
+        while (cursor < Math.min(inj.insertAfter, responseCount)) {
+          merged.push(messages[baseLength + cursor]);
+          cursor++;
+        }
+        merged.push(inj.message);
+      }
+      while (cursor < responseCount) {
+        merged.push(messages[baseLength + cursor]);
+        cursor++;
+      }
+      return { messages: merged };
     },
-    injectedMessages: () => [...injected]
+    injectedMessages: () => injected.map((i) => i.message)
   };
 }
 
@@ -4803,7 +4827,10 @@ The tool shows task metadata (status, result, error) and recent worker conversat
 
 ## Sending messages to workers (chat_worker)
 
-Use chat_worker(workerId, message) to send guidance to a running worker. The worker will see the message next time it calls check_controller_messages.
+Use chat_worker(workerId, message) to send guidance to a running worker.
+The worker reads it at its next step (puppet) or turn boundary (third-party) \u2014 a tool call in progress is NEVER interrupted; an idle multi-stage worker reads it when its next stage starts.
+Delivery is blind: "queued" only means the message sits in the worker's inbox until that boundary. A stuck worker never reads it.
+A third-party worker that already finished its session rejects the message with an explicit [ERROR] \u2014 inspect its output instead of retrying.
 Use sparingly \u2014 only when you need to:
 - Correct a worker that is going in the wrong direction
 - Provide additional context the worker did not have
@@ -5272,7 +5299,11 @@ var WorkerAgent = class extends BaseAgent {
   getSnapshot(path7) {
     return this.state.get(path7);
   }
-  /** Accept a message from the controller — writes to internal inbox. */
+  /**
+   * Accept a message from the controller — writes to internal inbox. The
+   * puppet reads it at its next LLM step, so a running (or idle) worker
+   * always accepts.
+   */
   acceptMessage(message) {
     this.state.append("inbox", {
       id: generateId("msg"),
@@ -5280,6 +5311,7 @@ var WorkerAgent = class extends BaseAgent {
       timestamp: Date.now()
     });
     this.logger.info({ workerId: this.id }, "Controller message accepted");
+    return true;
   }
   /** Unread controller messages (non-destructive) — engine reports these when the run ends. */
   pendingMessages() {
@@ -5376,14 +5408,20 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   // --- Controller messaging via streamInput ---
   _messageQueue = [];
   _messageResolve = null;
-  /** Active SDK query — interrupted to deliver controller messages promptly. */
-  _activeQuery = null;
   /**
-   * Interrupt requested while a permission was pending — delivered right
-   * after the permission settles (interrupting mid-permission is unproven
-   * SDK territory; see docs/develop/v0.6-design.md §3).
+   * True while run() is executing. Controller messages are rejected once the
+   * run's input has closed (see `_inputClosed`), but idle multi-stage workers
+   * (no run in flight) keep accepting — the next stage folds them into its
+   * opening prompt.
    */
-  _interruptQueued = false;
+  _runInFlight = false;
+  /**
+   * True once the prompt iterator reported done for the current run: the
+   * session can no longer take input (a turn result arrived with nothing
+   * queued, or the run was aborted). Further acceptMessage calls fail
+   * explicitly instead of pretending to queue.
+   */
+  _inputClosed = false;
   // --- ask_controller via in-process SDK MCP server ---
   _askController = null;
   // --- Permission control via canUseTool ---
@@ -5392,31 +5430,17 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   /** Exposed for engine to resolve pending permission requests. */
   permissionHandler = {
     resolvePermission: (requestId, approved, reason) => {
-      const ok = this._pendingPermissions.resolve(
+      return this._pendingPermissions.resolve(
         requestId,
         approved ? { behavior: "allow" } : { behavior: "deny", message: reason ?? "Denied by controller" }
       );
-      if (ok) this.afterPermissionSettled();
-      return ok;
     },
     cleanup: () => {
-      this._interruptQueued = false;
       this._pendingPermissions.cleanupAll(() => ({ behavior: "deny", message: "Worker aborted" }));
     },
     wrappedTools: {}
     // not used for ClaudeCodeWorker
   };
-  /**
-   * A permission settled (approved / denied / timed out). If a controller
-   * message was waiting for the permission window to close, deliver its
-   * interrupt now — this runs on BOTH the resolve and the timeout path.
-   */
-  afterPermissionSettled() {
-    if (this._interruptQueued && this._pendingPermissions.size === 0) {
-      this._interruptQueued = false;
-      this.requestInterrupt();
-    }
-  }
   // Signal context set during run()
   _signalQueue = null;
   _runContext = null;
@@ -5463,6 +5487,8 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   }
   async run(task, _tools, onProgress) {
     this._terminalResult = null;
+    this._inputClosed = false;
+    this._runInFlight = true;
     this.state.set("runtimeState.task", { id: task.id, description: task.description });
     const turnEnv = this.buildTurnEnv(task);
     this._currentTurnEnv = turnEnv;
@@ -5520,18 +5546,17 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
         prompt: this.buildPromptIterable(task.description),
         options
       });
-      this._activeQuery = stream;
       try {
         for await (const message of stream) {
           if (this.abortController.signal.aborted) break;
           this.processStreamMessage(message, onProgress);
-          if (this._terminalResult) break;
         }
       } finally {
-        this._activeQuery = null;
+        this._inputClosed = true;
       }
     } catch (err) {
       this.logger.error({ err, taskId: task.id }, "ClaudeCodeWorker query error");
+      this._inputClosed = true;
       if (!this._terminalResult) {
         this._terminalResult = {
           status: "failed",
@@ -5558,6 +5583,7 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
       startedAt: resultTs,
       endedAt: resultTs
     }, turnEnv));
+    this._runInFlight = false;
     return this._terminalResult;
   }
   /** Set signal context for permission requests. Called by engine before run(). */
@@ -5586,34 +5612,36 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
   getSnapshot(path7) {
     return this.state.get(path7);
   }
-  /** Accept a message from the controller — injects into running session via streamInput. */
+  /**
+   * Accept a message from the controller. The message is queued and handed
+   * to the SDK only when it pulls the next prompt: the CLI parks pulled
+   * prompts in an internal queue that it drains strictly BETWEEN turns, so
+   * delivery always lands on a turn boundary — a tool call in progress is
+   * never cut off (the v0.6 interrupt delivery did exactly that and killed
+   * the session with an orphaned tool_use; see docs/develop/v0.6-design.md
+   * §6.1 — the hazard is any unclosed tool_use, not just a pending
+   * permission).
+   *
+   * Returns false when delivery is impossible: the run's input has closed
+   * (final result received) or the worker was aborted. Idle multi-stage
+   * workers (no run in flight) always accept — the next stage folds the
+   * message into its opening prompt.
+   */
   acceptMessage(message) {
+    if (this.abortController.signal.aborted) return false;
+    if (this._runInFlight && this._inputClosed) return false;
     this._messageQueue.push(message);
     if (this._messageResolve) {
       this._messageResolve();
       this._messageResolve = null;
     }
-    if ((this.config.interruptOnMessage ?? "immediate") === "immediate") {
-      this.requestInterrupt();
-    }
     this.logger.info({ workerId: this.id }, "Controller message accepted");
+    return true;
   }
   /** Unread controller messages (non-destructive) — engine reports these when the run ends. */
   pendingMessages() {
     return [...this._messageQueue];
   }
-  /** Interrupt the active query unless a permission is pending (queued until it settles). */
-  requestInterrupt() {
-    if (this.abortController.signal.aborted || !this._activeQuery) return;
-    if (this._pendingPermissions.size > 0) {
-      this._interruptQueued = true;
-      return;
-    }
-    if (typeof this._activeQuery.interrupt !== "function") return;
-    this._activeQuery.interrupt().catch((err) => {
-      this.logger.warn({ workerId: this.id, err: String(err) }, "interrupt() failed");
-    });
-  }
   /**
    * Provide the engine-backed ask_controller implementation. Once set, the
    * worker exposes it to Claude Code as an in-process SDK MCP tool.
@@ -5651,9 +5679,7 @@ var ClaudeCodeWorker = class _ClaudeCodeWorker {
       ...this._turnLineage
     });
     return this._pendingPermissions.wait(requestId, _ClaudeCodeWorker.PERMISSION_TIMEOUT_MS, () => {
-      const value = { behavior: "deny", message: "Permission request timed out" };
-      this.afterPermissionSettled();
-      return value;
+      return { behavior: "deny", message: "Permission request timed out" };
     });
   }
   // --- Prompt as AsyncIterable (supports follow-up messages) ---
@@ -5680,13 +5706,22 @@ ${leftoverText}` : `${buildThirdPartyPrompt(this.skills)}${initialPrompt}`;
               };
             }
             while (true) {
-              if (this.abortController.signal.aborted || this._terminalResult) {
+              if (this.abortController.signal.aborted) {
+                this._inputClosed = true;
                 return { value: void 0, done: true };
               }
-              if (this._messageQueue.length > 0) break;
-              await new Promise((resolve11) => {
-                this._messageResolve = resolve11;
-              });
+              if (this._terminalResult) {
+                if (this._messageQueue.length === 0) {
+                  this._inputClosed = true;
+                  return { value: void 0, done: true };
+                }
+              } else if (this._messageQueue.length === 0) {
+                await new Promise((resolve11) => {
+                  this._messageResolve = resolve11;
+                });
+                continue;
+              }
+              break;
             }
             const msg = this._messageQueue.shift();
             return {
@@ -6353,7 +6388,7 @@ function updateProgressTool(deps) {
 import { z as z23 } from "zod";
 function chatWorkerTool(deps) {
   return defineTool({
-    description: "Send a message to a running worker. Use this to provide additional guidance, correct the worker's approach, or ask the worker to check something. The worker reads it at its next step (puppet) or turn boundary (third-party); idle multi-stage workers read it when their next stage starts.",
+    description: `Send a message to a running worker. Use this to provide additional guidance, correct the worker's approach, or ask the worker to check something. The worker reads it at its next step (puppet) or turn boundary (third-party); idle multi-stage workers read it when their next stage starts. A third-party worker NEVER acts on the message mid-tool-call: it finishes the current turn first, so "queued" can mean a delay of minutes. If the worker has already finished, this tool fails explicitly \u2014 inspect its output instead.`,
     parameters: z23.object({
       workerId: z23.string().describe("ID of the target worker"),
       message: z23.string().describe("Message to send to the worker")
@@ -6363,8 +6398,11 @@ function chatWorkerTool(deps) {
       if (status === "not_running") {
         return `[ERROR] Worker ${workerId} is not running (it may have just finished).`;
       }
+      if (status === "finished") {
+        return `[ERROR] Worker ${workerId} has already finished; message not delivered. Use get_task_detail to inspect its output.`;
+      }
       if (status === "queued") {
-        return `Message queued for worker ${workerId} \u2014 it will be read when the current turn ends or the next stage starts.`;
+        return `Message queued for worker ${workerId} \u2014 QUEUED only, not delivered yet: the worker reads it at its next step (puppet), turn boundary (third-party \u2014 the current turn, including any running tool call, finishes first) or next stage start (idle). A stuck worker will never reach that point. Verify with get_task_detail before relying on it; if it looks stuck, use cancel_task instead of waiting for this message.`;
       }
       return `Message delivered to worker ${workerId} \u2014 it will be read at the worker's next step.`;
     })
@@ -6885,14 +6923,16 @@ var TaskExecuteEngine = class {
    * Send a message to a worker. Delivery is judged by the activeWorkers
    * runtime state — NOT by the workers Map, which lingers one tick past
    * disposal (removeWorkerTracking defers) and would accept messages for a
-   * worker that is already gone.
+   * worker that is already gone. A worker that rejects the message (its run
+   * can no longer take input) is reported as 'finished' — never a fake
+   * 'queued'.
    */
   sendMessageToWorker(workerId, message) {
     const info = this.getActiveWorkers().find((w) => w.workerId === workerId);
     if (!info) return "not_running";
     const worker = this.workers.get(workerId);
     if (!worker) return "not_running";
-    worker.acceptMessage(message);
+    if (!worker.acceptMessage(message)) return "finished";
     if (info.status === "idle") return "queued";
     return worker instanceof WorkerAgent ? "delivered" : "queued";
   }
@@ -7556,7 +7596,7 @@ var ControllerLoop = class {
     this.signalQueue = signalQueue;
     this.controllerAgent = controllerAgent;
     this.heartbeatProvider = heartbeatProvider;
-    this.heartbeatIntervalMs = options?.heartbeatIntervalMs ?? 3e4;
+    this.heartbeatIntervalMs = options?.heartbeatIntervalMs ?? 6e4;
   }
   ctx;
   signalQueue;
@@ -9245,8 +9285,11 @@ async function runWayangServer(options, io = process) {
     return { status };
   });
   rpc.register(METHOD.CHAT_WORKER, (params) => {
-    supervisor.engine.sendMessageToWorker(requiredString(params, "workerId"), requiredString(params, "message"));
-    return {};
+    const status = supervisor.engine.sendMessageToWorker(
+      requiredString(params, "workerId"),
+      requiredString(params, "message")
+    );
+    return { status };
   });
   rpc.register(METHOD.DISPOSE_WORKER, (params) => {
     supervisor.engine.abortByWorkerId(requiredString(params, "workerId"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wayang-ai",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Multi-agent orchestration platform",
   "type": "module",
   "license": "MIT",