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

package/vendor/mcp-server/index.js

@@ -40,6 +40,7 @@ var import_daemon_core = require("@adhdev/daemon-core");
 var DEFAULT_IPC_PORT = import_daemon_core.IDENTITY.defaultPort;
 var DEFAULT_IPC_PATH = "/ipc";
 var DEFAULT_IPC_COMMAND_TIMEOUT_MS = 15e3;
+var IPC_COMMAND_TIMEOUT_ENV = "ADHDEV_IPC_COMMAND_TIMEOUT_MS";
 var IPC_COMMAND_TIMEOUTS_MS = {
   mesh_relay_command: 12e4,
   agent_command: 3e4,
@@ -67,6 +68,42 @@ var IPC_COMMAND_TIMEOUTS_MS = {
   refine_mesh_node: 3e4,
   batch_refine_mesh_nodes: 3e4
 };
+var IPC_PROBE_RETRYABLE_COMMANDS = /* @__PURE__ */ new Set([
+  "get_status_metadata",
+  "get_mesh",
+  "mesh_status",
+  "git_status",
+  "git_diff_summary",
+  "git_log",
+  "git_diff_file",
+  "read_chat",
+  "get_spec_debug",
+  "get_chat_debug_bundle",
+  "list_coordinator_prompts",
+  "list_provider_availability"
+]);
+var IPC_PROBE_RETRY_MAX_ENV = "ADHDEV_IPC_PROBE_RETRY_MAX";
+var IPC_PROBE_RETRY_BACKOFF_MS_ENV = "ADHDEV_IPC_PROBE_RETRY_BACKOFF_MS";
+var DEFAULT_IPC_PROBE_RETRY_MAX = 1;
+var DEFAULT_IPC_PROBE_RETRY_BACKOFF_MS = 2e3;
+function parsePositiveInt(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 resolveDefaultCommandTimeoutMs() {
+  const parsed = parsePositiveInt(process.env[IPC_COMMAND_TIMEOUT_ENV], DEFAULT_IPC_COMMAND_TIMEOUT_MS);
+  return parsed > 0 ? parsed : DEFAULT_IPC_COMMAND_TIMEOUT_MS;
+}
+function resolveProbeRetryMax() {
+  return parsePositiveInt(process.env[IPC_PROBE_RETRY_MAX_ENV], DEFAULT_IPC_PROBE_RETRY_MAX);
+}
+function resolveProbeRetryBackoffMs() {
+  return parsePositiveInt(process.env[IPC_PROBE_RETRY_BACKOFF_MS_ENV], DEFAULT_IPC_PROBE_RETRY_BACKOFF_MS);
+}
+function isRetryableProbeCommand(type) {
+  return IPC_PROBE_RETRYABLE_COMMANDS.has(type);
+}
 var WS_CONNECTING = 0;
 var WS_OPEN = 1;
 var POOL_IDLE_EVICT_MS = 5 * 6e4;
@@ -76,9 +113,10 @@ function buildRequestId() {
   return `mcp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
 }
 function getTimeoutMs(type, nestedCommand) {
+  const fallback = resolveDefaultCommandTimeoutMs();
   return Math.max(
-    IPC_COMMAND_TIMEOUTS_MS[type] ?? DEFAULT_IPC_COMMAND_TIMEOUT_MS,
-    IPC_COMMAND_TIMEOUTS_MS[nestedCommand] ?? DEFAULT_IPC_COMMAND_TIMEOUT_MS
+    IPC_COMMAND_TIMEOUTS_MS[type] ?? fallback,
+    IPC_COMMAND_TIMEOUTS_MS[nestedCommand] ?? fallback
   );
 }
 function getOrCreateConnection(WebSocketCtor, url) {
@@ -203,7 +241,20 @@ var IpcTransport = class {
       args
     });
   }
-  sendIpcCommand(type, args) {
+  async sendIpcCommand(type, args) {
+    const maxRetries = isRetryableProbeCommand(type) ? resolveProbeRetryMax() : 0;
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await this.sendIpcCommandOnce(type, args);
+      } catch (e) {
+        if (!e?.ipcTimeout || attempt >= maxRetries) throw e;
+        const backoffMs = resolveProbeRetryBackoffMs();
+        console.error(`[ipc] probe command '${type}' timed out; retrying (${attempt + 1}/${maxRetries}) in ${backoffMs}ms \u2014 read-only command, safe to re-send`);
+        await new Promise((resolve) => setTimeout(resolve, backoffMs));
+      }
+    }
+  }
+  sendIpcCommandOnce(type, args) {
     const WebSocketCtor = globalThis.WebSocket;
     if (!WebSocketCtor) {
       return Promise.reject(new Error("WebSocket is not available in this Node runtime; Node 20+ is required for daemon IPC mode"));
@@ -229,7 +280,9 @@ var IpcTransport = class {
       }
       const timer = setTimeout(() => {
         conn.pending.delete(requestId);
-        reject(new Error(`Daemon IPC ${diagnosticParts.join(" ")} timed out after ${Math.round(timeoutMs / 1e3)}s (requestId=${requestId})`));
+        const error = new Error(`Daemon IPC ${diagnosticParts.join(" ")} timed out after ${Math.round(timeoutMs / 1e3)}s (requestId=${requestId})`);
+        error.ipcTimeout = true;
+        reject(error);
       }, timeoutMs);
       conn.pending.set(requestId, { resolve, reject, timer });
       conn.lastUsedAt = Date.now();
@@ -577,6 +630,10 @@ var CANONICAL_MESH_TOOL_NAMES = [
   "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",
@@ -635,7 +692,7 @@ function withStatusProbeMarker(args = {}) {
 }
 
 // src/tools/mesh-tools-internal.ts
-var import_daemon_core4 = require("@adhdev/daemon-core");
+var import_daemon_core5 = require("@adhdev/daemon-core");
 
 // src/tools/mesh-tool-shared.ts
 function readString(value) {
@@ -1013,7 +1070,7 @@ var MESH_ENQUEUE_TASK_TOOL = {
 };
 var MESH_ENQUEUE_BATCH_TOOL = {
   name: "mesh_enqueue_batch",
-  description: "G5: atomically enqueue a dependency-wired set of tasks \u2014 either EVERY task in the batch is inserted or NONE is (a mid-batch error such as a dependency cycle, invalid difficulty, or guardrail violation rolls the whole batch back). Use this instead of N sequential mesh_enqueue_task calls whenever you are wiring a multi-task graph: give each task a batch-local `ref` label and name sibling refs in `depends_on` (forward references allowed \u2014 array order does not matter). A depends_on value that is not a ref in this batch must be an EXISTING queue task id; anything else is rejected. Per-task fields are the same as mesh_enqueue_task. Top-level mission_id applies to every task that lacks its own.",
+  description: "G5: atomically enqueue a dependency-wired set of tasks \u2014 either EVERY task in the batch is inserted or NONE is (a mid-batch error such as a dependency cycle, invalid difficulty, or guardrail violation rolls the whole batch back). Use this instead of N sequential mesh_enqueue_task calls whenever you are wiring a multi-task graph: give each task a batch-local `ref` label and name sibling refs in `depends_on` (forward references allowed \u2014 array order does not matter). A depends_on value that is not a ref in this batch must be an EXISTING queue task id; anything else is rejected. Per-task fields are the same as mesh_enqueue_task. Top-level mission_id applies to every task that lacks its own. Beyond plain ordering it also accepts a full orchestration graph, so you can submit the WHOLE known plan once instead of enqueueing each step as the previous one finishes: `inputs_from` binds selected predecessor outputs into a later task (no hand-copying worker text), `run_if` branches on those outputs, `gates` declare steps that stop for a coordinator action (Refinery landing, approval, CI wait, publish, deploy) with downstream tasks pointing at them via `gated_by`, and `workspaces` + `workspace_ref` prepare a worktree later for a task that needs one. These are strictly additive: a batch using only message/depends_on behaves exactly as before. Only graph-using batches create a graph, inspectable with mesh_graph_view.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1046,21 +1103,158 @@ var MESH_ENQUEUE_BATCH_TOOL = {
             not_before: { type: "number", description: "G7 delayed execution: hold the task pending until this time (epoch-ms, relative-ms, or ISO string)." },
             notBefore: { type: "number", description: "CamelCase alias for not_before. Also accepts an ISO-8601 timestamp string." },
             max_retries: { type: "number", description: "P3 retry cap (same semantics as mesh_enqueue_task)." },
-            maxRetries: { type: "number", description: "CamelCase alias for max_retries." }
+            maxRetries: { type: "number", description: "CamelCase alias for max_retries." },
+            // ── batch v2 graph fields (design :568-570). All optional; a batch
+            //    using none of them takes the unchanged compatibility path. ──
+            inputs_from: {
+              type: "array",
+              description: "Bind SELECTED outputs of predecessor steps into this task, instead of hand-copying a worker's text into the instruction. Each entry is {from: <ref of a predecessor task or gate>, select: <RFC-6901 JSON Pointer into that step's completion envelope>, as: <binding name>, required?: bool}. Bound values are appended to your immutable instruction inside a clearly-marked untrusted-evidence envelope with provenance and a digest \u2014 they can never alter routing, permissions, task mode or model. Using this makes the task wait for the graph to bind it before it becomes claimable.",
+              items: { type: "object" }
+            },
+            inputsFrom: { type: "array", description: "CamelCase alias for inputs_from.", items: { type: "object" } },
+            run_if: { type: "object", description: "Declarative condition deciding whether this task runs at all, evaluated against predecessor outputs and released gate outcomes (e.g. only run the deploy when the gate outcome was `passed`). A condition that is false SKIPS the task \u2014 skipped is terminal and, deliberately, is NOT treated as completed, so it never satisfies a downstream dependency. A malformed condition fails closed rather than defaulting to true." },
+            runIf: { type: "object", description: "CamelCase alias for run_if." },
+            on_false: { type: "string", enum: ["skip"], description: "What to do when run_if is false. Only `skip` is defined (and is the default)." },
+            onFalse: { type: "string", enum: ["skip"], description: "CamelCase alias for on_false." },
+            on_upstream_skip: { type: "string", enum: ["skip", "omit_dependency"], description: 'What happens to this task when an upstream step is SKIPPED. `skip` (default) propagates the skip. `omit_dependency` drops that edge from this task\'s dependency projection so it can still run \u2014 the explicit way to say "run anyway if that branch was not taken".' },
+            onUpstreamSkip: { type: "string", enum: ["skip", "omit_dependency"], description: "CamelCase alias for on_upstream_skip." },
+            workspace_ref: { type: "string", description: "Run this task in a worktree declared in the top-level `workspaces` array, prepared LATER rather than before the batch is accepted. The task stays held until that worktree is ready, then it is pinned to it automatically. Worktree preparation is a compensated saga: it is reported separately as workspacePreparation and is never part of the batch's DB atomicity." },
+            workspaceRef: { type: "string", description: "CamelCase alias for workspace_ref." },
+            gated_by: { type: "array", items: { type: "string" }, description: 'Refs of gates in this batch\'s `gates` array that must be RELEASED before this task may run. This is how you say "do not start until I have landed/approved/deployed". Do NOT put a gate ref in depends_on \u2014 a gate is an intentional stop, not an ordinary queue dependency, and listing one there is rejected.' },
+            gatedBy: { type: "array", items: { type: "string" }, description: "CamelCase alias for gated_by." }
           },
           required: ["message", "difficulty"]
         }
       },
+      gates: {
+        type: "array",
+        description: "Coordinator GATES: graph steps that intentionally stop progress until YOU act (Refinery landing, approval, CI wait, publish, deploy). The daemon never performs the action and never auto-passes a gate \u2014 you claim it (mesh_graph_gate_claim), do the thing, then release it (mesh_graph_gate_release). Declare the gate here and point downstream tasks at it with gated_by, so the whole plan can be submitted at once instead of waiting to enqueue the later steps by hand. Gate refs share ONE namespace with task and workspace refs.",
+        items: {
+          type: "object",
+          properties: {
+            ref: { type: "string", description: "Label for this gate; downstream tasks name it in gated_by." },
+            action: { type: "string", enum: ["refinery", "approval", "ci_wait", "publish", "deploy", "custom"], description: "What kind of action this gate is waiting for. A metadata label only \u2014 it tells you (and the view) what the gate means; the daemon never executes it." },
+            instructions: { type: "string", description: "What the coordinator must do at this gate, shown when the gate opens." },
+            depends_on: { type: "array", items: { type: "string" }, description: "Refs of tasks/gates in this batch that must complete before this gate OPENS for a coordinator." },
+            on_timeout: { type: "string", enum: ["hold", "cancel_downstream", "fail_graph"], description: "What happens when the gate passes its deadline. `hold` (default) keeps downstream blocked for an explicit reclaim; `cancel_downstream` cancels the pending downstream branch; `fail_graph` fails the graph. There is deliberately NO auto-release option: a timeout is never treated as the action having succeeded." },
+            deadline_seconds: { type: "number", description: "Seconds from when the gate OPENS until its on_timeout policy fires." },
+            lease_seconds: { type: "number", description: "Default claim lease length for this gate (a claim may override it)." },
+            eligible_coordinator_session_id: { type: "string", description: "Restrict claiming to one coordinator session." }
+          },
+          required: ["ref"]
+        }
+      },
+      workspaces: {
+        type: "array",
+        description: 'Worktrees to prepare LATER for tasks that name them via workspace_ref \u2014 the way to plan "clone a worktree, then work in it" as one batch instead of enqueueing, waiting, and enqueueing again. Preparation is a compensated saga with owned-resource cleanup: it happens outside the batch transaction and is reported as workspacePreparation, so `atomic: true` never claims the git side effects happened.',
+        items: {
+          type: "object",
+          properties: {
+            ref: { type: "string", description: "Label tasks use in workspace_ref. Shares one namespace with task and gate refs." },
+            source_node_id: { type: "string", description: "Node whose workspace the worktree is cloned from." },
+            purpose: { type: "string", description: "Short label folded into the derived branch name." },
+            base_revision: { type: "string", description: "Base revision to prepare from." },
+            desired_path: { type: "string", description: "Optional explicit worktree path." },
+            cleanup_on_graph_failure: { type: "boolean", description: "Remove the worktree this graph created if the graph fails. Only ever removes a worktree the saga itself owns." }
+          },
+          required: ["ref"]
+        }
+      },
+      batch_id: { type: "string", description: "Your own idempotency key for this batch. Re-sending the SAME batch_id with an identical plan replays and inserts nothing new; the same batch_id with a different plan is rejected (batch_id_conflict). Use it whenever a retry might duplicate work. Supplying it records the batch as a graph (so the key can be enforced), which is why the response then carries graphId \u2014 task behavior is unchanged." },
+      batchId: { type: "string", description: "CamelCase alias for batch_id." },
+      orchestration_decision: {
+        type: "object",
+        description: "Optional record of your planning decision, for adoption measurement: {decision, ready_worker_tasks, known_graph_steps, single_reason, capability_blockers}. It is stored as provenance with the graph and never changes execution."
+      },
+      orchestrationDecision: { type: "object", description: "CamelCase alias for orchestration_decision." },
       mission_id: { type: "string", description: "Mission every task in this batch belongs to unless an entry overrides it (full/exact id). For multi-task work, create the mission first (mesh_mission_upsert) and pass it here. An unresolvable id rejects the WHOLE batch (atomic) before anything is inserted." },
       missionId: { type: "string", description: "CamelCase alias for mission_id." },
       block_duplicate: { type: "boolean", description: "G4: when any entry matches an in-flight task with the same message+target, refuse the WHOLE batch (it is atomic) with code duplicate_suspect. Default false = warn-only via duplicateSuspects in the response." },
       blockDuplicate: { type: "boolean", description: "CamelCase alias for block_duplicate." },
       allow_duplicate: { type: "boolean", description: "G4: skip duplicate detection entirely for every entry (intentional re-enqueue)." },
-      allowDuplicate: { type: "boolean", description: "CamelCase alias for allow_duplicate." }
+      allowDuplicate: { type: "boolean", description: "CamelCase alias for allow_duplicate." },
+      on_dependency_failure: {
+        type: "string",
+        enum: ["block", "cancel"],
+        description: "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."
+      },
+      onDependencyFailure: {
+        type: "string",
+        enum: ["block", "cancel"],
+        description: "CamelCase alias for on_dependency_failure."
+      }
     },
     required: ["tasks"]
   }
 };
+var MESH_GRAPH_GATE_CLAIM_TOOL = {
+  name: "mesh_graph_gate_claim",
+  description: "Take the lease on a coordinator GATE that is awaiting a coordinator. A gate is a graph step that intentionally STOPS progress until a human/coordinator does something the daemon must not do itself \u2014 a Refinery landing, an approval, waiting on CI, a publish, a deploy. The daemon NEVER performs a gate action and NEVER auto-passes a gate: the only way through is your own mesh_graph_gate_release. Claim returns a monotonically increasing leaseGeneration and an opaque fencingToken \u2014 you MUST present both at release, so keep them. A gate whose lease has lapsed can be taken over by a new claim at a HIGHER generation; when that happens the response sets ambiguousExternalOutcome, meaning the previous owner may already have performed the external side effect \u2014 reconcile external evidence (did the merge/publish already land?) before doing it again. Use mesh_graph_view to find gates awaiting a coordinator.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      gate_id: { type: "string", description: "The gate to claim (from mesh_graph_view or the mesh_enqueue_batch response)." },
+      gateId: { type: "string", description: "CamelCase alias for gate_id." },
+      lease_seconds: { type: "number", description: "How long to hold the lease before it lapses. Defaults to the gate spec's lease_seconds, then 900s. Pick a duration that covers the real action \u2014 a lapsed lease cannot release (elapsed time is never completion evidence)." },
+      leaseSeconds: { type: "number", description: "CamelCase alias for lease_seconds." },
+      extend_deadline_seconds: { type: "number", description: "Push the gate DEADLINE out by this many seconds from now. Distinct from the lease: the deadline is when the on_timeout policy (hold / cancel_downstream / fail_graph) fires. Reclaiming a gate that expired under on_timeout=hold does NOT refresh its deadline unless you pass this, so the next sweep would expire it again." },
+      extendDeadlineSeconds: { type: "number", description: "CamelCase alias for extend_deadline_seconds." },
+      coordinator_session_id: { type: "string", description: "Owner session for the lease. Defaults to this coordinator session; pass explicitly only when driving a gate on behalf of another session." },
+      coordinatorSessionId: { type: "string", description: "CamelCase alias for coordinator_session_id." }
+    },
+    required: ["gate_id"]
+  }
+};
+var MESH_GRAPH_GATE_RELEASE_TOOL = {
+  name: "mesh_graph_gate_release",
+  description: "Release a coordinator gate you hold the lease on \u2014 the ONLY way a gate lets its downstream work run. Requires the leaseGeneration + fencingToken from your mesh_graph_gate_claim: a stale generation or wrong token is refused (stale_fence), and an EXPIRED lease can never release (re-claim first, and reconcile whether the external action already happened). Pass an idempotency_key of your choosing: re-sending the identical release with the same key is a safe no-op success, while the same key with a DIFFERENT payload is rejected as a conflict. `outcome` (passed / failed / rejected, or an action-specific label) and any structured `result` / `evidence` become readable by downstream tasks through run_if and inputs_from, so a gate decision can steer the rest of the graph. Validation failures roll the WHOLE release back: the gate stays claimed and downstream stays blocked.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      gate_id: { type: "string", description: "The gate being released." },
+      gateId: { type: "string", description: "CamelCase alias for gate_id." },
+      fencing_token: { type: "string", description: "The opaque token returned by mesh_graph_gate_claim. Required." },
+      fencingToken: { type: "string", description: "CamelCase alias for fencing_token." },
+      lease_generation: { type: "number", description: "The leaseGeneration returned by mesh_graph_gate_claim. Required \u2014 a stale generation is refused." },
+      leaseGeneration: { type: "number", description: "CamelCase alias for lease_generation." },
+      idempotency_key: { type: "string", description: "Your own key for this release. Re-sending the identical release with the same key is a no-op success; the same key with a different payload is a conflict. Required." },
+      idempotencyKey: { type: "string", description: "CamelCase alias for idempotency_key." },
+      outcome: { type: "string", description: "The gate outcome: passed | failed | rejected, or an action-specific structured label. Downstream run_if conditions read it as /gate_outcome." },
+      result: { type: "object", description: "Optional action-specific structured result, exposed to downstream bindings as /result/... (e.g. the merged commit sha)." },
+      evidence: { type: "object", description: "Optional evidence references/digests, exposed to downstream bindings as /evidence/... ." },
+      patches: {
+        type: "array",
+        description: "Optional pre-assignment patches to DIRECT downstream nodes. Only run_if, on_false, inputs_from and workspace_ref may be patched \u2014 message, routing, permissions, task mode and model are immutable by policy, and a task that is already claimed cannot be patched at all.",
+        items: {
+          type: "object",
+          properties: {
+            node: { type: "string", description: "Ref or node id of a DIRECT downstream node of this gate." },
+            base_spec_patch: { type: "object", description: "Keys to merge into that node's spec. Allowed keys: run_if, on_false, inputs_from, workspace_ref." },
+            baseSpecPatch: { type: "object", description: "CamelCase alias for base_spec_patch." }
+          },
+          required: ["node"]
+        }
+      }
+    },
+    required: ["gate_id", "fencing_token", "lease_generation", "idempotency_key", "outcome"]
+  }
+};
+var MESH_GRAPH_VIEW_TOOL = {
+  name: "mesh_graph_view",
+  description: "Inspect orchestration GRAPHS on this mesh: node states and refs, active edges, materialization receipts, coordinator gates (with who holds the lease and what is blocked), delayed workspace sagas, derived dependency failures, and the next action a coordinator actually has to take. Read-only. Defaults to in-flight graphs; pass include_terminal=true for completed ones. Only mesh_enqueue_batch requests that use graph features (gates, inputs_from, run_if, workspace_ref) create a graph \u2014 a plain depends_on batch runs on the ordinary queue and appears in mesh_view_queue instead. Do not poll this waiting for generating work; use it when you need to know why something is blocked or which gate is waiting on you.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      graph_id: { type: "string", description: "Show exactly this graph (including terminal ones)." },
+      graphId: { type: "string", description: "CamelCase alias for graph_id." },
+      batch_id: { type: "string", description: "Show the graph committed under this batch_id." },
+      batchId: { type: "string", description: "CamelCase alias for batch_id." },
+      include_terminal: { type: "boolean", description: "Include completed/failed/cancelled graphs. Default false (in-flight only)." },
+      includeTerminal: { type: "boolean", description: "CamelCase alias for include_terminal." },
+      limit: { type: "number", description: "Max graphs to return (default 20)." }
+    }
+  }
+};
 var MESH_VIEW_QUEUE_TOOL = {
   name: "mesh_view_queue",
   description: "View the mesh work queue with source-of-truth active counts separated from historical completed/failed/cancelled records. Do not repeatedly call this to wait for generating assigned work; wait for pendingCoordinatorEvents/completion events or an explicit user status request.",
@@ -1892,6 +2086,11 @@ var ALL_MESH_TOOLS = [
   MESH_ENQUEUE_TASK_TOOL,
   MESH_ENQUEUE_BATCH_TOOL,
   MESH_VIEW_QUEUE_TOOL,
+  // GRAPH-ORCHESTRATION Phase E — placed next to the queue/enqueue tools so a
+  // coordinator that loaded the batch schema also discovers how to pass a gate.
+  MESH_GRAPH_VIEW_TOOL,
+  MESH_GRAPH_GATE_CLAIM_TOOL,
+  MESH_GRAPH_GATE_RELEASE_TOOL,
   MESH_QUEUE_CANCEL_TOOL,
   MESH_QUEUE_REQUEUE_TOOL,
   MESH_SEND_TASK_TOOL,
@@ -1945,6 +2144,8 @@ var ALL_MESH_TOOLS = [
 ];
 
 // src/tools/mesh-compact.ts
+var import_daemon_core4 = require("@adhdev/daemon-core");
+var QUOTA_STALE_AFTER_MS = import_daemon_core4.DEFAULT_QUOTA_ROUTING_POLICY.staleAfterMs;
 function buildCompactGitSnapshot(status) {
   if (!status || typeof status !== "object" || Array.isArray(status)) return void 0;
   const slim = {};
@@ -1974,19 +2175,58 @@ function summarizeCompactSubmodules(submodules) {
   };
 }
 var MESH_COMPACT_PRESERVED_MARKER_FIELDS = ["dataFreshness", "quota", "isLocalWorktree"];
-function summarizeNodeQuota(quota) {
+function quotaSnapshotAgeMs(snapshot, now = Date.now()) {
+  const updatedAt = typeof snapshot?.updatedAt === "number" ? snapshot.updatedAt : NaN;
+  if (!Number.isFinite(updatedAt)) return null;
+  return Math.max(0, now - updatedAt);
+}
+function isQuotaSnapshotStale(snapshot, now = Date.now()) {
+  const ageMs = quotaSnapshotAgeMs(snapshot, now);
+  return ageMs === null || ageMs >= QUOTA_STALE_AFTER_MS;
+}
+function formatQuotaSnapshotAge(snapshot, now) {
+  const ageMs = quotaSnapshotAgeMs(snapshot, now);
+  if (ageMs === null) return "?";
+  return `${Math.round(ageMs / 6e4)}m`;
+}
+function annotateQuotaSnapshotFreshness(quota, now = Date.now()) {
+  if (!quota || typeof quota !== "object" || Array.isArray(quota)) return quota;
+  const out = {};
+  for (const [provider, snapshot] of Object.entries(quota)) {
+    if (!snapshot || typeof snapshot !== "object") {
+      out[provider] = snapshot;
+      continue;
+    }
+    const ageMs = quotaSnapshotAgeMs(snapshot, now);
+    out[provider] = {
+      ...snapshot,
+      ageMs: ageMs ?? -1,
+      stale: isQuotaSnapshotStale(snapshot, now)
+    };
+  }
+  return out;
+}
+function summarizeNodeQuota(quota, now = Date.now()) {
   if (!quota || typeof quota !== "object" || Array.isArray(quota)) return void 0;
   const out = {};
   for (const [provider, snapshot] of Object.entries(quota)) {
     if (!snapshot || typeof snapshot !== "object") continue;
     const status = typeof snapshot.status === "string" ? snapshot.status : "unknown";
-    if (status !== "ok") {
+    const lastGood = snapshot.metadata?.lastGoodWindows === true;
+    const pct = (w) => w && Number.isFinite(w.usedPercent) ? `${Math.round(w.usedPercent)}%` : void 0;
+    const weekly = pct(snapshot.weekly);
+    const session = pct(snapshot.session);
+    if (weekly === void 0 && session === void 0) {
       const kind = typeof snapshot.metadata?.failureKind === "string" ? snapshot.metadata.failureKind : void 0;
       out[provider] = kind ? `${status}:${kind}` : status;
       continue;
     }
-    const pct = (w) => w && Number.isFinite(w.usedPercent) ? `${Math.round(w.usedPercent)}%` : "\u2014";
-    out[provider] = `${pct(snapshot.session)}/${pct(snapshot.weekly)}`;
+    const age = formatQuotaSnapshotAge(snapshot, now);
+    const stale = isQuotaSnapshotStale(snapshot, now);
+    let line = `7d ${weekly ?? "\u2014"} \xB7 5h ${session ?? "\u2014"} \xB7 ${age}${stale ? " stale" : ""}`;
+    if (lastGood) line += " \xB7 refreshing";
+    else if (status !== "ok") line += ` \xB7 ${status}`;
+    out[provider] = line;
   }
   return Object.keys(out).length > 0 ? out : void 0;
 }
@@ -2427,7 +2667,7 @@ function annotateRapidReadChatAdvisory(payload, options) {
 }
 
 // src/tools/mesh-tools-internal.ts
-var import_daemon_core5 = require("@adhdev/daemon-core");
+var import_daemon_core6 = require("@adhdev/daemon-core");
 var import_node_crypto = require("crypto");
 var SESSION_PROVIDER_METADATA_TTL_MS = 30 * 6e4;
 var meshSessionProviderMetadata = /* @__PURE__ */ new Map();
@@ -2487,7 +2727,7 @@ function buildDirectTaskPayload(message, via, opts) {
   };
 }
 function findNode(mesh, nodeId) {
-  const node = mesh.nodes.find((n) => (0, import_daemon_core4.meshNodeIdMatches)(n, nodeId));
+  const node = mesh.nodes.find((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, nodeId));
   if (!node) throw new Error(`Node '${nodeId}' is not a member of mesh '${mesh.name}'`);
   return node;
 }
@@ -2502,13 +2742,13 @@ async function refreshMeshFromDaemon(ctx) {
     for (const existing of ctx.mesh.nodes) {
       const existingId = existing?.id;
       if (!existingId) continue;
-      if (merged.some((n) => (0, import_daemon_core4.meshNodeIdMatches)(n, existingId))) continue;
+      if (merged.some((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, existingId))) continue;
       if (isLocalControlPlaneNode(ctx, existing)) {
         settledNodeIds.add(existingId);
         continue;
       }
       const clonedFromNodeId = readString(existing?.clonedFromNodeId) || readString(existing?.cloned_from_node_id);
-      if (clonedFromNodeId && refreshedNodes.some((n) => (0, import_daemon_core4.meshNodeIdMatches)(n, clonedFromNodeId))) {
+      if (clonedFromNodeId && refreshedNodes.some((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, clonedFromNodeId))) {
         settledNodeIds.add(existingId);
         continue;
       }
@@ -2537,7 +2777,7 @@ async function resolveNodeFromOwningDaemons(ctx, nodeId) {
   const candidates = [];
   const pushCandidate = (id) => {
     if (typeof id !== "string" || !id.trim()) return;
-    if (localDaemonId && (0, import_daemon_core4.daemonIdsEquivalent)(id, localDaemonId)) return;
+    if (localDaemonId && (0, import_daemon_core5.daemonIdsEquivalent)(id, localDaemonId)) return;
     if (!candidates.includes(id)) candidates.push(id);
   };
   for (const node of ctx.mesh.nodes) pushCandidate(node?.daemonId);
@@ -2557,9 +2797,9 @@ async function resolveNodeFromOwningDaemons(ctx, nodeId) {
       if (result && result.success === false) ownerUnreachable = true;
       continue;
     }
-    const found = nodes.find((n) => n?.id && (0, import_daemon_core4.meshNodeIdMatches)(n, nodeId));
+    const found = nodes.find((n) => n?.id && (0, import_daemon_core5.meshNodeIdMatches)(n, nodeId));
     if (!found) continue;
-    const existingIndex = ctx.mesh.nodes.findIndex((n) => (0, import_daemon_core4.meshNodeIdMatches)(n, nodeId));
+    const existingIndex = ctx.mesh.nodes.findIndex((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, nodeId));
     if (existingIndex >= 0) ctx.mesh.nodes[existingIndex] = found;
     else ctx.mesh.nodes.push(found);
     return { node: found, ownerUnreachable: false };
@@ -2567,10 +2807,10 @@ async function resolveNodeFromOwningDaemons(ctx, nodeId) {
   return { node: null, ownerUnreachable };
 }
 async function findNodeWithRefresh(ctx, nodeId) {
-  const hit = ctx.mesh.nodes.find((n) => (0, import_daemon_core4.meshNodeIdMatches)(n, nodeId));
+  const hit = ctx.mesh.nodes.find((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, nodeId));
   if (hit && !hit.isLocalWorktree) return hit;
   const { settledNodeIds } = await refreshMeshFromDaemon(ctx);
-  const refreshed = ctx.mesh.nodes.find((n) => (0, import_daemon_core4.meshNodeIdMatches)(n, nodeId));
+  const refreshed = ctx.mesh.nodes.find((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, nodeId));
   if (refreshed) return refreshed;
   if (settledNodeIds.has(nodeId)) {
     throw new Error(`Node '${nodeId}' is not a member of mesh '${ctx.mesh.name}'`);
@@ -2587,10 +2827,10 @@ async function findNodeWithRefresh(ctx, nodeId) {
   throw new Error(`Node '${nodeId}' is not a member of mesh '${ctx.mesh.name}'`);
 }
 async function findOptionalNodeWithRefresh(ctx, nodeId) {
-  const hit = ctx.mesh.nodes.find((n) => (0, import_daemon_core4.meshNodeIdMatches)(n, nodeId));
+  const hit = ctx.mesh.nodes.find((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, nodeId));
   if (hit && !hit.isLocalWorktree) return hit;
   const { settledNodeIds } = await refreshMeshFromDaemon(ctx);
-  const refreshed = ctx.mesh.nodes.find((n) => (0, import_daemon_core4.meshNodeIdMatches)(n, nodeId));
+  const refreshed = ctx.mesh.nodes.find((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, nodeId));
   if (refreshed) return refreshed;
   if (settledNodeIds.has(nodeId)) return null;
   const owned = await resolveNodeFromOwningDaemons(ctx, nodeId);
@@ -2599,7 +2839,7 @@ async function findOptionalNodeWithRefresh(ctx, nodeId) {
 function hasRecentDuplicateDispatch(ctx, args) {
   const now = Date.now();
   const normalizedMessage = args.message.trim();
-  for (const task of (0, import_daemon_core4.getQueue)(ctx.mesh.id)) {
+  for (const task of (0, import_daemon_core5.getQueue)(ctx.mesh.id)) {
     const timestamp = new Date(task.updatedAt || task.createdAt).getTime();
     if (!Number.isFinite(timestamp) || now - timestamp > DUPLICATE_DISPATCH_WINDOW_MS) continue;
     if (task.targetNodeId && task.targetNodeId !== args.node_id) continue;
@@ -2609,7 +2849,7 @@ function hasRecentDuplicateDispatch(ctx, args) {
       return { duplicate: true, entry: task, source: "queue" };
     }
   }
-  const entries = (0, import_daemon_core4.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
+  const entries = (0, import_daemon_core5.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
   for (let i = entries.length - 1; i >= 0; i -= 1) {
     const entry = entries[i];
     const timestamp = new Date(entry.timestamp).getTime();
@@ -2626,7 +2866,7 @@ function hasRecentDuplicateDispatch(ctx, args) {
 }
 function buildMissionInactiveWarning(ctx, missionId) {
   if (!missionId) return void 0;
-  const mission = (0, import_daemon_core4.getMeshMission)(ctx.mesh.id, missionId);
+  const mission = (0, import_daemon_core5.getMeshMission)(ctx.mesh.id, missionId);
   if (!mission || mission.status === "active") return void 0;
   const hintByStatus = {
     paused: `Mission '${missionId}' (${mission.title}) is paused \u2014 a new task was just attached to it anyway. Mission status is never auto-transitioned; if this mission should be active again, call mesh_mission_upsert(mission_id: '${missionId}', status: 'active').`,
@@ -2640,7 +2880,7 @@ function buildMissionInactiveWarning(ctx, missionId) {
   };
 }
 function buildMissingNodeReadChatRecovery(ctx, args) {
-  const entries = (0, import_daemon_core4.readLedgerEntries)(ctx.mesh.id, { tail: 300 });
+  const entries = (0, import_daemon_core5.readLedgerEntries)(ctx.mesh.id, { tail: 300 });
   const relatedEntries = entries.filter((entry) => entry.nodeId === args.node_id || entry.sessionId === args.session_id);
   const completedEntries = relatedEntries.filter((entry) => entry.kind === "task_completed");
   const lastDispatch = [...relatedEntries].reverse().find((entry) => entry.kind === "task_dispatched");
@@ -2764,7 +3004,7 @@ function readFinalAssistantTranscriptEvidence(payload) {
 }
 function findNodeSession(nodes, nodeId, sessionId) {
   if (!nodeId || !sessionId) return {};
-  const node = nodes.find((candidate) => (0, import_daemon_core4.meshNodeIdMatches)(candidate, nodeId));
+  const node = nodes.find((candidate) => (0, import_daemon_core5.meshNodeIdMatches)(candidate, nodeId));
   if (!node) return {};
   const sessions = Array.isArray(node.sessions) ? node.sessions : [];
   const session = sessions.find((candidate) => readSessionRecordId(candidate) === sessionId);
@@ -2833,10 +3073,10 @@ async function reconcileDirectDispatchesFromTranscriptEvidence(ctx, liveNodes, d
       });
       const payload = unwrapCommandPayload(readResult);
       if (payload?.success === false) continue;
-      if ((0, import_daemon_core4.hasTrailingToolActivityAfterFinalAssistant)(Array.isArray(payload?.messages) ? payload.messages : [])) continue;
+      if ((0, import_daemon_core5.hasTrailingToolActivityAfterFinalAssistant)(Array.isArray(payload?.messages) ? payload.messages : [])) continue;
       const evidence = readFinalAssistantTranscriptEvidence(payload);
       if (!evidence.finalSummary) continue;
-      const result = (0, import_daemon_core4.reconcileDirectDispatchCompletionFromTranscript)({
+      const result = (0, import_daemon_core5.reconcileDirectDispatchCompletionFromTranscript)({
         meshId: ctx.mesh.id,
         nodeId,
         sessionId,
@@ -3021,7 +3261,7 @@ function extractLaunchPayload(value) {
 function classifyMeshLaunchFailure(error) {
   const message = error instanceof Error ? error.message : String(error || "launch failed");
   const lower = message.toLowerCase();
-  const p2pClassification = (0, import_daemon_core4.classifyP2pRelayFailure)(error, { command: "launch_cli" });
+  const p2pClassification = (0, import_daemon_core5.classifyP2pRelayFailure)(error, { command: "launch_cli" });
   if (p2pClassification.recoverable) {
     return p2pClassification;
   }
@@ -3096,7 +3336,7 @@ function buildRecoverableLaunchFailure(ctx, node, providerType, error) {
 function recordRecoverableLaunchFailure(ctx, node, providerType, error) {
   const failure = buildRecoverableLaunchFailure(ctx, node, providerType, error);
   try {
-    (0, import_daemon_core4.appendLedgerEntry)(ctx.mesh.id, {
+    (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
       kind: "recovery_attempted",
       nodeId: node.id,
       providerType,
@@ -3110,7 +3350,7 @@ function recordRecoverableLaunchFailure(ctx, node, providerType, error) {
   return failure;
 }
 function getLatestActiveLaunchFailure(meshId, nodeId) {
-  const entries = (0, import_daemon_core4.readLedgerEntries)(meshId, { tail: 200 });
+  const entries = (0, import_daemon_core5.readLedgerEntries)(meshId, { tail: 200 });
   for (let i = entries.length - 1; i >= 0; i -= 1) {
     const entry = entries[i];
     if (entry.nodeId !== nodeId) continue;
@@ -3122,7 +3362,7 @@ function getLatestActiveLaunchFailure(meshId, nodeId) {
   return null;
 }
 function buildCoordinatorP2pRelayFailure(error, context) {
-  const payload = (0, import_daemon_core4.buildP2pRelayFailurePayload)(error, {
+  const payload = (0, import_daemon_core5.buildP2pRelayFailurePayload)(error, {
     command: context.command,
     targetDaemonId: context.targetDaemonId
   });
@@ -3305,7 +3545,7 @@ function rememberMeshSessionProviderMetadataFromEvent(event) {
   });
 }
 function resolveMeshSessionProviderMetadataFromLedger(ctx, nodeId, runtimeSessionId) {
-  const entries = (0, import_daemon_core4.readLedgerEntries)(ctx.mesh.id, { tail: 50 });
+  const entries = (0, import_daemon_core5.readLedgerEntries)(ctx.mesh.id, { tail: 50 });
   for (let i = entries.length - 1; i >= 0; i -= 1) {
     const entry = entries[i];
     const payload = entry.payload && typeof entry.payload === "object" && !Array.isArray(entry.payload) ? entry.payload : {};
@@ -3443,12 +3683,12 @@ function readNodeSupportedProviders(policy) {
 }
 function buildNodeCapabilityExposure(node) {
   const providers = readNodeSupportedProviders(node.policy);
-  const capabilityTags = (0, import_daemon_core4.buildMeshNodeCapabilityTags)(node);
+  const capabilityTags = (0, import_daemon_core5.buildMeshNodeCapabilityTags)(node);
   const exposure = { capabilityTags };
   if (providers.length) {
     const byProvider = {};
     for (const provider of providers) {
-      byProvider[provider] = (0, import_daemon_core4.buildMeshNodeCapabilityTags)(node, provider);
+      byProvider[provider] = (0, import_daemon_core5.buildMeshNodeCapabilityTags)(node, provider);
     }
     exposure.capabilityTagsByProvider = byProvider;
   }
@@ -3785,7 +4025,7 @@ function buildMeshForwardPayloadFromPendingEvent(event) {
     // eventId (idempotency) and unicast routing intact, matching the reconcile-loop
     // relay path (buildForwardPayloadFromPending). Spread LAST so the authoritative
     // envelope always wins. Empty for a v1 event (version-skew safe).
-    ...(0, import_daemon_core4.serializeV2EnvelopeToWire)(event)
+    ...(0, import_daemon_core5.serializeV2EnvelopeToWire)(event)
   };
 }
 async function drainCoordinatorPendingEvents(ctx, opts) {
@@ -3859,11 +4099,11 @@ async function drainCoordinatorPendingEvents(ctx, opts) {
     }
     return surfacedEvents;
   }
-  const drainerIdentity = (0, import_daemon_core4.coordinatorIdentityFromEmitFields)({
+  const drainerIdentity = (0, import_daemon_core5.coordinatorIdentityFromEmitFields)({
     daemonId: ctx.localDaemonId,
     sessionId: ctx.coordinatorSessionId
   });
-  const events = (0, import_daemon_core4.drainPendingMeshCoordinatorEvents)(
+  const events = (0, import_daemon_core5.drainPendingMeshCoordinatorEvents)(
     ctx.mesh.id,
     ctx.localDaemonId,
     drainerIdentity ? { drainerIdentity } : void 0
@@ -3872,7 +4112,7 @@ async function drainCoordinatorPendingEvents(ctx, opts) {
   return events;
 }
 function isP2pTransportUnavailableError(error) {
-  return (0, import_daemon_core4.isP2pRelayTransportFailure)(error);
+  return (0, import_daemon_core5.isP2pRelayTransportFailure)(error);
 }
 function buildRemoveNodeArgs(ctx, nodeId, sessionCleanupMode, force) {
   return {
@@ -3891,7 +4131,7 @@ function classifyReadChatTransportCause(error) {
   return "saturated";
 }
 function resolveCachedMeshSessionPreviewFromLedger(ctx, nodeId, sessionId) {
-  const entries = (0, import_daemon_core4.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
+  const entries = (0, import_daemon_core5.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
   for (let i = entries.length - 1; i >= 0; i -= 1) {
     const entry = entries[i];
     const payload = entry.payload && typeof entry.payload === "object" && !Array.isArray(entry.payload) ? entry.payload : {};
@@ -3900,7 +4140,7 @@ function resolveCachedMeshSessionPreviewFromLedger(ctx, nodeId, sessionId) {
     const entrySessionId = readString(entry.sessionId) || readString(payload.targetSessionId) || readString(payload.sessionId) || readString(payload.instanceId);
     if (entrySessionId !== sessionId) continue;
     const metadataEvent = payload.metadataEvent && typeof payload.metadataEvent === "object" && !Array.isArray(payload.metadataEvent) ? payload.metadataEvent : payload;
-    const preview = (0, import_daemon_core4.resolveMeshSurfacedSessionPreview)(metadataEvent);
+    const preview = (0, import_daemon_core5.resolveMeshSurfacedSessionPreview)(metadataEvent);
     if (preview) {
       return { ...preview, ledgerKind: entry.kind, timestamp: entry.timestamp };
     }
@@ -3908,7 +4148,7 @@ function resolveCachedMeshSessionPreviewFromLedger(ctx, nodeId, sessionId) {
   return void 0;
 }
 function buildMeshReadChatCacheFallback(ctx, args, node, error) {
-  const classification = (0, import_daemon_core4.classifyP2pRelayFailure)(error, { command: "read_chat", targetDaemonId: node.daemonId });
+  const classification = (0, import_daemon_core5.classifyP2pRelayFailure)(error, { command: "read_chat", targetDaemonId: node.daemonId });
   const cause = classifyReadChatTransportCause(error);
   const errorMessage = error instanceof Error ? error.message : String(error ?? "");
   const causeNote = cause === "not_connected" ? "the worker daemon is not currently connected over P2P (no live channel)" : "the worker daemon is connected but saturated \u2014 it acknowledged the request but did not return the transcript within the deadline";
@@ -3989,12 +4229,12 @@ function summarizePendingEventProtocolMetrics(pendingEvents) {
   };
 }
 async function meshStatus(ctx, args = {}) {
-  const rateResult = (0, import_daemon_core5.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_status" });
+  const rateResult = (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_status" });
   const compact = args.verbose === true ? false : args.compact ?? true;
   await refreshMeshFromDaemon(ctx);
   const { mesh, transport } = ctx;
-  let ledgerSummary = (0, import_daemon_core5.getLedgerSummary)(mesh.id);
-  const schedulingRuntime = (0, import_daemon_core5.buildMeshSchedulingRuntime)(mesh, (0, import_daemon_core5.getQueue)(mesh.id));
+  let ledgerSummary = (0, import_daemon_core6.getLedgerSummary)(mesh.id);
+  const schedulingRuntime = (0, import_daemon_core6.buildMeshSchedulingRuntime)(mesh, (0, import_daemon_core6.getQueue)(mesh.id));
   const schedulingByNode = new Map(schedulingRuntime.nodes.map((n) => [n.nodeId, n]));
   const results = await Promise.all(mesh.nodes.map(async (node) => {
     const entry = {
@@ -4015,7 +4255,7 @@ async function meshStatus(ctx, args = {}) {
       const { nodeId: _omit, ...rest } = nodeScheduling;
       entry.scheduling = compact ? { load: rest.load, capReached: rest.capReached } : rest;
     }
-    const lastQuotaRanking = (0, import_daemon_core5.getLastQuotaRanking)(node.id);
+    const lastQuotaRanking = (0, import_daemon_core6.getLastQuotaRanking)(node.id);
     if (lastQuotaRanking) {
       entry.scheduling = { ...entry.scheduling ?? {}, lastQuotaRanking };
     }
@@ -4066,14 +4306,14 @@ async function meshStatus(ctx, args = {}) {
         noFallbackReason: failure.noFallbackReason
       });
     }
-    entry.dataFreshness = (0, import_daemon_core5.buildMeshNodeProbeFreshness)({
+    entry.dataFreshness = (0, import_daemon_core6.buildMeshNodeProbeFreshness)({
       git: entry.git,
       liveTruthProbed,
       isSelfNode: entry.machine?.sameMachine === true,
       daemonId: readNodeDaemonId(node),
       node
     });
-    const recoveryContext = (0, import_daemon_core5.getSessionRecoveryContext)(mesh.id, { nodeId: node.id });
+    const recoveryContext = (0, import_daemon_core6.getSessionRecoveryContext)(mesh.id, { nodeId: node.id });
     if (recoveryContext.consecutiveNodeFailures > 0) {
       entry.recoveryHints = {
         consecutiveFailures: recoveryContext.consecutiveNodeFailures,
@@ -4163,23 +4403,23 @@ async function meshStatus(ctx, args = {}) {
     }
     return entry;
   }));
-  let ledgerEntries = (0, import_daemon_core5.readLedgerEntries)(mesh.id, { tail: 200 });
-  let directDispatches = (0, import_daemon_core5.getActiveDirectDispatches)(mesh.id);
+  let ledgerEntries = (0, import_daemon_core6.readLedgerEntries)(mesh.id, { tail: 200 });
+  let directDispatches = (0, import_daemon_core6.getActiveDirectDispatches)(mesh.id);
   const directReconciliation = await reconcileDirectDispatchesFromTranscriptEvidence(ctx, results, directDispatches, ledgerEntries);
   if (directReconciliation.reconciled > 0) {
-    ledgerEntries = (0, import_daemon_core5.readLedgerEntries)(mesh.id, { tail: 200 });
-    directDispatches = (0, import_daemon_core5.getActiveDirectDispatches)(mesh.id);
-    ledgerSummary = (0, import_daemon_core5.getLedgerSummary)(mesh.id);
+    ledgerEntries = (0, import_daemon_core6.readLedgerEntries)(mesh.id, { tail: 200 });
+    directDispatches = (0, import_daemon_core6.getActiveDirectDispatches)(mesh.id);
+    ledgerSummary = (0, import_daemon_core6.getLedgerSummary)(mesh.id);
   }
-  const activeWorkEvidence = (0, import_daemon_core5.buildMeshActiveWork)({
+  const activeWorkEvidence = (0, import_daemon_core6.buildMeshActiveWork)({
     meshId: mesh.id,
-    queue: (0, import_daemon_core5.getQueue)(mesh.id),
+    queue: (0, import_daemon_core6.getQueue)(mesh.id),
     ledgerEntries,
     directDispatches,
     nodes: results
   });
   const pollingGuidance = buildActiveWorkPollingGuidance(activeWorkEvidence.summary);
-  const staleDirectWorkSummary = (0, import_daemon_core5.buildCompactStaleDirectWorkSummary)(activeWorkEvidence.staleDirectWork, {
+  const staleDirectWorkSummary = (0, import_daemon_core6.buildCompactStaleDirectWorkSummary)(activeWorkEvidence.staleDirectWork, {
     note: activeWorkEvidence.staleDirectWorkNote,
     detailHint: "Full stale direct entries are omitted from mesh_status by default. Call mesh_status with includeStaleDirectWorkDetails=true or inspect mesh_task_history for ledger detail."
   });
@@ -4224,7 +4464,7 @@ async function meshStatus(ctx, args = {}) {
     const daemonId = typeof entry?.daemonId === "string" && entry.daemonId ? entry.daemonId : "";
     if (!daemonId) continue;
     if (entry?.machine && !(daemonId in daemonMachines)) daemonMachines[daemonId] = entry.machine;
-    if (entry?.quota && !(daemonId in daemonQuotas)) daemonQuotas[daemonId] = entry.quota;
+    if (entry?.quota && !(daemonId in daemonQuotas)) daemonQuotas[daemonId] = annotateQuotaSnapshotFreshness(entry.quota);
   }
   const daemonUpgradeFailures = {};
   for (const entry of results) {
@@ -4443,13 +4683,13 @@ async function meshStatus(ctx, args = {}) {
   }
   if (args.includeUsage === true) {
     try {
-      response.usage = (0, import_daemon_core5.summarizeMeshUsage)(mesh.id);
+      response.usage = (0, import_daemon_core6.summarizeMeshUsage)(mesh.id);
     } catch {
     }
   }
   try {
     if (compact) {
-      const { live, historyFold } = (0, import_daemon_core5.getMeshStatusMissionsCompact)(mesh.id);
+      const { live, historyFold } = (0, import_daemon_core6.getMeshStatusMissionsCompact)(mesh.id);
       const ranked = [...live].sort((a, b) => String(b.tasks?.lastActivityAt ?? "").localeCompare(String(a.tasks?.lastActivityAt ?? "")));
       const kept = [];
       const overflow = [];
@@ -4476,11 +4716,11 @@ async function meshStatus(ctx, args = {}) {
       }
       if (historyFold) response.missionsHistory = historyFold;
     } else {
-      const missions = (0, import_daemon_core5.getMeshStatusMissionSummaries)(mesh.id, { verbose: true });
+      const missions = (0, import_daemon_core6.getMeshStatusMissionSummaries)(mesh.id, { verbose: true });
       if (missions.length > 0) {
         response.missions = missions.map((mission) => {
           try {
-            return { ...mission, stats: (0, import_daemon_core5.computeMeshMissionStats)(mesh.id, mission.id) };
+            return { ...mission, stats: (0, import_daemon_core6.computeMeshMissionStats)(mesh.id, mission.id) };
           } catch {
             return mission;
           }
@@ -4491,14 +4731,14 @@ async function meshStatus(ctx, args = {}) {
   }
   try {
     const pendingEvents = await drainCoordinatorPendingEvents(ctx);
-    const asyncRefineJobs = (0, import_daemon_core5.buildMeshAsyncRefineJobs)({
+    const asyncRefineJobs = (0, import_daemon_core6.buildMeshAsyncRefineJobs)({
       meshId: mesh.id,
       ledgerEntries,
       pendingEvents
     });
     if (asyncRefineJobs.length > 0) {
       if (compact) {
-        const summary = (0, import_daemon_core5.summarizeMeshAsyncRefineJobs)(asyncRefineJobs);
+        const summary = (0, import_daemon_core6.summarizeMeshAsyncRefineJobs)(asyncRefineJobs);
         if (summary.activeJobs.length > 0) response.asyncRefineJobs = summary.activeJobs;
         response.asyncRefineJobsSummary = {
           total: summary.total,
@@ -4509,9 +4749,9 @@ async function meshStatus(ctx, args = {}) {
         response.asyncRefineJobs = asyncRefineJobs;
       }
     }
-    const magiActivity = (0, import_daemon_core5.buildMeshMagiActivity)({ meshId: mesh.id, ledgerEntries });
+    const magiActivity = (0, import_daemon_core6.buildMeshMagiActivity)({ meshId: mesh.id, ledgerEntries });
     if (magiActivity.length > 0) {
-      const fold = (0, import_daemon_core5.summarizeMeshMagiActivity)(magiActivity);
+      const fold = (0, import_daemon_core6.summarizeMeshMagiActivity)(magiActivity);
       if (compact) {
         if (fold.groups.length > 0) response.magiActivity = fold.groups;
         response.magiActivitySummary = {
@@ -4563,6 +4803,277 @@ async function meshListNodes(ctx) {
   }, null, 2);
 }
 
+// src/tools/mesh-tools-graph.ts
+function readGraphTaskFields(entry) {
+  const inputsFrom = entry.inputs_from ?? entry.inputsFrom;
+  const runIf = entry.run_if ?? entry.runIf;
+  const onFalse = entry.on_false ?? entry.onFalse;
+  const onUpstreamSkip = readString(entry.on_upstream_skip) || readString(entry.onUpstreamSkip) || void 0;
+  const workspaceRef = readString(entry.workspace_ref) || readString(entry.workspaceRef) || void 0;
+  const rawGatedBy = entry.gated_by ?? entry.gatedBy;
+  const gatedBy = Array.isArray(rawGatedBy) ? rawGatedBy.map((g) => readString(g)).filter((g) => !!g) : void 0;
+  return {
+    ...inputsFrom !== void 0 ? { inputs_from: inputsFrom } : {},
+    ...runIf !== void 0 ? { run_if: runIf } : {},
+    ...onFalse !== void 0 ? { on_false: onFalse } : {},
+    ...onUpstreamSkip ? { on_upstream_skip: onUpstreamSkip } : {},
+    ...workspaceRef ? { workspace_ref: workspaceRef } : {},
+    ...gatedBy && gatedBy.length > 0 ? { gated_by: gatedBy } : {}
+  };
+}
+function normalizeWorkspaceDeclarations(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map((w) => ({
+    ref: readString(w?.ref) || "",
+    ...readString(w?.source_node_id ?? w?.sourceNodeId) ? { source_node_id: readString(w.source_node_id ?? w.sourceNodeId) } : {},
+    ...readString(w?.purpose) ? { purpose: readString(w.purpose) } : {},
+    ...readString(w?.base_revision ?? w?.baseRevision) ? { base_revision: readString(w.base_revision ?? w.baseRevision) } : {},
+    ...readString(w?.desired_path ?? w?.desiredPath) ? { desired_path: readString(w.desired_path ?? w.desiredPath) } : {},
+    ...(w?.cleanup_on_graph_failure ?? w?.cleanupOnGraphFailure) === true ? { cleanup_on_graph_failure: true } : {}
+  }));
+}
+function buildGraphPlanShape(specs, rawEntries, gates, workspaces, hasExplicitBatchId) {
+  const gateSpecs = Array.isArray(gates) ? gates : [];
+  const workspaceSpecs = normalizeWorkspaceDeclarations(workspaces);
+  const tasks = specs.map((spec, i) => ({ ...spec, ...readGraphTaskFields(rawEntries[i] ?? {}) }));
+  return {
+    tasks,
+    gates: gateSpecs,
+    workspaces: workspaceSpecs,
+    useGraphPath: hasExplicitBatchId || (0, import_daemon_core6.requestUsesGraphV2)({ tasks, gates: gateSpecs, workspaces: workspaceSpecs })
+  };
+}
+var GATE_RELEASE_ERROR_CODES = [
+  "gate_not_found",
+  "gate_release_conflict",
+  "gate_already_released",
+  "gate_not_claimed",
+  "stale_fence",
+  "gate_lease_expired",
+  "gate_upstream_unsettled",
+  "gate_patch_not_downstream",
+  "gate_patch_forbidden",
+  "task_already_claimed",
+  "graph_node_not_found"
+];
+function classifyGateError(message) {
+  return GATE_RELEASE_ERROR_CODES.find((code) => message.startsWith(`${code}:`) || message.includes(`${code}:`));
+}
+function resolveGateSession(ctx, explicit) {
+  return readString(explicit) || ctx.coordinatorSessionId || void 0;
+}
+async function meshGraphGateClaim(ctx, args) {
+  (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_graph_gate_claim" });
+  const gateId = readString(args.gate_id) || readString(args.gateId);
+  if (!gateId) {
+    return JSON.stringify({
+      success: false,
+      code: "missing_gate_id",
+      error: "mesh_graph_gate_claim requires gate_id. Use mesh_graph_view to list gates awaiting a coordinator."
+    });
+  }
+  const coordinatorSessionId = resolveGateSession(ctx, args.coordinator_session_id ?? args.coordinatorSessionId);
+  if (!coordinatorSessionId) {
+    return JSON.stringify({
+      success: false,
+      code: "missing_coordinator_session",
+      error: "No coordinator session id is available for this call, so a gate lease cannot be attributed to an owner. Pass coordinator_session_id explicitly."
+    });
+  }
+  const leaseSeconds = readNumber(args.lease_seconds ?? args.leaseSeconds);
+  const extendDeadlineSeconds = readNumber(args.extend_deadline_seconds ?? args.extendDeadlineSeconds);
+  try {
+    const result = (0, import_daemon_core6.claimMeshGraphGate)({
+      meshId: ctx.mesh.id,
+      gateId,
+      coordinatorSessionId,
+      ...leaseSeconds !== void 0 ? { leaseSeconds } : {},
+      ...extendDeadlineSeconds !== void 0 ? { extendDeadlineSeconds } : {}
+    });
+    if (!result.claimed) {
+      return JSON.stringify({
+        success: false,
+        claimed: false,
+        code: result.reason ?? "gate_not_claimable",
+        gateId,
+        ...result.gate ? { gateState: result.gate.state, action: result.gate.action } : {},
+        error: describeClaimRefusal(result.reason, result.gate?.state)
+      });
+    }
+    (0, import_daemon_core6.recordGraphGateClaimed)(ctx.mesh.id, {
+      graphId: result.gate.graphId,
+      gateId,
+      ref: result.gate.ref,
+      action: result.gate.action,
+      generation: result.leaseGeneration,
+      ownerSessionId: coordinatorSessionId,
+      leaseExpiresAt: result.leaseExpiresAt,
+      ambiguousExternalOutcome: result.ambiguousExternalOutcome,
+      previousLeaseOwnerSessionId: result.previousLeaseOwnerSessionId
+    });
+    return JSON.stringify({
+      success: true,
+      claimed: true,
+      gateId,
+      graphId: result.gate.graphId,
+      ...result.gate.ref ? { ref: result.gate.ref } : {},
+      action: result.gate.action,
+      ...result.gate.instructions ? { instructions: result.gate.instructions } : {},
+      // ★ Both values are REQUIRED by mesh_graph_gate_release. Losing them
+      // means the lease must lapse before anyone can act on the gate again.
+      leaseGeneration: result.leaseGeneration,
+      fencingToken: result.fencingToken,
+      leaseExpiresAt: result.leaseExpiresAt,
+      ...result.deadlineAt ? { deadlineAt: result.deadlineAt } : {},
+      onTimeout: result.gate.onTimeout,
+      ...result.ambiguousExternalOutcome ? {
+        ambiguousExternalOutcome: true,
+        previousLeaseOwnerSessionId: result.previousLeaseOwnerSessionId,
+        ambiguousExternalOutcomeHint: "This claim TOOK OVER from a previous owner whose lease lapsed. That owner may already have performed the external side effect (merge, publish, deploy). Reconcile external evidence \u2014 check whether the action already landed \u2014 BEFORE performing it again, then release with the real outcome."
+      } : {},
+      nextStep: "Perform the gate action yourself, then call mesh_graph_gate_release with this leaseGeneration + fencingToken and an idempotency_key. The daemon never performs a gate action and never auto-releases: the gate stays shut until you release it (a deadline can only EXPIRE it, never pass it)."
+    });
+  } catch (e) {
+    const message = e?.message || String(e);
+    return JSON.stringify({ success: false, claimed: false, gateId, code: classifyGateError(message), error: message });
+  }
+}
+function describeClaimRefusal(reason, state) {
+  switch (reason) {
+    case "gate_not_found":
+      return "No such gate on this mesh. Use mesh_graph_view to list gates.";
+    case "gate_not_eligible":
+      return "This gate is restricted to a different coordinator session (eligible_coordinator_session_id).";
+    case "gate_not_awaiting":
+      return "The gate is still `declared` \u2014 its predecessors have not completed yet, so it is not open for a coordinator. Wait for the upstream work; the gate opens itself when its predecessors settle.";
+    case "gate_lease_held":
+      return "Another coordinator holds a LIVE lease on this gate. Wait for the lease to lapse \u2014 a live lease is never taken over, because the holder may be mid-action.";
+    case "gate_claim_race":
+      return "Another claim won the race for this gate. Re-read the gate state and retry if it is still awaiting.";
+    default:
+      if (reason?.startsWith("gate_terminal:")) {
+        return `The gate is terminal (${state ?? reason.slice("gate_terminal:".length)}) and cannot be claimed. A released gate stays released; an expired gate under cancel_downstream/fail_graph has already applied its policy.`;
+      }
+      return `The gate could not be claimed (${reason ?? "unknown reason"}).`;
+  }
+}
+async function meshGraphGateRelease(ctx, args) {
+  (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_graph_gate_release" });
+  const gateId = readString(args.gate_id) || readString(args.gateId);
+  const fencingToken = readString(args.fencing_token) || readString(args.fencingToken);
+  const leaseGeneration = readNumber(args.lease_generation ?? args.leaseGeneration);
+  const idempotencyKey = readString(args.idempotency_key) || readString(args.idempotencyKey);
+  const outcome = readString(args.outcome);
+  const missing = [
+    !gateId ? "gate_id" : null,
+    !fencingToken ? "fencing_token" : null,
+    leaseGeneration === void 0 ? "lease_generation" : null,
+    !idempotencyKey ? "idempotency_key" : null,
+    !outcome ? "outcome" : null
+  ].filter((f) => f !== null);
+  if (missing.length > 0) {
+    return JSON.stringify({
+      success: false,
+      code: "missing_release_fields",
+      missing,
+      error: `mesh_graph_gate_release requires ${missing.join(", ")}. fencing_token and lease_generation come from the mesh_graph_gate_claim response; idempotency_key is yours to choose and makes a retried release a no-op instead of a double release.`
+    });
+  }
+  const patches = (args.patches ?? []).map((p) => ({
+    node: readString(p?.node) || "",
+    baseSpecPatch: p?.base_spec_patch ?? p?.baseSpecPatch ?? {}
+  })).filter((p) => p.node.length > 0);
+  try {
+    const result = (0, import_daemon_core6.releaseMeshGraphGate)({
+      meshId: ctx.mesh.id,
+      gateId,
+      fencingToken,
+      leaseGeneration,
+      idempotencyKey,
+      outcome,
+      ...args.result !== void 0 ? { result: args.result } : {},
+      ...args.evidence !== void 0 ? { evidence: args.evidence } : {},
+      ...patches.length > 0 ? { patches } : {}
+    });
+    (0, import_daemon_core6.recordGraphGateReleased)(ctx.mesh.id, {
+      graphId: result.gate.graphId,
+      gateId,
+      ref: result.gate.ref,
+      action: result.gate.action,
+      outcome,
+      generation: leaseGeneration,
+      releaseDigest: result.gate.releaseEvidenceDigest,
+      materializedNodeIds: result.materializedNodeIds,
+      duplicate: result.duplicate
+    });
+    const queueTrigger = result.materializedNodeIds.length > 0 ? await triggerMeshQueueAndReport(ctx) : void 0;
+    return JSON.stringify({
+      success: true,
+      released: true,
+      // A replayed release (same key + same digest) is a NO-OP SUCCESS, not an
+      // error — that is what makes a retried release safe (design :420-421).
+      duplicate: result.duplicate,
+      gateId,
+      graphId: result.gate.graphId,
+      ...result.gate.ref ? { ref: result.gate.ref } : {},
+      outcome,
+      materializedNodeIds: result.materializedNodeIds,
+      materializedCount: result.materializedNodeIds.length,
+      ...queueTrigger ? { queueTrigger } : {},
+      ...result.duplicate ? { duplicateHint: "This idempotency_key + payload was already committed; nothing changed. Re-sending an identical release is safe." } : {}
+    });
+  } catch (e) {
+    const message = e?.message || String(e);
+    const code = classifyGateError(message);
+    return JSON.stringify({
+      success: false,
+      released: false,
+      gateId,
+      ...code ? { code } : {},
+      error: message,
+      ...code === "gate_lease_expired" ? {
+        hint: "The lease expired before the release. Elapsed time is never completion evidence, so the release is refused. Re-claim the gate (you get a HIGHER generation), reconcile whether the external action already landed, then release."
+      } : {},
+      ...code === "stale_fence" ? { hint: "Another coordinator has claimed this gate since your claim. Your token is stale \u2014 re-claim before releasing." } : {},
+      ...code === "gate_release_conflict" ? { hint: "This idempotency_key was already used with a DIFFERENT payload. Use a new key, or re-send the identical payload." } : {}
+    });
+  }
+}
+async function meshGraphView(ctx, args) {
+  (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_graph_view" });
+  try {
+    await refreshMeshFromDaemon(ctx);
+    const graphId = readString(args.graph_id) || readString(args.graphId);
+    const batchId = readString(args.batch_id) || readString(args.batchId);
+    const includeTerminal = args.include_terminal === true || args.includeTerminal === true;
+    const graphs = (0, import_daemon_core6.buildMeshGraphViews)(ctx.mesh.id, {
+      ...graphId ? { graphId } : {},
+      ...batchId ? { batchId } : {},
+      activeOnly: !includeTerminal,
+      ...readNumber(args.limit) !== void 0 ? { limit: readNumber(args.limit) } : {}
+    });
+    const pendingActions = graphs.flatMap((g) => (g.nextCoordinatorAction ?? []).map((a) => ({ graphId: g.graphId, ...a })));
+    return JSON.stringify({
+      success: true,
+      meshId: ctx.mesh.id,
+      graphCount: graphs.length,
+      ...graphId || batchId ? {} : { scope: includeTerminal ? "all" : "in_flight" },
+      graphs,
+      ...pendingActions.length > 0 ? { pendingCoordinatorActions: pendingActions } : {},
+      ...graphs.length === 0 ? {
+        hint: graphId || batchId ? "No graph with that id on this mesh." : "No in-flight orchestration graphs. Only mesh_enqueue_batch requests that use graph features (gates, inputs_from, run_if, workspace_ref) create a graph; a plain depends_on batch runs on the unchanged queue path. Pass include_terminal=true to see completed graphs."
+      } : {}
+    });
+  } catch (e) {
+    return JSON.stringify({ success: false, error: e?.message || String(e) });
+  }
+}
+function readNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() && Number.isFinite(Number(value))) return Number(value);
+  return void 0;
+}
+
 // src/tools/mesh-tools-queue.ts
 function normalizeDedupMessage(message) {
   return (message || "").trim().replace(/\s+/g, " ").toLowerCase();
@@ -4570,12 +5081,12 @@ function normalizeDedupMessage(message) {
 function findInFlightDuplicate(ctx, message, targetNodeId) {
   const fingerprint = normalizeDedupMessage(message);
   if (!fingerprint) return null;
-  for (const task of (0, import_daemon_core5.getQueue)(ctx.mesh.id)) {
+  for (const task of (0, import_daemon_core6.getQueue)(ctx.mesh.id)) {
     if (task.status !== "pending" && task.status !== "assigned") continue;
     if (normalizeDedupMessage(task.message) !== fingerprint) continue;
     if (targetNodeId) {
       const existingTarget = task.targetNodeId || task.assignedNodeId;
-      if (!existingTarget || !(0, import_daemon_core5.meshNodeIdMatches)({ id: existingTarget }, targetNodeId)) continue;
+      if (!existingTarget || !(0, import_daemon_core6.meshNodeIdMatches)({ id: existingTarget }, targetNodeId)) continue;
     }
     return { id: task.id, status: task.status, assignedNodeId: task.assignedNodeId, targetNodeId: task.targetNodeId };
   }
@@ -4602,10 +5113,10 @@ function normalizeEnqueueTaskArgs(ctx, args, callerLabel) {
   }
   const taskMode = readString(args.task_mode) || readString(args.taskMode);
   const readonly = args.readonly === true || args.read_only === true;
-  const requiredTags = (0, import_daemon_core5.normalizeMeshCapabilityTags)(Array.isArray(args.requiredTags) ? args.requiredTags : args.required_tags);
+  const requiredTags = (0, import_daemon_core6.normalizeMeshCapabilityTags)(Array.isArray(args.requiredTags) ? args.requiredTags : args.required_tags);
   const dependsOn = Array.isArray(args.dependsOn) ? args.dependsOn : Array.isArray(args.depends_on) ? args.depends_on : void 0;
   const missionId = readString(args.missionId) || readString(args.mission_id) || void 0;
-  if (missionId && !(0, import_daemon_core5.getMeshMission)(ctx.mesh.id, missionId)) {
+  if (missionId && !(0, import_daemon_core6.getMeshMission)(ctx.mesh.id, missionId)) {
     return {
       ok: false,
       code: "mission_not_found",
@@ -4613,19 +5124,19 @@ function normalizeEnqueueTaskArgs(ctx, args, callerLabel) {
       extra: { missionId }
     };
   }
-  const priority = (0, import_daemon_core5.normalizeMeshTaskPriority)(readString(args.priority)) || void 0;
+  const priority = (0, import_daemon_core6.normalizeMeshTaskPriority)(readString(args.priority)) || void 0;
   const model = readString(args.model) || void 0;
   const thinkingLevel = readString(args.thinkingLevel) || void 0;
   const difficulty = readString(args.difficulty) || void 0;
   const notBeforeRaw = args.notBefore !== void 0 ? args.notBefore : args.not_before;
-  const notBefore = (0, import_daemon_core5.resolveNotBefore)(notBeforeRaw);
+  const notBefore = (0, import_daemon_core6.resolveNotBefore)(notBeforeRaw);
   const maxRetriesRaw = typeof args.maxRetries === "number" ? args.maxRetries : typeof args.max_retries === "number" ? args.max_retries : void 0;
   const maxRetries = typeof maxRetriesRaw === "number" && Number.isFinite(maxRetriesRaw) && maxRetriesRaw >= 0 ? Math.floor(maxRetriesRaw) : void 0;
   const explicitTargetRaw = readString(args.targetNodeId) || readString(args.target_node_id) || readString(args.targetNode) || readString(args.target_node) || void 0;
   const preferWorktree = args.preferWorktree === true || args.prefer_worktree === true;
   let targetNodeId;
   if (explicitTargetRaw) {
-    const matched = ctx.mesh.nodes.find((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, explicitTargetRaw));
+    const matched = ctx.mesh.nodes.find((n) => (0, import_daemon_core6.meshNodeIdMatches)(n, explicitTargetRaw));
     if (!matched) {
       return {
         ok: false,
@@ -4668,7 +5179,7 @@ function eagerPushTaskToRemoteNodes(ctx, task, message, targetNodeId, requiredTa
     const isLocalNode = isLocalControlPlaneNode(ctx, node);
     if (isLocalNode || !node.daemonId) continue;
     if (targetNodeId && node.id !== targetNodeId) continue;
-    if (!(0, import_daemon_core5.nodeSatisfiesRequiredTags)(requiredTags, (0, import_daemon_core5.buildMeshNodeCapabilityTags)(node))) continue;
+    if (!(0, import_daemon_core6.nodeSatisfiesRequiredTags)(requiredTags, (0, import_daemon_core6.buildMeshNodeCapabilityTags)(node))) continue;
     dispatchPromises.push(
       ipcDispatchToRemoteAgent(ctx, node, {
         message,
@@ -4683,7 +5194,7 @@ function eagerPushTaskToRemoteNodes(ctx, task, message, targetNodeId, requiredTa
           try {
             const providerType = result.providerType;
             const descriptor = summarizeTaskMessage(message);
-            (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+            (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
               kind: "task_dispatched",
               nodeId: node.id,
               sessionId: result.sessionId,
@@ -4705,7 +5216,7 @@ function eagerPushTaskToRemoteNodes(ctx, task, message, targetNodeId, requiredTa
         }
       }).catch((err) => {
         try {
-          (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+          (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
             kind: "p2p_dispatch_failed",
             nodeId: node.id,
             payload: {
@@ -4757,7 +5268,7 @@ async function meshEnqueueTask(ctx, args) {
     });
   }
   try {
-    const task = (0, import_daemon_core5.enqueueTask)(ctx.mesh.id, message, {
+    const task = (0, import_daemon_core6.enqueueTask)(ctx.mesh.id, message, {
       taskMode,
       ...readonly ? { readonly: true } : {},
       requiredTags,
@@ -4808,9 +5319,9 @@ async function meshEnqueueTask(ctx, args) {
     {
       const queueTrigger = await triggerMeshQueueAndReport(ctx);
       const dependencyStatusById = new Map(
-        (0, import_daemon_core5.getQueue)(ctx.mesh.id).map((t) => [t.id, t.status])
+        (0, import_daemon_core6.getQueue)(ctx.mesh.id).map((t) => [t.id, t.status])
       );
-      const eagerPushDeferred = !(0, import_daemon_core5.taskDependenciesSatisfied)(task, dependencyStatusById);
+      const eagerPushDeferred = !(0, import_daemon_core6.taskDependenciesSatisfied)(task, dependencyStatusById);
       const coordinatorDaemonId = resolveCoordinatorDaemonId(ctx);
       const dispatchPromises = eagerPushDeferred ? [] : eagerPushTaskToRemoteNodes(ctx, task, message, targetNodeId, requiredTags, coordinatorDaemonId);
       Promise.all(dispatchPromises).catch(() => {
@@ -4853,7 +5364,8 @@ var BATCH_ENQUEUE_ERROR_CODES = [
   "task_graph_too_large",
   "empty_task_graph",
   "missing_task_difficulty",
-  "invalid_task_difficulty"
+  "invalid_task_difficulty",
+  "invalid_on_dependency_failure"
 ];
 async function meshEnqueueBatch(ctx, args) {
   const rawTasks = Array.isArray(args.tasks) ? args.tasks : void 0;
@@ -4864,15 +5376,29 @@ async function meshEnqueueBatch(ctx, args) {
       error: "mesh_enqueue_batch requires a non-empty `tasks` array."
     });
   }
-  if (rawTasks.length > import_daemon_core5.MESH_TASK_GRAPH_MAX_TASKS) {
+  if (rawTasks.length > import_daemon_core6.MESH_TASK_GRAPH_MAX_TASKS) {
     return JSON.stringify({
       success: false,
       code: "task_graph_too_large",
-      error: `mesh_enqueue_batch accepts at most ${import_daemon_core5.MESH_TASK_GRAPH_MAX_TASKS} tasks per call (got ${rawTasks.length}). Split the graph, or reconsider whether one batch really needs this many tasks.`
+      error: `mesh_enqueue_batch accepts at most ${import_daemon_core6.MESH_TASK_GRAPH_MAX_TASKS} tasks per call (got ${rawTasks.length}). Split the graph, or reconsider whether one batch really needs this many tasks.`
     });
   }
   const batchMissionId = readString(args.missionId) || readString(args.mission_id) || void 0;
-  if (batchMissionId && !(0, import_daemon_core5.getMeshMission)(ctx.mesh.id, batchMissionId)) {
+  const rawFailurePolicy = args.on_dependency_failure ?? args.onDependencyFailure;
+  let onDependencyFailure;
+  if (rawFailurePolicy !== void 0) {
+    try {
+      onDependencyFailure = (0, import_daemon_core6.parseOnDependencyFailurePolicy)(rawFailurePolicy);
+    } catch (e) {
+      const message = e instanceof import_daemon_core6.MeshGraphPolicyError || e instanceof Error ? e.message : "invalid_on_dependency_failure";
+      return JSON.stringify({
+        success: false,
+        code: "invalid_on_dependency_failure",
+        error: message
+      });
+    }
+  }
+  if (batchMissionId && !(0, import_daemon_core6.getMeshMission)(ctx.mesh.id, batchMissionId)) {
     return JSON.stringify({
       success: false,
       code: "mission_not_found",
@@ -4883,6 +5409,7 @@ async function meshEnqueueBatch(ctx, args) {
   const allowDuplicate = args.allowDuplicate === true || args.allow_duplicate === true;
   const blockDuplicate = args.blockDuplicate === true || args.block_duplicate === true;
   const specs = [];
+  const rawGraphEntries = [];
   const normalizedEntries = [];
   const duplicateSuspects = [];
   for (let i = 0; i < rawTasks.length; i++) {
@@ -4914,6 +5441,7 @@ async function meshEnqueueBatch(ctx, args) {
       }
     }
     normalizedEntries.push({ ...v, ...ref ? { ref } : {} });
+    rawGraphEntries.push(entry);
     specs.push({
       ...ref ? { ref } : {},
       message: v.message,
@@ -4942,18 +5470,75 @@ async function meshEnqueueBatch(ctx, args) {
       atomic: true
     });
   }
+  const batchIdArg = readString(args.batch_id) || readString(args.batchId) || void 0;
+  const plan = buildGraphPlanShape(specs, rawGraphEntries, args.gates, args.workspaces, !!batchIdArg);
+  const useGraphPath = plan.useGraphPath;
+  const decision = (0, import_daemon_core6.normalizeOrchestrationDecision)(
+    args.orchestration_decision ?? args.orchestrationDecision,
+    "batch"
+  );
   let tasks;
+  let graphPlan;
   try {
-    tasks = (0, import_daemon_core5.enqueueTaskGraph)(ctx.mesh.id, specs);
+    if (useGraphPath) {
+      graphPlan = (0, import_daemon_core6.commitMeshGraphPlan)({
+        meshId: ctx.mesh.id,
+        tasks: plan.tasks,
+        gates: plan.gates,
+        workspaces: plan.workspaces,
+        ...batchIdArg ? { batchId: batchIdArg } : {},
+        ...batchMissionId ? { missionId: batchMissionId } : {},
+        ...onDependencyFailure ? { onDependencyFailure } : {},
+        ...ctx.coordinatorSessionId ? { sourceCoordinatorSessionId: ctx.coordinatorSessionId } : {},
+        enqueueSurface: "batch",
+        orchestrationDecision: decision.decision
+      });
+      tasks = graphPlan.tasks;
+    } else {
+      tasks = (0, import_daemon_core6.enqueueTaskGraph)(ctx.mesh.id, specs);
+    }
   } catch (e) {
     const message = e?.message || String(e);
-    const code = BATCH_ENQUEUE_ERROR_CODES.find((c) => message.includes(c));
+    const code = e instanceof import_daemon_core6.MeshGraphPlanError ? e.code : BATCH_ENQUEUE_ERROR_CODES.find((c) => message.includes(c));
+    if (useGraphPath) {
+      (0, import_daemon_core6.recordGraphEnqueueRolledBack)(ctx.mesh.id, {
+        code: code ?? "graph_plan_failed",
+        ...batchIdArg ? { batchId: batchIdArg } : {},
+        taskCount: specs.length,
+        error: message
+      });
+    } else {
+      (0, import_daemon_core6.recordGraphEnqueueValidationFailed)(ctx.mesh.id, {
+        code: code ?? "batch_enqueue_failed",
+        ...batchIdArg ? { batchId: batchIdArg } : {},
+        taskCount: specs.length
+      });
+    }
     return JSON.stringify({
       success: false,
       ...code ? { code } : {},
       error: message,
       enqueued: 0,
-      atomic: true
+      atomic: true,
+      ...e instanceof import_daemon_core6.MeshGraphPlanError && e.extra ? e.extra : {}
+    });
+  }
+  if (graphPlan) {
+    (0, import_daemon_core6.recordGraphEnqueueCommitted)(ctx.mesh.id, {
+      graphId: graphPlan.graphId,
+      batchId: graphPlan.batchId,
+      enqueueSurface: "batch",
+      schemaVersion: 2,
+      planDigest: graphPlan.planDigest,
+      ...batchMissionId ? { missionId: batchMissionId } : {},
+      ...ctx.coordinatorSessionId ? { coordinatorSessionId: ctx.coordinatorSessionId } : {},
+      taskCount: graphPlan.tasks.length,
+      gateCount: graphPlan.gates.length,
+      workspaceCount: graphPlan.workspaces.length,
+      dependencyEdgeCount: graphPlan.dependencyEdgeCount,
+      onDependencyFailure: onDependencyFailure ?? "block",
+      orchestrationDecision: decision.decision,
+      ...graphPlan.replayed ? { replayed: true } : {}
     });
   }
   const distinctMissionIds = [...new Set(specs.map((s) => s.missionId).filter((m) => !!m))];
@@ -4976,13 +5561,14 @@ async function meshEnqueueBatch(ctx, args) {
   const queueTrigger = await triggerMeshQueueAndReport(ctx);
   let eagerPushDeferredCount = 0;
   if (ctx.transport instanceof IpcTransport) {
-    const dependencyStatusById = new Map(
-      (0, import_daemon_core5.getQueue)(ctx.mesh.id).map((t) => [t.id, t.status])
-    );
+    const liveQueue = (0, import_daemon_core6.getQueue)(ctx.mesh.id);
+    const dependencyStatusById = new Map(liveQueue.map((t) => [t.id, t.status]));
+    const liveById = new Map(liveQueue.map((t) => [t.id, t]));
     const coordinatorDaemonId = resolveCoordinatorDaemonId(ctx);
     const dispatchPromises = [];
-    tasks.forEach((task, i) => {
-      if (!(0, import_daemon_core5.taskDependenciesSatisfied)(task, dependencyStatusById)) {
+    tasks.forEach((snapshot, i) => {
+      const task = liveById.get(snapshot.id) ?? snapshot;
+      if (!(0, import_daemon_core6.taskDependenciesSatisfied)(task, dependencyStatusById)) {
         eagerPushDeferredCount++;
         return;
       }
@@ -5003,11 +5589,37 @@ async function meshEnqueueBatch(ctx, args) {
     source: "queue",
     atomic: true,
     enqueued: tasks.length,
+    ...onDependencyFailure ? { on_dependency_failure: onDependencyFailure } : {},
+    // ── batch v2 additive response fields (design :582) ──
+    // Present only on the graph path: an old-path batch creates no graph, so
+    // reporting a graphId for it would be a lie.
+    ...graphPlan ? {
+      graphId: graphPlan.graphId,
+      batchId: graphPlan.batchId,
+      planDigest: graphPlan.planDigest,
+      // design :585-588 — DB atomicity NEVER implies the git worktree exists.
+      workspacePreparation: graphPlan.workspacePreparation,
+      ...graphPlan.replayed ? {
+        replayed: true,
+        replayedHint: "A graph with this batch_id and an identical plan digest already existed; nothing was re-inserted. Re-sending the same batch_id with a DIFFERENT plan is rejected as batch_id_conflict."
+      } : {},
+      ...graphPlan.gates.length > 0 ? {
+        gates: graphPlan.gates,
+        gateHint: "Gates are declared shut. When their predecessors complete they open (awaiting_coordinator) and BLOCK their downstream tasks. Pass one with mesh_graph_gate_claim \u2192 do the action yourself \u2192 mesh_graph_gate_release. The daemon never performs a gate action and a deadline can only expire a gate, never pass it."
+      } : {},
+      ...graphPlan.workspaces.length > 0 ? { workspaces: graphPlan.workspaces } : {},
+      ...graphPlan.heldNodeIds.length > 0 ? {
+        graphHeldTasks: graphPlan.heldNodeIds.length,
+        graphHeldHint: "Tasks declaring graph features (bound upstream outputs, a condition, a delayed worktree, or a gate) are held until the graph settles them \u2014 that is what makes their final instruction knowable. Tasks with only plain dependencies are NOT held; they use the unchanged queue dependency predicate."
+      } : {}
+    } : {},
+    ...decision.batchCapabilityAvailable ? { batchCapabilityAvailable: decision.batchCapabilityAvailable } : {},
     tasks: tasks.map((task, i) => ({
       ...normalizedEntries[i].ref ? { ref: normalizedEntries[i].ref } : {},
       taskId: task.id,
       status: task.status,
       taskMode: task.taskMode,
+      ...graphPlan?.nodeIdByIndex[i] ? { nodeId: graphPlan.nodeIdByIndex[i] } : {},
       ...Array.isArray(task.dependsOn) && task.dependsOn.length > 0 ? { dependsOn: task.dependsOn } : {},
       ...task.targetNodeId ? { targetNodeId: task.targetNodeId } : {},
       ...task.priority ? { priority: task.priority } : {},
@@ -5025,17 +5637,18 @@ async function meshEnqueueBatch(ctx, args) {
   });
 }
 async function meshViewQueue(ctx, args) {
-  const rateResult = (0, import_daemon_core5.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_view_queue" });
+  const rateResult = (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_view_queue" });
   const compact = args.verbose === true ? false : args.compact ?? true;
   try {
     await refreshMeshFromDaemon(ctx);
     const statusFilter = sanitizeQueueStatusFilter(args.status);
     const view = normalizeQueueViewMode(args.view);
-    const rawQueue = (0, import_daemon_core5.getQueue)(ctx.mesh.id);
+    const rawQueue = (0, import_daemon_core6.getQueue)(ctx.mesh.id);
     const statusById = new Map(rawQueue.map((task) => [task.id, task.status]));
+    const depMetaById = new Map(rawQueue.map((task) => [task.id, task]));
     const withDependencies = rawQueue.map((task) => {
       if (!Array.isArray(task.dependsOn) || task.dependsOn.length === 0) return task;
-      const depState = (0, import_daemon_core5.describeTaskDependencyState)(task, statusById);
+      const depState = (0, import_daemon_core6.describeTaskDependencyState)(task, statusById, depMetaById);
       return { ...task, ...depState };
     });
     const liveNodes = await collectMeshViewQueueNodesWithLiveSessionsVerified(ctx);
@@ -5044,16 +5657,16 @@ async function meshViewQueue(ctx, args) {
     const summary = buildQueueStatusSummary(fullQueue);
     const visibleSummary = buildQueueStatusSummary(queue);
     const maintenance = buildQueueMaintenanceReport(fullQueue);
-    let ledgerEntries = (0, import_daemon_core5.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
-    let directDispatches = (0, import_daemon_core5.getActiveDirectDispatches)(ctx.mesh.id);
+    let ledgerEntries = (0, import_daemon_core6.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
+    let directDispatches = (0, import_daemon_core6.getActiveDirectDispatches)(ctx.mesh.id);
     const directReconciliation = await reconcileDirectDispatchesFromTranscriptEvidence(ctx, liveNodes, directDispatches, ledgerEntries);
     if (directReconciliation.reconciled > 0) {
-      ledgerEntries = (0, import_daemon_core5.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
-      directDispatches = (0, import_daemon_core5.getActiveDirectDispatches)(ctx.mesh.id);
+      ledgerEntries = (0, import_daemon_core6.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
+      directDispatches = (0, import_daemon_core6.getActiveDirectDispatches)(ctx.mesh.id);
     }
-    (0, import_daemon_core5.markStaleDirectDispatches)(ctx.mesh.id);
-    directDispatches = (0, import_daemon_core5.getActiveDirectDispatches)(ctx.mesh.id);
-    const activeWorkEvidence = (0, import_daemon_core5.buildMeshActiveWork)({
+    (0, import_daemon_core6.markStaleDirectDispatches)(ctx.mesh.id);
+    directDispatches = (0, import_daemon_core6.getActiveDirectDispatches)(ctx.mesh.id);
+    const activeWorkEvidence = (0, import_daemon_core6.buildMeshActiveWork)({
       meshId: ctx.mesh.id,
       queue: fullQueue,
       ledgerEntries,
@@ -5078,7 +5691,7 @@ async function meshViewQueue(ctx, args) {
     const wantActiveQueueArray = view === "active" || statusFilter?.some((status) => ACTIVE_QUEUE_STATUSES.has(status));
     const wantHistoricalQueueArray = !compact && (view === "historical" || requestedHistoricalRows);
     const activeWorkResult = compact ? compactActiveWorkRecords(activeWorkEvidence.activeWork) : { records: activeWorkEvidence.activeWork, omitted: 0 };
-    const staleDirectWorkSummary = (0, import_daemon_core5.buildCompactStaleDirectWorkSummary)(activeWorkEvidence.staleDirectWork, {
+    const staleDirectWorkSummary = (0, import_daemon_core6.buildCompactStaleDirectWorkSummary)(activeWorkEvidence.staleDirectWork, {
       note: activeWorkEvidence.staleDirectWorkNote,
       detailHint: "Full stale direct entries are omitted from mesh_view_queue in compact mode. Call mesh_view_queue with verbose=true, or inspect mesh_task_history for ledger detail."
     });
@@ -5153,12 +5766,12 @@ async function meshQueueCancel(ctx, args) {
   try {
     const taskId = (args.task_id || args.taskId || "").trim();
     if (!taskId) return JSON.stringify({ success: false, error: "task_id required" });
-    const preCancel = (0, import_daemon_core5.getQueue)(ctx.mesh.id).find((t) => t?.id === taskId);
+    const preCancel = (0, import_daemon_core6.getQueue)(ctx.mesh.id).find((t) => t?.id === taskId);
     const wasAssigned = preCancel?.status === "assigned";
     const assignedSessionId = readString(preCancel?.assignedSessionId) || void 0;
     const assignedNodeId = readString(preCancel?.assignedNodeId) || void 0;
     const assignedProviderType = readString(preCancel?.assignedProviderType) || void 0;
-    const task = (0, import_daemon_core5.cancelTask)(ctx.mesh.id, taskId, { reason: args.reason });
+    const task = (0, import_daemon_core6.cancelTask)(ctx.mesh.id, taskId, { reason: args.reason });
     if (!task) return JSON.stringify({ success: false, error: `Queue task '${taskId}' not found` });
     ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
     });
@@ -5188,7 +5801,7 @@ async function meshQueueCancel(ctx, args) {
     let orphanedPinnedTasks = [];
     if (workerStop.attempted && assignedSessionId) {
       try {
-        orphanedPinnedTasks = (0, import_daemon_core5.notifyCoordinatorOfOrphanedPins)(ctx.mesh.id, assignedSessionId, {
+        orphanedPinnedTasks = (0, import_daemon_core6.notifyCoordinatorOfOrphanedPins)(ctx.mesh.id, assignedSessionId, {
           excludeTaskId: taskId,
           cause: `Cancelling task ${taskId}`,
           ...assignedNodeId ? { nodeId: assignedNodeId } : {},
@@ -5207,7 +5820,7 @@ async function meshQueueCancel(ctx, args) {
       // can act without waiting for the event round-trip.
       ...orphanedPinnedTasks.length > 0 ? {
         orphanedPinnedTasks,
-        orphanedPinnedTasksWarning: (0, import_daemon_core5.buildOrphanedPinNotice)(
+        orphanedPinnedTasksWarning: (0, import_daemon_core6.buildOrphanedPinNotice)(
           orphanedPinnedTasks,
           assignedSessionId,
           `Cancelling task ${taskId}`
@@ -5262,7 +5875,7 @@ async function meshQueueRequeue(ctx, args) {
       });
       return JSON.stringify({ success: true, task: task2 }, null, 2);
     }
-    const task = (0, import_daemon_core5.requeueTask)(ctx.mesh.id, taskId, {
+    const task = (0, import_daemon_core6.requeueTask)(ctx.mesh.id, taskId, {
       reason: args.reason,
       targetNodeId,
       targetSessionId,
@@ -5301,17 +5914,17 @@ async function meshTaskHistory(ctx, args) {
   const compactCap = requestedTail > 50 ? 20 : 30;
   const tail = compact ? Math.min(requestedTail, compactCap) : Math.min(requestedTail, 200);
   const kind = typeof args.kind === "string" && args.kind.trim() ? [args.kind.trim()] : void 0;
-  const rawEntries = (0, import_daemon_core5.readLedgerEntries)(mesh.id, { tail, kind });
+  const rawEntries = (0, import_daemon_core6.readLedgerEntries)(mesh.id, { tail, kind });
   const entries = compact ? rawEntries.map((e) => ({
     ...e,
     payload: e.payload ? slimLedgerPayload(e.payload) : e.payload
   })) : rawEntries;
-  const summary = (0, import_daemon_core5.getLedgerSummary)(mesh.id);
+  const summary = (0, import_daemon_core6.getLedgerSummary)(mesh.id);
   let taskStats;
   try {
     const taskIds = [...new Set(rawEntries.map((e) => typeof e.payload?.taskId === "string" ? e.payload.taskId : "").filter(Boolean))];
     if (taskIds.length > 0) {
-      const stats = (0, import_daemon_core5.computeMeshTaskStats)(mesh.id, { taskIds });
+      const stats = (0, import_daemon_core6.computeMeshTaskStats)(mesh.id, { taskIds });
       if (stats.length > 0) taskStats = stats;
     }
   } catch {
@@ -5333,8 +5946,8 @@ async function meshLedgerQuery(ctx, args) {
   const node = typeof args.node === "string" && args.node.trim() ? args.node.trim() : void 0;
   const requestedTail = typeof args.tail === "number" && args.tail > 0 ? Math.floor(args.tail) : 50;
   const tail = Math.min(requestedTail, 500);
-  const entries = (0, import_daemon_core5.readLedgerEntries)(mesh.id, { tail, kind, since, node });
-  const summary = (0, import_daemon_core5.getLedgerSummary)(mesh.id);
+  const entries = (0, import_daemon_core6.readLedgerEntries)(mesh.id, { tail, kind, since, node });
+  const summary = (0, import_daemon_core6.getLedgerSummary)(mesh.id);
   return JSON.stringify({
     meshId: mesh.id,
     query: {
@@ -5367,7 +5980,7 @@ async function meshRecordNote(ctx, args) {
   const supersedes = typeof args.supersedes === "string" && args.supersedes.trim() ? args.supersedes.trim() : void 0;
   const subjectKey = typeof args.subject_key === "string" && args.subject_key.trim() ? args.subject_key.trim() : void 0;
   const sourceCoordinator = ctx.coordinatorSessionId || ctx.localDaemonId || ctx.coordinatorHostname || void 0;
-  const entry = (0, import_daemon_core5.appendLedgerEntry)(mesh.id, {
+  const entry = (0, import_daemon_core6.appendLedgerEntry)(mesh.id, {
     kind: "coordinator_operating_note",
     ...sourceCoordinator ? { sessionId: sourceCoordinator } : {},
     payload: {
@@ -5405,7 +6018,7 @@ async function meshForgetNote(ctx, args) {
     return JSON.stringify({ success: false, error: "note_id or text required" }, null, 2);
   }
   try {
-    const { tombstone, matched } = (0, import_daemon_core5.tombstoneOperatingNote)(mesh.id, {
+    const { tombstone, matched } = (0, import_daemon_core6.tombstoneOperatingNote)(mesh.id, {
       ...noteId ? { noteId } : {},
       ...text ? { text } : {},
       ...typeof args.reason === "string" && args.reason.trim() ? { reason: args.reason.trim() } : {}
@@ -5438,8 +6051,8 @@ async function meshReconcileLedger(ctx, args) {
   const reconcileNode = async (node) => {
     try {
       if (isLocalControlPlaneNode(ctx, node) || !node.daemonId) {
-        const slice2 = (0, import_daemon_core5.readLedgerSliceFromStore)(ctx.mesh.id, queryArgs);
-        return (0, import_daemon_core5.buildMeshLedgerReplicaEvidence)({
+        const slice2 = (0, import_daemon_core6.readLedgerSliceFromStore)(ctx.mesh.id, queryArgs);
+        return (0, import_daemon_core6.buildMeshLedgerReplicaEvidence)({
           nodeId: node.id,
           daemonId: node.daemonId,
           transport: "local",
@@ -5456,9 +6069,9 @@ async function meshReconcileLedger(ctx, args) {
       if (slice?.protocol !== "adhdev.mesh.ledger.slice.v1" || !Array.isArray(slice.entries)) {
         throw new Error("remote daemon returned an invalid ledger slice payload");
       }
-      const importResult = shouldImport ? (0, import_daemon_core5.appendRemoteLedgerEntries)(ctx.mesh.id, slice.entries) : { accepted: 0, skippedDuplicate: 0, rejectedInvalid: 0, entries: [] };
+      const importResult = shouldImport ? (0, import_daemon_core6.appendRemoteLedgerEntries)(ctx.mesh.id, slice.entries) : { accepted: 0, skippedDuplicate: 0, rejectedInvalid: 0, entries: [] };
       if (shouldImport && importResult.accepted > 0) {
-        (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+        (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
           kind: "ledger_replicated",
           nodeId: node.id,
           payload: {
@@ -5471,7 +6084,7 @@ async function meshReconcileLedger(ctx, args) {
           }
         });
       }
-      return (0, import_daemon_core5.buildMeshLedgerReplicaEvidence)({
+      return (0, import_daemon_core6.buildMeshLedgerReplicaEvidence)({
         nodeId: node.id,
         daemonId: node.daemonId,
         transport: "p2p_datachannel",
@@ -5479,7 +6092,7 @@ async function meshReconcileLedger(ctx, args) {
         importResult
       });
     } catch (e) {
-      return (0, import_daemon_core5.buildMeshLedgerReplicaEvidence)({
+      return (0, import_daemon_core6.buildMeshLedgerReplicaEvidence)({
         nodeId: node.id,
         daemonId: node.daemonId,
         transport: node.daemonId ? "p2p_datachannel" : "local",
@@ -5494,7 +6107,7 @@ async function meshReconcileLedger(ctx, args) {
       replicas.push(outcome.value);
     } else {
       const node = nodes[idx];
-      replicas.push((0, import_daemon_core5.buildMeshLedgerReplicaEvidence)({
+      replicas.push((0, import_daemon_core6.buildMeshLedgerReplicaEvidence)({
         nodeId: node.id,
         daemonId: node.daemonId,
         transport: node.daemonId ? "p2p_datachannel" : "local",
@@ -5503,8 +6116,8 @@ async function meshReconcileLedger(ctx, args) {
       }));
     }
   });
-  const evidence = (0, import_daemon_core5.buildMeshLedgerReconciliationEvidence)(ctx.mesh.id, replicas);
-  (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+  const evidence = (0, import_daemon_core6.buildMeshLedgerReconciliationEvidence)(ctx.mesh.id, replicas);
+  (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
     kind: "ledger_reconciled",
     payload: {
       protocol: evidence.protocol,
@@ -5525,7 +6138,7 @@ async function meshRequeueHeldEvents(ctx, args) {
     ...readString(raw.reason) ? { reason: readString(raw.reason) } : {},
     ...readString(raw.since) ? { since: readString(raw.since) } : {}
   } : void 0;
-  const result = (0, import_daemon_core5.requeueHeldMeshCoordinatorEvents)(mesh.id, filter && Object.keys(filter).length > 0 ? filter : void 0);
+  const result = (0, import_daemon_core6.requeueHeldMeshCoordinatorEvents)(mesh.id, filter && Object.keys(filter).length > 0 ? filter : void 0);
   const note = result.matched === 0 ? "No recoverable held events matched. Nothing to requeue." : `${result.requeued} held event(s) restored to the pending queue` + (result.dedupSuppressed > 0 ? ` (${result.dedupSuppressed} collapsed onto still-live duplicates)` : "") + (result.alreadyRequeued > 0 ? `; ${result.alreadyRequeued} already recovered by a prior pass` : "") + (result.unrecoverable > 0 ? `; ${result.unrecoverable} had no restorable original event` : "") + ". A coordinator will drain them on its next poll.";
   return JSON.stringify({ success: true, ...result, note }, null, 2);
 }
@@ -5543,7 +6156,7 @@ async function meshMissionUpsert(ctx, args) {
         error: "mission_title_required: single-mission upsert needs a non-empty title. For a bulk status transition pass mission_ids (array) + status instead."
       });
     }
-    const mission = (0, import_daemon_core5.upsertMeshMission)(ctx.mesh.id, {
+    const mission = (0, import_daemon_core6.upsertMeshMission)(ctx.mesh.id, {
       id: readString(args.mission_id) || readString(args.missionId) || void 0,
       title,
       goal: typeof args.goal === "string" ? args.goal : void 0,
@@ -5579,9 +6192,9 @@ async function meshMissionUpsertBulk(ctx, missionIds, status) {
   }
   const results = missionIds.map((id) => {
     try {
-      const existing = (0, import_daemon_core5.getMeshMission)(ctx.mesh.id, id);
+      const existing = (0, import_daemon_core6.getMeshMission)(ctx.mesh.id, id);
       if (!existing) return { id, ok: false, error: "mission_not_found" };
-      const updated = (0, import_daemon_core5.upsertMeshMission)(ctx.mesh.id, {
+      const updated = (0, import_daemon_core6.upsertMeshMission)(ctx.mesh.id, {
         id,
         title: existing.title,
         status
@@ -5608,12 +6221,12 @@ async function meshMissionUpsertBulk(ctx, missionIds, status) {
 async function meshMissionList(ctx, args = {}) {
   try {
     const rawStatuses = Array.isArray(args.status) ? args.status : typeof args.status === "string" && args.status.trim() ? [args.status] : [];
-    const invalid = rawStatuses.filter((s) => !import_daemon_core5.MESH_MISSION_STATUSES.includes(s));
+    const invalid = rawStatuses.filter((s) => !import_daemon_core6.MESH_MISSION_STATUSES.includes(s));
     if (invalid.length > 0) {
       return JSON.stringify({
         success: false,
         code: "invalid_mission_status",
-        error: `invalid status filter: ${invalid.join(", ")} (valid: ${import_daemon_core5.MESH_MISSION_STATUSES.join(", ")})`
+        error: `invalid status filter: ${invalid.join(", ")} (valid: ${import_daemon_core6.MESH_MISSION_STATUSES.join(", ")})`
       });
     }
     const statuses = rawStatuses.length > 0 ? rawStatuses : void 0;
@@ -5621,7 +6234,7 @@ async function meshMissionList(ctx, args = {}) {
     const verbose = args.verbose === true;
     const withStats = verbose || (args.include_stats ?? args.includeStats) === true;
     const limit = typeof args.limit === "number" && Number.isFinite(args.limit) && args.limit > 0 ? Math.floor(args.limit) : void 0;
-    const result = (0, import_daemon_core5.listMeshMissionsForTool)(ctx.mesh.id, {
+    const result = (0, import_daemon_core6.listMeshMissionsForTool)(ctx.mesh.id, {
       statuses,
       verbose,
       includeMagi,
@@ -5654,7 +6267,7 @@ async function meshReviewInbox(ctx, args = {}) {
 }
 
 // src/tools/mesh-tools-magi.ts
-var import_daemon_core6 = require("@adhdev/daemon-core");
+var import_daemon_core7 = require("@adhdev/daemon-core");
 var MAGI_MAX_REPLICAS = 12;
 var MAGI_MIN_TARGETS = 2;
 var MAGI_CLUSTER_JACCARD = 0.4;
@@ -6138,19 +6751,19 @@ function buildMagiFanoutPlan(slots, nodes, opts = {}) {
   slotList.forEach((slot, slotIndex) => {
     const provider = slot.provider;
     const model = typeof slot.model === "string" && slot.model.trim() ? slot.model.trim() : void 0;
-    const capabilityTags = (0, import_daemon_core5.normalizeMeshCapabilityTags)(slot.capabilityTags);
-    const requiredTags = (0, import_daemon_core5.normalizeMeshCapabilityTags)([`provider=${provider}`, ...capabilityTags]);
+    const capabilityTags = (0, import_daemon_core6.normalizeMeshCapabilityTags)(slot.capabilityTags);
+    const requiredTags = (0, import_daemon_core6.normalizeMeshCapabilityTags)([`provider=${provider}`, ...capabilityTags]);
     const count = replicaCountFor(slot, defaultN, opts.n);
     let targetNodeId;
     let candidateNodes = [];
     if (slot.nodeId) {
-      const node = nodes.find((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, slot.nodeId));
+      const node = nodes.find((n) => (0, import_daemon_core6.meshNodeIdMatches)(n, slot.nodeId));
       if (node) {
         targetNodeId = node.id;
         candidateNodes = [node];
       }
     } else {
-      candidateNodes = nodes.filter((n) => (0, import_daemon_core5.nodeSatisfiesRequiredTags)(requiredTags, (0, import_daemon_core5.buildMeshNodeCapabilityTags)(n)));
+      candidateNodes = nodes.filter((n) => (0, import_daemon_core6.nodeSatisfiesRequiredTags)(requiredTags, (0, import_daemon_core6.buildMeshNodeCapabilityTags)(n)));
     }
     const available = candidateNodes.length > 0;
     if (!available) {
@@ -6164,9 +6777,9 @@ function buildMagiFanoutPlan(slots, nodes, opts = {}) {
       slotResolutions.push({ slotIndex, provider, nodeId: slot.nodeId, capabilityTags, available: false, gitStale: false, unhealthy: false, excluded: true, reason: "unavailable" });
       return;
     }
-    const launchableCandidates = candidateNodes.filter((n) => (0, import_daemon_core5.isMeshNodeHealthLaunchable)(n));
+    const launchableCandidates = candidateNodes.filter((n) => (0, import_daemon_core6.isMeshNodeHealthLaunchable)(n));
     if (launchableCandidates.length === 0) {
-      const health = (0, import_daemon_core5.resolveEffectiveMeshNodeHealth)(candidateNodes[0]);
+      const health = (0, import_daemon_core6.resolveEffectiveMeshNodeHealth)(candidateNodes[0]);
       unhealthySlots.push({
         slotIndex,
         provider,
@@ -6231,7 +6844,7 @@ function buildMagiFanoutPlan(slots, nodes, opts = {}) {
       // Candidate pool was already narrowed to launch-ready nodes above, so an
       // included slot is health-launchable by construction.
       unhealthy: false,
-      health: (0, import_daemon_core5.resolveEffectiveMeshNodeHealth)(candidateNodes[0]),
+      health: (0, import_daemon_core6.resolveEffectiveMeshNodeHealth)(candidateNodes[0]),
       excluded: false
     };
     if (gitStale && !includeStale) {
@@ -6404,13 +7017,13 @@ function collectMagiCandidateTexts(payload) {
 }
 function replicaCompletionIsWeak(meshId, taskId) {
   try {
-    const entries = (0, import_daemon_core5.readLedgerEntries)(meshId, { kind: ["task_completed"], tail: 200 });
+    const entries = (0, import_daemon_core6.readLedgerEntries)(meshId, { kind: ["task_completed"], tail: 200 });
     for (let i = entries.length - 1; i >= 0; i -= 1) {
       const entry = entries[i];
       const payload = entry?.payload && typeof entry.payload === "object" ? entry.payload : void 0;
       const entryTaskId = readString(payload?.taskId) || readString(entry?.taskId);
       if (!entryTaskId || entryTaskId !== taskId) continue;
-      if ((0, import_daemon_core5.isWeakCompletionEvidence)(payload)) return true;
+      if ((0, import_daemon_core6.isWeakCompletionEvidence)(payload)) return true;
       const diag = payload?.completionDiagnostic;
       if (diag && typeof diag === "object" && !Array.isArray(diag) && readString(diag.reason) === "short_generating_suppressed") {
         return true;
@@ -6437,9 +7050,9 @@ async function meshMagiKindPanelSet(ctx, args) {
   const meshId = ctx.mesh.id;
   const scope = magiPanelScope(meshId, ctx.mesh.name);
   try {
-    const current = (0, import_daemon_core5.getMagiKindPanel)(kind, meshId) ?? [];
+    const current = (0, import_daemon_core6.getMagiKindPanel)(kind, meshId) ?? [];
     if (!write) {
-      const preview = (0, import_daemon_core5.normalizeMagiSlots)(args.slots, ctx.mesh.nodes.map((n) => n.id));
+      const preview = (0, import_daemon_core6.normalizeMagiSlots)(args.slots, ctx.mesh.nodes.map((n) => n.id));
       return JSON.stringify({
         success: true,
         dryRun: true,
@@ -6451,7 +7064,7 @@ async function meshMagiKindPanelSet(ctx, args) {
         note: `Dry-run only \u2014 no file written. This is a WHOLESALE replacement of the kind's slot list for mesh '${meshId}' (machine-local ~/.adhdev/meshes.json); the currentSlots would be fully replaced. Other meshes on this machine are unaffected. Re-run with write=true after explicit user approval.`
       }, null, 2);
     }
