@adhdev/daemon-standalone 1.0.56-rc.8 → 1.0.56-rc.9

package/dist/index.js

@@ -36620,10 +36620,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "f45b1ccbf70f856ec2232e2dc5a87acaf875243e" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "f45b1ccb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.56-rc.8" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-19T16:04:19.674Z" : void 0);
+      const commit = readInjected(true ? "346a82b2748c5a3d6ab32d126bbe7399d24d9a82" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "346a82b2" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.56-rc.9" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-19T22:46:34.487Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -42860,6 +42860,7 @@ ${error48.message || ""}`;
           "mesh_graph_view",
           "mesh_graph_gate_claim",
           "mesh_graph_gate_release",
+          "mesh_graph_gate_abandon",
           "mesh_queue_cancel",
           "mesh_queue_requeue",
           "mesh_send_task",
@@ -57196,6 +57197,7 @@ When you compose the task message you dispatch to a node, include this requireme
 | \`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). **A gate and its dependents are one unit**: a gate earns its keep only when some task names it in \`gated_by\`, because releasing it is what dispatches that task. A gate nothing depends on opens nothing and is pure claim/release overhead \u2014 declare the follower in the same batch, or skip the gate |
+| \`mesh_graph_gate_abandon\` | Give up on a gate that can never be opened, so its graph can go terminal. **Not a pass**: it CANCELS everything the gate was holding and produces no gate outcome. Use it when you cancelled the work behind a gate \u2014 otherwise that gate stays awaiting forever and the graph reaches no terminal state, not even cancelled |
 | \`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 |
@@ -57270,6 +57272,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
        - **"The only thing I am sure of right now is this one task" is not evidence of a single.** That feeling is about your confidence, not about how many steps are settled; two steps are routinely settled at once while it still feels that way. Count the steps you would actually dispatch. If that count is two or more, it is a batch no matter how the plan feels.
        - **"I cannot choose the next step until I see this result" states that the next step EXISTS.** What the result decides is *which branch you take*, not *whether* there is a follow-up \u2014 and a branch that turns on a predecessor's output is what \`run_if\` selects, what \`inputs_from\` feeds, and what a coordinator gate holds until you decide. Needing to look at evidence before choosing is the ordinary case for a graph edge, not an exception to it.
        - **A gate or a batch is not overhead when something follows it.** The extra call buys the dispatch of everything behind it, so it costs one call and saves a whole round-trip through you. The only genuinely wasteful gate is one nothing depends on \u2014 a gate no task names in \`gated_by\` opens nothing when released, which the release response tells you about; that case is answered by declaring the follower, not by abandoning the batch.
+       - **If you cancel the tasks behind a gate, close the gate too.** Cancelling a task never touches the gate that was holding it \u2014 gates are a separate control plane on purpose. A gate left over a cancelled branch stays \`awaiting_coordinator\` forever, and while ANY gate is unsettled its graph can reach no terminal state at all, not even \`cancelled\`. Close it with \`mesh_graph_gate_abandon\` and a reason. \`mesh_graph_view\` flags this case for you as a \`gate_abandon\` action. Abandon is not a shortcut through a gate: it cancels whatever the gate was holding and yields no gate outcome, so use \`mesh_graph_gate_release\` whenever you actually want the downstream work to run.
 
    When you do use \`mesh_enqueue_task\`, pass \`orchestration_decision\` recording why a single was right (\`single_reason\`: \`only_one_step_known\` / \`future_step_not_specifiable\` / \`same_session_continuation\` / \`legacy_client\` / \`operator_override\`). Omitting it is recorded as \`decision_missing\`.
 
@@ -60972,6 +60975,98 @@ ${rendered}`, "utf-8");
         store.updateQueueEntry(entry);
       }
     }
