npm - @adhdev/daemon-standalone - Versions diffs - 1.0.49-rc.11 → 1.0.49-rc.13 - Mend

@adhdev/daemon-standalone 1.0.49-rc.11 → 1.0.49-rc.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/index.js +2740 -1922
package/dist/index.js.map +1 -1
package/package.json +2 -2
package/public/assets/index-B3OjPHzk.css +1 -0
package/public/assets/index-QzpIT-yd.js +119 -0
package/public/index.html +2 -2
package/vendor/mcp-server/index.js +401 -78
package/vendor/mcp-server/index.js.map +1 -1
package/public/assets/index-BeC2kIKA.js +0 -116
package/public/assets/index-CqyS0XiL.css +0 -1

package/public/index.html CHANGED Viewed

@@ -7,9 +7,9 @@
     <meta name="description" content="ADHDev self-hosted dashboard for controlling AI agents" />
     <link rel="icon" href="/otter-logo.png" />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap" rel="stylesheet" />
-  <script type="module" crossorigin src="/assets/index-BeC2kIKA.js"></script>
+  <script type="module" crossorigin src="/assets/index-QzpIT-yd.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-DgFmqOGd.js">
-  <link rel="stylesheet" crossorigin href="/assets/index-CqyS0XiL.css">
+  <link rel="stylesheet" crossorigin href="/assets/index-B3OjPHzk.css">
 </head>
 <body>
     <!-- Apply theme immediately to prevent FOIT (Flash of Incorrect Theme) -->

package/vendor/mcp-server/index.js CHANGED Viewed

