@adhdev/daemon-standalone 0.9.82-rc.24 → 0.9.82-rc.241

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,87 +185,46 @@ 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 });
+      }
     });
   }
 };
 
-// src/transports/mode.ts
-function isLocalTransport(transport) {
-  return typeof transport.command === "function";
-}
-
 // 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 +243,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 +284,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 +296,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 +348,63 @@ 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;
   try {
     const result = await ctx.transport.command("get_mesh", { meshId: ctx.mesh.id });
     if (!result?.success || !Array.isArray(result.mesh?.nodes)) return;
@@ -412,6 +565,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 +652,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 +699,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 +804,169 @@ 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) {
+  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 {
+      raw = await ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id });
+    }
+    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 +982,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 +1015,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 +1067,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 +1201,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 +1238,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 +1282,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 +1301,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 +1331,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 +1532,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) => ({
@@ -1024,7 +1583,7 @@ async function collectRelatedRepoStatuses(ctx, node) {
   const results = [];
   for (const repo of relatedRepos) {
     try {
-      const statusResult = !isLocalTransport(ctx.transport) && node.daemonId ? await ctx.transport.gitStatus(node.daemonId, repo.workspace, false, true) : await commandForNode(ctx, node, "git_status", { workspace: repo.workspace, refreshUpstream: true });
+      const statusResult = await commandForNode(ctx, node, "git_status", { workspace: repo.workspace, refreshUpstream: true });
       const status = extractGitStatus(statusResult);
       results.push(summarizeRelatedRepoStatus(repo, status));
     } catch (e) {
@@ -1048,6 +1607,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 +1631,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;
@@ -1194,10 +1802,7 @@ async function commandForNode(ctx, node, command, args = {}) {
   if (ctx.transport instanceof IpcTransport && node.daemonId && !isLocalNode) {
     return ctx.transport.meshCommand(node.daemonId, 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}'`);
+  return ctx.transport.command(command, args);
 }
 function normalizePendingMeshCoordinatorEvents(value) {
   const payload = unwrapCommandPayload(value);
@@ -1215,6 +1820,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 +1842,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", { meshId: ctx.mesh.id })).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,29 +1859,30 @@ 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", { meshId: ctx.mesh.id })
+          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", { meshId: ctx.mesh.id })).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)(ctx.mesh.id).filter(matchesCurrentMesh);
-  }
-  return [];
+  const events = (0, import_daemon_core.drainPendingMeshCoordinatorEvents)(ctx.mesh.id, ctx.localDaemonId).filter(matchesCurrentMesh);
+  events.forEach(rememberMeshSessionProviderMetadataFromEvent);
+  return events;
 }
 function isP2pTransportUnavailableError(error) {
   return (0, import_daemon_core.isP2pRelayTransportFailure)(error);
@@ -1277,11 +1897,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 +1922,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 +1968,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 +1977,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 +1991,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 +2051,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 +2078,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 +2163,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 +2183,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,78 +2192,117 @@ var MESH_REFINE_NODE_TOOL = {
     required: ["node_id"]
   }
 };
-var ALL_MESH_TOOLS = [
-  MESH_STATUS_TOOL,
-  MESH_LIST_NODES_TOOL,
-  MESH_ENQUEUE_TASK_TOOL,
-  MESH_VIEW_QUEUE_TOOL,
-  MESH_QUEUE_CANCEL_TOOL,
-  MESH_QUEUE_REQUEUE_TOOL,
-  MESH_SEND_TASK_TOOL,
-  MESH_READ_CHAT_TOOL,
-  MESH_READ_DEBUG_TOOL,
+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,
+  MESH_ENQUEUE_TASK_TOOL,
+  MESH_VIEW_QUEUE_TOOL,
+  MESH_QUEUE_CANCEL_TOOL,
+  MESH_QUEUE_REQUEUE_TOOL,
+  MESH_SEND_TASK_TOOL,
+  MESH_READ_CHAT_TOOL,
+  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 {
-      if (!isLocalTransport(transport) && node.daemonId) {
-        const result = await transport.gitStatus(node.daemonId, node.workspace, false, true);
-        const status = extractGitStatus(result);
-        const uncommittedChanges = countUncommittedChanges(status);
-        const dirty = isGitStatusDirty(status);
-        entry.health = status?.isGitRepo ? dirty ? "dirty" : "online" : "degraded";
-        entry.branch = status?.branch;
-        entry.isDirty = dirty;
-        entry.uncommittedChanges = uncommittedChanges;
-        entry.branchConvergence = buildBranchConvergence(mesh, node, status, dirty, uncommittedChanges);
-        const submodules = extractSubmodules(result, node.policy?.submoduleIgnorePaths || []);
-        if (submodules && submodules.some((s) => s?.outOfSync)) {
-          entry.submoduleWarning = "One or more submodules are out of sync with the parent repo. Run `git submodule update` or check deployment readiness.";
-          entry.outOfSyncSubmodules = submodules.filter((s) => s?.outOfSync).map((s) => s.path);
-        }
-      } else if (isLocalTransport(transport)) {
-        const autoDiscover = node.policy?.autoDiscoverSubmodules !== false;
-        const statusResult = await commandForNode(ctx, node, "git_status", {
-          workspace: node.workspace,
-          refreshUpstream: true,
-          includeSubmodules: autoDiscover,
-          submoduleIgnorePaths: node.policy?.submoduleIgnorePaths || void 0
-        });
-        const status = extractGitStatus(statusResult);
-        const uncommittedChanges = countUncommittedChanges(status);
-        const dirty = isGitStatusDirty(status);
-        entry.health = status?.isGitRepo ? dirty ? "dirty" : "online" : "degraded";
-        entry.branch = status?.branch;
-        entry.isDirty = dirty;
-        entry.uncommittedChanges = uncommittedChanges;
-        entry.branchConvergence = buildBranchConvergence(mesh, node, status, dirty, uncommittedChanges);
-        const submodules = extractSubmodules(statusResult, node.policy?.submoduleIgnorePaths || []);
-        if (submodules && submodules.some((s) => s?.outOfSync)) {
-          entry.submoduleWarning = "One or more submodules are out of sync with the parent repo. Run `git submodule update` or check deployment readiness.";
-          entry.outOfSyncSubmodules = submodules.filter((s) => s?.outOfSync).map((s) => s.path);
-        }
-      } else {
-        entry.health = "unknown";
-        entry.note = "No daemonId available for cloud status probe";
+      const autoDiscover = node.policy?.autoDiscoverSubmodules !== false;
+      const statusResult = await commandForNode(ctx, node, "git_status", {
+        workspace: node.workspace,
+        refreshUpstream: true,
+        includeSubmodules: autoDiscover,
+        submoduleIgnorePaths: node.policy?.submoduleIgnorePaths || void 0
+      });
+      const status = extractGitStatus(statusResult);
+      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;
+      entry.branchConvergence = buildBranchConvergence(mesh, node, status, dirty, uncommittedChanges);
+      const submodules = extractSubmodules(statusResult, node.policy?.submoduleIgnorePaths || []);
+      if (submodules && submodules.some((s) => s?.outOfSync)) {
+        entry.submoduleWarning = "One or more submodules are out of sync with the parent repo. Run `git submodule update` or check deployment readiness.";
+        entry.outOfSyncSubmodules = submodules.filter((s) => s?.outOfSync).map((s) => s.path);
       }
     } catch (e) {
       const failure = buildCoordinatorP2pRelayFailure(e, {
@@ -1626,7 +2326,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
       };
@@ -1666,7 +2366,55 @@ async function meshStatus(ctx) {
     }
     const relatedRepos = await collectRelatedRepoStatuses(ctx, node);
     if (relatedRepos.length) entry.relatedRepos = relatedRepos;
-    results.push(entry);
+    const liveSessions = await collectLiveStatusSessions(ctx, node);
+    if (liveSessions.length > 0) {
+      entry.sessions = liveSessions.map((s) => {
+        const coordinatorMeshId = typeof s.coordinator?.meshId === "string" ? s.coordinator.meshId : void 0;
+        const isSelfCoordinator = coordinatorMeshId === mesh.id;
+        return {
+          id: s.instanceId ?? s.id ?? s.sessionId,
+          status: s.status ?? s.lifecycle ?? s.state,
+          providerType: s.providerType ?? s.cliType ?? s.type,
+          ...s.activeChat?.status ? { chatStatus: s.activeChat.status } : {},
+          ...isSelfCoordinator ? { isSelfCoordinator: true, role: "coordinator" } : {}
+        };
+      }).filter((s) => s.id);
+    }
+    return entry;
+  }));
+  let ledgerEntries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail: 200 });
+  let directDispatches = (0, import_daemon_core.getActiveDirectDispatches)(mesh.id);
+  const directReconciliation = await reconcileDirectDispatchesFromTranscriptEvidence(ctx, results, directDispatches, ledgerEntries);
+  if (directReconciliation.reconciled > 0) {
+    ledgerEntries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail: 200 });
+    directDispatches = (0, import_daemon_core.getActiveDirectDispatches)(mesh.id);
+    ledgerSummary = (0, import_daemon_core.getLedgerSummary)(mesh.id);
+  }
+  const activeWorkEvidence = (0, import_daemon_core.buildMeshActiveWork)({
+    meshId: mesh.id,
+    queue: (0, import_daemon_core.getQueue)(mesh.id),
+    ledgerEntries,
+    directDispatches,
+    nodes: results
+  });
+  const pollingGuidance = buildActiveWorkPollingGuidance(activeWorkEvidence.summary);
+  const staleDirectWorkSummary = (0, import_daemon_core.buildCompactStaleDirectWorkSummary)(activeWorkEvidence.staleDirectWork, {
+    note: activeWorkEvidence.staleDirectWorkNote,
+    detailHint: "Full stale direct entries are omitted from mesh_status by default. Call mesh_status with includeStaleDirectWorkDetails=true or inspect mesh_task_history for ledger detail."
+  });
+  const coordinatorSessions = [];
+  for (const nodeEntry of results) {
+    const sessions = Array.isArray(nodeEntry.sessions) ? nodeEntry.sessions : [];
+    for (const s of sessions) {
+      if (s?.isSelfCoordinator === true && s.id) {
+        coordinatorSessions.push({
+          nodeId: nodeEntry.nodeId,
+          sessionId: s.id,
+          providerType: s.providerType,
+          status: s.status
+        });
+      }
+    }
   }
   const response = {
     meshId: mesh.id,
@@ -1677,17 +2425,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 +2483,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 +2524,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 +2597,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 +2608,167 @@ 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);
-    if (isLocalTransport(ctx.transport) && !(ctx.transport instanceof IpcTransport)) {
-      ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
+    const task = (0, import_daemon_core.enqueueTask)(ctx.mesh.id, args.message, { taskMode, requiredTags, dependsOn, missionId });
+    if (!(ctx.transport instanceof IpcTransport)) {
+      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 });
   } 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 +2783,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 +2826,8 @@ 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` });
+    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,23 +2845,81 @@ 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 (isLocalTransport(ctx.transport)) {
-      ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
-      });
+    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);
     }
+    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 });
   }
 }
 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)) {
+    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({
@@ -1953,47 +2939,73 @@ async function meshSendTask(ctx, args) {
     });
   }
   try {
-    if (!isLocalTransport(ctx.transport) && node.daemonId) {
-      const res = await ctx.transport.meshEnqueueTask(node.daemonId, {
-        meshId: ctx.mesh.id,
-        message: args.message,
-        targetNodeId: args.node_id
-      });
-      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 coordinatorDaemonId = resolveCoordinatorNode(ctx)?.daemonId || ctx.localDaemonId;
       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,
+          ...coordinatorDaemonId ? { coordinatorDaemonId } : {}
+        }
       });
       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));
+    if (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 +3020,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 +3071,58 @@ 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 coordinatorDaemonId = resolveCoordinatorNode(ctx)?.daemonId || ctx.localDaemonId;
       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,
+          ...coordinatorDaemonId ? { coordinatorDaemonId } : {}
+        }
       });
       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 +3135,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)(ctx.mesh.id) : [];
-    const result = { success: true, nodeId: args.node_id, taskId: task.id, status: task.status };
+    const queueTrigger = await triggerMeshQueueAndReport(ctx);
+    const pendingEvents = (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;
     }
@@ -2088,88 +3226,59 @@ async function meshReadChat(ctx, args) {
   if (!node) {
     return JSON.stringify(buildMissingNodeReadChatRecovery(ctx, args), null, 2);
   }
-  if (ctx.transport instanceof IpcTransport || isLocalTransport(ctx.transport)) {
-    await drainCoordinatorPendingEvents(ctx, { nodeIds: [args.node_id] });
-  }
-  if (isLocalTransport(ctx.transport)) {
-    const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
-    const 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", {
+  await drainCoordinatorPendingEvents(ctx, { nodeIds: [args.node_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,
+    targetSessionId: args.session_id,
+    workspace: node.workspace,
+    ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
+    ...providerSessionId ? { providerSessionId } : {},
+    tailLimit: args.tail ?? 10
+  });
+  const payload = annotateRapidReadChatAdvisory(unwrapCommandPayload(result), {
+    key: `mesh:${args.node_id}:${args.session_id}`,
+    toolName: "mesh_read_chat",
+    completionCallbackExpected: true
+  });
+  const useCompact = args.compact !== false;
+  if (useCompact) {
+    const compactPayload = compactChatPayload(payload, {
+      nodeId: args.node_id,
       sessionId: args.session_id,
-      targetSessionId: args.session_id,
-      workspace: node.workspace,
-      ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
-      ...providerSessionId ? { providerSessionId } : {},
-      tailLimit: args.tail ?? 10
+      limit: args.tail ?? 10
     });
-    const payload = annotateRapidReadChatAdvisory(unwrapCommandPayload(result), {
-      key: `mesh:${args.node_id}:${args.session_id}`,
-      toolName: "mesh_read_chat",
-      completionCallbackExpected: true
-    });
-    if (args.compact) {
-      const compactPayload = compactChatPayload(payload, {
-        nodeId: args.node_id,
-        sessionId: args.session_id,
-        limit: args.tail ?? 10
-      });
-      return JSON.stringify(
-        payload.pollingAdvisory ? { ...compactPayload, pollingAdvisory: payload.pollingAdvisory } : compactPayload,
-        null,
-        2
-      );
-    }
-    return JSON.stringify(payload, null, 2);
-  } else if (!isLocalTransport(ctx.transport) && node.daemonId) {
-    try {
-      const targetId = `${node.daemonId}:session:${args.session_id}`;
-      const res = await ctx.transport.readChat(targetId, {
-        limit: args.tail ?? 10,
-        sessionId: args.session_id
-      });
-      return JSON.stringify(res, null, 2);
-    } catch (e) {
-      return JSON.stringify({ success: false, error: e.message });
-    }
-  } else {
-    return JSON.stringify({ error: "Cloud mesh read_chat requires node daemonId" });
+    return JSON.stringify(
+      payload.pollingAdvisory ? { ...compactPayload, pollingAdvisory: payload.pollingAdvisory } : compactPayload,
+      null,
+      2
+    );
   }
+  return JSON.stringify(payload, null, 2);
 }
 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 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", {
-      sessionId: args.session_id,
-      targetSessionId: args.session_id,
-      workspace: node.workspace,
-      ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
-      ...providerSessionId ? { providerSessionId } : {},
-      tailLimit: args.tail ?? 40,
-      ...delivery ? { delivery } : {}
-    });
-    const payload = unwrapCommandPayload(result);
-    return JSON.stringify(payload, null, 2);
-  } else if (!isLocalTransport(ctx.transport) && node.daemonId) {
-    try {
-      const targetId = `${node.daemonId}:session:${args.session_id}`;
-      const res = await ctx.transport.getChatDebugBundle(targetId, {
-        sessionId: args.session_id,
-        tailLimit: args.tail ?? 40,
-        delivery: args.delivery
-      });
-      return JSON.stringify(res, null, 2);
-    } catch (e) {
-      return JSON.stringify({ success: false, error: e.message });
-    }
-  }
-  return JSON.stringify({ error: "Cloud mesh read_debug requires node daemonId" });
+  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", {
+    sessionId: args.session_id,
+    targetSessionId: args.session_id,
+    workspace: node.workspace,
+    ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
+    ...providerSessionId ? { providerSessionId } : {},
+    tailLimit: args.tail ?? 40,
+    ...delivery ? { delivery } : {}
+  });
+  const payload = unwrapCommandPayload(result);
+  return JSON.stringify(payload, null, 2);
 }
 async function meshLaunchSession(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
-  if (isLocalTransport(ctx.transport)) {
+  const bootstrapBlock = getWorktreeBootstrapLaunchBlock(node, ctx.mesh.policy);
+  if (bootstrapBlock) return JSON.stringify(bootstrapBlock, null, 2);
+  {
     let resolvedProviderType = typeof args.type === "string" && args.type.trim() ? args.type : "";
     if (!resolvedProviderType) {
       const providerPriority = readProviderPriority(node.policy);
@@ -2203,6 +3312,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 +3336,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,63 +3350,14 @@ 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 : "";
-    if (!resolvedProviderType) {
-      const providerPriority = readProviderPriority(node.policy);
-      if (!providerPriority.length) {
-        return JSON.stringify({ success: false, error: missingProviderPriorityMessage(args.node_id) });
-      }
-      resolvedProviderType = providerPriority[0];
-    }
-    const coordinatorNode = resolveCoordinatorNode(ctx);
-    const coordinatorDaemonId = coordinatorNode?.daemonId || ctx.localDaemonId;
-    const spawnedSessionVisibility = readSpawnedSessionVisibility(ctx.mesh.policy);
-    if (!coordinatorDaemonId) {
-      return JSON.stringify(buildMissingCoordinatorDaemonIdFailure(ctx, node, resolvedProviderType), null, 2);
-    }
-    try {
-      const res = await ctx.transport.launch(node.daemonId, {
-        type: resolvedProviderType,
-        dir: node.workspace,
-        settings: {
-          meshNodeFor: ctx.mesh.id,
-          meshNodeId: args.node_id,
-          spawnedSessionVisibility,
-          ...coordinatorDaemonId ? { meshCoordinatorDaemonId: coordinatorDaemonId } : {},
-          ...coordinatorNode?.id ? { meshCoordinatorNodeId: coordinatorNode.id } : {},
-          launchedByCoordinator: true
-        }
-      });
-      const runtimeSessionId = typeof res?.sessionId === "string" ? res.sessionId : typeof res?.id === "string" ? res.id : "";
-      try {
-        (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
-          kind: "session_launched",
-          nodeId: args.node_id,
-          sessionId: runtimeSessionId || void 0,
-          providerType: resolvedProviderType,
-          payload: {}
-        });
-      } catch {
-      }
-      return JSON.stringify({ ...res, resolvedProviderType }, null, 2);
-    } catch (e) {
-      return JSON.stringify(recordRecoverableLaunchFailure(ctx, node, resolvedProviderType, e), null, 2);
-    }
-  } else {
-    return JSON.stringify({ error: "Cloud mesh launch_session requires node daemonId" });
   }
 }
 async function meshGitStatus(ctx, args) {
@@ -2301,37 +3365,23 @@ async function meshGitStatus(ctx, args) {
   const autoDiscoverSubmodules = node.policy?.autoDiscoverSubmodules !== false;
   const submoduleIgnorePaths = node.policy?.submoduleIgnorePaths || [];
   try {
-    if (!isLocalTransport(ctx.transport) && node.daemonId) {
-      const result = await ctx.transport.gitStatus(node.daemonId, node.workspace, true, true);
-      return JSON.stringify({
-        nodeId: args.node_id,
-        workspace: node.workspace,
-        status: extractGitStatus(result),
-        diff: extractGitDiff(result),
-        submodules: autoDiscoverSubmodules ? extractSubmodules(result, submoduleIgnorePaths) : void 0,
-        relatedRepos: await collectRelatedRepoStatuses(ctx, node)
-      }, null, 2);
-    } else if (isLocalTransport(ctx.transport)) {
-      const statusResult = await commandForNode(ctx, node, "git_status", {
-        workspace: node.workspace,
-        refreshUpstream: true,
-        includeSubmodules: autoDiscoverSubmodules,
-        submoduleIgnorePaths: submoduleIgnorePaths.length > 0 ? submoduleIgnorePaths : void 0
-      });
-      const diffResult = await commandForNode(ctx, node, "git_diff_summary", {
-        workspace: node.workspace
-      });
-      return JSON.stringify({
-        nodeId: args.node_id,
-        workspace: node.workspace,
-        status: extractGitStatus(statusResult),
-        diff: extractGitDiff(diffResult),
-        submodules: autoDiscoverSubmodules ? extractSubmodules(statusResult, submoduleIgnorePaths) : void 0,
-        relatedRepos: await collectRelatedRepoStatuses(ctx, node)
-      }, null, 2);
-    } else {
-      return JSON.stringify({ error: "No daemonId available for cloud git_status probe" });
-    }
+    const statusResult = await commandForNode(ctx, node, "git_status", {
+      workspace: node.workspace,
+      refreshUpstream: true,
+      includeSubmodules: autoDiscoverSubmodules,
+      submoduleIgnorePaths: submoduleIgnorePaths.length > 0 ? submoduleIgnorePaths : void 0
+    });
+    const diffResult = await commandForNode(ctx, node, "git_diff_summary", {
+      workspace: node.workspace
+    });
+    return JSON.stringify({
+      nodeId: args.node_id,
+      workspace: node.workspace,
+      status: extractGitStatus(statusResult),
+      diff: extractGitDiff(diffResult),
+      submodules: autoDiscoverSubmodules ? extractSubmodules(statusResult, submoduleIgnorePaths) : void 0,
+      relatedRepos: await collectRelatedRepoStatuses(ctx, node)
+    }, null, 2);
   } catch (e) {
     const failure = buildCoordinatorP2pRelayFailure(e, {
       command: "git_status",
@@ -2344,242 +3394,216 @@ async function meshGitStatus(ctx, args) {
     }, null, 2);
   }
 }
-async function meshCheckpoint(ctx, args) {
+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({ error: `Node '${args.node_id}' is read-only \u2014 cannot checkpoint` });
+    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);
   }
-  if (isLocalTransport(ctx.transport)) {
-    const result = await commandForNode(ctx, node, "git_checkpoint", {
+  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,
-      message: args.message,
-      includeUntracked: true
+      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
     });
-    try {
-      (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
-        kind: "checkpoint_created",
-        nodeId: args.node_id,
-        payload: { message: args.message, commit: result?.checkpoint?.commit }
-      });
-    } catch {
-    }
-    return JSON.stringify(result, null, 2);
-  } else if (!isLocalTransport(ctx.transport) && node.daemonId) {
-    try {
-      const res = await ctx.transport.gitCheckpoint(node.daemonId, {
-        workspace: node.workspace,
+    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) {
+    return JSON.stringify({ error: `Node '${args.node_id}' is read-only \u2014 cannot checkpoint` });
+  }
+  const result = await commandForNode(ctx, node, "git_checkpoint", {
+    workspace: node.workspace,
+    message: args.message,
+    includeUntracked: true
+  });
+  try {
+    (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
+      kind: "checkpoint_created",
+      nodeId: args.node_id,
+      payload: {
         message: args.message,
-        includeUntracked: true
-      });
-      try {
-        (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
-          kind: "checkpoint_created",
-          nodeId: args.node_id,
-          payload: { message: args.message, commit: res?.checkpoint?.commit }
-        });
-      } catch {
+        commit: result?.checkpoint?.commit,
+        outcome: result?.checkpoint?.status || (result?.checkpoint?.noop ? "skipped" : void 0),
+        noop: result?.checkpoint?.noop === true,
+        reason: result?.checkpoint?.reason
       }
-      return JSON.stringify(res, null, 2);
-    } catch (e) {
-      return JSON.stringify({ success: false, error: e.message });
-    }
-  } else {
-    return JSON.stringify({ error: "Cloud mesh checkpoint requires node daemonId" });
+    });
+  } catch {
   }
+  return JSON.stringify(result, null, 2);
 }
 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 providerSessionId = cached?.providerSessionId;
-    const result = await commandForNode(ctx, node, "resolve_action", {
-      sessionId: args.session_id,
-      targetSessionId: args.session_id,
-      workspace: node.workspace,
-      ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
-      ...providerSessionId ? { providerSessionId } : {},
-      action: args.action === "reject" ? "reject" : "approve"
-    });
-    return JSON.stringify(result, null, 2);
-  } else if (!isLocalTransport(ctx.transport) && node.daemonId) {
-    try {
-      const targetId = `${node.daemonId}:session:${args.session_id}`;
-      const res = await ctx.transport.approve(targetId, args.action === "reject" ? "reject" : "approve");
-      return JSON.stringify(res, null, 2);
-    } catch (e) {
-      return JSON.stringify({ success: false, error: e.message });
-    }
-  } else {
-    return JSON.stringify({ error: "Cloud mesh approve requires node daemonId" });
-  }
+  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,
+    targetSessionId: args.session_id,
+    workspace: node.workspace,
+    ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
+    ...providerSessionId ? { providerSessionId } : {},
+    action: args.action === "reject" ? "reject" : "approve"
+  });
+  return JSON.stringify(result, null, 2);
 }
 async function meshCloneNode(ctx, args) {
   const sourceNode = await findNodeWithRefresh(ctx, args.source_node_id);
-  if (isLocalTransport(ctx.transport)) {
-    const result = await commandForNode(ctx, sourceNode, "clone_mesh_node", {
-      meshId: ctx.mesh.id,
-      sourceNodeId: args.source_node_id,
-      branch: args.branch,
-      baseBranch: args.base_branch,
-      inlineMesh: ctx.mesh
-    });
-    const clonePayload = extractCloneNodePayload(result);
-    if (clonePayload?.success && clonePayload.node?.id) {
-      const existingIndex = ctx.mesh.nodes.findIndex((n) => n.id === clonePayload.node.id);
-      if (existingIndex >= 0) ctx.mesh.nodes[existingIndex] = clonePayload.node;
-      else ctx.mesh.nodes.push(clonePayload.node);
-      ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      await syncCoordinatorDaemonMeshCache(ctx);
-    }
-    return JSON.stringify(result, null, 2);
-  } else if (!isLocalTransport(ctx.transport) && sourceNode.daemonId) {
-    try {
-      const res = await ctx.transport.meshCloneNode(sourceNode.daemonId, {
-        meshId: ctx.mesh.id,
-        sourceNodeId: args.source_node_id,
-        branch: args.branch,
-        baseBranch: args.base_branch,
-        inlineMesh: ctx.mesh
-      });
-      const clonePayload = extractCloneNodePayload(res);
-      if (clonePayload?.success && clonePayload.node?.id) {
-        const existingIndex = ctx.mesh.nodes.findIndex((n) => n.id === clonePayload.node.id);
-        if (existingIndex >= 0) ctx.mesh.nodes[existingIndex] = clonePayload.node;
-        else ctx.mesh.nodes.push(clonePayload.node);
-        ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await syncCoordinatorDaemonMeshCache(ctx);
-      }
-      return JSON.stringify(res, null, 2);
-    } catch (e) {
-      return JSON.stringify({ success: false, error: e.message });
-    }
-  } else {
-    return JSON.stringify({ error: "Cloud mesh clone_node requires source node daemonId" });
+  const result = await commandForNode(ctx, sourceNode, "clone_mesh_node", {
+    meshId: ctx.mesh.id,
+    sourceNodeId: args.source_node_id,
+    branch: args.branch,
+    baseBranch: args.base_branch,
+    inlineMesh: ctx.mesh
+  });
+  const clonePayload = extractCloneNodePayload(result);
+  if (clonePayload?.success && clonePayload.node?.id) {
+    const existingIndex = ctx.mesh.nodes.findIndex((n) => n.id === clonePayload.node.id);
+    if (existingIndex >= 0) ctx.mesh.nodes[existingIndex] = clonePayload.node;
+    else ctx.mesh.nodes.push(clonePayload.node);
+    ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await syncCoordinatorDaemonMeshCache(ctx);
   }
+  return JSON.stringify(result, null, 2);
 }
 async function meshCleanupSessions(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
-  if (isLocalTransport(ctx.transport)) {
-    const result = await commandForNode(ctx, node, "cleanup_mesh_sessions", {
-      meshId: ctx.mesh.id,
-      nodeId: args.node_id,
-      mode: args.mode,
-      sessionIds: args.session_ids,
-      dryRun: args.dry_run === true,
-      inlineMesh: ctx.mesh
-    });
-    return JSON.stringify(result, null, 2);
-  } else if (!isLocalTransport(ctx.transport) && node.daemonId) {
-    try {
-      const res = await ctx.transport.meshCleanupSessions(node.daemonId, {
-        meshId: ctx.mesh.id,
-        nodeId: args.node_id,
-        mode: args.mode,
-        sessionIds: args.session_ids,
-        dryRun: args.dry_run === true,
-        inlineMesh: ctx.mesh
-      });
-      return JSON.stringify(res, null, 2);
-    } catch (e) {
-      return JSON.stringify({ success: false, error: e.message });
-    }
-  } else {
-    return JSON.stringify({ error: "Cloud mesh cleanup_sessions requires node daemonId" });
-  }
+  const result = await commandForNode(ctx, node, "cleanup_mesh_sessions", {
+    meshId: ctx.mesh.id,
+    nodeId: args.node_id,
+    mode: args.mode,
+    sessionIds: args.session_ids,
+    dryRun: args.dry_run === true,
+    inlineMesh: ctx.mesh
+  });
+  return JSON.stringify(result, null, 2);
 }
 async function meshRemoveNode(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
-  if (isLocalTransport(ctx.transport)) {
-    const removeArgs = buildRemoveNodeArgs(ctx, args.node_id, args.session_cleanup_mode);
-    let result;
-    let transportFallback;
-    try {
-      result = await commandForNode(ctx, node, "remove_mesh_node", removeArgs);
-    } catch (e) {
-      if (ctx.transport instanceof IpcTransport && node.isLocalWorktree && isP2pTransportUnavailableError(e)) {
-        result = await ctx.transport.command("remove_mesh_node", removeArgs);
-        transportFallback = {
-          from: "p2p_mesh_relay",
-          to: "local_control_plane",
-          reason: e?.message || String(e)
-        };
-      } else {
-        return JSON.stringify({
-          success: false,
-          code: isP2pTransportUnavailableError(e) ? "p2p_unavailable" : "mesh_remove_node_failed",
-          error: e?.message || String(e),
-          recoveryHint: isP2pTransportUnavailableError(e) ? "If this is an ADHDev-managed local worktree, retry from a coordinator connected to the daemon that owns the worktree; dashboard command/data-plane traffic still requires P2P." : "Inspect mesh_status and retry after resolving the reported failure."
-        }, null, 2);
-      }
-    }
-    if (result?.success && result.removed !== false) {
-      const idx = ctx.mesh.nodes.findIndex((n) => n.id === args.node_id);
-      if (idx >= 0) {
-        ctx.mesh.nodes.splice(idx, 1);
-        ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      }
+  const removeArgs = buildRemoveNodeArgs(ctx, args.node_id, args.session_cleanup_mode);
+  let result;
+  let transportFallback;
+  try {
+    result = await commandForNode(ctx, node, "remove_mesh_node", removeArgs);
+  } catch (e) {
+    if (ctx.transport instanceof IpcTransport && node.isLocalWorktree && isP2pTransportUnavailableError(e)) {
+      result = await ctx.transport.command("remove_mesh_node", removeArgs);
+      transportFallback = {
+        from: "p2p_mesh_relay",
+        to: "local_control_plane",
+        reason: e?.message || String(e)
+      };
+    } else {
+      return JSON.stringify({
+        success: false,
+        code: isP2pTransportUnavailableError(e) ? "p2p_unavailable" : "mesh_remove_node_failed",
+        error: e?.message || String(e),
+        recoveryHint: isP2pTransportUnavailableError(e) ? "If this is an ADHDev-managed local worktree, retry from a coordinator connected to the daemon that owns the worktree; dashboard command/data-plane traffic still requires P2P." : "Inspect mesh_status and retry after resolving the reported failure."
+      }, null, 2);
     }
-    return JSON.stringify({ ...result || {}, ...transportFallback ? { transportFallback } : {} }, null, 2);
-  } else if (!isLocalTransport(ctx.transport) && node.daemonId) {
-    try {
-      const res = await ctx.transport.meshRemoveNode(node.daemonId, {
-        meshId: ctx.mesh.id,
-        nodeId: args.node_id,
-        ...args.session_cleanup_mode ? { sessionCleanupMode: args.session_cleanup_mode } : {},
-        inlineMesh: ctx.mesh
-      });
-      if (res?.success && res.removed !== false) {
-        const idx = ctx.mesh.nodes.findIndex((n) => n.id === args.node_id);
-        if (idx >= 0) {
-          ctx.mesh.nodes.splice(idx, 1);
-          ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        }
-      }
-      return JSON.stringify(res, null, 2);
-    } catch (e) {
-      return JSON.stringify({ success: false, error: e.message });
+  }
+  if (result?.success && result.removed !== false) {
+    const idx = ctx.mesh.nodes.findIndex((n) => n.id === args.node_id);
+    if (idx >= 0) {
+      ctx.mesh.nodes.splice(idx, 1);
+      ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     }
-  } else {
-    return JSON.stringify({ error: "Cloud mesh remove_node requires node daemonId" });
   }
+  return JSON.stringify({ ...result || {}, ...transportFallback ? { transportFallback } : {} }, null, 2);
+}
+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)) {
-    const result = await commandForNode(ctx, node, "refine_mesh_node", {
-      meshId: ctx.mesh.id,
-      nodeId: args.node_id,
-      inlineMesh: ctx.mesh
-    });
-    if (result?.success && 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);
-        ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      }
-    }
-    return JSON.stringify(result, null, 2);
-  } else if (!isLocalTransport(ctx.transport) && node.daemonId) {
-    try {
-      const res = await ctx.transport.meshRefineNode(node.daemonId, {
-        meshId: ctx.mesh.id,
-        nodeId: args.node_id,
-        inlineMesh: ctx.mesh
-      });
-      if (res?.success && 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);
-          ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        }
-      }
-      return JSON.stringify(res, null, 2);
-    } catch (e) {
-      return JSON.stringify({ success: false, error: e.message });
+  const result = await commandForNode(ctx, node, "refine_mesh_node", {
+    meshId: ctx.mesh.id,
+    nodeId: args.node_id,
+    inlineMesh: ctx.mesh
+  });
+  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);
+      ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     }
-  } else {
-    return JSON.stringify({ error: "Cloud mesh refine_node requires node daemonId" });
   }
+  return JSON.stringify(result, null, 2);
+}
+async function meshReviewInbox(ctx, args = {}) {
+  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
@@ -2603,28 +3627,24 @@ 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 --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
+  --mode <mode>           Transport: local or ipc
   --port <n>              Standalone or IPC daemon port (defaults: local 3847, ipc 19222)
   --password <pass>       Standalone daemon password (if set)
-  --api-key <key>         ADHDev cloud API key (switches to cloud mode)
-  --base-url <url>        Override cloud API base URL
   --repo-mesh <mesh_id>   Enable mesh mode \u2014 exposes only mesh-scoped coordinator tools
   --help                  Show this help
 
 Environment variables:
-  ADHDEV_API_KEY      API key (cloud mode)
   ADHDEV_PASSWORD     Daemon password (local mode)
   ADHDEV_MESH_ID      Mesh ID (mesh mode)
-  ADHDEV_MCP_TRANSPORT Transport: local, cloud, or ipc
+  ADHDEV_MCP_TRANSPORT Transport: local or ipc
 
 Standard tools:   ${STANDARD_TOOLS.join(", ")}
 Mesh tools:       ${meshTools.join(", ")}
@@ -2634,6 +3654,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
@@ -2652,287 +3673,24 @@ var LocalTransport = class {
   }
   async getStatus() {
     const res = await fetch(`${this.baseUrl}/api/v1/status`, { headers: this.headers() });
-    if (!res.ok) throw new Error(`Status fetch failed: ${res.status}`);
-    return res.json();
-  }
-  async command(type, args = {}) {
-    const res = await fetch(`${this.baseUrl}/api/v1/command`, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify({ type, ...args })
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => res.statusText);
-      throw new Error(`Command ${type} failed: ${res.status} ${text}`);
-    }
-    return res.json();
-  }
-  async ping() {
-    try {
-      await this.getStatus();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-
-// src/transports/cloud.ts
-var DEFAULT_BASE_URL = "https://api.adhf.dev";
-var CloudTransport = class {
-  baseUrl;
-  apiKey;
-  constructor(opts) {
-    this.apiKey = opts.apiKey;
-    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
-  }
-  headers() {
-    return {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${this.apiKey}`
-    };
-  }
-  async listRemoteMeshes() {
-    const res = await fetch(`${this.baseUrl}/api/v1/repo-meshes`, { headers: this.headers() });
-    if (!res.ok) throw new Error(`List remote meshes failed: ${res.status}`);
+    if (!res.ok) throw new Error(`Status fetch failed: ${res.status}`);
     return res.json();
   }