+    function coordinatorGateAbandonedReason(gateId) {
+      return `coordinator_gate_abandoned:${gateId}`;
+    }
+    function abandonMeshGraphGate(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) {
+          return { abandoned: false, reason: "gate_not_found", cancelledNodeIds: [], cancelledTaskIds: [] };
+        }
+        if (gate.state === "cancelled") {
+          return { abandoned: true, reason: "gate_already_abandoned", gate, cancelledNodeIds: [], cancelledTaskIds: [] };
+        }
+        if (gate.state === "released") {
+          return { abandoned: false, reason: `gate_terminal:${gate.state}`, gate, cancelledNodeIds: [], cancelledTaskIds: [] };
+        }
+        if (!input.force && gate.state === "claimed" && gate.leaseExpiresAt && gate.leaseExpiresAt > nowIso) {
+          return { abandoned: false, reason: "gate_lease_held", gate, cancelledNodeIds: [], cancelledTaskIds: [] };
+        }
+        const abandonReason = `${coordinatorGateAbandonedReason(gate.gateId)}:${input.reason}`;
+        const won = graphStore.patchGate(gate.gateId, {
+          state: "cancelled",
+          // Drop the lease: an abandoned gate has no owner and no live fence.
+          leaseOwnerSessionId: null,
+          fencingToken: null,
+          leaseExpiresAt: null
+        }, nowIso, { leaseGeneration: gate.leaseGeneration });
+        if (!won) {
+          return { abandoned: false, reason: "gate_abandon_race", gate, cancelledNodeIds: [], cancelledTaskIds: [] };
+        }
+        const node = graphStore.getNode(gate.graphId, gate.nodeId);
+        if (node && node.state !== "cancelled") {
+          graphStore.updateNodeState(gate.graphId, gate.nodeId, "cancelled", nowIso, { failureReason: abandonReason });
+        }
+        const cancelledNodeIds = node ? cancelGateDownstreamSubtree(store, node, nowIso, abandonReason) : [];
+        const cancelledTaskIds = [];
+        for (const nodeId of cancelledNodeIds) {
+          const target = graphStore.getNode(gate.graphId, nodeId);
+          if (target?.queueTaskId) cancelledTaskIds.push(target.queueTaskId);
+        }
+        const graph = graphStore.getGraph(gate.graphId);
+        let graphStatus;
+        const rolled = classifyGraphRollup(graphStore.listNodes(gate.graphId));
+        if (graph && rolled && graph.status !== rolled) {
+          graphStore.updateGraphStatus(gate.graphId, rolled, nowIso, true);
+          graphStatus = rolled;
+          insertGateOutbox(
+            graphStore,
+            gate.meshId,
+            gate.graphId,
+            rolled === "completed" ? "graph_completed" : rolled === "failed" ? "graph_failed" : "graph_cancelled",
+            { graphId: gate.graphId, status: rolled },
+            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);
+            graphStatus = "active";
+          }
+        }
+        insertGateOutbox(graphStore, gate.meshId, gate.graphId, "graph_gate_abandoned", {
+          graphId: gate.graphId,
+          gateId: gate.gateId,
+          nodeId: gate.nodeId,
+          ref: gate.ref,
+          action: gate.action,
+          priorState: gate.state,
+          reason: input.reason,
+          ...input.coordinatorSessionId ? { coordinatorSessionId: input.coordinatorSessionId } : {},
+          ...input.force ? { force: true } : {},
+          ...cancelledNodeIds.length > 0 ? { cancelledNodeIds } : {}
+        }, nowIso);
+        return {
+          abandoned: true,
+          gate: graphStore.getGate(gate.gateId),
+          cancelledNodeIds,
+          cancelledTaskIds,
+          ...graphStatus ? { graphStatus } : {}
+        };
+      });
+      if (result.abandoned) {
+        try {
+          drainMeshGraphOutbox(input.meshId);
+        } catch {
+        }
+      }
+      return result;
+    }
     function sweepMeshGraphGateTimeouts(meshId, nowMs) {
       const store = MeshRuntimeStore.getInstance();
       const now = nowMs ?? Date.now();
@@ -61024,7 +61119,7 @@ ${rendered}`, "utf-8");
     function isCancelExempt(state) {
       return state === "completed" || state === "released" || state === "skipped" || state === "cancelled" || state === "failed" || state === "expired";
     }
-    function cancelGateDownstreamSubtree(store, gateNode, nowIso) {
+    function cancelGateDownstreamSubtree(store, gateNode, nowIso, reason = `coordinator_gate_timeout:${gateNode.nodeId}`) {
       const graphStore = store.graphStore();
       const nodes = graphStore.listNodes(gateNode.graphId);
       const edges = graphStore.listEdges(gateNode.graphId);
@@ -61041,13 +61136,13 @@ ${rendered}`, "utf-8");
             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}`
+              failureReason: reason
             });
             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}`;
