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

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 ? "d143fc7369d10b184b4cad79ce3a4240bc811faf" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "d143fc73" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.56-rc.6" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-19T09:46:30.077Z" : 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,11 +56873,12 @@ ${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\` (the default \u2014 see Workflow 3.a), falling back to \`mesh_enqueue_task\` only for a terminal single step, to \`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 whichever dispatch surface Workflow 3.a selects (\`mesh_enqueue_batch\` by default; \`mesh_enqueue_task\` / \`mesh_send_task\` in their narrower cases). 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.
+- **Batch is the default enqueue surface.** Apply Workflow 3.a: before every enqueue, ask whether you will read this task's result and then dispatch more work. If yes, that successor is declarable \u2014 submit the whole plan as one \`mesh_enqueue_batch\` with \`inputs_from\` / \`run_if\` / \`gated_by\`, rather than enqueueing a step, waiting, and enqueueing the next by hand. \`mesh_enqueue_task\` is the fallback for a genuinely terminal single step, and it takes an \`orchestration_decision\` stating which \`single_reason\` applies.
 - **Base nodes are reserved for environment-specific testing.** Apply Workflow 3.b0: only work that verifies a machine's physical environment runs on a base node (pinned with \`required_tags\`/\`target_node_id\`); every ordinary \`code_change\` gets its own cloned worktree. Node availability is not branch isolation.
 - **Worktree affinity.** Apply Workflow 3.b1: route a branch's follow-ups back to its own worktree node (\`required_tags: ["worktree=<branch>"]\` or \`target_node_id\`, taken from the \`mesh_clone_node\` result or a live \`mesh_status\`); only \`convergence\` (merge/push) runs base-side.
 - **Classify task difficulty honestly.** Judge each task's real difficulty (\`easy\`/\`medium\`/\`difficult\`/\`freeform\`) per the Task difficulty section above \u2014 it is a routing hint, and the matched slot's own model/thinking is what launches. Never bend difficulty to chase a model; retune slots instead (\`mesh_node_slots_set\`).
@@ -56904,12 +56939,12 @@ 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 |
-| \`mesh_graph_gate_release\` | Pass a gate you hold \u2014 the ONLY way through one (no timeout ever passes a gate) |
+| \`mesh_graph_gate_release\` | Pass a gate you hold \u2014 the ONLY way through one (no timeout ever passes a gate). **A gate and its dependents are one unit**: a gate earns its keep only when some task names it in \`gated_by\`, because releasing it is what dispatches that task. A gate nothing depends on opens nothing and is pure claim/release overhead \u2014 declare the follower in the same batch, or skip the gate |
 | \`mesh_queue_cancel\` | Cancel a queue task (audit history kept) |
 | \`mesh_queue_requeue\` | Return a task to pending for retry |
 | \`mesh_send_task\` | Push a task straight to a specific node/session |
@@ -56962,6 +56997,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 +57009,24 @@ 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 submit the plan as one \`mesh_enqueue_batch\` carrying that \`mission_id\` (a top-level \`mission_id\` applies to every entry). 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.** Before enqueueing anything, answer ONE question: *when this task reports back, will I read its result and then dispatch more work \u2014 or does the result go to the user with nothing behind it?*
+       - **You will act on the result \u2192 \`mesh_enqueue_batch\`.** If you already intend to read the output and dispatch a next step, that next step is a step you can declare. Declare it: bind the evidence with \`inputs_from\`, branch on it with \`run_if\`, or put your own decision behind a coordinator gate and point the follower at it with \`gated_by\`. "I need to see the result first" is HOW a graph edge is expressed, not a reason to skip the graph \u2014 that is exactly what \`inputs_from\` and gates are for. An investigation you plan to act on is, by this test, a declarable two-step plan.
+       - **The result goes to the user and nothing follows \u2192 \`mesh_enqueue_task\`.** One task, no successor you intend to dispatch yourself. Same-subject continuation of an already-running session is \`mesh_send_task\`, not a new enqueue either way.
+       - Submit the whole materializable plan in ONE batch. A batch may mix worker tasks, \`inputs_from\` bindings, \`run_if\` branches, delayed \`workspace_ref\` preparation, and coordinator gates for approval, Refinery, CI waiting, publish, or deployment. Do not enqueue one known step, wait for it, and then enqueue the next known step by hand.
+       - **A mesh with idle nodes or a short plan does not remove this requirement.** "It is only two steps" and "I will just enqueue the next one when this finishes" are the two ways the graph gets skipped; neither is a reason. Two declarable steps is precisely the case the batch surface exists for.
+       - **"The only thing I am sure of right now is this one task" is not evidence of a single.** That feeling is about your confidence, not about how many steps are settled; two steps are routinely settled at once while it still feels that way. Count the steps you would actually dispatch. If that count is two or more, it is a batch no matter how the plan feels.
+       - **"I cannot choose the next step until I see this result" states that the next step EXISTS.** What the result decides is *which branch you take*, not *whether* there is a follow-up \u2014 and a branch that turns on a predecessor's output is what \`run_if\` selects, what \`inputs_from\` feeds, and what a coordinator gate holds until you decide. Needing to look at evidence before choosing is the ordinary case for a graph edge, not an exception to it.
+       - **A gate or a batch is not overhead when something follows it.** The extra call buys the dispatch of everything behind it, so it costs one call and saves a whole round-trip through you. The only genuinely wasteful gate is one nothing depends on \u2014 a gate no task names in \`gated_by\` opens nothing when released, which the release response tells you about; that case is answered by declaring the follower, not by abandoning the batch.
+
+   When you do use \`mesh_enqueue_task\`, pass \`orchestration_decision\` recording why a single was right (\`single_reason\`: \`only_one_step_known\` / \`future_step_not_specifiable\` / \`same_session_continuation\` / \`legacy_client\` / \`operator_override\`). Omitting it is recorded as \`decision_missing\`.
+
+   Do not invent speculative downstream instructions merely to form a batch \u2014 a step you would not actually dispatch does not belong in the graph. But check the three declaration surfaces before concluding a step is unstatable: \`inputs_from\` when the instruction is stable and only needs predecessor evidence, a coordinator gate when a human/coordinator decision or external side effect must come first, \`run_if\` when the branch turns on a structured result predicate. Only when none of the three can state the future step faithfully is single-task enqueue correct.
+
+   **The line between the two failures.** The rebuttals above are aimed at declining to declare a step you already intend to dispatch; this guard is aimed at fabricating one you do not. They never both apply to the same step: the test is whether the step exists in your plan, not whether its details are settled. A step you intend to run but whose exact branch depends on evidence is KNOWN and belongs in the batch \u2014 that dependency is what the three surfaces express. A step you would have to make up to fill the batch is UNKNOWN and belongs nowhere. When you genuinely cannot tell which one you are looking at, enqueue the single and record \`future_step_not_specifiable\`; that is the honest answer and it is measured.
+
+   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.
@@ -60495,9 +60547,11 @@ ${rendered}`, "utf-8");
         const materializedNodeIds = advanceReleasedGateDownstream(store, gate, node, nowIso);
         const freshNodes = graphStore.listNodes(gate.graphId);
         const graph = graphStore.getGraph(gate.graphId);
