@adhdev/daemon-standalone 1.0.56-rc.4 → 1.0.56-rc.5

package/dist/index.js

@@ -36620,10 +36620,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "0ac5de5a5c119ce79644b72b5cf2e44ae1afc677" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "0ac5de5a" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.56-rc.4" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-19T02:15:04.773Z" : void 0);
+      const commit = readInjected(true ? "d41089a0d560d75e670a90d3c4e9955bf955bbbc" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "d41089a0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.56-rc.5" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-19T05:42:19.473Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -42852,8 +42852,9 @@ ${error48.message || ""}`;
         CANONICAL_MESH_TOOL_NAMES = [
           "mesh_status",
           "mesh_list_nodes",
-          "mesh_enqueue_task",
+          // GRAPH-ORCHESTRATION Phase F — batch before task, mirroring ALL_MESH_TOOLS.
           "mesh_enqueue_batch",
+          "mesh_enqueue_task",
           "mesh_view_queue",
           // GRAPH-ORCHESTRATION Phase E — the coordinator gate + graph view surface.
           "mesh_graph_view",
@@ -52427,62 +52428,6 @@ ${blocks.join("\n\n")}`;
         MAX_CLONE_CHAIN = 16;
       }
     });
-    function loadDatabaseCtor() {
-      if (DatabaseCtor) return DatabaseCtor;
-      DatabaseCtor = loadBetterSqlite3();
-      return DatabaseCtor;
-    }
-    function safeMeshId(meshId) {
-      return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-    }
-    function legacyQueuePath(meshId) {
-      return (0, import_path6.join)(getLedgerDir2(), `${safeMeshId(meshId)}.queue.json`);
-    }
-    function cleanupStrayRootRuntimeDb(canonicalPath2) {
-      try {
-        const strayPath = (0, import_path6.join)(getConfigDir2(), "mesh-runtime.db");
-        if (strayPath === canonicalPath2) return;
-        if (!(0, import_fs6.existsSync)(strayPath)) return;
-        if ((0, import_fs6.statSync)(strayPath).size !== 0) return;
-        (0, import_fs6.unlinkSync)(strayPath);
-        if (!loggedStrayCleanup) {
-          loggedStrayCleanup = true;
-          LOG2.info("MeshRuntimeStore", `Removed stray 0-byte root mesh-runtime.db at ${strayPath}`);
-        }
-      } catch (err) {
-        if (!loggedStrayCleanup) {
-          loggedStrayCleanup = true;
-          LOG2.warn("MeshRuntimeStore", `Stray root mesh-runtime.db cleanup failed (ignored): ${err?.message || err}`);
-        }
-      }
-    }
-    function meshRuntimeStorePath() {
-      const dir = getLedgerDir2();
-      const nextPath = (0, import_path6.join)(dir, "mesh-runtime.db");
-      cleanupStrayRootRuntimeDb(nextPath);
-      if ((0, import_fs6.existsSync)(nextPath)) return nextPath;
-      const legacyPath = (0, import_path6.join)(dir, "beads.db");
-      if (!(0, import_fs6.existsSync)(legacyPath)) return nextPath;
-      try {
-        (0, import_fs6.renameSync)(legacyPath, nextPath);
-        for (const suffix of ["-wal", "-shm"]) {
-          const legacyCompanion = `${legacyPath}${suffix}`;
-          if ((0, import_fs6.existsSync)(legacyCompanion)) {
-            (0, import_fs6.renameSync)(legacyCompanion, `${nextPath}${suffix}`);
-          }
-        }
-      } catch (err) {
-        if (!loggedMigrationFailure) {
-          loggedMigrationFailure = true;
-          LOG2.warn(
-            "MeshRuntimeStore",
-            `Legacy beads.db\u2192mesh-runtime.db migration failed; using existing DB in-place to avoid data loss: ${err?.message || err}`
-          );
-        }
-        return (0, import_fs6.existsSync)(nextPath) ? nextPath : legacyPath;
-      }
-      return nextPath;
-    }
     function meshTurnAttemptFromRow(r) {
       return {
         attemptId: r.attempt_id,
@@ -52540,15 +52485,82 @@ ${blocks.join("\n\n")}`;
         return { ledger: 0, toolCalls: 0, terminalQueue: 0, sessionDelivery: 0 };
       }
     }
+    var MESH_EVENT_LEDGER_RETENTION_MS;
+    var MESH_TOOL_CALL_LOG_RETENTION_MS;
+    var MESH_TERMINAL_QUEUE_RETENTION_MS;
+    var init_mesh_runtime_store_turn_rows = __esm2({
+      "src/mesh/mesh-runtime-store-turn-rows.ts"() {
+        "use strict";
+        init_logger();
+        init_mesh_retention_config();
+        init_mesh_runtime_store();
+        MESH_EVENT_LEDGER_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+        MESH_TOOL_CALL_LOG_RETENTION_MS = 14 * 24 * 60 * 60 * 1e3;
+        MESH_TERMINAL_QUEUE_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+      }
+    });
+    function loadDatabaseCtor() {
+      if (DatabaseCtor) return DatabaseCtor;
+      DatabaseCtor = loadBetterSqlite3();
+      return DatabaseCtor;
+    }
+    function safeMeshId(meshId) {
+      return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    }
+    function legacyQueuePath(meshId) {
+      return (0, import_path6.join)(getLedgerDir2(), `${safeMeshId(meshId)}.queue.json`);
+    }
+    function cleanupStrayRootRuntimeDb(canonicalPath2) {
+      try {
+        const strayPath = (0, import_path6.join)(getConfigDir2(), "mesh-runtime.db");
+        if (strayPath === canonicalPath2) return;
+        if (!(0, import_fs6.existsSync)(strayPath)) return;
+        if ((0, import_fs6.statSync)(strayPath).size !== 0) return;
+        (0, import_fs6.unlinkSync)(strayPath);
+        if (!loggedStrayCleanup) {
+          loggedStrayCleanup = true;
+          LOG2.info("MeshRuntimeStore", `Removed stray 0-byte root mesh-runtime.db at ${strayPath}`);
+        }
+      } catch (err) {
+        if (!loggedStrayCleanup) {
+          loggedStrayCleanup = true;
+          LOG2.warn("MeshRuntimeStore", `Stray root mesh-runtime.db cleanup failed (ignored): ${err?.message || err}`);
+        }
+      }
+    }
+    function meshRuntimeStorePath() {
+      const dir = getLedgerDir2();
+      const nextPath = (0, import_path6.join)(dir, "mesh-runtime.db");
+      cleanupStrayRootRuntimeDb(nextPath);
+      if ((0, import_fs6.existsSync)(nextPath)) return nextPath;
+      const legacyPath = (0, import_path6.join)(dir, "beads.db");
+      if (!(0, import_fs6.existsSync)(legacyPath)) return nextPath;
+      try {
+        (0, import_fs6.renameSync)(legacyPath, nextPath);
+        for (const suffix of ["-wal", "-shm"]) {
+          const legacyCompanion = `${legacyPath}${suffix}`;
+          if ((0, import_fs6.existsSync)(legacyCompanion)) {
+            (0, import_fs6.renameSync)(legacyCompanion, `${nextPath}${suffix}`);
+          }
+        }
+      } catch (err) {
+        if (!loggedMigrationFailure) {
+          loggedMigrationFailure = true;
+          LOG2.warn(
+            "MeshRuntimeStore",
+            `Legacy beads.db\u2192mesh-runtime.db migration failed; using existing DB in-place to avoid data loss: ${err?.message || err}`
+          );
+        }
+        return (0, import_fs6.existsSync)(nextPath) ? nextPath : legacyPath;
+      }
+      return nextPath;
+    }
     var import_fs6;
     var import_path6;
     var DatabaseCtor;
     var loggedMigrationFailure;
     var loggedStrayCleanup;
     var MeshRuntimeStore;
-    var MESH_EVENT_LEDGER_RETENTION_MS;
-    var MESH_TOOL_CALL_LOG_RETENTION_MS;
-    var MESH_TERMINAL_QUEUE_RETENTION_MS;
     var init_mesh_runtime_store = __esm2({
       "src/mesh/mesh-runtime-store.ts"() {
         "use strict";
@@ -52558,13 +52570,14 @@ ${blocks.join("\n\n")}`;
         init_load_better_sqlite3();
         init_config();
         init_mesh_ledger();
-        init_mesh_retention_config();
         init_mesh_work_queue();
         init_mesh_graph_schema();
         init_mesh_graph_store();
         init_slot_model_enforcement();
         init_mesh_daemon_slot_axis();
         init_dist();
+        init_mesh_runtime_store_turn_rows();
+        init_mesh_runtime_store_turn_rows();
         loggedMigrationFailure = false;
         loggedStrayCleanup = false;
         MeshRuntimeStore = class _MeshRuntimeStore {
@@ -52760,6 +52773,7 @@ ${blocks.join("\n\n")}`;
                 mesh_id TEXT NOT NULL,
                 tool TEXT NOT NULL,
                 session_id TEXT,
+                caller_role TEXT,
                 called_at INTEGER NOT NULL
             );
 
@@ -53089,6 +53103,10 @@ ${blocks.join("\n\n")}`;
                     ON mesh_event_ledger(mesh_id, task_id, timestamp)
                     WHERE task_id IS NOT NULL
             `);
+              const toolCallCols = this.tableColumns("mesh_tool_call_log");
+              if (!toolCallCols.has("caller_role")) {
+                this.db.exec(`ALTER TABLE mesh_tool_call_log ADD COLUMN caller_role TEXT`);
+              }
             } catch (err) {
               if (!loggedMigrationFailure) {
                 loggedMigrationFailure = true;
@@ -54022,16 +54040,23 @@ ${blocks.join("\n\n")}`;
            * Returns a rate-limit advisory string when the call rate is too high, null otherwise.
            * windowMs: sliding window size in ms (default 10s)
            * maxCalls: max allowed calls within the window (default 5)
+           *
+           * `callerRole` is a diagnostic, not an auth boundary: it reflects whether
+           * ADHDEV_COORDINATOR_SESSION_ID was present in this process's env at call
+           * time, and a process can set that env var on itself. It exists to answer
+           * "was this call made by a coordinator-launched process or not" for the
+           * mesh-tool-call-caller-instrumentation investigation, not to gate access —
+           * do not wire it into any block/allow decision.
            */
           recordMeshToolCall(opts) {
-            const { meshId, tool, sessionId = null } = opts;
+            const { meshId, tool, sessionId = null, callerRole = null } = opts;
             const windowMs = opts.windowMs ?? 1e4;
             const maxCalls = opts.maxCalls ?? 5;
             const now = Date.now();
             const windowStart = now - windowMs;
             this.db.prepare(
-              "INSERT INTO mesh_tool_call_log (mesh_id, tool, session_id, called_at) VALUES (?, ?, ?, ?)"
-            ).run(meshId, tool, sessionId, now);
+              "INSERT INTO mesh_tool_call_log (mesh_id, tool, session_id, caller_role, called_at) VALUES (?, ?, ?, ?, ?)"
+            ).run(meshId, tool, sessionId, callerRole, now);
             const row = this.db.prepare(
               "SELECT COUNT(*) as cnt FROM mesh_tool_call_log WHERE mesh_id = ? AND tool = ? AND called_at >= ?"
             ).get(meshId, tool, windowStart);
@@ -54057,6 +54082,18 @@ ${blocks.join("\n\n")}`;
           pruneToolCallLog(olderThanMs) {
             return this.db.prepare("DELETE FROM mesh_tool_call_log WHERE called_at < ?").run(Date.now() - olderThanMs).changes;
           }
+          /**
+           * Read back recent mesh_tool_call_log rows for one mesh, most recent first.
+           * Diagnostic reader for the MESH-TOOL-CALL-CALLER-INSTRUMENTATION 1단계
+           * investigation (was session_id/caller_role actually getting recorded, and
+           * does the coordinator/unknown split hold up) — not on any hot path.
+           */
+          getRecentToolCalls(meshId, limit = 100) {
+            const rows = this.db.prepare(
+              "SELECT tool, session_id, caller_role, called_at FROM mesh_tool_call_log WHERE mesh_id = ? ORDER BY called_at DESC LIMIT ?"
+            ).all(meshId, limit);
+            return rows.map((r) => ({ tool: r.tool, sessionId: r.session_id, callerRole: r.caller_role, calledAt: r.called_at }));
+          }
           /**
            * Retention prune for mesh_event_ledger (SoT 1-11 (b)). The ledger is append-only
            * with NO lifecycle GC of its own, so lifecycle events accumulate without bound
@@ -55199,9 +55236,6 @@ ${blocks.join("\n\n")}`;
             return res.changes > 0;
           }
         };
-        MESH_EVENT_LEDGER_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
-        MESH_TOOL_CALL_LOG_RETENTION_MS = 14 * 24 * 60 * 60 * 1e3;
-        MESH_TERMINAL_QUEUE_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
       }
     });
     var mesh_ledger_exports = {};