+                entry.blockedReason = reason;
                 store.updateQueueEntry(entry);
               }
             }
@@ -61084,6 +61179,7 @@ ${rendered}`, "utf-8");
         init_logger();
         init_mesh_graph_input_binding();
         init_mesh_graph_types();
+        init_mesh_graph_derived_failure();
         init_mesh_graph_transition_runner();
         init_mesh_graph_transition_runner();
         MESH_GATE_DEFAULT_LEASE_SECONDS = 900;
@@ -61216,6 +61312,20 @@ ${rendered}`, "utf-8");
         ...p.cancelledNodeIds?.length ? { cancelledNodeIds: p.cancelledNodeIds } : {}
       });
     }
+    function recordGraphGateAbandoned(meshId, p) {
+      safeAppend(meshId, "graph_gate_abandoned", {
+        graphId: p.graphId,
+        gateId: p.gateId,
+        ...p.ref ? { ref: p.ref } : {},
+        action: p.action,
+        priorState: p.priorState,
+        reason: p.reason.slice(0, 500),
+        ...p.coordinatorSessionId ? { coordinatorSessionId: p.coordinatorSessionId } : {},
+        ...p.force ? { force: true } : {},
+        ...p.cancelledNodeIds?.length ? { cancelledNodeIds: p.cancelledNodeIds } : {},
+        ...p.graphStatus ? { graphStatus: p.graphStatus } : {}
+      });
+    }
     var MESH_VALID_SINGLE_REASONS;
     var MESH_SUPERSEDED_SINGLE_REASONS;
     var MESH_DECLARED_ELIGIBLE_SINGLE_HINT;
