@adhdev/daemon-standalone 0.9.82-rc.2 → 0.9.82-rc.200

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 });
+      }
     });
   }
 };
@@ -161,16 +248,19 @@ function isCoordinatorVisibleMessage(message) {
   if (meta?.internal === true || meta?.debug === true || meta?.control === true || meta?.userVisible === false || meta?.user_visible === false) return false;
   return role === "user" || role === "assistant" || role === "agent";
 }
+function buildCompactMessageTail(visibleMessages, opts) {
+  return visibleMessages.slice(-opts.limit);
+}
 function compactChatPayload(payload, opts = {}) {
   const rawMessages = Array.isArray(payload?.messages) ? payload.messages : [];
   const visible = rawMessages.filter(isCoordinatorVisibleMessage);
   const limit = Math.max(1, Math.min(opts.limit ?? 10, 10));
-  const messages = visible.slice(-limit);
   const finalAssistant = [...visible].reverse().find((message) => {
     const role = String(message?.role ?? "").toLowerCase();
     return (role === "assistant" || role === "agent") && messageContent(message).trim();
   });
   const summary = typeof payload?.summary === "string" && payload.summary.trim() ? payload.summary.trim() : messageContent(finalAssistant).trim();
+  const messages = buildCompactMessageTail(visible, { summary, finalAssistant, limit });
   return {
     success: payload?.success !== false,
     compact: true,
@@ -231,30 +321,86 @@ 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;
     const refreshedNodes = result.mesh.nodes.filter((n) => n?.id).map((n) => n);
-    if (!refreshedNodes.length) return;
     ctx.mesh.nodes.splice(0, ctx.mesh.nodes.length, ...refreshedNodes);
     ctx.mesh.updatedAt = result.mesh.updatedAt ?? ctx.mesh.updatedAt;
   } catch {
   }
 }
+async function syncCoordinatorDaemonMeshCache(ctx) {
+  if (!(ctx.transport instanceof IpcTransport)) return;
+  try {
+    await ctx.transport.command("get_mesh", {
+      meshId: ctx.mesh.id,
+      inlineMesh: ctx.mesh
+    });
+  } catch {
+  }
+}
 async function findNodeWithRefresh(ctx, nodeId) {
   const hit = ctx.mesh.nodes.find((n) => n.id === nodeId);
-  if (hit) return hit;
+  if (hit && !hit.isLocalWorktree) return hit;
   await refreshMeshFromDaemon(ctx);
   const refreshed = ctx.mesh.nodes.find((n) => n.id === nodeId);
   if (!refreshed) throw new Error(`Node '${nodeId}' is not a member of mesh '${ctx.mesh.name}'`);
@@ -262,7 +408,7 @@ async function findNodeWithRefresh(ctx, nodeId) {
 }
 async function findOptionalNodeWithRefresh(ctx, nodeId) {
   const hit = ctx.mesh.nodes.find((n) => n.id === nodeId);
-  if (hit) return hit;
+  if (hit && !hit.isLocalWorktree) return hit;
   await refreshMeshFromDaemon(ctx);
   return ctx.mesh.nodes.find((n) => n.id === nodeId) ?? null;
 }
@@ -314,9 +460,26 @@ function buildMissingNodeReadChatRecovery(ctx, args) {
     readDebugLocator: readString(lastTerminal?.payload?.readDebugLocator) || readString(lastTerminal?.payload?.debugBundlePath)
   };
   if (finalSummary) {
+    if (args.compact === true) {
+      return {
+        ...compactChatPayload({
+          success: true,
+          status: "idle",
+          providerSessionId,
+          summary: finalSummary,
+          messages: [{ role: "assistant", content: finalSummary, isHistorical: true }]
+        }, {
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          limit: args.tail ?? 10
+        }),
+        recoveredFromLedger: true,
+        ledger
+      };
+    }
     return {
       success: true,
-      compact: args.compact === true,
+      compact: false,
       recoveredFromLedger: true,
       nodeId: args.node_id,
       sessionId: args.session_id,
@@ -368,6 +531,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);
@@ -436,18 +626,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
     },
@@ -475,6 +673,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,
@@ -568,6 +778,172 @@ function unwrapCommandPayload(value) {
   }
   return current;
 }
