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

package/dist/index.js

@@ -35904,6 +35904,15 @@ var require_dist3 = __commonJS({
       } else {
         delete policy.quotaRouting;
       }
+      if (policy.onDependencyFailure === void 0 || policy.onDependencyFailure === "block") {
+        delete policy.onDependencyFailure;
+      } else if (policy.onDependencyFailure === "cancel") {
+        policy.onDependencyFailure = "cancel";
+      } else {
+        throw new Error(
+          `invalid_on_dependency_failure: must be 'block' or 'cancel' (got ${JSON.stringify(policy.onDependencyFailure)}). Invalid values are rejected; they do not silently become 'block'.`
+        );
+      }
       return policy;
     }
     function resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy, provider, repoConfig, providerType, overrideModeId, overrideLegacyAutoApprove) {
@@ -36040,7 +36049,8 @@ var require_dist3 = __commonJS({
           // notifies the owner. Opt into 'auto_silent_on_dispatch' to one-shot-silence the
           // routine idle push for a coordinator-driven task (approval/failure notifications
           // are never affected — see coordinatorIdlePushPolicy).
-          coordinatorIdlePushPolicy: "always"
+          coordinatorIdlePushPolicy: "always",
+          onDependencyFailure: "block"
         };
         DEFAULT_QUOTA_ROUTING_POLICY = {
           staleAfterMs: 30 * 60 * 1e3,
@@ -36610,10 +36620,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "043f842c15bd9babf19ea49b2392bf827f8cc97a" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "043f842c" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.56-rc.3" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-18T13:29:56.354Z" : void 0);
+      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);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -42845,6 +42855,10 @@ ${error48.message || ""}`;
           "mesh_enqueue_task",
           "mesh_enqueue_batch",
           "mesh_view_queue",
+          // GRAPH-ORCHESTRATION Phase E — the coordinator gate + graph view surface.
+          "mesh_graph_view",
+          "mesh_graph_gate_claim",
+          "mesh_graph_gate_release",
           "mesh_queue_cancel",
           "mesh_queue_requeue",
           "mesh_send_task",
@@ -43952,6 +43966,10 @@ ${error48.message || ""}`;
           return `[System] ${args.nodeLabel} already has completion evidence${metadata}. The no-progress monitor reconciled the terminal handoff and marked the session complete; wait for the queued completion event/status refresh before doing any manual transcript check.`;
         }
         const reviewRecommended = args.metadataEvent.reviewRecommended === true;
+        const timedOutNoResponse = args.metadataEvent.completionDiagnostic && typeof args.metadataEvent.completionDiagnostic === "object" && args.metadataEvent.completionDiagnostic.timedOutWithoutFinalAssistant === true;
+        if (timedOutNoResponse) {
+          return `[System] ${args.nodeLabel} was forcibly terminated WITHOUT a response${metadata}: the finalization wait expired with no final assistant answer, so the task was recorded as a forced termination (failed), NOT as a completion. Verify the actual state with mesh_read_chat / git status and re-dispatch the task if the work is still needed.`;
+        }
         const weakCompletion = isWeakCompletionMetadata(args.metadataEvent);
         const completionLead = weakCompletion ? `[System] ${args.nodeLabel} reported a possible completion (weak evidence) \u2014 awaiting confirmation${metadata}.` : `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}.`;
         const verifyTextNote = " Completion evidence is weak \u2014 verify via mesh_read_chat or git status before declaring the task done; the worker may still be mid-turn or parked on an approval/modal.";
@@ -45352,14 +45370,40 @@ Next step: ${nextStep}`;
         sessionOrderChains = /* @__PURE__ */ new Map();
       }
     });
+    function newMeshGraphId() {
+      return (0, import_crypto6.randomUUID)();
+    }
+    function newMeshGraphNodeId() {
+      return (0, import_crypto6.randomUUID)();
+    }
+    function newMeshGraphGateId() {
+      return (0, import_crypto6.randomUUID)();
+    }
     function newMeshGraphOutboxId() {
       return (0, import_crypto6.randomUUID)();
     }
     var import_crypto6;
+    var MESH_GRAPH_SCHEMA_VERSION;
+    var MESH_GRAPH_ON_UPSTREAM_SKIP_POLICIES;
+    var MESH_GRAPH_GATE_ACTIONS;
+    var MESH_GRAPH_GATE_TIMEOUT_POLICIES;
+    var MESH_GRAPH_ON_DEPENDENCY_FAILURE_POLICIES;
     var init_mesh_graph_types = __esm2({
       "src/mesh/mesh-graph-types.ts"() {
         "use strict";
         import_crypto6 = require("crypto");
+        MESH_GRAPH_SCHEMA_VERSION = 2;
+        MESH_GRAPH_ON_UPSTREAM_SKIP_POLICIES = ["skip", "omit_dependency"];
+        MESH_GRAPH_GATE_ACTIONS = [
+          "refinery",
+          "approval",
+          "ci_wait",
+          "publish",
+          "deploy",
+          "custom"
+        ];
+        MESH_GRAPH_GATE_TIMEOUT_POLICIES = ["hold", "cancel_downstream", "fail_graph"];
+        MESH_GRAPH_ON_DEPENDENCY_FAILURE_POLICIES = ["block", "cancel"];
       }
     });
     function maskKeepTail(token) {
@@ -45895,6 +45939,188 @@ ${blocks.join("\n\n")}`;
         init_mesh_graph_workspace_identity();
       }
     });
+    function parseOnDependencyFailurePolicy(value) {
+      if (value === void 0 || value === null || value === "") return "block";
+      if (typeof value === "string" && MESH_GRAPH_ON_DEPENDENCY_FAILURE_POLICIES.includes(value)) {
+        return value;
+      }
+      throw new MeshGraphPolicyError(
+        `invalid_on_dependency_failure: must be 'block' or 'cancel' (got ${JSON.stringify(value)}). Invalid values are rejected; they do not silently become 'block'.`
+      );
+    }
+    function resolveOnDependencyFailurePolicy(value) {
+      return value === "cancel" ? "cancel" : "block";
+    }
+    function parseGraphPolicy(policyJson) {
+      const parsed = safeParseObject(policyJson);
+      const raw = parsed?.on_dependency_failure ?? parsed?.onDependencyFailure;
+      return { on_dependency_failure: parseOnDependencyFailurePolicy(raw) };
+    }
+    function projectGraphPublicPolicy(policyJson) {
+      try {
+        return parseGraphPolicy(policyJson);
+      } catch (e) {
+        return {
+          on_dependency_failure: "block",
+          policyInvalid: e instanceof Error ? e.message : String(e)
+        };
+      }
+    }
+    function serializeGraphPolicy(policy) {
+      return JSON.stringify({ on_dependency_failure: policy.on_dependency_failure });
+    }
+    function isGraphSkipPlaceholder(entry) {
+      if (!entry) return false;
+      const reason = entry.blockedReason ?? entry.cancelReason ?? "";
+      return entry.status === "cancelled" && reason.startsWith(MESH_GRAPH_SKIP_BLOCK_PREFIX);
+    }
+    function parseLegacyDependencyFailedPredecessor(reason) {
+      if (typeof reason !== "string") return null;
+      if (!reason.startsWith(LEGACY_DEPENDENCY_FAILED_PREFIX)) return null;
+      const rest = reason.slice(LEGACY_DEPENDENCY_FAILED_PREFIX.length);
+      if (!rest || rest.startsWith(":")) return null;
+      return rest;
+    }
+    function deriveDependencyFailures(dependsOn, statusById, depMetaById) {
+      const deps = Array.isArray(dependsOn) ? dependsOn : [];
+      const failures = [];
+      for (const taskId of deps) {
+        const meta3 = depMetaById?.get(taskId);
+        const status = statusById.get(taskId) ?? meta3?.status;
+        if (isGraphSkipPlaceholder({ status, blockedReason: meta3?.blockedReason, cancelReason: meta3?.cancelReason })) {
+          continue;
+        }
+        if (status !== "failed" && status !== "cancelled") continue;
+        const reason = meta3?.cancelReason ?? meta3?.blockedReason;
+        failures.push({
+          taskId,
+          status,
+          ...reason ? { reason } : {}
+        });
+      }
+      return failures;
+    }
+    function classifyGraphRollup(nodes) {
+      const gates = nodes.filter((n) => n.kind === "coordinator_gate");
+      const workers = nodes.filter((n) => n.kind !== "coordinator_gate");
+      if (gates.some((g) => !GATE_SETTLED.has(g.state))) return null;
+      if (workers.some((w) => !WORKER_SETTLED.has(w.state))) return null;
+      if (workers.some((w) => w.state === "failed")) return "failed";
+      if (workers.some((w) => w.state === "cancelled") || gates.some((g) => g.state === "cancelled" || g.state === "expired")) {
+        return "cancelled";
+      }
+      if (workers.length === 0 && gates.length === 0) return "completed";
+      if (workers.every((w) => SUCCESS_TERMINAL.has(w.state)) && gates.every((g) => g.state === "released" || SUCCESS_TERMINAL.has(g.state))) {
+        return "completed";
+      }
+      return "completed";
+    }
+    function applyGraphCancelCascade(store, nodes, edges, origin, nowIso, updateNodeState) {
+      const byId = new Map(nodes.map((n) => [n.nodeId, n]));
+      const frontier = [origin.nodeId];
+      const seen = new Set(frontier);
+      const cancelledNodeIds = [];
+      const cancelledTaskIds = [];
+      const sourceTaskId = origin.queueTaskId ?? origin.nodeId;
+      const sourceRef = origin.ref ?? origin.nodeId;
+      while (frontier.length > 0) {
+        const currentId = frontier.pop();
+        const outgoing = edges.filter((e) => e.fromNodeId === currentId && e.kind !== "gate");
+        for (const edge of outgoing) {
+          const target = byId.get(edge.toNodeId);
+          if (!target || seen.has(target.nodeId)) continue;
+          seen.add(target.nodeId);
+          if (target.kind !== "worker_task") continue;
+          if (target.state === "skipped") continue;
+          if (!CANCELABLE_NODE_STATES.has(target.state)) continue;
+          const reason = `${LEGACY_DEPENDENCY_FAILED_PREFIX}${sourceRef}`;
+          updateNodeState(target, reason);
+          target.state = "cancelled";
+          target.failureReason = reason;
+          cancelledNodeIds.push(target.nodeId);
+          if (target.queueTaskId) {
+            const entry = store.findQueueEntryById(target.meshId, target.queueTaskId);
+            if (entry && entry.status === "pending") {
+              cancelledTaskIds.push(entry.id);
+            }
+          }
+          frontier.push(target.nodeId);
+        }
+      }
+      return { cancelledNodeIds, cancelledTaskIds };
+    }
+    function migrateLegacyDependencyFailedQueueBlocks(db) {
+      let rows;
+      try {
+        rows = db.prepare(`SELECT id, mesh_id, payload FROM mesh_queue`).all();
+      } catch {
+        return [];
+      }
+      const cleared = [];
+      const update = db.prepare(`UPDATE mesh_queue SET payload = ?, updated_at = ? WHERE id = ? AND mesh_id = ?`);
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      for (const row of rows) {
+        let entry;
+        try {
+          entry = JSON.parse(row.payload);
+        } catch {
+          continue;
+        }
+        const predecessorId = parseLegacyDependencyFailedPredecessor(entry.blockedReason);
+        if (!predecessorId) continue;
+        delete entry.blockedReason;
+        update.run(JSON.stringify(entry), nowIso, row.id, row.mesh_id);
+        cleared.push({ taskId: row.id, meshId: row.mesh_id, predecessorId });
+      }
+      return cleared;
+    }
+    function safeParseObject(text) {
+      if (!text) return null;
+      try {
+        const value = JSON.parse(text);
+        if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+        return value;
+      } catch {
+        return null;
+      }
+    }
+    var MESH_ON_DEPENDENCY_FAILURE_PUBLIC_TEXT;
+    var MESH_GRAPH_SKIP_BLOCK_PREFIX;
+    var LEGACY_DEPENDENCY_FAILED_PREFIX;
+    var MeshGraphPolicyError;
+    var SUCCESS_TERMINAL;
+    var WORKER_SETTLED;
+    var GATE_SETTLED;
+    var CANCELABLE_NODE_STATES;
+    var init_mesh_graph_derived_failure = __esm2({
+      "src/mesh/mesh-graph-derived-failure.ts"() {
+        "use strict";
+        init_mesh_graph_types();
+        MESH_ON_DEPENDENCY_FAILURE_PUBLIC_TEXT = "on_dependency_failure controls downstream tasks when a required worker task fails or is cancelled. `block` (default) keeps downstream pending and automatically recovers if the predecessor is retried and later completes. `cancel` terminally cancels the dependent branch; it is not revived by predecessor retry.";
+        MESH_GRAPH_SKIP_BLOCK_PREFIX = "graph_skipped:";
+        LEGACY_DEPENDENCY_FAILED_PREFIX = "dependency_failed:";
+        MeshGraphPolicyError = class extends Error {
+          constructor(message, code = "invalid_on_dependency_failure") {
+            super(message);
+            this.code = code;
+            this.name = "MeshGraphPolicyError";
+          }
+        };
+        SUCCESS_TERMINAL = /* @__PURE__ */ new Set(["completed", "released", "skipped"]);
+        WORKER_SETTLED = /* @__PURE__ */ new Set([
+          "completed",
+          "skipped",
+          "failed",
+          "cancelled"
+        ]);
+        GATE_SETTLED = /* @__PURE__ */ new Set(["released", "cancelled", "expired"]);
+        CANCELABLE_NODE_STATES = /* @__PURE__ */ new Set([
+          "declared",
+          "blocked",
+          "materialized"
+        ]);
+      }
+    });
     function graphMaterializationBlockReason(nodeId, materializationVersion) {
       return `${GRAPH_BLOCK_PREFIX}${nodeId}:${materializationVersion}`;
     }
@@ -45907,6 +46133,14 @@ ${blocks.join("\n\n")}`;
       if (!Number.isInteger(version2) || version2 < 0) return null;
       return { nodeId: rest.slice(0, sep15), version: version2 };
     }
+    function coordinatorGateBlockReason(gateId) {
+      return `${GATE_BLOCK_PREFIX}${gateId}`;
+    }
+    function parseCoordinatorGateBlock(reason) {
+      if (!reason || !reason.startsWith(GATE_BLOCK_PREFIX)) return null;
+      const gateId = reason.slice(GATE_BLOCK_PREFIX.length);
+      return gateId.length > 0 ? { gateId } : null;
+    }
     function registerMeshGraphQueueWakeHandler(handler) {
       queueWakeHandler = handler;
     }
@@ -46030,11 +46264,59 @@ ${blocks.join("\n\n")}`;
       });
       const nodes = graphStore.listNodes(node.graphId);
       const byId = new Map(nodes.map((n) => [n.nodeId, n]));
-      let graphRolledUp = false;
-      if (nodes.every(isTerminalEquivalent)) {
-        graphStore.updateGraphStatus(node.graphId, "completed", nowIso, true);
-        outbox.push({ kind: "graph_completed", payload: { graphId: node.graphId } });
-        graphRolledUp = true;
+      const graph = graphStore.getGraph(node.graphId);
+      const failurePolicy = projectGraphPublicPolicy(graph?.policyJson).on_dependency_failure;
+      if ((terminal.status === "failed" || terminal.status === "cancelled") && failurePolicy === "cancel") {
+        const edges = graphStore.listEdges(node.graphId);
+        const cascade = applyGraphCancelCascade(
+          store,
+          nodes,
+          edges,
+          node,
+          nowIso,
+          (target, reason) => {
+            graphStore.updateNodeState(target.graphId, target.nodeId, "cancelled", nowIso, {
+              failureReason: reason
+            });
+          }
+        );
+        for (const taskId of cascade.cancelledTaskIds) {
+          const entry = store.findQueueEntryById(node.meshId, taskId);
+          if (entry && entry.status === "pending") {
+            entry.status = "cancelled";
+            entry.cancelledAt = nowIso;
+            entry.cancelReason = `dependency_failed:${terminal.taskId}`;
+            store.updateQueueEntry(entry);
+          }
+        }
+        for (const nodeId of cascade.cancelledNodeIds) {
+          const target = byId.get(nodeId);
+          outbox.push({
+            kind: "graph_node_cancelled",
+            payload: {
+              graphId: node.graphId,
+              nodeId,
+              ref: target?.ref,
+              taskId: target?.queueTaskId,
+              reason: `dependency_failed:${node.ref ?? node.nodeId}`
+            }
+          });
+        }
+      } else if (terminal.status === "failed" || terminal.status === "cancelled") {
+        const dependents = graphStore.listEdges(node.graphId).filter((e) => e.fromNodeId === node.nodeId && e.kind !== "gate").map((e) => byId.get(e.toNodeId)).filter((n) => !!n && n.kind === "worker_task");
+        outbox.push({
+          kind: "graph_derived_failure",
+          payload: {
+            graphId: node.graphId,
+            nodeId: node.nodeId,
+            ref: node.ref,
+            taskId: terminal.taskId,
+            outcome: terminal.status,
+            policy: "block",
+            dependentNodeIds: dependents.map((d) => d.nodeId),
+            dependentTaskIds: dependents.map((d) => d.queueTaskId).filter(Boolean)
+          }
+        });
       }
       const materialized = [];
       if (terminal.status === "completed") {
@@ -46047,7 +46329,12 @@ ${blocks.join("\n\n")}`;
           );
           for (const targetId of downstreamIds) {
             const target = byId.get(targetId);
-            if (!target || target.kind !== "worker_task" || !target.queueTaskId) continue;
+            if (!target) continue;
+            if (target.kind === "coordinator_gate") {
+              maybeOpenCoordinatorGate(store, target, edges, byId, nowIso);
+              continue;
+            }
+            if (target.kind !== "worker_task" || !target.queueTaskId) continue;
             if (target.state !== "declared" && target.state !== "blocked") continue;
             const outcome = settleDownstreamNode(store, target, edges, byId, nowIso);
             if (outcome.kind === "materialized") {
@@ -46091,10 +46378,12 @@ ${blocks.join("\n\n")}`;
           }
           frontier = nextFrontier;
         }