@@ -70844,81 +70954,6 @@ ${cleanBody}`;
         init_mesh_events_utils();
       }
     });
-    function bootstrapQueueTaskCountsAsHandled(task, bootstrapNodeId, nowMs) {
-      if (!meshNodeIdMatches({ id: task.targetNodeId }, bootstrapNodeId)) return false;
-      if (task.status === "assigned") return true;
-      const al = task.autoLaunch;
-      if (!al) return true;
-      if (al.status === "started" || al.status === "completed") {
-        const launchedAtMs = Date.parse(al.updatedAt);
-        return Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
-      }
-      return true;
-    }
-    function resolveCoordinatorDrainDaemonIds(components) {
-      const statusInstanceId = readNonEmptyString(components.statusInstanceId);
-      const machineId = readNonEmptyString(loadConfig2().machineId);
-      return expandDaemonIdForms([statusInstanceId, machineId]);
-    }
-    function getCachedMeshByWorkspace(workspace) {
-      const now = Date.now();
-      const cached5 = meshByWorkspaceCache.get(workspace);
-      if (cached5 && now - cached5.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached5.mesh;
-      const mesh = getMeshByRepo(workspace);
-      meshByWorkspaceCache.set(workspace, { mesh, cachedAt: now });
-      return mesh;
-    }
-    function recoverMeshIdByNodeId(nodeId) {
-      if (!nodeId) return "";
-      for (const mesh of listMeshes()) {
-        if (Array.isArray(mesh.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, nodeId))) {
-          return readNonEmptyString(mesh.id);
-        }
-      }
-      return "";
-    }
-    function recoverMeshIdByCoordinatorAndNode(coordinatorDaemonId, nodeId) {
-      if (!coordinatorDaemonId) return "";
-      const hosted = listMeshes().filter((mesh) => {
-        const host = resolveMeshHostStatus(mesh);
-        return host.role === "host" && (!host.hostDaemonId || daemonIdsEquivalent(host.hostDaemonId, coordinatorDaemonId));
-      });
-      if (hosted.length === 0) return "";
-      if (nodeId) {
-        const byNode = hosted.find((mesh) => Array.isArray(mesh.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, nodeId)));
-        if (byNode) return readNonEmptyString(byNode.id);
-        return "";
-      }
-      return hosted.length === 1 ? readNonEmptyString(hosted[0].id) : "";
-    }
-    function resolveForwardEventMeshId(components, payload) {
-      const direct = readNonEmptyString(payload.meshId);
-      if (direct) return direct;
-      const workspace = readNonEmptyString(payload.workspace);
-      const byWorkspace = workspace ? readNonEmptyString(getCachedMeshByWorkspace(workspace)?.id) : "";
-      if (byWorkspace) return byWorkspace;
-      const byNode = recoverMeshIdByNodeId(readNonEmptyString(payload.nodeId));
-      if (byNode) return byNode;
-      const sessionId = readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId);
-      if (sessionId) {
-        try {
-          const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
-          const settings = state?.settings || {};
-          const meshNodeFor = readNonEmptyString(settings.meshNodeFor);
-          if (meshNodeFor) return meshNodeFor;
-          const byStamp = recoverMeshIdByNodeId(readNonEmptyString(settings.meshNodeId));
-          if (byStamp) return byStamp;
-          const sessionWorkspace = readNonEmptyString(state?.workspace);
-          const bySessionWorkspace = sessionWorkspace ? readNonEmptyString(getCachedMeshByWorkspace(sessionWorkspace)?.id) : "";
-          if (bySessionWorkspace) return bySessionWorkspace;
-        } catch {
-        }
-      }
-      return "";
-    }
-    function __resetMeshWorkspaceCacheForTests() {
-      meshByWorkspaceCache.clear();
-    }
     function sweepExpiredRemoteIdleSessions() {
       try {
         MeshRuntimeStore.getInstance().pruneExpiredRemoteIdleSessions();
@@ -71046,6 +71081,10 @@ ${cleanBody}`;
       if (explicit) return explicit;
       return extractJsonObjectFromSummary(readNonEmptyString(metadataEvent.finalSummary) || void 0);
     }
+    function resolveUnifiedCompletionEvidenceLevel(args) {
+      if (args.computedLevel === "insufficient" || args.priorLevel === "insufficient") return "insufficient";
+      return args.computedLevel || args.priorLevel;
+    }
     function supersedesTruncatedTerminalSummary(args) {
       if (!args.terminalTaskId || !args.eventTaskId || args.terminalTaskId !== args.eventTaskId) return false;
       if (!isGenuineCompletionEvidence(args.metadataEvent)) return false;
@@ -71086,7 +71125,7 @@ ${cleanBody}`;
       return false;
     }
     function evaluateMeshEventSuppression(args, ctx) {
-      const { traceCtx, eventSessionId, eventNodeId, eventTimestamp, workerCoordinatorDaemonId, components } = ctx;
+      const { traceCtx, eventSessionId, eventNodeId, eventTimestamp, workerCoordinatorDaemonId, components, injectMeshSystemMessage: injectMeshSystemMessage2 } = ctx;
       const intentionalCleanupStop = shouldSuppressIntentionalCleanupStop({
         event: args.event,
         meshId: args.meshId,
@@ -71172,7 +71211,7 @@ ${cleanBody}`;
                 eventSessionId,
                 attempt
               });