+function isDirectDispatchLedgerEntry(entry) {
+  if (entry?.kind !== "task_dispatched") return false;
+  const payload = entry.payload || {};
+  const via = readString(payload.via);
+  return payload.source === "direct" || via === "p2p_direct" || via === "local_direct" || via === "mesh_send_task";
+}
+function readMessageTimestampIso(message) {
+  for (const value of [message?.timestamp, message?.createdAt, message?.created_at, message?.updatedAt, message?.time]) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      const ms = value > 1e10 ? value : value * 1e3;
+      return new Date(ms).toISOString();
+    }
+    if (typeof value === "string" && value.trim()) {
+      const ms = new Date(value.trim()).getTime();
+      if (Number.isFinite(ms)) return new Date(ms).toISOString();
+    }
+  }
+  return void 0;
+}
+function readFinalAssistantTranscriptEvidence(payload) {
+  const rawMessages = Array.isArray(payload?.messages) ? payload.messages : [];
+  const finalAssistant = [...rawMessages].reverse().filter(isCoordinatorVisibleMessage).find((message) => {
+    const role = String(message?.role ?? "").toLowerCase();
+    return (role === "assistant" || role === "agent") && messageContent(message).trim();
+  });
+  const finalSummary = messageContent(finalAssistant).trim() || (typeof payload?.summary === "string" && payload.summary.trim() ? payload.summary.trim() : void 0);
+  return {
+    finalSummary,
+    transcriptMessageAt: finalAssistant ? readMessageTimestampIso(finalAssistant) : void 0
+  };
+}
+function findNodeSession(nodes, nodeId, sessionId) {
+  if (!nodeId || !sessionId) return {};
+  const node = nodes.find((candidate) => readString(candidate?.id) === nodeId || readString(candidate?.nodeId) === nodeId);
+  if (!node) return {};
+  const sessions = Array.isArray(node.sessions) ? node.sessions : [];
+  const session = sessions.find((candidate) => readSessionRecordId(candidate) === sessionId);
+  return { node, session };
+}
+function buildDirectDispatchReconciliationCandidates(directDispatches, ledgerEntries) {
+  const candidates = [];
+  const seenTaskIds = /* @__PURE__ */ new Set();
+  for (const dispatch of directDispatches || []) {
+    const taskId = readString(dispatch?.taskId);
+    if (!taskId || seenTaskIds.has(taskId)) continue;
+    seenTaskIds.add(taskId);
+    candidates.push(dispatch);
+  }
+  for (const entry of ledgerEntries || []) {
+    if (!isDirectDispatchLedgerEntry(entry)) continue;
+    const taskId = readString(entry.payload?.taskId);
+    if (!taskId || seenTaskIds.has(taskId)) continue;
+    seenTaskIds.add(taskId);
+    candidates.push({
+      taskId,
+      nodeId: entry.nodeId,
+      sessionId: entry.sessionId,
+      providerType: entry.providerType || readString(entry.payload?.providerType),
+      message: readString(entry.payload?.message),
+      dispatchedAt: entry.timestamp,
+      via: readString(entry.payload?.via)
+    });
+  }
+  return candidates;
+}
+async function reconcileDirectDispatchesFromTranscriptEvidence(ctx, liveNodes, directDispatches, ledgerEntries) {
+  let attempted = 0;
+  let reconciled = 0;
+  let skipped = 0;
+  const candidates = buildDirectDispatchReconciliationCandidates(directDispatches, ledgerEntries);
+  for (const dispatch of candidates) {
+    const taskId = readString(dispatch?.taskId);
+    const nodeId = readString(dispatch?.nodeId);
+    const sessionId = readString(dispatch?.sessionId);
+    if (!taskId || !nodeId || !sessionId) {
+      skipped += 1;
+      continue;
+    }
+    const { session } = findNodeSession(liveNodes, nodeId, sessionId);
+    if (!session || !isIdleSessionRecord(session)) {
+      skipped += 1;
+      continue;
+    }
+    const node = await findOptionalNodeWithRefresh(ctx, nodeId).catch(() => null);
+    if (!node) {
+      skipped += 1;
+      continue;
+    }
+    const providerType = readString(dispatch?.providerType) || resolveSessionProviderType(session);
+    const providerSessionId = readString(session?.providerSessionId) || readString(session?.activeChat?.providerSessionId) || readString(session?.settings?.providerSessionId) || resolveMeshSessionProviderMetadata(ctx, nodeId, sessionId)?.providerSessionId;
+    attempted += 1;
+    try {
+      const readResult = await commandForNode(ctx, node, "read_chat", {
+        sessionId,
+        targetSessionId: sessionId,
+        workspace: node.workspace,
+        ...providerType ? { agentType: providerType, providerType } : {},
+        ...providerSessionId ? { providerSessionId } : {},
+        tailLimit: 10
+      });
+      const payload = unwrapCommandPayload(readResult);
+      if (payload?.success === false) continue;
+      const evidence = readFinalAssistantTranscriptEvidence(payload);
+      if (!evidence.finalSummary) continue;
+      const result = (0, import_daemon_core.reconcileDirectDispatchCompletionFromTranscript)({
+        meshId: ctx.mesh.id,
+        nodeId,
+        sessionId,
+        providerType,
+        providerSessionId: readString(payload?.providerSessionId) || providerSessionId,
+        taskId,
+        finalSummary: evidence.finalSummary,
+        transcriptMessageAt: evidence.transcriptMessageAt,
+        targetCoordinatorDaemonId: ctx.localDaemonId,
+        source: "mcp_mesh_status_transcript_reconciliation"
+      });
+      if (result.reconciled) reconciled += 1;
+    } catch {
+      skipped += 1;
+    }
+  }
+  return { attempted, reconciled, skipped };
+}
+async function triggerMeshQueueAndReport(ctx, node, opts) {
+  if (!(isLocalTransport(ctx.transport) || ctx.transport instanceof IpcTransport)) return void 0;
+  try {
+    let raw;
+    if (ctx.transport instanceof IpcTransport && node?.daemonId && opts?.localNode === false) {
+      raw = await ctx.transport.meshCommand(node.daemonId, "trigger_mesh_queue", { meshId: ctx.mesh.id });
+    } else if (isLocalTransport(ctx.transport)) {
+      raw = await ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id });
+    } else {
+      return void 0;
+    }
+    const payload = unwrapCommandPayload(raw);
+    const trigger = payload?.trigger && typeof payload.trigger === "object" ? payload.trigger : payload;
+    return trigger && typeof trigger === "object" ? trigger : { success: true };
+  } catch (e) {
+    return {
+      success: false,
+      error: e?.message || String(e)
+    };
+  }
+}
+function buildQueueTriggerGuidance(queueTrigger) {
+  if (!queueTrigger || queueTrigger.claimed === true) return void 0;
+  if (queueTrigger.success === false) {
+    return {
+      queueClaimed: false,
+      queueDispatchState: "trigger_failed",
+      nextAction: "Do not assume the queued task is running. Check mesh_view_queue and daemon connectivity before redispatching."
+    };
+  }
+  if (queueTrigger.noIdleMeshSessionAvailable === true) {
+    return {
+      queueClaimed: false,
+      queueDispatchState: "pending_no_idle_mesh_session",
+      nextAction: "The task is queued but not running. Launch a managed worker with mesh_launch_session, or wait for a delegated session to become ready and trigger the queue again."
+    };
+  }
+  return {
+    queueClaimed: false,
+    queueDispatchState: "pending_or_waiting_for_ready",
+    nextAction: "The task is queued but this trigger did not claim it. Use mesh_view_queue for the current active-work source of truth before retrying."
+  };
+}
 function isTerminalSessionRecord(session) {
   const status = typeof session?.status === "string" ? session.status.toLowerCase() : "";
   const lifecycle = typeof session?.lifecycle === "string" ? session.lifecycle.toLowerCase() : "";
@@ -580,13 +956,66 @@ 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 hasRemoteRelayMetadata(session) {
+  return Boolean(
+    readString(session?.settings?.meshCoordinatorDaemonId) || readString(session?.meta?.meshCoordinatorDaemonId) || readString(session?.metadata?.meshCoordinatorDaemonId) || readString(session?.meshCoordinatorDaemonId)
+  );
+}
+function isRelaySafeRemoteDelegateSession(session, meshId, nodeId) {
+  return isMeshOwnedDelegateSession(session, meshId, nodeId) && hasRemoteRelayMetadata(session);
+}
 function chooseDispatchableSession(sessions, providerType, meshId, nodeId) {
   const live = sessions.filter((session) => !isTerminalSessionRecord(session));
   const matchingProvider = (session) => !providerType || session?.providerType === providerType || session?.cliType === providerType;
   const meshSessions = live.filter(
-    (session) => session?.settings?.meshNodeFor === meshId || session?.settings?.meshNodeId === nodeId
+    (session) => isRelaySafeRemoteDelegateSession(session, meshId, nodeId)
   );
-  return meshSessions.find((session) => isIdleSessionRecord(session) && matchingProvider(session)) || meshSessions.find(matchingProvider) || live.find((session) => isIdleSessionRecord(session) && matchingProvider(session)) || live.find(matchingProvider) || live.find(isIdleSessionRecord) || live[0];
+  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();
@@ -615,12 +1044,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));
 }