-        if (!graphRolledUp && graphStore.listNodes(node.graphId).every(isTerminalEquivalent)) {
-          graphStore.updateGraphStatus(node.graphId, "completed", nowIso, true);
-          outbox.push({ kind: "graph_completed", payload: { graphId: node.graphId } });
-        }
+      }
+      const rolled = classifyGraphRollup(graphStore.listNodes(node.graphId));
+      if (rolled && graph?.status !== rolled) {
+        graphStore.updateGraphStatus(node.graphId, rolled, nowIso, true);
+        const kind = rolled === "completed" ? "graph_completed" : rolled === "failed" ? "graph_failed" : "graph_cancelled";
+        outbox.push({ kind, payload: { graphId: node.graphId, status: rolled } });
       }
       if (materialized.length > 0) {
         outbox.push({ kind: "queue_wake", payload: { meshId: node.meshId, reason: "graph_materialization", graphId: node.graphId } });
@@ -46117,9 +46406,95 @@ ${blocks.join("\n\n")}`;
     function isTerminalEquivalent(n) {
       return n.state === "completed" || n.state === "released" || n.state === "skipped";
     }
+    function maybeOpenCoordinatorGate(store, gateNode, edges, byId, nowIso) {
+      const graphStore = store.graphStore();
+      if (gateNode.state !== "declared" && gateNode.state !== "blocked") return false;
+      const gate = graphStore.findGateByNodeId(gateNode.graphId, gateNode.nodeId);
+      if (!gate || gate.state !== "declared") return false;
+      const incoming = edges.filter((e) => e.toNodeId === gateNode.nodeId);
+      const satisfied = incoming.every((e) => {
+        const sourceState = byId.get(e.fromNodeId)?.state;
+        return sourceState === "completed" || sourceState === "released" || sourceState === "skipped" && e.omitOnSkip;
+      });
+      if (!satisfied) return false;
+      const spec = safeParseJson(gateNode.baseSpecJson);
+      const deadlineSeconds = typeof spec?.deadline_seconds === "number" ? spec.deadline_seconds : void 0;
+      const deadlineAt = deadlineSeconds && deadlineSeconds > 0 ? new Date(Date.parse(nowIso) + deadlineSeconds * 1e3).toISOString() : void 0;
+      graphStore.patchGate(gate.gateId, {
+        state: "awaiting_coordinator",
+        ...deadlineAt ? { deadlineAt } : {}
+      }, nowIso);
+      graphStore.updateNodeState(gateNode.graphId, gateNode.nodeId, "awaiting_coordinator", nowIso);
+      gateNode.state = "awaiting_coordinator";
+      byId.set(gateNode.nodeId, gateNode);
+      const block2 = coordinatorGateBlockReason(gate.gateId);
+      for (const edge of edges.filter((e) => e.fromNodeId === gateNode.nodeId)) {
+        const target = byId.get(edge.toNodeId);
+        if (!target || target.kind !== "worker_task" || !target.queueTaskId) continue;
+        if (target.state !== "declared" && target.state !== "blocked") continue;
+        if (target.state !== "blocked") {
+          graphStore.updateNodeState(target.graphId, target.nodeId, "blocked", nowIso);
+          target.state = "blocked";
+          byId.set(target.nodeId, target);
+        }
+        const entry = store.findQueueEntryById(target.meshId, target.queueTaskId);
+        if (!entry || entry.status !== "pending") continue;
+        const owned = !entry.blockedReason || parseGraphMaterializationBlock(entry.blockedReason) !== null || parseCoordinatorGateBlock(entry.blockedReason) !== null || entry.blockedReason.startsWith("materialization_error:");
+        if (owned && entry.blockedReason !== block2) {
+          entry.blockedReason = block2;
+          store.updateQueueEntry(entry);
+        }
+      }
+      graphStore.insertOutboxEvent({
+        id: newMeshGraphOutboxId(),
+        meshId: gateNode.meshId,
+        graphId: gateNode.graphId,
+        kind: "graph_gate_awaiting",
+        payload: JSON.stringify({
+          graphId: gateNode.graphId,
+          gateId: gate.gateId,
+          nodeId: gateNode.nodeId,
+          ref: gate.ref ?? gateNode.ref,
+          action: gate.action,
+          instructions: gate.instructions,
+          deadlineAt
+        }),
+        status: "pending",
+        attemptCount: 0,
+        createdAt: nowIso,
+        updatedAt: nowIso
+      });
+      const graph = graphStore.getGraph(gateNode.graphId);
+      if (graph?.status === "active") {
+        graphStore.updateGraphStatus(gateNode.graphId, "waiting_gate", nowIso);
+      }
+      return true;
+    }
+    function gateOutcomeOutputForNode(graphStore, gateNode) {
+      const gate = graphStore.findGateByNodeId(gateNode.graphId, gateNode.nodeId);
+      if (!gate || gate.state !== "released") return null;
+      const stored = typeof gate.releaseEvidenceJson === "string" ? safeParseJson(gate.releaseEvidenceJson) : void 0;
+      return {
+        ref: gateNode.ref ?? gate.ref ?? gateNode.nodeId,
+        envelope: {
+          gate_outcome: gate.releaseOutcome,
+          action: gate.action,
+          gate_id: gate.gateId,
+          ref: gate.ref ?? gateNode.ref,
+          result: stored?.result,
+          evidence: stored?.evidence,
+          evidence_digest: gate.releaseEvidenceDigest,
+          released_at: gate.updatedAt
+        }
+      };
+    }
     function settleDownstreamNode(store, target, edges, byId, nowIso) {
       const graphStore = store.graphStore();
       const incoming = edges.filter((e) => e.toNodeId === target.nodeId && e.kind !== "gate");
+      const gateIncoming = edges.filter((e) => e.toNodeId === target.nodeId && e.kind === "gate");
+      for (const edge of gateIncoming) {
+        if (byId.get(edge.fromNodeId)?.state !== "released") return { kind: "deferred" };
+      }
       const skippedSources = incoming.filter((e) => byId.get(e.fromNodeId)?.state === "skipped");
       const propagatingSkip = skippedSources.find((e) => !e.omitOnSkip);
       if (propagatingSkip) {
@@ -46132,6 +46507,12 @@ ${blocks.join("\n\n")}`;
       const queueEntry = store.findQueueEntryById(target.meshId, target.queueTaskId);
       if (!queueEntry) return { kind: "deferred" };
       const outputsByRef = collectUpstreamOutputs(store, activeIncoming, byId);
+      for (const edge of gateIncoming) {
+        const gateNode = byId.get(edge.fromNodeId);
+        if (!gateNode) continue;
+        const output = gateOutcomeOutputForNode(graphStore, gateNode);
+        if (output && !outputsByRef.has(output.ref)) outputsByRef.set(output.ref, output);
+      }
       const baseSpec = safeParseJson(target.baseSpecJson);
       let conditionsHold = true;
       let falseCondition;
@@ -46287,6 +46668,10 @@ ${blocks.join("\n\n")}`;
       }
       if (queueEntry.blockedReason?.startsWith("materialization_error:")) {
         delete queueEntry.blockedReason;
+        return;
+      }
+      if (parseCoordinatorGateBlock(queueEntry.blockedReason)) {
+        delete queueEntry.blockedReason;
       }
     }
     function syncNodeRowState(byId, target, state, patch) {
@@ -46375,6 +46760,7 @@ ${blocks.join("\n\n")}`;
       return result.materialized;
     }
     var GRAPH_BLOCK_PREFIX;
+    var GATE_BLOCK_PREFIX;
     var queueWakeHandler;
     var init_mesh_graph_transition_runner = __esm2({
       "src/mesh/mesh-graph-transition-runner.ts"() {
@@ -46386,7 +46772,9 @@ ${blocks.join("\n\n")}`;
         init_mesh_graph_types();
         init_mesh_graph_input_binding();
         init_mesh_graph_workspace_bind();
+        init_mesh_graph_derived_failure();
         GRAPH_BLOCK_PREFIX = "graph_materialization_pending:";
+        GATE_BLOCK_PREFIX = "coordinator_gate:";
       }
     });
     function formatMeshTaskModeViolations(result) {
@@ -48212,7 +48600,10 @@ ${blocks.join("\n\n")}`;
       return record2 ? { ...record2, status: normalizeMissionStatus(record2.status), source: normalizeMissionSource(record2.source) } : null;
     }
     function summarizeMissionTasks(meshId, missionId) {
-      const tasks = getQueue(meshId).filter((task) => task.missionId === missionId);
+      const queue = getQueue(meshId);
+      const tasks = queue.filter((task) => task.missionId === missionId);
+      const statusById = new Map(queue.map((task) => [task.id, task.status]));
+      const depMetaById = new Map(queue.map((task) => [task.id, { blockedReason: task.blockedReason, cancelReason: task.cancelReason, status: task.status }]));
       const aggregate = {
         total: tasks.length,
         pending: 0,
@@ -48229,7 +48620,9 @@ ${blocks.join("\n\n")}`;
         else if (task.status === "completed") aggregate.completed += 1;
         else if (task.status === "failed") aggregate.failed += 1;
         else if (task.status === "cancelled") aggregate.cancelled += 1;
-        if (task.status === "pending" && task.blockedReason) aggregate.blocked += 1;
+        if (task.status === "pending" && (task.blockedReason || deriveDependencyFailures(task.dependsOn, statusById, depMetaById).length > 0)) {
+          aggregate.blocked += 1;
+        }
         if (task.updatedAt && (!aggregate.lastActivityAt || task.updatedAt > aggregate.lastActivityAt)) {
           aggregate.lastActivityAt = task.updatedAt;
         }
@@ -48425,6 +48818,7 @@ ${blocks.join("\n\n")}`;
         init_logger();
         init_mesh_runtime_store();
         init_mesh_work_queue();
+        init_mesh_graph_derived_failure();
         init_mesh_task_stats();
         init_mesh_ledger();
         init_mesh_events_pending();
@@ -48857,13 +49251,14 @@ ${blocks.join("\n\n")}`;
     function resolveDependencyFailurePolicy(meshId) {
       try {
         const policy = getMesh(meshId)?.policy ?? {};
-        return policy.onDependencyFailure === "cancel" ? "cancel" : "block";
+        return resolveOnDependencyFailurePolicy(policy.onDependencyFailure ?? policy.on_dependency_failure);
       } catch {
         return "block";
       }
     }
     function propagateDependencyFailure(meshId, failedTaskId) {
       const policy = resolveDependencyFailurePolicy(meshId);
+      if (policy !== "cancel") return [];
       const store = MeshRuntimeStore.getInstance();
       const cancelled = [];
       const frontier = [failedTaskId];
@@ -48874,17 +49269,12 @@ ${blocks.join("\n\n")}`;
         for (const dependent of dependents) {
           if (seen.has(dependent.id)) continue;
           seen.add(dependent.id);
-          if (policy === "cancel") {
-            dependent.status = "cancelled";
-            dependent.cancelledAt = (/* @__PURE__ */ new Date()).toISOString();
-            dependent.cancelReason = `dependency_failed:${currentId}`;
-            store.updateQueueEntry(dependent);
-            cancelled.push(dependent);
-            frontier.push(dependent.id);
-          } else {
-            dependent.blockedReason = `dependency_failed:${currentId}`;
-            store.updateQueueEntry(dependent);
-          }
+          dependent.status = "cancelled";
+          dependent.cancelledAt = (/* @__PURE__ */ new Date()).toISOString();
+          dependent.cancelReason = `dependency_failed:${currentId}`;
+          store.updateQueueEntry(dependent);
+          cancelled.push(dependent);
+          frontier.push(dependent.id);
         }
       }
       return cancelled;
@@ -49180,12 +49570,13 @@ ${blocks.join("\n\n")}`;
       const deps = Array.isArray(entry.dependsOn) ? entry.dependsOn : [];
       return deps.every((depId) => statusById.get(depId) === "completed");
     }
-    function describeTaskDependencyState(entry, statusById) {
+    function describeTaskDependencyState(entry, statusById, depMetaById) {
       const deps = Array.isArray(entry.dependsOn) ? entry.dependsOn : [];
       const waitingOn = deps.filter((depId) => statusById.get(depId) !== "completed");
       return {
         waitingOn,
-        dependenciesSatisfied: taskDependenciesSatisfied(entry, statusById)
+        dependenciesSatisfied: taskDependenciesSatisfied(entry, statusById),
+        dependencyFailures: deriveDependencyFailures(entry.dependsOn, statusById, depMetaById)
       };
     }
     function getMeshQueueStats(meshId) {
@@ -49305,6 +49696,7 @@ ${blocks.join("\n\n")}`;
         init_mesh_task_inflight();
         init_mesh_turn_ledger();
         init_mesh_graph_transition_runner();
+        init_mesh_graph_derived_failure();
         init_dist();
         init_mesh_task_mode_guardrail();
         init_mesh_task_mode_guardrail();
@@ -49520,10 +49912,12 @@ ${blocks.join("\n\n")}`;
         CREATE INDEX IF NOT EXISTS idx_mesh_graph_outbox_graph
             ON mesh_graph_outbox(graph_id, status);
     `);
+      migrateLegacyDependencyFailedQueueBlocks(db);
     }
     var init_mesh_graph_schema = __esm2({
       "src/mesh/mesh-graph-schema.ts"() {
         "use strict";
+        init_mesh_graph_derived_failure();
       }
     });
     function mapGraphRow(r) {
@@ -49704,6 +50098,39 @@ ${blocks.join("\n\n")}`;
             ).get(meshId, batchId);
             return r ? mapGraphRow(r) : null;
           }
+          /**
+           * Phase-E graph listing for the graph view / metrics (design :759-775). Newest
+           * first so a view without an explicit graph id shows current work. `statuses`
+           * narrows to e.g. the in-flight set.
+           */
+          listGraphsByMesh(meshId, opts) {
+            const limit = Math.max(1, Math.min(opts?.limit ?? 50, 500));
+            const statuses = opts?.statuses;
+            if (statuses && statuses.length > 0) {
+              const placeholders = statuses.map(() => "?").join(",");
+              const rows2 = this.db.prepare(
+                `SELECT * FROM mesh_task_graphs WHERE mesh_id = ? AND status IN (${placeholders})
+                 ORDER BY created_at DESC LIMIT ?`
+              ).all(meshId, ...statuses, limit);
+              return rows2.map(mapGraphRow);
+            }
+            const rows = this.db.prepare(
+              `SELECT * FROM mesh_task_graphs WHERE mesh_id = ? ORDER BY created_at DESC LIMIT ?`
+            ).all(meshId, limit);
+            return rows.map(mapGraphRow);
+          }
+          /**
+           * Phase-E: replace the graph's normalized policy document. Used at plan-commit
+           * time to attach the enqueue-decision provenance record next to the persisted
+           * `on_dependency_failure` (design :697-710, :733-738). Deliberately a whole-
+           * document write — the policy is normalized once at commit and never patched
+           * field-by-field afterwards.
+           */
+          updateGraphPolicyJson(graphId, policyJson, nowIso) {
+            this.db.prepare(
+              `UPDATE mesh_task_graphs SET policy_json = ?, updated_at = ? WHERE graph_id = ?`
+            ).run(policyJson, nowIso, graphId);
+          }
           /** Phase-B rollup: graph status transition once every node reached a terminal-equivalent state. */
           updateGraphStatus(graphId, status, nowIso, terminal = false) {
             this.db.prepare(`
@@ -49893,6 +50320,79 @@ ${blocks.join("\n\n")}`;
             const r = this.db.prepare(`SELECT * FROM mesh_graph_gates WHERE gate_id = ?`).get(gateId);
             return r ? mapGateRow(r) : null;
           }
+          /** Reverse lookup from a graph node (kind `coordinator_gate`) to its gate row (phase C2). */
+          findGateByNodeId(graphId, nodeId) {
+            const r = this.db.prepare(
+              `SELECT * FROM mesh_graph_gates WHERE graph_id = ? AND node_id = ?`
+            ).get(graphId, nodeId);
+            return r ? mapGateRow(r) : null;
+          }
+          listGatesByGraph(graphId) {
+            const rows = this.db.prepare(
+              `SELECT * FROM mesh_graph_gates WHERE graph_id = ? ORDER BY created_at ASC`
+            ).all(graphId);
+            return rows.map(mapGateRow);
+          }
+          /** Phase-C2 timeout sweep: gates of one mesh, optionally narrowed to states (e.g. awaiting/claimed). */
+          listGatesByMesh(meshId, states) {
+            if (states && states.length > 0) {
+              const placeholders = states.map(() => "?").join(",");
+              const rows2 = this.db.prepare(
+                `SELECT * FROM mesh_graph_gates WHERE mesh_id = ? AND state IN (${placeholders}) ORDER BY created_at ASC`
+              ).all(meshId, ...states);
+              return rows2.map(mapGateRow);
+            }
+            const rows = this.db.prepare(
+              `SELECT * FROM mesh_graph_gates WHERE mesh_id = ? ORDER BY created_at ASC`
+            ).all(meshId);
+            return rows.map(mapGateRow);
+          }
+          /**
+           * Row write for phase C2 (claim / release / deadline sweep). `undefined`
+           * fields are left unchanged; explicit `null` clears a nullable field. The
+           * optional generation CAS rejects a stale fenced writer: the update lands
+           * only while the row still carries `cas.leaseGeneration`.
+           */
+          patchGate(gateId, patch, nowIso, cas) {
+            const current = this.getGate(gateId);
+            if (!current) return false;
+            if (cas && current.leaseGeneration !== cas.leaseGeneration) return false;
+            const next = {
+              state: patch.state ?? current.state,
+              leaseOwnerSessionId: patch.leaseOwnerSessionId === void 0 ? current.leaseOwnerSessionId ?? null : patch.leaseOwnerSessionId,
+              leaseGeneration: patch.leaseGeneration ?? current.leaseGeneration,
+              fencingToken: patch.fencingToken === void 0 ? current.fencingToken ?? null : patch.fencingToken,
+              leaseExpiresAt: patch.leaseExpiresAt === void 0 ? current.leaseExpiresAt ?? null : patch.leaseExpiresAt,
+              deadlineAt: patch.deadlineAt === void 0 ? current.deadlineAt ?? null : patch.deadlineAt,
+              releaseOutcome: patch.releaseOutcome === void 0 ? current.releaseOutcome ?? null : patch.releaseOutcome,
+              releaseEvidenceJson: patch.releaseEvidenceJson === void 0 ? current.releaseEvidenceJson ?? null : patch.releaseEvidenceJson,
+              releaseEvidenceDigest: patch.releaseEvidenceDigest === void 0 ? current.releaseEvidenceDigest ?? null : patch.releaseEvidenceDigest,
+              releaseIdempotencyKey: patch.releaseIdempotencyKey === void 0 ? current.releaseIdempotencyKey ?? null : patch.releaseIdempotencyKey
+            };
+            const r = this.db.prepare(`
+            UPDATE mesh_graph_gates
+            SET state = ?, lease_owner_session_id = ?, lease_generation = ?, fencing_token = ?,
+                lease_expires_at = ?, deadline_at = ?, release_outcome = ?,
+                release_evidence_json = ?, release_evidence_digest = ?,
+                release_idempotency_key = ?, updated_at = ?
+            WHERE gate_id = ? AND lease_generation = ?
+        `).run(
+              next.state,
+              next.leaseOwnerSessionId,
+              next.leaseGeneration,
+              next.fencingToken,
+              next.leaseExpiresAt,
+              next.deadlineAt,
+              next.releaseOutcome,
+              next.releaseEvidenceJson,
+              next.releaseEvidenceDigest,
+              next.releaseIdempotencyKey,
+              nowIso,
+              gateId,
+              current.leaseGeneration
+            );
+            return r.changes > 0;
+          }
           // ── mesh_graph_workspace_intents ─────────────────────────────────────────
           insertWorkspaceIntent(row) {
             this.db.prepare(`
@@ -56325,6 +56825,10 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
       if (policy.coordinatorIdlePushPolicy === "auto_silent_on_dispatch") {
         rules.push("- Delegated-worker completions are **auto-silenced**: the routine idle/completion push for a task you dispatch is suppressed once (approval-needed, failure, and long-running alerts still notify the owner normally)");
       }
+      const failurePolicy = policy.onDependencyFailure === "cancel" ? "cancel" : "block";
+      rules.push(
+        `- on_dependency_failure: **${failurePolicy}** \u2014 controls downstream tasks when a required worker task fails or is cancelled. \`block\` (default) keeps downstream pending and automatically recovers if the predecessor is retried and later completes. \`cancel\` terminally cancels the dependent branch; it is not revived by predecessor retry.`
+      );
       return `## Policy
 ${rules.join("\n")}`;
     }
@@ -56401,8 +56905,11 @@ 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) |
+| \`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_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_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 |
@@ -59764,6 +60271,593 @@ ${rendered}`, "utf-8");
         ACTIVE_SAGA_STATES = ["declared", "preparing", "compensating"];
       }
     });