-  async createRemoteMesh(data) {
-    const res = await fetch(`${this.baseUrl}/api/v1/repo-meshes`, {
+  async command(type, args = {}) {
+    const res = await fetch(`${this.baseUrl}/api/v1/command`, {
       method: "POST",
       headers: this.headers(),
-      body: JSON.stringify(data)
-    });
-    if (!res.ok) throw new Error(`Create remote mesh failed: ${res.status}`);
-    return res.json();
-  }
-  async deleteRemoteMesh(meshId) {
-    const res = await fetch(`${this.baseUrl}/api/v1/repo-meshes/${encodeURIComponent(meshId)}`, {
-      method: "DELETE",
-      headers: this.headers()
+      body: JSON.stringify({ type, ...args })
     });
-    if (!res.ok) throw new Error(`Delete remote mesh failed: ${res.status}`);
-  }
-  async listDaemons() {
-    const res = await fetch(`${this.baseUrl}/api/v1/daemons`, { headers: this.headers() });
-    if (!res.ok) throw new Error(`List daemons failed: ${res.status}`);
-    return res.json();
-  }
-  async getStatus(targetId) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/status`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Status failed: ${res.status}`);
-    return res.json();
-  }
-  /** Get all sessions for a daemon (returns CompactSessionEntry[]). */
-  async getDaemonStatus(daemonId) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/daemons/${encodeURIComponent(daemonId)}/status`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Daemon status failed: ${res.status}`);
-    return res.json();
-  }
-  async readChat(targetId, opts = {}) {
-    const params = new URLSearchParams();
-    if (opts.limit) params.set("limit", String(opts.limit));
-    if (opts.sessionId) params.set("sessionId", opts.sessionId);
-    const qs = params.toString() ? `?${params}` : "";
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/chat${qs}`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Read chat failed: ${res.status}`);
-    return res.json();
-  }
-  async getChatDebugBundle(targetId, opts = {}) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/chat/debug`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify({
-          ...opts.agentType ? { agentType: opts.agentType } : {},
-          ...opts.sessionId ? { sessionId: opts.sessionId } : {},
-          ...opts.tailLimit ? { tailLimit: opts.tailLimit } : {},
-          ...opts.delivery ? { delivery: opts.delivery } : {}
-        })
-      }
-    );
-    if (!res.ok) throw new Error(`Chat debug bundle failed: ${res.status}`);
-    return res.json();
-  }
-  async sendChat(targetId, message, opts = {}) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/chat`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify({ message, ...opts })
-      }
-    );
-    if (!res.ok) throw new Error(`Send chat failed: ${res.status}`);
-    return res.json();
-  }
-  async approve(targetId, action, agentType) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/approve`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify({ action, ...agentType ? { agentType } : {} })
-      }
-    );
-    if (!res.ok) throw new Error(`Approve failed: ${res.status}`);
-    return res.json();
-  }
-  async gitStatus(daemonId, workspace, includeDiff = true, refreshUpstream = false) {
-    const params = new URLSearchParams({ workspace, includeDiff: String(includeDiff), refreshUpstream: String(refreshUpstream) });
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-status?${params}`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Git status failed: ${res.status}`);
-    return res.json();
-  }
-  async stop(daemonId, opts) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/stop`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(opts)
-      }
-    );
-    if (!res.ok) throw new Error(`Stop failed: ${res.status}`);
-    return res.json();
-  }
-  async launch(daemonId, opts) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/launch`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(opts)
-      }
-    );
-    if (!res.ok) throw new Error(`Launch failed: ${res.status}`);
-    return res.json();
-  }
-  async gitLog(daemonId, workspace, opts = {}) {
-    const params = new URLSearchParams({ workspace });
-    if (opts.limit) params.set("limit", String(opts.limit));
-    if (opts.file) params.set("file", opts.file);
-    if (opts.since) params.set("since", opts.since);
-    if (opts.until) params.set("until", opts.until);
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-log?${params}`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Git log failed: ${res.status}`);
-    return res.json();
-  }
-  async gitDiff(daemonId, workspace, opts = {}) {
-    const params = new URLSearchParams({ workspace });
-    if (opts.file) params.set("file", opts.file);
-    if (opts.maxLines) params.set("maxLines", String(opts.maxLines));
-    if (opts.staged) params.set("staged", "true");
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-diff?${params}`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Git diff failed: ${res.status}`);
-    return res.json();
-  }
-  async gitPush(daemonId, opts) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-push`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(opts)
-      }
-    );
-    if (!res.ok) throw new Error(`Git push failed: ${res.status}`);
-    return res.json();
-  }
-  async gitCheckpoint(daemonId, opts) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-checkpoint`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(opts)
-      }
-    );
-    if (!res.ok) throw new Error(`Git checkpoint failed: ${res.status}`);
-    return res.json();
-  }
-  async meshCloneNode(daemonId, payload) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/mesh/clone-node`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(payload)
-      }
-    );
-    if (!res.ok) throw new Error(`Mesh clone node failed: ${res.status}`);
-    return res.json();
-  }
-  async meshRemoveNode(daemonId, payload) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/mesh/remove-node`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(payload)
-      }
-    );
-    if (!res.ok) throw new Error(`Mesh remove node failed: ${res.status}`);
-    return res.json();
-  }
-  async meshCleanupSessions(daemonId, payload) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/mesh/cleanup-sessions`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(payload)
-      }
-    );
-    if (!res.ok) throw new Error(`Mesh cleanup sessions failed: ${res.status}`);
-    return res.json();
-  }
-  async meshEnqueueTask(daemonId, payload) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/mesh/enqueue`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(payload)
-      }
-    );
-    if (!res.ok) throw new Error(`Mesh enqueue task failed: ${res.status}`);
-    return res.json();
-  }
-  async meshRefineNode(daemonId, payload) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/mesh/refine-node`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(payload)
-      }
-    );
-    if (!res.ok) throw new Error(`Mesh refine node failed: ${res.status}`);
+    if (!res.ok) {
+      const text = await res.text().catch(() => res.statusText);
+      throw new Error(`Command ${type} failed: ${res.status} ${text}`);
+    }
     return res.json();
   }
   async ping() {
     try {
-      await this.listDaemons();
+      await this.getStatus();
       return true;
     } catch {
       return false;
@@ -2950,14 +3708,10 @@ var FORMAT_PROP = {
 };
 var LIST_SESSIONS_TOOL = {
   name: "list_sessions",
-  description: "List all connected agent sessions. In cloud mode, fetches session state from each daemon (data is sourced from daemon WS status reports, up to 30s stale). Pass daemon_id to scope to a single daemon.",
+  description: "List all connected agent sessions.",
   inputSchema: {
     type: "object",
     properties: {
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only). Omit to list sessions across all daemons."
-      },
       ...FORMAT_PROP
     },
     required: []
@@ -2965,87 +3719,35 @@ var LIST_SESSIONS_TOOL = {
 };
 async function listSessions(transport, args = {}) {
   const asJson = args.format === "json";
-  if (isLocalTransport(transport)) {
-    const status = await transport.getStatus();
-    const sessions = status?.sessions ?? [];
-    if (asJson) {
-      return JSON.stringify({
-        sessions: sessions.map((s) => ({
-          id: s.id,
-          type: s.providerType ?? s.type ?? "unknown",
-          label: s.label ?? null,
-          status: s.status ?? s.agentStatus ?? null,
-          workspace: s.workspace ?? null
-        }))
-      }, null, 2);
-    }
-    if (sessions.length === 0) return "No active sessions.";
-    const lines = sessions.map((s) => {
-      const parts = [`id: ${s.id}`, `type: ${s.providerType ?? s.type ?? "unknown"}`];
-      if (s.label) parts.push(`label: ${s.label}`);
-      if (s.status ?? s.agentStatus) parts.push(`status: ${s.status ?? s.agentStatus}`);
-      if (s.workspace) parts.push(`workspace: ${s.workspace}`);
-      return parts.join(", ");
-    });
-    return `Sessions (${sessions.length}):
-${lines.join("\n")}`;
-  }
-  return listSessionsCloud(transport, args.daemon_id, asJson);
-}
-async function listSessionsCloud(transport, daemonId, asJson) {
-  const collected = [];
-  if (daemonId) {
-    const daemonStatus = await transport.getDaemonStatus(daemonId);
-    for (const s of daemonStatus?.sessions ?? []) {
-      collected.push({ daemonId, session: s });
-    }
-  } else {
-    const data = await transport.listDaemons();
-    const daemons = data?.daemons ?? [];
-    for (let i = 0; i < daemons.length; i += 5) {
-      await Promise.allSettled(
-        daemons.slice(i, i + 5).map(async (d) => {
-          try {
-            const daemonStatus = await transport.getDaemonStatus(d.id);
-            for (const s of daemonStatus?.sessions ?? []) {
-              collected.push({ daemonId: d.id, session: s });
-            }
-          } catch {
-          }
-        })
-      );
-    }
-  }
+  const status = await transport.getStatus();
+  const sessions = status?.sessions ?? [];
   if (asJson) {
     return JSON.stringify({
-      sessions: collected.map(({ daemonId: dId, session: s }) => ({
-        daemon_id: dId,
+      sessions: sessions.map((s) => ({
         id: s.id,
-        type: s.providerType ?? "unknown",
-        status: s.status ?? null,
+        type: s.providerType ?? s.type ?? "unknown",
+        label: s.label ?? null,
+        status: s.status ?? s.agentStatus ?? null,
         workspace: s.workspace ?? null
       }))
     }, null, 2);
   }
-  if (collected.length === 0) return "No active sessions.";
-  const lines = collected.map(({ daemonId: dId, session: s }) => {
-    const parts = [
-      `daemon: ${dId}`,
-      `session: ${s.id}`,
-      `type: ${s.providerType ?? "unknown"}`
-    ];
-    if (s.status) parts.push(`status: ${s.status}`);
+  if (sessions.length === 0) return "No active sessions.";
+  const lines = sessions.map((s) => {
+    const parts = [`id: ${s.id}`, `type: ${s.providerType ?? s.type ?? "unknown"}`];
+    if (s.label) parts.push(`label: ${s.label}`);
+    if (s.status ?? s.agentStatus) parts.push(`status: ${s.status ?? s.agentStatus}`);
     if (s.workspace) parts.push(`workspace: ${s.workspace}`);
     return parts.join(", ");
   });
-  return `Sessions (${collected.length}):
+  return `Sessions (${sessions.length}):
 ${lines.join("\n")}`;
 }
 
 // src/tools/list-daemons.ts
 var LIST_DAEMONS_TOOL = {
   name: "list_daemons",
-  description: "List all connected daemons (machines running the ADHDev agent). Use this to discover daemon IDs before calling launch_session, git_status, or other tools that require daemon_id. In local mode returns the single standalone daemon info.",
+  description: "List the connected daemon (machine running the ADHDev agent). Returns the daemon identity extracted from its status report.",
   inputSchema: {
     type: "object",
     properties: {
@@ -3056,46 +3758,17 @@ var LIST_DAEMONS_TOOL = {
 };
 async function listDaemons(transport, args = {}) {
   const asJson = args.format === "json";
-  if (isLocalTransport(transport)) {
-    const status = await transport.getStatus();
-    const daemon = {
-      id: status?.id ?? status?.instanceId ?? "standalone",
-      hostname: status?.hostname ?? status?.machine?.hostname ?? "localhost",
-      platform: status?.platform ?? status?.machine?.platform ?? "unknown",
-      version: status?.version ?? null,
-      sessions: (status?.sessions ?? []).length
-    };
-    if (asJson) return JSON.stringify({ daemons: [daemon] }, null, 2);
-    return `Daemons (1):
+  const status = await transport.getStatus();
+  const daemon = {
+    id: status?.id ?? status?.instanceId ?? "standalone",
+    hostname: status?.hostname ?? status?.machine?.hostname ?? "localhost",
+    platform: status?.platform ?? status?.machine?.platform ?? "unknown",
+    version: status?.version ?? null,
+    sessions: (status?.sessions ?? []).length
+  };
+  if (asJson) return JSON.stringify({ daemons: [daemon] }, null, 2);
+  return `Daemons (1):
   id: ${daemon.id}, hostname: ${daemon.hostname}, platform: ${daemon.platform}${daemon.version ? `, version: ${daemon.version}` : ""}, sessions: ${daemon.sessions}`;
-  }
-  const data = await transport.listDaemons();
-  const daemons = data?.daemons ?? [];
-  if (asJson) {
-    return JSON.stringify({
-      daemons: daemons.map((d) => ({
-        id: d.id,
-        hostname: d.hostname ?? null,
-        platform: d.platform ?? null,
-        nickname: d.nickname ?? null,
-        version: d.version ?? null,
-        p2p_available: d.p2p?.available ?? null,
-        cdp_connected: d.cdpConnected ?? null
-      }))
-    }, null, 2);
-  }
-  if (daemons.length === 0) return "No connected daemons.";
-  const lines = daemons.map((d) => {
-    const parts = [`id: ${d.id}`];
-    if (d.nickname) parts.push(`nickname: ${d.nickname}`);
-    if (d.hostname) parts.push(`hostname: ${d.hostname}`);
-    if (d.platform) parts.push(`platform: ${d.platform}`);
-    if (d.version) parts.push(`version: ${d.version}`);
-    if (d.p2p?.available != null) parts.push(`p2p: ${d.p2p.available ? "yes" : "no"}`);
-    return parts.join(", ");
-  });
-  return `Daemons (${daemons.length}):
-${lines.join("\n")}`;
 }
 
 // src/tools/read-chat.ts
@@ -3113,10 +3786,6 @@ var READ_CHAT_TOOL = {
         type: "number",
         description: "Max messages to return (default: 50)."
       },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only). Omit for local mode."
-      },
       compact: {
         type: "boolean",
         description: "Opt-in compact mode: filters tool/terminal/system/internal/control/debug/status chatter and returns user-visible messages plus lightweight summary metadata."
@@ -3128,23 +3797,12 @@ var READ_CHAT_TOOL = {
 };
 async function readChat(transport, args) {
   const limit = args.limit ?? 50;
-  if (isLocalTransport(transport)) {
-    const result2 = await transport.command("read_chat", {
-      ...args.session_id ? { targetSessionId: args.session_id } : {},
-      tailLimit: limit
-    });
-    const annotated2 = annotateRapidReadChatAdvisory(result2, {
-      key: `local:${args.session_id ?? "__active__"}`,
-      toolName: "read_chat",
-      completionCallbackExpected: false
-    });
-    return formatChatResult(annotated2, args.session_id, args.format, limit, args.compact);
-  }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
-  const result = await transport.readChat(targetId, { limit, sessionId: args.session_id });
+  const result = await transport.command("read_chat", {
+    ...args.session_id ? { targetSessionId: args.session_id } : {},
+    tailLimit: limit
+  });
   const annotated = annotateRapidReadChatAdvisory(result, {
-    key: `cloud:${args.daemon_id}:${args.session_id ?? "__active__"}`,
+    key: `local:${args.session_id ?? "__active__"}`,
     toolName: "read_chat",
     completionCallbackExpected: false
   });
@@ -3185,11 +3843,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;
@@ -3228,10 +3892,6 @@ var READ_CHAT_DEBUG_TOOL = {
         type: "string",
         description: "Target session ID (from list_sessions). Required for reliable routing."
       },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only). Omit for local mode."
-      },
       agent_type: {
         type: "string",
         description: "Optional provider/agent type hint, e.g. hermes-cli, claude-cli, codex-cli."
@@ -3261,19 +3921,7 @@ async function readChatDebug(transport, args) {
     ...args.agent_type ? { agentType: args.agent_type, providerType: args.agent_type } : {},
     ...delivery === "daemon_file" ? { delivery: "daemon_file" } : {}
   };
-  let result;
-  if (isLocalTransport(transport)) {
-    result = await transport.command("get_chat_debug_bundle", commandArgs);
-  } 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.getChatDebugBundle(targetId, {
-      sessionId,
-      agentType: args.agent_type,
-      tailLimit,
-      delivery
-    });
-  }
+  const result = await transport.command("get_chat_debug_bundle", commandArgs);
   return formatChatDebugResult(result, { sessionId, delivery, format: args.format });
 }
 function formatChatDebugResult(result, options) {
@@ -3304,6 +3952,79 @@ 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)."
+      },
+      ...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");
+  const result = await transport.command("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",
@@ -3318,10 +4039,6 @@ var SEND_CHAT_TOOL = {
       session_id: {
         type: "string",
         description: "Target session ID (from list_sessions). Omit to use the active session."
-      },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only). Omit for local mode."
       }
     },
     required: ["message"]
@@ -3329,18 +4046,9 @@ var SEND_CHAT_TOOL = {
 };
 async function sendChat(transport, args) {
   if (!args.message?.trim()) throw new Error("message is required");
-  if (isLocalTransport(transport)) {
-    const result2 = await transport.command("send_chat", {
-      message: args.message,
-      ...args.session_id ? { targetSessionId: args.session_id } : {}
-    });
-    if (result2?.success === false) return `Error: ${result2.error ?? "send_chat failed"}`;
-    return "Message sent.";
-  }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
-  const result = await transport.sendChat(targetId, args.message, {
-    ...args.session_id ? { sessionId: args.session_id } : {}
+  const result = await transport.command("send_chat", {
+    message: args.message,
+    ...args.session_id ? { targetSessionId: args.session_id } : {}
   });
   if (result?.success === false) return `Error: ${result.error ?? "send_chat failed"}`;
   return "Message sent.";
@@ -3361,10 +4069,6 @@ var APPROVE_TOOL = {
       session_id: {
         type: "string",
         description: "Target session ID. Omit to use the active session."
-      },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only)."
       }
     },
     required: ["action"]
@@ -3372,25 +4076,18 @@ var APPROVE_TOOL = {
 };
 async function approve(transport, args) {
   const action = args.action === "reject" ? "reject" : "approve";
-  if (isLocalTransport(transport)) {
-    const result2 = await transport.command("resolve_action", {
-      action,
-      ...args.session_id ? { targetSessionId: args.session_id } : {}
-    });
-    if (result2?.success === false) return `Error: ${result2.error ?? "resolve_action failed"}`;
-    return `Action ${action}d.`;
-  }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
-  const result = await transport.approve(targetId, action);
-  if (result?.success === false) return `Error: ${result.error ?? "approve failed"}`;
+  const result = await transport.command("resolve_action", {
+    action,
+    ...args.session_id ? { targetSessionId: args.session_id } : {}
+  });
+  if (result?.success === false) return `Error: ${result.error ?? "resolve_action failed"}`;
   return `Action ${action}d.`;
 }
 
 // src/tools/screenshot.ts
 var SCREENSHOT_TOOL = {
   name: "screenshot",
-  description: "Capture a screenshot of the current IDE window. Returns the image. Local mode only \u2014 screenshots require direct P2P access to the daemon and are not available in cloud mode.",
+  description: "Capture a screenshot of the current IDE window. Returns the image.",
   inputSchema: {
     type: "object",
     properties: {
@@ -3403,14 +4100,9 @@ var SCREENSHOT_TOOL = {
   }
 };
 async function screenshot(transport, args) {
-  let result;
-  if (isLocalTransport(transport)) {
-    result = await transport.command("screenshot", {
-      ...args.session_id ? { targetSessionId: args.session_id } : {}
-    });
-  } else {
-    return { type: "text", text: "Screenshots are not available in cloud mode. Run adhdev mcp in local mode (requires standalone daemon)." };
-  }
+  const result = await transport.command("screenshot", {
+    ...args.session_id ? { targetSessionId: args.session_id } : {}
+  });
   if (result?.success === false) {
     return { type: "text", text: `Error: ${result.error ?? "screenshot failed"}` };
   }
@@ -3437,42 +4129,22 @@ var GIT_STATUS_TOOL = {
         type: "boolean",
         description: "Include changed file list (default: true)."
       },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only)."
-      },
       ...FORMAT_PROP
     },
     required: ["workspace"]
   }
 };
 async function gitStatus(transport, args) {
-  let status;
   let diffSummary;
-  if (isLocalTransport(transport)) {
-    const statusResult = await transport.command("git_status", {
+  const statusResult = await transport.command("git_status", {
+    workspace: args.workspace
+  });
+  const status = statusResult?.status ?? statusResult;
+  if (args.include_diff !== false) {
+    const diffResult = await transport.command("git_diff_summary", {
       workspace: args.workspace
     });
-    status = statusResult?.status ?? statusResult;
-    if (args.include_diff !== false) {
-      const diffResult = await transport.command("git_diff_summary", {
-        workspace: args.workspace
-      });
-      diffSummary = diffResult?.diffSummary ?? diffResult;
-    }
-  } else {
-    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-    const result = await transport.gitStatus(
-      args.daemon_id,
-      args.workspace,
-      args.include_diff !== false
-    );
-    if (result?.error) {
-      if (args.format === "json") return JSON.stringify({ error: result.error }, null, 2);
-      return `Error: ${result.error}`;
-    }
-    status = result?.status;
-    diffSummary = result?.diff;
+    diffSummary = diffResult?.diffSummary ?? diffResult;
   }
   if (status?.success === false || status?.reason) {
     const msg = status?.error ?? status?.reason ?? "unknown";
@@ -3564,10 +4236,6 @@ var GIT_LOG_TOOL = {
         type: "string",
         description: "Only commits before this date (ISO 8601 or git date string, optional)."
       },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only, required)."
-      },
       ...FORMAT_PROP
     },
     required: ["workspace"]
@@ -3575,26 +4243,14 @@ var GIT_LOG_TOOL = {
 };
 async function gitLog(transport, args) {
   const limit = Math.max(1, Math.min(100, args.limit ?? 20));
-  let raw;
-  if (isLocalTransport(transport)) {
-    raw = await transport.command("git_log", {
-      workspace: args.workspace,
-      limit,
-      ...args.file ? { path: args.file } : {},
-      ...args.since ? { since: args.since } : {},
-      ...args.until ? { until: args.until } : {}
-    });
-    raw = raw?.log ?? raw;
-  } else {
-    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-    const result = await transport.gitLog(args.daemon_id, args.workspace, {
-      limit,
-      file: args.file,
-      since: args.since,
-      until: args.until
-    });
-    raw = result?.log ?? result;
-  }
+  let raw = await transport.command("git_log", {
+    workspace: args.workspace,
+    limit,
+    ...args.file ? { path: args.file } : {},
+    ...args.since ? { since: args.since } : {},
+    ...args.until ? { until: args.until } : {}
+  });
+  raw = raw?.log ?? raw;
   if (raw?.success === false || raw?.reason) {
     const msg = raw?.error ?? raw?.reason ?? "unknown";
     if (args.format === "json") return JSON.stringify({ error: msg }, null, 2);
@@ -3657,10 +4313,6 @@ var GIT_DIFF_TOOL = {
         type: "boolean",
         description: "Show staged changes instead of unstaged (default: false)."
       },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only, required)."
-      },
       ...FORMAT_PROP
     },
     required: ["workspace"]
@@ -3669,20 +4321,7 @@ var GIT_DIFF_TOOL = {
 async function gitDiff(transport, args) {
   const maxLines = Math.max(10, Math.min(2e3, args.max_lines ?? 300));
   const staged = args.staged ?? false;
-  if (isLocalTransport(transport)) {
-    return localGitDiff(transport, args.workspace, args.file, maxLines, staged, args.format);
-  }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const result = await transport.gitDiff(args.daemon_id, args.workspace, {
-    file: args.file,
-    maxLines,
-    staged
-  });
-  if (result?.error) {
-    if (args.format === "json") return JSON.stringify({ error: result.error }, null, 2);
-    return `Git diff error: ${result.error}`;
-  }
-  return formatDiffResult(result, args.format);
+  return localGitDiff(transport, args.workspace, args.file, maxLines, staged, args.format);
 }
 async function localGitDiff(transport, workspace, file, maxLines, staged, format) {
   if (file) {
@@ -3804,10 +4443,6 @@ var GIT_CHECKPOINT_TOOL = {
       include_untracked: {
         type: "boolean",
         description: "Also stage and commit untracked files (default: false)."
-      },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only, required)."
       }
     },
     required: ["workspace", "message"]
@@ -3817,23 +4452,12 @@ async function gitCheckpoint(transport, args) {
   const message = args.message?.trim();
   if (!message) return "Error: message is required";
   if (message.length > 200) return "Error: message must be 200 characters or fewer";
-  let raw;
-  if (isLocalTransport(transport)) {
-    raw = await transport.command("git_checkpoint", {
-      workspace: args.workspace,
-      message,
-      includeUntracked: args.include_untracked ?? false
-    });
-    raw = raw?.checkpoint ?? raw;
-  } else {
-    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-    const result = await transport.gitCheckpoint(args.daemon_id, {
-      workspace: args.workspace,
-      message,
-      includeUntracked: args.include_untracked ?? false
-    });
-    raw = result?.checkpoint ?? result;
-  }
+  let raw = await transport.command("git_checkpoint", {
+    workspace: args.workspace,
+    message,
+    includeUntracked: args.include_untracked ?? false
+  });
+  raw = raw?.checkpoint ?? raw;
   if (raw?.success === false || raw?.reason) {
     const msg = raw?.error ?? raw?.reason ?? "unknown";
     if (msg.includes("Nothing to commit") || msg.includes("nothing to commit")) {
@@ -3864,33 +4488,18 @@ var GIT_PUSH_TOOL = {
       branch: {
         type: "string",
         description: "Branch to push (default: current branch)."
-      },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only, required)."
       }
     },
     required: ["workspace"]
   }
 };
 async function gitPush(transport, args) {
-  let raw;
-  if (isLocalTransport(transport)) {
-    raw = await transport.command("git_push", {
-      workspace: args.workspace,
-      remote: args.remote ?? "origin",
-      ...args.branch ? { branch: args.branch } : {}
-    });
-    raw = raw?.push ?? raw;
-  } else {
-    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-    const result = await transport.gitPush(args.daemon_id, {
-      workspace: args.workspace,
-      remote: args.remote,
-      branch: args.branch
-    });
-    raw = result?.push ?? result;
-  }
+  let raw = await transport.command("git_push", {
+    workspace: args.workspace,
+    remote: args.remote ?? "origin",
+    ...args.branch ? { branch: args.branch } : {}
+  });
+  raw = raw?.push ?? raw;
   if (raw?.success === false || raw?.reason) {
     const msg = raw?.error ?? raw?.reason ?? "unknown";
     return `Git push error: ${msg}`;
@@ -3921,32 +4530,17 @@ var LAUNCH_SESSION_TOOL = {
       model: {
         type: "string",
         description: "Model override for ACP agents (e.g. claude-opus-4-7)."
-      },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only). Required in cloud mode."
       }
     },
     required: ["type"]
   }
 };
 async function launchSession(transport, args) {
-  if (isLocalTransport(transport)) {
-    const isCliOrAcp = args.type.includes("-cli") || args.type.includes("-acp") || args.type === "codex";
-    const commandType = isCliOrAcp ? "launch_cli" : "launch_ide";
-    const payload = isCliOrAcp ? { cliType: args.type, dir: args.workspace ?? "~", ...args.model ? { model: args.model } : {} } : { ideType: args.type, enableCdp: true };
-    const result2 = await transport.command(commandType, payload);
-    if (result2?.success === false) return `Error: ${result2.error ?? "launch failed"}`;
-    const id2 = result2?.id ?? result2?.sessionId;
-    return id2 ? `Session launched. id: ${id2}, type: ${args.type}` : `Launched: ${JSON.stringify(result2)}`;
-  }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const result = await transport.launch(args.daemon_id, {
-    type: args.type,
-    dir: args.workspace,
-    model: args.model
-  });
-  if (result?.success === false || result?.error) return `Error: ${result.error ?? "launch failed"}`;
+  const isCliOrAcp = args.type.includes("-cli") || args.type.includes("-acp") || args.type === "codex";
+  const commandType = isCliOrAcp ? "launch_cli" : "launch_ide";
+  const payload = isCliOrAcp ? { cliType: args.type, dir: args.workspace ?? "~", ...args.model ? { model: args.model } : {} } : { ideType: args.type, enableCdp: true };
+  const result = await transport.command(commandType, payload);
+  if (result?.success === false) return `Error: ${result.error ?? "launch failed"}`;
   const id = result?.id ?? result?.sessionId;
   return id ? `Session launched. id: ${id}, type: ${args.type}` : `Launched: ${JSON.stringify(result)}`;
 }