@@ -745,20 +1178,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 (!isRelaySafeRemoteDelegateSession(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 (!isRelaySafeRemoteDelegateSession(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) {
@@ -770,7 +1259,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) {
@@ -788,7 +1278,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 {
@@ -818,34 +1308,197 @@ 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.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"];
@@ -856,8 +1509,23 @@ function countUncommittedChanges(status) {
 function isGitStatusDirty(status) {
   if (typeof status?.isDirty === "boolean") return status.isDirty;
   if (typeof status?.dirty === "boolean") return status.dirty;
+  if (Array.isArray(status?.submodules) && status.submodules.some((submodule) => submodule?.dirty || submodule?.outOfSync || submodule?.error)) return true;
   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) => ({
@@ -872,6 +1540,10 @@ function summarizeRelatedRepoStatus(repo, status) {
     workspace: repo.workspace,
     isGitRepo: status?.isGitRepo === true,
     branch: status?.branch ?? null,
+    upstream: status?.upstream ?? null,
+    upstreamStatus: typeof status?.upstreamStatus === "string" ? status.upstreamStatus : status?.upstream ? "unchecked" : "no_upstream",
+    upstreamFetchedAt: Number.isFinite(Number(status?.upstreamFetchedAt)) ? Number(status.upstreamFetchedAt) : null,
+    upstreamFetchError: typeof status?.upstreamFetchError === "string" ? status.upstreamFetchError : null,
     ahead: Number.isFinite(Number(status?.ahead)) ? Number(status.ahead) : 0,
     behind: Number.isFinite(Number(status?.behind)) ? Number(status.behind) : 0,
     dirty,
@@ -888,7 +1560,7 @@ async function collectRelatedRepoStatuses(ctx, node) {
   const results = [];
   for (const repo of relatedRepos) {
     try {
-      const statusResult = !isLocalTransport(ctx.transport) && node.daemonId ? await ctx.transport.gitStatus(node.daemonId, repo.workspace, false) : await commandForNode(ctx, node, "git_status", { workspace: repo.workspace });
+      const statusResult = !isLocalTransport(ctx.transport) && node.daemonId ? await ctx.transport.gitStatus(node.daemonId, repo.workspace, false, true) : await commandForNode(ctx, node, "git_status", { workspace: repo.workspace, refreshUpstream: true });
       const status = extractGitStatus(statusResult);
       results.push(summarizeRelatedRepoStatus(repo, status));
     } catch (e) {
@@ -912,6 +1584,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 {
@@ -926,6 +1608,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;
@@ -936,11 +1645,13 @@ function buildBranchConvergence(mesh, node, status, dirty, uncommittedChanges) {
   const ahead = readNumeric(status?.ahead);
   const behind = readNumeric(status?.behind);
   const upstream = readString(status?.upstream) ?? null;
+  const upstreamStatus = readString(status?.upstreamStatus) ?? (upstream ? "unchecked" : "no_upstream");
   const hasConflicts = status?.hasConflicts === true || Array.isArray(status?.conflictFiles) && status.conflictFiles.length > 0;
   const base = {
     defaultBranch,
     branch,
     upstream,
+    upstreamStatus,
     ahead,
     behind,
     isWorktree: node.isLocalWorktree === true,
@@ -974,6 +1685,15 @@ function buildBranchConvergence(mesh, node, status, dirty, uncommittedChanges) {
     };
   }
   if (branch === defaultBranch) {
+    if (upstream && upstreamStatus !== "fresh") {
+      return {
+        ...base,
+        status: "blocked_review",
+        needsConvergence: true,
+        reason: "default_branch_upstream_unverified",
+        nextStep: `Refresh ${defaultBranch}'s upstream refs or resolve the fetch failure before declaring convergence complete for node '${node.id}'.`
+      };
+    }
     if (ahead > 0 || behind > 0) {
       return {
         ...base,
@@ -1000,6 +1720,15 @@ function buildBranchConvergence(mesh, node, status, dirty, uncommittedChanges) {
       nextStep: `Run mesh_refine_node(node_id: "${node.id}") or explicitly classify this worktree as blocked_review/not_mergeable before ending the task.`
     };
   }
+  if (upstream && upstreamStatus !== "fresh") {
+    return {
+      ...base,
+      status: "blocked_review",
+      needsConvergence: true,
+      reason: "feature_branch_upstream_unverified",
+      nextStep: `Refresh branch '${branch}' upstream refs or resolve the fetch failure before deciding whether it is ready to merge into ${defaultBranch}.`
+    };
+  }
   if (!upstream || ahead > 0 || behind > 0) {
     return {
       ...base,
@@ -1041,7 +1770,91 @@ 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);
+  const events = Array.isArray(payload?.events) ? payload.events : Array.isArray(value?.events) ? value.events : [];
+  return events.filter((event) => event && typeof event === "object");
+}
+function buildMeshForwardPayloadFromPendingEvent(event) {
+  const metadataEvent = event?.metadataEvent && typeof event.metadataEvent === "object" ? event.metadataEvent : {};
+  return {
+    event: readString(event?.event),
+    meshId: readString(event?.meshId),
+    nodeId: readString(event?.nodeId) || readString(metadataEvent.meshNodeId),
+    workspace: readString(event?.workspace) || readString(metadataEvent.workspace),
+    targetSessionId: readString(metadataEvent.targetSessionId) || readString(metadataEvent.sessionId) || readString(metadataEvent.instanceId),
+    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 } : {},
+    ...readString(metadataEvent.reason) ? { reason: readString(metadataEvent.reason) } : {},
+    ...readString(metadataEvent.stopReason) ? { stopReason: readString(metadataEvent.stopReason) } : {},
+    ...readString(metadataEvent.cleanupReason) ? { cleanupReason: readString(metadataEvent.cleanupReason) } : {},
+    ...readString(metadataEvent.source) ? { source: readString(metadataEvent.source) } : {}
+  };
+}
+async function drainCoordinatorPendingEvents(ctx, opts) {
+  const requestedNodeIds = opts?.nodeIds?.length ? new Set(opts.nodeIds) : null;
+  const matchesCurrentMesh = (event) => readString(event?.meshId) === ctx.mesh.id;
+  if (ctx.transport instanceof IpcTransport) {
+    const surfacedEvents = [];
+    const coordinatorDaemonId = readString(ctx.localDaemonId);
+    const pendingEventArgs = {
+      meshId: ctx.mesh.id,
+      ...coordinatorDaemonId ? { coordinatorDaemonId } : {}
+    };
+    try {
+      surfacedEvents.push(
+        ...normalizePendingMeshCoordinatorEvents(await ctx.transport.command("get_pending_mesh_events", pendingEventArgs)).filter(matchesCurrentMesh)
+      );
+      surfacedEvents.forEach(rememberMeshSessionProviderMetadataFromEvent);
+    } catch {
+    }
+    for (const node of ctx.mesh.nodes) {
+      if (!node.daemonId || isLocalControlPlaneNode(ctx, node)) continue;
+      if (requestedNodeIds && !requestedNodeIds.has(node.id)) continue;
+      try {
+        const remoteEvents = normalizePendingMeshCoordinatorEvents(
+          await ctx.transport.meshCommand(node.daemonId, "get_pending_mesh_events", pendingEventArgs)
+        ).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", pendingEventArgs)).filter(matchesCurrentMesh)
+      );
+      surfacedEvents.forEach(rememberMeshSessionProviderMetadataFromEvent);
+    } catch {
+    }
+    return surfacedEvents;
+  }
+  if (isLocalTransport(ctx.transport)) {
+    const events = (0, import_daemon_core.drainPendingMeshCoordinatorEvents)(ctx.mesh.id, ctx.localDaemonId).filter(matchesCurrentMesh);
+    events.forEach(rememberMeshSessionProviderMetadataFromEvent);
+    return events;
+  }
+  return [];
 }
 function isP2pTransportUnavailableError(error) {
   return (0, import_daemon_core.isP2pRelayTransportFailure)(error);
@@ -1056,11 +1869,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." }
     }
   }
 };
@@ -1080,14 +1894,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: {
@@ -1140,7 +1958,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"]
   }
@@ -1198,6 +2018,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.",
@@ -1274,38 +2109,75 @@ var MESH_CLEANUP_SESSIONS_TOOL = {
     required: ["node_id", "mode"]
   }
 };
-var MESH_TASK_HISTORY_TOOL = {
-  name: "mesh_task_history",
-  description: "Read the task ledger for this mesh \u2014 dispatched tasks, completions, failures, checkpoints, and node lifecycle events. Use to understand what has been done before deciding next steps, to detect repeated failures, and to inform recovery decisions.",
+var MESH_TASK_HISTORY_TOOL = {
+  name: "mesh_task_history",
+  description: "Read the task ledger for this mesh \u2014 dispatched tasks, completions, failures, checkpoints, and node lifecycle events. Use to understand what has been done before deciding next steps, to detect repeated failures, and to inform recovery decisions.",
+  inputSchema: {
+    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, direct_fast_forward." }
+    }
+  }
+};
+var MESH_RECONCILE_LEDGER_TOOL = {
+  name: "mesh_reconcile_ledger",
+  description: "Reconcile daemon-local mesh ledgers by querying bounded ledger slices over P2P/DataChannel and importing missing entries into the coordinator local JSONL ledger. Cloud/D1 is not used as a ledger source of truth.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_ids: { type: "array", items: { type: "string" }, description: "Optional node IDs to query. Defaults to all mesh nodes." },
+      limit: { type: "number", description: "Bounded slice size per node. Defaults to 100 and is clamped by daemon-core." },
+      after_id: { type: "string", description: "Optional cursor entry ID; remote slices return entries strictly after this ID when present." },
+      since: { type: "string", description: "Optional ISO timestamp lower bound for queried entries." },
+      import_entries: { type: "boolean", description: "When false, query and report evidence without importing remote entries. Defaults true." }
+    }
+  }
+};
+var MESH_REFINE_NODE_TOOL = {
+  name: "mesh_refine_node",
+  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: {
+      node_id: { type: "string", description: "Node ID of the completed worktree node to refine and merge." }
+    },
+    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: {
-      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." }
+      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_RECONCILE_LEDGER_TOOL = {
-  name: "mesh_reconcile_ledger",
-  description: "Reconcile daemon-local mesh ledgers by querying bounded ledger slices over P2P/DataChannel and importing missing entries into the coordinator local JSONL ledger. Cloud/D1 is not used as a ledger source of truth.",
+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_ids: { type: "array", items: { type: "string" }, description: "Optional node IDs to query. Defaults to all mesh nodes." },
-      limit: { type: "number", description: "Bounded slice size per node. Defaults to 100 and is clamped by daemon-core." },
-      after_id: { type: "string", description: "Optional cursor entry ID; remote slices return entries strictly after this ID when present." },
-      since: { type: "string", description: "Optional ISO timestamp lower bound for queried entries." },
-      import_entries: { type: "boolean", description: "When false, query and report evidence without importing remote entries. Defaults true." }
+      node_id: { type: "string", description: "Optional node/workspace used for suggestions. Defaults to the first mesh node." }
     }
   }
 };
-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.",
+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 completed worktree node to refine and merge." }
+      node_id: { type: "string", description: "Node ID of the worktree node to plan." }
     },
     required: ["node_id"]
   }
@@ -1322,33 +2194,41 @@ 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) {
+  let ledgerSummary = (0, import_daemon_core.getLedgerSummary)(mesh.id);
+  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 {
       if (!isLocalTransport(transport) && node.daemonId) {
-        const result = await transport.gitStatus(node.daemonId, node.workspace, false);
+        const result = await transport.gitStatus(node.daemonId, node.workspace, false, true);
         const status = extractGitStatus(result);
         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;
@@ -1362,6 +2242,7 @@ async function meshStatus(ctx) {
         const autoDiscover = node.policy?.autoDiscoverSubmodules !== false;
         const statusResult = await commandForNode(ctx, node, "git_status", {
           workspace: node.workspace,
+          refreshUpstream: true,
           includeSubmodules: autoDiscover,
           submoduleIgnorePaths: node.policy?.submoduleIgnorePaths || void 0
         });
@@ -1369,6 +2250,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;
@@ -1404,7 +2286,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
       };
@@ -1444,7 +2326,55 @@ 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;
+  }));
+  let ledgerEntries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail: 200 });
+  let directDispatches = (0, import_daemon_core.getActiveDirectDispatches)(mesh.id);
+  const directReconciliation = await reconcileDirectDispatchesFromTranscriptEvidence(ctx, results, directDispatches, ledgerEntries);
+  if (directReconciliation.reconciled > 0) {
+    ledgerEntries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail: 200 });
+    directDispatches = (0, import_daemon_core.getActiveDirectDispatches)(mesh.id);
+    ledgerSummary = (0, import_daemon_core.getLedgerSummary)(mesh.id);
+  }
+  const activeWorkEvidence = (0, import_daemon_core.buildMeshActiveWork)({
+    meshId: mesh.id,
+    queue: (0, import_daemon_core.getQueue)(mesh.id),
+    ledgerEntries,
+    directDispatches,
+    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,
@@ -1452,20 +2382,43 @@ 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;
   } catch {
   }
   try {
-    let pendingEvents = [];
-    if (ctx.transport instanceof IpcTransport) {
-      const eventsResult = await ctx.transport.command("get_pending_mesh_events", {});
-      pendingEvents = Array.isArray(eventsResult?.events) ? eventsResult.events : [];
-    } else if (isLocalTransport(ctx.transport)) {
-      pendingEvents = (0, import_daemon_core.drainPendingMeshCoordinatorEvents)();
+    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;
@@ -1476,11 +2429,21 @@ async function meshStatus(ctx) {
 }
 async function meshTaskHistory(ctx, args) {
   const { mesh } = 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);
@@ -1570,6 +2533,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),
@@ -1579,57 +2545,135 @@ 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(() => {
+      const queueTrigger = await triggerMeshQueueAndReport(ctx);
+      return JSON.stringify({
+        success: true,
+        source: "queue",
+        taskId: task.id,
+        status: task.status,
+        taskMode: task.taskMode,
+        requiredTags: task.requiredTags,
+        queueTrigger,
+        ...buildQueueTriggerGuidance(queueTrigger)
       });
-      return JSON.stringify({ success: true, taskId: task.id, status: task.status });
     }
     if (ctx.transport instanceof IpcTransport) {
-      ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
-      });
+      const queueTrigger = await triggerMeshQueueAndReport(ctx);
       const dispatchPromises = [];
       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,
+        queueTrigger,
+        ...buildQueueTriggerGuidance(queueTrigger)
+      });
     }
-    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);
+    let ledgerEntries = (0, import_daemon_core.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
+    let directDispatches = (0, import_daemon_core.getActiveDirectDispatches)(ctx.mesh.id);
+    const directReconciliation = await reconcileDirectDispatchesFromTranscriptEvidence(ctx, liveNodes, directDispatches, ledgerEntries);
+    if (directReconciliation.reconciled > 0) {
+      ledgerEntries = (0, import_daemon_core.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
+      directDispatches = (0, import_daemon_core.getActiveDirectDispatches)(ctx.mesh.id);
+    }
+    (0, import_daemon_core.markStaleDirectDispatches)(ctx.mesh.id);
+    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 MeshRuntimeStore records (may be empty). buildMeshActiveWork uses them for local
+      // dispatches and falls through to ledger scan for remote P2P dispatches not in MeshRuntimeStore.
+      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: {
@@ -1644,21 +2688,29 @@ 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,
+      visibleSummary,
       activeCounts: summary.activeCounts,
       historicalCounts: summary.historicalCounts,
-      activeCount: summary.activeCount,
-      historicalCount: summary.historicalCount,
       visibleActiveCounts: visibleSummary.activeCounts,
       visibleHistoricalCounts: visibleSummary.historicalCounts,
+      activeCount: summary.activeCount,
+      historicalCount: summary.historicalCount,
       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 || "")))
       } : {},