+        let graphCompleted = false;
         if (graph && freshNodes.every(isTerminalEquivalent)) {
           graphStore.updateGraphStatus(gate.graphId, "completed", nowIso, true);
           insertGateOutbox(graphStore, gate.meshId, gate.graphId, "graph_completed", { graphId: gate.graphId }, nowIso);
+          graphCompleted = true;
         } else if (graph?.status === "waiting_gate") {
           const stillWaiting = graphStore.listGatesByGraph(gate.graphId).some((g) => g.gateId !== gate.gateId && (g.state === "awaiting_coordinator" || g.state === "claimed"));
           if (!stillWaiting) graphStore.updateGraphStatus(gate.graphId, "active", nowIso);
@@ -60521,7 +60575,16 @@ ${rendered}`, "utf-8");
             gateId: gate.gateId
           }, nowIso);
         }
-        return { released: true, duplicate: false, gate: graphStore.getGate(gate.gateId), materializedNodeIds };
+        return {
+          released: true,
+          duplicate: false,
+          gate: graphStore.getGate(gate.gateId),
+          materializedNodeIds,
+          // Read from the edge set this release already walked — a gate with an empty
+          // directDownstream is terminal, and terminal gates materialize nothing by design.
+          downstreamNodeCount: directDownstream.size,
+          graphCompleted
+        };
       });
       try {
         drainMeshGraphOutbox(input.meshId);
@@ -60782,6 +60845,18 @@ ${rendered}`, "utf-8");
         ...p.replayed ? { replayed: true } : {}
       });
     }