@@ -56755,7 +56789,7 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
       const lines = [
         "## Task difficulty",
         "",
-        "Pass `difficulty` on `mesh_enqueue_task` (`easy` / `medium` / `difficult` / `freeform`) to describe how hard the work is. It is a ROUTING HINT: it is matched against each node's capability slots, so a task goes to a slot configured for that difficulty.",
+        "Pass `difficulty` on every worker entry in `mesh_enqueue_batch`, or on `mesh_enqueue_task` for the single-task fallback. The values (`easy` / `medium` / `difficult` / `freeform`) describe how hard the work is. It is a ROUTING HINT: it is matched against each node's capability slots, so a task goes to a slot configured for that difficulty.",
         "",
         '**The slot decides the model and thinking level \u2014 not the difficulty.** `difficulty: "difficult"` does not mean "use opus"; it means "route to a slot that handles difficult work", and that slot\'s own model/thinking is what launches. So classify honestly by how hard the task is, and change what a difficulty RUNS ON by editing the node\'s slots (`mesh_node_slots_set`), never by picking a different difficulty. Passing an explicit `model`/`thinkingLevel` still overrides everything for one task.'
       ];
@@ -56839,8 +56873,8 @@ ${rules.join("\n")}`;
       return `## Rules
 
 - **Route, don't implement.** Delegate all code reading, analysis, and execution to node agents. Never read source files or run commands in the coordinator \u2014 keep context lean. See also: **Never use local sub-agents** below.${destructiveGitRule}