+    function readGateSpec(node) {
+      if (!node) return {};
+      try {
+        const parsed = JSON.parse(node.baseSpecJson);
+        return parsed && typeof parsed === "object" ? parsed : {};
+      } catch {
+        return {};
+      }
+    }
+    function isoAfter(nowMs, seconds) {
+      return new Date(nowMs + seconds * 1e3).toISOString();
+    }
+    function claimMeshGraphGate(input) {
+      const store = MeshRuntimeStore.getInstance();
+      const nowMs = input.nowMs ?? Date.now();
+      const nowIso = new Date(nowMs).toISOString();
+      const outboxEvents = [];
+      const result = store.transaction(() => {
+        const graphStore = store.graphStore();
+        const gate = graphStore.getGate(input.gateId);
+        if (!gate || gate.meshId !== input.meshId) return { claimed: false, reason: "gate_not_found" };
+        if (gate.eligibleCoordinatorSessionId && gate.eligibleCoordinatorSessionId !== input.coordinatorSessionId) {
+          return { claimed: false, reason: "gate_not_eligible" };
+        }
+        if (gate.state === "released" || gate.state === "cancelled") {
+          return { claimed: false, reason: `gate_terminal:${gate.state}` };
+        }
+        if (gate.state === "declared") {
+          return { claimed: false, reason: "gate_not_awaiting" };
+        }
+        const leaseLive = !!gate.leaseExpiresAt && gate.leaseExpiresAt > nowIso;
+        const sameOwner = gate.leaseOwnerSessionId === input.coordinatorSessionId;
+        const priorState = gate.state;
+        let takeoverFromClaimed = false;
+        if (priorState === "claimed" && leaseLive && !sameOwner) {
+          return { claimed: false, reason: "gate_lease_held", gate };
+        }
+        if (priorState === "expired" && gate.onTimeout !== "hold") {
+          return { claimed: false, reason: "gate_terminal:expired", gate };
+        }
+        const node = graphStore.getNode(gate.graphId, gate.nodeId);
+        const spec = readGateSpec(node);
+        const leaseSeconds = input.leaseSeconds ?? spec.lease_seconds ?? MESH_GATE_DEFAULT_LEASE_SECONDS;
+        const leaseExpiresAt = isoAfter(nowMs, leaseSeconds);
+        let generation;
+        let fencingToken;
+        if (priorState === "claimed" && sameOwner && leaseLive) {
+          generation = gate.leaseGeneration;
+          fencingToken = gate.fencingToken;
+        } else {
+          takeoverFromClaimed = priorState === "claimed";
+          generation = gate.leaseGeneration + 1;
+          fencingToken = (0, import_crypto13.randomUUID)();
+        }
+        const deadlineAt = input.extendDeadlineSeconds && input.extendDeadlineSeconds > 0 ? isoAfter(nowMs, input.extendDeadlineSeconds) : gate.deadlineAt;
+        const won = graphStore.patchGate(gate.gateId, {
+          state: "claimed",
+          leaseOwnerSessionId: input.coordinatorSessionId,
+          leaseGeneration: generation,
+          fencingToken,
+          leaseExpiresAt,
+          ...deadlineAt !== void 0 ? { deadlineAt } : {}
+        }, nowIso, { leaseGeneration: gate.leaseGeneration });
+        if (!won) return { claimed: false, reason: "gate_claim_race" };
+        if (node && node.state === "expired") {
+          graphStore.updateNodeState(gate.graphId, gate.nodeId, "awaiting_coordinator", nowIso);
+        }
+        if (takeoverFromClaimed) {
+          outboxEvents.push({
+            kind: "graph_gate_lease_expired",
+            payload: {
+              graphId: gate.graphId,
+              gateId: gate.gateId,
+              ref: gate.ref,
+              previousOwnerSessionId: gate.leaseOwnerSessionId,
+              previousGeneration: gate.leaseGeneration,
+              newGeneration: generation
+            }
+          });
+        }
+        outboxEvents.push({
+          kind: "graph_gate_claimed",
+          payload: {
+            graphId: gate.graphId,
+            gateId: gate.gateId,
+            ref: gate.ref,
+            action: gate.action,
+            ownerSessionId: input.coordinatorSessionId,
+            generation,
+            leaseExpiresAt
+          }
+        });
+        for (const event of outboxEvents) {
+          graphStore.insertOutboxEvent({
+            id: newMeshGraphOutboxId(),
+            meshId: gate.meshId,
+            graphId: gate.graphId,
+            kind: event.kind,
+            payload: JSON.stringify(event.payload),
+            status: "pending",
+            attemptCount: 0,
+            createdAt: nowIso,
+            updatedAt: nowIso
+          });
+        }
+        return {
+          claimed: true,
+          gate: graphStore.getGate(gate.gateId),
+          leaseGeneration: generation,
+          fencingToken,
+          leaseExpiresAt,
+          deadlineAt,
+          ambiguousExternalOutcome: takeoverFromClaimed || priorState === "expired" && gate.leaseGeneration > 0,
+          previousLeaseOwnerSessionId: gate.leaseOwnerSessionId
+        };
+      });
+      if (result.claimed) {
+        try {
+          drainMeshGraphOutbox(input.meshId);
+        } catch {
+        }
+      }
+      return result;
+    }
+    function releaseMeshGraphGate(input) {
+      const store = MeshRuntimeStore.getInstance();
+      const nowMs = input.nowMs ?? Date.now();
+      const nowIso = new Date(nowMs).toISOString();
+      const result = store.transaction(() => {
+        const graphStore = store.graphStore();
+        const gate = graphStore.getGate(input.gateId);
+        if (!gate || gate.meshId !== input.meshId) throw new Error(`gate_not_found: no gate '${input.gateId}'`);
+        const releaseDigest = sha256Hex2(canonicalJson({
+          outcome: input.outcome,
+          result: input.result ?? null,
+          evidence: input.evidence ?? null,
+          patches: input.patches ?? []
+        }));
+        if (gate.releaseIdempotencyKey === input.idempotencyKey) {
+          if (gate.releaseEvidenceDigest === releaseDigest) {
+            return { released: true, duplicate: true, gate, materializedNodeIds: [] };
+          }
+          throw new Error(
+            `gate_release_conflict: idempotency key '${input.idempotencyKey}' already committed with a different release digest (gate '${input.gateId}')`
+          );
+        }
+        if (gate.state === "released") {
+          throw new Error(`gate_already_released: gate '${input.gateId}' was released under a different idempotency key`);
+        }
+        if (gate.state !== "claimed") {
+          throw new Error(`gate_not_claimed: gate '${input.gateId}' is '${gate.state}' \u2014 only a claimed gate can be released`);
+        }
+        if (input.fencingToken !== gate.fencingToken || input.leaseGeneration !== gate.leaseGeneration) {
+          throw new Error(
+            `stale_fence: gate '${input.gateId}' is at lease generation ${gate.leaseGeneration}; the presented token/generation (${input.leaseGeneration}) is stale`
+          );
+        }
+        if (gate.leaseExpiresAt && gate.leaseExpiresAt <= nowIso) {
+          throw new Error(
+            `gate_lease_expired: gate '${input.gateId}' lease expired at ${gate.leaseExpiresAt} \u2014 reclaim the gate (higher generation) and reconcile external evidence before releasing`
+          );
+        }
+        const node = graphStore.getNode(gate.graphId, gate.nodeId);
+        if (!node) throw new Error(`graph_node_not_found: gate '${input.gateId}' backs a missing node '${gate.nodeId}'`);
+        const nodes = graphStore.listNodes(gate.graphId);
+        const edges = graphStore.listEdges(gate.graphId);
+        const byId = new Map(nodes.map((n) => [n.nodeId, n]));
+        const incoming = edges.filter((e) => e.toNodeId === node.nodeId);
+        const upstreamSettled = incoming.every((e) => {
+          const sourceState = byId.get(e.fromNodeId)?.state;
+          return sourceState === "completed" || sourceState === "released" || sourceState === "skipped" && e.omitOnSkip;
+        });
+        if (!upstreamSettled) {
+          throw new Error(`gate_upstream_unsettled: gate '${input.gateId}' has unsatisfied predecessors`);
+        }
+        const directDownstream = new Set(edges.filter((e) => e.fromNodeId === node.nodeId).map((e) => e.toNodeId));
+        for (const patch of input.patches ?? []) {
+          const target = nodes.find((n) => n.nodeId === patch.node || n.ref === patch.node);
+          if (!target || !directDownstream.has(target.nodeId)) {
+            throw new Error(`gate_patch_not_downstream: '${patch.node}' is not a direct downstream node of gate '${input.gateId}'`);
+          }
+          for (const key2 of Object.keys(patch.baseSpecPatch)) {
+            if (!MESH_GATE_RELEASE_PATCH_KEYS.includes(key2)) {
+              throw new Error(`gate_patch_forbidden: key '${key2}' is outside the permitted release patch surface (design :294-299)`);
+            }
+          }
+          if (target.queueTaskId) {
+            const entry = store.findQueueEntryById(target.meshId, target.queueTaskId);
+            if (entry && entry.status !== "pending") {
+              throw new Error(
+                `task_already_claimed: gate release cannot patch node '${target.nodeId}' \u2014 queue task '${target.queueTaskId}' is '${entry.status}' and immutable (design :334)`
+              );
+            }
+          }
+          const rawSpec = (() => {
+            try {
+              return JSON.parse(target.baseSpecJson);
+            } catch {
+              return {};
+            }
+          })();
+          graphStore.updateNodeBaseSpec(
+            target.graphId,
+            target.nodeId,
+            JSON.stringify({ ...rawSpec && typeof rawSpec === "object" ? rawSpec : {}, ...patch.baseSpecPatch }),
+            nowIso
+          );
+          const inMap = byId.get(target.nodeId);
+          if (inMap) inMap.materializationVersion += 1;
+        }
+        const won = graphStore.patchGate(gate.gateId, {
+          state: "released",
+          releaseOutcome: input.outcome,
+          releaseEvidenceJson: canonicalJson({ result: input.result ?? null, evidence: input.evidence ?? null }),
+          releaseEvidenceDigest: releaseDigest,
+          releaseIdempotencyKey: input.idempotencyKey
+        }, nowIso, { leaseGeneration: gate.leaseGeneration });
+        if (!won) throw new Error(`stale_fence: gate '${input.gateId}' moved under the release (generation race)`);
+        graphStore.updateNodeState(gate.graphId, node.nodeId, "released", nowIso);
+        const mapped = byId.get(node.nodeId);
+        if (mapped) mapped.state = "released";
+        const materializedNodeIds = advanceReleasedGateDownstream(store, gate, node, nowIso);
+        const freshNodes = graphStore.listNodes(gate.graphId);
+        const graph = graphStore.getGraph(gate.graphId);
+        if (graph && freshNodes.every(isTerminalEquivalent)) {
+          graphStore.updateGraphStatus(gate.graphId, "completed", nowIso, true);
+          insertGateOutbox(graphStore, gate.meshId, gate.graphId, "graph_completed", { graphId: gate.graphId }, nowIso);
+        } 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);
+        }
+        insertGateOutbox(graphStore, gate.meshId, gate.graphId, "graph_gate_released", {
+          graphId: gate.graphId,
+          gateId: gate.gateId,
+          nodeId: node.nodeId,
+          ref: gate.ref,
+          action: gate.action,
+          outcome: input.outcome,
+          releaseDigest,
+          generation: gate.leaseGeneration,
+          materializedNodeIds
+        }, nowIso);
+        if (materializedNodeIds.length > 0) {
+          insertGateOutbox(graphStore, gate.meshId, gate.graphId, "queue_wake", {
+            meshId: gate.meshId,
+            reason: "graph_gate_released",
+            graphId: gate.graphId,
+            gateId: gate.gateId
+          }, nowIso);
+        }
+        return { released: true, duplicate: false, gate: graphStore.getGate(gate.gateId), materializedNodeIds };
+      });
+      try {
+        drainMeshGraphOutbox(input.meshId);
+      } catch {
+      }
+      return result;
+    }
+    function advanceReleasedGateDownstream(store, gate, gateNode, nowIso) {
+      const graphStore = store.graphStore();
+      const nodes = graphStore.listNodes(gate.graphId);
+      const edges = graphStore.listEdges(gate.graphId);
+      const byId = new Map(nodes.map((n) => [n.nodeId, n]));
+      const mappedGate = byId.get(gateNode.nodeId);
+      if (mappedGate) mappedGate.state = "released";
+      const materialized = [];
+      let frontier = /* @__PURE__ */ new Set([gateNode.nodeId]);
+      for (let pass = 0; pass < nodes.length + 1 && frontier.size > 0; pass += 1) {
+        const nextFrontier = /* @__PURE__ */ new Set();
+        const downstreamIds = new Set(edges.filter((e) => frontier.has(e.fromNodeId)).map((e) => e.toNodeId));
+        for (const targetId of downstreamIds) {
+          const target = byId.get(targetId);
+          if (!target) continue;
+          if (target.kind === "coordinator_gate") {
+            maybeOpenCoordinatorGate(store, target, edges, byId, nowIso);
+            continue;
+          }
+          if (target.kind !== "worker_task" || !target.queueTaskId) continue;
+          if (target.state !== "declared" && target.state !== "blocked") continue;
+          clearReleasedGateHold(store, target, gate.gateId);
+          const outcome = settleDownstreamNode(store, target, edges, byId, nowIso);
+          if (outcome.kind === "materialized") {
+            materialized.push(target.nodeId);
+            insertGateOutbox(graphStore, target.meshId, target.graphId, "graph_node_materialized", {
+              graphId: target.graphId,
+              nodeId: target.nodeId,
+              ref: target.ref,
+              taskId: target.queueTaskId,
+              gateId: gate.gateId,
+              materializationVersion: target.materializationVersion,
+              digest: outcome.digest,
+              receipts: outcome.receipts
+            }, nowIso);
+          } else if (outcome.kind === "skipped") {
+            nextFrontier.add(target.nodeId);
+            insertGateOutbox(graphStore, target.meshId, target.graphId, "graph_node_skipped", {
+              graphId: target.graphId,
+              nodeId: target.nodeId,
+              ref: target.ref,
+              taskId: target.queueTaskId,
+              gateId: gate.gateId,
+              reason: outcome.reason
+            }, nowIso);
+          } else if (outcome.kind === "error") {
+            insertGateOutbox(graphStore, target.meshId, target.graphId, "graph_node_materialization_failed", {
+              graphId: target.graphId,
+              nodeId: target.nodeId,
+              ref: target.ref,
+              taskId: target.queueTaskId,
+              gateId: gate.gateId,
+              blockedReason: outcome.blockedReason
+            }, nowIso);
+          } else {
+            const entry = store.findQueueEntryById(target.meshId, target.queueTaskId);
+            if (entry && entry.status === "pending" && !entry.blockedReason) {
+              entry.blockedReason = graphMaterializationBlockReason(target.nodeId, target.materializationVersion);
+              store.updateQueueEntry(entry);
+            }
+          }
+        }
+        frontier = nextFrontier;
+      }
+      return materialized;
+    }
+    function clearReleasedGateHold(store, target, gateId) {
+      if (!target.queueTaskId) return;
+      const entry = store.findQueueEntryById(target.meshId, target.queueTaskId);
+      if (!entry || entry.status !== "pending") return;
+      const hold = parseCoordinatorGateBlock(entry.blockedReason);
+      if (hold && hold.gateId === gateId) {
+        delete entry.blockedReason;
+        store.updateQueueEntry(entry);
+      }
+    }
+    function sweepMeshGraphGateTimeouts(meshId, nowMs) {
+      const store = MeshRuntimeStore.getInstance();
+      const now = nowMs ?? Date.now();
+      const nowIso = new Date(now).toISOString();
+      const result = store.transaction(() => {
+        const graphStore = store.graphStore();
+        const candidates = graphStore.listGatesByMesh(meshId, ["awaiting_coordinator", "claimed"]);
+        const expiredLeaseGateIds = candidates.filter((g) => g.state === "claimed" && g.leaseExpiresAt && g.leaseExpiresAt <= nowIso).map((g) => g.gateId);
+        const expiredGateIds = [];
+        for (const gate of candidates) {
+          if (!gate.deadlineAt || gate.deadlineAt > nowIso) continue;
+          const node = graphStore.getNode(gate.graphId, gate.nodeId);
+          const won = graphStore.patchGate(gate.gateId, { state: "expired" }, nowIso, { leaseGeneration: gate.leaseGeneration });
+          if (!won) continue;
+          if (node && node.state !== "expired") {
+            graphStore.updateNodeState(gate.graphId, gate.nodeId, "expired", nowIso);
+          }
+          let cancelledNodeIds = [];
+          if (gate.onTimeout === "cancel_downstream" && node) {
+            cancelledNodeIds = cancelGateDownstreamSubtree(store, node, nowIso);
+          } else if (gate.onTimeout === "fail_graph") {
+            graphStore.updateGraphStatus(gate.graphId, "failed", nowIso, true);
+          }
+          insertGateOutbox(graphStore, gate.meshId, gate.graphId, "graph_gate_expired", {
+            graphId: gate.graphId,
+            gateId: gate.gateId,
+            nodeId: gate.nodeId,
+            ref: gate.ref,
+            action: gate.action,
+            policy: gate.onTimeout,
+            deadlineAt: gate.deadlineAt,
+            urgent: true,
+            ...cancelledNodeIds.length > 0 ? { cancelledNodeIds } : {}
+          }, nowIso);
+          expiredGateIds.push(gate.gateId);
+        }
+        return { expiredGateIds, expiredLeaseGateIds };
+      });
+      if (result.expiredGateIds.length > 0) {
+        try {
+          drainMeshGraphOutbox(meshId);
+        } catch {
+        }
+      }
+      if (result.expiredGateIds.length > 0 || result.expiredLeaseGateIds.length > 0) {
+        LOG2.info("MeshGraph", `Gate sweep for mesh ${meshId}: expired=[${result.expiredGateIds.join(",")}] lease-lapsed=[${result.expiredLeaseGateIds.join(",")}]`);
+      }
+      return result;
+    }
+    function isCancelExempt(state) {
+      return state === "completed" || state === "released" || state === "skipped" || state === "cancelled" || state === "failed" || state === "expired";
+    }
+    function cancelGateDownstreamSubtree(store, gateNode, nowIso) {
+      const graphStore = store.graphStore();
+      const nodes = graphStore.listNodes(gateNode.graphId);
+      const edges = graphStore.listEdges(gateNode.graphId);
+      const byId = new Map(nodes.map((n) => [n.nodeId, n]));
+      const cancelled = [];
+      const visited = /* @__PURE__ */ new Set([gateNode.nodeId]);
+      let frontier = [gateNode.nodeId];
+      while (frontier.length > 0) {
+        const next = [];
+        for (const id of frontier) {
+          for (const edge of edges.filter((e) => e.fromNodeId === id)) {
+            if (visited.has(edge.toNodeId)) continue;
+            visited.add(edge.toNodeId);
+            const target = byId.get(edge.toNodeId);
+            if (!target || isCancelExempt(target.state)) continue;
+            graphStore.updateNodeState(target.graphId, target.nodeId, "cancelled", nowIso, {
+              failureReason: `coordinator_gate_timeout:${gateNode.nodeId}`
+            });
+            if (target.queueTaskId) {
+              const entry = store.findQueueEntryById(target.meshId, target.queueTaskId);
+              if (entry && entry.status === "pending") {
+                entry.status = "cancelled";
+                entry.blockedReason = `coordinator_gate_timeout:${gateNode.nodeId}`;
+                store.updateQueueEntry(entry);
+              }
+            }
+            cancelled.push(target.nodeId);
+            next.push(target.nodeId);
+          }
+        }
+        frontier = next;
+      }
+      return cancelled;
+    }
+    function insertGateOutbox(graphStore, meshId, graphId, kind, payload, nowIso) {
+      graphStore.insertOutboxEvent({
+        id: newMeshGraphOutboxId(),
+        meshId,
+        graphId,
+        kind,
+        payload: JSON.stringify(payload),
+        status: "pending",
+        attemptCount: 0,
+        createdAt: nowIso,
+        updatedAt: nowIso
+      });
+    }
+    var import_crypto13;
+    var MESH_GATE_DEFAULT_LEASE_SECONDS;
+    var MESH_GATE_NAMED_OUTCOMES;
+    var MESH_GATE_RELEASE_PATCH_KEYS;
+    var init_mesh_graph_gates = __esm2({
+      "src/mesh/mesh-graph-gates.ts"() {
+        "use strict";
+        import_crypto13 = require("crypto");
+        init_mesh_runtime_store();
+        init_logger();
+        init_mesh_graph_input_binding();
+        init_mesh_graph_types();
+        init_mesh_graph_transition_runner();
+        init_mesh_graph_transition_runner();
+        MESH_GATE_DEFAULT_LEASE_SECONDS = 900;
+        MESH_GATE_NAMED_OUTCOMES = ["passed", "failed", "rejected"];
+        MESH_GATE_RELEASE_PATCH_KEYS = ["run_if", "on_false", "inputs_from", "workspace_ref"];
+      }
+    });
+    function normalizeOrchestrationDecision(raw, surface) {
+      const source = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+      const readCount = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : void 0;
+      const readyWorkerTasks = readCount(source.ready_worker_tasks ?? source.readyWorkerTasks);
+      const knownGraphSteps = readCount(source.known_graph_steps ?? source.knownGraphSteps);
+      const rawReason = source.single_reason ?? source.singleReason;
+      const singleReason = typeof rawReason === "string" && rawReason.trim() ? rawReason.trim() : null;
+      const rawBlockers = source.capability_blockers ?? source.capabilityBlockers;
+      const blockers = Array.isArray(rawBlockers) ? rawBlockers.filter((b) => typeof b === "string" && b.trim().length > 0).map((b) => b.trim()) : [];
+      const decision = {
+        decision: surface,
+        ...readyWorkerTasks !== void 0 ? { ready_worker_tasks: readyWorkerTasks } : {},
+        ...knownGraphSteps !== void 0 ? { known_graph_steps: knownGraphSteps } : {},
+        single_reason: surface === "single" ? singleReason : null,
+        ...blockers.length > 0 ? { capability_blockers: blockers } : {}
+      };
+      const result = { decision };
+      if (surface !== "single") return result;
+      const superseded = [singleReason, ...blockers].find(
+        (value) => !!value && MESH_SUPERSEDED_SINGLE_REASONS.includes(value)
+      );
+      if (superseded) {
+        result.batchCapabilityAvailable = {
+          code: "batch_capability_available",
+          reportedReason: superseded,
+          message: `'${superseded}' is no longer a blocker: mesh_enqueue_batch supports selected predecessor outputs (inputs_from), delayed worktree preparation (workspace_ref) and coordinator gates. Declare the whole known plan in one batch instead of enqueueing the steps separately.`
+        };
+      }
+      if (knownGraphSteps !== void 0 && knownGraphSteps >= 2) {
+        result.declaredEligibleSingle = true;
+      }
+      return result;
+    }
+    function safeAppend(meshId, kind, payload, taskId) {
+      try {
+        appendLedgerEntry(meshId, { kind, ...taskId ? { taskId } : {}, payload });
+      } catch (e) {
+        LOG2.warn("MeshGraph", `Ledger provenance append (${kind}) failed: ${e?.message || e}`);
+      }
+    }
+    function recordGraphEnqueueCommitted(meshId, p) {
+      safeAppend(meshId, "graph_enqueue_committed", {
+        graphId: p.graphId,
+        batchId: p.batchId,
+        enqueueSurface: p.enqueueSurface,
+        schemaVersion: p.schemaVersion,
+        planDigest: p.planDigest,
+        ...p.missionId ? { missionId: p.missionId } : {},
+        ...p.coordinatorSessionId ? { coordinatorSessionId: p.coordinatorSessionId } : {},
+        taskCount: p.taskCount,
+        gateCount: p.gateCount,
+        workspaceCount: p.workspaceCount,
+        dependencyEdgeCount: p.dependencyEdgeCount,
+        onDependencyFailure: p.onDependencyFailure,
+        ...p.orchestrationDecision ? { orchestrationDecision: p.orchestrationDecision } : {},
+        ...p.replayed ? { replayed: true } : {}
+      });
+    }
+    function recordGraphEnqueueValidationFailed(meshId, p) {
+      safeAppend(meshId, "graph_enqueue_validation_failed", {
+        code: p.code,
+        ...p.batchId ? { batchId: p.batchId } : {},
+        ...p.taskCount !== void 0 ? { taskCount: p.taskCount } : {},
+        ...p.gateCount !== void 0 ? { gateCount: p.gateCount } : {},
+        ...p.workspaceCount !== void 0 ? { workspaceCount: p.workspaceCount } : {},
+        ...p.orchestrationDecision ? { orchestrationDecision: p.orchestrationDecision } : {}
+      });
+    }
+    function recordGraphEnqueueRolledBack(meshId, p) {
+      safeAppend(meshId, "graph_enqueue_rolled_back", {
+        code: p.code,
+        ...p.batchId ? { batchId: p.batchId } : {},
+        ...p.taskCount !== void 0 ? { taskCount: p.taskCount } : {},
+        // The error STRING is a validation message authored by this codebase
+        // (never worker output or a task message), so it is safe provenance.
+        ...p.error ? { error: p.error.slice(0, 500) } : {}
+      });
+    }
+    function recordGraphGateClaimed(meshId, p) {
+      safeAppend(meshId, "graph_gate_claimed", {
+        graphId: p.graphId,
+        gateId: p.gateId,
+        ...p.ref ? { ref: p.ref } : {},
+        action: p.action,
+        generation: p.generation,
+        ownerSessionId: p.ownerSessionId,
+        ...p.leaseExpiresAt ? { leaseExpiresAt: p.leaseExpiresAt } : {},
+        ...p.ambiguousExternalOutcome ? { ambiguousExternalOutcome: true } : {},
+        ...p.previousLeaseOwnerSessionId ? { previousLeaseOwnerSessionId: p.previousLeaseOwnerSessionId } : {}
+      });
+    }
+    function recordGraphGateReleased(meshId, p) {
+      safeAppend(meshId, "graph_gate_released", {
+        graphId: p.graphId,
+        gateId: p.gateId,
+        ...p.ref ? { ref: p.ref } : {},
+        action: p.action,
+        outcome: p.outcome,
+        generation: p.generation,
+        ...p.releaseDigest ? { releaseDigest: p.releaseDigest } : {},
+        ...p.materializedNodeIds?.length ? { materializedNodeIds: p.materializedNodeIds } : {},
+        ...p.duplicate ? { duplicate: true } : {}
+      });
+    }
+    function recordGraphGateExpired(meshId, p) {
+      safeAppend(meshId, "graph_gate_expired", {
+        gateId: p.gateId,
+        ...p.graphId ? { graphId: p.graphId } : {},
+        policy: p.policy,
+        ...p.deadlineAt ? { deadlineAt: p.deadlineAt } : {},
+        ...p.cancelledNodeIds?.length ? { cancelledNodeIds: p.cancelledNodeIds } : {}
+      });
+    }
+    var MESH_VALID_SINGLE_REASONS;
+    var MESH_SUPERSEDED_SINGLE_REASONS;
+    var init_mesh_graph_provenance = __esm2({
+      "src/mesh/mesh-graph-provenance.ts"() {
+        "use strict";
+        init_mesh_ledger();
+        init_logger();
+        MESH_VALID_SINGLE_REASONS = [
+          "only_one_step_known",
+          "future_step_not_specifiable",
+          "same_session_continuation",
+          "legacy_client",
+          "operator_override"
+        ];
+        MESH_SUPERSEDED_SINGLE_REASONS = [
+          "output_needed",
+          "workspace_unresolved",
+          "coordinator_action_between"
+        ];
+      }
+    });
     function turnProjectionActiveWorkStatus(meshId, taskId) {
       const row = resolveTurnAttemptRow({ meshId, taskId });
       if (!row) return null;
@@ -61805,15 +62899,15 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return "";
     }