-              const heldForRetry = retryEligible && holdCompletionForLiveStateRetry(components, args, eventSessionId, Date.now(), injectMeshSystemMessage);
+              const heldForRetry = retryEligible && holdCompletionForLiveStateRetry(components, args, eventSessionId, Date.now(), injectMeshSystemMessage2);
               const authorityDetail = !authority.authoritative && authority.detail ? ` [authorityClass=${authority.detail.authorityClass ?? "none"} evidenceSource=${authority.detail.evidenceSource ?? "none"} timing=${authority.detail.timing ?? "none"}]` : "";
               LOG2.info("MeshEvents", `Suppressed agent:generating_completed for session ${eventSessionId} (mesh ${args.meshId}): current live evidence remains pending (${live.kind ?? "unknown"}); transcript authority=${authority.authoritative ? "fresh_but_not_newer" : authority.reason}${authorityDetail}${heldForRetry ? " \u2014 bounded content-free retry armed" : ""}`);
               traceMeshEventDrop(
@@ -71218,7 +71257,7 @@ ${cleanBody}`;
               args,
               eventSessionId,
               Date.now(),
-              injectMeshSystemMessage
+              injectMeshSystemMessage2
             );
             LOG2.info("MeshEvents", `Suppressed agent:generating_completed for session ${eventSessionId} (mesh ${args.meshId}): terminal admission declined (${admission.reason}) \u2014 ${admission.detail}${heldForRetry ? " \u2014 bounded content-free retry armed" : ""}`);
             traceMeshEventDrop(
@@ -71485,6 +71524,119 @@ ${cleanBody}`;
       }
       return false;
     }