-- **Never use local sub-agents.** Do NOT spawn your runtime's own sub-agents (e.g. Claude Code's Task/Explore/Agent tools, or any equivalent in-process agent-spawning tool) to read code, investigate, run RCA, or implement. Such sub-agents execute on the coordinator's machine, outside the mesh \u2014 they escape mesh parallelism, the ledger/audit trail, node capability profiles, and worktree isolation, and leave no \`mesh_task_history\` record. ALL code reading, analysis, RCA, and implementation must be delegated to mesh nodes via \`mesh_enqueue_task\` / \`mesh_send_task\` (use \`task_mode: "live_debug_readonly"\` for read-only investigation), or cross-verified via \`mesh_magi_review\` for read-only fan-out. The coordinator's own actions are limited to \`mesh_*\` tool orchestration and synthesizing results.
-- **Front-load task messages.** Include everything the agent needs (files, problem, expected fix) in \`mesh_enqueue_task\` / \`mesh_send_task\`. Append a structured result request at the end: ask the worker to conclude with a JSON block containing \`status\`, \`changedFiles\`, \`gitStatus\`, \`validationResults\`, \`errors\`, \`nextAction\`. The daemon parses this automatically; you can read it from \`mesh_task_history\`.
+- **Never use local sub-agents.** Do NOT spawn your runtime's own sub-agents (e.g. Claude Code's Task/Explore/Agent tools, or any equivalent in-process agent-spawning tool) to read code, investigate, run RCA, or implement. Such sub-agents execute on the coordinator's machine, outside the mesh \u2014 they escape mesh parallelism, the ledger/audit trail, node capability profiles, and worktree isolation, and leave no \`mesh_task_history\` record. ALL code reading, analysis, RCA, and implementation must be delegated through \`mesh_enqueue_batch\` for a currently known multi-step graph, \`mesh_enqueue_task\` for one ready task, or \`mesh_send_task\` for a same-session continuation (use \`task_mode: "live_debug_readonly"\` for read-only investigation), or cross-verified via \`mesh_magi_review\` for read-only fan-out. The coordinator's own actions are limited to \`mesh_*\` tool orchestration and synthesizing results.
+- **Front-load immutable task instructions.** Include everything the agent needs (files, problem, expected fix) in \`mesh_enqueue_batch\` / \`mesh_enqueue_task\` / \`mesh_send_task\`. Put predecessor-produced data in explicit \`inputs_from\` bindings and coordinator decisions in gates; never copy untrusted worker output into a new instruction by hand when a binding can preserve provenance. Append a structured result request at the end: ask the worker to conclude with a JSON block containing \`status\`, \`changedFiles\`, \`gitStatus\`, \`validationResults\`, \`errors\`, \`nextAction\`. The daemon parses this automatically; you can read it from \`mesh_task_history\`.
 - **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start a fresh session only when: (a) branch/worktree isolation is required, (b) the existing session had a dispatch failure or provider mismatch, (c) the transcript/runtime is contaminated or interrupted, (d) the user explicitly asks for a different provider/session, or (e) **the delta is a genuinely NEW subject rather than a continuation** \u2014 a new topic appended to an existing session can be dropped or re-run as the previous task, so give it its own task even when a session sits idle. Continuation of the same issue in an already-idle session is allowed and preferred \u2014 this rule blocks concurrent unrelated work interleaved into a live (still-generating) session, not sequential same-issue follow-ups. The test is subject continuity, not timing: carrying an investigation forward into its own fix is the SAME subject and belongs in that session (Workflow 3f), while an unrelated bug is a new subject even if the same session just went idle.
 - **Nodes are separate machines with separate checkouts \u2014 not interchangeable execution slots.** Each node is a different physical computer with its own clone of the repo. Work done on another node must be committed, pushed, and pulled back before this machine sees it, and since RELEASE/DEPLOY runs on the coordinator's own machine, sending a code change elsewhere buys a round trip out and another one back. So **default to this coordinator's own machine for code changes** \u2014 its local node (base or a worktree cloned from it). Routing to a DIFFERENT machine is the exception and needs a reason, of which there are exactly two: (a) **platform-specific verification** that cannot be done here \u2014 win32 PATH/registry, a clean install/uninstall on that OS, that machine's package-manager state; or (b) **parallelizing read-only investigation** across machines. "That node is idle" is not a reason. If you catch yourself dispatching a fix to another machine without (a) or (b), route it here instead.
 - **Don't split investigation from the fix.** When a task will plainly end in a code change, dispatch it as \`code_change\` from the start \u2014 the in-session handoff and split criteria live in Workflow 3f. Split only when the fix genuinely belongs on another machine for reason (a) above; redoing an investigator's context in a fresh session (worse, on another machine) is pure loss.
@@ -56904,8 +56938,8 @@ When you compose the task message you dispatch to a node, include this requireme
 |------|---------|
 | \`mesh_status\` | Nodes' health, git state, sessions, branch convergence |
 | \`mesh_list_nodes\` | List nodes with workspace paths |
-| \`mesh_enqueue_task\` | Add a task to the pull-based queue; idle nodes auto-claim |
-| \`mesh_enqueue_batch\` | Atomically enqueue a dependency-wired task set; \`depends_on\` may name batch-local \`ref\`s (forward refs OK). Also carries the full graph surface: \`inputs_from\`, \`run_if\`, \`gates\` + \`gated_by\`, \`workspaces\` + \`workspace_ref\` |
+| \`mesh_enqueue_batch\` | **DEFAULT enqueue surface** for a plan with two or more known graph steps. Atomically enqueues a dependency-wired task set; \`depends_on\` may name batch-local \`ref\`s (forward refs OK). Carries the full graph surface: \`inputs_from\`, \`run_if\`, \`gates\` + \`gated_by\`, \`workspaces\` + \`workspace_ref\` |
+| \`mesh_enqueue_task\` | SINGLE-TASK FALLBACK \u2014 one ready task with no declarable downstream step; idle nodes auto-claim |
 | \`mesh_view_queue\` | Queue status \u2014 pending/assigned/completed/failed/cancelled |
 | \`mesh_graph_view\` | Inspect orchestration graphs \u2014 node states, gates awaiting you, workspace sagas, why something is blocked |
 | \`mesh_graph_gate_claim\` | Take the lease on a gate awaiting a coordinator; returns the fencing token + generation a release needs |
@@ -56962,6 +56996,8 @@ When you compose the task message you dispatch to a node, include this requireme
 | \`mesh_coordinator_prompt_append_set\` | Write/clear that APPEND (append-only; base prompt is not replaceable) |`;
         TOOL_EXPOSURE_PREFLIGHT_SECTION = `## Tool Exposure Preflight
 
+Before searching for an enqueue tool, classify the whole currently known work frontier. For every new delegation search, include \`mesh_enqueue_batch\` by exact name; never search for or load only \`mesh_enqueue_task\`. Load \`mesh_enqueue_task\` only as the single-task fallback after the batch eligibility check below fails.
+
 Before doing any coordinator work, confirm that the actual callable tool list includes \`mesh_status\` and the other \`mesh_*\` tools from the table above. If this Repo Mesh coordinator prompt is present but the callable \`mesh_*\` tools are missing, the MCP server/tool manifest is stale or not injected yet. Do not substitute terminal/file/git tools, do not inspect or edit the repository directly, and do not continue as a non-mesh local coding agent. Stop immediately and tell the user to run \`/reload-mcp\` or start a fresh coordinator session so ADHDev can reconnect \`adhdev-mesh\`.`;
         QUOTA_SECTION = `## Provider Quota
 
@@ -56972,9 +57008,15 @@ Before doing any coordinator work, confirm that the actual callable tool list in
         WORKFLOW_SECTION = `## Orchestration Workflow
 
 1. **Assess** \u2014 Call \`mesh_status\` to see which nodes are healthy and available. Check \`mesh_task_history\` to understand what has already been done in this mesh \u2014 previous delegations, completions, and failures.
-2. **Plan** \u2014 Decompose the user's request into independent tasks for parallel execution, or sequential tasks when dependencies exist. If \`mesh_task_history\` shows a recent failure for a task, decide whether to retry or reassign. **For multi-task work, create a mission first**: call \`mesh_mission_upsert\` with a title and goal, then attach every enqueued task with \`mission_id\`. Express "B after A" ordering with \`depends_on\` on the queue task instead of waiting and polling \u2014 the system claims dependents automatically when their dependencies complete. When the plan is a multi-task graph, submit it with ONE \`mesh_enqueue_batch\` call instead of N sequential enqueues: the batch inserts atomically (a mid-batch error such as a cycle or bad difficulty rolls the whole set back, so no half-registered chain), and each task's \`depends_on\` may name sibling tasks by their batch-local \`ref\` label, forward references included. When the mission's outcome is decided, update its status (\`completed\`/\`abandoned\`) via \`mesh_mission_upsert\`. If the prompt already shows an **Active Mission**, continue it from its current task state \u2014 do not re-enqueue tasks that already exist.
+2. **Plan** \u2014 Decompose the user's request into independent tasks for parallel execution, or sequential tasks when dependencies exist. If \`mesh_task_history\` shows a recent failure for a task, decide whether to retry or reassign. **For multi-task work, create a mission first**: call \`mesh_mission_upsert\` with a title and goal, then attach every enqueued task with \`mission_id\`. Express "B after A" ordering with \`depends_on\` instead of waiting and polling \u2014 the system claims dependents automatically when their dependencies complete. When the mission's outcome is decided, update its status (\`completed\`/\`abandoned\`) via \`mesh_mission_upsert\`. If the prompt already shows an **Active Mission**, continue it from its current task state \u2014 do not re-enqueue tasks that already exist.
 3. **Queue / Delegate** \u2014 The Mesh uses an autonomous pull-based Work Queue:
-   a. **General Tasks**: Enqueue tasks using \`mesh_enqueue_task\`. Idle node agents will automatically pull tasks from the queue and begin working.
+   a. **Batch-first rule:** submit one \`mesh_enqueue_batch\` whenever the currently known plan contains two or more graph steps. A graph may include worker tasks, selected predecessor outputs via \`inputs_from\`, declarative \`run_if\` branches, delayed \`workspace_ref\` preparation, and coordinator gates for approval, Refinery, CI waiting, publish, or deployment. Submit the whole materializable plan once; do not wait and enqueue each known step separately.
+
+   Use \`mesh_enqueue_task\` only when exactly one new worker task is currently known and there is no known downstream step to declare, or when continuing an already-running session via \`mesh_send_task\` is the correct same-subject handoff. If later work is genuinely unknown, enqueue the one ready task and start a new batch when the next frontier becomes known.
+
+   Do not invent speculative downstream instructions merely to form a batch. Use an \`inputs_from\` binding when the instruction is stable but needs predecessor evidence; use a coordinator gate when a human/coordinator decision or external side effect must happen first; use \`run_if\` for a structured result predicate. If none can state the future step faithfully, single-task enqueue is correct.
+
+   Either way, idle node agents automatically pull tasks from the queue and begin working. A batch inserts atomically (a mid-batch error such as a cycle or bad difficulty rolls the whole set back, so no half-registered chain), and each task's \`depends_on\` may name sibling tasks by their batch-local \`ref\` label, forward references included.
    b. **Node Preparation**: Reuse an existing idle session on the correct node/provider before launching a new chat/session. Call \`mesh_launch_session\` only when no suitable session exists, when the user explicitly asks for a fresh provider/session, or when branch/worktree isolation requires it. **A node is not limited to one live session for read-only work** \u2014 \`readonly\`/\`live_debug_readonly\` tasks are exempt from the one-active-per-node invariant, so the SAME node can auto-launch multiple concurrent read-only sessions with no worktree needed. Cloning a worktree costs roughly 10 seconds, so it is cheap enough to create one whenever write work needs a free node; use it for branch isolation, for parallel write tasks (one active write per node), or when a node's read-only queue is deep enough that a second node would clearly finish faster \u2014 call \`mesh_clone_node\` to create the worktree node first.
    b0. **Base nodes are for environment-specific testing, not for general code changes.** Before dispatching any write task, answer ONE question: *does this task verify the physical environment of a specific machine or OS, or does it only change code?*
        - **Physical-environment task \u2192 base node, targeted.** Pin it with \`required_tags\` (e.g. \`["os=win32"]\`) or \`target_node_id\`. Examples that genuinely require the real machine: verifying a win32 \`PATH\`/registry/installer layout, a clean-install or uninstall on a specific OS, Homebrew or package-manager state on one particular machine, an OS-dependent runtime behavior (path separators, process spawn, native bindings), or reproducing a bug reported only on that node. A worktree CANNOT substitute for these \u2014 the point is the machine itself.
@@ -85682,20 +85724,29 @@ ${e?.stderr || ""}`;
             if (!fromNodeId) continue;
             addEdge(fromNodeId, nodeIdByIndex[i], "requires", omitOnSkip);
           }