+    function recordSingleEnqueueDecision(meshId, p) {
+      safeAppend(meshId, "single_enqueue_decision", {
+        taskId: p.taskId,
+        enqueueSurface: "single",
+        ...p.missionId ? { missionId: p.missionId } : {},
+        ...p.coordinatorSessionId ? { coordinatorSessionId: p.coordinatorSessionId } : {},
+        orchestrationDecision: p.decision,
+        ...p.decisionMissing ? { decisionMissing: true } : {},
+        ...p.declaredEligibleSingle ? { declaredEligibleSingle: true } : {},
+        ...p.batchCapabilityAvailable ? { batchCapabilityAvailable: p.batchCapabilityAvailable } : {}
+      }, p.taskId);
+    }
     function recordGraphEnqueueValidationFailed(meshId, p) {
       safeAppend(meshId, "graph_enqueue_validation_failed", {
         code: p.code,
@@ -60839,6 +60914,7 @@ ${rendered}`, "utf-8");
     }
     var MESH_VALID_SINGLE_REASONS;
     var MESH_SUPERSEDED_SINGLE_REASONS;
+    var MESH_DECLARED_ELIGIBLE_SINGLE_HINT;
     var init_mesh_graph_provenance = __esm2({
       "src/mesh/mesh-graph-provenance.ts"() {
         "use strict";
@@ -60856,6 +60932,7 @@ ${rendered}`, "utf-8");
           "workspace_unresolved",
           "coordinator_action_between"
         ];
+        MESH_DECLARED_ELIGIBLE_SINGLE_HINT = "You declared known_graph_steps >= 2 but used the single-task surface. Submit the known steps as one mesh_enqueue_batch \u2014 its input bindings, conditions and coordinator gates declare the ones that need predecessor evidence, a condition, or a coordinator action \u2014 instead of enqueueing them one at a time.";
       }
     });
     function turnProjectionActiveWorkStatus(meshId, taskId) {
@@ -61706,8 +61783,28 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         }
       };
     }