@@ -575,6 +575,7 @@ var CANONICAL_MESH_TOOL_NAMES = [
   "mesh_status",
   "mesh_list_nodes",
   "mesh_enqueue_task",
+  "mesh_enqueue_batch",
   "mesh_view_queue",
   "mesh_queue_cancel",
   "mesh_queue_requeue",
@@ -949,7 +950,7 @@ function isLocalControlPlaneNode(ctx, node) {
 // src/tools/mesh-tool-schemas.ts
 var MESH_STATUS_TOOL = {
   name: "mesh_status",
-  description: `Get the current status of all nodes in the repo mesh \u2014 health, git state, active sessions, recovery hints, and recommended next steps. Use this to decide which node to send work to or how to recover from failures. Also reports the running daemon build per daemonId under top-level daemonBuilds ({commit, commitShort, version}); when a live daemon was built from a commit BEHIND its workspace HEAD it adds staleDaemonBuilds[] + staleDaemonBuildWarning \u2014 meaning a just-merged refinery/mesh-tool fix is NOT yet live on that daemon (awaiting deploy/restart; a local dist rebuild does not update a cloud daemon). When a daemon has a durable failed-upgrade notice on record it adds daemonUpgradeFailures{daemonId \u2192 {summary, recordedAt, ageLabel, targetVersion, noticePath, logPath}} + daemonUpgradeFailureWarning \u2014 meaning that daemon's LAST upgrade attempt failed and was rolled back, so it is still on the PREVIOUS version (an upgrade/restart response only ever reports "scheduled", never success). Do not repeatedly call this to wait for generating delegated work; wait for pendingCoordinatorEvents/completion events or an explicit user status request.`,
+  description: `Get the current status of all nodes in the repo mesh \u2014 health, git state, active sessions, recovery hints, and recommended next steps. Use this to decide which node to send work to or how to recover from failures. Also reports the running daemon build per daemonId under top-level daemonBuilds ({commit, commitShort, version, track}); track is stable/preview when explicitly reported by that daemon and unknown for legacy peers \u2014 it is never inferred from an rc version suffix. When a live daemon was built from a commit BEHIND its workspace HEAD it adds staleDaemonBuilds[] + staleDaemonBuildWarning \u2014 meaning a just-merged refinery/mesh-tool fix is NOT yet live on that daemon (awaiting deploy/restart; a local dist rebuild does not update a cloud daemon). When a daemon has a durable failed-upgrade notice on record it adds daemonUpgradeFailures{daemonId \u2192 {summary, recordedAt, ageLabel, targetVersion, noticePath, logPath}} + daemonUpgradeFailureWarning \u2014 meaning that daemon's LAST upgrade attempt failed and was rolled back, so it is still on the PREVIOUS version (an upgrade/restart response only ever reports "scheduled", never success). Do not repeatedly call this to wait for generating delegated work; wait for pendingCoordinatorEvents/completion events or an explicit user status request.`,
   inputSchema: {
     type: "object",
     properties: {
@@ -974,7 +975,7 @@ var MESH_LIST_NODES_TOOL = {
 };
 var MESH_ENQUEUE_TASK_TOOL = {
   name: "mesh_enqueue_task",
-  description: "Add a new task to the mesh work queue. Idle nodes will automatically pull and execute tasks from this queue. Use this instead of mesh_send_task when you do not need to target a specific node. Supports task-level priority (high tasks are pulled ahead of older normal/low tasks), not_before delayed execution (hold a task pending until a time), maxRetries (auto-fail after N requeues), and duplicate detection (by default warns in the response when an in-flight task with the same message+target already exists; pass block_duplicate=true to refuse instead, or allow_duplicate=true to silence the warning).",
+  description: "Add a new task to the mesh work queue. Idle nodes will automatically pull and execute tasks from this queue. Use this instead of mesh_send_task when you do not need to target a specific node. For a dependency-wired MULTI-task graph prefer mesh_enqueue_batch: it inserts the whole set atomically and lets depends_on reference batch-local refs, so no half-registered chain can be left behind. Supports task-level priority (high tasks are pulled ahead of older normal/low tasks), not_before delayed execution (hold a task pending until a time), maxRetries (auto-fail after N requeues), and duplicate detection (by default warns in the response when an in-flight task with the same message+target already exists; pass block_duplicate=true to refuse instead, or allow_duplicate=true to silence the warning).",
   inputSchema: {
     type: "object",
     properties: {
@@ -1010,6 +1011,56 @@ var MESH_ENQUEUE_TASK_TOOL = {
     required: ["message", "difficulty"]
   }
 };
+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.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      tasks: {
+        type: "array",
+        description: "The tasks to enqueue atomically (max 50). Each entry accepts the same fields as mesh_enqueue_task, plus an optional batch-local `ref`.",
+        items: {
+          type: "object",
+          properties: {
+            ref: { type: "string", description: `Batch-local label other entries' depends_on may name (e.g. "investigate", "fix", "verify"). Never persisted \u2014 resolved to the generated task id at insert.` },
+            message: { type: "string", description: "The task instruction for the agent." },
+            task_mode: { type: "string", enum: ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"], description: "Optional task-mode contract (same semantics as mesh_enqueue_task)." },
+            taskMode: { type: "string", enum: ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"], description: "CamelCase alias for task_mode." },
+            readonly: { type: "boolean", description: "Optional read-only axis (orthogonal to task_mode); same semantics as mesh_enqueue_task." },
+            read_only: { type: "boolean", description: "Snake-case alias for readonly." },
+            requiredTags: { type: "array", items: { type: "string" }, description: "Optional capability tags every eligible node must have, e.g. os=darwin, provider=codex-cli, worktree=<branch>." },
+            required_tags: { type: "array", items: { type: "string" }, description: "Snake_case alias for requiredTags." },
+            target_node_id: { type: "string", description: "Optional HARD pin: only this node may claim the task. An unresolvable id rejects the WHOLE batch (atomic)." },
+            targetNodeId: { type: "string", description: "CamelCase alias for target_node_id." },
+            prefer_worktree: { type: "boolean", description: "Route to the most recently cloned idle worktree node (no-op when none exists)." },
+            preferWorktree: { type: "boolean", description: "CamelCase alias for prefer_worktree." },
+            depends_on: { type: "array", items: { type: "string" }, description: "Refs of sibling entries in THIS batch (forward references allowed) and/or EXISTING queue task ids that must complete before this task becomes claimable. Cycles and unknown values reject the whole batch." },
+            dependsOn: { type: "array", items: { type: "string" }, description: "CamelCase alias for depends_on." },
+            mission_id: { type: "string", description: "Per-task mission override; defaults to the top-level mission_id." },
+            missionId: { type: "string", description: "CamelCase alias for mission_id." },
+            priority: { type: "string", enum: ["low", "normal", "high"], description: "G6 task-level scheduling priority (same semantics as mesh_enqueue_task)." },
+            model: { type: "string", description: "Optional model override for the agent that runs this task (best-effort at launch)." },
+            thinkingLevel: { type: "string", enum: ["low", "medium", "high"], description: "Optional reasoning-effort level (best-effort at launch)." },
+            difficulty: { type: "string", enum: ["easy", "medium", "difficult", "freeform"], description: "REQUIRED per task \u2014 routing hint matched against node capability slots (same semantics as mesh_enqueue_task)." },
+            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." }
+          },
+          required: ["message", "difficulty"]
+        }
+      },
+      mission_id: { type: "string", description: "Mission every task in this batch belongs to unless an entry overrides it. For multi-task work, create the mission first (mesh_mission_upsert) and pass it here." },
+      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." }
+    },
+    required: ["tasks"]
+  }
+};
 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.",
@@ -1206,7 +1257,7 @@ var MESH_FAST_FORWARD_NODE_TOOL = {
 };
 var MESH_RESTART_DAEMON_TOOL = {
   name: "mesh_restart_daemon",
-  description: `Restart a mesh node's daemon, optionally updating it first \u2014 the same path as the dashboard "preview update" button, exposed as a mesh command so a coordinator can roll a worker daemon without a manual restart round-trip. No agent session is launched. mode="upgrade" (default): update to the latest published version on the release channel, then restart; already-latest is a no-op (no restart, returns alreadyLatest:true). mode="restart": pure re-spawn with no reinstall \u2014 restarts even when already latest, with much shorter downtime; use it to reset wedged daemon state (memory leaks, zombie sessions). Idle-gated: a node whose daemon has an active session (generating / waiting_approval / starting) is refused with code "blocking_sessions" so an in-flight turn is never interrupted. self_only=true waives ONLY this mesh's own coordinator session (the structural self-deadlock case \u2014 the coordinator is always generating while it calls). Other sessions still refuse. force=true bypasses the gate entirely: in-flight turns die and the unpersisted pendingOutboundQueue is lost. when_idle=true schedules the restart to run automatically once the daemon goes idle (the safest path \u2014 no queue loss); cancel_when_idle=true cancels it and every response reports the schedule under deferredRestart. kill_session_host=true additionally stops the session-host process, destroying ALL hosted CLI sessions (hard refresh; this is what Windows already does on every upgrade). Default off. Note: on Windows any daemon restart/upgrade terminates all hosted sessions regardless of options; on POSIX hosted sessions survive a plain restart and rebind on next boot. Upgrade mode refuses a DOWNGRADE: if the target version resolved from the daemon's build track is OLDER than the running daemon, the call fails with code "downgrade_refused" and reports currentVersion / targetVersion / channel instead of rolling the node back. Pass allow_downgrade=true only for a deliberate rollback. The channel parameter is DEPRECATED and ignored: since Phase 3 the release channel is a build-time identity of the installed binary (stable = adhdev/@latest, preview = adhdev-preview/@next), so an upgrade always targets the daemon's own build track and can never switch channels. When you pass a channel that conflicts with the node's build track, the response now carries a channelOverride object saying so \u2014 the request is not silently honored.`,
+  description: `Restart a mesh node's daemon, optionally updating it first \u2014 the same path as the dashboard "preview update" button, exposed as a mesh command so a coordinator can roll a worker daemon without a manual restart round-trip. No agent session is launched. mode="upgrade" (default): update to the latest published version on the release channel, then restart; already-latest is a no-op (no restart, returns alreadyLatest:true). mode="restart": pure re-spawn with no reinstall \u2014 restarts even when already latest, with much shorter downtime; use it to reset wedged daemon state (memory leaks, zombie sessions). Idle-gated: a node whose daemon has an active session (generating / waiting_approval / starting) is refused with code "blocking_sessions" so an in-flight turn is never interrupted. self_only=true waives ONLY this mesh's own coordinator session (the structural self-deadlock case \u2014 the coordinator is always generating while it calls). Other sessions still refuse. force=true bypasses the gate entirely: in-flight turns die and the unpersisted pendingOutboundQueue is lost. when_idle=true schedules the restart to run automatically once the daemon goes idle (the safest path \u2014 no queue loss); cancel_when_idle=true cancels it and every response reports the schedule under deferredRestart. kill_session_host=true additionally stops the session-host process, destroying ALL hosted CLI sessions (hard refresh; this is what Windows already does on every upgrade). Default off. Note: on Windows any daemon restart/upgrade terminates all hosted sessions regardless of options; on POSIX hosted sessions survive a plain restart and rebind on next boot. Upgrade mode refuses a DOWNGRADE: if the target version resolved from the daemon's build track is OLDER than the running daemon, the call fails with code "downgrade_refused" and reports currentVersion / targetVersion / channel instead of rolling the node back. Pass allow_downgrade=true only for a deliberate rollback. The channel parameter is DEPRECATED and ignored: since Phase 3 the release channel is a build-time identity of the installed binary (stable = adhdev/@latest, preview = adhdev-preview/@next), so an upgrade always targets the daemon's own build track and can never switch channels. When you pass a channel that conflicts with the node's build track, the response now carries a channelOverride object saying so \u2014 the request is not silently honored. The response compares meshAttachedDaemon (the daemon that answered status immediately before the command) with restartTargetDaemon (the daemon process that accepted the lifecycle operation). daemonMismatch/trackMismatch=true and trackWarning surface a split but do not block the operation; null means an older/unreachable daemon did not report enough identity.`,
   inputSchema: {
     type: "object",
     properties: {
@@ -1567,7 +1618,7 @@ var MESH_PRUNE_STALE_DIRECT_TOOL = {
 };
 var MESH_REFINE_NODE_TOOL = {
   name: "mesh_refine_node",
-  description: "The Refinery: validate \u2192 merge \u2192 push \u2192 clean up a completed worktree node onto the base branch. Defaults to dry-run (plan only): returns the validation plan with mergeWillRun:false/cleanupWillRun:false and performs NO merge/push/cleanup. Pass execute=true to actually converge the node. execute=true is async: the immediate response includes async:true, status:'accepted', jobId, interactionId, target node, and startedAt; completion/failure evidence is delivered through pending mesh events and the mesh task ledger. dry_run=true overrides execute. Matches the mesh_refine_batch / mesh_fast_forward_node dry_run/execute contract.",
+  description: "The Refinery: validate \u2192 merge \u2192 push \u2192 clean up a completed worktree node onto the base branch. Defaults to dry-run (plan only): returns the validation plan with mergeWillRun:false/cleanupWillRun:false and performs NO merge/push/cleanup. Pass execute=true to actually converge the node. execute=true is async: the immediate response includes async:true, status:'accepted', jobId, interactionId, target node, and startedAt; completion/failure evidence is delivered through pending mesh events and the mesh task ledger. dry_run=true overrides execute. Matches the mesh_refine_batch / mesh_fast_forward_node dry_run/execute contract. Converges ONE node: to land two or more sibling worktrees that share a base branch, use mesh_refine_batch instead of calling this repeatedly \u2014 it orders the nodes conflict-aware and auto-rebases each one onto the base its predecessors advanced, which repeated single-node calls leave to you (and which can contend on the base lease as base_locked).",
   inputSchema: {
     type: "object",
     properties: {
@@ -1839,6 +1890,7 @@ var ALL_MESH_TOOLS = [
   MESH_STATUS_TOOL,
   MESH_LIST_NODES_TOOL,
   MESH_ENQUEUE_TASK_TOOL,
+  MESH_ENQUEUE_BATCH_TOOL,
   MESH_VIEW_QUEUE_TOOL,
   MESH_QUEUE_CANCEL_TOOL,
   MESH_QUEUE_REQUEUE_TOOL,
@@ -3478,8 +3530,10 @@ async function collectLiveStatusSessionsVerified(ctx, node) {
 async function collectLiveStatusProbe(ctx, node) {
   try {
     const statusResult = await commandForNode(ctx, node, "get_status_metadata", {}, { statusProbe: true });
+    const payload = unwrapCommandPayload(statusResult);
     return {
       sessions: extractStatusMetadataSessions(statusResult),
+      ...readString(payload?.status?.instanceId) ? { daemonId: readString(payload.status.instanceId) } : {},
       daemonBuild: extractDaemonBuildInfo(statusResult),
       upgradeFailure: extractUpgradeFailureSummary(statusResult)
     };
@@ -3515,11 +3569,14 @@ function extractDaemonBuildInfo(value) {
   if (!build) return void 0;
   const commit = readString(build.commit);
   if (!commit) return void 0;
+  const reportedTrack = readString(build.track);
+  const track = reportedTrack === "stable" || reportedTrack === "preview" ? reportedTrack : "unknown";
   return {
     commit,
     commitShort: readString(build.commitShort) || commit.slice(0, 7),
     version: readString(build.version) || "unknown",
-    ...readString(build.builtAt) ? { builtAt: readString(build.builtAt) } : {}
+    ...readString(build.builtAt) ? { builtAt: readString(build.builtAt) } : {},
+    track
   };
 }
 async function collectMeshViewQueueNodesWithLiveSessions(ctx) {
@@ -4534,14 +4591,14 @@ function buildUntargetedCodeChangeWorktreeAdvisory(input) {
     worktreeRoutingAdvisory: 'This untargeted `code_change` will be claimed by whichever node polls first \u2014 usually the BASE node, which gives it no branch isolation. Base nodes are for environment-specific testing (win32 PATH/registry, clean install on one OS, that machine\'s package state, OS-dependent runtime behavior). If this task only changes code, cancel it (mesh_queue_cancel), call mesh_clone_node (~10s, auto-launch starts the session), and re-enqueue with target_node_id set to the returned worktree node id \u2014 or pass prefer_worktree: true to route to the most recent worktree. If it DOES need a specific machine, pin it with required_tags (e.g. ["os=win32"]) or target_node_id and this advisory will not appear.'
   };
 }
-async function meshEnqueueTask(ctx, args) {
+function normalizeEnqueueTaskArgs(ctx, args, callerLabel) {
   const message = readString(args.message);
   if (!message) {
-    return JSON.stringify({
-      success: false,
+    return {
+      ok: false,
       code: "invalid_message",
-      error: "mesh_enqueue_task requires a non-empty string `message`."
-    });
+      error: `${callerLabel} requires a non-empty string \`message\`.`
+    };
   }
   const taskMode = readString(args.task_mode) || readString(args.taskMode);
   const readonly = args.readonly === true || args.read_only === true;
@@ -4556,26 +4613,132 @@ async function meshEnqueueTask(ctx, args) {
   const notBefore = (0, import_daemon_core5.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 allowDuplicate = args.allowDuplicate === true || args.allow_duplicate === true;
-  const blockDuplicate = args.blockDuplicate === true || args.block_duplicate === true;
   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));
     if (!matched) {
-      return JSON.stringify({
-        success: false,
+      return {
+        ok: false,
         code: "target_node_not_found",
         error: `target node '${explicitTargetRaw}' is not a member of this mesh \u2014 refusing to enqueue an unpinned task (it could be claimed by any node, including a different machine). Use mesh_list_nodes to get a valid node id.`,
-        targetNodeId: explicitTargetRaw,
-        availableNodeIds: ctx.mesh.nodes.map((n) => n.id).filter(Boolean)
-      });
+        extra: {
+          targetNodeId: explicitTargetRaw,
+          availableNodeIds: ctx.mesh.nodes.map((n) => n.id).filter(Boolean)
+        }
+      };
     }
     targetNodeId = readString(matched.id) || explicitTargetRaw;
   } else if (preferWorktree) {
     targetNodeId = resolvePreferredWorktreeNodeId(ctx) || void 0;
   }
+  return {
+    ok: true,
+    value: {
+      message,
+      taskMode,
+      readonly,
+      requiredTags,
+      dependsOn,
+      missionId,
+      priority,
+      model,
+      thinkingLevel,
+      difficulty,
+      notBefore,
+      maxRetries,
+      explicitTargetRaw,
+      preferWorktree,
+      targetNodeId
+    }
+  };
+}
+function eagerPushTaskToRemoteNodes(ctx, task, message, targetNodeId, requiredTags, coordinatorDaemonId) {
+  const dispatchPromises = [];
+  for (const node of ctx.mesh.nodes) {
+    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;
+    dispatchPromises.push(
+      ipcDispatchToRemoteAgent(ctx, node, {
+        message,
+        meshContext: {
+          meshId: ctx.mesh.id,
+          nodeId: node.id,
+          taskId: task.id,
+          ...coordinatorDaemonId ? { coordinatorDaemonId } : {}
+        }
+      }).then((result) => {
+        if (result.success) {
+          try {
+            const providerType = result.providerType;
+            const descriptor = summarizeTaskMessage(message);
+            (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+              kind: "task_dispatched",
+              nodeId: node.id,
+              sessionId: result.sessionId,
+              providerType,
+              payload: {
+                source: "queue",
+                via: "p2p_direct",
+                taskId: task.id,
+                message,
+                taskTitle: descriptor.taskTitle,
+                taskSummary: descriptor.taskSummary,
+                ...task.taskMode ? { taskMode: task.taskMode } : {},
+                ...providerType ? { providerType } : {},
+                targetSessionId: result.sessionId
+              }
+            });
+          } catch {
+          }
+        }
+      }).catch((err) => {
+        try {
+          (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
+            kind: "p2p_dispatch_failed",
+            nodeId: node.id,
+            payload: {
+              source: "queue",
+              via: "p2p_direct",
+              taskId: task.id,
+              error: err?.message || String(err),
+              dispatchFailedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+        } catch {
+        }
+      })
+    );
+  }
+  return dispatchPromises;
+}
+async function meshEnqueueTask(ctx, args) {
+  const normalized = normalizeEnqueueTaskArgs(ctx, args, "mesh_enqueue_task");
+  if (!normalized.ok) {
+    return JSON.stringify({ success: false, code: normalized.code, error: normalized.error, ...normalized.extra ?? {} });
+  }
+  const {
+    message,
+    taskMode,
+    readonly,
+    requiredTags,
+    dependsOn,
+    missionId,
+    priority,
+    model,
+    thinkingLevel,
+    difficulty,
+    notBefore,
+    maxRetries,
+    explicitTargetRaw,
+    preferWorktree,
+    targetNodeId
+  } = normalized.value;
+  const allowDuplicate = args.allowDuplicate === true || args.allow_duplicate === true;
+  const blockDuplicate = args.blockDuplicate === true || args.block_duplicate === true;
   const duplicateSuspect = allowDuplicate ? null : findInFlightDuplicate(ctx, message, targetNodeId);
   if (duplicateSuspect && blockDuplicate) {
     return JSON.stringify({
@@ -4641,65 +4804,7 @@ async function meshEnqueueTask(ctx, args) {
       );
       const eagerPushDeferred = !(0, import_daemon_core5.taskDependenciesSatisfied)(task, dependencyStatusById);
       const coordinatorDaemonId = resolveCoordinatorDaemonId(ctx);
-      const dispatchPromises = [];
-      const eagerPushTargets = eagerPushDeferred ? [] : ctx.mesh.nodes;
-      for (const node of eagerPushTargets) {
-        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;
-        dispatchPromises.push(
-          ipcDispatchToRemoteAgent(ctx, node, {
-            message,
-            meshContext: {
-              meshId: ctx.mesh.id,
-              nodeId: node.id,
-              taskId: task.id,
-              ...coordinatorDaemonId ? { coordinatorDaemonId } : {}
-            }
-          }).then((result) => {
-            if (result.success) {
-              try {
-                const providerType = result.providerType;
-                const descriptor = summarizeTaskMessage(message);
-                (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
-                  kind: "task_dispatched",
-                  nodeId: node.id,
-                  sessionId: result.sessionId,
-                  providerType,
-                  payload: {
-                    source: "queue",
-                    via: "p2p_direct",
-                    taskId: task.id,
-                    message,
-                    taskTitle: descriptor.taskTitle,
-                    taskSummary: descriptor.taskSummary,
-                    ...task.taskMode ? { taskMode: task.taskMode } : {},
-                    ...providerType ? { providerType } : {},
-                    targetSessionId: result.sessionId
-                  }
-                });
-              } catch {
-              }
-            }
-          }).catch((err) => {
-            try {
-              (0, import_daemon_core5.appendLedgerEntry)(ctx.mesh.id, {
-                kind: "p2p_dispatch_failed",
-                nodeId: node.id,
-                payload: {
-                  source: "queue",
-                  via: "p2p_direct",
-                  taskId: task.id,
-                  error: err?.message || String(err),
-                  dispatchFailedAt: (/* @__PURE__ */ new Date()).toISOString()
-                }
-              });
-            } catch {
-            }
-          })
-        );
-      }
+      const dispatchPromises = eagerPushDeferred ? [] : eagerPushTaskToRemoteNodes(ctx, task, message, targetNodeId, requiredTags, coordinatorDaemonId);
       Promise.all(dispatchPromises).catch(() => {
       });
       return JSON.stringify({
@@ -4731,6 +4836,178 @@ async function meshEnqueueTask(ctx, args) {
     return JSON.stringify({ success: false, error: message2 });
   }
 }
+var BATCH_ENQUEUE_ERROR_CODES = [
+  "live_debug_readonly_guardrail_violation",
+  "dependency_cycle_detected",
+  "unknown_dependency",
+  "duplicate_task_ref",
+  "duplicate_task_id",
+  "task_graph_too_large",
+  "empty_task_graph",
+  "missing_task_difficulty",
+  "invalid_task_difficulty"
+];
+async function meshEnqueueBatch(ctx, args) {
+  const rawTasks = Array.isArray(args.tasks) ? args.tasks : void 0;
+  if (!rawTasks || rawTasks.length === 0) {
+    return JSON.stringify({
+      success: false,
+      code: "empty_task_graph",
+      error: "mesh_enqueue_batch requires a non-empty `tasks` array."
+    });
+  }
+  if (rawTasks.length > import_daemon_core5.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.`
+    });
+  }
+  const batchMissionId = readString(args.missionId) || readString(args.mission_id) || void 0;
+  const allowDuplicate = args.allowDuplicate === true || args.allow_duplicate === true;
+  const blockDuplicate = args.blockDuplicate === true || args.block_duplicate === true;
+  const specs = [];
+  const normalizedEntries = [];
+  const duplicateSuspects = [];
+  for (let i = 0; i < rawTasks.length; i++) {
+    const entry = rawTasks[i] ?? {};
+    const ref = readString(entry.ref) || void 0;
+    const label = ref ? `task '${ref}'` : `task #${i}`;
+    const normalized = normalizeEnqueueTaskArgs(ctx, entry, `mesh_enqueue_batch ${label}`);
+    if (!normalized.ok) {
+      return JSON.stringify({
+        success: false,
+        code: normalized.code,
+        error: normalized.error,
+        taskIndex: i,
+        ...ref ? { ref } : {},
+        ...normalized.extra ?? {},
+        enqueued: 0,
+        atomic: true
+      });
+    }
+    const v = normalized.value;
+    if (!allowDuplicate) {
+      const suspect = findInFlightDuplicate(ctx, v.message, v.targetNodeId);
+      if (suspect) {
+        duplicateSuspects.push({
+          taskIndex: i,
+          ...ref ? { ref } : {},
+          duplicateOf: { taskId: suspect.id, status: suspect.status, assignedNodeId: suspect.assignedNodeId, targetNodeId: suspect.targetNodeId }
+        });
+      }
+    }
+    normalizedEntries.push({ ...v, ...ref ? { ref } : {} });
+    specs.push({
+      ...ref ? { ref } : {},
+      message: v.message,
+      taskMode: v.taskMode,
+      ...v.readonly ? { readonly: true } : {},
+      requiredTags: v.requiredTags,
+      dependsOn: v.dependsOn,
+      missionId: v.missionId ?? batchMissionId,
+      targetNodeId: v.targetNodeId,
+      ...v.priority ? { priority: v.priority } : {},
+      ...v.model ? { model: v.model } : {},
+      ...v.thinkingLevel ? { thinkingLevel: v.thinkingLevel } : {},
+      ...v.difficulty ? { difficulty: v.difficulty } : {},
+      ...v.notBefore ? { notBefore: v.notBefore } : {},
+      ...v.maxRetries !== void 0 ? { maxRetries: v.maxRetries } : {},
+      ...ctx.coordinatorSessionId ? { sourceCoordinatorSessionId: ctx.coordinatorSessionId } : {}
+    });
+  }
+  if (duplicateSuspects.length > 0 && blockDuplicate) {
+    return JSON.stringify({
+      success: false,
+      code: "duplicate_suspect",
+      error: `${duplicateSuspects.length} task(s) in this batch match an in-flight task with the same message (and target node when pinned). Refusing the WHOLE batch because block_duplicate=true and the batch is atomic. Cancel the in-flight duplicates, wait for them, or re-send with allow_duplicate=true.`,
+      duplicateSuspects,
+      enqueued: 0,
+      atomic: true
+    });
+  }
+  let tasks;
+  try {
+    tasks = (0, import_daemon_core5.enqueueTaskGraph)(ctx.mesh.id, specs);
+  } catch (e) {
+    const message = e?.message || String(e);
+    const code = BATCH_ENQUEUE_ERROR_CODES.find((c) => message.includes(c));
+    return JSON.stringify({
+      success: false,
+      ...code ? { code } : {},
+      error: message,
+      enqueued: 0,
+      atomic: true
+    });
+  }
+  const distinctMissionIds = [...new Set(specs.map((s) => s.missionId).filter((m) => !!m))];
+  const missionWarning = distinctMissionIds.map((missionId) => buildMissionInactiveWarning(ctx, missionId)).find((w) => w !== null) ?? {};
+  const advisoryTasks = [];
+  normalizedEntries.forEach((entry, i) => {
+    const advisory = buildUntargetedCodeChangeWorktreeAdvisory({
+      taskMode: entry.taskMode,
+      readonly: entry.readonly,
+      requiredTags: entry.requiredTags,
+      targetNodeId: entry.targetNodeId,
+      preferWorktree: entry.preferWorktree
+    });
+    if (advisory) advisoryTasks.push(entry.ref ? `'${entry.ref}'` : `#${i}`);
+  });
+  const worktreeAdvisory = advisoryTasks.length > 0 ? {
+    ...buildUntargetedCodeChangeWorktreeAdvisory({ taskMode: "code_change", readonly: false, preferWorktree: false }),
+    worktreeRoutingAdvisoryTasks: advisoryTasks
+  } : {};
+  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 coordinatorDaemonId = resolveCoordinatorDaemonId(ctx);
+    const dispatchPromises = [];
+    tasks.forEach((task, i) => {
+      if (!(0, import_daemon_core5.taskDependenciesSatisfied)(task, dependencyStatusById)) {
+        eagerPushDeferredCount++;
+        return;
+      }
+      dispatchPromises.push(...eagerPushTaskToRemoteNodes(
+        ctx,
+        task,
+        normalizedEntries[i].message,
+        normalizedEntries[i].targetNodeId,
+        normalizedEntries[i].requiredTags,
+        coordinatorDaemonId
+      ));
+    });
+    Promise.all(dispatchPromises).catch(() => {
+    });
+  }
+  return JSON.stringify({
+    success: true,
+    source: "queue",
+    atomic: true,
+    enqueued: tasks.length,
+    tasks: tasks.map((task, i) => ({
+      ...normalizedEntries[i].ref ? { ref: normalizedEntries[i].ref } : {},
+      taskId: task.id,
+      status: task.status,
+      taskMode: task.taskMode,
+      ...Array.isArray(task.dependsOn) && task.dependsOn.length > 0 ? { dependsOn: task.dependsOn } : {},
+      ...task.targetNodeId ? { targetNodeId: task.targetNodeId } : {},
+      ...task.priority ? { priority: task.priority } : {},
+      ...task.notBefore ? { notBefore: task.notBefore } : {}
+    })),
+    ...duplicateSuspects.length > 0 ? {
+      duplicateSuspects,
+      duplicateSuspectHint: "In-flight task(s) with the same message+target already exist. The batch was enqueued anyway (warn-only). Cancel duplicates via mesh_queue_cancel, or pass allow_duplicate=true / block_duplicate=true to silence or refuse next time."
+    } : {},
+    ...missionWarning,
+    ...worktreeAdvisory,
+    ...eagerPushDeferredCount > 0 ? { eagerPushDeferred: eagerPushDeferredCount, eagerPushDeferredReason: "dependencies_unsatisfied" } : {},
+    queueTrigger,
+    ...buildQueueTriggerGuidance(queueTrigger)
+  });
+}
 async function meshViewQueue(ctx, args) {
   const rateResult = (0, import_daemon_core5.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_view_queue" });
   const compact = args.verbose === true ? false : args.compact ?? true;
@@ -8146,6 +8423,10 @@ async function meshFastForwardNode(ctx, args) {
 async function meshRestartDaemon(ctx, args) {
   await refreshMeshFromDaemon(ctx);
   const node = await findNodeWithRefresh(ctx, args.node_id);
+  const observedProbe = await collectLiveStatusProbe(ctx, node);
+  const meshAttachedTrack = observedProbe.daemonBuild?.track ?? "unknown";
+  const configuredDaemonId = typeof node.daemonId === "string" && node.daemonId.trim() ? node.daemonId.trim() : "unknown";
+  const meshAttachedDaemonId = observedProbe.daemonId ?? "unknown";
   try {
     const result = await commandForNode(ctx, node, "restart_daemon_node", {
       meshId: ctx.mesh.id,
@@ -8163,14 +8444,53 @@ async function meshRestartDaemon(ctx, args) {
       // a downgrade" for every caller that does not opt in.
       ...args.allow_downgrade === true ? { allowDowngrade: true } : {}
     });
-    return JSON.stringify(unwrapCommandPayload(result), null, 2);
+    const payload = unwrapCommandPayload(result);
+    const rawTarget = payload?.restartTargetDaemon && typeof payload.restartTargetDaemon === "object" ? payload.restartTargetDaemon : {};
+    const targetTrack = rawTarget.track === "stable" || rawTarget.track === "preview" ? rawTarget.track : "unknown";
+    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 routingMismatch = trackMismatch === true || daemonMismatch === true;
+    return JSON.stringify({
+      ...payload,
+      meshAttachedDaemon: {
+        daemonId: meshAttachedDaemonId,
+        configuredDaemonId,
+        track: meshAttachedTrack
+      },
+      restartTargetDaemon: {
+        daemonId: targetDaemonId,
+        track: targetTrack,
+        npmTag: targetNpmTag
+      },
+      daemonMismatch,
+      trackMismatch,
+      ...routingMismatch ? {
+        trackWarning: `DAEMON/TRACK MISMATCH: mesh status was answered by ${meshAttachedDaemonId} on the '${meshAttachedTrack}' track, but restart/upgrade was accepted by ${targetDaemonId} on the '${targetTrack}' track. The operation was not blocked; verify the intended daemon before interpreting version changes.`
+      } : {},
+      ...!routingMismatch && (trackMismatch === null || daemonMismatch === null) ? {
+        trackWarning: "Daemon/track match is unknown because the mesh-attached daemon or restart target did not report enough identity. No track was inferred from the version string."
+      } : {}
+    }, null, 2);
   } catch (e) {
     const failure = buildCoordinatorP2pRelayFailure(e, {
       command: "restart_daemon_node",
       targetDaemonId: node.daemonId,
       nodeId: args.node_id
     });
-    return JSON.stringify(failure, null, 2);
+    return JSON.stringify({
+      ...failure,
+      meshAttachedDaemon: {
+        daemonId: meshAttachedDaemonId,
+        configuredDaemonId,
+        track: meshAttachedTrack
+      },
+      restartTargetDaemon: { daemonId: "unknown", track: "unknown", npmTag: "unknown" },
+      daemonMismatch: null,
+      trackMismatch: null,
+      trackWarning: "Restart/upgrade target track is unknown because the command was not accepted. No track was inferred from the version string."
+    }, null, 2);
   }
 }
 async function meshCheckpoint(ctx, args) {
@@ -9876,6 +10196,9 @@ async function startMcpServer(opts) {
           case "mesh_enqueue_task":
             text = await meshEnqueueTask(meshCtx, a);
             break;
+          case "mesh_enqueue_batch":
+            text = await meshEnqueueBatch(meshCtx, a);
+            break;
           case "mesh_view_queue":
             text = await meshViewQueue(meshCtx, a);
             break;