-    function extractFinalAssistantSummaryEvidence(messages, maxChars = DEFAULT_FINAL_SUMMARY_MAX_CHARS) {
-      const turnEnd = selectFinalAssistantTurnEndMessage(messages);
+    function extractFinalAssistantSummaryEvidence(messages, maxChars = DEFAULT_FINAL_SUMMARY_MAX_CHARS, opts) {
+      const turnEnd = selectFinalAssistantTurnEndMessage(messages, opts);
       if (!turnEnd) return { finalSummary: "" };
       return {
         finalSummary: flattenContent(turnEnd.content).trim().slice(0, maxChars),
         transcriptMessageAt: readChatMessageTimestampIso(turnEnd)
       };
     }
-    function selectFinalAssistantTurnEndMessage(messages) {
+    function selectFinalAssistantTurnEndMessage(messages, opts) {
       if (!Array.isArray(messages) || messages.length === 0) return null;
       let chromeFallbacks = 0;
       for (let i = messages.length - 1; i >= 0; i--) {
@@ -61828,6 +62922,13 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             chromeFallbacks++;
             continue;
           }
+          const boundaryMs = opts?.turnStartedAtMs;
+          if (typeof boundaryMs === "number" && Number.isFinite(boundaryMs)) {
+            const msgAt = readChatMessageTimestampMs(msg);
+            if (typeof msgAt === "number" && Number.isFinite(msgAt) && msgAt >= boundaryMs && msgAt - boundaryMs < FINAL_ANSWER_MIN_TURN_AGE_MS && Date.now() - msgAt < FINAL_ANSWER_MIN_TURN_AGE_MS) {
+              return null;
+            }
+          }
           return msg;
         }
         return null;
@@ -62164,6 +63265,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       return (Array.isArray(messages) ? messages : []).filter((message) => classifyChatMessageVisibility(message).surface === surface);
     }
     var DEFAULT_FINAL_SUMMARY_MAX_CHARS;
+    var FINAL_ANSWER_MIN_TURN_AGE_MS;
     var FINAL_SUMMARY_CHROME_FALLBACK_MAX_DEPTH;
     var TRANSCRIPT_CHROME_HARD_LINE_PATTERNS;
     var TRANSCRIPT_CHROME_PANEL_LINE_PATTERNS;
@@ -62187,6 +63289,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         "use strict";
         init_contracts2();
         DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16e3;
+        FINAL_ANSWER_MIN_TURN_AGE_MS = 3e4;
         FINAL_SUMMARY_CHROME_FALLBACK_MAX_DEPTH = 2;
         TRANSCRIPT_CHROME_HARD_LINE_PATTERNS = [
           // Bottom status bar: "auto  K3 thinking: high  ~/Work/adhdev  main [±]"
@@ -66765,7 +67868,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const fingerprint = `${target}::${buildPendingEventFingerprint(fingerprintSource)}`;
       try {
         const inserted = store.insertPendingEvent({
-          id: (0, import_crypto13.randomUUID)(),
+          id: (0, import_crypto15.randomUUID)(),
           meshId: UNRESOLVED_FORWARD_OUTBOX_MESH_ID,
           coordinatorDaemonId: target,
           event,
@@ -66828,14 +67931,14 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         return 0;
       }
     }
-    var import_crypto13;
+    var import_crypto15;
     var UNRESOLVED_FORWARD_OUTBOX_MESH_ID;
     var UNRESOLVED_FORWARD_MAX_AGE_MS;
     var retryNudgeHandler;
     var init_mesh_unresolved_forward_outbox = __esm2({
       "src/mesh/mesh-unresolved-forward-outbox.ts"() {
         "use strict";
-        import_crypto13 = require("crypto");
+        import_crypto15 = require("crypto");
         init_logger();
         init_mesh_runtime_store();
         init_mesh_events_pending();
@@ -69514,6 +70617,15 @@ ${cleanBody}`;
               }
             };
           }
+          if (admission.kind === "admit") {
+            traceMeshEventStage(
+              "terminal_admission_admitted",
+              traceCtx,
+              `${admission.evidenceLevel}:${admission.reason}`
+            );
+          } else {
+            traceMeshEventStage("terminal_admission_not_enforced", traceCtx, admission.reason);
+          }
         }
         if (!readNonEmptyString(args.metadataEvent.taskId) && !sessionHasActiveAssignment(args.meshId, eventSessionId) && !findRecentTerminalLedgerEvidence({ meshId: args.meshId, sessionId: eventSessionId, nodeId: eventNodeId || void 0 }) && isWeakCompletionEvidence(args.metadataEvent)) {
           LOG2.info("MeshEvents", `Suppressed agent:generating_completed for session ${eventSessionId} (mesh ${args.meshId}): no taskId, no active assignment, and no prior terminal ledger evidence \u2014 a pre-dispatch startup/greeting artifact, not a real task completion`);
@@ -69876,13 +70988,13 @@ ${cleanBody}`;
         const emittedAfterFinalizationTimeout = completionDiagnostic?.emittedAfterFinalizationTimeout === true;
         const weakEvidenceAtEntry = isWeakCompletionEvidence(args.metadataEvent);
         const weakCompleted = outcome === "completed" && weakEvidenceAtEntry && !emittedAfterFinalizationTimeout;
-        if (outcome === "completed" && emittedAfterFinalizationTimeout && weakEvidenceAtEntry) {
+        if (emittedAfterFinalizationTimeout && weakEvidenceAtEntry) {
           args.metadataEvent.reviewRecommended = true;
           args.metadataEvent.completionDiagnostic = {
             ...completionDiagnostic || {},
             timedOutWithoutFinalAssistant: true
           };
-          LOG2.info("MeshQueue", `Completion for session ${sessionId} exhausted the finalization wait with no confirmed final assistant \u2014 flipping terminal (never wedge) but flagged reviewRecommended`);
+          LOG2.info("MeshQueue", `Completion for session ${sessionId} exhausted the finalization wait with no confirmed final assistant \u2014 recording FORCED TERMINATION (outcome=${outcome}; terminal, never wedge) flagged reviewRecommended; NOT a completion`);
         }
         let reducerAllowsFlip = true;
         if (eventTaskId && !weakCompleted) {
@@ -70006,6 +71118,7 @@ ${cleanBody}`;
         return task ? { id: task.id, taskMode: task.taskMode } : null;
       }
       let completedTaskForLedger = null;
+      let forcedTimeoutNoResponse = false;
       let directDispatchTaskIdForLedger;
       let worktreeHasQueuedTask = false;
       if (args.event === "agent:generating_completed") {
@@ -70015,7 +71128,8 @@ ${cleanBody}`;
         if (sessionId) {
           directDispatchTaskIdForLedger = readNonEmptyString(args.metadataEvent.taskId) || resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
           const isFalseIdle = isFalseIdleCompletion(args.metadataEvent);
-          completedTaskForLedger = markSessionTerminal(sessionId, "completed", eventTimestamp, { tentativeIfDirect: isFalseIdle });
+          forcedTimeoutNoResponse = isWeakCompletionEvidence(args.metadataEvent) && (args.metadataEvent.completionDiagnostic && typeof args.metadataEvent.completionDiagnostic === "object" && args.metadataEvent.completionDiagnostic.emittedAfterFinalizationTimeout === true) === true;
+          completedTaskForLedger = markSessionTerminal(sessionId, forcedTimeoutNoResponse ? "failed" : "completed", eventTimestamp, { tentativeIfDirect: isFalseIdle });
           if (nodeId && providerType) {
             if (!isFalseIdle) {
               sweepExpiredRemoteIdleSessions();
@@ -70038,7 +71152,7 @@ ${cleanBody}`;
             }
           }
           const completedTaskId = completedTaskForLedger?.id;
-          if (completedTaskId && hasPendingDependents(args.meshId, completedTaskId)) {
+          if (completedTaskId && !forcedTimeoutNoResponse && hasPendingDependents(args.meshId, completedTaskId)) {
             setImmediate(() => {
               triggerMeshQueue(components, args.meshId).catch((e) => {
                 LOG2.warn("MeshQueue", `Dependent wake after task ${completedTaskId} failed: ${e?.message || e}`);
@@ -70264,7 +71378,7 @@ ${cleanBody}`;
           });
         });
       }
-      const ledgerKind = EVENT_TO_LEDGER_KIND[args.event];
+      const ledgerKind = forcedTimeoutNoResponse ? "task_failed" : EVENT_TO_LEDGER_KIND[args.event];
       if (ledgerKind) {
         try {
           const ledgerNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0;
@@ -72466,6 +73580,20 @@ ${cleanBody}`;
       }
       return newest;
     }
+    function escapeTailFingerprint(messages) {
+      let fp = "";
+      for (const msg of messages) {
+        if (!msg) continue;
+        const ts2 = readChatMessageTimestampMs(msg) ?? 0;
+        let len = -1;
+        try {
+          len = JSON.stringify(msg.content)?.length ?? -1;
+        } catch {
+        }
+        fp += `${msg.role}:${ts2}:${len};`;
+      }
+      return fp;
+    }
     async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds, localDaemonId) {
       const dispatches = getActiveDirectDispatches(mesh.id);
       rehydrateAckedHoldsForMesh(mesh.id);
@@ -72476,6 +73604,9 @@ ${cleanBody}`;
       for (const key2 of heldKeys) {
         if (!activeTaskKeys.has(key2)) deleteHoldState(key2, mesh.id);
       }
+      for (const key2 of [...nonIdleEscapeTracks.keys()]) {
+        if (key2.startsWith(`${mesh.id}::`) && !activeTaskKeys.has(key2)) nonIdleEscapeTracks.delete(key2);
+      }
       if (dispatches.length === 0) return;
       const dispatchMeshCommand = components.dispatchMeshCommand;
       const nodeById = new Map(mesh.nodes.map((n) => [n.id, n]));
@@ -72540,23 +73671,43 @@ ${cleanBody}`;
           consecutiveReadFailures: 0,
           ...priorHoldState?.transcriptIdleSinceMs !== void 0 ? { transcriptIdleSinceMs: priorHoldState.transcriptIdleSinceMs } : {}
         });
-        let nonIdleEscapeSinceAckMs = null;
         const nowMs = Date.now();
         if (readChatPayloadStatus(payload) !== "idle") {
           if (isAcked && readChatPayloadStatus(payload) === "generating") {
-            const escapeAckedAtMs = Date.parse(readNonEmptyString(dispatch.updatedAt));
-            const escapeSinceAckMs = Number.isFinite(escapeAckedAtMs) ? nowMs - escapeAckedAtMs : Number.POSITIVE_INFINITY;
-            if (escapeSinceAckMs >= resolveAckedDeathDeadlineMs()) {
-              nonIdleEscapeSinceAckMs = escapeSinceAckMs;
+            const escapeMessages = Array.isArray(payload.messages) ? payload.messages : [];
+            const fingerprint = escapeTailFingerprint(escapeMessages);
+            const prior = nonIdleEscapeTracks.get(synthKey);
+            if (!prior || prior.tailFingerprint !== fingerprint) {
+              nonIdleEscapeTracks.set(synthKey, { anchorMs: nowMs, tailFingerprint: fingerprint, candidateRecorded: false });
+              if (prior) {
+                LOG2.info("MeshReconcile", `Non-idle escape re-armed: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) reads 'generating' and its transcript tail moved \u2014 worker is alive mid-turn; the escape deadline restarts from now`);
+              }
+            } else {
+              const staticMs = nowMs - prior.anchorMs;
+              if (staticMs >= resolveAckedDeathDeadlineMs() && !prior.candidateRecorded) {
+                prior.candidateRecorded = true;
+                const candidateEvidence = extractFinalAssistantSummaryEvidence(escapeMessages);
+                LOG2.warn("MeshReconcile", `Non-idle escape WEAK CANDIDATE (no completion): task ${taskId} on node ${nodeId} (mesh ${mesh.id}) has read 'generating' with a static transcript tail for ${Math.round(staticMs / 1e3)}s (deadline ${Math.round(resolveAckedDeathDeadlineMs() / 1e3)}s)${candidateEvidence.finalSummary ? " and a final-looking assistant bubble" : ""} \u2014 recorded as a weak candidate only; NOT completed (a timeout is never completion evidence); the hold/reclaim nets own the terminal`);
+                traceMeshEventDrop("non_idle_escape_weak_candidate_held", {
+                  taskId,
+                  sessionId,
+                  nodeId,
+                  meshId: mesh.id,
+                  event: "agent:generating_completed"
+                }, `staticTailMs=${staticMs} finalAssistant=${candidateEvidence.finalSummary ? "present" : "absent"} transcriptAt=${candidateEvidence.transcriptMessageAt ?? "n/a"}`);
+              }
             }
           }
-          if (nonIdleEscapeSinceAckMs === null) {
-            setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
-            continue;
-          }
+          setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
+          continue;
         }
         const messages = Array.isArray(payload.messages) ? payload.messages : [];
-        const evidence = extractFinalAssistantSummaryEvidence(messages);
+        const dispatchedAtMs = Date.parse(readNonEmptyString(dispatch.dispatchedAt));
+        const evidence = extractFinalAssistantSummaryEvidence(
+          messages,
+          void 0,
+          Number.isFinite(dispatchedAtMs) ? { turnStartedAtMs: dispatchedAtMs } : void 0
+        );
         if (hasTrailingToolActivityAfterFinalAssistant(messages)) {
           setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
           LOG2.info("MeshReconcile", `Mid-turn causal admission: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) \u2014 the latest final-looking assistant bubble is followed by trailing tool/terminal activity (interim narration; the turn is still executing); holding the transcript synth`);
@@ -72588,7 +73739,7 @@ ${cleanBody}`;
           const deathDeadlineMs = resolveAckedDeathDeadlineMs();
           const holdState = getHoldState(synthKey, mesh.id);
           let fastTrackReady = false;
-          if (nonIdleEscapeSinceAckMs === null && evidence.finalSummary) {
+          if (evidence.finalSummary) {
             const idleSinceMs = holdState?.transcriptIdleSinceMs ?? nowMs;
             if (holdState && holdState.transcriptIdleSinceMs === void 0) {
               setHoldState(synthKey, mesh.id, { ...holdState, transcriptIdleSinceMs: idleSinceMs });
@@ -72609,9 +73760,7 @@ ${cleanBody}`;
           }
           if (!fastTrackReady) {
             backstopKind = "ackedHoldDeathDeadlineFired";
-            if (nonIdleEscapeSinceAckMs === null) {
-              LOG2.warn("MeshReconcile", `Acked-hold death deadline reached: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) still idle ${Math.round(sinceAckMs / 1e3)}s after the ack (deadline ${Math.round(deathDeadlineMs / 1e3)}s) \u2014 synthesizing the missing completion as a notification-loss net (a real emit, if it ever lands, no-ops idempotently).`);
-            }
+            LOG2.warn("MeshReconcile", `Acked-hold death deadline reached: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) still idle ${Math.round(sinceAckMs / 1e3)}s after the ack (deadline ${Math.round(deathDeadlineMs / 1e3)}s) \u2014 synthesizing the missing completion as a notification-loss net (a real emit, if it ever lands, no-ops idempotently).`);
           }
         }
         if (realTerminalEmitPendingForTask(mesh.id, taskId)) {
@@ -72620,21 +73769,8 @@ ${cleanBody}`;
           continue;
         }
         if (!evidence.finalSummary) continue;
-        const dispatchedAtMs = Date.parse(readNonEmptyString(dispatch.dispatchedAt));
         const transcriptAtMs = Date.parse(evidence.transcriptMessageAt ?? "");
-        if (nonIdleEscapeSinceAckMs !== null) {
-          if (!Number.isFinite(dispatchedAtMs) || !Number.isFinite(transcriptAtMs) || transcriptAtMs < dispatchedAtMs) {
-            LOG2.info("MeshReconcile", `Non-idle-escape stale-summary guard: refusing transcript synth for task ${taskId} on node ${nodeId} (mesh ${mesh.id}) \u2014 final assistant message (${evidence.transcriptMessageAt ?? "unparseable"}) is not provably at/after this task's dispatch (${dispatch.dispatchedAt})`);
-            traceMeshEventDrop("reconcile_non_idle_escape_stale_summary", {
-              taskId,
-              sessionId,
-              nodeId,
-              meshId: mesh.id,
-              event: "agent:generating_completed"
-            }, `transcriptAt=${evidence.transcriptMessageAt} dispatchedAt=${dispatch.dispatchedAt}`);
-            continue;
-          }
-        } else if (Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs < dispatchedAtMs) {
+        if (Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs < dispatchedAtMs) {
           LOG2.info("MeshReconcile", `Stale-summary guard: skipping transcript reconcile for task ${taskId} on node ${nodeId} (mesh ${mesh.id}) \u2014 final assistant message (${evidence.transcriptMessageAt}) predates this task's dispatch (${dispatch.dispatchedAt}); it is a prior task's summary`);
           traceMeshEventDrop("reconcile_stale_summary_before_dispatch", {
             taskId,
@@ -72645,15 +73781,12 @@ ${cleanBody}`;
           }, `transcriptAt=${evidence.transcriptMessageAt} < dispatchedAt=${dispatch.dispatchedAt}`);
           continue;
         }
-        const reprobeStatus = nonIdleEscapeSinceAckMs !== null ? null : await reprobeWorkerStatus(components, { isLocalNode, nodeDaemonId, readArgs });
+        const reprobeStatus = await reprobeWorkerStatus(components, { isLocalNode, nodeDaemonId, readArgs });
         if (reprobeStatus && reprobeStatus !== "idle") {
           deleteHoldState(synthKey, mesh.id);
           LOG2.info("MeshReconcile", `Live re-probe defer: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read '${reprobeStatus}' at synth-commit time \u2014 worker resumed generating; deferring synth to a later tick`);
           continue;
         }
-        if (nonIdleEscapeSinceAckMs !== null) {
-          LOG2.warn("MeshReconcile", `Acked-hold death deadline NON-IDLE escape: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) still reads 'generating' ${Math.round(nonIdleEscapeSinceAckMs / 1e3)}s after the ack with a causally-proven final assistant (transcriptAt=${evidence.transcriptMessageAt ?? "n/a"}) \u2014 the floor-class PTY wedge rescue net; synthesizing the missing completion (a real emit, if it ever lands, no-ops idempotently).`);
-        }
         const providerSessionId = readNonEmptyString(payload.providerSessionId);
         const workerSession = components.instanceManager.getInstance(sessionId);
         const workerCoordinatorDaemonId = readNonEmptyString(
@@ -72814,8 +73947,12 @@ ${cleanBody}`;
       if (!payload) return declined("chat_tail_unreadable", "worker transcript read returned no payload (offline/unreachable?)");
       const payloadStatus = readChatPayloadProviderObservedStatus(payload);
       const messages = Array.isArray(payload.messages) ? payload.messages : [];
-      const evidence = extractFinalAssistantSummaryEvidence(messages);
       const dispatchedAtMs = Date.parse(readNonEmptyString(row.dispatchTimestamp));
+      const evidence = extractFinalAssistantSummaryEvidence(
+        messages,
+        void 0,
+        Number.isFinite(dispatchedAtMs) ? { turnStartedAtMs: dispatchedAtMs } : void 0
+      );
       const transcriptAtMs = Date.parse(evidence.transcriptMessageAt ?? "");
       if (Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs < dispatchedAtMs) {
         return declined(
@@ -72861,7 +73998,10 @@ ${cleanBody}`;
           `dispatchTimestamp=${row.dispatchTimestamp ?? "none"} transcriptMessageAt=${evidence.transcriptMessageAt ?? "none"} \u2014 shape-only evidence (${verdict.reason}) cannot complete an undated tail; reclaim owns it`
         );
       }
-      const selectedFinalAssistant = finalAssistantPresent ? selectFinalAssistantTurnEndMessage(messages) : null;
+      const selectedFinalAssistant = finalAssistantPresent ? selectFinalAssistantTurnEndMessage(
+        messages,
+        Number.isFinite(dispatchedAtMs) ? { turnStartedAtMs: dispatchedAtMs } : void 0
+      ) : null;
       const selectedFinalAssistantIndex = selectedFinalAssistant ? messages.lastIndexOf(selectedFinalAssistant) : -1;
       const admissionSnapshot = {
         producer,
@@ -72897,6 +74037,7 @@ ${cleanBody}`;
         admissionSnapshot
       };
     }
+    var nonIdleEscapeTracks;
     var init_mesh_completion_synthesis = __esm2({
       "src/mesh/mesh-completion-synthesis.ts"() {
         "use strict";
@@ -72917,6 +74058,7 @@ ${cleanBody}`;
         init_mesh_reconcile_v2_backstop();
         init_mesh_reconcile_acked_hold();
         init_mesh_remote_event_pull();
+        nonIdleEscapeTracks = /* @__PURE__ */ new Map();
       }
     });
     function findLiveCoordinators(components) {
@@ -73527,6 +74669,53 @@ ${cleanBody}`;
               producer: "early_idle_transcript_evidence"
             });
             if (terminalEvidence) {
+              const weakCandidateKey = `${meshId}::${row.id}`;
+              if (terminalEvidence.evidenceLevel === "weak") {
+                const candidate = weakCompletionCandidateStreak.get(weakCandidateKey) ?? { count: 0 };
+                if (candidate.finalAssistantAt !== void 0 && candidate.finalAssistantAt !== terminalEvidence.transcriptMessageAt) {
+                  candidate.count = 0;
+                }
+                candidate.finalAssistantAt = terminalEvidence.transcriptMessageAt;
+                candidate.count += 1;
+                weakCompletionCandidateStreak.set(weakCandidateKey, candidate);
+                if (candidate.count === 1) {
+                  const nodeLabel = row.assignedNodeId ? `Node '${row.assignedNodeId}'` : "Remote agent";
+                  const metadataEvent = {
+                    evidenceLevel: "weak",
+                    finalSummary: terminalEvidence.finalSummary,
+                    taskId: row.id,
+                    providerType: readNonEmptyString(row.assignedProviderType) || terminalEvidence.providerType,
+                    providerSessionId: terminalEvidence.providerSessionId,
+                    source: "early_idle_transcript_evidence",
+                    targetSessionId: terminalEvidence.sessionId
+                  };
+                  try {
+                    queuePendingMeshCoordinatorEvent({
+                      event: "agent:generating_completed",
+                      meshId,
+                      nodeLabel,
+                      nodeId: row.assignedNodeId,
+                      metadataEvent,
+                      coordinatorMessage: buildMeshSystemMessage({ event: "agent:generating_completed", nodeLabel, metadataEvent }),
+                      queuedAt: nowMs
+                    });
+                  } catch {
+                  }
+                }
+                if (candidate.count < WEAK_COMPLETION_CANDIDATE_CONFIRM_TICKS) {
+                  traceMeshEventDrop("weak_completion_candidate_held", {
+                    taskId: row.id,
+                    sessionId: row.assignedSessionId,
+                    nodeId: row.assignedNodeId,
+                    meshId,
+                    event: "agent:generating_completed"
+                  }, `weak message-shape completion candidate ${candidate.count}/${WEAK_COMPLETION_CANDIDATE_CONFIRM_TICKS} (early-idle) \u2014 awaiting re-confirmation`);
+                  continue;
+                }
+                weakCompletionCandidateStreak.delete(weakCandidateKey);
+              } else {
+                weakCompletionCandidateStreak.delete(weakCandidateKey);
+              }
               const propagation = propagateWatchdogTranscriptCompletion(
                 components,
                 meshId,
@@ -74466,6 +75655,30 @@ ${cleanBody}`;
           LOG2.warn("MeshReconcile", `Completion reconcile failed for mesh ${mesh.id}: ${e?.message || e}`);
         }
       }
+      if (store) {
+        for (const mesh of listMeshes()) {
+          const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
+          if (!daemonHostsMesh(mesh, selfIds)) continue;
+          try {
+            const gateStore = store.graphStore();
+            const preSweep = new Map(
+              gateStore.listGatesByMesh(mesh.id, ["awaiting_coordinator", "claimed"]).map((g) => [g.gateId, { graphId: g.graphId, onTimeout: g.onTimeout, deadlineAt: g.deadlineAt }])
+            );
+            const swept = sweepMeshGraphGateTimeouts(mesh.id);
+            for (const gateId of swept.expiredGateIds) {
+              const meta3 = preSweep.get(gateId);
+              recordGraphGateExpired(mesh.id, {
+                gateId,
+                graphId: meta3?.graphId,
+                policy: meta3?.onTimeout ?? "hold",
+                deadlineAt: meta3?.deadlineAt
+              });
+            }
+          } catch (e) {
+            LOG2.warn("MeshReconcile", `Graph gate sweep failed for mesh ${mesh.id}: ${e?.message || e}`);
+          }
+        }
+      }
       if (store) {
         for (const mesh of listMeshes()) {
           const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
@@ -74768,6 +75981,8 @@ ${cleanBody}`;
         init_mesh_reconcile_stranded_dispatch();
         init_mesh_reconcile_unresolved_forward();
         init_mesh_graph_workspace_saga();
+        init_mesh_graph_gates();
+        init_mesh_graph_provenance();
         init_mesh_reconcile_v2_backstop();
         init_mesh_reconcile_acked_hold();
         init_mesh_reconcile_coordinator_drain();
@@ -77195,6 +78410,29 @@ ${cleanBody}`;
         "use strict";
       }
     });
+    function resolveRefineVitestMaxWorkers(env2 = process.env) {
+      const raw = env2[REFINE_VITEST_MAX_WORKERS_ENV];
+      if (raw === void 0 || raw.trim() === "") return DEFAULT_REFINE_VITEST_MAX_WORKERS;
+      const parsed = Number.parseInt(raw, 10);
+      if (!Number.isFinite(parsed)) return DEFAULT_REFINE_VITEST_MAX_WORKERS;
+      if (parsed === 0) return null;
+      return Math.max(1, parsed);
+    }
+    function refineGateChildEnv(env2 = process.env) {
+      if (env2.VITEST_MAX_WORKERS) return {};
+      const cap = resolveRefineVitestMaxWorkers(env2);
+      if (cap === null) return {};
+      return { VITEST_MAX_WORKERS: String(cap) };
+    }
+    var REFINE_VITEST_MAX_WORKERS_ENV;
+    var DEFAULT_REFINE_VITEST_MAX_WORKERS;
+    var init_mesh_refine_worker_cap = __esm2({
+      "src/mesh/mesh-refine-worker-cap.ts"() {
+        "use strict";
+        REFINE_VITEST_MAX_WORKERS_ENV = "ADHDEV_REFINE_VITEST_MAX_WORKERS";
+        DEFAULT_REFINE_VITEST_MAX_WORKERS = 2;
+      }
+    });
     function truncateValidationOutput(value) {
       const text = typeof value === "string" ? value : value == null ? "" : String(value);
       if (text.length <= REFINE_VALIDATION_SUMMARY_CHARS) return text;
@@ -78673,7 +79911,7 @@ ${mergeTreeErr?.stderr || ""}`;
               encoding: "utf8",
               timeout,
               maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
-              env: { ...process.env, CI: process.env.CI || "1", ...candidate.env || {} },
+              env: { ...process.env, CI: process.env.CI || "1", ...refineGateChildEnv(), ...candidate.env || {} },
               ...spawn7.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
             });
             summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
@@ -78718,7 +79956,7 @@ ${mergeTreeErr?.stderr || ""}`;
             encoding: "utf8",
             timeout,
             maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
-            env: { ...process.env, CI: process.env.CI || "1", ...candidate.env || {} },
+            env: { ...process.env, CI: process.env.CI || "1", ...refineGateChildEnv(), ...candidate.env || {} },
             ...spawn7.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
           });
           summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
@@ -78784,6 +80022,7 @@ ${mergeTreeErr?.stderr || ""}`;
         fs48 = __toESM2(require("fs"));
         import_node_child_process11 = require("child_process");
         init_resolve_executable();
+        init_mesh_refine_worker_cap();
         GIT4 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
         REFINE_VALIDATION_TIMEOUT_MS = 12e4;
         REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
@@ -78869,6 +80108,45 @@ ${mergeTreeErr?.stderr || ""}`;
         REFINE_INFLIGHT_FRESHNESS_MS = 30 * 6e4;
       }
     });
+    function resolveRefineMaxConcurrentJobs(env2 = process.env) {
+      const raw = env2[REFINE_MAX_CONCURRENT_JOBS_ENV];
+      if (raw === void 0 || raw.trim() === "") return DEFAULT_REFINE_MAX_CONCURRENT_JOBS;
+      const parsed = Number.parseInt(raw, 10);
+      if (!Number.isFinite(parsed) || parsed < 1) return DEFAULT_REFINE_MAX_CONCURRENT_JOBS;
+      return parsed;
+    }
+    async function runWithRefineExecutionSlot(label, task) {
+      const limit = resolveRefineMaxConcurrentJobs();
+      if (activeExecutions >= limit) {
+        LOG2.info("Mesh", `[Refinery] ${label} QUEUED \u2014 ${activeExecutions} refine job(s) already executing (limit ${limit}), ${waitQueue.length + 1} waiting. It starts automatically; do not re-invoke.`);
+        await new Promise((resolve30) => {
+          waitQueue.push(resolve30);
+        });
+        LOG2.info("Mesh", `[Refinery] ${label} dequeued \u2014 starting now (${activeExecutions} other job(s) still executing).`);
+      }
+      activeExecutions += 1;
+      try {
+        return await task();
+      } finally {
+        activeExecutions -= 1;
+        const next = waitQueue.shift();
+        if (next) next();
+      }
+    }
+    var REFINE_MAX_CONCURRENT_JOBS_ENV;
+    var DEFAULT_REFINE_MAX_CONCURRENT_JOBS;
+    var activeExecutions;
+    var waitQueue;
+    var init_mesh_refine_concurrency = __esm2({
+      "src/mesh/mesh-refine-concurrency.ts"() {
+        "use strict";
+        init_logger();
+        REFINE_MAX_CONCURRENT_JOBS_ENV = "ADHDEV_REFINE_MAX_CONCURRENT_JOBS";
+        DEFAULT_REFINE_MAX_CONCURRENT_JOBS = 1;
+        activeExecutions = 0;
+        waitQueue = [];
+      }
+    });
     function resolveRefineResumeDispatchGraceMs() {
       return resolveTunedReconcileMs("MESH_REFINE_RESUME_DISPATCH_GRACE_MS", 6e4, 0, 10 * 6e4);
     }
@@ -80807,7 +82085,10 @@ ${e?.stderr || ""}`;
       await appendRefineBatchJobLedger(self, "task_dispatched", handle);
       queueRefineBatchJobEvent(self, "refine:accepted", handle);
       setImmediate(() => {
-        void finishMeshRefineBatchJob(self, handle, orderedNodes, ordering, args);
+        void runWithRefineExecutionSlot(
+          `batch ${handle.jobId} (mesh ${meshId})`,
+          () => finishMeshRefineBatchJob(self, handle, orderedNodes, ordering, args)
+        );
       });
       return {
         ...handle,
@@ -81006,7 +82287,10 @@ ${e?.stderr || ""}`;
       queueRefineJobEvent(self, "refine:accepted", handle);
       setImmediate(() => {
         void recordRefineAcceptBaseDivergence(self, handle, node);
-        void finishMeshRefineJob(self, handle, args);
+        void runWithRefineExecutionSlot(
+          `job ${handle.jobId} (node ${handle.targetNodeId})`,
+          () => finishMeshRefineJob(self, handle, args)
+        );
       });
       return handle;
     }
@@ -81035,6 +82319,7 @@ ${e?.stderr || ""}`;
         init_git_locale();
         init_mesh_node_identity();
         init_mesh_refine_gates();
+        init_mesh_refine_concurrency();
         init_router_refine_resume();
         RETRYABLE_BASE_MOVEMENT_CODES = /* @__PURE__ */ new Set(["base_moved", "base_locked"]);
       }
@@ -81110,6 +82395,9 @@ ${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_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,
       MESH_JSON_CONFIG_LOCATIONS: () => MESH_JSON_CONFIG_LOCATIONS,
       MESH_JSON_CONFIG_SCHEMA: () => MESH_JSON_CONFIG_SCHEMA,
       MESH_JSON_PROVIDER_DEFAULTS_EXAMPLE: () => MESH_JSON_PROVIDER_DEFAULTS_EXAMPLE,
@@ -81119,16 +82407,21 @@ ${e?.stderr || ""}`;
       MESH_MISSION_LIST_STATUS_LIMIT: () => MESH_MISSION_LIST_STATUS_LIMIT,
       MESH_MISSION_STATUSES: () => MESH_MISSION_STATUSES,
       MESH_NODE_LIVE_TRUTH_MARKER: () => MESH_NODE_LIVE_TRUTH_MARKER,
+      MESH_ON_DEPENDENCY_FAILURE_PUBLIC_TEXT: () => MESH_ON_DEPENDENCY_FAILURE_PUBLIC_TEXT,
       MESH_REFINE_CONFIG_LOCATIONS: () => MESH_REFINE_CONFIG_LOCATIONS,
       MESH_REFINE_CONFIG_SCHEMA: () => MESH_REFINE_CONFIG_SCHEMA,
       MESH_SCHEDULING_STRATEGIES: () => MESH_SCHEDULING_STRATEGIES,
+      MESH_SUPERSEDED_SINGLE_REASONS: () => MESH_SUPERSEDED_SINGLE_REASONS,
       MESH_TASK_GRAPH_MAX_TASKS: () => MESH_TASK_GRAPH_MAX_TASKS,
       MESH_TASK_PRIORITIES: () => MESH_TASK_PRIORITIES,
+      MESH_VALID_SINGLE_REASONS: () => MESH_VALID_SINGLE_REASONS,
       MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS: () => MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
       MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA: () => MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
       MIN_GIT_WORKSPACE_POLL_INTERVAL_MS: () => MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
       MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS: () => MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS2,
       MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS: () => MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS2,
+      MeshGraphPlanError: () => MeshGraphPlanError,
+      MeshGraphPolicyError: () => MeshGraphPolicyError,
       NOT_BEFORE_RELATIVE_THRESHOLD_MS: () => NOT_BEFORE_RELATIVE_THRESHOLD_MS,
       NodePtyTransportFactory: () => NodePtyTransportFactory,
       OPERATING_NOTE_DEDUPE_WINDOW: () => OPERATING_NOTE_DEDUPE_WINDOW,
@@ -81185,6 +82478,7 @@ ${e?.stderr || ""}`;
       buildMeshActiveWork: () => buildMeshActiveWork,
       buildMeshActiveWorkSummary: () => buildMeshActiveWorkSummary,
       buildMeshAsyncRefineJobs: () => buildMeshAsyncRefineJobs,
+      buildMeshGraphViews: () => buildMeshGraphViews,
       buildMeshHostRequiredFailure: () => buildMeshHostRequiredFailure,
       buildMeshJsonConfigScaffold: () => buildMeshJsonConfigScaffold,
       buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
@@ -81211,6 +82505,7 @@ ${e?.stderr || ""}`;
       buildUserChatMessage: () => buildUserChatMessage,
       cancelTask: () => cancelTask,
       canonicalDaemonId: () => canonicalDaemonId,
+      claimMeshGraphGate: () => claimMeshGraphGate,
       claimNextTask: () => claimNextTask,
       classifyChatMessageVisibility: () => classifyChatMessageVisibility,
       classifyDuplicateMeshDispatch: () => classifyDuplicateMeshDispatch,
@@ -81225,14 +82520,17 @@ ${e?.stderr || ""}`;
       clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
       collectPendingApprovals: () => collectPendingApprovals,
       collectSyncTargetTypes: () => collectSyncTargetTypes,
+      commitMeshGraphPlan: () => commitMeshGraphPlan,
       compareGitSnapshots: () => compareGitSnapshots,
       compensateWorkspaceIntent: () => compensateWorkspaceIntent,
+      computeMeshGraphPlanDigest: () => computeMeshGraphPlanDigest,
       computeMeshMissionStats: () => computeMeshMissionStats,
       computeMeshTaskStats: () => computeMeshTaskStats,
       computeProviderTreeDigest: () => computeProviderTreeDigest,
       configureDebugTraceStore: () => configureDebugTraceStore,
       connectCdpManager: () => connectCdpManager,
       consoleSymbols: () => consoleSymbols,
+      coordinatorGateBlockReason: () => coordinatorGateBlockReason,
       coordinatorIdentityFromEmitFields: () => coordinatorIdentityFromEmitFields,
       createDebugTraceStore: () => createDebugTraceStore,
       createDefaultGitCommandServices: () => createDefaultGitCommandServices,
@@ -81252,6 +82550,7 @@ ${e?.stderr || ""}`;
       delegatedWorkerAutoApproveSettings: () => delegatedWorkerAutoApproveSettings,
       deleteDirectDispatchesByTaskId: () => deleteDirectDispatchesByTaskId,
       deleteMesh: () => deleteMesh,
+      deriveDependencyFailures: () => deriveDependencyFailures,
       deriveMeshNodeHealthFromGit: () => deriveMeshNodeHealthFromGit,
       deriveMeshReviewInboxItems: () => deriveMeshReviewInboxItems,
       deriveWorkspaceBranchIdentity: () => deriveWorkspaceBranchIdentity,
@@ -81352,6 +82651,7 @@ ${e?.stderr || ""}`;
       installGlobalInterceptor: () => installGlobalInterceptor,
       interactivePromptFromClaudeAskUserQuestion: () => interactivePromptFromClaudeAskUserQuestion,
       isActivityChatMessage: () => isActivityChatMessage,
+      isAdvancedGraphTask: () => isAdvancedGraphTask,
       isAlwaysOnTraceCategory: () => isAlwaysOnTraceCategory,
       isBuiltinChatMessageKind: () => isBuiltinChatMessageKind,
       isCdpConnected: () => isCdpConnected,
@@ -81437,11 +82737,13 @@ ${e?.stderr || ""}`;
       normalizeMeshTaskPriority: () => normalizeMeshTaskPriority,
       normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
       normalizeMessageParts: () => normalizeMessageParts,
+      normalizeOrchestrationDecision: () => normalizeOrchestrationDecision,
       normalizeRepoIdentity: () => normalizeRepoIdentity,
       normalizeRepoMeshDeclarativeConfig: () => normalizeRepoMeshDeclarativeConfig,
       normalizeSessionModalFields: () => normalizeSessionModalFields,
       notifyCoordinatorOfOrphanedPins: () => notifyCoordinatorOfOrphanedPins,
       otherTrackConfigDir: () => otherTrackConfigDir,
+      parseOnDependencyFailurePolicy: () => parseOnDependencyFailurePolicy,
       parsePorcelainV2Status: () => parsePorcelainV2Status,
       parseProviderSourceConfigUpdate: () => parseProviderSourceConfigUpdate,
       parseWorktreeListOutput: () => parseWorktreeListOutput,
@@ -81458,6 +82760,7 @@ ${e?.stderr || ""}`;
       printQuota: () => printQuota2,
       printQuotaInstallError: () => printQuotaInstallError2,
       probeCdpPort: () => probeCdpPort,
+      projectGraphPublicPolicy: () => projectGraphPublicPolicy,
       pruneOperatingNotes: () => pruneOperatingNotes,
       pruneStaleDirectDispatches: () => pruneStaleDirectDispatches,
       queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
@@ -81481,15 +82784,23 @@ ${e?.stderr || ""}`;
       reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
       recordDebugTrace: () => recordDebugTrace,
       recordDirectDispatchTask: () => recordDirectDispatchTask,
+      recordGraphEnqueueCommitted: () => recordGraphEnqueueCommitted,
+      recordGraphEnqueueRolledBack: () => recordGraphEnqueueRolledBack,
+      recordGraphEnqueueValidationFailed: () => recordGraphEnqueueValidationFailed,
+      recordGraphGateClaimed: () => recordGraphGateClaimed,
+      recordGraphGateExpired: () => recordGraphGateExpired,
+      recordGraphGateReleased: () => recordGraphGateReleased,
       recordMeshToolCall: () => recordMeshToolCall,
       recordMissingSessionAttempt: () => recordMissingSessionAttempt2,
       recordSessionUsage: () => recordSessionUsage,
       recoverExpiredWorkspaceSagas: () => recoverExpiredWorkspaceSagas,
       registerExtensionProviders: () => registerExtensionProviders,
       registerMeshCoordinator: () => registerMeshCoordinator,
+      releaseMeshGraphGate: () => releaseMeshGraphGate,
       removeMagiKindPanel: () => removeMagiKindPanel,
       removeNode: () => removeNode,
       removeWorktree: () => removeWorktree,
+      requestUsesGraphV2: () => requestUsesGraphV2,
       requeueHeldMeshCoordinatorEvents: () => requeueHeldMeshCoordinatorEvents,
       requeueTask: () => requeueTask,
       requireMeshHostQueueOwner: () => requireMeshHostQueueOwner,
@@ -81524,6 +82835,7 @@ ${e?.stderr || ""}`;
       resolveNodeSchedulingPriority: () => resolveNodeSchedulingPriority,
       resolveNotBefore: () => resolveNotBefore,
       resolveNpmPublishedVersion: () => resolveNpmPublishedVersion,
+      resolveOnDependencyFailurePolicy: () => resolveOnDependencyFailurePolicy,
       resolveProviderChannel: () => resolveProviderChannel,
       resolveProviderMaxParallel: () => resolveProviderMaxParallel,
       resolveScopedMeshId: () => resolveScopedMeshId,
@@ -81568,6 +82880,7 @@ ${e?.stderr || ""}`;
       summarizeMeshUsage: () => summarizeMeshUsage,
       summarizeMissionTasks: () => summarizeMissionTasks,
       supportsUnicodeSymbols: () => supportsUnicodeSymbols,
+      sweepMeshGraphGateTimeouts: () => sweepMeshGraphGateTimeouts,
       taskDependenciesSatisfied: () => taskDependenciesSatisfied,
       tombstoneOperatingNote: () => tombstoneOperatingNote,
       totalTokens: () => totalTokens,
@@ -84066,10 +85379,658 @@ ${e?.stderr || ""}`;
       };
     }
     init_mesh_work_queue();
+    init_mesh_graph_derived_failure();
     init_mesh_graph_workspace_saga();
     init_mesh_graph_workspace_safety();
     init_mesh_graph_workspace_identity();
     init_mesh_graph_workspace_ports();
+    init_mesh_graph_gates();
+    var import_crypto14 = require("crypto");
+    init_logger();
+    init_mesh_runtime_store();
+    init_mesh_graph_input_binding();
+    init_mesh_graph_types();
+    init_mesh_graph_derived_failure();
+    init_mesh_graph_transition_runner();
+    init_mesh_graph_workspace_saga();
+    init_mesh_work_queue();
+    var MeshGraphPlanError = class extends Error {
+      constructor(code, message, extra) {
+        super(`${code}: ${message}`);
+        this.code = code;
+        this.extra = extra;
+        this.name = "MeshGraphPlanError";
+      }
+    };
+    function isAdvancedGraphTask(spec) {
+      return spec.inputs_from !== void 0 || spec.run_if !== void 0 || typeof spec.workspace_ref === "string" && spec.workspace_ref.trim().length > 0 || Array.isArray(spec.gated_by) && spec.gated_by.length > 0;
+    }
+    function requestUsesGraphV2(req) {
+      if (Array.isArray(req.gates) && req.gates.length > 0) return true;
+      if (Array.isArray(req.workspaces) && req.workspaces.length > 0) return true;
+      return (req.tasks ?? []).some(isAdvancedGraphTask);
+    }
+    function normalizeRef(value, label) {
+      const ref = typeof value === "string" ? value.trim() : "";
+      if (!ref) throw new MeshGraphPlanError("invalid_graph_ref", `${label} requires a non-empty ref`);
+      return ref;
+    }
+    function pickEnum(value, allowed, fallback, code, label) {
+      if (value === void 0 || value === null || value === "") return fallback;
+      if (typeof value === "string" && allowed.includes(value)) return value;
+      throw new MeshGraphPlanError(code, `${label} must be one of ${allowed.join(" | ")} (got ${JSON.stringify(value)})`);
+    }
+    function computeMeshGraphPlanDigest(req) {
+      const normalized = {
+        tasks: (req.tasks ?? []).map((t) => ({
+          ref: typeof t.ref === "string" ? t.ref.trim() : null,
+          message: t.message,
+          depends_on: [...t.dependsOn ?? []].sort(),
+          gated_by: [...t.gated_by ?? []].sort(),
+          inputs_from: t.inputs_from ?? null,
+          run_if: t.run_if ?? null,
+          on_false: t.on_false ?? null,
+          on_upstream_skip: t.on_upstream_skip ?? null,
+          workspace_ref: t.workspace_ref ?? null,
+          target_node_id: t.targetNodeId ?? null,
+          task_mode: t.taskMode ?? null,
+          difficulty: t.difficulty ?? null
+        })),
+        gates: (req.gates ?? []).map((g) => ({
+          ref: g.ref,
+          action: g.action ?? "custom",
+          depends_on: [...g.depends_on ?? []].sort(),
+          on_timeout: g.on_timeout ?? "hold",
+          lease_seconds: g.lease_seconds ?? null,
+          deadline_seconds: g.deadline_seconds ?? null
+        })),
+        workspaces: (req.workspaces ?? []).map((w) => ({
+          ref: w.ref,
+          source_node_id: w.source_node_id ?? null,
+          base_revision: w.base_revision ?? null,
+          desired_path: w.desired_path ?? null,
+          cleanup_on_graph_failure: w.cleanup_on_graph_failure === true
+        })),
+        on_dependency_failure: parseOnDependencyFailurePolicy(req.onDependencyFailure)
+      };
+      return (0, import_crypto14.createHash)("sha256").update(canonicalJson(normalized)).digest("hex");
+    }
+    function commitMeshGraphPlan(req) {
+      const store = MeshRuntimeStore.getInstance();
+      const tasks = Array.isArray(req.tasks) ? req.tasks : [];
+      if (tasks.length === 0) {
+        throw new MeshGraphPlanError("empty_task_graph", "a graph plan requires at least one task");
+      }
+      const gates = Array.isArray(req.gates) ? req.gates : [];
+      const workspaces = Array.isArray(req.workspaces) ? req.workspaces : [];
+      const policy = { on_dependency_failure: parseOnDependencyFailurePolicy(req.onDependencyFailure) };
+      const planDigest = computeMeshGraphPlanDigest(req);
+      const batchId = typeof req.batchId === "string" && req.batchId.trim() ? req.batchId.trim() : newMeshGraphId();
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      const taskRefs = /* @__PURE__ */ new Map();
+      tasks.forEach((t, i) => {
+        const ref = typeof t.ref === "string" ? t.ref.trim() : "";
+        if (!ref) return;
+        if (taskRefs.has(ref)) {
+          throw new MeshGraphPlanError("duplicate_task_ref", `ref '${ref}' is used by more than one task in this batch`);
+        }
+        taskRefs.set(ref, i);
+      });
+      const gateRefs = /* @__PURE__ */ new Map();
+      gates.forEach((g, i) => {
+        const ref = normalizeRef(g.ref, `gates[${i}]`);
+        if (taskRefs.has(ref) || gateRefs.has(ref)) {
+          throw new MeshGraphPlanError(
+            "duplicate_graph_ref",
+            `ref '${ref}' is declared more than once \u2014 tasks, gates and workspaces share ONE ref namespace`
+          );
+        }
+        gateRefs.set(ref, i);
+      });
+      const workspaceRefs = /* @__PURE__ */ new Set();
+      workspaces.forEach((w, i) => {
+        const ref = normalizeRef(w.ref, `workspaces[${i}]`);
+        if (taskRefs.has(ref) || gateRefs.has(ref) || workspaceRefs.has(ref)) {
+          throw new MeshGraphPlanError(
+            "duplicate_graph_ref",
+            `ref '${ref}' is declared more than once \u2014 tasks, gates and workspaces share ONE ref namespace`
+          );
+        }
+        workspaceRefs.add(ref);
+      });
+      tasks.forEach((t, i) => {
+        for (const dep of t.dependsOn ?? []) {
+          if (gateRefs.has(dep)) {
+            throw new MeshGraphPlanError(
+              "gate_ref_in_depends_on",
+              `task ${t.ref ? `'${t.ref}'` : `#${i}`} lists gate ref '${dep}' in depends_on \u2014 use gated_by to declare a gate edge (a gate is an intentional stop, never an ordinary queue dependency)`
+            );
+          }
+        }
+        for (const gateRef of t.gated_by ?? []) {
+          if (!gateRefs.has(gateRef)) {
+            throw new MeshGraphPlanError(
+              "unknown_gate_ref",
+              `task ${t.ref ? `'${t.ref}'` : `#${i}`} is gated_by '${gateRef}', which is not a gate in this batch` + (gateRefs.size ? ` (gates: ${[...gateRefs.keys()].join(", ")})` : "")
+            );
+          }
+        }
+        const ws = typeof t.workspace_ref === "string" ? t.workspace_ref.trim() : "";
+        if (ws && !workspaceRefs.has(ws)) {
+          throw new MeshGraphPlanError(
+            "unknown_workspace_ref",
+            `task ${t.ref ? `'${t.ref}'` : `#${i}`} names workspace_ref '${ws}', which is not declared in this batch`
+          );
+        }
+      });
+      gates.forEach((g, i) => {
+        for (const dep of g.depends_on ?? []) {
+          if (!taskRefs.has(dep) && !gateRefs.has(dep)) {
+            throw new MeshGraphPlanError(
+              "unknown_gate_dependency",
+              `gate '${g.ref}' depends on '${dep}', which is not a task or gate ref in this batch`
+            );
+          }
+        }
+        pickEnum(g.action, MESH_GRAPH_GATE_ACTIONS, "custom", "invalid_gate_action", `gates[${i}].action`);
+        pickEnum(g.on_timeout, MESH_GRAPH_GATE_TIMEOUT_POLICIES, "hold", "invalid_gate_on_timeout", `gates[${i}].on_timeout`);
+      });
+      tasks.forEach((t, i) => {
+        pickEnum(t.on_upstream_skip, MESH_GRAPH_ON_UPSTREAM_SKIP_POLICIES, "skip", "invalid_on_upstream_skip", `tasks[${i}].on_upstream_skip`);
+      });
+      const result = store.transaction(() => {
+        const graphStore = store.graphStore();
+        const existing = graphStore.getGraphByBatchId(req.meshId, batchId);
+        if (existing) {
+          if (existing.planDigest !== planDigest) {
+            throw new MeshGraphPlanError(
+              "batch_id_conflict",
+              `batch_id '${batchId}' already exists on this mesh with a DIFFERENT plan digest \u2014 reuse of a batch id is only idempotent for an identical plan`,
+              { graphId: existing.graphId }
+            );
+          }
+          const existingNodes = graphStore.listNodes(existing.graphId);
+          const workerNodes = existingNodes.filter((n) => n.kind === "worker_task");
+          const replayTasks = workerNodes.map((n) => n.queueTaskId ? store.findQueueEntryById(req.meshId, n.queueTaskId) : null).filter((e) => !!e);
+          return {
+            graphId: existing.graphId,
+            batchId,
+            tasks: replayTasks,
+            nodeIdByIndex: workerNodes.map((n) => n.nodeId),
+            gates: graphStore.listGatesByGraph(existing.graphId).map((g) => ({
+              ref: g.ref ?? g.gateId,
+              gateId: g.gateId,
+              nodeId: g.nodeId,
+              action: g.action
+            })),
+            workspaces: graphStore.listWorkspaceIntents(existing.graphId).map((w) => ({
+              ref: w.workspaceRef,
+              sagaState: w.sagaState,
+              branchIdentity: w.branchIdentity
+            })),
+            dependencyEdgeCount: existing.dependencyEdgeCount,
+            planDigest,
+            replayed: true,
+            workspacePreparation: existing.workspaceCount > 0 ? "pending" : "not_requested",
+            heldNodeIds: []
+          };
+        }
+        const queueSpecs = tasks.map((t) => {
+          const {
+            inputs_from: _inputsFrom,
+            run_if: _runIf,
+            on_false: _onFalse,
+            on_upstream_skip: _onUpstreamSkip,
+            workspace_ref: _workspaceRef,
+            gated_by: _gatedBy,
+            ...queueSpec
+          } = t;
+          return {
+            ...queueSpec,
+            missionId: queueSpec.missionId ?? req.missionId,
+            ...req.sourceCoordinatorSessionId ? { sourceCoordinatorSessionId: req.sourceCoordinatorSessionId } : {}
+          };
+        });
+        const inserted = enqueueTaskGraph(req.meshId, queueSpecs);
+        const graphId = newMeshGraphId();
+        const nodeIdByIndex = tasks.map(() => newMeshGraphNodeId());
+        const gateNodeIdByRef = /* @__PURE__ */ new Map();
+        const gateIdByRef = /* @__PURE__ */ new Map();
+        gates.forEach((g) => {
+          gateNodeIdByRef.set(g.ref.trim(), newMeshGraphNodeId());
+          gateIdByRef.set(g.ref.trim(), newMeshGraphGateId());
+        });
+        const nodeIdByRef = /* @__PURE__ */ new Map();
+        tasks.forEach((t, i) => {
+          const ref = typeof t.ref === "string" ? t.ref.trim() : "";
+          if (ref) nodeIdByRef.set(ref, nodeIdByIndex[i]);
+        });
+        for (const [ref, nodeId] of gateNodeIdByRef) nodeIdByRef.set(ref, nodeId);
+        const edges = [];
+        const addEdge = (fromNodeId, toNodeId, kind, omitOnSkip) => {
+          edges.push({ graphId, meshId: req.meshId, fromNodeId, toNodeId, kind, omitOnSkip, createdAt: nowIso });
+        };
+        tasks.forEach((t, i) => {
+          const nodeId = nodeIdByIndex[i];
+          const ref = typeof t.ref === "string" ? t.ref.trim() : void 0;
+          const baseSpec = { message: t.message };
+          if (t.inputs_from !== void 0) baseSpec.inputs_from = t.inputs_from;
+          if (t.run_if !== void 0) baseSpec.run_if = t.run_if;
+          if (t.on_false !== void 0) baseSpec.on_false = t.on_false;
+          if (typeof t.workspace_ref === "string" && t.workspace_ref.trim()) {
+            baseSpec.workspace_ref = t.workspace_ref.trim();
+          }
+          const node = {
+            graphId,
+            nodeId,
+            meshId: req.meshId,
+            ...ref ? { ref } : {},
+            kind: "worker_task",
+            queueTaskId: inserted[i].id,
+            state: "declared",
+            baseSpecJson: JSON.stringify(baseSpec),
+            materializationVersion: 0,
+            createdAt: nowIso,
+            updatedAt: nowIso
+          };
+          graphStore.insertNode(node);
+        });
+        gates.forEach((g, i) => {
+          const ref = g.ref.trim();
+          const nodeId = gateNodeIdByRef.get(ref);
+          const gateSpec = {};
+          if (typeof g.lease_seconds === "number" && g.lease_seconds > 0) gateSpec.lease_seconds = g.lease_seconds;
+          if (typeof g.deadline_seconds === "number" && g.deadline_seconds > 0) gateSpec.deadline_seconds = g.deadline_seconds;
+          graphStore.insertNode({
+            graphId,
+            nodeId,
+            meshId: req.meshId,
+            ref,
+            kind: "coordinator_gate",
+            state: "declared",
+            baseSpecJson: JSON.stringify(gateSpec),
+            materializationVersion: 0,
+            createdAt: nowIso,
+            updatedAt: nowIso
+          });
+          graphStore.insertGate({
+            gateId: gateIdByRef.get(ref),
+            graphId,
+            nodeId,
+            meshId: req.meshId,
+            ref,
+            state: "declared",
+            action: pickEnum(g.action, MESH_GRAPH_GATE_ACTIONS, "custom", "invalid_gate_action", `gates[${i}].action`),
+            instructions: typeof g.instructions === "string" ? g.instructions : void 0,
+            eligibleCoordinatorSessionId: typeof g.eligible_coordinator_session_id === "string" ? g.eligible_coordinator_session_id : void 0,
+            leaseGeneration: 0,
+            onTimeout: pickEnum(g.on_timeout, MESH_GRAPH_GATE_TIMEOUT_POLICIES, "hold", "invalid_gate_on_timeout", `gates[${i}].on_timeout`),
+            createdAt: nowIso,
+            updatedAt: nowIso
+          });
+        });
+        tasks.forEach((t, i) => {
+          const omitOnSkip = pickEnum(
+            t.on_upstream_skip,
+            MESH_GRAPH_ON_UPSTREAM_SKIP_POLICIES,
+            "skip",
+            "invalid_on_upstream_skip",
+            `tasks[${i}].on_upstream_skip`
+          ) === "omit_dependency";
+          for (const dep of t.dependsOn ?? []) {
+            const fromNodeId = nodeIdByRef.get(dep);
+            if (!fromNodeId) continue;
+            addEdge(fromNodeId, nodeIdByIndex[i], "requires", omitOnSkip);
+          }
+          for (const sourceRef of collectRunIfSourceRefs(t.run_if)) {
+            const fromNodeId = nodeIdByRef.get(sourceRef);
+            if (!fromNodeId || fromNodeId === nodeIdByIndex[i]) 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 (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());
+            if (!fromNodeId) continue;
+            addEdge(fromNodeId, nodeIdByIndex[i], "gate", false);
+          }
+        });
+        gates.forEach((g) => {
+          const toNodeId = gateNodeIdByRef.get(g.ref.trim());
+          for (const dep of g.depends_on ?? []) {
+            const fromNodeId = nodeIdByRef.get(dep);
+            if (!fromNodeId) continue;
+            addEdge(fromNodeId, toNodeId, "requires", false);
+          }
+        });
+        for (const edge of edges) graphStore.insertEdge(edge);
+        graphStore.insertGraph({
+          graphId,
+          meshId: req.meshId,
+          batchId,
+          missionId: req.missionId,
+          sourceCoordinatorSessionId: req.sourceCoordinatorSessionId,
+          enqueueSurface: req.enqueueSurface ?? "batch",
+          schemaVersion: MESH_GRAPH_SCHEMA_VERSION,
+          status: "active",
+          taskCount: tasks.length,
+          gateCount: gates.length,
+          workspaceCount: workspaces.length,
+          dependencyEdgeCount: edges.length,
+          planDigest,
+          // ★ E-2: `on_dependency_failure` is now PERSISTED on the graph row
+          // (C3 only validated and echoed it). The C3 derived-failure path reads
+          // it back through parseGraphPolicy/projectGraphPublicPolicy.
+          policyJson: serializeGraphPolicy(policy),
+          createdAt: nowIso,
+          activatedAt: nowIso,
+          updatedAt: nowIso
+        });
+        if (req.orchestrationDecision) {
+          const merged = JSON.stringify({
+            ...JSON.parse(serializeGraphPolicy(policy)),
+            orchestration_decision: req.orchestrationDecision
+          });
+          graphStore.updateGraphPolicyJson(graphId, merged, nowIso);
+        }
+        const heldNodeIds = [];
+        tasks.forEach((t, i) => {
+          if (!isAdvancedGraphTask(t)) return;
+          const nodeId = nodeIdByIndex[i];
+          const entry = store.findQueueEntryById(req.meshId, inserted[i].id);
+          if (!entry || entry.status !== "pending" || entry.blockedReason) return;
+          entry.blockedReason = graphMaterializationBlockReason(nodeId, 0);
+          store.updateQueueEntry(entry);
+          graphStore.updateNodeState(graphId, nodeId, "blocked", nowIso);
+          heldNodeIds.push(nodeId);
+        });
+        return {
+          graphId,
+          batchId,
+          tasks: inserted,
+          nodeIdByIndex,
+          gates: gates.map((g) => ({
+            ref: g.ref.trim(),
+            gateId: gateIdByRef.get(g.ref.trim()),
+            nodeId: gateNodeIdByRef.get(g.ref.trim()),
+            action: pickEnum(g.action, MESH_GRAPH_GATE_ACTIONS, "custom", "invalid_gate_action", "gate action")
+          })),
+          workspaces: [],
+          dependencyEdgeCount: edges.length,
+          planDigest,
+          replayed: false,
+          workspacePreparation: workspaces.length > 0 ? "pending" : "not_requested",
+          heldNodeIds
+        };
+      });
+      if (!result.replayed && workspaces.length > 0) {
+        try {
+          const declared = declareWorkspaceIntents({
+            graphId: result.graphId,
+            meshId: req.meshId,
+            workspaces
+          });
+          result.workspaces = declared.map((w) => ({
+            ref: w.workspaceRef,
+            sagaState: w.sagaState,
+            branchIdentity: w.branchIdentity
+          }));
+        } catch (e) {
+          LOG2.warn("MeshGraph", `Workspace intent declaration failed for graph ${result.graphId}: ${e?.message || e}`);
+        }
+      }
+      return result;
+    }
+    function collectRunIfSourceRefs(runIf, depth = 0) {
+      if (!runIf || typeof runIf !== "object" || depth > 8) return [];
+      const out = [];
+      const node = runIf;
+      if (typeof node.from === "string" && node.from.trim()) out.push(node.from.trim());
+      for (const key2 of ["all", "any", "not", "conditions"]) {
+        const child = node[key2];
+        if (Array.isArray(child)) {
+          for (const item of child) out.push(...collectRunIfSourceRefs(item, depth + 1));
+        } else if (child && typeof child === "object") {
+          out.push(...collectRunIfSourceRefs(child, depth + 1));
+        }
+      }
+      return [...new Set(out)];
+    }
+    function collectInputSourceRefs(inputsFrom) {
+      if (!Array.isArray(inputsFrom)) return [];
+      const out = [];
+      for (const item of inputsFrom) {
+        if (item && typeof item === "object" && typeof item.from === "string") {
+          const from = item.from.trim();
+          if (from) out.push(from);
+        }
+      }
+      return [...new Set(out)];
+    }
+    init_mesh_runtime_store();
+    init_mesh_graph_derived_failure();
+    init_mesh_graph_transition_runner();
+    var IN_FLIGHT_GRAPH_STATUSES = [
+      "preparing",
+      "active",
+      "waiting_gate",
+      "compensation_required"
+    ];
+    function buildMeshGraphViews(meshId, opts = {}) {
+      const store = MeshRuntimeStore.getInstance();
+      const graphStore = store.graphStore();
+      const nowIso = new Date(opts.nowMs ?? Date.now()).toISOString();
+      let graphs;
+      if (opts.graphId) {
+        const one = graphStore.getGraph(opts.graphId);
+        graphs = one && one.meshId === meshId ? [one] : [];
+      } else if (opts.batchId) {
+        const one = graphStore.getGraphByBatchId(meshId, opts.batchId);
+        graphs = one ? [one] : [];
+      } else {
+        graphs = graphStore.listGraphsByMesh(meshId, {
+          ...opts.activeOnly === false ? {} : { statuses: IN_FLIGHT_GRAPH_STATUSES },
+          limit: opts.limit ?? 20
+        });
+      }
+      return graphs.map((graph) => {
+        const nodes = graphStore.listNodes(graph.graphId);
+        const edges = graphStore.listEdges(graph.graphId);
+        const gates = graphStore.listGatesByGraph(graph.graphId);
+        const workspaces = graphStore.listWorkspaceIntents(graph.graphId);
+        const byId = new Map(nodes.map((n) => [n.nodeId, n]));
+        const policy = projectGraphPublicPolicy(graph.policyJson);
+        const decision = readOrchestrationDecision(graph.policyJson);
+        const queueByTaskId = /* @__PURE__ */ new Map();
+        for (const node of nodes) {
+          if (!node.queueTaskId) continue;
+          const entry = store.findQueueEntryById(meshId, node.queueTaskId);
+          if (entry) {
+            queueByTaskId.set(node.queueTaskId, {
+              status: entry.status,
+              blockedReason: entry.blockedReason,
+              cancelReason: entry.cancelReason,
+              dependsOn: entry.dependsOn
+            });
+          }
+        }
+        const statusById = /* @__PURE__ */ new Map();
+        const depMetaById = /* @__PURE__ */ new Map();
+        for (const [taskId, row] of queueByTaskId) {
+          statusById.set(taskId, row.status);
+          depMetaById.set(taskId, { status: row.status, blockedReason: row.blockedReason, cancelReason: row.cancelReason });
+        }
+        for (const row of queueByTaskId.values()) {
+          for (const depId of row.dependsOn ?? []) {
+            if (statusById.has(depId)) continue;
+            const dep = store.findQueueEntryById(meshId, depId);
+            if (!dep) continue;
+            statusById.set(depId, dep.status);
+            depMetaById.set(depId, {
+              status: dep.status,
+              blockedReason: dep.blockedReason,
+              cancelReason: dep.cancelReason
+            });
+          }
+        }
+        const gateByNodeId = new Map(gates.map((g) => [g.nodeId, g]));
+        const nodeViews = nodes.map((node) => {
+          const queue = node.queueTaskId ? queueByTaskId.get(node.queueTaskId) : void 0;
+          const gateBlock = parseCoordinatorGateBlock(queue?.blockedReason);
+          const failures = queue?.dependsOn?.length ? deriveDependencyFailures(queue.dependsOn, statusById, depMetaById) : [];
+          return {
+            nodeId: node.nodeId,
+            ...node.ref ? { ref: node.ref } : {},
+            kind: node.kind,
+            state: node.state,
+            ...node.queueTaskId ? { taskId: node.queueTaskId } : {},
+            ...queue ? { taskStatus: queue.status } : {},
+            ...queue?.blockedReason ? { blockedReason: queue.blockedReason } : {},
+            ...gateBlock ? { blockedByGateId: gateBlock.gateId } : {},
+            materializationVersion: node.materializationVersion,
+            ...node.materializedDigest ? { materializedDigest: node.materializedDigest } : {},
+            ...node.skipReason ? { skipReason: node.skipReason } : {},
+            ...node.failureReason ? { failureReason: node.failureReason } : {},
+            ...failures.length > 0 ? { dependencyFailures: failures } : {},
+            ...describeNodeFeatures(node.baseSpecJson).length > 0 ? { features: describeNodeFeatures(node.baseSpecJson) } : {}
+          };
+        });
+        const edgeViews = edges.map((edge) => {
+          const source = byId.get(edge.fromNodeId);
+          const active = !(source?.state === "skipped" && edge.omitOnSkip);
+          return {
+            from: source?.ref ?? edge.fromNodeId,
+            to: byId.get(edge.toNodeId)?.ref ?? edge.toNodeId,
+            kind: edge.kind,
+            omitOnSkip: edge.omitOnSkip,
+            active
+          };
+        });
+        const gateViews = gates.map((gate) => {
+          const blocking = nodeViews.filter((n) => n.blockedByGateId === gate.gateId).map((n) => n.ref ?? n.nodeId);
+          const leaseExpired = gate.state === "claimed" && !!gate.leaseExpiresAt && gate.leaseExpiresAt <= nowIso;
+          return {
+            gateId: gate.gateId,
+            ...gate.ref ? { ref: gate.ref } : {},
+            nodeId: gate.nodeId,
+            state: gate.state,
+            action: gate.action,
+            ...gate.instructions ? { instructions: gate.instructions } : {},
+            onTimeout: gate.onTimeout,
+            leaseGeneration: gate.leaseGeneration,
+            ...gate.leaseOwnerSessionId ? { leaseOwnerSessionId: gate.leaseOwnerSessionId } : {},
+            ...gate.leaseExpiresAt ? { leaseExpiresAt: gate.leaseExpiresAt } : {},
+            ...leaseExpired ? { leaseExpired: true } : {},
+            ...gate.deadlineAt ? { deadlineAt: gate.deadlineAt } : {},
+            ...gate.releaseOutcome ? { releaseOutcome: gate.releaseOutcome } : {},
+            ...gate.eligibleCoordinatorSessionId ? { eligibleCoordinatorSessionId: gate.eligibleCoordinatorSessionId } : {},
+            ...blocking.length > 0 ? { blocking } : {}
+          };
+        });
+        const nodeStates = {};
+        for (const node of nodes) nodeStates[node.state] = (nodeStates[node.state] ?? 0) + 1;
+        const actions = [];
+        for (const gate of gateViews) {
+          if (gate.state === "awaiting_coordinator") {
+            actions.push({
+              kind: "gate_awaiting",
+              gateId: gate.gateId,
+              detail: `Gate '${gate.ref ?? gate.gateId}' (${gate.action}) is awaiting a coordinator. Claim it with mesh_graph_gate_claim, perform the action, then release it with mesh_graph_gate_release.`
+            });
+          } else if (gate.state === "claimed" && gate.leaseExpired) {
+            actions.push({
+              kind: "gate_reclaim",
+              gateId: gate.gateId,
+              detail: `Gate '${gate.ref ?? gate.gateId}' has a LAPSED lease (generation ${gate.leaseGeneration}). Reclaim it to get a higher generation; the previous owner may already have performed the external side effect, so reconcile external evidence before acting again.`
+            });
+          } else if (gate.state === "claimed") {
+            actions.push({
+              kind: "gate_claimed",
+              gateId: gate.gateId,
+              detail: `Gate '${gate.ref ?? gate.gateId}' is claimed by ${gate.leaseOwnerSessionId ?? "a coordinator"} until ${gate.leaseExpiresAt ?? "lease expiry"}; release it to advance the graph.`
+            });
+          } else if (gate.state === "expired" && gate.onTimeout === "hold") {
+            actions.push({
+              kind: "gate_reclaim",
+              gateId: gate.gateId,
+              detail: `Gate '${gate.ref ?? gate.gateId}' passed its deadline under on_timeout=hold \u2014 downstream is still held. Reclaim it (optionally with extend_deadline_seconds) to resume, or cancel the branch explicitly. A timeout is never passage: the gate cannot release itself.`
+            });
+          }
+        }
+        for (const ws of workspaces) {
+          if (ws.sagaState === "compensation_required") {
+            actions.push({
+              kind: "workspace_compensation",
+              workspaceRef: ws.workspaceRef,
+              detail: `Workspace '${ws.workspaceRef}' needs manual compensation: ${ws.lastError ?? "compensation refused"}.`
+            });
+          }
+        }
+        return {
+          graphId: graph.graphId,
+          batchId: graph.batchId,
+          status: graph.status,
+          ...graph.missionId ? { missionId: graph.missionId } : {},
+          enqueueSurface: graph.enqueueSurface,
+          schemaVersion: graph.schemaVersion,
+          createdAt: graph.createdAt,
+          ...graph.terminalAt ? { terminalAt: graph.terminalAt } : {},
+          onDependencyFailure: policy.on_dependency_failure,
+          ...policy.policyInvalid ? { policyInvalid: policy.policyInvalid } : {},
+          ...decision ? { orchestrationDecision: decision } : {},
+          counts: {
+            tasks: graph.taskCount,
+            gates: graph.gateCount,
+            workspaces: graph.workspaceCount,
+            edges: graph.dependencyEdgeCount
+          },
+          nodeStates,
+          nodes: nodeViews,
+          edges: edgeViews,
+          gates: gateViews,
+          workspaces: workspaces.map((w) => ({
+            ref: w.workspaceRef,
+            sagaState: w.sagaState,
+            ...w.branchIdentity ? { branchIdentity: w.branchIdentity } : {},
+            ...w.createdNodeId ? { createdNodeId: w.createdNodeId } : {},
+            ...w.createdWorktreePath ? { createdWorktreePath: w.createdWorktreePath } : {},
+            ...w.lastError ? { lastError: w.lastError } : {}
+          })),
+          ...actions.length > 0 ? { nextCoordinatorAction: actions } : {}
+        };
+      });
+    }
+    function describeNodeFeatures(baseSpecJson) {
+      let spec;
+      try {
+        const parsed = JSON.parse(baseSpecJson);
+        spec = parsed && typeof parsed === "object" ? parsed : void 0;
+      } catch {
+        return ["invalid_base_spec"];
+      }
+      if (!spec) return [];
+      const features = [];
+      if (Array.isArray(spec.inputs_from) && spec.inputs_from.length > 0) features.push("inputs_from");
+      if (spec.run_if !== void 0) features.push("run_if");
+      if (typeof spec.workspace_ref === "string" && spec.workspace_ref) features.push("workspace_ref");
+      return features;
+    }
+    function readOrchestrationDecision(policyJson) {
+      if (!policyJson) return void 0;
+      try {
+        const parsed = JSON.parse(policyJson);
+        const decision = parsed?.orchestration_decision;
+        return decision && typeof decision === "object" && !Array.isArray(decision) ? decision : void 0;
+      } catch {
+        return void 0;
+      }
+    }
+    init_mesh_graph_provenance();
     init_mesh_node_identity();
     init_mesh_active_work();
     init_mesh_idle_reminder();
@@ -111685,7 +113646,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     var path47 = __toESM2(require("path"));
     var fs41 = __toESM2(require("fs"));
     var path46 = __toESM2(require("path"));
-    var import_crypto14 = require("crypto");
+    var import_crypto16 = require("crypto");
     var TREE_DIGEST_ALGORITHM = "adhdev-provider-tree-sha256-v1";
     function computeProviderTreeDigest(rootDir, providerType) {
       const relPaths = [];
@@ -111698,7 +113659,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         );
       }
       relPaths.sort();
-      const hash2 = (0, import_crypto14.createHash)("sha256");
+      const hash2 = (0, import_crypto16.createHash)("sha256");
       for (const relPath of relPaths) {
         const absPath = path46.join(rootDir, ...relPath.split("/"));
         const bytes = fs41.readFileSync(absPath);
@@ -115775,11 +117736,11 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           let node;
           const { migrateProviderRolesToSlots: migrateProviderRolesToSlots2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           if (meshRecord.inline) {
-            const { randomUUID: randomUUID19 } = await import("crypto");
+            const { randomUUID: randomUUID20 } = await import("crypto");
             const clonedPolicy = { ...sourceNode.policy || {} };
             migrateProviderRolesToSlots2(clonedPolicy);
             node = {
-              id: `node_${randomUUID19().replace(/-/g, "")}`,
+              id: `node_${randomUUID20().replace(/-/g, "")}`,
               workspace: result.worktreePath,
               repoRoot: result.worktreePath,
               daemonId: sourceNode.daemonId,
@@ -116311,8 +118272,10 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2, describeTaskDependencyState: describeTaskDependencyState2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
           const status = Array.isArray(args?.status) ? args.status.map((s2) => typeof s2 === "string" ? s2.trim() : "").filter(Boolean) : void 0;
           const rawQueue = getQueue2(meshId, { status });
-          const statusById = new Map(getQueue2(meshId).map((task) => [task.id, task.status]));
-          const queue = rawQueue.map((task) => Array.isArray(task.dependsOn) && task.dependsOn.length > 0 ? { ...task, ...describeTaskDependencyState2(task, statusById) } : task);
+          const allQueue = getQueue2(meshId);
+          const statusById = new Map(allQueue.map((task) => [task.id, task.status]));
+          const depMetaById = new Map(allQueue.map((task) => [task.id, task]));
+          const queue = rawQueue.map((task) => Array.isArray(task.dependsOn) && task.dependsOn.length > 0 ? { ...task, ...describeTaskDependencyState2(task, statusById, depMetaById) } : task);
           const summary = getMeshQueueStats2(meshId);
           return {
             success: true,
@@ -127391,7 +129354,7 @@ data: ${JSON.stringify(msg.data)}
         });
       }
     };
-    var import_crypto15 = require("crypto");
+    var import_crypto17 = require("crypto");
     var import_session_host_core12 = require_dist();
     var BASE_KEY_SEQUENCES = {
       enter: "\r",
@@ -127489,7 +129452,7 @@ data: ${JSON.stringify(msg.data)}
         const sessionId = String(options.sessionId || "").trim();
         if (!sessionId) throw new Error("sessionId is required");
         const mode = options.mode || "read";
-        const clientId = options.clientId || `raw-terminal-${process.pid}-${(0, import_crypto15.randomUUID)().slice(0, 8)}`;
+        const clientId = options.clientId || `raw-terminal-${process.pid}-${(0, import_crypto17.randomUUID)().slice(0, 8)}`;
         const client = options.client || new import_session_host_core12.SessionHostClient({ endpoint: options.endpoint });
         await client.connect();
         const attachResponse = await client.request({
@@ -128253,7 +130216,7 @@ data: ${JSON.stringify(msg.data)}
     init_mesh_reconcile_loop();
     var import_fs19 = require("fs");
     var import_path20 = require("path");
-    var import_crypto16 = require("crypto");
+    var import_crypto18 = require("crypto");
     init_logger();
     init_mesh_ledger();
     init_mesh_runtime_store();
@@ -128287,7 +130250,7 @@ data: ${JSON.stringify(msg.data)}
       try {
         const fingerprint = buildPendingEventFingerprint(event);
         MeshRuntimeStore.getInstance().insertPendingEvent({
-          id: (0, import_crypto16.randomUUID)(),
+          id: (0, import_crypto18.randomUUID)(),
           meshId: event.meshId,
           coordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
           event: event.event,
@@ -128408,6 +130371,73 @@ data: ${JSON.stringify(msg.data)}
       }
       return newlyFrozen;
     }
+    var import_node_perf_hooks = require("perf_hooks");
+    init_logger();
+    var EVENT_LOOP_MONITOR_INTERVAL_ENV = "ADHDEV_EVENT_LOOP_MONITOR_INTERVAL_MS";
+    var EVENT_LOOP_LAG_WARN_ENV = "ADHDEV_EVENT_LOOP_LAG_WARN_MS";
+    var DEFAULT_EVENT_LOOP_MONITOR_INTERVAL_MS = 1e4;
+    var DEFAULT_EVENT_LOOP_LAG_WARN_MS = 5e3;
+    function parseMs(raw, fallback) {
+      if (raw === void 0 || raw.trim() === "") return fallback;
+      const parsed = Number.parseInt(raw, 10);
+      return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+    }
+    function resolveEventLoopMonitorIntervalMs(env2 = process.env) {
+      return parseMs(env2[EVENT_LOOP_MONITOR_INTERVAL_ENV], DEFAULT_EVENT_LOOP_MONITOR_INTERVAL_MS);
+    }
+    function resolveEventLoopLagWarnMs(env2 = process.env) {
+      return parseMs(env2[EVENT_LOOP_LAG_WARN_ENV], DEFAULT_EVENT_LOOP_LAG_WARN_MS);
+    }
+    function defaultLogFn(level, message) {
+      if (level === "warn") LOG2.warn("EventLoop", message);
+      else LOG2.debug("EventLoop", message);
+    }
+    function startEventLoopMonitor(opts) {
+      const intervalMs = opts?.intervalMs ?? resolveEventLoopMonitorIntervalMs();
+      const warnMs = opts?.warnMs ?? resolveEventLoopLagWarnMs();
+      const logFn = opts?.logFn ?? defaultLogFn;
+      if (intervalMs <= 0) return { stop: () => {
+      } };
+      let histogram;
+      try {
+        histogram = (0, import_node_perf_hooks.monitorEventLoopDelay)({ resolution: 20 });
+        histogram.enable();
+      } catch {
+        return { stop: () => {
+        } };
+      }
+      let expectedTickAt = null;
+      const timer = setInterval(() => {
+        try {
+          const now = Date.now();
+          const driftMs = expectedTickAt === null ? 0 : Math.max(0, now - expectedTickAt);
+          expectedTickAt = now + intervalMs;
+          const maxMs = histogram.max / 1e6;
+          const p99Ms = histogram.percentile(99) / 1e6;
+          const meanMs = histogram.mean / 1e6;
+          histogram.reset();
+          const worstMs = Math.max(driftMs, maxMs);
+          const message = `event-loop lag: drift=${driftMs.toFixed(0)}ms max=${maxMs.toFixed(0)}ms p99=${p99Ms.toFixed(0)}ms mean=${meanMs.toFixed(1)}ms over ${intervalMs}ms window`;
+          if (worstMs >= warnMs) {
+            logFn("warn", `${message} \u2014 EXCEEDS ${warnMs}ms: the whole daemon process was frozen/unscheduled (machine saturation), not one slow handler. Expect IPC probe timeouts and reconcile-tick gaps in this window.`);
+          } else {
+            logFn("debug", message);
+          }
+        } catch {
+        }
+      }, intervalMs);
+      expectedTickAt = Date.now() + intervalMs;
+      timer.unref?.();
+      return {
+        stop: () => {
+          clearInterval(timer);
+          try {
+            histogram.disable();
+          } catch {
+          }
+        }
+      };
+    }
     init_require_whitelist();
     async function initDaemonComponents2(config2) {
       applyProcessHardening();
@@ -128707,6 +130737,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         refreshQuotaCacheOnBoot(isQuotaProviderEnabled);
       });
       setImmediate(() => void router.resumePendingRefineJobsOnStartup());
+      components.eventLoopMonitor = startEventLoopMonitor();
       setImmediate(() => router.resumeDeferredRestartsOnStartup());
       return components;
     }
@@ -128736,10 +130767,15 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         meshReconcileLoop,
         quotaRefreshLoop,
         quotaEventRefresh,
-        providerStalenessProbe
+        providerStalenessProbe,
+        eventLoopMonitor
       } = components;
       poller.stop();
       cdpInitializer.stop();
+      try {
+        eventLoopMonitor?.stop();
+      } catch {
+      }
       try {
         meshReconcileLoop?.stop();
       } catch {