-    function quotaFactsContextForLiveRouting(mesh, isLocalNode) {
-      return { nodes: mesh?.nodes, liveLocalQuota: liveLocalQuotaForRouting(isLocalNode) };
+    function liveLocalProviderEnablementForRouting(loader2, isLocalNode) {
+      if (!loader2) return null;
+      const verdicts = /* @__PURE__ */ new Map();
+      return {
+        isMachineProviderEnabled: (providerType) => loader2.isMachineProviderEnabled(providerType),
+        isMachineQuotaEnabled: (providerType) => loader2.isMachineQuotaEnabled ? loader2.isMachineQuotaEnabled(providerType) : true,
+        isLocalNode(node) {
+          let verdict = verdicts.get(node);
+          if (verdict === void 0) {
+            verdict = !!node && isLocalNode(node) === true;
+            verdicts.set(node, verdict);
+          }
+          return verdict;
+        }
+      };
+    }
+    function quotaFactsContextForLiveRouting(mesh, isLocalNode, providerLoader) {
+      return {
+        nodes: mesh?.nodes,
+        liveLocalQuota: liveLocalQuotaForRouting(isLocalNode),
+        providerEnablement: liveLocalProviderEnablementForRouting(providerLoader, isLocalNode)
+      };
     }
     function directQuotaEntryFor(node, providerType) {
       const facts = node?.nodeFacts;
@@ -61764,6 +61861,28 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const ageText = Number.isFinite(ageMs2) ? `${Math.round(ageMs2 / 6e4)}m` : "unparseable";
       LOG2.info("MeshQuota", `QUOTA GATE: provider '${providerType}' on node ${nodeId} fails open \u2014 snapshot age ${ageText} exceeds the ${Math.round(staleAfterMs / 6e4)}m freshness threshold`);
     }
+    function classifyAbsentQuotaReason(node, providerType, context) {
+      const enablement = context?.providerEnablement;
+      if (!enablement) return "unclassified_remote";
+      const sourceNode = cloneSourceNodeFor(node, context);
+      if (!enablement.isLocalNode(node) && !(sourceNode !== void 0 && enablement.isLocalNode(sourceNode))) {
+        return "unclassified_remote";
+      }
+      if (!enablement.isMachineProviderEnabled(providerType)) return "provider_disabled";
+      if (!enablement.isMachineQuotaEnabled(providerType)) return "probe_disabled";
+      return "not_measured";
+    }
+    function logAbsentQuotaFailOpen(node, providerType, policy, now, context) {
+      const staleAfterMs = resolveQuotaRoutingPolicy(policy).staleAfterMs;
+      const nodeId = typeof node?.nodeId === "string" && node.nodeId ? node.nodeId : typeof node?.id === "string" && node.id ? node.id : "unknown";
+      const key2 = `${nodeId} ${providerType}`;
+      const last = absentFailOpenLoggedAt.get(key2);
+      if (last !== void 0 && now - last < staleAfterMs) return;
+      absentFailOpenLoggedAt.set(key2, now);
+      const reason = classifyAbsentQuotaReason(node, providerType, context);
+      const reasonText = reason === "probe_disabled" ? "quota probing is disabled for this provider on this machine (quotaEnabled: false \u2014 an intended opt-out, not a fault)" : reason === "provider_disabled" ? "this provider is not enabled on this machine" : reason === "not_measured" ? "no snapshot has been measured yet" : "this daemon cannot read that node's machineProviders config (remote node, or its own daemon has not injected one) \u2014 cannot tell not-yet-measured from an opt-out; check the owning node's config directly";
+      LOG2.info("MeshQuota", `QUOTA GATE: provider '${providerType}' on node ${nodeId} fails open \u2014 no quota entry (${reason}: ${reasonText})`);
+    }
     function isSessionResetImminent(session, facts, quota, imminentMs, now) {
       const resetsAt = Number(session?.resetsAt);
       if (!Number.isFinite(resetsAt) || resetsAt <= 0) return false;
@@ -61785,7 +61904,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     }
     function evaluateProviderQuotaGate(node, providerType, policy, now = Date.now(), context) {
       const entry = quotaEntryFor(node, providerType, context, now);
-      if (!entry) return null;
+      if (!entry) {
+        logAbsentQuotaFailOpen(node, providerType, policy, now, context);
+        return null;
+      }
       const { facts, quota } = entry;
       let sessionTrustworthy = true;
       let weeklyTrustworthy = true;
@@ -61947,6 +62069,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON;
     var ALL_PROVIDERS_QUOTA_GATED_SKIP_REASON;
     var staleFailOpenLoggedAt;
+    var absentFailOpenLoggedAt;
     var DEFAULT_WEEKLY_WINDOW_MINUTES;
     var DEFAULT_SESSION_WINDOW_MINUTES;
     var lastQuotaRankingByNode;
@@ -61962,6 +62085,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON = "provider_quota_exhausted";
         ALL_PROVIDERS_QUOTA_GATED_SKIP_REASON = "all_providers_quota_gated";
         staleFailOpenLoggedAt = /* @__PURE__ */ new Map();
+        absentFailOpenLoggedAt = /* @__PURE__ */ new Map();
         DEFAULT_WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
         DEFAULT_SESSION_WINDOW_MINUTES = 5 * 60;
         lastQuotaRankingByNode = /* @__PURE__ */ new Map();
@@ -66498,7 +66622,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         LOG2.info("MeshQueue", `Deferring queue claim for node ${nodeId} (${sessionId}): an auto fast-forward is mutating its workspace \u2014 task left pending, claim re-fires next tick`);
         return false;
       }
-      const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null, Date.now(), quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode));
+      const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null, Date.now(), quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader));
       if (quotaClaimTrace) quotaClaimTrace.evaluated += 1;
       if (quotaClaimBlock) {
         const observation = { nodeId, sessionId, providerType, block: quotaClaimBlock };
@@ -67236,7 +67360,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           // pass it through for the 'fitness' strategy's task→slot ranking. The
           // mesh's quotaRouting thresholds ride along so the fitness score can
           // include the quota-headroom spread bonus (fail-open when unset).
-          { bumpCursor: true, task: { difficulty: task.difficulty, requiredTags: task.requiredTags }, quotaRouting: mesh?.policy?.quotaRouting ?? null, quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode) }
+          { bumpCursor: true, task: { difficulty: task.difficulty, requiredTags: task.requiredTags }, quotaRouting: mesh?.policy?.quotaRouting ?? null, quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader) }
         ).map((c) => c.node);
         const skippedCandidates = [];
         const SKIPPED_CANDIDATES_MAX = 5;