@@ -1678,6 +2730,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 });
@@ -1708,10 +2764,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({
@@ -1735,47 +2841,191 @@ 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.`
+        });
+      }
+      if (explicitTargetSession && !isIdleSessionRecord(explicitTargetSession) && !isTerminalSessionRecord(explicitTargetSession)) {
+        const sessionStatus = typeof explicitTargetSession?.status === "string" ? explicitTargetSession.status : "unknown";
+        const { createSessionDelivery: createDelivery, resolveDeliveryDecision } = await import("@adhdev/daemon-core");
+        const policyResult = resolveDeliveryDecision(sessionStatus, { kind: "task" });
+        if (policyResult.decision === "queued") {
+          const delivery = createDelivery({
+            meshId: ctx.mesh.id,
+            nodeId: args.node_id,
+            sessionId: args.session_id,
+            providerType: resolvedProviderType,
+            kind: "task",
+            message: args.message,
+            status: "queued"
+          });
+          return JSON.stringify({
+            success: true,
+            dispatched: false,
+            decision: "queued_delivery",
+            deliveryId: delivery.id,
+            reason: policyResult.reason,
+            nodeId: args.node_id,
+            sessionId: args.session_id,
+            sessionStatus,
+            taskMode: taskMode || void 0,
+            message: policyResult.message,
+            nextAction: `Use mesh_status to watch for session idle transition, or use mesh_enqueue_task for queue-based assignment. Check deliveryId '${delivery.id}' to track queued delivery.`
+          });
+        }
+      }
+      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,
@@ -1787,23 +3037,79 @@ 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 {
+      }
+      (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
+      });
+      let deliveryId;
+      try {
+        const { createSessionDelivery: createDelivery } = await import("@adhdev/daemon-core");
+        const delivery = createDelivery({
+          meshId: ctx.mesh.id,
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          providerType: resolvedProviderType || void 0,
+          taskId,
+          kind: "task",
+          message: args.message,
+          status: sessionWasIdle ? "delivered" : "delivering"
         });
+        deliveryId = delivery.id;
       } catch {
       }
-      return JSON.stringify({ success: true, dispatched: true, nodeId: args.node_id, sessionId: args.session_id });
+      return JSON.stringify({
+        success: true,
+        dispatched: true,
+        decision: "immediate",
+        source: "direct",
+        taskId,
+        deliveryId,
+        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 queueTrigger = isLocalTransport(ctx.transport) || ctx.transport instanceof IpcTransport ? await triggerMeshQueueAndReport(ctx) : void 0;
+    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,
+      queueTrigger,
+      ...buildQueueTriggerGuidance(queueTrigger)
+    };
     if (pendingEvents.length > 0) {
       result.pendingCoordinatorEvents = pendingEvents;
     }
@@ -1823,8 +3129,11 @@ async function meshReadChat(ctx, args) {
   if (!node) {
     return JSON.stringify(buildMissingNodeReadChatRecovery(ctx, args), null, 2);
   }
+  if (ctx.transport instanceof IpcTransport || isLocalTransport(ctx.transport)) {
+    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,
@@ -1832,18 +3141,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,
@@ -1856,7 +3166,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);
@@ -1870,7 +3180,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", {
@@ -1901,6 +3211,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) {
@@ -1925,6 +3237,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", {
@@ -1952,7 +3268,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 {
@@ -1965,18 +3282,13 @@ 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(() => {
-      });
-    } else if (isLocalTransport(ctx.transport)) {
-      ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
-      });
-    }
+    const queueTrigger = await triggerMeshQueueAndReport(ctx, node, { localNode: isLocalNode });
     return JSON.stringify({
       ...launchPayload,
       resolvedProviderType,
-      ...providerSessionId ? { providerSessionId } : {}
+      ...providerSessionId ? { providerSessionId } : {},
+      queueTrigger,
+      ...buildQueueTriggerGuidance(queueTrigger)
     }, null, 2);
   } else if (!isLocalTransport(ctx.transport) && node.daemonId) {
     let resolvedProviderType = typeof args.type === "string" && args.type.trim() ? args.type : "";
@@ -1990,6 +3302,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,
@@ -2028,7 +3343,7 @@ async function meshGitStatus(ctx, args) {
   const submoduleIgnorePaths = node.policy?.submoduleIgnorePaths || [];
   try {
     if (!isLocalTransport(ctx.transport) && node.daemonId) {
-      const result = await ctx.transport.gitStatus(node.daemonId, node.workspace, true);
+      const result = await ctx.transport.gitStatus(node.daemonId, node.workspace, true, true);
       return JSON.stringify({
         nodeId: args.node_id,
         workspace: node.workspace,
@@ -2040,6 +3355,7 @@ async function meshGitStatus(ctx, args) {
     } else if (isLocalTransport(ctx.transport)) {
       const statusResult = await commandForNode(ctx, node, "git_status", {
         workspace: node.workspace,
+        refreshUpstream: true,
         includeSubmodules: autoDiscoverSubmodules,
         submoduleIgnorePaths: submoduleIgnorePaths.length > 0 ? submoduleIgnorePaths : void 0
       });
@@ -2069,6 +3385,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) {
@@ -2084,7 +3445,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 {
     }
@@ -2100,7 +3467,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 {
       }
@@ -2115,7 +3488,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,
@@ -2154,6 +3527,7 @@ async function meshCloneNode(ctx, args) {
       if (existingIndex >= 0) ctx.mesh.nodes[existingIndex] = clonePayload.node;
       else ctx.mesh.nodes.push(clonePayload.node);
       ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await syncCoordinatorDaemonMeshCache(ctx);
     }
     return JSON.stringify(result, null, 2);
   } else if (!isLocalTransport(ctx.transport) && sourceNode.daemonId) {
@@ -2171,6 +3545,7 @@ async function meshCloneNode(ctx, args) {
         if (existingIndex >= 0) ctx.mesh.nodes[existingIndex] = clonePayload.node;
         else ctx.mesh.nodes.push(clonePayload.node);
         ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await syncCoordinatorDaemonMeshCache(ctx);
       }
       return JSON.stringify(res, null, 2);
     } catch (e) {
@@ -2266,6 +3641,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)) {
@@ -2274,7 +3686,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);
@@ -2289,7 +3701,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);
@@ -2326,13 +3738,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
@@ -2357,6 +3769,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
@@ -2511,8 +3924,8 @@ var CloudTransport = class {
     if (!res.ok) throw new Error(`Approve failed: ${res.status}`);
     return res.json();
   }
-  async gitStatus(daemonId, workspace, includeDiff = true) {
-    const params = new URLSearchParams({ workspace, includeDiff: String(includeDiff) });
+  async gitStatus(daemonId, workspace, includeDiff = true, refreshUpstream = false) {
+    const params = new URLSearchParams({ workspace, includeDiff: String(includeDiff), refreshUpstream: String(refreshUpstream) });
     const res = await fetch(
       `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-status?${params}`,
       { headers: this.headers() }
@@ -2907,6 +4320,28 @@ function formatChatResult(result, sessionId, format, limit = 50, compact = false
       }))
     }, null, 2);
   }
+  if ((format === "text" || format === void 0) && compact && compactPayload) {
+    const summaryText = typeof compactPayload.summary === "string" ? compactPayload.summary.trim() : "";
+    const tail = outputMessages.slice(-limit);
+    const lastIndex = tail.length - 1;
+    const lines2 = tail.flatMap((m, idx) => {
+      const role = m.role === "user" ? "User" : m.role === "assistant" ? "Agent" : m.role;
+      const content = messageContent(m);
+      if (idx === lastIndex && (role === "Agent" || m.role === "agent") && summaryText && content.trim() === summaryText) {
+        return [];
+      }
+      const truncated = content.length > 500 ? `${content.slice(0, 500)}\u2026` : content;
+      return [`[${role}] ${truncated}`];
+    });
+    if (compactPayload.summary) {
+      const truncatedSummary = compactPayload.summary.length > 500 ? `${compactPayload.summary.slice(0, 500)}\u2026` : compactPayload.summary;
+      lines2.push(`[Summary] ${truncatedSummary}`);
+    }
+    if (result?.pollingAdvisory) {
+      lines2.push(`Advisory: ${result.pollingAdvisory.message}`);
+    }
+    return lines2.length > 0 ? lines2.join("\n\n") : "No messages in chat.";
+  }
   if (outputMessages.length === 0) {
     return result?.pollingAdvisory ? `No messages in chat.
 
@@ -3011,6 +4446,90 @@ function formatChatDebugResult(result, options) {
   return JSON.stringify(result, null, 2);
 }
 
+// src/tools/spec-debug.ts
+var SPEC_DEBUG_TOOL = {
+  name: "spec_debug",
+  description: "Get current spec state, sections, and state transition history for a spec-driven CLI session (claude-cli, antigravity-cli, etc.). Use to diagnose idle/busy detection issues, inspect section parsing, or verify idle_hold and busy_hold behavior.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      session_id: {
+        type: "string",
+        description: "Target session ID (from list_sessions)."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only). Omit for local mode."
+      },
+      ...FORMAT_PROP
+    },
+    required: ["session_id"]
+  }
+};
+async function specDebug(transport, args) {
+  const sessionId = typeof args.session_id === "string" ? args.session_id.trim() : "";
+  if (!sessionId) throw new Error("session_id is required");
+  let result;
+  if (isLocalTransport(transport)) {
+    result = await transport.command("get_spec_debug", { targetSessionId: sessionId });
+  } else {
+    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+    const targetId = `${args.daemon_id}:session:${sessionId}`;
+    result = await transport.sendCommand(targetId, "get_spec_debug", { targetSessionId: sessionId });
+  }
+  return formatSpecDebugResult(result, { sessionId, format: args.format });
+}
+function formatSpecDebugResult(result, options) {
+  if (!result?.success) {
+    const err = result?.error || "Unknown error";
+    if (options.format === "json") return JSON.stringify({ success: false, error: err }, null, 2);
+    return `Error: ${err}`;
+  }
+  if (options.format === "json") return JSON.stringify(result, null, 2);
+  const snap = result.snapshot;
+  if (!snap) {
+    return [
+      `session_id: ${options.sessionId}`,
+      `provider_type: ${String(result.providerType || "")}`,
+      "is_spec_provider: false",
+      "No spec debug data available (not a spec-driven provider)."
+    ].join("\n");
+  }
+  const lines = [];
+  lines.push(`session_id: ${options.sessionId}`);
+  lines.push(`provider_type: ${String(result.providerType || snap.cliType || "")}`);
+  lines.push(`spec_id: ${String(snap.spec_id || "")}`);
+  lines.push(`spec_path: ${String(snap.specPath || "")}`);
+  lines.push(`current_state: ${snap.current_state ? `${snap.current_state.id} (${snap.current_state.label})` : "none"}`);
+  lines.push(`idle_hold_pending: ${String(snap.idleHoldPending ?? false)}`);
+  lines.push(`last_busy_at: ${snap.lastBusyAt ? new Date(snap.lastBusyAt).toISOString() : "never"}`);
+  lines.push(`exited: ${String(snap.exited ?? false)}`);
+  if (snap.current_modal) {
+    lines.push(`current_modal: ${JSON.stringify(snap.current_modal)}`);
+  }
+  if (snap.sections && typeof snap.sections === "object") {
+    lines.push("");
+    lines.push("\u2500\u2500 sections \u2500\u2500");
+    for (const [id, text] of Object.entries(snap.sections)) {
+      const preview = String(text || "").replace(/\n/g, "\u21B5").slice(0, 120);
+      lines.push(`  ${id}: ${preview}`);
+    }
+  }
+  const history = Array.isArray(snap.stateHistory) ? snap.stateHistory : [];
+  if (history.length > 0) {
+    lines.push("");
+    lines.push("\u2500\u2500 state history (newest first) \u2500\u2500");
+    const now = Date.now();
+    for (const entry of [...history].reverse().slice(0, 20)) {
+      const agoMs = now - entry.at;
+      const ago = agoMs < 2e3 ? `${agoMs}ms ago` : `${(agoMs / 1e3).toFixed(1)}s ago`;
+      const dur = entry.durationMs > 0 ? `  held ${entry.durationMs}ms` : "";
+      lines.push(`  ${String(entry.stateId).padEnd(18)} ${ago}${dur}`);
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/tools/send-chat.ts
 var SEND_CHAT_TOOL = {
   name: "send_chat",
@@ -3874,6 +5393,7 @@ async function startMcpServer(opts) {
               requirePreTaskCheckpoint: false,
               requirePostTaskCheckpoint: true,
               requireApprovalForPush: true,
+              allowAutoPublishSubmoduleMainCommits: false,
               requireApprovalForDestructiveGit: true,
               dirtyWorkspaceBehavior: "warn",
               maxParallelTasks: 2,
@@ -3930,11 +5450,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 {
       }
     }
@@ -3942,14 +5464,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");
@@ -3975,7 +5499,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);
@@ -4007,6 +5531,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;
@@ -4022,6 +5549,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;
@@ -4053,6 +5592,7 @@ async function startMcpServer(opts) {
     CHECK_PENDING_TOOL,
     READ_CHAT_TOOL,
     READ_CHAT_DEBUG_TOOL,
+    SPEC_DEBUG_TOOL,
     SEND_CHAT_TOOL,
     APPROVE_TOOL,
     GIT_STATUS_TOOL,
@@ -4088,6 +5628,10 @@ async function startMcpServer(opts) {
           const text = await readChatDebug(transport, a);
           return { content: [{ type: "text", text }] };
         }
+        case "spec_debug": {
+          const text = await specDebug(transport, a);
+          return { content: [{ type: "text", text }] };
+        }
         case "send_chat": {
           const text = await sendChat(transport, { message: a.message, session_id: a.session_id, daemon_id: a.daemon_id });
           return { content: [{ type: "text", text }] };