-    const slots = (0, import_daemon_core5.setMagiKindPanel)(kind, args.slots, meshId);
+    const slots = (0, import_daemon_core6.setMagiKindPanel)(kind, args.slots, meshId);
     return JSON.stringify({
       success: true,
       written: true,
@@ -6472,9 +7085,9 @@ async function meshMagiKindPanelList(ctx, args = {}) {
   const only = readString(args.task_kind) || readString(args.kind);
   const meshId = ctx.mesh.id;
   const scope = magiPanelScope(meshId, ctx.mesh.name);
-  const all = (0, import_daemon_core5.listMagiKindPanels)(meshId);
+  const all = (0, import_daemon_core6.listMagiKindPanels)(meshId);
   if (only) {
-    const slots = (0, import_daemon_core5.getMagiKindPanel)(only, meshId);
+    const slots = (0, import_daemon_core6.getMagiKindPanel)(only, meshId);
     if (slots === void 0) {
       return JSON.stringify({
         success: false,
@@ -6507,7 +7120,7 @@ async function meshMagiReview(ctx, args) {
   const referenceSubmoduleKey = resolveMagiReferenceSubmoduleKey(ctx);
   const taskKind = normalizeMagiTaskKind(explicitTaskKind);
   const panelName = `(kind:${taskKind})`;
-  const slots = (0, import_daemon_core5.getMagiKindPanel)(taskKind, ctx.mesh.id);
+  const slots = (0, import_daemon_core6.getMagiKindPanel)(taskKind, ctx.mesh.id);
   if (!slots || slots.length === 0) {
     return JSON.stringify({
       success: false,
@@ -6515,13 +7128,13 @@ async function meshMagiReview(ctx, args) {
       error: `No panel slots are configured for this task_kind in mesh '${ctx.mesh.id}' settings. Add at least one (machine + provider + model) slot in settings \u2014 task_kind '${taskKind}' has no configured kind-panel.`,
       taskKind,
       meshId: ctx.mesh.id,
-      configuredKinds: Object.keys((0, import_daemon_core5.listMagiKindPanels)(ctx.mesh.id)),
+      configuredKinds: Object.keys((0, import_daemon_core6.listMagiKindPanels)(ctx.mesh.id)),
       hint: "Configure this kind in mesh settings (MagiKindPanelEditor), or set it with mesh_magi_kind_panel_set, then retry."
     }, null, 2);
   }
   let planSlots;
   try {
-    planSlots = (0, import_daemon_core5.normalizeMagiSlots)(slots);
+    planSlots = (0, import_daemon_core6.normalizeMagiSlots)(slots);
   } catch (e) {
     return JSON.stringify({
       success: false,
@@ -6577,7 +7190,7 @@ async function meshMagiReview(ctx, args) {
   const waitTimeoutMs = Math.min(MAGI_MAX_WAIT_MS, Math.max(MAGI_POLL_INTERVAL_MS, Number(args.wait_timeout_ms ?? args.waitTimeoutMs) || MAGI_DEFAULT_WAIT_MS));
   const consensusGroupId = `magi_${(0, import_node_crypto.randomUUID)().replace(/-/g, "")}`;
   const titleQ = question.length > 80 ? `${question.slice(0, 77)}...` : question;
-  const mission = (0, import_daemon_core5.upsertMeshMission)(ctx.mesh.id, {
+  const mission = (0, import_daemon_core6.upsertMeshMission)(ctx.mesh.id, {
     title: `MAGI: ${titleQ}`,
     goal: `Cross-verify (read-only) across panel '${panelName}': ${question}${args.target ? `
 Target: ${args.target}` : ""}`,
@@ -6589,7 +7202,7 @@ Target: ${args.target}` : ""}`,
   const replicaRecords = [];
   for (const replica of plan.replicas) {
     try {
-      const task = (0, import_daemon_core5.enqueueTask)(ctx.mesh.id, prompt, {
+      const task = (0, import_daemon_core6.enqueueTask)(ctx.mesh.id, prompt, {
         readonly: true,
         taskMode: "live_debug_readonly",
         // DIFFICULTY-REQUIRED (MAGI decision): a fixed 'freeform' sentinel, NOT an
@@ -6618,7 +7231,7 @@ Target: ${args.target}` : ""}`,
       replicaRecords.push({ taskId: task.id, provider: replica.provider, targetNodeId: replica.targetNodeId, requiredTags: replica.requiredTags });
     } catch (e) {
       try {
-        (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+        (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
           kind: "magi_replica_enqueue_failed",
           payload: { consensusGroupId, missionId: mission.id, provider: replica.provider, error: e?.message || String(e) }
         });
@@ -6708,7 +7321,7 @@ Target: ${args.target}` : ""}`,
   });
   closeMagiMissionIfTerminal(ctx, mission.id, collected.terminal);
   const cleanupMode = resolveMagiAutoCleanupMode(ctx, args.auto_cleanup ?? args.autoCleanup);
-  const cleanupReplicaTasks = findMagiReplicaTasks((0, import_daemon_core5.getQueue)(ctx.mesh.id), consensusGroupId);
+  const cleanupReplicaTasks = findMagiReplicaTasks((0, import_daemon_core6.getQueue)(ctx.mesh.id), consensusGroupId);
   const cleanup = await cleanupMagiAutoLaunchedSessions(ctx, {
     replicaTasks: cleanupReplicaTasks,
     terminal: collected.terminal,
@@ -6738,7 +7351,7 @@ async function meshMagiCollect(ctx, args) {
   await refreshMeshFromDaemon(ctx);
   const explicitKind = args.task_kind ?? args.taskKind;
   const taskKind = explicitKind !== void 0 ? normalizeMagiTaskKind(explicitKind) : recoverMagiTaskKind(ctx, consensusGroupId);
-  const replicaTasks = findMagiReplicaTasks((0, import_daemon_core5.getQueue)(ctx.mesh.id), consensusGroupId);
+  const replicaTasks = findMagiReplicaTasks((0, import_daemon_core6.getQueue)(ctx.mesh.id), consensusGroupId);
   if (replicaTasks.length === 0) {
     return JSON.stringify({
       success: false,
@@ -6842,7 +7455,7 @@ function computeMagiCleanupTargets(replicaTasks) {
 function resolveMagiAutoCleanupMode(ctx, perCallOverride) {
   if (perCallOverride === true) return "stop_and_delete";
   if (perCallOverride === false) return "preserve";
-  return (0, import_daemon_core6.resolveMagiSessionCleanupMode)(ctx.mesh?.policy?.magiSessionCleanup);
+  return (0, import_daemon_core7.resolveMagiSessionCleanupMode)(ctx.mesh?.policy?.magiSessionCleanup);
 }
 async function cleanupMagiAutoLaunchedSessions(ctx, args) {
   if (args.mode === "preserve") return null;
@@ -6921,7 +7534,7 @@ function classifyStaleReplicas(annotatedTasks, terminal = MAGI_TERMINAL_STATUSES
 }
 function persistMagiDispatched(ctx, args) {
   try {
-    (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+    (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
       kind: "magi_dispatched",
       payload: {
         source: "magi",
@@ -6941,7 +7554,7 @@ function persistMagiDispatched(ctx, args) {
 }
 function recoverMagiTaskKind(ctx, consensusGroupId) {
   try {
-    const entries = (0, import_daemon_core5.readLedgerEntries)(ctx.mesh.id, { kind: ["magi_dispatched"], tail: 200 });
+    const entries = (0, import_daemon_core6.readLedgerEntries)(ctx.mesh.id, { kind: ["magi_dispatched"], tail: 200 });
     for (let i = entries.length - 1; i >= 0; i -= 1) {
       const payload = entries[i]?.payload;
       if (!payload || typeof payload !== "object") continue;
@@ -6965,7 +7578,7 @@ function stripRawAnswers(synthesis) {
 }
 function persistMagiSynthesis(ctx, args) {
   try {
-    (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+    (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
       kind: "magi_synthesis",
       payload: {
         source: "magi",
@@ -6985,9 +7598,9 @@ function closeMagiMissionIfTerminal(ctx, missionId, terminal) {
   const id = readString(missionId);
   if (!id) return;
   try {
-    const mission = (0, import_daemon_core5.getMeshMission)(ctx.mesh.id, id);
+    const mission = (0, import_daemon_core6.getMeshMission)(ctx.mesh.id, id);
     if (!mission || mission.status !== "active") return;
-    (0, import_daemon_core5.upsertMeshMission)(ctx.mesh.id, {
+    (0, import_daemon_core6.upsertMeshMission)(ctx.mesh.id, {
       id,
       title: mission.title,
       // Preserve goal: upsert defaults goal to the existing value when omitted.
@@ -7022,8 +7635,8 @@ async function collectMagiResponses(ctx, args) {
       const candidates = collectMagiCandidateTexts(payload);
       const raw = candidates.find((c) => c.trim().length > 0);
       if (!raw) return;
-      if (raw.length > import_daemon_core5.MAGI_RAW_ANSWER_CAP) {
-        source.rawAnswer = raw.slice(0, import_daemon_core5.MAGI_RAW_ANSWER_CAP);
+      if (raw.length > import_daemon_core6.MAGI_RAW_ANSWER_CAP) {
+        source.rawAnswer = raw.slice(0, import_daemon_core6.MAGI_RAW_ANSWER_CAP);
         source.rawAnswerTruncated = true;
       } else {
         source.rawAnswer = raw;
@@ -7033,7 +7646,7 @@ async function collectMagiResponses(ctx, args) {
   };
   const buildSource = (task) => {
     const sourceNodeId = task.assignedNodeId || task.targetNodeId || void 0;
-    const gitRef = extractNodeGitRef(sourceNodeId ? ctx.mesh.nodes.find((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, sourceNodeId)) : void 0);
+    const gitRef = extractNodeGitRef(sourceNodeId ? ctx.mesh.nodes.find((n) => (0, import_daemon_core6.meshNodeIdMatches)(n, sourceNodeId)) : void 0);
     return {
       taskId: task.id,
       nodeId: sourceNodeId,
@@ -7043,7 +7656,7 @@ async function collectMagiResponses(ctx, args) {
     };
   };
   const sendKindRetry = async (task, failReason) => {
-    const node = ctx.mesh.nodes.find((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, task.assignedNodeId));
+    const node = ctx.mesh.nodes.find((n) => (0, import_daemon_core6.meshNodeIdMatches)(n, task.assignedNodeId));
     if (!node || !task.assignedSessionId) return false;
     const why = failReason === "empty_evidence" ? "your previous answer had an empty evidence array" : failReason === "missing_required_fields" ? "your previous answer was missing required fields" : "your previous answer did not parse as the required JSON";
     const message = `Your previous MAGI answer could not be accepted (${why}). Respond NOW with ONLY a single JSON object (no prose, no code fence) matching EXACTLY this schema, with non-empty evidence:
@@ -7069,7 +7682,7 @@ ${magiOutputContractFor(kind)}`;
         }
       });
       try {
-        (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+        (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
           kind: "magi_replica_retry",
           payload: { taskId: task.id, kind, failReason }
         });
@@ -7081,7 +7694,7 @@ ${magiOutputContractFor(kind)}`;
     }
   };
   const nudgeWedgedReplica = async (task) => {
-    const node = ctx.mesh.nodes.find((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, task.assignedNodeId));
+    const node = ctx.mesh.nodes.find((n) => (0, import_daemon_core6.meshNodeIdMatches)(n, task.assignedNodeId));
     if (!node || !task.assignedSessionId) return;
     try {
       const read = await commandForNode(ctx, node, "read_chat", {
@@ -7103,7 +7716,7 @@ ${magiOutputContractFor(kind)}`;
         action: "approve"
       });
       try {
-        (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+        (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
           kind: "magi_replica_auto_approved",
           payload: { taskId: task.id, nodeId: task.assignedNodeId, status }
         });
@@ -7147,7 +7760,7 @@ ${magiOutputContractFor(kind)}`;
     }
     let kindResult;
     try {
-      const node = ctx.mesh.nodes.find((n) => (0, import_daemon_core5.meshNodeIdMatches)(n, task.assignedNodeId));
+      const node = ctx.mesh.nodes.find((n) => (0, import_daemon_core6.meshNodeIdMatches)(n, task.assignedNodeId));
       if (!node) throw new Error("assigned node not in mesh");
       const result = await commandForNode(ctx, node, "read_chat", {
         sessionId: task.assignedSessionId,
@@ -7200,7 +7813,7 @@ ${magiOutputContractFor(kind)}`;
     return false;
   };
   for (; ; ) {
-    const tasks = annotateQueueStaleness((0, import_daemon_core5.getQueue)(ctx.mesh.id).filter((t) => ids.has(t.id)), ctx.mesh);
+    const tasks = annotateQueueStaleness((0, import_daemon_core6.getQueue)(ctx.mesh.id).filter((t) => ids.has(t.id)), ctx.mesh);
     const allPresent = tasks.length === ids.size;
     const { staleTaskIds: staleTaskIds2, staleReasons: staleReasons2 } = classifyStaleReplicas(tasks, TERMINAL);
     const pastDeadline = Date.now() >= deadline;
@@ -7214,7 +7827,7 @@ ${magiOutputContractFor(kind)}`;
     if (allPresent && outstanding.length > 0 && outstanding.every((t) => staleTaskIds2.has(t.id))) break;
     await sleep(Math.min(MAGI_POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
   }
-  const finalTasks = annotateQueueStaleness((0, import_daemon_core5.getQueue)(ctx.mesh.id).filter((t) => ids.has(t.id)), ctx.mesh);
+  const finalTasks = annotateQueueStaleness((0, import_daemon_core6.getQueue)(ctx.mesh.id).filter((t) => ids.has(t.id)), ctx.mesh);
   const { staleTaskIds, staleReasons } = classifyStaleReplicas(finalTasks, TERMINAL);
   const presentIds = new Set(finalTasks.map((t) => t.id));
   for (const task of finalTasks) {
@@ -7409,7 +8022,7 @@ async function meshNodeSlotsPropose(ctx, args = {}) {
 }
 
 // src/tools/mesh-tools-session.ts
-var import_daemon_core7 = require("@adhdev/daemon-core");
+var import_daemon_core8 = require("@adhdev/daemon-core");
 function computeIdleDispatchAckRisk(sessionWasIdle, dispatchPreRecorded, sessionId) {
   if (!sessionWasIdle || dispatchPreRecorded) return {};
   return {
@@ -7423,11 +8036,11 @@ async function meshPruneStaleDirect(ctx, args = {}) {
   const execute = args.execute === true && args.dry_run !== true;
   const includeTerminal = args.include_terminal === true;
   const liveNodes = await collectMeshViewQueueNodesWithLiveSessions(ctx);
-  const ledgerEntries = (0, import_daemon_core5.readLedgerEntries)(ctx.mesh.id, { tail: 500 });
-  const directDispatches = (0, import_daemon_core5.getActiveDirectDispatches)(ctx.mesh.id);
-  const result = (0, import_daemon_core5.pruneStaleDirectDispatches)({
+  const ledgerEntries = (0, import_daemon_core6.readLedgerEntries)(ctx.mesh.id, { tail: 500 });
+  const directDispatches = (0, import_daemon_core6.getActiveDirectDispatches)(ctx.mesh.id);
+  const result = (0, import_daemon_core6.pruneStaleDirectDispatches)({
     meshId: ctx.mesh.id,
-    queue: (0, import_daemon_core5.getQueue)(ctx.mesh.id),
+    queue: (0, import_daemon_core6.getQueue)(ctx.mesh.id),
     ledgerEntries,
     directDispatches,
     nodes: liveNodes,
@@ -7478,7 +8091,7 @@ async function meshSendTask(ctx, args) {
   const requestedTaskMode = readString(args.task_mode) || readString(args.taskMode);
   const readonly = args.readonly === true || args.read_only === true;
   const missionId = readString(args.missionId) || readString(args.mission_id) || void 0;
-  if (missionId && !(0, import_daemon_core5.getMeshMission)(ctx.mesh.id, missionId)) {
+  if (missionId && !(0, import_daemon_core6.getMeshMission)(ctx.mesh.id, missionId)) {
     return JSON.stringify({
       success: false,
       code: "mission_not_found",
@@ -7496,7 +8109,7 @@ async function meshSendTask(ctx, args) {
     });
   }
   const difficulty = difficultyRaw;
-  const modeValidation = (0, import_daemon_core5.validateMeshTaskModeRequest)(requestedTaskMode, message, readonly);
+  const modeValidation = (0, import_daemon_core6.validateMeshTaskModeRequest)(requestedTaskMode, message, readonly);
   if (!modeValidation.valid) {
     return JSON.stringify({
       success: false,
@@ -7507,7 +8120,7 @@ async function meshSendTask(ctx, args) {
       // can see what tripped the guard instead of rewording blind.
       ...modeValidation.violationDetails ? { violationDetails: modeValidation.violationDetails } : {},
       allowedOperations: modeValidation.allowedOperations,
-      error: (0, import_daemon_core5.buildMeshTaskModeViolationError)(modeValidation)
+      error: (0, import_daemon_core6.buildMeshTaskModeViolationError)(modeValidation)
     });
   }
   const taskMode = modeValidation.taskMode;
@@ -7611,7 +8224,7 @@ async function meshSendTask(ctx, args) {
         const dispatchedAt = (/* @__PURE__ */ new Date()).toISOString();
         try {
           const providerType = result2.providerType || cached?.providerType;
-          (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+          (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
             kind: "task_dispatched",
             nodeId: args.node_id,
             sessionId: dispatchedSessionId,
@@ -7629,7 +8242,7 @@ async function meshSendTask(ctx, args) {
               ...coordinatorDaemonId ? { coordinatorDaemonId } : {}
             })
           });
-          (0, import_daemon_core5.insertDirectDispatch)(ctx.mesh.id, {
+          (0, import_daemon_core6.insertDirectDispatch)(ctx.mesh.id, {
             taskId,
             nodeId: args.node_id,
             sessionId: dispatchedSessionId,
@@ -7639,7 +8252,7 @@ async function meshSendTask(ctx, args) {
             via: "p2p_direct",
             dispatchedAt
           });
-          (0, import_daemon_core5.recordDirectDispatchTask)(ctx.mesh.id, message, {
+          (0, import_daemon_core6.recordDirectDispatchTask)(ctx.mesh.id, message, {
             id: taskId,
             ...missionId ? { missionId } : {},
             assignedNodeId: args.node_id,
@@ -7744,7 +8357,7 @@ async function meshSendTask(ctx, args) {
         const { resolveDeliveryDecision } = await import("@adhdev/daemon-core");
         const policyResult = resolveDeliveryDecision(sessionStatus, { kind: "task" });
         if (policyResult.decision === "queued") {
-          const queuedTask = (0, import_daemon_core5.enqueueTask)(ctx.mesh.id, message, {
+          const queuedTask = (0, import_daemon_core6.enqueueTask)(ctx.mesh.id, message, {
             targetNodeId: args.node_id,
             targetSessionId: args.session_id,
             taskMode,
@@ -7774,7 +8387,7 @@ async function meshSendTask(ctx, args) {
       const dispatchedAt = (/* @__PURE__ */ new Date()).toISOString();
       const coordinatorDaemonId = resolveCoordinatorDaemonId(ctx);
       try {
-        (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+        (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
           kind: "task_dispatched",
           nodeId: args.node_id,
           sessionId: args.session_id,
@@ -7795,7 +8408,7 @@ async function meshSendTask(ctx, args) {
         });
       } catch {
       }
-      (0, import_daemon_core5.insertDirectDispatch)(ctx.mesh.id, {
+      (0, import_daemon_core6.insertDirectDispatch)(ctx.mesh.id, {
         taskId,
         nodeId: args.node_id,
         sessionId: args.session_id,
@@ -7808,7 +8421,7 @@ async function meshSendTask(ctx, args) {
       });
       let dispatchPreRecorded = false;
       try {
-        dispatchPreRecorded = (0, import_daemon_core5.getActiveDirectDispatches)(ctx.mesh.id).some((d) => d.taskId === taskId);
+        dispatchPreRecorded = (0, import_daemon_core6.getActiveDirectDispatches)(ctx.mesh.id).some((d) => d.taskId === taskId);
       } catch {
       }
       const dispatchResult = await commandForNode(ctx, node, "agent_command", {
@@ -7832,7 +8445,7 @@ async function meshSendTask(ctx, args) {
       const dispatchPayload = unwrapCommandPayload(dispatchResult);
       if (dispatchPayload?.success === false || dispatchResult?.success === false) {
         try {
-          (0, import_daemon_core5.deleteDirectDispatchesByTaskId)(ctx.mesh.id, [taskId]);
+          (0, import_daemon_core6.deleteDirectDispatchesByTaskId)(ctx.mesh.id, [taskId]);
         } catch {
         }
         dispatchPreRecorded = false;
@@ -7846,7 +8459,7 @@ async function meshSendTask(ctx, args) {
         });
       }
       try {
-        (0, import_daemon_core5.recordDirectDispatchTask)(ctx.mesh.id, message, {
+        (0, import_daemon_core6.recordDirectDispatchTask)(ctx.mesh.id, message, {
           id: taskId,
           ...missionId ? { missionId } : {},
           assignedNodeId: args.node_id,
@@ -7892,7 +8505,7 @@ async function meshSendTask(ctx, args) {
         ...buildMissionInactiveWarning(ctx, missionId) ?? {}
       });
     }
-    const task = (0, import_daemon_core5.enqueueTask)(ctx.mesh.id, message, {
+    const task = (0, import_daemon_core6.enqueueTask)(ctx.mesh.id, message, {
       targetNodeId: args.node_id,
       targetSessionId: args.session_id,
       taskMode,
@@ -7902,7 +8515,7 @@ async function meshSendTask(ctx, args) {
       ...ctx.coordinatorSessionId ? { sourceCoordinatorSessionId: ctx.coordinatorSessionId } : {}
     });
     const queueTrigger = await triggerMeshQueueAndReport(ctx);
-    const pendingEvents = (0, import_daemon_core5.drainPendingMeshCoordinatorEvents)(ctx.mesh.id, ctx.localDaemonId);
+    const pendingEvents = (0, import_daemon_core6.drainPendingMeshCoordinatorEvents)(ctx.mesh.id, ctx.localDaemonId);
     const result = {
       success: true,
       source: "queue",
@@ -7948,7 +8561,7 @@ async function meshReadChat(ctx, args) {
       tailLimit: args.tail ?? 10
     });
   } catch (e) {
-    if (isLocalNode || !(0, import_daemon_core5.isP2pRelayTransportFailure)(e)) throw e;
+    if (isLocalNode || !(0, import_daemon_core6.isP2pRelayTransportFailure)(e)) throw e;
     return buildMeshReadChatCacheFallback(ctx, args, node, e);
   }
   const payload = annotateRapidReadChatAdvisory(unwrapCommandPayload(result), {
@@ -8037,7 +8650,7 @@ async function meshSendKeys(ctx, args) {
   const auditKeys = requestedKeys.slice(0, 64);
   const recordAudit = (result2, extra = {}) => {
     try {
-      (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+      (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
         kind: "key_injection",
         nodeId: args.node_id,
         sessionId: args.session_id,
@@ -8054,7 +8667,7 @@ async function meshSendKeys(ctx, args) {
     }
   };
   if (hasDestructive) {
-    const policyAllows = (0, import_daemon_core5.resolveAllowSendKeysDestructive)(ctx.mesh.policy, node.policy);
+    const policyAllows = (0, import_daemon_core6.resolveAllowSendKeysDestructive)(ctx.mesh.policy, node.policy);
     if (args.confirm_destructive !== true || !policyAllows) {
       recordAudit("refused", { refused: "destructive_gate", policyAllows });
       return JSON.stringify({
@@ -8104,7 +8717,7 @@ async function meshLaunchSession(ctx, args) {
           supportedProviders: slotProviders
         }, null, 2);
       }
-      const explicitBlock = (0, import_daemon_core7.evaluateProviderQuotaGate)(node, requestedType, ctx.mesh.policy?.quotaRouting ?? null);
+      const explicitBlock = (0, import_daemon_core8.evaluateProviderQuotaGate)(node, requestedType, ctx.mesh.policy?.quotaRouting ?? null);
       if (explicitBlock) {
         explicitTypeQuotaWarning = {
           quotaWarning: `Provider '${requestedType}' on node '${args.node_id}' is quota-gated (${explicitBlock.reason}; ${explicitBlock.window} window at ${explicitBlock.remainingPercent}% remaining, threshold ${explicitBlock.thresholdPercent}%). Launching anyway because the type was requested explicitly \u2014 the session may fail immediately if the provider rejects on quota.`,
@@ -8142,7 +8755,7 @@ async function meshLaunchSession(ctx, args) {
         failed.push(`${providerType}: ${detectedPayload?.error || "not detected"}`);
       }
       if (detectedCandidates.length) {
-        const ranked = (0, import_daemon_core7.rankProvidersByQuotaGate)(node, detectedCandidates, ctx.mesh.policy?.quotaRouting ?? null);
+        const ranked = (0, import_daemon_core8.rankProvidersByQuotaGate)(node, detectedCandidates, ctx.mesh.policy?.quotaRouting ?? null);
         if (ranked.clear.length) {
           resolvedProviderType = ranked.clear[0];
         } else {
@@ -8173,14 +8786,14 @@ async function meshLaunchSession(ctx, args) {
     const coordinatorNode = resolveCoordinatorNode(ctx);
     const coordinatorDaemonId = resolveCoordinatorDaemonId(ctx);
     const spawnedSessionVisibility = readSpawnedSessionVisibility(ctx.mesh.policy);
-    const delegatedWorkerAutoApprove = (0, import_daemon_core5.resolveDelegatedWorkerAutoApprove)(ctx.mesh.policy, node.policy);
+    const delegatedWorkerAutoApprove = (0, import_daemon_core6.resolveDelegatedWorkerAutoApprove)(ctx.mesh.policy, node.policy);
     let requestedAutoApproveMode;
-    const delegatedWorkerDangerousModeAllow = (0, import_daemon_core5.resolveDelegatedWorkerDangerousModeAllow)(ctx.mesh.policy, node.policy);
+    const delegatedWorkerDangerousModeAllow = (0, import_daemon_core6.resolveDelegatedWorkerDangerousModeAllow)(ctx.mesh.policy, node.policy);
     if (delegatedWorkerAutoApprove !== false) {
       try {
         const ws = typeof node.workspace === "string" && node.workspace.trim() ? node.workspace.trim() : "";
         if (ws) {
-          const repo = (0, import_daemon_core5.loadRepoMeshJsonConfig)(ws);
+          const repo = (0, import_daemon_core6.loadRepoMeshJsonConfig)(ws);
           const repoMode = repo.sourceType === "repo_file" ? repo.config?.providerDefaults?.autoApproveModes?.[resolvedProviderType] : void 0;
           if (typeof repoMode === "string" && repoMode.trim()) requestedAutoApproveMode = repoMode.trim();
         }
@@ -8277,7 +8890,7 @@ async function meshLaunchSession(ctx, args) {
       });
     }
     try {
-      (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+      (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
         kind: "session_launched",
         nodeId: args.node_id,
         sessionId: runtimeSessionId || void 0,
@@ -8331,26 +8944,26 @@ async function meshAnswerQuestion(ctx, args) {
   return JSON.stringify(result, null, 2);
 }
 async function meshListPendingApprovals(ctx, _args = {}) {
-  (0, import_daemon_core5.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_list_pending_approvals" });
+  (0, import_daemon_core6.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_list_pending_approvals" });
   await refreshMeshFromDaemon(ctx);
   const liveNodes = await collectMeshViewQueueNodesWithLiveSessions(ctx);
-  let ledgerEntries = (0, import_daemon_core5.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
-  let directDispatches = (0, import_daemon_core5.getActiveDirectDispatches)(ctx.mesh.id);
+  let ledgerEntries = (0, import_daemon_core6.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
+  let directDispatches = (0, import_daemon_core6.getActiveDirectDispatches)(ctx.mesh.id);
   const directReconciliation = await reconcileDirectDispatchesFromTranscriptEvidence(ctx, liveNodes, directDispatches, ledgerEntries);
   if (directReconciliation.reconciled > 0) {
-    ledgerEntries = (0, import_daemon_core5.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
-    directDispatches = (0, import_daemon_core5.getActiveDirectDispatches)(ctx.mesh.id);
+    ledgerEntries = (0, import_daemon_core6.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
+    directDispatches = (0, import_daemon_core6.getActiveDirectDispatches)(ctx.mesh.id);
   }
-  (0, import_daemon_core5.markStaleDirectDispatches)(ctx.mesh.id);
-  directDispatches = (0, import_daemon_core5.getActiveDirectDispatches)(ctx.mesh.id);
-  const activeWorkEvidence = (0, import_daemon_core5.buildMeshActiveWork)({
+  (0, import_daemon_core6.markStaleDirectDispatches)(ctx.mesh.id);
+  directDispatches = (0, import_daemon_core6.getActiveDirectDispatches)(ctx.mesh.id);
+  const activeWorkEvidence = (0, import_daemon_core6.buildMeshActiveWork)({
     meshId: ctx.mesh.id,
-    queue: (0, import_daemon_core5.getQueue)(ctx.mesh.id),
+    queue: (0, import_daemon_core6.getQueue)(ctx.mesh.id),
     ledgerEntries,
     directDispatches,
     nodes: liveNodes
   });
-  const approvals = (0, import_daemon_core5.collectPendingApprovals)(activeWorkEvidence.activeWork);
+  const approvals = (0, import_daemon_core6.collectPendingApprovals)(activeWorkEvidence.activeWork);
   return JSON.stringify({
     count: approvals.length,
     approvals,
@@ -8504,7 +9117,7 @@ async function meshRestartDaemon(ctx, args) {
     const targetDaemonId = typeof rawTarget.daemonId === "string" && rawTarget.daemonId.trim() ? rawTarget.daemonId.trim() : "unknown";
     const targetNpmTag = typeof rawTarget.npmTag === "string" && rawTarget.npmTag.trim() ? rawTarget.npmTag.trim() : typeof payload?.npmTag === "string" && payload.npmTag.trim() ? payload.npmTag.trim() : "unknown";
     const trackMismatch = meshAttachedTrack === "unknown" || targetTrack === "unknown" ? null : meshAttachedTrack !== targetTrack;
-    const daemonMismatch = meshAttachedDaemonId === "unknown" || targetDaemonId === "unknown" ? null : !(0, import_daemon_core5.daemonIdsEquivalent)(meshAttachedDaemonId, targetDaemonId);
+    const daemonMismatch = meshAttachedDaemonId === "unknown" || targetDaemonId === "unknown" ? null : !(0, import_daemon_core6.daemonIdsEquivalent)(meshAttachedDaemonId, targetDaemonId);
     const routingMismatch = trackMismatch === true || daemonMismatch === true;
     return JSON.stringify({
       ...payload,
@@ -8558,7 +9171,7 @@ async function meshCheckpoint(ctx, args) {
     includeUntracked: true
   });
   try {
-    (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+    (0, import_daemon_core6.appendLedgerEntry)(ctx.mesh.id, {
       kind: "checkpoint_created",
       nodeId: args.node_id,
       payload: {
@@ -10256,6 +10869,15 @@ async function startMcpServer(opts) {
           case "mesh_view_queue":
             text = await meshViewQueue(meshCtx, a);
             break;
+          case "mesh_graph_view":
+            text = await meshGraphView(meshCtx, a);
+            break;
+          case "mesh_graph_gate_claim":
+            text = await meshGraphGateClaim(meshCtx, a);
+            break;
+          case "mesh_graph_gate_release":
+            text = await meshGraphGateRelease(meshCtx, a);
+            break;
           case "mesh_queue_cancel":
             text = await meshQueueCancel(meshCtx, a);
             break;