open-walnut 0.5.0 → 0.5.1

package/dist/build-info.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.5.0",
-  "commit": "e2b9769e",
-  "branch": null,
-  "builtAt": "2026-09-28T17:12:43.018Z",
+  "version": "0.5.1",
+  "commit": "cb1af703",
+  "branch": "main",
+  "builtAt": "2026-09-28T22:28:51.736Z",
   "dirty": false
 }

package/dist/cli-fast.js

@@ -14,8 +14,8 @@ import path from "path";
 import { fileURLToPath } from "url";
 function getVersion() {
   if (cachedVersion) return cachedVersion;
-  if ("0.5.0") {
-    cachedVersion = "0.5.0";
+  if ("0.5.1") {
+    cachedVersion = "0.5.1";
     versionKnown = true;
     return cachedVersion;
   }
@@ -2904,6 +2904,17 @@ var init_tasks = __esm({
           );
         } catch (err) {
           const error = err instanceof Error ? err.message : String(err);
+          if (error.includes("(too_many_running_subtasks)")) {
+            return withOutcome(
+              withRef({ ...view, execution: { state: "not_started", error } }, {
+                ...extra,
+                execution: { state: "not_started", error },
+                start_error: error
+              }),
+              `${where}Task ${id} was created but NOT started: ${error}`,
+              `Start it after one of the running subtasks finishes: walnut tools call task_start '{"id":"${id}"}'`
+            );
+          }
           return withOutcome(
             withRef({ ...view, execution: { state: "unconfirmed", error } }, {
               ...extra,
@@ -5727,6 +5738,7 @@ var init_daemon_service_cli = __esm({
 var wn_cli_exports = {};
 __export(wn_cli_exports, {
   WAIT_DEFAULT_TIMEOUT_SECS: () => WAIT_DEFAULT_TIMEOUT_SECS,
+  WAIT_MAX_IDS: () => WAIT_MAX_IDS,
   WAIT_MAX_TIMEOUT_SECS: () => WAIT_MAX_TIMEOUT_SECS,
   WAIT_POLL_INTERVAL_MS: () => WAIT_POLL_INTERVAL_MS,
   WALNUT_CLI_TIMEOUT_MS: () => WALNUT_CLI_TIMEOUT_MS,
@@ -5738,7 +5750,8 @@ __export(wn_cli_exports, {
   isTrustedGatewaySocket: () => isTrustedGatewaySocket,
   parseWalnutCliArgs: () => parseWalnutCliArgs,
   resolveWalnutCliEndpoint: () => resolveWalnutCliEndpoint,
-  runWalnutCli: () => runWalnutCli
+  runWalnutCli: () => runWalnutCli,
+  waitManyVerdict: () => waitManyVerdict
 });
 import fs9 from "fs";
 import net from "net";
@@ -5762,21 +5775,25 @@ function parseWalnutCliArgs(argv2) {
   if (head === "wait") {
     let json2 = false;
     let timeoutSecs = WAIT_DEFAULT_TIMEOUT_SECS;
-    let id;
+    let mode = "all";
+    const ids = [];
     for (let i = 0; i < rest2.length; i++) {
       const a = rest2[i];
       if (a === "--json") json2 = true;
       else if (a === "--help" || a === "-h") return { kind: "help", topic: "root" };
+      else if (a === "--any") mode = "any";
+      else if (a === "--all") mode = "all";
       else if (a === "--timeout") {
         const v = Number(rest2[++i]);
         if (!Number.isFinite(v) || v <= 0) return { kind: "usage-error", message: "--timeout needs seconds > 0" };
         timeoutSecs = Math.min(v, WAIT_MAX_TIMEOUT_SECS);
       } else if (a.startsWith("--")) return { kind: "usage-error", message: `unknown flag: ${a}` };
-      else if (id === void 0) id = a;
-      else return { kind: "usage-error", message: `unexpected argument: ${a}` };
+      else if (!ids.includes(a)) ids.push(a);
     }
-    if (!id) return { kind: "usage-error", message: "wait requires <task-id | rq-id>" };
-    return { kind: "wait", id, timeoutSecs, json: json2 };
+    if (ids.length === 0) return { kind: "usage-error", message: "wait requires <task-id | rq-id> [...]" };
+    if (ids.length > WAIT_MAX_IDS) return { kind: "usage-error", message: `wait takes at most ${WAIT_MAX_IDS} ids` };
+    if (ids.length === 1) return { kind: "wait", id: ids[0], timeoutSecs, json: json2 };
+    return { kind: "wait", id: ids[0], ids, mode, timeoutSecs, json: json2 };
   }
   return { kind: "usage-error", message: `unknown command: ${head}` };
 }
@@ -6048,7 +6065,9 @@ run \`walnut --help\` for usage
       callArgs = args3.args;
     }
   }
-  if (parsed.kind === "wait") return runWait(socketPath, sid, parsed);
+  if (parsed.kind === "wait") {
+    return parsed.ids ? runWaitMany(socketPath, sid, { ...parsed, ids: parsed.ids, mode: parsed.mode ?? "all" }) : runWait(socketPath, sid, parsed);
+  }
   const op = parsed.kind === "tools.help" ? "tools.list" : parsed.kind === "guide" ? "tools.call" : parsed.kind;
   const args2 = parsed.kind === "tools.call" ? {
     name: parsed.name,
@@ -6125,6 +6144,20 @@ function evaluateWaitResult(id, result) {
     summary: { task: task.id ?? id, title: task.title, phase }
   };
 }
+function waitManyVerdict(ids, latest, settled, mode) {
+  const count = ids.filter((id) => settled.has(id)).length;
+  const done = mode === "any" ? count > 0 : count === ids.length;
+  return {
+    done,
+    body: {
+      done,
+      mode,
+      settled: count,
+      of: ids.length,
+      results: ids.map((id) => ({ ...latest.get(id) ?? (id.startsWith("rq-") ? { request: id } : { task: id }), done: settled.has(id) }))
+    }
+  };
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -6163,7 +6196,47 @@ async function runWait(socketPath, sid, parsed) {
   await writeStdout(JSON.stringify({ done: false, timeout: true, waitedSecs: parsed.timeoutSecs, ...last }, null, parsed.json ? 0 : 2) + "\n");
   return 7;
 }
-var WALNUT_CLI_TIMEOUT_MS, WAIT_POLL_INTERVAL_MS, WAIT_DEFAULT_TIMEOUT_SECS, WAIT_MAX_TIMEOUT_SECS, HELP_ROOT, HELP_TOOLS, WalnutCliTimeoutError, WALNUT_STDOUT_FLUSH_TIMEOUT_MS, WAIT_DONE_PHASES;
+async function runWaitMany(socketPath, sid, parsed) {
+  const deadline = Date.now() + parsed.timeoutSecs * 1e3;
+  const latest = /* @__PURE__ */ new Map();
+  const settled = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    for (const id of parsed.ids) {
+      if (settled.has(id)) continue;
+      let resp;
+      try {
+        resp = await requestOverSocket(socketPath, {
+          v: 1,
+          op: "tools.call",
+          sid,
+          args: { name: id.startsWith("rq-") ? "request_get" : "task_get", args: { id } }
+        });
+      } catch (err) {
+        latest.set(id, { ...latest.get(id) ?? {}, transportError: err instanceof Error ? err.message : String(err) });
+        continue;
+      }
+      if (!resp.ok) {
+        process.stderr.write(`walnut: wait ${id}:
+` + formatErrorLines(resp.error).join("\n") + "\n");
+        return errorToExitCode(resp.error.code);
+      }
+      const { done, summary } = evaluateWaitResult(id, resp.result);
+      latest.set(id, summary);
+      if (done) settled.add(id);
+    }
+    const verdict = waitManyVerdict(parsed.ids, latest, settled, parsed.mode);
+    if (verdict.done) {
+      await writeStdout(JSON.stringify(verdict.body, null, parsed.json ? 0 : 2) + "\n");
+      return 0;
+    }
+    if (Date.now() >= deadline) {
+      await writeStdout(JSON.stringify({ ...verdict.body, timeout: true, waitedSecs: parsed.timeoutSecs }, null, parsed.json ? 0 : 2) + "\n");
+      return 7;
+    }
+    await sleep(WAIT_POLL_INTERVAL_MS);
+  }
+}
+var WALNUT_CLI_TIMEOUT_MS, WAIT_POLL_INTERVAL_MS, WAIT_DEFAULT_TIMEOUT_SECS, WAIT_MAX_TIMEOUT_SECS, WAIT_MAX_IDS, HELP_ROOT, HELP_TOOLS, WalnutCliTimeoutError, WALNUT_STDOUT_FLUSH_TIMEOUT_MS, WAIT_DONE_PHASES;
 var init_wn_cli = __esm({
   "src/providers/wn-cli.ts"() {
     "use strict";
@@ -6174,12 +6247,13 @@ var init_wn_cli = __esm({
     WAIT_POLL_INTERVAL_MS = 5e3;
     WAIT_DEFAULT_TIMEOUT_SECS = 1800;
     WAIT_MAX_TIMEOUT_SECS = 24 * 60 * 60;
+    WAIT_MAX_IDS = 20;
     HELP_ROOT = `walnut \u2014 the Walnut CLI
 
 USAGE
   walnut guide                              print the full Walnut manual (recipes + safety rules)
   walnut tools list|help|call ...           call Walnut operations (see \`walnut tools --help\`)
-  walnut wait <id> [--timeout secs] [--json]   block until a task settles or a reply request resolves
+  walnut wait <id> [<id>...] [--any] [--timeout secs] [--json]   block until tasks settle or reply requests resolve
   walnut --help | walnut tools --help
 
 THE MODEL (one identity: the task)
@@ -6209,6 +6283,7 @@ THE VERBS (keep it simple)
 WAIT
   walnut wait <task-id>   returns when the task reaches NEED_ACTION / COMPLETE
   walnut wait <rq-id>     returns when the reply request leaves pending
+  walnut wait <id> <id>   several ids (up to 20): returns when ALL settled; --any returns at the first
   --timeout secs          default 1800, max 86400; exit 7 on timeout
 
 ENVIRONMENT