@@ -3962,43 +4556,29 @@ var STOP_SESSION_TOOL = {
         type: "string",
         description: "Session ID to stop (from list_sessions)."
       },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only, required)."
-      },
       type: {
         type: "string",
-        description: "Provider type (e.g. hermes-cli, claude-cli). Local mode auto-resolves from session_id if omitted; cloud mode forwards the session_id and omits type unless explicitly provided."
+        description: "Provider type (e.g. hermes-cli, claude-cli). Auto-resolved from session_id if omitted."
       }
     },
     required: ["session_id"]
   }
 };
 async function stopSession(transport, args) {
-  if (isLocalTransport(transport)) {
-    const local = transport;
-    let resolvedType = args.type;
-    if (!resolvedType) {
-      const status = await local.getStatus();
-      const session = (status?.sessions ?? []).find((s) => s.id === args.session_id);
-      resolvedType = session?.providerType ?? session?.type;
-    }
-    if (!resolvedType) {
-      return `Error: could not resolve session type for ${args.session_id}. Pass type= explicitly.`;
-    }
-    const result2 = await local.command("stop_cli", {
-      targetSessionId: args.session_id,
-      cliType: resolvedType
-    });
-    if (result2?.success === false) return `Error: ${result2.error ?? "stop failed"}`;
-    return `Session ${args.session_id} stopped.`;
+  let resolvedType = args.type;
+  if (!resolvedType) {
+    const status = await transport.getStatus();
+    const session = (status?.sessions ?? []).find((s) => s.id === args.session_id);
+    resolvedType = session?.providerType ?? session?.type;
+  }
+  if (!resolvedType) {
+    return `Error: could not resolve session type for ${args.session_id}. Pass type= explicitly.`;
   }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const result = await transport.stop(args.daemon_id, {
-    id: args.session_id,
-    ...args.type ? { type: args.type } : {}
+  const result = await transport.command("stop_cli", {
+    targetSessionId: args.session_id,
+    cliType: resolvedType
   });
-  if (result?.success === false || result?.error) return `Error: ${result.error ?? "stop failed"}`;
+  if (result?.success === false) return `Error: ${result.error ?? "stop failed"}`;
   return `Session ${args.session_id} stopped.`;
 }
 
@@ -4009,28 +4589,18 @@ var CHECK_PENDING_TOOL = {
   inputSchema: {
     type: "object",
     properties: {
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID to check (cloud mode). Omit to check all daemons."
-      },
       ...FORMAT_PROP
     },
     required: []
   }
 };
 async function checkPending(transport, args) {
-  if (isLocalTransport(transport)) {
-    return checkPendingLocal(transport, args.format);
-  }
-  return checkPendingCloud(transport, args.daemon_id, args.format);
-}
-async function checkPendingLocal(transport, format) {
   const status = await transport.getStatus();
   const sessions = status?.sessions ?? [];
   const pending = sessions.filter(
     (s) => s.status === "waiting_approval" || s.agentStatus === "waiting_approval"
   );
-  if (format === "json") {
+  if (args.format === "json") {
     return JSON.stringify({
       pending: pending.map((s) => ({
         session_id: s.id,
@@ -4053,56 +4623,6 @@ async function checkPendingLocal(transport, format) {
   });
   return `Pending approvals (${pending.length}):
 
-${lines.join("\n\n")}`;
-}
-async function checkPendingCloud(transport, daemonId, format) {
-  const pending = [];
-  if (daemonId) {
-    const daemonStatus = await transport.getDaemonStatus(daemonId);
-    const sessions = daemonStatus?.sessions ?? [];
-    for (const s of sessions) {
-      if (s.status === "waiting_approval") pending.push({ daemonId, session: s });
-    }
-  } else {
-    const data = await transport.listDaemons();
-    const daemons = data?.daemons ?? [];
-    for (let i = 0; i < daemons.length; i += 5) {
-      await Promise.allSettled(
-        daemons.slice(i, i + 5).map(async (d) => {
-          try {
-            const daemonStatus = await transport.getDaemonStatus(d.id);
-            const sessions = daemonStatus?.sessions ?? [];
-            for (const s of sessions) {
-              if (s.status === "waiting_approval") pending.push({ daemonId: d.id, session: s });
-            }
-          } catch {
-          }
-        })
-      );
-    }
-  }
-  if (format === "json") {
-    return JSON.stringify({
-      pending: pending.map(({ daemonId: dId, session: s }) => ({
-        daemon_id: dId,
-        session_id: s.id,
-        workspace: s.workspace ?? null,
-        type: s.providerType ?? null,
-        modal_message: null,
-        buttons: []
-      }))
-    }, null, 2);
-  }
-  if (pending.length === 0) return "No sessions waiting for approval.";
-  const lines = pending.map(({ daemonId: dId, session: s }) => {
-    const parts = [`daemon_id: ${dId}`, `session_id: ${s.id}`];
-    if (s.workspace) parts.push(`workspace: ${s.workspace}`);
-    if (s.providerType) parts.push(`type: ${s.providerType}`);
-    parts.push("(use read_chat to see the approval prompt)");
-    return parts.join("\n  ");
-  });
-  return `Pending approvals (${pending.length}):
-
 ${lines.join("\n\n")}`;
 }
 
@@ -4116,10 +4636,10 @@ async function buildMeshModeCoordinatorPrompt(mesh) {
   }
 }
 async function startMcpServer(opts) {
-  const transport = opts.mode === "cloud" ? new CloudTransport({ apiKey: opts.apiKey, baseUrl: opts.baseUrl }) : opts.mode === "ipc" ? new IpcTransport({ port: opts.port }) : new LocalTransport({ port: opts.port, password: opts.password });
+  const transport = opts.mode === "ipc" ? new IpcTransport({ port: opts.port }) : new LocalTransport({ port: opts.port, password: opts.password });
   const alive = await transport.ping();
   if (!alive) {
-    const hint = opts.mode === "local" ? `Make sure the standalone daemon is running (adhdev standalone or npx @adhdev/daemon-standalone).` : opts.mode === "ipc" ? `Make sure the cloud daemon is running with local IPC enabled (adhdev daemon).` : `Check your API key and network connectivity.`;
+    const hint = opts.mode === "local" ? `Make sure the standalone daemon is running (adhdev standalone or npx @adhdev/daemon-standalone).` : `Make sure the cloud daemon is running with local IPC enabled (adhdev daemon).`;
     process.stderr.write(`[adhdev-mcp] Cannot reach ${opts.mode} daemon. ${hint}
 `);
     process.exit(1);
@@ -4134,63 +4654,6 @@ async function startMcpServer(opts) {
 `);
       } catch (e) {
         process.stderr.write(`[adhdev-mcp] Failed to parse ADHDEV_INLINE_MESH: ${e.message}
-`);
-      }
-    }
-    if (!mesh && opts.mode === "cloud" && opts.apiKey) {
-      try {
-        const base = opts.baseUrl || "https://api.adhf.dev";
-        const res = await fetch(`${base}/api/v1/repo-meshes/${opts.meshId}`, {
-          headers: { "Authorization": `Bearer ${opts.apiKey}`, "Content-Type": "application/json" }
-        });
-        if (res.ok) {
-          const data = await res.json();
-          const rm = data.mesh;
-          const nodes = data.nodes || [];
-          let policy = {};
-          try {
-            policy = JSON.parse(rm.policy_json || rm.policy || "{}");
-          } catch {
-          }
-          let coordinator = {};
-          try {
-            coordinator = JSON.parse(rm.coordinator_json || rm.coordinator_config || "{}");
-          } catch {
-          }
-          mesh = {
-            id: rm.id,
-            name: rm.name,
-            repoIdentity: rm.repo_identity,
-            repoRemoteUrl: rm.repo_remote_url,
-            defaultBranch: rm.default_branch,
-            policy: {
-              requirePreTaskCheckpoint: false,
-              requirePostTaskCheckpoint: true,
-              requireApprovalForPush: true,
-              requireApprovalForDestructiveGit: true,
-              dirtyWorkspaceBehavior: "warn",
-              maxParallelTasks: 2,
-              spawnedSessionVisibility: "visible",
-              ...policy
-            },
-            coordinator,
-            nodes: nodes.map((n) => ({
-              id: n.id,
-              workspace: n.workspace,
-              repoRoot: n.repo_root,
-              daemonId: n.daemon_id,
-              userOverrides: {},
-              policy: {},
-              isLocalWorktree: false
-            })),
-            createdAt: rm.created_at,
-            updatedAt: rm.updated_at
-          };
-          process.stderr.write(`[adhdev-mcp] Loaded mesh config from cloud API
-`);
-        }
-      } catch (e) {
-        process.stderr.write(`[adhdev-mcp] Cloud mesh fetch failed, falling back to local: ${e.message}
 `);
       }
     }
@@ -4217,17 +4680,19 @@ async function startMcpServer(opts) {
       }
     }
     if (!mesh) {
-      process.stderr.write(`[adhdev-mcp] Mesh '${opts.meshId}' not found in ${opts.mode === "cloud" ? "cloud or local" : "local"} config. Use 'adhdev mesh list' to see available meshes.
+      process.stderr.write(`[adhdev-mcp] Mesh '${opts.meshId}' not found in local config. Use 'adhdev mesh list' to see available meshes.
 `);
       process.exit(1);
     }
     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 +4700,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 +4735,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 +4767,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 +4785,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 +4806,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 +4834,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,
@@ -4370,7 +4859,7 @@ async function startMcpServer(opts) {
           return { content: [{ type: "text", text }] };
         }
         case "list_sessions": {
-          const text = await listSessions(transport, { format: a.format, daemon_id: a.daemon_id });
+          const text = await listSessions(transport, { format: a.format });
           return { content: [{ type: "text", text }] };
         }
         case "read_chat": {
@@ -4381,13 +4870,17 @@ 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 });
+          const text = await sendChat(transport, { message: a.message, session_id: a.session_id });
           return { content: [{ type: "text", text }] };
         }
         case "approve": {
           const action = a.action === "reject" ? "reject" : "approve";
-          const text = await approve(transport, { action, session_id: a.session_id, daemon_id: a.daemon_id });
+          const text = await approve(transport, { action, session_id: a.session_id });
           return { content: [{ type: "text", text }] };
         }
         case "screenshot": {
@@ -4400,44 +4893,42 @@ async function startMcpServer(opts) {
           return { content: [{ type: "text", text: result.text }] };
         }
         case "git_status": {
-          const text = await gitStatus(transport, { workspace: a.workspace, include_diff: a.include_diff, daemon_id: a.daemon_id, format: a.format });
+          const text = await gitStatus(transport, { workspace: a.workspace, include_diff: a.include_diff, format: a.format });
           return { content: [{ type: "text", text }] };
         }
         case "git_log": {
-          const text = await gitLog(transport, { workspace: a.workspace, limit: a.limit, file: a.file, since: a.since, until: a.until, daemon_id: a.daemon_id, format: a.format });
+          const text = await gitLog(transport, { workspace: a.workspace, limit: a.limit, file: a.file, since: a.since, until: a.until, format: a.format });
           return { content: [{ type: "text", text }] };
         }
         case "git_diff": {
-          const text = await gitDiff(transport, { workspace: a.workspace, file: a.file, max_lines: a.max_lines, staged: a.staged, daemon_id: a.daemon_id, format: a.format });
+          const text = await gitDiff(transport, { workspace: a.workspace, file: a.file, max_lines: a.max_lines, staged: a.staged, format: a.format });
           return { content: [{ type: "text", text }] };
         }
         case "git_checkpoint": {
-          const text = await gitCheckpoint(transport, { workspace: a.workspace, message: a.message, include_untracked: a.include_untracked, daemon_id: a.daemon_id });
+          const text = await gitCheckpoint(transport, { workspace: a.workspace, message: a.message, include_untracked: a.include_untracked });
           return { content: [{ type: "text", text }] };
         }
         case "git_push": {
-          const text = await gitPush(transport, { workspace: a.workspace, remote: a.remote, branch: a.branch, daemon_id: a.daemon_id });
+          const text = await gitPush(transport, { workspace: a.workspace, remote: a.remote, branch: a.branch });
           return { content: [{ type: "text", text }] };
         }
         case "launch_session": {
           const text = await launchSession(transport, {
             type: a.type,
             workspace: a.workspace,
-            model: a.model,
-            daemon_id: a.daemon_id
+            model: a.model
           });
           return { content: [{ type: "text", text }] };
         }
         case "stop_session": {
           const text = await stopSession(transport, {
             session_id: a.session_id,
-            daemon_id: a.daemon_id,
             type: a.type
           });
           return { content: [{ type: "text", text }] };
         }
         case "check_pending": {
-          const text = await checkPending(transport, { daemon_id: a.daemon_id, format: a.format });
+          const text = await checkPending(transport, { format: a.format });
           return { content: [{ type: "text", text }] };
         }
         default:
@@ -4459,26 +4950,18 @@ async function startMcpServer(opts) {
 // src/index.ts
 function parseArgs(argv, env = process.env) {
   const args = argv.slice(2);
-  let apiKey;
-  let baseUrl;
   let port;
   let password;
   let meshId;
   let explicitMode;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if ((arg === "--api-key" || arg === "-k") && args[i + 1]) {
-      apiKey = args[++i];
-    } else if (arg?.startsWith("--api-key=")) {
-      apiKey = arg.slice("--api-key=".length);
-    } else if (arg === "--base-url" && args[i + 1]) {
-      baseUrl = args[++i];
-    } else if (arg === "--mode" && args[i + 1]) {
+    if (arg === "--mode" && args[i + 1]) {
       const value = String(args[++i]).trim();
-      if (value === "local" || value === "cloud" || value === "ipc") explicitMode = value;
+      if (value === "local" || value === "ipc") explicitMode = value;
     } else if (arg?.startsWith("--mode=")) {
       const value = arg.slice("--mode=".length).trim();
-      if (value === "local" || value === "cloud" || value === "ipc") explicitMode = value;
+      if (value === "local" || value === "ipc") explicitMode = value;
     } else if (arg === "--port" && args[i + 1]) {
       port = Number(args[++i]);
     } else if (arg?.startsWith("--port=")) {
@@ -4494,15 +4977,14 @@ function parseArgs(argv, env = process.env) {
       process.exit(0);
     }
   }
-  if (!apiKey && env.ADHDEV_API_KEY) apiKey = env.ADHDEV_API_KEY;
   if (!password && env.ADHDEV_PASSWORD) password = env.ADHDEV_PASSWORD;
   if (!meshId && env.ADHDEV_MESH_ID) meshId = env.ADHDEV_MESH_ID;
   if (!explicitMode && env.ADHDEV_MCP_TRANSPORT) {
     const value = env.ADHDEV_MCP_TRANSPORT.trim();
-    if (value === "local" || value === "cloud" || value === "ipc") explicitMode = value;
+    if (value === "local" || value === "ipc") explicitMode = value;
   }
-  const mode = explicitMode || (apiKey ? "cloud" : meshId && env.ADHDEV_INLINE_MESH ? "ipc" : "local");
-  return { mode, port, password, apiKey, baseUrl, meshId };
+  const mode = explicitMode || (meshId && env.ADHDEV_INLINE_MESH ? "ipc" : "local");
+  return { mode, port, password, meshId };
 }
 function printHelp() {
   console.error(buildMcpHelpText());