@@ -67295,7 +67419,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           }
           autoLaunchInProgress.add(launchKey);
           try {
-            const resolved = await resolveUsableProvider(components, nodeId, node, meshId, task.requiredTags, { difficulty: task.difficulty, requiredTags: task.requiredTags }, mesh?.policy?.quotaRouting ?? null, quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode), task.id);
+            const resolved = await resolveUsableProvider(components, nodeId, node, meshId, task.requiredTags, { difficulty: task.difficulty, requiredTags: task.requiredTags }, mesh?.policy?.quotaRouting ?? null, quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader), task.id);
             if (!resolved.providerType) {
               markSkip(nodeId, resolved.reason || "provider_unusable");
               continue;
@@ -67436,7 +67560,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
               task: { difficulty: task.difficulty, requiredTags: task.requiredTags },
               resolved,
               quotaRouting: mesh?.policy?.quotaRouting ?? null,
-              quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode),
+              quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader),
               skippedCandidates,
               requiredTagsResult: {
                 required: requiredTags,
@@ -71489,7 +71613,7 @@ ${cleanBody}`;
                   // daemon's live quota cache, not the git_status-stamped
                   // nodeFacts copy (mesh-quota-routing). Remote nodes keep
                   // reading their reported nodeFacts.
-                  quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode)
+                  quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader)
                 ) : { action: "block" };
                 const relaunchProviderType = relaunch.action === "block" ? null : relaunch.providerType;
                 if (node) {
@@ -82395,6 +82519,7 @@ ${e?.stderr || ""}`;
       MAX_SIZE_ROTATION_GENERATIONS: () => MAX_SIZE_ROTATION_GENERATIONS,
       MESH_CONVERGE_FAST_FORWARD_TAG: () => MESH_CONVERGE_FAST_FORWARD_TAG,
       MESH_CONVERGE_REFINE_TAG: () => MESH_CONVERGE_REFINE_TAG,
+      MESH_DECLARED_ELIGIBLE_SINGLE_HINT: () => MESH_DECLARED_ELIGIBLE_SINGLE_HINT,
       MESH_GATE_DEFAULT_LEASE_SECONDS: () => MESH_GATE_DEFAULT_LEASE_SECONDS,
       MESH_GATE_NAMED_OUTCOMES: () => MESH_GATE_NAMED_OUTCOMES,
       MESH_GATE_RELEASE_PATCH_KEYS: () => MESH_GATE_RELEASE_PATCH_KEYS,
@@ -82793,6 +82918,7 @@ ${e?.stderr || ""}`;
       recordMeshToolCall: () => recordMeshToolCall,
       recordMissingSessionAttempt: () => recordMissingSessionAttempt2,
       recordSessionUsage: () => recordSessionUsage,
+      recordSingleEnqueueDecision: () => recordSingleEnqueueDecision,
       recoverExpiredWorkspaceSagas: () => recoverExpiredWorkspaceSagas,
       registerExtensionProviders: () => registerExtensionProviders,
       registerMeshCoordinator: () => registerMeshCoordinator,
@@ -85682,20 +85808,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);
           }