@adhdev/daemon-standalone 0.9.82-rc.18 → 0.9.82-rc.181

package/vendor/mcp-server/index.js

@@ -35,9 +35,128 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/tools/mesh-tools.ts
+var import_node_crypto = require("crypto");
+
 // src/transports/ipc.ts
 var DEFAULT_IPC_PORT = 19222;
 var DEFAULT_IPC_PATH = "/ipc";
+var DEFAULT_IPC_COMMAND_TIMEOUT_MS = 15e3;
+var IPC_COMMAND_TIMEOUTS_MS = {
+  mesh_relay_command: 12e4,
+  agent_command: 3e4,
+  git_status: 45e3,
+  git_diff_summary: 45e3,
+  fast_forward_mesh_node: 12e4,
+  mesh_status: 12e4
+};
+var WS_CONNECTING = 0;
+var WS_OPEN = 1;
+var POOL_IDLE_EVICT_MS = 5 * 6e4;
+var POOL_MAX_AGE_MS = 10 * 6e4;
+var connectionPool = /* @__PURE__ */ new Map();
+function buildRequestId() {
+  return `mcp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function getTimeoutMs(type, nestedCommand) {
+  return Math.max(
+    IPC_COMMAND_TIMEOUTS_MS[type] ?? DEFAULT_IPC_COMMAND_TIMEOUT_MS,
+    IPC_COMMAND_TIMEOUTS_MS[nestedCommand] ?? DEFAULT_IPC_COMMAND_TIMEOUT_MS
+  );
+}
+function getOrCreateConnection(WebSocketCtor, url) {
+  const existing = connectionPool.get(url);
+  if (existing) {
+    const { readyState } = existing.ws;
+    const now2 = Date.now();
+    const isAlive = readyState === WS_CONNECTING || readyState === WS_OPEN;
+    const isIdle = now2 - existing.lastUsedAt > POOL_IDLE_EVICT_MS && existing.pending.size === 0;
+    const isTooOld = now2 - existing.createdAt > POOL_MAX_AGE_MS && existing.pending.size === 0;
+    if (isAlive && !isIdle && !isTooOld) {
+      return existing;
+    }
+    if (isAlive && (isIdle || isTooOld)) {
+      try {
+        existing.ws.close();
+      } catch {
+      }
+      connectionPool.delete(url);
+    }
+    connectionPool.delete(url);
+  }
+  const now = Date.now();
+  const conn = {
+    ws: new WebSocketCtor(url),
+    ready: false,
+    commandQueue: [],
+    pending: /* @__PURE__ */ new Map(),
+    lastUsedAt: now,
+    createdAt: now
+  };
+  connectionPool.set(url, conn);
+  const drainQueue = () => {
+    conn.ready = true;
+    for (const { type, args, requestId } of conn.commandQueue) {
+      conn.ws.send(JSON.stringify({ type: "ext:command", payload: { command: type, args, requestId } }));
+    }
+    conn.commandQueue = [];
+  };
+  let tornDown = false;
+  const teardown = (error) => {
+    if (tornDown) return;
+    tornDown = true;
+    connectionPool.delete(url);
+    conn.ready = false;
+    for (const [, req] of conn.pending) {
+      clearTimeout(req.timer);
+      req.reject(error);
+    }
+    conn.pending.clear();
+    conn.commandQueue = [];
+  };
+  conn.ws.addEventListener("open", () => {
+    conn.ws.send(JSON.stringify({
+      type: "ext:register",
+      payload: {
+        ideType: "mcp-server",
+        ideVersion: "1.0.0",
+        extensionVersion: "1.0.0",
+        instanceId: `mcp-server-${process.pid}`,
+        machineId: "mcp-server",
+        workspaceFolders: []
+      }
+    }));
+  });
+  conn.ws.addEventListener("message", (event) => {
+    try {
+      const raw = typeof event.data === "string" ? event.data : String(event.data);
+      const msg = JSON.parse(raw);
+      if (msg?.type === "daemon:welcome") {
+        drainQueue();
+        return;
+      }
+      if (msg?.type !== "ext:command_result") return;
+      const req = conn.pending.get(msg?.payload?.requestId);
+      if (!req) return;
+      conn.pending.delete(msg.payload.requestId);
+      clearTimeout(req.timer);
+      const payload = msg.payload;
+      if (payload?.success === false) {
+        req.reject(new Error(payload.error || "Daemon IPC command failed"));
+      } else {
+        req.resolve(payload?.result ?? payload);
+      }
+    } catch {
+    }
+  });
+  conn.ws.addEventListener("error", () => {
+    teardown(new Error(`Cannot connect to daemon IPC at ${url}`));
+  });
+  conn.ws.addEventListener("close", () => {
+    teardown(new Error(`Daemon IPC connection closed: ${url}`));
+  });
+  return conn;
+}
 var IpcTransport = class {
   port;
   path;
@@ -66,73 +185,41 @@ var IpcTransport = class {
       args
     });
   }
-  async sendIpcCommand(type, args) {
+  sendIpcCommand(type, args) {
     const WebSocketCtor = globalThis.WebSocket;
     if (!WebSocketCtor) {
-      throw new Error("WebSocket is not available in this Node runtime; Node 20+ is required for daemon IPC mode");
+      return Promise.reject(new Error("WebSocket is not available in this Node runtime; Node 20+ is required for daemon IPC mode"));
     }
+    const requestId = buildRequestId();
+    const nestedCommand = typeof args?.command === "string" ? args.command : "";
+    const timeoutMs = getTimeoutMs(type, nestedCommand);
+    const targetDaemonId = typeof args?.targetDaemonId === "string" ? args.targetDaemonId : "";
+    const diagnosticParts = [
+      `command='${type}'`,
+      ...nestedCommand ? [`relayedCommand='${nestedCommand}'`] : [],
+      ...targetDaemonId ? [`targetDaemonId='${targetDaemonId.slice(0, 12)}'`] : [],
+      ...typeof args?.nodeId === "string" ? [`nodeId='${args.nodeId}'`] : [],
+      ...typeof args?.workspace === "string" ? [`workspace='${args.workspace}'`] : []
+    ];
+    const url = `ws://127.0.0.1:${this.port}${this.path}`;
     return new Promise((resolve, reject) => {
-      const requestId = `mcp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      const ws = new WebSocketCtor(`ws://127.0.0.1:${this.port}${this.path}`);
-      let settled = false;
-      const finish = (fn) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timeout);
-        try {
-          ws.close();
-        } catch {
-        }
-        fn();
-      };
-      const timeoutMs = type === "mesh_relay_command" ? 6e4 : 15e3;
-      const timeout = setTimeout(() => {
-        finish(() => reject(new Error(`Daemon IPC command '${type}' timed out after ${Math.round(timeoutMs / 1e3)}s`)));
+      let conn;
+      try {
+        conn = getOrCreateConnection(WebSocketCtor, url);
+      } catch (e) {
+        return reject(new Error(`Failed to create IPC connection: ${e?.message || e}`));
+      }
+      const timer = setTimeout(() => {
+        conn.pending.delete(requestId);
+        reject(new Error(`Daemon IPC ${diagnosticParts.join(" ")} timed out after ${Math.round(timeoutMs / 1e3)}s (requestId=${requestId})`));
       }, timeoutMs);
-      let commandSent = false;
-      const send = () => {
-        if (commandSent) return;
-        commandSent = true;
-        ws.send(JSON.stringify({
-          type: "ext:command",
-          payload: { command: type, args, requestId }
-        }));
-      };
-      ws.addEventListener("open", () => {
-        ws.send(JSON.stringify({
-          type: "ext:register",
-          payload: {
-            ideType: "mcp-server",
-            ideVersion: "1.0.0",
-            extensionVersion: "1.0.0",
-            instanceId: `mcp-server-${process.pid}`,
-            machineId: "mcp-server",
-            workspaceFolders: []
-          }
-        }));
-      });
-      ws.addEventListener("message", (event) => {
-        try {
-          const raw = typeof event.data === "string" ? event.data : String(event.data);
-          const msg = JSON.parse(raw);
-          if (msg?.type === "daemon:welcome") {
-            send();
-            return;
-          }
-          if (msg?.type !== "ext:command_result") return;
-          if (msg?.payload?.requestId !== requestId) return;
-          const payload = msg.payload;
-          if (payload?.success === false) {
-            finish(() => reject(new Error(payload.error || `Daemon IPC command '${type}' failed`)));
-            return;
-          }
-          finish(() => resolve(payload?.result ?? payload));
-        } catch {
-        }
-      });
-      ws.addEventListener("error", () => {
-        finish(() => reject(new Error(`Cannot connect to daemon IPC at ws://127.0.0.1:${this.port}${this.path}`)));
-      });
+      conn.pending.set(requestId, { resolve, reject, timer });
+      conn.lastUsedAt = Date.now();
+      if (conn.ready) {
+        conn.ws.send(JSON.stringify({ type: "ext:command", payload: { command: type, args, requestId } }));
+      } else {
+        conn.commandQueue.push({ type, args, requestId });
+      }
     });
   }
 };