+    var lastPendingEventsPruneAt;
+    var PENDING_EVENTS_PRUNE_INTERVAL_MS;
+    var INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
+    var RECENT_COMPLETION_FINGERPRINT_TTL_MS;
+    var RECONCILED_COMPLETION_SOURCES;
+    var turnOutboxDrainScheduled;
+    var init_mesh_event_suppression = __esm2({
+      "src/mesh/mesh-event-suppression.ts"() {
+        "use strict";
+        init_logger();
+        init_mesh_ledger();
+        init_mesh_work_queue();
+        init_mesh_runtime_store();
+        init_mesh_events_pending();
+        init_mesh_event_trace();
+        init_dist();
+        init_mesh_events_stale();
+        init_mesh_task_inflight();
+        init_mesh_node_identity();
+        init_mesh_events_utils();
+        init_mesh_turn_ledger();
+        init_mesh_turn_presentation();
+        init_mesh_queue_assignment();
+        init_mesh_completion_live_gate();
+        init_mesh_provider_event_admission();
+        lastPendingEventsPruneAt = 0;
+        PENDING_EVENTS_PRUNE_INTERVAL_MS = 60 * 60 * 1e3;
+        INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
+        RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
+        RECONCILED_COMPLETION_SOURCES = /* @__PURE__ */ new Set([
+          "direct_task_transcript_reconciliation",
+          "daemon_reconcile_transcript_completion",
+          "mcp_mesh_status_transcript_reconciliation",
+          "no_progress_reconciliation"
+        ]);
+        turnOutboxDrainScheduled = false;
+      }
+    });
+    function bootstrapQueueTaskCountsAsHandled(task, bootstrapNodeId, nowMs) {
+      if (!meshNodeIdMatches({ id: task.targetNodeId }, bootstrapNodeId)) return false;
+      if (task.status === "assigned") return true;
+      const al = task.autoLaunch;
+      if (!al) return true;
+      if (al.status === "started" || al.status === "completed") {
+        const launchedAtMs = Date.parse(al.updatedAt);
+        return Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+      }
+      return true;
+    }
+    function resolveCoordinatorDrainDaemonIds(components) {
+      const statusInstanceId = readNonEmptyString(components.statusInstanceId);
+      const machineId = readNonEmptyString(loadConfig2().machineId);
+      return expandDaemonIdForms([statusInstanceId, machineId]);
+    }
+    function getCachedMeshByWorkspace(workspace) {
+      const now = Date.now();
+      const cached5 = meshByWorkspaceCache.get(workspace);
+      if (cached5 && now - cached5.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached5.mesh;
+      const mesh = getMeshByRepo(workspace);
+      meshByWorkspaceCache.set(workspace, { mesh, cachedAt: now });
+      return mesh;
+    }
+    function recoverMeshIdByNodeId(nodeId) {
+      if (!nodeId) return "";
+      for (const mesh of listMeshes()) {
+        if (Array.isArray(mesh.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, nodeId))) {
+          return readNonEmptyString(mesh.id);
+        }
+      }
+      return "";
+    }
+    function recoverMeshIdByCoordinatorAndNode(coordinatorDaemonId, nodeId) {
+      if (!coordinatorDaemonId) return "";
+      const hosted = listMeshes().filter((mesh) => {
+        const host = resolveMeshHostStatus(mesh);
+        return host.role === "host" && (!host.hostDaemonId || daemonIdsEquivalent(host.hostDaemonId, coordinatorDaemonId));
+      });
+      if (hosted.length === 0) return "";
+      if (nodeId) {
+        const byNode = hosted.find((mesh) => Array.isArray(mesh.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, nodeId)));
+        if (byNode) return readNonEmptyString(byNode.id);
+        return "";
+      }
+      return hosted.length === 1 ? readNonEmptyString(hosted[0].id) : "";
+    }
+    function resolveForwardEventMeshId(components, payload) {
+      const direct = readNonEmptyString(payload.meshId);
+      if (direct) return direct;
+      const workspace = readNonEmptyString(payload.workspace);
+      const byWorkspace = workspace ? readNonEmptyString(getCachedMeshByWorkspace(workspace)?.id) : "";
+      if (byWorkspace) return byWorkspace;
+      const byNode = recoverMeshIdByNodeId(readNonEmptyString(payload.nodeId));
+      if (byNode) return byNode;
+      const sessionId = readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId);
+      if (sessionId) {
+        try {
+          const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+          const settings = state?.settings || {};
+          const meshNodeFor = readNonEmptyString(settings.meshNodeFor);
+          if (meshNodeFor) return meshNodeFor;
+          const byStamp = recoverMeshIdByNodeId(readNonEmptyString(settings.meshNodeId));
+          if (byStamp) return byStamp;
+          const sessionWorkspace = readNonEmptyString(state?.workspace);
+          const bySessionWorkspace = sessionWorkspace ? readNonEmptyString(getCachedMeshByWorkspace(sessionWorkspace)?.id) : "";
+          if (bySessionWorkspace) return bySessionWorkspace;
+        } catch {
+        }
+      }
+      return "";
+    }
+    function __resetMeshWorkspaceCacheForTests() {
+      meshByWorkspaceCache.clear();
+    }
     function injectMeshSystemMessage(components, args) {
       const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
       const eventNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
@@ -71562,7 +71714,8 @@ ${cleanBody}`;
         eventNodeId,
         eventTimestamp,
         workerCoordinatorDaemonId,
-        components
+        components,
+        injectMeshSystemMessage
       });
       if (suppression) {
         if (suppression.kind === "reconcile") {
@@ -72039,7 +72192,36 @@ ${cleanBody}`;
               // worker-result-shaped, e.g. a MAGI envelope) is concrete evidence and must
               // resolve to 'sufficient' — resolveWorkerResult now upgrades that case so a
               // complete, valid answer is no longer mislabelled insufficient/reviewRecommended.
-              ...completionEvidence ? completionEvidence.workerResult.source === "default" ? { evidenceLevel: "insufficient", reviewRecommended: true } : { evidenceLevel: "sufficient" } : {},
+              //
+              // EVIDENCE-LEVEL-UNIFY: the LEDGER value is merged with whatever
+              // applyTaskModeCompletionEvidence already stamped onto
+              // args.metadataEvent.evidenceLevel earlier in markSessionTerminal, so a
+              // 'reported' stamp can never make the ledger forget a locally-computed
+              // 'insufficient' (and vice versa). See resolveUnifiedCompletionEvidenceLevel.
+              //
+              // ONE-WAY ON PURPOSE — do NOT write the resolved level back onto
+              // args.metadataEvent. That mutation looks like the natural way to make the
+              // later buildMeshSystemMessage read agree with the ledger, but
+              // metadataEvent.evidenceLevel is load-bearing for DEDUP, not just wording:
+              // buildPendingEventFingerprint (mesh-events-pending.ts) keys terminal
+              // completions `…::weak` / `…::genuine` off isWeakCompletionMetadata, which
+              // reads this very field. Stamping 'insufficient' back onto an ordinary
+              // completion (workerResult.source === 'default' is the COMMON plain-text
+              // finalSummary case, not an anomaly) moves it into the `::weak` slot, where
+              // it collides with an earlier weak synth for the same taskId and the
+              // genuine completion is dropped as a duplicate — the exact swallow that
+              // EARLYNOTIFY-GATEBYPASS guards against. The ledger records the stricter
+              // verdict; the coordinator-facing weakness signal stays owned by the
+              // producers that set it deliberately.
+              ...(() => {
+                const computedLevel = completionEvidence ? completionEvidence.workerResult.source === "default" ? "insufficient" : "sufficient" : void 0;
+                const resolvedLevel = resolveUnifiedCompletionEvidenceLevel({
+                  computedLevel,
+                  priorLevel: readNonEmptyString(args.metadataEvent.evidenceLevel)
+                });
+                if (!resolvedLevel) return {};
+                return resolvedLevel === "insufficient" ? { evidenceLevel: resolvedLevel, reviewRecommended: true } : { evidenceLevel: resolvedLevel };
+              })(),
               // FALSE-COMPLETION-GIT-EVIDENCE: markSessionTerminal's synchronous git-clean
               // gate stamps this onto metadataEvent BEFORE this ledger append runs — OR it
               // into reviewRecommended (never downgrade the NOTIF Defect-2b verdict above)
@@ -72537,12 +72719,6 @@ ${cleanBody}`;
     var REMOTE_IDLE_SESSION_TTL_MS;
     var meshByWorkspaceCache;
     var MESH_WORKSPACE_CACHE_TTL_MS;
-    var lastPendingEventsPruneAt;
-    var PENDING_EVENTS_PRUNE_INTERVAL_MS;
-    var INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
-    var RECENT_COMPLETION_FINGERPRINT_TTL_MS;
-    var RECONCILED_COMPLETION_SOURCES;
-    var turnOutboxDrainScheduled;
     var init_mesh_event_forwarding = __esm2({
       "src/mesh/mesh-event-forwarding.ts"() {
         "use strict";
@@ -72569,28 +72745,15 @@ ${cleanBody}`;
         init_mesh_events_stale();
         init_mesh_task_inflight();
         init_mesh_graph_transition_runner();
-        init_mesh_node_identity();
         init_mesh_events_utils();
         init_mesh_event_classify();
         init_mesh_turn_ledger();
-        init_mesh_turn_presentation();
         init_mesh_queue_assignment();
-        init_mesh_completion_live_gate();
-        init_mesh_provider_event_admission();
+        init_mesh_event_suppression();
+        init_mesh_event_suppression();
         REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
         meshByWorkspaceCache = /* @__PURE__ */ new Map();
         MESH_WORKSPACE_CACHE_TTL_MS = 5e3;
-        lastPendingEventsPruneAt = 0;
-        PENDING_EVENTS_PRUNE_INTERVAL_MS = 60 * 60 * 1e3;
-        INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
-        RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
-        RECONCILED_COMPLETION_SOURCES = /* @__PURE__ */ new Set([
-          "direct_task_transcript_reconciliation",
-          "daemon_reconcile_transcript_completion",
-          "mcp_mesh_status_transcript_reconciliation",
-          "no_progress_reconciliation"
-        ]);
-        turnOutboxDrainScheduled = false;
       }
     });
     var init_mesh_events_coordinator = __esm2({
@@ -83162,6 +83325,7 @@ ${e?.stderr || ""}`;
       WORKSPACE_OWNER_GIT_CONFIG_KEY: () => WORKSPACE_OWNER_GIT_CONFIG_KEY,
       WORKSPACE_SAGA_LEASE_MS: () => WORKSPACE_SAGA_LEASE_MS,
       WorkspaceSagaPermanentError: () => WorkspaceSagaPermanentError,
+      abandonMeshGraphGate: () => abandonMeshGraphGate,
       addNode: () => addNode,
       appendLedgerEntry: () => appendLedgerEntry,
       appendRecentActivity: () => appendRecentActivity,
@@ -83235,6 +83399,7 @@ ${e?.stderr || ""}`;
       configureDebugTraceStore: () => configureDebugTraceStore,
       connectCdpManager: () => connectCdpManager,
       consoleSymbols: () => consoleSymbols,
+      coordinatorGateAbandonedReason: () => coordinatorGateAbandonedReason,
       coordinatorGateBlockReason: () => coordinatorGateBlockReason,
       coordinatorIdentityFromEmitFields: () => coordinatorIdentityFromEmitFields,
       createDebugTraceStore: () => createDebugTraceStore,
@@ -83499,6 +83664,7 @@ ${e?.stderr || ""}`;
       recordGraphEnqueueCommitted: () => recordGraphEnqueueCommitted,
       recordGraphEnqueueRolledBack: () => recordGraphEnqueueRolledBack,
       recordGraphEnqueueValidationFailed: () => recordGraphEnqueueValidationFailed,
+      recordGraphGateAbandoned: () => recordGraphGateAbandoned,
       recordGraphGateClaimed: () => recordGraphGateClaimed,
       recordGraphGateExpired: () => recordGraphGateExpired,
       recordGraphGateReleased: () => recordGraphGateReleased,
@@ -86660,8 +86826,25 @@ ${e?.stderr || ""}`;
         });
         const nodeStates = {};
         for (const node of nodes) nodeStates[node.state] = (nodeStates[node.state] ?? 0) + 1;