+          const gateRefsForNode = new Set((t.gated_by ?? []).map((r) => r.trim()).filter(Boolean));
           for (const sourceRef of collectRunIfSourceRefs(t.run_if)) {
             const fromNodeId = nodeIdByRef.get(sourceRef);
             if (!fromNodeId || fromNodeId === nodeIdByIndex[i]) continue;
+            if (gateNodeIdByRef.has(sourceRef)) {
+              gateRefsForNode.add(sourceRef);
+              continue;
+            }
             if (edges.some((e) => e.fromNodeId === fromNodeId && e.toNodeId === nodeIdByIndex[i])) continue;
             addEdge(fromNodeId, nodeIdByIndex[i], "conditional", omitOnSkip);
           }
           for (const sourceRef of collectInputSourceRefs(t.inputs_from)) {
             const fromNodeId = nodeIdByRef.get(sourceRef);
             if (!fromNodeId || fromNodeId === nodeIdByIndex[i]) continue;
+            if (gateNodeIdByRef.has(sourceRef)) {
+              gateRefsForNode.add(sourceRef);
+              continue;
+            }
             if (edges.some((e) => e.fromNodeId === fromNodeId && e.toNodeId === nodeIdByIndex[i] && e.kind === "requires")) continue;
             addEdge(fromNodeId, nodeIdByIndex[i], "requires", omitOnSkip);
           }
-          for (const gateRef of t.gated_by ?? []) {
-            const fromNodeId = gateNodeIdByRef.get(gateRef.trim());
+          for (const gateRef of gateRefsForNode) {
+            const fromNodeId = gateNodeIdByRef.get(gateRef);
             if (!fromNodeId) continue;
             addEdge(fromNodeId, nodeIdByIndex[i], "gate", false);
           }