@@ -241,17 +328,64 @@ function annotateRapidReadChatAdvisory(payload, options) {
 
 // src/tools/mesh-tools.ts
 var import_daemon_core = require("@adhdev/daemon-core");
+var SESSION_PROVIDER_METADATA_TTL_MS = 30 * 6e4;
 var meshSessionProviderMetadata = /* @__PURE__ */ new Map();
+function getSessionMetadata(key) {
+  const entry = meshSessionProviderMetadata.get(key);
+  if (!entry) return void 0;
+  if (entry.expiresAt <= Date.now()) {
+    meshSessionProviderMetadata.delete(key);
+    return void 0;
+  }
+  return entry;
+}
+var ACTIVE_WORK_POLLING_BACKOFF_MS = 6e4;
+function buildActiveWorkPollingGuidance(summary, now = Date.now()) {
+  if (!summary || summary.generatingCount <= 0) return void 0;
+  return {
+    activeGeneratingWork: true,
+    generatingCount: summary.generatingCount,
+    doNotPollBefore: new Date(now + ACTIVE_WORK_POLLING_BACKOFF_MS).toISOString(),
+    eventSurface: "pendingCoordinatorEvents",
+    nextRecommendedAction: "Wait for pendingCoordinatorEvents/completion events or an explicit user status request. If no terminal evidence appears and the user asks for status, make one bounded status check, then wait again.",
+    message: "Do not repeatedly poll mesh_status/mesh_view_queue/mesh_read_chat while delegated work is generating; terminal ledger or completion evidence will be surfaced through pendingCoordinatorEvents when available."
+  };
+}
 function readString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
+function summarizeTaskMessage(message) {
+  const taskSummary = message.replace(/\s+/g, " ").trim();
+  const taskTitle = taskSummary.length > 96 ? `${taskSummary.slice(0, 93)}...` : taskSummary;
+  return { taskTitle: taskTitle || "(untitled task)", taskSummary };
+}
+function buildDirectTaskPayload(message, via, opts) {
+  const descriptor = summarizeTaskMessage(message);
+  return {
+    source: "direct",
+    via,
+    taskId: opts.taskId,
+    message,
+    taskTitle: descriptor.taskTitle,
+    taskSummary: descriptor.taskSummary,
+    ...opts.taskMode ? { taskMode: opts.taskMode } : {},
+    ...opts.providerType ? { providerType: opts.providerType } : {},
+    ...opts.targetSessionId ? { targetSessionId: opts.targetSessionId } : {},
+    ...opts.dispatchedToIdleSession !== void 0 ? { dispatchedToIdleSession: opts.dispatchedToIdleSession } : {}
+  };
+}
+function findNode(mesh, nodeId) {
+  const node = mesh.nodes.find((n) => n.id === nodeId);
+  if (!node) throw new Error(`Node '${nodeId}' is not a member of mesh '${mesh.name}'`);
+  return node;
+}
 var DUPLICATE_DISPATCH_WINDOW_MS = 6e4;
 var STALE_ASSIGNED_QUEUE_MS = 30 * 6e4;
 var OLD_HISTORICAL_QUEUE_RECORD_MS = 7 * 24 * 60 * 6e4;
 var ACTIVE_QUEUE_STATUSES = /* @__PURE__ */ new Set(["pending", "assigned"]);
 var HISTORICAL_QUEUE_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 async function refreshMeshFromDaemon(ctx) {
-  if (!(ctx.transport instanceof IpcTransport)) return;
+  if (!isLocalTransport(ctx.transport)) return;
   try {
     const result = await ctx.transport.command("get_mesh", { meshId: ctx.mesh.id });
     if (!result?.success || !Array.isArray(result.mesh?.nodes)) return;
@@ -404,6 +538,33 @@ function buildMissingNodeReadChatRecovery(ctx, args) {
 function readSessionRecordId(session) {
   return readString(session?.id) || readString(session?.sessionId) || readString(session?.session_id) || readString(session?.runtimeSessionId) || readString(session?.runtime_session_id) || readString(session?.instanceId) || readString(session?.instance_id);
 }
+function extractStatusMetadataSessions(value) {
+  const payload = unwrapCommandPayload(value);
+  const status = payload?.status && typeof payload.status === "object" ? payload.status : payload;
+  return Array.isArray(status?.sessions) ? status.sessions : [];
+}
+function resolveSessionProviderType(session) {
+  return readString(session?.providerType) || readString(session?.cliType) || readString(session?.agentType) || "";
+}
+function isMeshCoordinatorSessionRecord(session) {
+  return Boolean(
+    readString(session?.settings?.meshCoordinatorFor) || readString(session?.meta?.meshCoordinatorFor) || readString(session?.metadata?.meshCoordinatorFor) || readString(session?.meshCoordinatorFor)
+  );
+}
+function isUnmanagedSessionRecord(session) {
+  const hasMeshNodeFor = Boolean(
+    readString(session?.settings?.meshNodeFor) || readString(session?.meta?.meshNodeFor) || readString(session?.metadata?.meshNodeFor) || readString(session?.meshNodeFor)
+  );
+  if (hasMeshNodeFor) return false;
+  if (isMeshCoordinatorSessionRecord(session)) return false;
+  const launchedByCoordinator = Boolean(
+    session?.settings?.launchedByCoordinator === true || session?.meta?.launchedByCoordinator === true || session?.launchedByCoordinator === true
+  );
+  return !launchedByCoordinator;
+}
+function isWorkerTaskMode(taskMode) {
+  return taskMode !== "live_debug_readonly";
+}
 function addSessionRecord(target, session) {
   if (!session || typeof session !== "object" || isTerminalSessionRecord(session)) return;
   const sessionId = readSessionRecordId(session);
@@ -472,18 +633,26 @@ function queueAssignmentStaleReason(task, liveness) {
 }
 function buildQueueStatusSummary(queue) {
   const counts = { pending: 0, assigned: 0, completed: 0, failed: 0, cancelled: 0 };
+  let staleAssigned = 0;
   for (const task of queue) {
     const status = typeof task?.status === "string" ? task.status : void 0;
     if (status && Object.prototype.hasOwnProperty.call(counts, status)) {
       counts[status] += 1;
     }
+    if (status === "assigned" && task?.staleAssigned === true) staleAssigned += 1;
   }
+  const liveAssigned = Math.max(0, counts.assigned - staleAssigned);
   return {
     totalCount: queue.length,
-    activeCount: counts.pending + counts.assigned,
+    activeCount: counts.pending + liveAssigned,
     historicalCount: counts.completed + counts.failed + counts.cancelled,
     counts,
     activeCounts: {
+      pending: counts.pending,
+      assigned: liveAssigned
+    },
+    staleAssignedCount: staleAssigned,
+    rawActiveCounts: {
       pending: counts.pending,
       assigned: counts.assigned
     },
@@ -511,6 +680,18 @@ function filterQueueForView(queue, view, statuses) {
   if (view === "historical") return queue.filter((task) => HISTORICAL_QUEUE_STATUSES.has(String(task?.status || "")));
   return queue;
 }
+function prioritizeActiveQueueRows(queue) {
+  const active = [];
+  const historical = [];
+  const other = [];
+  for (const task of queue) {
+    const status = String(task?.status || "");
+    if (ACTIVE_QUEUE_STATUSES.has(status)) active.push(task);
+    else if (HISTORICAL_QUEUE_STATUSES.has(status)) historical.push(task);
+    else other.push(task);
+  }
+  return [...active, ...other, ...historical];
+}
 function slimQueueTask(task) {
   return {
     id: task?.id,
@@ -616,22 +797,59 @@ function isIdleSessionRecord(session) {
   const chatStatus = typeof session?.activeChat?.status === "string" ? session.activeChat.status.toLowerCase() : "";
   return status === "idle" || chatStatus === "waiting_input";
 }
+function isMeshOwnedDelegateSession(session, meshId, nodeId) {
+  const settings = session?.settings;
+  const sessionMeshId = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
+  const sessionNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
+  if (sessionMeshId !== meshId) return false;
+  return !sessionNodeId || sessionNodeId === nodeId;
+}
 function chooseDispatchableSession(sessions, providerType, meshId, nodeId) {
   const live = sessions.filter((session) => !isTerminalSessionRecord(session));
   const matchingProvider = (session) => !providerType || session?.providerType === providerType || session?.cliType === providerType;
-  const isMeshOwnedDelegateSession = (session) => {
-    const settings = session?.settings;
-    const sessionMeshId = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
-    const coordinatorDaemonId = typeof settings?.meshCoordinatorDaemonId === "string" ? settings.meshCoordinatorDaemonId.trim() : "";
-    const sessionNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
-    if (sessionMeshId !== meshId || !coordinatorDaemonId) return false;
-    return !sessionNodeId || sessionNodeId === nodeId;
-  };
   const meshSessions = live.filter(
-    (session) => isMeshOwnedDelegateSession(session)
+    (session) => isMeshOwnedDelegateSession(session, meshId, nodeId)
   );
   return meshSessions.find((session) => isIdleSessionRecord(session) && matchingProvider(session)) || meshSessions.find(matchingProvider) || void 0;
 }
+function buildRelayUnsafeRemoteSessionFailure(ctx, node, sessionId, providerType) {
+  return {
+    success: false,
+    recoverable: true,
+    code: "mesh_delegate_session_missing_relay_metadata",
+    reason: "mesh_delegate_session_missing_relay_metadata",
+    transport: "mesh_transport",
+    retryRecommended: true,
+    meshId: ctx.mesh.id,
+    nodeId: node.id,
+    daemonId: node.daemonId,
+    workspace: node.workspace,
+    sessionId,
+    unsafeTranscriptAlias: true,
+    ...providerType ? { resolvedProviderType: providerType } : {},
+    error: `Remote session '${sessionId}' is not relay-safe for mesh '${ctx.mesh.id}': missing meshNodeFor/meshCoordinatorDaemonId metadata, so completion events would not reach the coordinator ledger. This session may be the coordinator itself or an unrelated session (unsafe_transcript_alias risk).`,
+    nextAction: `Launch a fresh relay-safe session with mesh_launch_session(node_id: '${node.id}'${providerType ? `, type: '${providerType}'` : ""}) or dispatch without session_id so Repo Mesh can choose a valid delegate session.`,
+    noFallbackReason: "Blindly reusing a remote session without mesh relay metadata would silently drop task_completed / generating_completed events."
+  };
+}
+function buildMissingCoordinatorDaemonIdFailure(ctx, node, providerType) {
+  return {
+    success: false,
+    recoverable: true,
+    code: "mesh_coordinator_daemon_unknown",
+    reason: "mesh_coordinator_daemon_unknown",
+    transport: "mesh_transport",
+    retryRecommended: true,
+    meshId: ctx.mesh.id,
+    nodeId: node.id,
+    daemonId: node.daemonId,
+    workspace: node.workspace,
+    ...providerType ? { resolvedProviderType: providerType } : {},
+    error: `Cannot launch a remote mesh delegate for node '${node.id}': coordinator daemon identity is unavailable, so the worker would be unable to relay completion events back to the coordinator.`,
+    nextAction: "Retry after the coordinator daemon identity is available (for example from an attached daemon-backed MCP session) so meshCoordinatorDaemonId can be stamped on the worker session.",
+    noFallbackReason: "Launching without meshCoordinatorDaemonId would create a worker session that can finish work but cannot emit task_completed / generating_completed back to the coordinator."
+  };
+}
 function findNestedPayload(value, predicate) {
   const seen = /* @__PURE__ */ new Set();
   const stack = [{ payload: value, depth: 0 }];
@@ -659,12 +877,16 @@ function extractGitDiff(value) {
 }
 function extractSubmodules(value, ignorePaths) {
   const payload = unwrapCommandPayload(value);
-  const subs = payload?.submodules ?? value?.submodules;
+  const subs = payload?.status?.submodules ?? payload?.submodules ?? value?.status?.submodules ?? value?.submodules;
   if (!Array.isArray(subs)) return void 0;
   if (ignorePaths.length === 0) return subs;
   const ignoreSet = new Set(ignorePaths);
   return subs.filter((s) => s?.path && !ignoreSet.has(s.path));
 }
+function assignFullGitSnapshot(entry, status) {
+  if (!status || typeof status !== "object" || Array.isArray(status)) return;
+  entry.git = status;
+}
 function extractLaunchPayload(value) {
   return findNestedPayload(value, (payload) => Boolean(payload?.sessionId || payload?.id || payload?.runtimeSessionId));
 }
@@ -789,20 +1011,76 @@ async function ipcDispatchToRemoteAgent(ctx, node, args) {
   let sessionId = args.session_id?.trim() || "";
   const providerPriorityList = Array.isArray(node.policy?.providerPriority) ? node.policy.providerPriority : [];
   let resolvedProviderType = args.providerType?.trim() || providerPriorityList[0] || "";
-  if (!sessionId) {
+  if (sessionId && args.verifiedSession) {
+    const explicitSession = args.verifiedSession;
+    if (!isMeshOwnedDelegateSession(explicitSession, ctx.mesh.id, node.id)) {
+      return buildRelayUnsafeRemoteSessionFailure(
+        ctx,
+        node,
+        sessionId,
+        resolvedProviderType || resolveSessionProviderType(explicitSession) || void 0
+      );
+    }
+    if (!resolvedProviderType) {
+      resolvedProviderType = resolveSessionProviderType(explicitSession);
+    }
+  } else if (!sessionId || args.session_id) {
     try {
       const relayResult = await transport.meshCommand(daemonId, "get_status_metadata", {});
-      const innerResult = relayResult?.result ?? relayResult;
-      const statusObj = innerResult?.status ?? innerResult;
-      const sessions = Array.isArray(statusObj?.sessions) ? statusObj.sessions : [];
-      const targetSession = chooseDispatchableSession(sessions, resolvedProviderType, ctx.mesh.id, node.id);
-      if (targetSession?.id || targetSession?.sessionId) {
-        sessionId = targetSession.id || targetSession.sessionId;
+      const sessions = extractStatusMetadataSessions(relayResult);
+      if (sessionId) {
+        const explicitSession = sessions.find((session) => readSessionRecordId(session) === sessionId);
+        if (!explicitSession) {
+          return {
+            success: false,
+            recoverable: true,
+            code: "mesh_target_session_not_found",
+            reason: "mesh_target_session_not_found",
+            transport: "mesh_transport",
+            retryRecommended: true,
+            meshId: ctx.mesh.id,
+            nodeId: node.id,
+            daemonId,
+            workspace: node.workspace,
+            sessionId,
+            ...resolvedProviderType ? { resolvedProviderType } : {},
+            error: `Remote session '${sessionId}' is not present in the live status for node '${node.id}'.`,
+            nextAction: `Launch a fresh session with mesh_launch_session(node_id: '${node.id}'${resolvedProviderType ? `, type: '${resolvedProviderType}'` : ""}) or retry without session_id so Repo Mesh can target a live delegate session.`
+          };
+        }
+        if (!isMeshOwnedDelegateSession(explicitSession, ctx.mesh.id, node.id)) {
+          return buildRelayUnsafeRemoteSessionFailure(
+            ctx,
+            node,
+            sessionId,
+            resolvedProviderType || resolveSessionProviderType(explicitSession) || void 0
+          );
+        }
         if (!resolvedProviderType) {
-          resolvedProviderType = targetSession.providerType || targetSession.cliType || "";
+          resolvedProviderType = resolveSessionProviderType(explicitSession);
+        }
+      } else {
+        const targetSession = chooseDispatchableSession(sessions, resolvedProviderType, ctx.mesh.id, node.id);
+        if (targetSession?.id || targetSession?.sessionId) {
+          sessionId = targetSession.id || targetSession.sessionId;
+          if (!resolvedProviderType) {
+            resolvedProviderType = resolveSessionProviderType(targetSession);
+          }
         }
       }
     } catch (e) {
+      if (sessionId) {
+        return {
+          ...buildCoordinatorP2pRelayFailure(e, {
+            command: "get_status_metadata",
+            targetDaemonId: daemonId,
+            nodeId: node.id,
+            sessionId
+          }),
+          success: false,
+          error: `Cannot verify remote session '${sessionId}' before dispatch: ${e?.message || String(e)}`
+        };
+      }
     }
   }
   if (!resolvedProviderType) {
@@ -814,7 +1092,8 @@ async function ipcDispatchToRemoteAgent(ctx, node, args) {
       agentType: resolvedProviderType,
       cliType: resolvedProviderType,
       action: "send_chat",
-      message: args.message
+      message: args.message,
+      ...args.meshContext ? { meshContext: args.meshContext } : {}
     });
     const dispatchPayload = unwrapCommandPayload(dispatchResult);
     if (dispatchPayload?.success === false || dispatchResult?.success === false) {
@@ -832,7 +1111,7 @@ async function ipcDispatchToRemoteAgent(ctx, node, args) {
         error: `P2P dispatch failed: ${errorMessage}`
       };
     }
-    return { success: true, dispatched: true, sessionId: sessionId || resolvedProviderType };
+    return { success: true, dispatched: true, sessionId: sessionId || resolvedProviderType, providerType: resolvedProviderType };
   } catch (e) {
     const errorMessage = e?.message || String(e);
     return {
@@ -862,34 +1141,199 @@ function resolveCoordinatorNode(ctx) {
   return void 0;
 }
 function readNodeMachineId(node) {
-  return readString(node.machineId) || readString(node.machine_id);
+  return readString(node.machineId) || readString(node.machine_id) || readString(node.machine?.id) || readString(node.machine?.machineId) || readString(node.lastProbe?.machineId) || readString(node.last_probe?.machine_id) || readString(node.lastProbe?.machine?.id) || readString(node.lastProbe?.machine?.machineId) || readString(node.last_probe?.machine?.id) || readString(node.last_probe?.machine?.machine_id);
 }
 function readNodeDaemonId(node) {
-  return readString(node.daemonId) || readString(node.daemon_id);
+  return readString(node.daemonId) || readString(node.daemon_id) || readString(node.machine?.daemonId) || readString(node.machine?.daemon_id) || readString(node.lastProbe?.daemonId) || readString(node.last_probe?.daemon_id) || readString(node.lastProbe?.machine?.daemonId) || readString(node.lastProbe?.machine?.daemon_id) || readString(node.last_probe?.machine?.daemonId) || readString(node.last_probe?.machine?.daemon_id);
+}
+function normalizeHostname(value) {
+  const hostname = readString(value);
+  if (!hostname) return void 0;
+  return hostname.toLowerCase().replace(/\.$/, "");
+}
+function readNodeHostname(node) {
+  return readString(node.hostname) || readString(node.host) || readString(node.machineHostname) || readString(node.machine_hostname) || readString(node.machine?.hostname) || readString(node.machine?.host) || readString(node.lastProbe?.hostname) || readString(node.last_probe?.hostname) || readString(node.lastProbe?.machine?.hostname) || readString(node.last_probe?.machine?.hostname);
+}
+function readNodeDisplayMachineName(node) {
+  return readString(node.machineName) || readString(node.machine_name) || readString(node.machineLabel) || readString(node.machine_label) || readString(node.machineNickname) || readString(node.machine_nickname) || readString(node.alias) || readString(node.machine?.name) || readString(node.machine?.displayName) || readString(node.machine?.display_name) || readString(node.lastProbe?.machineName) || readString(node.last_probe?.machine_name) || readString(node.lastProbe?.machine?.name) || readString(node.last_probe?.machine?.name) || readNodeHostname(node);
+}
+function compactIdentityEvidence(value) {
+  if (!value) return void 0;
+  return value.length > 24 ? `${value.slice(0, 12)}\u2026${value.slice(-8)}` : value;
+}
+function pushIdentityEvidence(evidence, label, value) {
+  const compact = compactIdentityEvidence(value);
+  if (compact) evidence.push(`${label}:${compact}`);
+}
+function buildNodeMachineIdentity(ctx, node) {
+  const machineId = readNodeMachineId(node);
+  const daemonId = readNodeDaemonId(node);
+  const hostname = readNodeHostname(node);
+  const machineName = readNodeDisplayMachineName(node);
+  const coordinatorHostname = readString(ctx.coordinatorHostname);
+  const localControlPlaneReason = getLocalControlPlaneMatchReason(ctx, node);
+  const directLocal = !!localControlPlaneReason;
+  const hostnameMatches = Boolean(
+    normalizeHostname(hostname) && normalizeHostname(coordinatorHostname) && normalizeHostname(hostname) === normalizeHostname(coordinatorHostname)
+  );
+  const sameMachine = directLocal || hostnameMatches;
+  const evidence = [];
+  pushIdentityEvidence(evidence, "machineName", machineName);
+  pushIdentityEvidence(evidence, "hostname", hostname);
+  pushIdentityEvidence(evidence, "machineId", machineId);
+  pushIdentityEvidence(evidence, "daemonId", daemonId);
+  if (localControlPlaneReason) {
+    pushIdentityEvidence(evidence, "localMatch", localControlPlaneReason);
+    pushIdentityEvidence(evidence, "localMachineId", ctx.localMachineId);
+    pushIdentityEvidence(evidence, "localDaemonId", ctx.localDaemonId);
+  }
+  const locality = sameMachine ? "same_machine" : evidence.length > 0 ? "remote_known" : "remote_or_unknown";
+  const localityReason = sameMachine ? localControlPlaneReason || "matched coordinator hostname" : evidence.length > 0 ? `known remote/other machine identity; no local coordinator match (${evidence.join(", ")})` : "no useful machine identity evidence available";
+  return {
+    daemonId,
+    machineId,
+    hostname,
+    machineName,
+    displayName: machineName || hostname || daemonId || machineId,
+    coordinatorHostname,
+    sameMachine,
+    locality,
+    localityReason,
+    identityEvidence: evidence
+  };
+}
+function nodeHasLocalDaemonEvidence(ctx, node) {
+  const isLocal = (session) => {
+    if (!session || typeof session !== "object") return false;
+    if (ctx.localDaemonId && session.settings?.meshCoordinatorDaemonId === ctx.localDaemonId) return true;
+    if (session.launchedByCoordinator === true) return true;
+    if (ctx.localDaemonId && session.runtime?.owner === ctx.localDaemonId) return true;
+    if (ctx.localDaemonId && session.daemonClient?.daemonId === ctx.localDaemonId) return true;
+    return false;
+  };
+  const sessionArrays = [
+    node?.sessions,
+    node?.activeSessions,
+    node?.active_sessions,
+    node?.lastProbe?.sessions,
+    node?.last_probe?.sessions,
+    node?.lastProbe?.status?.sessions,
+    node?.last_probe?.status?.sessions
+  ];
+  for (const arr of sessionArrays) {
+    if (Array.isArray(arr) && arr.some(isLocal)) return true;
+  }
+  const sessionRecords = [
+    node?.activeSession,
+    node?.active_session,
+    node?.currentSession,
+    node?.current_session,
+    node?.runtimeSession,
+    node?.runtime_session,
+    node?.session,
+    node?.lastProbe?.activeSession,
+    node?.last_probe?.active_session,
+    node?.lastProbe?.currentSession,
+    node?.last_probe?.current_session,
+    node?.lastProbe?.session,
+    node?.last_probe?.session
+  ];
+  for (const session of sessionRecords) {
+    if (isLocal(session)) return true;
+  }
+  return false;
 }
 function isDirectLocalNode(ctx, node) {
   const machineId = readNodeMachineId(node);
   const daemonId = readNodeDaemonId(node);
   return Boolean(
-    ctx.localMachineId && machineId === ctx.localMachineId || ctx.localDaemonId && daemonId === ctx.localDaemonId
+    ctx.localMachineId && machineId === ctx.localMachineId || ctx.localDaemonId && daemonId === ctx.localDaemonId || nodeHasLocalDaemonEvidence(ctx, node)
   );
 }
+function isConfiguredCoordinatorNode(ctx, node) {
+  if (!ctx.localMachineId && !ctx.localDaemonId) return false;
+  const nodeId = readString(node.id) || readString(node.nodeId) || readString(node.node_id);
+  if (!nodeId) return false;
+  const nodeDaemonId = readNodeDaemonId(node);
+  const nodeMachineId = readNodeMachineId(node);
+  if (nodeDaemonId && ctx.localDaemonId && nodeDaemonId !== ctx.localDaemonId) return false;
+  if (nodeMachineId && ctx.localMachineId && nodeMachineId !== ctx.localMachineId) return false;
+  const preferredNodeId = readString(ctx.mesh.coordinator?.preferredNodeId) || readString(ctx.mesh.coordinator?.preferred_node_id);
+  if (preferredNodeId) return nodeId === preferredNodeId;
+  const first = ctx.mesh.nodes?.[0];
+  const firstNodeId = readString(first?.id) || readString(first?.nodeId) || readString(first?.node_id);
+  return !!firstNodeId && nodeId === firstNodeId;
+}
+function getLocalControlPlaneMatchReason(ctx, node) {
+  if (isDirectLocalNode(ctx, node)) return "matched coordinator daemon or machine id";
+  if (isConfiguredCoordinatorNode(ctx, node)) return "matched configured coordinator node";
+  if (node.isLocalWorktree === true) {
+    const sourceNode = findClonedFromNode(ctx, node);
+    if (sourceNode && isDirectLocalNode(ctx, sourceNode)) return "matched local cloned-from node";
+    if (sourceNode && isConfiguredCoordinatorNode(ctx, sourceNode)) return "matched configured coordinator source node";
+  }
+  return void 0;
+}
 function findClonedFromNode(ctx, node) {
   const clonedFromNodeId = readString(node.clonedFromNodeId) || readString(node.cloned_from_node_id);
   if (!clonedFromNodeId) return void 0;
   return ctx.mesh.nodes.find((n) => n.id === clonedFromNodeId || n.nodeId === clonedFromNodeId || n.node_id === clonedFromNodeId);
 }
 function isLocalControlPlaneNode(ctx, node) {
-  if (isDirectLocalNode(ctx, node)) return true;
-  if (node.isLocalWorktree === true) {
-    const sourceNode = findClonedFromNode(ctx, node);
-    if (sourceNode && isDirectLocalNode(ctx, sourceNode)) return true;
-  }
-  return false;
+  return !!getLocalControlPlaneMatchReason(ctx, node);
 }
 function meshSessionCacheKey(nodeId, runtimeSessionId) {
   return `${nodeId}:${runtimeSessionId}`;
 }
+function rememberMeshSessionProviderMetadata(nodeId, runtimeSessionId, metadata) {
+  const keyNodeId = readString(nodeId);
+  const keySessionId = readString(runtimeSessionId);
+  if (!keyNodeId || !keySessionId) return;
+  const providerType = readString(metadata.providerType);
+  const providerSessionId = readString(metadata.providerSessionId);
+  if (!providerType && !providerSessionId) return;
+  const existing = getSessionMetadata(meshSessionCacheKey(keyNodeId, keySessionId)) || { providerType: "" };
+  meshSessionProviderMetadata.set(meshSessionCacheKey(keyNodeId, keySessionId), {
+    providerType: providerType || existing.providerType,
+    providerSessionId: providerSessionId || existing.providerSessionId,
+    expiresAt: Date.now() + SESSION_PROVIDER_METADATA_TTL_MS
+  });
+}
+function rememberMeshSessionProviderMetadataFromEvent(event) {
+  const metadataEvent = event?.metadataEvent && typeof event.metadataEvent === "object" ? event.metadataEvent : event && typeof event === "object" ? event : {};
+  const nodeId = readString(event?.nodeId) || readString(metadataEvent.nodeId) || readString(metadataEvent.meshNodeId);
+  const sessionId = readString(metadataEvent.targetSessionId) || readString(metadataEvent.sessionId) || readString(metadataEvent.instanceId) || readString(event?.sessionId);
+  rememberMeshSessionProviderMetadata(nodeId, sessionId, {
+    providerType: readString(metadataEvent.providerType) || readString(event?.providerType) || "",
+    providerSessionId: readString(metadataEvent.providerSessionId) || readString(event?.providerSessionId)
+  });
+}
+function resolveMeshSessionProviderMetadataFromLedger(ctx, nodeId, runtimeSessionId) {
+  const entries = (0, import_daemon_core.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 : {};
+    const entryNodeId = readString(entry.nodeId) || readString(payload.nodeId) || readString(payload.meshNodeId);
+    if (entryNodeId && entryNodeId !== nodeId) continue;
+    const entrySessionId = readString(entry.sessionId) || readString(payload.targetSessionId) || readString(payload.sessionId) || readString(payload.instanceId);
+    if (entrySessionId !== runtimeSessionId) continue;
+    const providerType = readString(entry.providerType) || readString(payload.providerType);
+    const completionDiagnostic = payload.completionDiagnostic && typeof payload.completionDiagnostic === "object" && !Array.isArray(payload.completionDiagnostic) ? payload.completionDiagnostic : {};
+    const metadataEvent = payload.metadataEvent && typeof payload.metadataEvent === "object" && !Array.isArray(payload.metadataEvent) ? payload.metadataEvent : {};
+    const providerSessionId = readString(payload.providerSessionId) || readString(completionDiagnostic.providerSessionId) || readString(metadataEvent.providerSessionId);
+    if (providerType || providerSessionId) {
+      return { providerType: providerType || "", providerSessionId };
+    }
+  }
+  return void 0;
+}
+function resolveMeshSessionProviderMetadata(ctx, nodeId, runtimeSessionId) {
+  const cached = getSessionMetadata(meshSessionCacheKey(nodeId, runtimeSessionId));
+  if (cached?.providerType || cached?.providerSessionId) return cached;
+  const fromLedger = resolveMeshSessionProviderMetadataFromLedger(ctx, nodeId, runtimeSessionId);
+  if (fromLedger) rememberMeshSessionProviderMetadata(nodeId, runtimeSessionId, fromLedger);
+  return fromLedger;
+}
 function countUncommittedChanges(status) {
   if (typeof status?.uncommittedChanges === "number") return status.uncommittedChanges;
   const keys = ["staged", "modified", "untracked", "deleted", "renamed"];
@@ -902,6 +1346,20 @@ function isGitStatusDirty(status) {
   if (typeof status?.dirty === "boolean") return status.dirty;
   return countUncommittedChanges(status) > 0;
 }
+function slimLedgerPayload(payload) {
+  const slim = {};
+  for (const [k, v] of Object.entries(payload)) {
+    if (k === "message" || k === "taskSummary") {
+      slim[k] = typeof v === "string" && v.length > 200 ? v.slice(0, 200) + "\u2026" : v;
+    } else if (k === "evidence" || k === "workerResult" || k === "gitStatus" || k === "validationResults") {
+    } else if (k === "finalSummary") {
+      slim[k] = typeof v === "string" && v.length > 300 ? v.slice(0, 300) + "\u2026" : v;
+    } else {
+      slim[k] = v;
+    }
+  }
+  return slim;
+}
 function readRelatedRepos(node) {
   const raw = Array.isArray(node.relatedRepos) ? node.relatedRepos : Array.isArray(node.policy?.relatedRepos) ? node.policy.relatedRepos : [];
   return raw.map((entry) => ({
@@ -960,6 +1418,16 @@ function missingProviderPriorityMessage(nodeId) {
   return `Node '${nodeId}' has no providerPriority policy; pass type explicitly or configure node.policy.providerPriority`;
 }
 function getNodeLaunchReadiness(node) {
+  const bootstrap = node.worktreeBootstrap;
+  if (node.isLocalWorktree && bootstrap?.status === "failed" && bootstrap?.required !== false) {
+    return {
+      providerPriority: readProviderPriority(node.policy),
+      launchReady: false,
+      launchBlockedReason: "worktree_bootstrap_failed",
+      launchBlockedMessage: typeof bootstrap.error === "string" && bootstrap.error.trim() ? bootstrap.error.trim() : "Required worktree bootstrap failed; resolve it before launching an agent into this node.",
+      worktreeBootstrap: bootstrap
+    };
+  }
   const providerPriority = readProviderPriority(node.policy);
   if (providerPriority.length) {
     return {
@@ -974,6 +1442,33 @@ function getNodeLaunchReadiness(node) {
     launchBlockedMessage: missingProviderPriorityMessage(node.id)
   };
 }
+function getWorktreeBootstrapLaunchBlock(node) {
+  const bootstrap = node.worktreeBootstrap;
+  if (!node.isLocalWorktree || bootstrap?.status !== "failed" || bootstrap?.required === false) return void 0;
+  return {
+    success: false,
+    code: "worktree_bootstrap_failed",
+    error: typeof bootstrap.error === "string" && bootstrap.error.trim() ? bootstrap.error.trim() : `Node '${node.id}' has a failed required worktree bootstrap.`,
+    nodeId: node.id,
+    worktreeBootstrap: bootstrap,
+    recoveryHint: "Fix the configured worktree bootstrap command or remove/recreate the worktree node before launching an agent."
+  };
+}
+async function collectLiveStatusSessions(ctx, node) {
+  try {
+    const statusResult = await commandForNode(ctx, node, "get_status_metadata", {});
+    return extractStatusMetadataSessions(statusResult);
+  } catch {
+    return [];
+  }
+}
+async function collectMeshViewQueueNodesWithLiveSessions(ctx) {
+  const nodes = await Promise.all(ctx.mesh.nodes.map(async (node) => {
+    const liveSessions = await collectLiveStatusSessions(ctx, node);
+    return liveSessions.length > 0 ? { ...node, sessions: liveSessions } : node;
+  }));
+  return nodes;
+}
 function readNumeric(value, fallback = 0) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : fallback;
@@ -1109,7 +1604,8 @@ async function commandForNode(ctx, node, command, args = {}) {
   if (isLocalTransport(ctx.transport)) {
     return ctx.transport.command(command, args);
   }
-  throw new Error(`Command '${command}' requires daemon IPC/local transport for node '${node.id}'`);
+  const identity = buildNodeMachineIdentity(ctx, node);
+  throw new Error(`Command '${command}' requires daemon IPC/local transport for node '${node.id}' (hostname=${identity.hostname || "unknown"}, coordinatorHostname=${identity.coordinatorHostname || "unknown"}, sameMachine=${identity.sameMachine})`);
 }
 function normalizePendingMeshCoordinatorEvents(value) {
   const payload = unwrapCommandPayload(value);
@@ -1127,6 +1623,14 @@ function buildMeshForwardPayloadFromPendingEvent(event) {
     providerType: readString(metadataEvent.providerType),
     providerSessionId: readString(metadataEvent.providerSessionId),
     finalSummary: readString(metadataEvent.finalSummary) || readString(metadataEvent.summary),
+    jobId: readString(metadataEvent.jobId),
+    interactionId: readString(metadataEvent.interactionId),
+    status: readString(metadataEvent.status),
+    targetDaemonId: readString(metadataEvent.targetDaemonId),
+    startedAt: readString(metadataEvent.startedAt),
+    completedAt: readString(metadataEvent.completedAt),
+    retryOfJobId: readString(metadataEvent.retryOfJobId),
+    ...metadataEvent.result && typeof metadataEvent.result === "object" && !Array.isArray(metadataEvent.result) ? { result: metadataEvent.result } : {},
     ...metadataEvent.intentional === true ? { intentional: true } : {},
     ...metadataEvent.intentionalStop === true ? { intentionalStop: true } : {},
     ...metadataEvent.operatorCleanup === true ? { operatorCleanup: true } : {},
@@ -1143,8 +1647,9 @@ async function drainCoordinatorPendingEvents(ctx, opts) {
     const surfacedEvents = [];
     try {
       surfacedEvents.push(
-        ...normalizePendingMeshCoordinatorEvents(await ctx.transport.command("get_pending_mesh_events", {})).filter(matchesCurrentMesh)
+        ...normalizePendingMeshCoordinatorEvents(await ctx.transport.command("get_pending_mesh_events", { meshId: ctx.mesh.id })).filter(matchesCurrentMesh)
       );
+      surfacedEvents.forEach(rememberMeshSessionProviderMetadataFromEvent);
     } catch {
     }
     for (const node of ctx.mesh.nodes) {
@@ -1152,27 +1657,31 @@ async function drainCoordinatorPendingEvents(ctx, opts) {
       if (requestedNodeIds && !requestedNodeIds.has(node.id)) continue;
       try {
         const remoteEvents = normalizePendingMeshCoordinatorEvents(
-          await ctx.transport.meshCommand(node.daemonId, "get_pending_mesh_events", {})
+          await ctx.transport.meshCommand(node.daemonId, "get_pending_mesh_events", { meshId: ctx.mesh.id })
         ).filter(matchesCurrentMesh);
         if (remoteEvents.length === 0) continue;
         for (const event of remoteEvents) {
           const payload = buildMeshForwardPayloadFromPendingEvent(event);
           if (!payload.event || !payload.meshId) continue;
           await ctx.transport.command("mesh_forward_event", payload);
+          rememberMeshSessionProviderMetadataFromEvent({ ...event, metadataEvent: payload });
         }
       } catch {
       }
     }
     try {
       surfacedEvents.push(
-        ...normalizePendingMeshCoordinatorEvents(await ctx.transport.command("get_pending_mesh_events", {})).filter(matchesCurrentMesh)
+        ...normalizePendingMeshCoordinatorEvents(await ctx.transport.command("get_pending_mesh_events", { meshId: ctx.mesh.id })).filter(matchesCurrentMesh)
       );
+      surfacedEvents.forEach(rememberMeshSessionProviderMetadataFromEvent);
     } catch {
     }
     return surfacedEvents;
   }
   if (isLocalTransport(ctx.transport)) {
-    return (0, import_daemon_core.drainPendingMeshCoordinatorEvents)().filter(matchesCurrentMesh);
+    const events = (0, import_daemon_core.drainPendingMeshCoordinatorEvents)(ctx.mesh.id, ctx.localDaemonId).filter(matchesCurrentMesh);
+    events.forEach(rememberMeshSessionProviderMetadataFromEvent);
+    return events;
   }
   return [];
 }
@@ -1189,11 +1698,12 @@ function buildRemoveNodeArgs(ctx, nodeId, sessionCleanupMode) {
 }
 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.",
+  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. 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: {
-      _gemini_compat: { type: "string", description: "Dummy property for Gemini compatibility. Ignore this." }
+      _gemini_compat: { type: "string", description: "Dummy property for Gemini compatibility. Ignore this." },
+      includeStaleDirectWorkDetails: { type: "boolean", description: "Opt in to the full staleDirectWork array. Defaults false; normal status returns compact staleDirectWorkSummary only." }
     }
   }
 };
@@ -1213,14 +1723,18 @@ var MESH_ENQUEUE_TASK_TOOL = {
   inputSchema: {
     type: "object",
     properties: {
-      message: { type: "string", description: "The task instruction for the agent." }
+      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. live_debug_readonly rejects obvious write/commit/push/deploy/destructive instructions before dispatch." },
+      taskMode: { type: "string", enum: ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"], description: "CamelCase alias for task_mode." },
+      requiredTags: { type: "array", items: { type: "string" }, description: "Optional capability tags that every eligible node must have, e.g. os=darwin, provider=codex-cli, gpu." },
+      required_tags: { type: "array", items: { type: "string" }, description: "Snake_case alias for requiredTags." }
     },
     required: ["message"]
   }
 };
 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.",
+  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.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1273,7 +1787,9 @@ var MESH_SEND_TASK_TOOL = {
     properties: {
       node_id: { type: "string", description: "Target node ID (from mesh_list_nodes)." },
       session_id: { type: "string", description: "Agent session ID on the target node." },
-      message: { type: "string", description: "Natural-language task to send to the agent." }
+      message: { type: "string", description: "Natural-language task to send to the agent." },
+      task_mode: { type: "string", enum: ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"], description: "Optional task-mode contract. live_debug_readonly rejects obvious write/commit/push/deploy/destructive instructions before local or remote direct dispatch." },
+      taskMode: { type: "string", enum: ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"], description: "CamelCase alias for task_mode." }
     },
     required: ["node_id", "session_id", "message"]
   }
@@ -1331,6 +1847,21 @@ var MESH_GIT_STATUS_TOOL = {
     required: ["node_id"]
   }
 };
+var MESH_FAST_FORWARD_NODE_TOOL = {
+  name: "mesh_fast_forward_node",
+  description: "Safely dry-run or execute an obvious direct fast-forward for a mesh node without launching an agent session. Defaults to dry-run; execution requires execute=true. Never pushes, rebases, resets, cleans, or checks out arbitrary revisions.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Target node ID." },
+      branch: { type: "string", description: "Optional guard: require the node's current branch to match this branch before planning/executing." },
+      execute: { type: "boolean", description: "When true, apply the fast-forward if all safety gates pass. Defaults false/dry-run." },
+      dry_run: { type: "boolean", description: "Preview only. Defaults true unless execute=true; dry_run=true overrides execute." },
+      update_submodules: { type: "boolean", description: "When true, if the root fast-forward changes gitlinks, run only git submodule update --init --recursive and verify submodules clean." }
+    },
+    required: ["node_id"]
+  }
+};
 var MESH_CHECKPOINT_TOOL = {
   name: "mesh_checkpoint",
   description: "Create a git checkpoint (commit) on a mesh node workspace.",
@@ -1414,7 +1945,7 @@ var MESH_TASK_HISTORY_TOOL = {
     type: "object",
     properties: {
       tail: { type: "number", description: "Number of recent entries to return (default: 20)." },
-      kind: { type: "string", description: "Filter by entry kind: task_dispatched, task_completed, task_failed, task_stalled, session_launched, checkpoint_created, node_cloned, node_removed." }
+      kind: { type: "string", description: "Filter by entry kind: task_dispatched, task_completed, task_failed, task_stalled, session_launched, checkpoint_created, node_cloned, node_removed, direct_fast_forward." }
     }
   }
 };
@@ -1434,7 +1965,7 @@ var MESH_RECONCILE_LEDGER_TOOL = {
 };
 var MESH_REFINE_NODE_TOOL = {
   name: "mesh_refine_node",
-  description: "The Refinery: Automatically validate and merge a completed worktree node back into its base branch. This tool automates the validation gate and merge queue step. It will merge the node's branch into its base branch and cleanly remove the worktree node and its sessions.",
+  description: "The Refinery: Accept an async validation/merge/cleanup job for a completed worktree node. 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.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1443,6 +1974,43 @@ var MESH_REFINE_NODE_TOOL = {
     required: ["node_id"]
   }
 };
+var MESH_REFINE_CONFIG_SCHEMA_TOOL = {
+  name: "mesh_refine_config_schema",
+  description: "Return the Repo Mesh Refinery config JSON schema and supported repo-local config locations. This is the validation source of truth; heuristic command detection is suggestions-only.",
+  inputSchema: { type: "object", properties: {} }
+};
+var MESH_VALIDATE_REFINE_CONFIG_TOOL = {
+  name: "mesh_validate_refine_config",
+  description: "Validate the repo mesh/refine config for a node/workspace without running validation commands or merging.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Optional node/workspace whose refine config should be loaded. Defaults to the first mesh node." },
+      config: { type: "object", description: "Optional inline config object to validate instead of loading from the repo." }
+    }
+  }
+};
+var MESH_SUGGEST_REFINE_CONFIG_TOOL = {
+  name: "mesh_suggest_refine_config",
+  description: "Suggest a repo mesh/refine config scaffold from project context/package scripts. Suggestions are never executed until saved as explicit refine config.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Optional node/workspace used for suggestions. Defaults to the first mesh node." }
+    }
+  }
+};
+var MESH_REFINE_PLAN_TOOL = {
+  name: "mesh_refine_plan",
+  description: "Dry-run Refinery plan for a worktree node: reports config source, validation commands, suggestions/unavailable reason, and merge/cleanup intent without executing validation or git merge.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Node ID of the worktree node to plan." }
+    },
+    required: ["node_id"]
+  }
+};
 var ALL_MESH_TOOLS = [
   MESH_STATUS_TOOL,
   MESH_LIST_NODES_TOOL,
@@ -1455,24 +2023,31 @@ var ALL_MESH_TOOLS = [
   MESH_READ_DEBUG_TOOL,
   MESH_LAUNCH_SESSION_TOOL,
   MESH_GIT_STATUS_TOOL,
+  MESH_FAST_FORWARD_NODE_TOOL,
   MESH_CHECKPOINT_TOOL,
   MESH_APPROVE_TOOL,
   MESH_CLONE_NODE_TOOL,
   MESH_REMOVE_NODE_TOOL,
   MESH_REFINE_NODE_TOOL,
+  MESH_REFINE_CONFIG_SCHEMA_TOOL,
+  MESH_VALIDATE_REFINE_CONFIG_TOOL,
+  MESH_SUGGEST_REFINE_CONFIG_TOOL,
+  MESH_REFINE_PLAN_TOOL,
   MESH_CLEANUP_SESSIONS_TOOL,
   MESH_TASK_HISTORY_TOOL,
   MESH_RECONCILE_LEDGER_TOOL
 ];
-async function meshStatus(ctx) {
+async function meshStatus(ctx, args = {}) {
   await refreshMeshFromDaemon(ctx);
   const { mesh, transport } = ctx;
-  const results = [];
   const ledgerSummary = (0, import_daemon_core.getLedgerSummary)(mesh.id);
-  for (const node of mesh.nodes) {
+  const results = await Promise.all(mesh.nodes.map(async (node) => {
     const entry = {
       nodeId: node.id,
       workspace: node.workspace,
+      machine: buildNodeMachineIdentity(ctx, node),
+      daemonId: readNodeDaemonId(node),
+      machineId: readNodeMachineId(node),
       ...getNodeLaunchReadiness(node)
     };
     try {
@@ -1482,6 +2057,7 @@ async function meshStatus(ctx) {
         const uncommittedChanges = countUncommittedChanges(status);
         const dirty = isGitStatusDirty(status);
         entry.health = status?.isGitRepo ? dirty ? "dirty" : "online" : "degraded";
+        assignFullGitSnapshot(entry, status);
         entry.branch = status?.branch;
         entry.isDirty = dirty;
         entry.uncommittedChanges = uncommittedChanges;
@@ -1503,6 +2079,7 @@ async function meshStatus(ctx) {
         const uncommittedChanges = countUncommittedChanges(status);
         const dirty = isGitStatusDirty(status);
         entry.health = status?.isGitRepo ? dirty ? "dirty" : "online" : "degraded";
+        assignFullGitSnapshot(entry, status);
         entry.branch = status?.branch;
         entry.isDirty = dirty;
         entry.uncommittedChanges = uncommittedChanges;
@@ -1538,7 +2115,7 @@ async function meshStatus(ctx) {
     if (recoveryContext.consecutiveNodeFailures > 0) {
       entry.recoveryHints = {
         consecutiveFailures: recoveryContext.consecutiveNodeFailures,
-        lastTaskMessage: recoveryContext.lastTaskMessage,
+        lastTaskMessage: typeof recoveryContext.lastTaskMessage === "string" ? recoveryContext.lastTaskMessage.slice(0, 100) + (recoveryContext.lastTaskMessage.length > 100 ? "\u2026" : "") : recoveryContext.lastTaskMessage,
         advice: recoveryContext.advice,
         retryRecommended: recoveryContext.retryRecommended
       };
@@ -1578,7 +2155,47 @@ async function meshStatus(ctx) {
     }
     const relatedRepos = await collectRelatedRepoStatuses(ctx, node);
     if (relatedRepos.length) entry.relatedRepos = relatedRepos;
-    results.push(entry);
+    const liveSessions = await collectLiveStatusSessions(ctx, node);
+    if (liveSessions.length > 0) {
+      entry.sessions = liveSessions.map((s) => {
+        const coordinatorMeshId = typeof s.coordinator?.meshId === "string" ? s.coordinator.meshId : void 0;
+        const isSelfCoordinator = coordinatorMeshId === mesh.id;
+        return {
+          id: s.instanceId ?? s.id ?? s.sessionId,
+          status: s.status ?? s.lifecycle ?? s.state,
+          providerType: s.providerType ?? s.cliType ?? s.type,
+          ...s.activeChat?.status ? { chatStatus: s.activeChat.status } : {},
+          ...isSelfCoordinator ? { isSelfCoordinator: true, role: "coordinator" } : {}
+        };
+      }).filter((s) => s.id);
+    }
+    return entry;
+  }));
+  const ledgerEntries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail: 200 });
+  const activeWorkEvidence = (0, import_daemon_core.buildMeshActiveWork)({
+    meshId: mesh.id,
+    queue: (0, import_daemon_core.getQueue)(mesh.id),
+    ledgerEntries,
+    nodes: results
+  });
+  const pollingGuidance = buildActiveWorkPollingGuidance(activeWorkEvidence.summary);
+  const staleDirectWorkSummary = (0, import_daemon_core.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."
+  });
+  const coordinatorSessions = [];
+  for (const nodeEntry of results) {
+    const sessions = Array.isArray(nodeEntry.sessions) ? nodeEntry.sessions : [];
+    for (const s of sessions) {
+      if (s?.isSelfCoordinator === true && s.id) {
+        coordinatorSessions.push({
+          nodeId: nodeEntry.nodeId,
+          sessionId: s.id,
+          providerType: s.providerType,
+          status: s.status
+        });
+      }
+    }
   }
   const response = {
     meshId: mesh.id,
@@ -1586,8 +2203,29 @@ async function meshStatus(ctx) {
     repoIdentity: mesh.repoIdentity,
     policy: mesh.policy,
     refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceOfTruth: {
+      membership: "coordinator_daemon_live_mesh",
+      currentStatus: "live_git_and_session_probes",
+      activeWork: "mesh_queue_file_and_local_ledger",
+      historicalEvidenceOnly: ["recoveryHints", "ledgerSummary"]
+    },
     nodes: results,
-    branchConvergenceSummary: summarizeBranchConvergence(results)
+    activeWork: activeWorkEvidence.activeWork,
+    staleDirectWorkSummary,
+    ...args.includeStaleDirectWorkDetails === true ? { staleDirectWork: activeWorkEvidence.staleDirectWork } : {},
+    // terminalDirectWork is historical (completed/failed direct dispatches) — opt-in only.
+    ...args.includeTerminalDirectWork === true ? { terminalDirectWork: activeWorkEvidence.terminalDirectWork } : {},
+    activeWorkSummary: activeWorkEvidence.summary,
+    ...pollingGuidance ? { pollingGuidance } : {},
+    branchConvergenceSummary: summarizeBranchConvergence(results),
+    ...coordinatorSessions.length > 0 ? {
+      coordinatorSessions,
+      selfIdentification: {
+        meshId: mesh.id,
+        coordinatorSessions,
+        note: "Sessions listed here are coordinator sessions for this mesh. The calling coordinator IS one of these sessions \u2014 do not treat its own generating CLI session as a foreign delegated task. Per-session marker: sessions[].isSelfCoordinator === true."
+      }
+    } : {}
   };
   try {
     response.ledgerSummary = ledgerSummary;
@@ -1595,6 +2233,14 @@ async function meshStatus(ctx) {
   }
   try {
     const pendingEvents = await drainCoordinatorPendingEvents(ctx);
+    const asyncRefineJobs = (0, import_daemon_core.buildMeshAsyncRefineJobs)({
+      meshId: mesh.id,
+      ledgerEntries,
+      pendingEvents
+    });
+    if (asyncRefineJobs.length > 0) {
+      response.asyncRefineJobs = asyncRefineJobs;
+    }
     if (pendingEvents.length > 0) {
       response.pendingCoordinatorEvents = pendingEvents;
     }
@@ -1604,12 +2250,21 @@ async function meshStatus(ctx) {
 }
 async function meshTaskHistory(ctx, args) {
   const { mesh } = ctx;
-  await drainCoordinatorPendingEvents(ctx);
+  const pendingEvents = await drainCoordinatorPendingEvents(ctx);
   const tail = typeof args.tail === "number" && args.tail > 0 ? args.tail : 20;
   const kind = typeof args.kind === "string" && args.kind.trim() ? [args.kind.trim()] : void 0;
-  const entries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail, kind });
+  const rawEntries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail, kind });
+  const entries = rawEntries.map((e) => ({
+    ...e,
+    payload: e.payload ? slimLedgerPayload(e.payload) : e.payload
+  }));
   const summary = (0, import_daemon_core.getLedgerSummary)(mesh.id);
-  return JSON.stringify({ meshId: mesh.id, entries, summary }, null, 2);
+  return JSON.stringify({
+    meshId: mesh.id,
+    entries,
+    summary,
+    ...pendingEvents.length > 0 ? { pendingCoordinatorEvents: pendingEvents } : {}
+  }, null, 2);
 }
 async function meshReconcileLedger(ctx, args) {
   await refreshMeshFromDaemon(ctx);
@@ -1699,6 +2354,9 @@ async function meshListNodes(ctx) {
       nodeId: n.id,
       workspace: n.workspace,
       repoRoot: n.repoRoot,
+      daemonId: readNodeDaemonId(n),
+      machineId: readNodeMachineId(n),
+      machine: buildNodeMachineIdentity(ctx, n),
       isLocalWorktree: n.isLocalWorktree,
       policy: n.policy,
       relatedRepos: readRelatedRepos(n),
@@ -1708,12 +2366,14 @@ async function meshListNodes(ctx) {
   }, null, 2);
 }
 async function meshEnqueueTask(ctx, args) {
+  const taskMode = readString(args.task_mode) || readString(args.taskMode);
+  const requiredTags = (0, import_daemon_core.normalizeMeshCapabilityTags)(Array.isArray(args.requiredTags) ? args.requiredTags : args.required_tags);
   try {
-    const task = (0, import_daemon_core.enqueueTask)(ctx.mesh.id, args.message);
+    const task = (0, import_daemon_core.enqueueTask)(ctx.mesh.id, args.message, { taskMode, requiredTags });
     if (isLocalTransport(ctx.transport) && !(ctx.transport instanceof IpcTransport)) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
-      return JSON.stringify({ success: true, taskId: task.id, status: task.status });
+      return JSON.stringify({ success: true, source: "queue", taskId: task.id, status: task.status, taskMode: task.taskMode, requiredTags: task.requiredTags });
     }
     if (ctx.transport instanceof IpcTransport) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
@@ -1722,43 +2382,97 @@ async function meshEnqueueTask(ctx, args) {
       for (const node of ctx.mesh.nodes) {
         const isLocalNode = isLocalControlPlaneNode(ctx, node);
         if (isLocalNode || !node.daemonId) continue;
+        if (!(0, import_daemon_core.nodeSatisfiesRequiredTags)(requiredTags, (0, import_daemon_core.buildMeshNodeCapabilityTags)(node))) continue;
         dispatchPromises.push(
           ipcDispatchToRemoteAgent(ctx, node, { message: args.message }).then((result) => {
             if (result.success) {
               try {
+                const providerType = result.providerType;
+                const descriptor = summarizeTaskMessage(args.message);
                 (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
                   kind: "task_dispatched",
                   nodeId: node.id,
                   sessionId: result.sessionId,
-                  payload: { message: args.message, via: "p2p_direct", taskId: task.id }
+                  providerType,
+                  payload: {
+                    source: "queue",
+                    via: "p2p_direct",
+                    taskId: task.id,
+                    message: args.message,
+                    taskTitle: descriptor.taskTitle,
+                    taskSummary: descriptor.taskSummary,
+                    ...task.taskMode ? { taskMode: task.taskMode } : {},
+                    ...providerType ? { providerType } : {},
+                    targetSessionId: result.sessionId
+                  }
                 });
               } catch {
               }
             }
-          }).catch(() => {
+          }).catch((err) => {
+            try {
+              (0, import_daemon_core.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 {
+            }
           })
         );
       }
       Promise.all(dispatchPromises).catch(() => {
       });
-      return JSON.stringify({ success: true, taskId: task.id, status: task.status });
+      return JSON.stringify({ success: true, source: "queue", taskId: task.id, status: task.status, taskMode: task.taskMode, requiredTags: task.requiredTags });
     }
-    return JSON.stringify({ success: true, taskId: task.id, status: task.status });
+    return JSON.stringify({ success: true, source: "queue", taskId: task.id, status: task.status, taskMode: task.taskMode, requiredTags: task.requiredTags });
   } catch (e) {
-    return JSON.stringify({ success: false, error: e.message });
+    const message = e?.message || String(e);
+    if (message.includes("live_debug_readonly_guardrail_violation")) {
+      return JSON.stringify({ success: false, code: "live_debug_readonly_guardrail_violation", taskMode, error: message });
+    }
+    return JSON.stringify({ success: false, error: message });
   }
 }
 async function meshViewQueue(ctx, args) {
   try {
+    await refreshMeshFromDaemon(ctx);
     const statusFilter = sanitizeQueueStatusFilter(args.status);
     const view = normalizeQueueViewMode(args.view);
-    const fullQueue = annotateQueueStaleness((0, import_daemon_core.getQueue)(ctx.mesh.id), ctx.mesh);
+    const fullQueue = prioritizeActiveQueueRows(annotateQueueStaleness((0, import_daemon_core.getQueue)(ctx.mesh.id), ctx.mesh));
     const queue = filterQueueForView(fullQueue, view, statusFilter);
     const summary = buildQueueStatusSummary(fullQueue);
     const visibleSummary = buildQueueStatusSummary(queue);
     const maintenance = buildQueueMaintenanceReport(fullQueue);
+    const liveNodes = await collectMeshViewQueueNodesWithLiveSessions(ctx);
+    (0, import_daemon_core.markStaleDirectDispatches)(ctx.mesh.id);
+    const ledgerEntries = (0, import_daemon_core.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
+    const directDispatches = (0, import_daemon_core.getActiveDirectDispatches)(ctx.mesh.id);
+    const activeWorkEvidence = (0, import_daemon_core.buildMeshActiveWork)({
+      meshId: ctx.mesh.id,
+      queue: fullQueue,
+      ledgerEntries,
+      // Always pass BeadsDB records (may be empty). buildMeshActiveWork uses them for local
+      // dispatches and falls through to ledger scan for remote P2P dispatches not in BeadsDB.
+      directDispatches,
+      nodes: liveNodes
+    });
+    const recentDispatchFailures = ledgerEntries.filter((e) => e.kind === "p2p_dispatch_failed").slice(-20).map((e) => ({
+      nodeId: e.nodeId,
+      taskId: e.payload?.taskId,
+      error: e.payload?.error,
+      via: e.payload?.via,
+      failedAt: e.payload?.dispatchFailedAt || e.timestamp
+    }));
     const staleAssignedTasks = maintenance.staleAssignedTasks || [];
     const requestedHistoricalRows = queue.some((task) => HISTORICAL_QUEUE_STATUSES.has(String(task?.status || "")));
+    const pollingGuidance = buildActiveWorkPollingGuidance(activeWorkEvidence.summary);
     return JSON.stringify({
       success: true,
       sourceOfTruth: {
@@ -1773,21 +2487,20 @@ async function meshViewQueue(ctx, args) {
         filtered: Boolean(statusFilter?.length) || view !== "all"
       },
       queue,
-      visibleQueue: queue,
-      visibleSummary,
+      activeWork: activeWorkEvidence.activeWork,
+      staleDirectWork: activeWorkEvidence.staleDirectWork,
+      activeWorkSummary: activeWorkEvidence.summary,
+      ...pollingGuidance ? { pollingGuidance } : {},
       summary,
-      activeCounts: summary.activeCounts,
-      historicalCounts: summary.historicalCounts,
-      activeCount: summary.activeCount,
-      historicalCount: summary.historicalCount,
-      visibleActiveCounts: visibleSummary.activeCounts,
-      visibleHistoricalCounts: visibleSummary.historicalCounts,
-      visibleActiveCount: visibleSummary.activeCount,
-      visibleHistoricalCount: visibleSummary.historicalCount,
       staleAssignedTasks,
       staleAssignedCount: maintenance.staleAssignedCount,
       queueMaintenance: maintenance,
       cleanupDryRun: maintenance,
+      ...recentDispatchFailures.length > 0 ? {
+        recentDispatchFailures,
+        dispatchFailureCount: recentDispatchFailures.length,
+        dispatchFailureNote: "Remote P2P dispatch attempts that failed. Affected tasks remain pending and may require mesh_queue_requeue if no idle session picks them up."
+      } : {},
       ...view === "active" || statusFilter?.some((status) => ACTIVE_QUEUE_STATUSES.has(status)) ? {
         activeQueue: queue.filter((task) => ACTIVE_QUEUE_STATUSES.has(String(task?.status || "")))
       } : {},
@@ -1807,6 +2520,10 @@ async function meshQueueCancel(ctx, args) {
     if (!taskId) return JSON.stringify({ success: false, error: "task_id required" });
     const task = (0, import_daemon_core.cancelTask)(ctx.mesh.id, taskId, { reason: args.reason });
     if (!task) return JSON.stringify({ success: false, error: `Queue task '${taskId}' not found` });
+    if (isLocalTransport(ctx.transport)) {
+      ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
+      });
+    }
     return JSON.stringify({ success: true, task }, null, 2);
   } catch (e) {
     return JSON.stringify({ success: false, error: e.message });
@@ -1837,10 +2554,60 @@ async function meshQueueRequeue(ctx, args) {
   }
 }
 async function meshSendTask(ctx, args) {
+  const requestedTaskMode = readString(args.task_mode) || readString(args.taskMode);
+  const modeValidation = (0, import_daemon_core.validateMeshTaskModeRequest)(requestedTaskMode, args.message);
+  if (!modeValidation.valid) {
+    return JSON.stringify({
+      success: false,
+      code: "live_debug_readonly_guardrail_violation",
+      taskMode: modeValidation.taskMode || requestedTaskMode,
+      violations: modeValidation.violations,
+      allowedOperations: modeValidation.allowedOperations,
+      error: `live_debug_readonly_guardrail_violation: forbidden operations (${modeValidation.violations.join(", ")})`
+    });
+  }
+  const taskMode = modeValidation.taskMode;
   const node = await findNodeWithRefresh(ctx, args.node_id);
   if (node.policy?.readOnly) {
     return JSON.stringify({ error: `Node '${args.node_id}' is read-only` });
   }
+  let explicitTargetSession;
+  if (args.session_id && isWorkerTaskMode(taskMode) && (ctx.transport instanceof IpcTransport || isLocalTransport(ctx.transport))) {
+    try {
+      const statusResult = await commandForNode(ctx, node, "get_status_metadata", {});
+      const sessions = extractStatusMetadataSessions(statusResult);
+      explicitTargetSession = sessions.find((session) => readSessionRecordId(session) === args.session_id);
+      if (explicitTargetSession && isMeshCoordinatorSessionRecord(explicitTargetSession)) {
+        return JSON.stringify({
+          success: false,
+          recoverable: true,
+          code: "mesh_target_session_is_coordinator",
+          reason: "mesh_target_session_is_coordinator",
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          taskMode: taskMode || "unspecified",
+          error: `Session '${args.session_id}' is a Repo Mesh coordinator session, not a visible worker session. Launch or use a visible worker session before dispatching this task.`,
+          nextAction: `Call mesh_launch_session for node '${args.node_id}' and then retry mesh_send_task with that worker session_id, or use mesh_enqueue_task for queue-based worker assignment.`
+        });
+      }
+      if (explicitTargetSession && isUnmanagedSessionRecord(explicitTargetSession)) {
+        return JSON.stringify({
+          success: false,
+          recoverable: true,
+          code: "mesh_target_session_unmanaged",
+          reason: "mesh_target_session_unmanaged",
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          taskMode: taskMode || "unspecified",
+          unsafeTranscriptAlias: true,
+          error: `Session '${args.session_id}' on node '${args.node_id}' has no Repo Mesh delegation metadata (missing meshNodeFor/meshCoordinatorFor/launchedByCoordinator). It may be the coordinator's own session or an unrelated session \u2014 dispatching risks self-send and orphaned completion events that never reach the coordinator ledger.`,
+          nextAction: `Call mesh_launch_session for node '${args.node_id}' to start a fresh managed worker session, then retry mesh_send_task with the returned session_id. Alternatively use mesh_enqueue_task for queue-based assignment without specifying session_id.`
+        });
+      }
+    } catch {
+      explicitTargetSession = void 0;
+    }
+  }
   const duplicate = hasRecentDuplicateDispatch(ctx, args);
   if (duplicate.duplicate) {
     return JSON.stringify({
@@ -1864,47 +2631,162 @@ async function meshSendTask(ctx, args) {
       const res = await ctx.transport.meshEnqueueTask(node.daemonId, {
         meshId: ctx.mesh.id,
         message: args.message,
-        targetNodeId: args.node_id
+        targetNodeId: args.node_id,
+        ...taskMode ? { taskMode } : {}
       });
       return JSON.stringify(res);
     }
     const isLocalNode = isLocalControlPlaneNode(ctx, node);
     if (ctx.transport instanceof IpcTransport && node.daemonId && !isLocalNode) {
-      const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id || ""));
+      const cached = getSessionMetadata(meshSessionCacheKey(args.node_id, args.session_id || ""));
+      const taskId = (0, import_node_crypto.randomUUID)();
       const result2 = await ipcDispatchToRemoteAgent(ctx, node, {
         session_id: args.session_id,
         message: args.message,
-        providerType: cached?.providerType
+        providerType: cached?.providerType,
+        verifiedSession: explicitTargetSession,
+        meshContext: {
+          meshId: ctx.mesh.id,
+          nodeId: args.node_id,
+          taskId
+        }
       });
       if (result2.success) {
         const dispatchedSessionId = args.session_id || result2.sessionId;
+        const dispatchedAt = (/* @__PURE__ */ new Date()).toISOString();
         try {
+          const providerType = result2.providerType || cached?.providerType;
           (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
             kind: "task_dispatched",
             nodeId: args.node_id,
             sessionId: dispatchedSessionId,
-            payload: {
-              message: args.message,
-              via: "p2p_direct",
-              ...dispatchedSessionId ? { targetSessionId: dispatchedSessionId } : {}
-            }
+            providerType,
+            payload: buildDirectTaskPayload(args.message, "p2p_direct", {
+              taskId,
+              taskMode,
+              providerType,
+              targetSessionId: dispatchedSessionId
+            })
+          });
+          (0, import_daemon_core.insertDirectDispatch)(ctx.mesh.id, {
+            taskId,
+            nodeId: args.node_id,
+            sessionId: dispatchedSessionId,
+            providerType: providerType || void 0,
+            message: args.message,
+            taskMode: taskMode || void 0,
+            via: "p2p_direct",
+            dispatchedAt
           });
         } catch {
         }
       }
-      return JSON.stringify({ ...result2, nodeId: args.node_id, dispatched: result2.success === true });
+      return JSON.stringify({
+        ...result2,
+        nodeId: args.node_id,
+        sessionId: result2.success ? args.session_id || result2.sessionId : args.session_id,
+        ...result2.success ? { source: "direct", taskId } : {},
+        taskMode,
+        ...result2.success && result2.providerType ? { providerType: result2.providerType } : {},
+        dispatched: result2.success === true
+      });
     }
     if (args.session_id && isLocalTransport(ctx.transport)) {
-      const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+      const cached = getSessionMetadata(meshSessionCacheKey(args.node_id, args.session_id));
+      let resolvedProviderType = cached?.providerType || "";
+      if (!resolvedProviderType) {
+        let explicitSession = explicitTargetSession;
+        if (!explicitSession) {
+          const statusResult = await commandForNode(ctx, node, "get_status_metadata", {});
+          const sessions = extractStatusMetadataSessions(statusResult);
+          explicitSession = sessions.find((session) => readSessionRecordId(session) === args.session_id);
+        }
+        if (!explicitSession) {
+          return JSON.stringify({
+            success: false,
+            recoverable: true,
+            code: "mesh_target_session_not_found",
+            reason: "mesh_target_session_not_found",
+            transport: "local_ipc",
+            retryRecommended: true,
+            nodeId: args.node_id,
+            sessionId: args.session_id,
+            error: `Local session '${args.session_id}' is not present in live status for node '${args.node_id}'.`,
+            nextAction: `Launch a fresh session with mesh_launch_session(node_id: '${args.node_id}') or retry without session_id so Repo Mesh can target a live delegate session.`
+          });
+        }
+        if (isMeshCoordinatorSessionRecord(explicitSession)) {
+          return JSON.stringify({
+            success: false,
+            recoverable: true,
+            code: "mesh_target_session_is_coordinator",
+            reason: "mesh_target_session_is_coordinator",
+            nodeId: args.node_id,
+            sessionId: args.session_id,
+            taskMode: taskMode || "unspecified",
+            error: `Session '${args.session_id}' is a Repo Mesh coordinator session, not a visible worker session. Launch or use a visible worker session before dispatching this task.`,
+            nextAction: `Call mesh_launch_session for node '${args.node_id}' and then retry mesh_send_task with that worker session_id, or use mesh_enqueue_task for queue-based worker assignment.`
+          });
+        }
+        if (isUnmanagedSessionRecord(explicitSession)) {
+          return JSON.stringify({
+            success: false,
+            recoverable: true,
+            code: "mesh_target_session_unmanaged",
+            reason: "mesh_target_session_unmanaged",
+            nodeId: args.node_id,
+            sessionId: args.session_id,
+            taskMode: taskMode || "unspecified",
+            unsafeTranscriptAlias: true,
+            unsafeDelegateTarget: true,
+            error: `Session '${args.session_id}' on node '${args.node_id}' has no Repo Mesh delegation metadata (missing meshNodeFor/meshCoordinatorFor/launchedByCoordinator). It may be the coordinator's own session or an unrelated session \u2014 dispatching risks self-send and orphaned completion events that never reach the coordinator ledger.`,
+            nextAction: `Call mesh_launch_session for node '${args.node_id}' to start a fresh managed worker session, then retry mesh_send_task with the returned session_id. Alternatively use mesh_enqueue_task for queue-based assignment without specifying session_id.`
+          });
+        }
+        resolvedProviderType = resolveSessionProviderType(explicitSession);
+        if (resolvedProviderType) {
+          meshSessionProviderMetadata.set(meshSessionCacheKey(args.node_id, args.session_id), {
+            providerType: resolvedProviderType,
+            providerSessionId: readString(explicitSession?.providerSessionId) || void 0,
+            expiresAt: Date.now() + SESSION_PROVIDER_METADATA_TTL_MS
+          });
+        }
+      }
+      if (!resolvedProviderType) {
+        return JSON.stringify({
+          success: false,
+          recoverable: true,
+          code: "mesh_target_session_provider_unknown",
+          reason: "mesh_target_session_provider_unknown",
+          transport: "local_ipc",
+          retryRecommended: false,
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          error: `Local session '${args.session_id}' is live but does not expose providerType/cliType, so agent_command cannot be routed safely.`,
+          nextAction: `Relaunch the target session on node '${args.node_id}' or retry without session_id so Repo Mesh can pick a session with provider metadata.`
+        });
+      }
+      const sessionWasIdle = explicitTargetSession ? isIdleSessionRecord(explicitTargetSession) : false;
+      const taskId = (0, import_node_crypto.randomUUID)();
+      const dispatchedAt = (/* @__PURE__ */ new Date()).toISOString();
       const dispatchResult = await commandForNode(ctx, node, "agent_command", {
         targetSessionId: args.session_id,
-        ...cached?.providerType ? { agentType: cached.providerType, cliType: cached.providerType, providerType: cached.providerType } : {},
+        agentType: resolvedProviderType,
+        cliType: resolvedProviderType,
+        providerType: resolvedProviderType,
         action: "send_chat",
-        message: args.message
+        message: args.message,
+        meshContext: {
+          meshId: ctx.mesh.id,
+          nodeId: args.node_id,
+          taskId
+        }
       });
       const dispatchPayload = unwrapCommandPayload(dispatchResult);
       if (dispatchPayload?.success === false || dispatchResult?.success === false) {
+        const source = dispatchPayload?.success === false ? dispatchPayload : dispatchResult;
         return JSON.stringify({
+          ...source && typeof source === "object" ? source : {},
           success: false,
           nodeId: args.node_id,
           sessionId: args.session_id,
@@ -1916,23 +2798,55 @@ async function meshSendTask(ctx, args) {
           kind: "task_dispatched",
           nodeId: args.node_id,
           sessionId: args.session_id,
-          providerType: cached?.providerType,
-          payload: { message: args.message, via: "local_direct" }
+          providerType: resolvedProviderType,
+          payload: buildDirectTaskPayload(args.message, "local_direct", {
+            taskId,
+            taskMode,
+            providerType: resolvedProviderType,
+            targetSessionId: args.session_id,
+            dispatchedToIdleSession: sessionWasIdle
+          })
         });
       } catch {
       }
-      return JSON.stringify({ success: true, dispatched: true, nodeId: args.node_id, sessionId: args.session_id });
+      (0, import_daemon_core.insertDirectDispatch)(ctx.mesh.id, {
+        taskId,
+        nodeId: args.node_id,
+        sessionId: args.session_id,
+        providerType: resolvedProviderType || void 0,
+        message: args.message,
+        taskMode: taskMode || void 0,
+        via: "local_direct",
+        dispatchedToIdleSession: sessionWasIdle,
+        dispatchedAt
+      });
+      return JSON.stringify({
+        success: true,
+        dispatched: true,
+        source: "direct",
+        taskId,
+        taskMode,
+        providerType: resolvedProviderType,
+        nodeId: args.node_id,
+        sessionId: args.session_id,
+        ...sessionWasIdle ? {
+          dispatchAcknowledgementRisk: true,
+          dispatchAcknowledgementRiskReason: "session_was_idle_at_dispatch",
+          dispatchAcknowledgementNote: `Session '${args.session_id}' was idle at dispatch time. If it does not transition to generating, this direct task was not acknowledged. Use mesh_status to verify; if the session remains idle, it may appear as stale direct work \u2014 launch a fresh session and retry.`
+        } : {}
+      });
     }
     const task = (0, import_daemon_core.enqueueTask)(ctx.mesh.id, args.message, {
       targetNodeId: args.node_id,
-      targetSessionId: args.session_id
+      targetSessionId: args.session_id,
+      taskMode
     });
     if (isLocalTransport(ctx.transport) || ctx.transport instanceof IpcTransport) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
     }
-    const pendingEvents = isLocalTransport(ctx.transport) ? (0, import_daemon_core.drainPendingMeshCoordinatorEvents)() : [];
-    const result = { success: true, nodeId: args.node_id, taskId: task.id, status: task.status };
+    const pendingEvents = isLocalTransport(ctx.transport) ? (0, import_daemon_core.drainPendingMeshCoordinatorEvents)(ctx.mesh.id, ctx.localDaemonId) : [];
+    const result = { success: true, source: "queue", nodeId: args.node_id, taskId: task.id, status: task.status, taskMode: task.taskMode };
     if (pendingEvents.length > 0) {
       result.pendingCoordinatorEvents = pendingEvents;
     }
@@ -1956,7 +2870,7 @@ async function meshReadChat(ctx, args) {
     await drainCoordinatorPendingEvents(ctx, { nodeIds: [args.node_id] });
   }
   if (isLocalTransport(ctx.transport)) {
-    const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+    const cached = resolveMeshSessionProviderMetadata(ctx, args.node_id, args.session_id);
     const providerSessionId = typeof args.provider_session_id === "string" && args.provider_session_id.trim() ? args.provider_session_id.trim() : cached?.providerSessionId;
     const result = await commandForNode(ctx, node, "read_chat", {
       sessionId: args.session_id,
@@ -1964,18 +2878,19 @@ async function meshReadChat(ctx, args) {
       workspace: node.workspace,
       ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
       ...providerSessionId ? { providerSessionId } : {},
-      tailLimit: args.tail ?? 10
+      tailLimit: args.tail ?? 3
     });
     const payload = annotateRapidReadChatAdvisory(unwrapCommandPayload(result), {
       key: `mesh:${args.node_id}:${args.session_id}`,
       toolName: "mesh_read_chat",
       completionCallbackExpected: true
     });
-    if (args.compact) {
+    const useCompact = args.compact !== false;
+    if (useCompact) {
       const compactPayload = compactChatPayload(payload, {
         nodeId: args.node_id,
         sessionId: args.session_id,
-        limit: args.tail ?? 10
+        limit: args.tail ?? 3
       });
       return JSON.stringify(
         payload.pollingAdvisory ? { ...compactPayload, pollingAdvisory: payload.pollingAdvisory } : compactPayload,
@@ -1988,7 +2903,7 @@ async function meshReadChat(ctx, args) {
     try {
       const targetId = `${node.daemonId}:session:${args.session_id}`;
       const res = await ctx.transport.readChat(targetId, {
-        limit: args.tail ?? 10,
+        limit: args.tail ?? 3,
         sessionId: args.session_id
       });
       return JSON.stringify(res, null, 2);
@@ -2002,7 +2917,7 @@ async function meshReadChat(ctx, args) {
 async function meshReadDebug(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
   if (isLocalTransport(ctx.transport)) {
-    const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+    const cached = resolveMeshSessionProviderMetadata(ctx, args.node_id, args.session_id);
     const providerSessionId = typeof args.provider_session_id === "string" && args.provider_session_id.trim() ? args.provider_session_id.trim() : cached?.providerSessionId;
     const delivery = args.delivery === "inline" ? void 0 : "daemon_file";
     const result = await commandForNode(ctx, node, "get_chat_debug_bundle", {
@@ -2033,6 +2948,8 @@ async function meshReadDebug(ctx, args) {
 }
 async function meshLaunchSession(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
+  const bootstrapBlock = getWorktreeBootstrapLaunchBlock(node);
+  if (bootstrapBlock) return JSON.stringify(bootstrapBlock, null, 2);
   if (isLocalTransport(ctx.transport)) {
     let resolvedProviderType = typeof args.type === "string" && args.type.trim() ? args.type : "";
     if (!resolvedProviderType) {
@@ -2057,6 +2974,10 @@ async function meshLaunchSession(ctx, args) {
     const coordinatorNode = resolveCoordinatorNode(ctx);
     const coordinatorDaemonId = coordinatorNode?.daemonId || ctx.localDaemonId;
     const spawnedSessionVisibility = readSpawnedSessionVisibility(ctx.mesh.policy);
+    const isLocalNode = isLocalControlPlaneNode(ctx, node);
+    if (node.daemonId && !isLocalNode && !coordinatorDaemonId) {
+      return JSON.stringify(buildMissingCoordinatorDaemonIdFailure(ctx, node, resolvedProviderType), null, 2);
+    }
     let result;
     try {
       result = await commandForNode(ctx, node, "launch_cli", {
@@ -2084,7 +3005,8 @@ async function meshLaunchSession(ctx, args) {
     if (runtimeSessionId) {
       meshSessionProviderMetadata.set(meshSessionCacheKey(args.node_id, runtimeSessionId), {
         providerType: resolvedProviderType,
-        ...providerSessionId ? { providerSessionId } : {}
+        ...providerSessionId ? { providerSessionId } : {},
+        expiresAt: Date.now() + SESSION_PROVIDER_METADATA_TTL_MS
       });
     }
     try {
@@ -2097,7 +3019,6 @@ async function meshLaunchSession(ctx, args) {
       });
     } catch {
     }
-    const isLocalNode = isLocalControlPlaneNode(ctx, node);
     if (ctx.transport instanceof IpcTransport && node.daemonId && !isLocalNode) {
       ctx.transport.meshCommand(node.daemonId, "trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
@@ -2122,6 +3043,9 @@ async function meshLaunchSession(ctx, args) {
     const coordinatorNode = resolveCoordinatorNode(ctx);
     const coordinatorDaemonId = coordinatorNode?.daemonId || ctx.localDaemonId;
     const spawnedSessionVisibility = readSpawnedSessionVisibility(ctx.mesh.policy);
+    if (!coordinatorDaemonId) {
+      return JSON.stringify(buildMissingCoordinatorDaemonIdFailure(ctx, node, resolvedProviderType), null, 2);
+    }
     try {
       const res = await ctx.transport.launch(node.daemonId, {
         type: resolvedProviderType,
@@ -2202,6 +3126,51 @@ async function meshGitStatus(ctx, args) {
     }, null, 2);
   }
 }
+async function meshFastForwardNode(ctx, args) {
+  await refreshMeshFromDaemon(ctx);
+  const node = await findNodeWithRefresh(ctx, args.node_id);
+  const submoduleIgnorePaths = node.policy?.submoduleIgnorePaths || [];
+  if (node.policy?.readOnly) {
+    return JSON.stringify({
+      success: false,
+      code: "node_read_only",
+      nodeId: args.node_id,
+      workspace: node.workspace,
+      allowed: false,
+      willRun: false,
+      executed: false,
+      blockingReasons: ["node_read_only"]
+    }, null, 2);
+  }
+  try {
+    const dryRun = args.dry_run === true || args.execute !== true;
+    const result = await commandForNode(ctx, node, "fast_forward_mesh_node", {
+      meshId: ctx.mesh.id,
+      nodeId: node.id,
+      workspace: node.workspace,
+      branch: typeof args.branch === "string" ? args.branch : void 0,
+      execute: args.execute === true && args.dry_run !== true,
+      dryRun,
+      updateSubmodules: args.update_submodules === true,
+      submoduleIgnorePaths: submoduleIgnorePaths.length > 0 ? submoduleIgnorePaths : void 0
+    });
+    return JSON.stringify(unwrapCommandPayload(result), null, 2);
+  } catch (e) {
+    const failure = buildCoordinatorP2pRelayFailure(e, {
+      command: "fast_forward_mesh_node",
+      targetDaemonId: node.daemonId,
+      nodeId: args.node_id
+    });
+    return JSON.stringify({
+      ...failure,
+      workspace: node.workspace,
+      allowed: false,
+      willRun: false,
+      executed: false,
+      blockingReasons: [failure.code || "mesh_fast_forward_unavailable"]
+    }, null, 2);
+  }
+}
 async function meshCheckpoint(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
   if (node.policy?.readOnly) {
@@ -2217,7 +3186,13 @@ async function meshCheckpoint(ctx, args) {
       (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
         kind: "checkpoint_created",
         nodeId: args.node_id,
-        payload: { message: args.message, commit: result?.checkpoint?.commit }
+        payload: {
+          message: args.message,
+          commit: result?.checkpoint?.commit,
+          outcome: result?.checkpoint?.status || (result?.checkpoint?.noop ? "skipped" : void 0),
+          noop: result?.checkpoint?.noop === true,
+          reason: result?.checkpoint?.reason
+        }
       });
     } catch {
     }
@@ -2233,7 +3208,13 @@ async function meshCheckpoint(ctx, args) {
         (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
           kind: "checkpoint_created",
           nodeId: args.node_id,
-          payload: { message: args.message, commit: res?.checkpoint?.commit }
+          payload: {
+            message: args.message,
+            commit: res?.checkpoint?.commit,
+            outcome: res?.checkpoint?.status || (res?.checkpoint?.noop ? "skipped" : void 0),
+            noop: res?.checkpoint?.noop === true,
+            reason: res?.checkpoint?.reason
+          }
         });
       } catch {
       }
@@ -2248,7 +3229,7 @@ async function meshCheckpoint(ctx, args) {
 async function meshApprove(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
   if (isLocalTransport(ctx.transport)) {
-    const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+    const cached = getSessionMetadata(meshSessionCacheKey(args.node_id, args.session_id));
     const providerSessionId = cached?.providerSessionId;
     const result = await commandForNode(ctx, node, "resolve_action", {
       sessionId: args.session_id,
@@ -2401,6 +3382,43 @@ async function meshRemoveNode(ctx, args) {
     return JSON.stringify({ error: "Cloud mesh remove_node requires node daemonId" });
   }
 }
+function resolveRefineConfigNode(ctx, nodeId) {
+  if (nodeId) return findNode(ctx.mesh, nodeId);
+  const node = ctx.mesh.nodes.find((entry) => !!entry.workspace);
+  if (!node) throw new Error("No mesh node with a workspace is available");
+  return node;
+}
+async function meshRefineConfigSchema(ctx) {
+  const node = resolveRefineConfigNode(ctx);
+  const result = await commandForNode(ctx, node, "get_mesh_refine_config_schema", {});
+  return JSON.stringify(result, null, 2);
+}
+async function meshValidateRefineConfig(ctx, args) {
+  const node = resolveRefineConfigNode(ctx, args.node_id);
+  const result = await commandForNode(ctx, node, "validate_mesh_refine_config", {
+    workspace: node.workspace,
+    inlineMesh: ctx.mesh,
+    ...args.config ? { config: args.config } : {}
+  });
+  return JSON.stringify(result, null, 2);
+}
+async function meshSuggestRefineConfig(ctx, args) {
+  const node = resolveRefineConfigNode(ctx, args.node_id);
+  const result = await commandForNode(ctx, node, "suggest_mesh_refine_config", {
+    workspace: node.workspace,
+    inlineMesh: ctx.mesh
+  });
+  return JSON.stringify(result, null, 2);
+}
+async function meshRefinePlan(ctx, args) {
+  const node = await findNodeWithRefresh(ctx, args.node_id);
+  const result = await commandForNode(ctx, node, "plan_mesh_refine_node", {
+    meshId: ctx.mesh.id,
+    nodeId: args.node_id,
+    inlineMesh: ctx.mesh
+  });
+  return JSON.stringify(result, null, 2);
+}
 async function meshRefineNode(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
   if (isLocalTransport(ctx.transport)) {
@@ -2409,7 +3427,7 @@ async function meshRefineNode(ctx, args) {
       nodeId: args.node_id,
       inlineMesh: ctx.mesh
     });
-    if (result?.success && result.removeResult?.removed !== false) {
+    if (result?.success && result.async !== true && result.removeResult?.removed !== false) {
       const idx = ctx.mesh.nodes.findIndex((n) => n.id === args.node_id);
       if (idx >= 0) {
         ctx.mesh.nodes.splice(idx, 1);
@@ -2424,7 +3442,7 @@ async function meshRefineNode(ctx, args) {
         nodeId: args.node_id,
         inlineMesh: ctx.mesh
       });
-      if (res?.success && res.removeResult?.removed !== false) {
+      if (res?.success && res.async !== true && res.removeResult?.removed !== false) {
         const idx = ctx.mesh.nodes.findIndex((n) => n.id === args.node_id);
         if (idx >= 0) {
           ctx.mesh.nodes.splice(idx, 1);
@@ -2461,13 +3479,13 @@ var STANDARD_TOOLS = [
 function buildMcpHelpText() {
   const meshTools = ALL_MESH_TOOLS.map((tool) => tool.name);
   return `
-adhdev-mcp \u2014 ADHDev MCP Server
+ADHDev MCP Server
 
 Usage:
-  adhdev-mcp                                    Local mode (requires standalone daemon)
-  adhdev-mcp --api-key <key>                    Cloud mode (ADHDev cloud API)
-  adhdev-mcp --mode ipc --repo-mesh <mesh_id>   Cloud daemon IPC mesh mode
-  adhdev-mcp --repo-mesh <mesh_id>              Mesh mode (coordinator-scoped tools)
+  adhdev mcp                                    Local mode (requires standalone daemon)
+  adhdev mcp --api-key <key>                    Cloud mode (ADHDev cloud API)
+  adhdev mcp --mode ipc --repo-mesh <mesh_id>   Cloud daemon IPC mesh mode
+  adhdev-mcp --help                             Compatibility bin (same server, legacy package entrypoint)
 
 Options:
   --mode <mode>           Transport: local, cloud, or ipc
@@ -2492,6 +3510,7 @@ Mesh tools:       ${meshTools.join(", ")}
 // src/server.ts
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_node_os = __toESM(require("os"));
 var import_types = require("@modelcontextprotocol/sdk/types.js");
 
 // src/transports/local.ts
@@ -4025,6 +5044,7 @@ async function startMcpServer(opts) {
               requirePreTaskCheckpoint: false,
               requirePostTaskCheckpoint: true,
               requireApprovalForPush: true,
+              allowAutoPublishSubmoduleMainCommits: false,
               requireApprovalForDestructiveGit: true,
               dirtyWorkspaceBehavior: "warn",
               maxParallelTasks: 2,
@@ -4081,11 +5101,13 @@ async function startMcpServer(opts) {
     }
     let localDaemonId;
     let localMachineId;
+    let coordinatorHostname = import_node_os.default.hostname();
     if (transport instanceof LocalTransport || transport instanceof IpcTransport) {
       try {
         const { loadConfig } = await import("@adhdev/daemon-core");
         const cfg = loadConfig();
-        if (cfg.registeredMachineId) localMachineId = cfg.registeredMachineId;
+        if (cfg.machineId) localMachineId = cfg.machineId;
+        else if (cfg.registeredMachineId) localMachineId = cfg.registeredMachineId;
       } catch {
       }
     }
@@ -4093,14 +5115,16 @@ async function startMcpServer(opts) {
       try {
         const statusResult = await transport.getStatus();
         const instanceId = typeof statusResult?.status?.instanceId === "string" ? statusResult.status.instanceId.trim() : "";
+        const hostname = typeof statusResult?.status?.hostname === "string" ? statusResult.status.hostname.trim() : typeof statusResult?.status?.machine?.hostname === "string" ? statusResult.status.machine.hostname.trim() : "";
         if (instanceId) localDaemonId = instanceId;
+        if (hostname) coordinatorHostname = hostname;
       } catch {
       }
     }
-    const meshCtx = { mesh, transport, ...localDaemonId ? { localDaemonId } : {}, ...localMachineId ? { localMachineId } : {} };
+    const meshCtx = { mesh, transport, ...localDaemonId ? { localDaemonId } : {}, ...localMachineId ? { localMachineId } : {}, ...coordinatorHostname ? { coordinatorHostname } : {} };
     const coordinatorPrompt = await buildMeshModeCoordinatorPrompt(mesh);
     const server2 = new import_server.Server(
-      { name: "adhdev-mcp-server", version: "0.9.81" },
+      { name: "adhdev-mcp-server", version: "0.9.82" },
       { capabilities: { tools: {}, resources: {} } }
     );
     const { ListResourcesRequestSchema, ReadResourceRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
@@ -4126,7 +5150,7 @@ async function startMcpServer(opts) {
         let text;
         switch (name) {
           case "mesh_status":
-            text = await meshStatus(meshCtx);
+            text = await meshStatus(meshCtx, a);
             break;
           case "mesh_list_nodes":
             text = await meshListNodes(meshCtx);
@@ -4158,6 +5182,9 @@ async function startMcpServer(opts) {
           case "mesh_git_status":
             text = await meshGitStatus(meshCtx, a);
             break;
+          case "mesh_fast_forward_node":
+            text = await meshFastForwardNode(meshCtx, a);
+            break;
           case "mesh_checkpoint":
             text = await meshCheckpoint(meshCtx, a);
             break;
@@ -4173,6 +5200,18 @@ async function startMcpServer(opts) {
           case "mesh_refine_node":
             text = await meshRefineNode(meshCtx, a);
             break;
+          case "mesh_refine_config_schema":
+            text = await meshRefineConfigSchema(meshCtx);
+            break;
+          case "mesh_validate_refine_config":
+            text = await meshValidateRefineConfig(meshCtx, a);
+            break;
+          case "mesh_suggest_refine_config":
+            text = await meshSuggestRefineConfig(meshCtx, a);
+            break;
+          case "mesh_refine_plan":
+            text = await meshRefinePlan(meshCtx, a);
+            break;
           case "mesh_cleanup_sessions":
             text = await meshCleanupSessions(meshCtx, a);
             break;