@adhdev/daemon-standalone 0.9.82-rc.22 → 0.9.82-rc.221

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 });
+      }
     });
   }
 };
@@ -143,10 +230,6 @@ function isLocalTransport(transport) {
 }
 
 // src/tools/chat-compact.ts
-function isAssistantLike(message) {
-  const role = String(message?.role ?? "").toLowerCase();
-  return role === "assistant" || role === "agent";
-}
 function messageContent(message) {
   const content = message?.content;
   if (typeof content === "string") return content;
@@ -165,11 +248,36 @@ 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 summarizeToolMessage(message) {
+  if (!message || typeof message !== "object") return null;
+  const kind = String(message.kind ?? message.type ?? message.messageKind ?? "").toLowerCase();
+  const role = String(message.role ?? "").toLowerCase();
+  if (kind === "terminal" || kind === "bash") {
+    const cmd = message.command ?? message.cmd ?? message.input ?? messageContent(message);
+    const exit = message.exitCode ?? message.exit_code ?? message.code;
+    const cmdShort = typeof cmd === "string" ? cmd.split("\n")[0].slice(0, 120) : null;
+    if (!cmdShort) return null;
+    return exit !== void 0 && exit !== null ? `[Bash] ${cmdShort} \u2192 exit ${exit}` : `[Bash] ${cmdShort}`;
+  }
+  if (kind === "tool_call" || kind === "tool" || role === "tool") {
+    const name = message.name ?? message.toolName ?? message.tool_name ?? message.function?.name;
+    if (typeof name === "string" && name.trim()) return `[Tool] ${name.trim()}`;
+    return null;
+  }
+  if (kind === "tool_result") {
+    const exit = message.exitCode ?? message.exit_code ?? message.code;
+    const name = message.name ?? message.toolName ?? message.tool_name;
+    const label = typeof name === "string" && name.trim() ? name.trim() : "tool";
+    return exit !== void 0 && exit !== null ? `[Tool result: ${label}] exit ${exit}` : null;
+  }
+  return null;
+}
 function buildCompactMessageTail(visibleMessages, opts) {
-  const summary = typeof opts.summary === "string" ? opts.summary.trim() : "";
-  const shouldOmitSummaryMessage = !!summary && !!opts.finalAssistant && isAssistantLike(opts.finalAssistant) && messageContent(opts.finalAssistant).trim() === summary;
-  const sourceMessages = shouldOmitSummaryMessage ? visibleMessages.filter((message) => message !== opts.finalAssistant) : visibleMessages;
-  return sourceMessages.slice(-opts.limit);
+  const tail = visibleMessages.slice(-opts.limit);
+  if (opts.finalAssistant && !tail.includes(opts.finalAssistant)) {
+    return [opts.finalAssistant, ...tail];
+  }
+  return tail;
 }
 function compactChatPayload(payload, opts = {}) {
   const rawMessages = Array.isArray(payload?.messages) ? payload.messages : [];
@@ -181,6 +289,9 @@ function compactChatPayload(payload, opts = {}) {
   });
   const summary = typeof payload?.summary === "string" && payload.summary.trim() ? payload.summary.trim() : messageContent(finalAssistant).trim();
   const messages = buildCompactMessageTail(visible, { summary, finalAssistant, limit });
+  const toolSummaries = rawMessages.filter((m) => !isCoordinatorVisibleMessage(m)).map(summarizeToolMessage).filter((s) => s !== null);
+  const omittedMessages = Math.max(0, rawMessages.length - messages.length);
+  const filteredMessages = Math.max(0, rawMessages.length - visible.length);
   return {
     success: payload?.success !== false,
     compact: true,
@@ -190,8 +301,9 @@ function compactChatPayload(payload, opts = {}) {
     providerSessionId: payload?.providerSessionId ?? null,
     totalMessages: rawMessages.length,
     visibleMessages: visible.length,
-    filteredMessages: visible.length,
-    omittedMessages: Math.max(0, rawMessages.length - visible.length),
+    filteredMessages,
+    omittedMessages,
+    ...toolSummaries.length > 0 ? { toolSummaries } : {},
     summary,
     ...payload?.changedFiles !== void 0 ? { changedFiles: payload.changedFiles } : {},
     ...payload?.testsRun !== void 0 ? { testsRun: payload.testsRun } : {},
@@ -241,17 +353,64 @@ function annotateRapidReadChatAdvisory(payload, options) {
 
 // src/tools/mesh-tools.ts
 var import_daemon_core = require("@adhdev/daemon-core");
+var SESSION_PROVIDER_METADATA_TTL_MS = 30 * 6e4;
 var meshSessionProviderMetadata = /* @__PURE__ */ new Map();
+function getSessionMetadata(key) {
+  const entry = meshSessionProviderMetadata.get(key);
+  if (!entry) return void 0;
+  if (entry.expiresAt <= Date.now()) {
+    meshSessionProviderMetadata.delete(key);
+    return void 0;
+  }
+  return entry;
+}
+var ACTIVE_WORK_POLLING_BACKOFF_MS = 6e4;
+function buildActiveWorkPollingGuidance(summary, now = Date.now()) {
+  if (!summary || summary.generatingCount <= 0) return void 0;
+  return {
+    activeGeneratingWork: true,
+    generatingCount: summary.generatingCount,
+    doNotPollBefore: new Date(now + ACTIVE_WORK_POLLING_BACKOFF_MS).toISOString(),
+    eventSurface: "pendingCoordinatorEvents",
+    nextRecommendedAction: "Wait for pendingCoordinatorEvents/completion events or an explicit user status request. If no terminal evidence appears and the user asks for status, make one bounded status check, then wait again.",
+    message: "Do not repeatedly poll mesh_status/mesh_view_queue/mesh_read_chat while delegated work is generating; terminal ledger or completion evidence will be surfaced through pendingCoordinatorEvents when available."
+  };
+}
 function readString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
+function summarizeTaskMessage(message) {
+  const taskSummary = message.replace(/\s+/g, " ").trim();
+  const taskTitle = taskSummary.length > 96 ? `${taskSummary.slice(0, 93)}...` : taskSummary;
+  return { taskTitle: taskTitle || "(untitled task)", taskSummary };
+}
+function buildDirectTaskPayload(message, via, opts) {
+  const descriptor = summarizeTaskMessage(message);
+  return {
+    source: "direct",
+    via,
+    taskId: opts.taskId,
+    message,
+    taskTitle: descriptor.taskTitle,
+    taskSummary: descriptor.taskSummary,
+    ...opts.taskMode ? { taskMode: opts.taskMode } : {},
+    ...opts.providerType ? { providerType: opts.providerType } : {},
+    ...opts.targetSessionId ? { targetSessionId: opts.targetSessionId } : {},
+    ...opts.dispatchedToIdleSession !== void 0 ? { dispatchedToIdleSession: opts.dispatchedToIdleSession } : {}
+  };
+}
+function findNode(mesh, nodeId) {
+  const node = mesh.nodes.find((n) => n.id === nodeId);
+  if (!node) throw new Error(`Node '${nodeId}' is not a member of mesh '${mesh.name}'`);
+  return node;
+}
 var DUPLICATE_DISPATCH_WINDOW_MS = 6e4;
 var STALE_ASSIGNED_QUEUE_MS = 30 * 6e4;
 var OLD_HISTORICAL_QUEUE_RECORD_MS = 7 * 24 * 60 * 6e4;
 var ACTIVE_QUEUE_STATUSES = /* @__PURE__ */ new Set(["pending", "assigned"]);
 var HISTORICAL_QUEUE_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 async function refreshMeshFromDaemon(ctx) {
-  if (!(ctx.transport instanceof IpcTransport)) return;
+  if (!isLocalTransport(ctx.transport)) return;
   try {
     const result = await ctx.transport.command("get_mesh", { meshId: ctx.mesh.id });
     if (!result?.success || !Array.isArray(result.mesh?.nodes)) return;
@@ -412,6 +571,25 @@ function extractStatusMetadataSessions(value) {
 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);
@@ -480,18 +658,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
     },
@@ -519,6 +705,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,
@@ -612,6 +810,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() : "";
@@ -627,16 +991,23 @@ function isIdleSessionRecord(session) {
 function isMeshOwnedDelegateSession(session, meshId, nodeId) {
   const settings = session?.settings;
   const sessionMeshId = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
-  const coordinatorDaemonId = typeof settings?.meshCoordinatorDaemonId === "string" ? settings.meshCoordinatorDaemonId.trim() : "";
   const sessionNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
-  if (sessionMeshId !== meshId || !coordinatorDaemonId) return false;
+  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) => isMeshOwnedDelegateSession(session, meshId, nodeId)
+    (session) => isRelaySafeRemoteDelegateSession(session, meshId, nodeId)
   );
   return meshSessions.find((session) => isIdleSessionRecord(session) && matchingProvider(session)) || meshSessions.find(matchingProvider) || void 0;
 }
@@ -653,8 +1024,9 @@ function buildRelayUnsafeRemoteSessionFailure(ctx, node, sessionId, providerType
     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.`,
+    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."
   };
@@ -704,12 +1076,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));
 }
@@ -834,7 +1210,20 @@ 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 || args.session_id) {
+  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 sessions = extractStatusMetadataSessions(relayResult);
@@ -858,7 +1247,7 @@ async function ipcDispatchToRemoteAgent(ctx, node, args) {
             nextAction: `Launch a fresh session with mesh_launch_session(node_id: '${node.id}'${resolvedProviderType ? `, type: '${resolvedProviderType}'` : ""}) or retry without session_id so Repo Mesh can target a live delegate session.`
           };
         }
-        if (!isMeshOwnedDelegateSession(explicitSession, ctx.mesh.id, node.id)) {
+        if (!isRelaySafeRemoteDelegateSession(explicitSession, ctx.mesh.id, node.id)) {
           return buildRelayUnsafeRemoteSessionFailure(
             ctx,
             node,
@@ -902,7 +1291,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) {
@@ -920,7 +1310,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 {
@@ -950,34 +1340,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"];
@@ -988,8 +1541,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) => ({
@@ -1048,6 +1616,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 {
@@ -1062,6 +1640,45 @@ function getNodeLaunchReadiness(node) {
     launchBlockedMessage: missingProviderPriorityMessage(node.id)
   };
 }
+function getWorktreeBootstrapLaunchBlock(node, meshPolicy) {
+  if (!node.isLocalWorktree) return void 0;
+  const bootstrap = node.worktreeBootstrap;
+  const requireReady = !!(meshPolicy && typeof meshPolicy === "object" && meshPolicy.requireBootstrapBeforeLaunch === true);
+  if (requireReady && bootstrap?.status !== "ready") {
+    return {
+      success: false,
+      code: "bootstrap_not_ready",
+      error: `Node '${node.id}' bootstrap state is '${bootstrap?.status ?? "unknown"}' and mesh policy requireBootstrapBeforeLaunch is enabled.`,
+      nodeId: node.id,
+      worktreeBootstrap: bootstrap ?? null,
+      recoveryHint: "Run the worktree bootstrap (clone runOnClone or a refine with bootstrap inherit) until the node reports ready, or disable requireBootstrapBeforeLaunch."
+    };
+  }
+  if (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;
@@ -1197,7 +1814,8 @@ async function commandForNode(ctx, node, command, args = {}) {
   if (isLocalTransport(ctx.transport)) {
     return ctx.transport.command(command, args);
   }
-  throw new Error(`Command '${command}' requires daemon IPC/local transport for node '${node.id}'`);
+  const identity = buildNodeMachineIdentity(ctx, node);
+  throw new Error(`Command '${command}' requires daemon IPC/local transport for node '${node.id}' (hostname=${identity.hostname || "unknown"}, coordinatorHostname=${identity.coordinatorHostname || "unknown"}, sameMachine=${identity.sameMachine})`);
 }
 function normalizePendingMeshCoordinatorEvents(value) {
   const payload = unwrapCommandPayload(value);
@@ -1215,6 +1833,14 @@ function buildMeshForwardPayloadFromPendingEvent(event) {
     providerType: readString(metadataEvent.providerType),
     providerSessionId: readString(metadataEvent.providerSessionId),
     finalSummary: readString(metadataEvent.finalSummary) || readString(metadataEvent.summary),
+    jobId: readString(metadataEvent.jobId),
+    interactionId: readString(metadataEvent.interactionId),
+    status: readString(metadataEvent.status),
+    targetDaemonId: readString(metadataEvent.targetDaemonId),
+    startedAt: readString(metadataEvent.startedAt),
+    completedAt: readString(metadataEvent.completedAt),
+    retryOfJobId: readString(metadataEvent.retryOfJobId),
+    ...metadataEvent.result && typeof metadataEvent.result === "object" && !Array.isArray(metadataEvent.result) ? { result: metadataEvent.result } : {},
     ...metadataEvent.intentional === true ? { intentional: true } : {},
     ...metadataEvent.intentionalStop === true ? { intentionalStop: true } : {},
     ...metadataEvent.operatorCleanup === true ? { operatorCleanup: true } : {},
@@ -1229,10 +1855,16 @@ async function drainCoordinatorPendingEvents(ctx, opts) {
   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", {})).filter(matchesCurrentMesh)
+        ...normalizePendingMeshCoordinatorEvents(await ctx.transport.command("get_pending_mesh_events", pendingEventArgs)).filter(matchesCurrentMesh)
       );
+      surfacedEvents.forEach(rememberMeshSessionProviderMetadataFromEvent);
     } catch {
     }
     for (const node of ctx.mesh.nodes) {
@@ -1240,27 +1872,31 @@ async function drainCoordinatorPendingEvents(ctx, opts) {
       if (requestedNodeIds && !requestedNodeIds.has(node.id)) continue;
       try {
         const remoteEvents = normalizePendingMeshCoordinatorEvents(
-          await ctx.transport.meshCommand(node.daemonId, "get_pending_mesh_events", {})
+          await ctx.transport.meshCommand(node.daemonId, "get_pending_mesh_events", 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", {})).filter(matchesCurrentMesh)
+        ...normalizePendingMeshCoordinatorEvents(await ctx.transport.command("get_pending_mesh_events", pendingEventArgs)).filter(matchesCurrentMesh)
       );
+      surfacedEvents.forEach(rememberMeshSessionProviderMetadataFromEvent);
     } catch {
     }
     return surfacedEvents;
   }
   if (isLocalTransport(ctx.transport)) {
-    return (0, import_daemon_core.drainPendingMeshCoordinatorEvents)().filter(matchesCurrentMesh);
+    const events = (0, import_daemon_core.drainPendingMeshCoordinatorEvents)(ctx.mesh.id, ctx.localDaemonId).filter(matchesCurrentMesh);
+    events.forEach(rememberMeshSessionProviderMetadataFromEvent);
+    return events;
   }
   return [];
 }
@@ -1277,11 +1913,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." }
     }
   }
 };
@@ -1301,14 +1938,22 @@ 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." },
+      depends_on: { type: "array", items: { type: "string" }, description: "Task ids that must complete before this task becomes claimable. Cycles are rejected at enqueue." },
+      dependsOn: { type: "array", items: { type: "string" }, description: "CamelCase alias for depends_on." },
+      mission_id: { type: "string", description: "Mission this task belongs to (mesh_mission record id)." },
+      missionId: { type: "string", description: "CamelCase alias for mission_id." }
     },
     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: {
@@ -1339,7 +1984,7 @@ var MESH_QUEUE_CANCEL_TOOL = {
 };
 var MESH_QUEUE_REQUEUE_TOOL = {
   name: "mesh_queue_requeue",
-  description: "Return a mesh queue task to pending for retry. By default clears stale assigned owner and target session so another live session can claim it.",
+  description: "Return a mesh queue task to pending for retry. By default clears stale assigned owner and target session so another live session can claim it. When the task has exceeded its retry cap it is auto-failed instead; use force=true to override.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1348,7 +1993,8 @@ var MESH_QUEUE_REQUEUE_TOOL = {
       target_node_id: { type: "string", description: "Optional replacement target node ID." },
       target_session_id: { type: "string", description: "Optional replacement target runtime session ID." },
       clear_target_node: { type: "boolean", description: "When true, remove any existing target node constraint." },
-      keep_target_session: { type: "boolean", description: "When true, preserve an existing target session if target_session_id is not provided. Defaults false to avoid stale session targets." }
+      keep_target_session: { type: "boolean", description: "When true, preserve an existing target session if target_session_id is not provided. Defaults false to avoid stale session targets." },
+      force: { type: "boolean", description: "When true, bypass the retry cap and requeue even if maxRetries has been exceeded. Use only for explicit operator recovery." }
     },
     required: ["task_id"]
   }
@@ -1361,7 +2007,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"]
   }
@@ -1419,6 +2067,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.",
@@ -1431,6 +2094,20 @@ var MESH_CHECKPOINT_TOOL = {
     required: ["node_id", "message"]
   }
 };
+var MESH_MISSION_UPSERT_TOOL = {
+  name: "mesh_mission_upsert",
+  description: "Create or update a persistent mission record so the plan survives coordinator restarts. Create a mission before enqueueing a multi-task batch, attach tasks via mesh_enqueue_task mission_id, and update status to completed/abandoned when the outcome is decided. Progress is derived from task statuses \u2014 there is no separate progress field.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      mission_id: { type: "string", description: "Mission id to update. Omit to create a new mission." },
+      title: { type: "string", description: "Short mission title." },
+      goal: { type: "string", description: "Free-text mission goal/definition of done." },
+      status: { type: "string", enum: ["active", "paused", "completed", "abandoned"], description: "Mission lifecycle status. Defaults to active on create." }
+    },
+    required: ["title"]
+  }
+};
 var MESH_APPROVE_TOOL = {
   name: "mesh_approve",
   description: "Approve or reject a pending action on a delegated agent session.",
@@ -1502,7 +2179,7 @@ var MESH_TASK_HISTORY_TOOL = {
     type: "object",
     properties: {
       tail: { type: "number", description: "Number of recent entries to return (default: 20)." },
-      kind: { type: "string", description: "Filter by entry kind: task_dispatched, task_completed, task_failed, task_stalled, session_launched, checkpoint_created, node_cloned, node_removed." }
+      kind: { type: "string", description: "Filter by entry kind: task_dispatched, task_completed, task_failed, task_stalled, session_launched, checkpoint_created, node_cloned, node_removed, direct_fast_forward." }
     }
   }
 };
@@ -1522,7 +2199,7 @@ var MESH_RECONCILE_LEDGER_TOOL = {
 };
 var MESH_REFINE_NODE_TOOL = {
   name: "mesh_refine_node",
-  description: "The Refinery: Automatically validate and merge a completed worktree node back into its base branch. This tool automates the validation gate and merge queue step. It will merge the node's branch into its base branch and cleanly remove the worktree node and its sessions.",
+  description: "The Refinery: Accept an async validation/merge/cleanup job for a completed worktree node. The immediate response includes async:true, status:'accepted', jobId, interactionId, target node, and startedAt; completion/failure evidence is delivered through pending mesh events and the mesh task ledger.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1531,6 +2208,54 @@ var MESH_REFINE_NODE_TOOL = {
     required: ["node_id"]
   }
 };
+var MESH_REFINE_CONFIG_SCHEMA_TOOL = {
+  name: "mesh_refine_config_schema",
+  description: "Return the Repo Mesh Refinery config JSON schema and supported repo-local config locations. This is the validation source of truth; heuristic command detection is suggestions-only.",
+  inputSchema: { type: "object", properties: {} }
+};
+var MESH_VALIDATE_REFINE_CONFIG_TOOL = {
+  name: "mesh_validate_refine_config",
+  description: "Validate the repo mesh/refine config for a node/workspace without running validation commands or merging.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Optional node/workspace whose refine config should be loaded. Defaults to the first mesh node." },
+      config: { type: "object", description: "Optional inline config object to validate instead of loading from the repo." }
+    }
+  }
+};
+var MESH_SUGGEST_REFINE_CONFIG_TOOL = {
+  name: "mesh_suggest_refine_config",
+  description: "Suggest a repo mesh/refine config scaffold from project context/package scripts. Suggestions are never executed until saved as explicit refine config.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Optional node/workspace used for suggestions. Defaults to the first mesh node." }
+    }
+  }
+};
+var MESH_REFINE_PLAN_TOOL = {
+  name: "mesh_refine_plan",
+  description: "Dry-run Refinery plan for a worktree node: reports config source, validation commands, suggestions/unavailable reason, and merge/cleanup intent without executing validation or git merge.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Node ID of the worktree node to plan." }
+    },
+    required: ["node_id"]
+  }
+};
+var MESH_REVIEW_INBOX_TOOL = {
+  name: "mesh_review_inbox",
+  description: "List local worktree nodes that need human review: merge candidates (pushed feature branches ready to merge) and Refinery-blocked review results. Returns evidence summaries, diff stats vs. the default branch, and suggested actions (Refine / Requeue / Dismiss). Remote nodes are excluded in M4.0.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      mesh_id: { type: "string", description: "Mesh ID (optional \u2014 inferred from active mesh if omitted)." }
+    },
+    required: []
+  }
+};
 var ALL_MESH_TOOLS = [
   MESH_STATUS_TOOL,
   MESH_LIST_NODES_TOOL,
@@ -1543,24 +2268,34 @@ 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
+  MESH_RECONCILE_LEDGER_TOOL,
+  MESH_MISSION_UPSERT_TOOL,
+  MESH_REVIEW_INBOX_TOOL
 ];
-async function meshStatus(ctx) {
+async function meshStatus(ctx, args = {}) {
+  const rateResult = (0, import_daemon_core.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_status" });
   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 {
@@ -1570,6 +2305,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;
@@ -1591,6 +2327,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;
@@ -1626,7 +2363,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
       };
@@ -1661,12 +2398,60 @@ async function meshStatus(ctx) {
         nextStepHints.push(`Consider reassigning work to a different node.`);
       }
     }
-    if (nextStepHints.length > 0) {
-      entry.nextStepHints = nextStepHints;
-    }
-    const relatedRepos = await collectRelatedRepoStatuses(ctx, node);
-    if (relatedRepos.length) entry.relatedRepos = relatedRepos;
-    results.push(entry);
+    if (nextStepHints.length > 0) {
+      entry.nextStepHints = nextStepHints;
+    }
+    const relatedRepos = await collectRelatedRepoStatuses(ctx, node);
+    if (relatedRepos.length) entry.relatedRepos = relatedRepos;
+    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,
@@ -1677,17 +2462,55 @@ async function meshStatus(ctx) {
     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 } : {},
+    ...rateResult.rateLimitExceeded ? { pollingRateAdvisory: { type: "rate_limit_exceeded", tool: "mesh_status", callsInWindow: rateResult.callsInWindow, message: rateResult.advisory } } : {},
+    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 {
+    const missions = (0, import_daemon_core.getActiveMeshMissionSummaries)(mesh.id);
+    if (missions.length > 0) {
+      response.missions = missions.map((mission) => {
+        try {
+          return { ...mission, stats: (0, import_daemon_core.computeMeshMissionStats)(mesh.id, mission.id) };
+        } catch {
+          return mission;
+        }
+      });
+    }
+  } catch {
+  }
   try {
     const pendingEvents = await drainCoordinatorPendingEvents(ctx);
+    const asyncRefineJobs = (0, import_daemon_core.buildMeshAsyncRefineJobs)({
+      meshId: mesh.id,
+      ledgerEntries,
+      pendingEvents
+    });
+    if (asyncRefineJobs.length > 0) {
+      response.asyncRefineJobs = asyncRefineJobs;
+    }
     if (pendingEvents.length > 0) {
       response.pendingCoordinatorEvents = pendingEvents;
     }
@@ -1697,12 +2520,31 @@ async function meshStatus(ctx) {
 }
 async function meshTaskHistory(ctx, args) {
   const { mesh } = ctx;
-  await drainCoordinatorPendingEvents(ctx);
+  const pendingEvents = await drainCoordinatorPendingEvents(ctx);
   const tail = typeof args.tail === "number" && args.tail > 0 ? args.tail : 20;
   const kind = typeof args.kind === "string" && args.kind.trim() ? [args.kind.trim()] : void 0;
-  const entries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail, kind });
+  const rawEntries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail, kind });
+  const entries = rawEntries.map((e) => ({
+    ...e,
+    payload: e.payload ? slimLedgerPayload(e.payload) : e.payload
+  }));
   const summary = (0, import_daemon_core.getLedgerSummary)(mesh.id);
-  return JSON.stringify({ meshId: mesh.id, entries, summary }, null, 2);
+  let taskStats;
+  try {
+    const taskIds = [...new Set(rawEntries.map((e) => typeof e.payload?.taskId === "string" ? e.payload.taskId : "").filter(Boolean))];
+    if (taskIds.length > 0) {
+      const stats = (0, import_daemon_core.computeMeshTaskStats)(mesh.id, { taskIds });
+      if (stats.length > 0) taskStats = stats;
+    }
+  } catch {
+  }
+  return JSON.stringify({
+    meshId: mesh.id,
+    entries,
+    summary,
+    ...taskStats ? { taskStats } : {},
+    ...pendingEvents.length > 0 ? { pendingCoordinatorEvents: pendingEvents } : {}
+  }, null, 2);
 }
 async function meshReconcileLedger(ctx, args) {
   await refreshMeshFromDaemon(ctx);
@@ -1719,7 +2561,7 @@ async function meshReconcileLedger(ctx, args) {
   for (const node of nodes) {
     try {
       if (isLocalControlPlaneNode(ctx, node) || !node.daemonId) {
-        const slice2 = (0, import_daemon_core.readLedgerSlice)(ctx.mesh.id, queryArgs);
+        const slice2 = (0, import_daemon_core.readLedgerSliceFromStore)(ctx.mesh.id, queryArgs);
         replicas.push((0, import_daemon_core.buildMeshLedgerReplicaEvidence)({
           nodeId: node.id,
           daemonId: node.daemonId,
@@ -1792,6 +2634,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),
@@ -1800,58 +2645,168 @@ async function meshListNodes(ctx) {
     }))
   }, null, 2);
 }
+async function meshMissionUpsert(ctx, args) {
+  try {
+    const mission = (0, import_daemon_core.upsertMeshMission)(ctx.mesh.id, {
+      id: readString(args.mission_id) || readString(args.missionId) || void 0,
+      title: args.title,
+      goal: typeof args.goal === "string" ? args.goal : void 0,
+      status: readString(args.status) || void 0
+    });
+    return JSON.stringify({
+      success: true,
+      mission,
+      nextAction: "Attach tasks with mesh_enqueue_task mission_id and depends_on. mesh_status shows live task aggregates for this mission."
+    });
+  } catch (e) {
+    const message = e?.message || String(e);
+    const code = message.includes("mission_title_required") ? "mission_title_required" : message.includes("invalid_mission_status") ? "invalid_mission_status" : void 0;
+    return JSON.stringify({ success: false, ...code ? { code } : {}, error: message });
+  }
+}
 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);
+  const dependsOn = Array.isArray(args.dependsOn) ? args.dependsOn : Array.isArray(args.depends_on) ? args.depends_on : void 0;
+  const missionId = readString(args.missionId) || readString(args.mission_id) || void 0;
   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, dependsOn, missionId });
     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 });
+    }
+    if (message.includes("dependency_cycle_detected")) {
+      return JSON.stringify({ success: false, code: "dependency_cycle_detected", dependsOn, error: message });
+    }
+    return JSON.stringify({ success: false, error: message });
   }
 }
 async function meshViewQueue(ctx, args) {
+  const rateResult = (0, import_daemon_core.recordMeshToolCall)({ meshId: ctx.mesh.id, tool: "mesh_view_queue" });
   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 rawQueue = (0, import_daemon_core.getQueue)(ctx.mesh.id);
+    const statusById = new Map(rawQueue.map((task) => [task.id, task.status]));
+    const withDependencies = rawQueue.map((task) => {
+      if (!Array.isArray(task.dependsOn) || task.dependsOn.length === 0) return task;
+      const depState = (0, import_daemon_core.describeTaskDependencyState)(task, statusById);
+      return { ...task, ...depState };
+    });
+    const fullQueue = prioritizeActiveQueueRows(annotateQueueStaleness(withDependencies, 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: {
@@ -1866,21 +2821,30 @@ 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 } : {},
+      ...rateResult.rateLimitExceeded ? { pollingRateAdvisory: { type: "rate_limit_exceeded", tool: "mesh_view_queue", callsInWindow: rateResult.callsInWindow, message: rateResult.advisory } } : {},
       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 || "")))
       } : {},
@@ -1900,6 +2864,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 });
@@ -1917,9 +2885,19 @@ async function meshQueueRequeue(ctx, args) {
       targetNodeId,
       targetSessionId,
       clearTargetNode: args.clear_target_node === true || args.clearTargetNode === true,
-      clearTargetSession: targetSessionId ? false : !keepTargetSession
+      clearTargetSession: targetSessionId ? false : !keepTargetSession,
+      force: args.force === true
     });
     if (!task) return JSON.stringify({ success: false, error: `Queue task '${taskId}' not found` });
+    if (task.status === "failed" && task.cancelReason?.startsWith("max_retries_exceeded")) {
+      return JSON.stringify({
+        success: false,
+        code: "max_retries_exceeded",
+        error: task.cancelReason,
+        task,
+        hint: "Use force=true to bypass the retry cap for explicit operator recovery."
+      }, null, 2);
+    }
     if (isLocalTransport(ctx.transport)) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
@@ -1930,10 +2908,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({
@@ -1957,43 +2985,76 @@ 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) {
-        const statusResult = await commandForNode(ctx, node, "get_status_metadata", {});
-        const sessions = extractStatusMetadataSessions(statusResult);
-        const explicitSession = sessions.find((session) => readSessionRecordId(session) === args.session_id);
+        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,
@@ -2008,11 +3069,40 @@ async function meshSendTask(ctx, args) {
             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
+            providerSessionId: readString(explicitSession?.providerSessionId) || void 0,
+            expiresAt: Date.now() + SESSION_PROVIDER_METADATA_TTL_MS
           });
         }
       }
@@ -2030,17 +3120,56 @@ async function meshSendTask(ctx, args) {
           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,
         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,
@@ -2053,22 +3182,78 @@ async function meshSendTask(ctx, args) {
           nodeId: args.node_id,
           sessionId: args.session_id,
           providerType: resolvedProviderType,
-          payload: { message: args.message, via: "local_direct" }
+          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;
     }
@@ -2092,7 +3277,7 @@ async function meshReadChat(ctx, args) {
     await drainCoordinatorPendingEvents(ctx, { nodeIds: [args.node_id] });
   }
   if (isLocalTransport(ctx.transport)) {
-    const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+    const cached = resolveMeshSessionProviderMetadata(ctx, args.node_id, args.session_id);
     const providerSessionId = typeof args.provider_session_id === "string" && args.provider_session_id.trim() ? args.provider_session_id.trim() : cached?.providerSessionId;
     const result = await commandForNode(ctx, node, "read_chat", {
       sessionId: args.session_id,
@@ -2107,7 +3292,8 @@ async function meshReadChat(ctx, args) {
       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,
@@ -2138,7 +3324,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", {
@@ -2169,6 +3355,8 @@ async function meshReadDebug(ctx, args) {
 }
 async function meshLaunchSession(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
+  const bootstrapBlock = getWorktreeBootstrapLaunchBlock(node, ctx.mesh.policy);
+  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) {
@@ -2203,6 +3391,9 @@ async function meshLaunchSession(ctx, args) {
         cliType: resolvedProviderType,
         dir: node.workspace,
         settings: {
+          // Worker launch envelope (A5): structured metadata so worker sessions
+          // know their role and can route completion events back correctly.
+          role: "worker",
           meshNodeFor: ctx.mesh.id,
           meshNodeId: args.node_id,
           spawnedSessionVisibility,
@@ -2224,7 +3415,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 {
@@ -2237,17 +3429,13 @@ async function meshLaunchSession(ctx, args) {
       });
     } catch {
     }
-    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 : "";
@@ -2344,6 +3532,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) {
@@ -2359,7 +3592,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 {
     }
@@ -2375,7 +3614,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 {
       }
@@ -2390,7 +3635,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,
@@ -2543,6 +3788,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)) {
@@ -2551,7 +3833,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);
@@ -2566,7 +3848,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);
@@ -2581,6 +3863,18 @@ async function meshRefineNode(ctx, args) {
     return JSON.stringify({ error: "Cloud mesh refine_node requires node daemonId" });
   }
 }
+async function meshReviewInbox(ctx, args = {}) {
+  if (!isLocalTransport(ctx.transport)) {
+    return JSON.stringify({ error: "mesh_review_inbox requires a local daemon transport (M4.0 scope: local nodes only)" });
+  }
+  await refreshMeshFromDaemon(ctx);
+  const meshId = (args.mesh_id ?? ctx.mesh.id).trim();
+  const result = await commandForNode(ctx, ctx.mesh.nodes[0], "get_mesh_review_inbox", {
+    meshId,
+    inlineMesh: ctx.mesh
+  });
+  return JSON.stringify(result, null, 2);
+}
 
 // src/help.ts
 var STANDARD_TOOLS = [
@@ -2603,13 +3897,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
@@ -2634,6 +3928,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
@@ -3185,11 +4480,17 @@ function formatChatResult(result, sessionId, format, limit = 50, compact = false
     }, null, 2);
   }
   if ((format === "text" || format === void 0) && compact && compactPayload) {
-    const lines2 = outputMessages.slice(-limit).map((m) => {
+    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}`;
+      return [`[${role}] ${truncated}`];
     });
     if (compactPayload.summary) {
       const truncatedSummary = compactPayload.summary.length > 500 ? `${compactPayload.summary.slice(0, 500)}\u2026` : compactPayload.summary;
@@ -3304,6 +4605,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",
@@ -4167,6 +5552,7 @@ async function startMcpServer(opts) {
               requirePreTaskCheckpoint: false,
               requirePostTaskCheckpoint: true,
               requireApprovalForPush: true,
+              allowAutoPublishSubmoduleMainCommits: false,
               requireApprovalForDestructiveGit: true,
               dirtyWorkspaceBehavior: "warn",
               maxParallelTasks: 2,
@@ -4223,11 +5609,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 {
       }
     }
@@ -4235,14 +5623,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");
@@ -4268,7 +5658,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);
@@ -4300,6 +5690,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;
@@ -4315,6 +5708,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;
@@ -4324,6 +5729,12 @@ async function startMcpServer(opts) {
           case "mesh_reconcile_ledger":
             text = await meshReconcileLedger(meshCtx, a);
             break;
+          case "mesh_mission_upsert":
+            text = await meshMissionUpsert(meshCtx, a);
+            break;
+          case "mesh_review_inbox":
+            text = await meshReviewInbox(meshCtx, a);
+            break;
           default:
             return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
         }
@@ -4346,6 +5757,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,
@@ -4381,6 +5793,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 }] };