+        const orphanedGateIds = /* @__PURE__ */ new Set();
+        for (const gate of gates) {
+          if (gate.state !== "awaiting_coordinator" && gate.state !== "claimed" && gate.state !== "expired") continue;
+          const downstream = edges.filter((e) => e.fromNodeId === gate.nodeId).map((e) => byId.get(e.toNodeId)).filter((n) => !!n);
+          if (downstream.length === 0) continue;
+          if (downstream.every((n) => n.state === "cancelled" || n.state === "failed" || n.state === "skipped")) {
+            orphanedGateIds.add(gate.gateId);
+          }
+        }
         const actions = [];
         for (const gate of gateViews) {
+          if (orphanedGateIds.has(gate.gateId)) {
+            actions.push({
+              kind: "gate_abandon",
+              gateId: gate.gateId,
+              detail: `Gate '${gate.ref ?? gate.gateId}' (${gate.action}) is ORPHANED: every task it was gating is already cancelled, failed or skipped, so releasing it would open nothing. While it stays unsettled this graph cannot reach ANY terminal state \u2014 not even cancelled. Close it with mesh_graph_gate_abandon and a reason. Abandon cancels what the gate was holding; it never passes the gate.`
+            });
+            continue;
+          }
           if (gate.state === "awaiting_coordinator") {
             actions.push({
               kind: "gate_awaiting",
@@ -86684,7 +86867,7 @@ ${e?.stderr || ""}`;
             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.`
+              detail: `Gate '${gate.ref ?? gate.gateId}' passed its deadline under on_timeout=hold \u2014 downstream is still held. Reclaim it with mesh_graph_gate_claim (optionally with extend_deadline_seconds) to resume, or give it up with mesh_graph_gate_abandon, which cancels what it was holding instead of opening it. A timeout is never passage: the gate cannot release itself.`
             });
           }
         }