@adhdev/daemon-standalone 0.9.82-rc.7 → 0.9.82-rc.71

package/vendor/mcp-server/index.js

@@ -35,9 +35,19 @@ __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: 6e4,
+  agent_command: 3e4,
+  git_status: 45e3,
+  mesh_status: 12e4
+};
 var IpcTransport = class {
   port;
   path;
@@ -85,7 +95,7 @@ var IpcTransport = class {
         }
         fn();
       };
-      const timeoutMs = type === "mesh_relay_command" ? 6e4 : 15e3;
+      const timeoutMs = IPC_COMMAND_TIMEOUTS_MS[type] ?? DEFAULT_IPC_COMMAND_TIMEOUT_MS;
       const timeout = setTimeout(() => {
         finish(() => reject(new Error(`Daemon IPC command '${type}' timed out after ${Math.round(timeoutMs / 1e3)}s`)));
       }, timeoutMs);
@@ -143,6 +153,10 @@ function isLocalTransport(transport) {
 }
 
 // src/tools/chat-compact.ts
+function isAssistantLike(message) {
+  const role = String(message?.role ?? "").toLowerCase();
+  return role === "assistant" || role === "agent";
+}
 function messageContent(message) {
   const content = message?.content;
   if (typeof content === "string") return content;
@@ -161,16 +175,22 @@ function isCoordinatorVisibleMessage(message) {
   if (meta?.internal === true || meta?.debug === true || meta?.control === true || meta?.userVisible === false || meta?.user_visible === false) return false;
   return role === "user" || role === "assistant" || role === "agent";
 }
+function buildCompactMessageTail(visibleMessages, opts) {
+  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);
+}
 function compactChatPayload(payload, opts = {}) {
   const rawMessages = Array.isArray(payload?.messages) ? payload.messages : [];
   const visible = rawMessages.filter(isCoordinatorVisibleMessage);
   const limit = Math.max(1, Math.min(opts.limit ?? 10, 10));
-  const messages = visible.slice(-limit);
   const finalAssistant = [...visible].reverse().find((message) => {
     const role = String(message?.role ?? "").toLowerCase();
     return (role === "assistant" || role === "agent") && messageContent(message).trim();
   });
   const summary = typeof payload?.summary === "string" && payload.summary.trim() ? payload.summary.trim() : messageContent(finalAssistant).trim();
+  const messages = buildCompactMessageTail(visible, { summary, finalAssistant, limit });
   return {
     success: payload?.success !== false,
     compact: true,
@@ -235,6 +255,30 @@ var meshSessionProviderMetadata = /* @__PURE__ */ new Map();
 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 } : {}
+  };
+}
+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;
@@ -246,15 +290,24 @@ async function refreshMeshFromDaemon(ctx) {
     const result = await ctx.transport.command("get_mesh", { meshId: ctx.mesh.id });
     if (!result?.success || !Array.isArray(result.mesh?.nodes)) return;
     const refreshedNodes = result.mesh.nodes.filter((n) => n?.id).map((n) => n);
-    if (!refreshedNodes.length) return;
     ctx.mesh.nodes.splice(0, ctx.mesh.nodes.length, ...refreshedNodes);
     ctx.mesh.updatedAt = result.mesh.updatedAt ?? ctx.mesh.updatedAt;
   } catch {
   }
 }
+async function syncCoordinatorDaemonMeshCache(ctx) {
+  if (!(ctx.transport instanceof IpcTransport)) return;
+  try {
+    await ctx.transport.command("get_mesh", {
+      meshId: ctx.mesh.id,
+      inlineMesh: ctx.mesh
+    });
+  } catch {
+  }
+}
 async function findNodeWithRefresh(ctx, nodeId) {
   const hit = ctx.mesh.nodes.find((n) => n.id === nodeId);
-  if (hit) return hit;
+  if (hit && !hit.isLocalWorktree) return hit;
   await refreshMeshFromDaemon(ctx);
   const refreshed = ctx.mesh.nodes.find((n) => n.id === nodeId);
   if (!refreshed) throw new Error(`Node '${nodeId}' is not a member of mesh '${ctx.mesh.name}'`);
@@ -262,7 +315,7 @@ async function findNodeWithRefresh(ctx, nodeId) {
 }
 async function findOptionalNodeWithRefresh(ctx, nodeId) {
   const hit = ctx.mesh.nodes.find((n) => n.id === nodeId);
-  if (hit) return hit;
+  if (hit && !hit.isLocalWorktree) return hit;
   await refreshMeshFromDaemon(ctx);
   return ctx.mesh.nodes.find((n) => n.id === nodeId) ?? null;
 }
@@ -314,9 +367,26 @@ function buildMissingNodeReadChatRecovery(ctx, args) {
     readDebugLocator: readString(lastTerminal?.payload?.readDebugLocator) || readString(lastTerminal?.payload?.debugBundlePath)
   };
   if (finalSummary) {
+    if (args.compact === true) {
+      return {
+        ...compactChatPayload({
+          success: true,
+          status: "idle",
+          providerSessionId,
+          summary: finalSummary,
+          messages: [{ role: "assistant", content: finalSummary, isHistorical: true }]
+        }, {
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          limit: args.tail ?? 10
+        }),
+        recoveredFromLedger: true,
+        ledger
+      };
+    }
     return {
       success: true,
-      compact: args.compact === true,
+      compact: false,
       recoveredFromLedger: true,
       nodeId: args.node_id,
       sessionId: args.session_id,
@@ -368,6 +438,14 @@ function buildMissingNodeReadChatRecovery(ctx, args) {
 function readSessionRecordId(session) {
   return readString(session?.id) || readString(session?.sessionId) || readString(session?.session_id) || readString(session?.runtimeSessionId) || readString(session?.runtime_session_id) || readString(session?.instanceId) || readString(session?.instance_id);
 }
+function extractStatusMetadataSessions(value) {
+  const payload = unwrapCommandPayload(value);
+  const status = payload?.status && typeof payload.status === "object" ? payload.status : payload;
+  return Array.isArray(status?.sessions) ? status.sessions : [];
+}
+function resolveSessionProviderType(session) {
+  return readString(session?.providerType) || readString(session?.cliType) || readString(session?.agentType) || "";
+}
 function addSessionRecord(target, session) {
   if (!session || typeof session !== "object" || isTerminalSessionRecord(session)) return;
   const sessionId = readSessionRecordId(session);
@@ -475,6 +553,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,
@@ -580,22 +670,59 @@ function isIdleSessionRecord(session) {
   const chatStatus = typeof session?.activeChat?.status === "string" ? session.activeChat.status.toLowerCase() : "";
   return status === "idle" || chatStatus === "waiting_input";
 }
+function isMeshOwnedDelegateSession(session, meshId, nodeId) {
+  const settings = session?.settings;
+  const sessionMeshId = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
+  const coordinatorDaemonId = typeof settings?.meshCoordinatorDaemonId === "string" ? settings.meshCoordinatorDaemonId.trim() : "";
+  const sessionNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
+  if (sessionMeshId !== meshId || !coordinatorDaemonId) return false;
+  return !sessionNodeId || sessionNodeId === nodeId;
+}
 function chooseDispatchableSession(sessions, providerType, meshId, nodeId) {
   const live = sessions.filter((session) => !isTerminalSessionRecord(session));
   const matchingProvider = (session) => !providerType || session?.providerType === providerType || session?.cliType === providerType;
-  const isMeshOwnedDelegateSession = (session) => {
-    const settings = session?.settings;
-    const sessionMeshId = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
-    const coordinatorDaemonId = typeof settings?.meshCoordinatorDaemonId === "string" ? settings.meshCoordinatorDaemonId.trim() : "";
-    const sessionNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
-    if (sessionMeshId !== meshId || !coordinatorDaemonId) return false;
-    return !sessionNodeId || sessionNodeId === nodeId;
-  };
   const meshSessions = live.filter(
-    (session) => isMeshOwnedDelegateSession(session)
+    (session) => isMeshOwnedDelegateSession(session, meshId, nodeId)
   );
   return meshSessions.find((session) => isIdleSessionRecord(session) && matchingProvider(session)) || meshSessions.find(matchingProvider) || void 0;
 }
+function buildRelayUnsafeRemoteSessionFailure(ctx, node, sessionId, providerType) {
+  return {
+    success: false,
+    recoverable: true,
+    code: "mesh_delegate_session_missing_relay_metadata",
+    reason: "mesh_delegate_session_missing_relay_metadata",
+    transport: "mesh_transport",
+    retryRecommended: true,
+    meshId: ctx.mesh.id,
+    nodeId: node.id,
+    daemonId: node.daemonId,
+    workspace: node.workspace,
+    sessionId,
+    ...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.`,
+    nextAction: `Launch a fresh relay-safe session with mesh_launch_session(node_id: '${node.id}'${providerType ? `, type: '${providerType}'` : ""}) or dispatch without session_id so Repo Mesh can choose a valid delegate session.`,
+    noFallbackReason: "Blindly reusing a remote session without mesh relay metadata would silently drop task_completed / generating_completed events."
+  };
+}
+function buildMissingCoordinatorDaemonIdFailure(ctx, node, providerType) {
+  return {
+    success: false,
+    recoverable: true,
+    code: "mesh_coordinator_daemon_unknown",
+    reason: "mesh_coordinator_daemon_unknown",
+    transport: "mesh_transport",
+    retryRecommended: true,
+    meshId: ctx.mesh.id,
+    nodeId: node.id,
+    daemonId: node.daemonId,
+    workspace: node.workspace,
+    ...providerType ? { resolvedProviderType: providerType } : {},
+    error: `Cannot launch a remote mesh delegate for node '${node.id}': coordinator daemon identity is unavailable, so the worker would be unable to relay completion events back to the coordinator.`,
+    nextAction: "Retry after the coordinator daemon identity is available (for example from an attached daemon-backed MCP session) so meshCoordinatorDaemonId can be stamped on the worker session.",
+    noFallbackReason: "Launching without meshCoordinatorDaemonId would create a worker session that can finish work but cannot emit task_completed / generating_completed back to the coordinator."
+  };
+}
 function findNestedPayload(value, predicate) {
   const seen = /* @__PURE__ */ new Set();
   const stack = [{ payload: value, depth: 0 }];
@@ -623,12 +750,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));
 }
@@ -753,20 +884,63 @@ async function ipcDispatchToRemoteAgent(ctx, node, args) {
   let sessionId = args.session_id?.trim() || "";
   const providerPriorityList = Array.isArray(node.policy?.providerPriority) ? node.policy.providerPriority : [];
   let resolvedProviderType = args.providerType?.trim() || providerPriorityList[0] || "";
-  if (!sessionId) {
+  if (!sessionId || args.session_id) {
     try {
       const relayResult = await transport.meshCommand(daemonId, "get_status_metadata", {});
-      const innerResult = relayResult?.result ?? relayResult;
-      const statusObj = innerResult?.status ?? innerResult;
-      const sessions = Array.isArray(statusObj?.sessions) ? statusObj.sessions : [];
-      const targetSession = chooseDispatchableSession(sessions, resolvedProviderType, ctx.mesh.id, node.id);
-      if (targetSession?.id || targetSession?.sessionId) {
-        sessionId = targetSession.id || targetSession.sessionId;
+      const sessions = extractStatusMetadataSessions(relayResult);
+      if (sessionId) {
+        const explicitSession = sessions.find((session) => readSessionRecordId(session) === sessionId);
+        if (!explicitSession) {
+          return {
+            success: false,
+            recoverable: true,
+            code: "mesh_target_session_not_found",
+            reason: "mesh_target_session_not_found",
+            transport: "mesh_transport",
+            retryRecommended: true,
+            meshId: ctx.mesh.id,
+            nodeId: node.id,
+            daemonId,
+            workspace: node.workspace,
+            sessionId,
+            ...resolvedProviderType ? { resolvedProviderType } : {},
+            error: `Remote session '${sessionId}' is not present in the live status for node '${node.id}'.`,
+            nextAction: `Launch a fresh session with mesh_launch_session(node_id: '${node.id}'${resolvedProviderType ? `, type: '${resolvedProviderType}'` : ""}) or retry without session_id so Repo Mesh can target a live delegate session.`
+          };
+        }
+        if (!isMeshOwnedDelegateSession(explicitSession, ctx.mesh.id, node.id)) {
+          return buildRelayUnsafeRemoteSessionFailure(
+            ctx,
+            node,
+            sessionId,
+            resolvedProviderType || resolveSessionProviderType(explicitSession) || void 0
+          );
+        }
         if (!resolvedProviderType) {
-          resolvedProviderType = targetSession.providerType || targetSession.cliType || "";
+          resolvedProviderType = resolveSessionProviderType(explicitSession);
+        }
+      } else {
+        const targetSession = chooseDispatchableSession(sessions, resolvedProviderType, ctx.mesh.id, node.id);
+        if (targetSession?.id || targetSession?.sessionId) {
+          sessionId = targetSession.id || targetSession.sessionId;
+          if (!resolvedProviderType) {
+            resolvedProviderType = resolveSessionProviderType(targetSession);
+          }
         }
       }
     } catch (e) {
+      if (sessionId) {
+        return {
+          ...buildCoordinatorP2pRelayFailure(e, {
+            command: "get_status_metadata",
+            targetDaemonId: daemonId,
+            nodeId: node.id,
+            sessionId
+          }),
+          success: false,
+          error: `Cannot verify remote session '${sessionId}' before dispatch: ${e?.message || String(e)}`
+        };
+      }
     }
   }
   if (!resolvedProviderType) {
@@ -796,7 +970,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 {
@@ -880,6 +1054,10 @@ function summarizeRelatedRepoStatus(repo, status) {
     workspace: repo.workspace,
     isGitRepo: status?.isGitRepo === true,
     branch: status?.branch ?? null,
+    upstream: status?.upstream ?? null,
+    upstreamStatus: typeof status?.upstreamStatus === "string" ? status.upstreamStatus : status?.upstream ? "unchecked" : "no_upstream",
+    upstreamFetchedAt: Number.isFinite(Number(status?.upstreamFetchedAt)) ? Number(status.upstreamFetchedAt) : null,
+    upstreamFetchError: typeof status?.upstreamFetchError === "string" ? status.upstreamFetchError : null,
     ahead: Number.isFinite(Number(status?.ahead)) ? Number(status.ahead) : 0,
     behind: Number.isFinite(Number(status?.behind)) ? Number(status.behind) : 0,
     dirty,
@@ -896,7 +1074,7 @@ async function collectRelatedRepoStatuses(ctx, node) {
   const results = [];
   for (const repo of relatedRepos) {
     try {
-      const statusResult = !isLocalTransport(ctx.transport) && node.daemonId ? await ctx.transport.gitStatus(node.daemonId, repo.workspace, false) : await commandForNode(ctx, node, "git_status", { workspace: repo.workspace });
+      const statusResult = !isLocalTransport(ctx.transport) && node.daemonId ? await ctx.transport.gitStatus(node.daemonId, repo.workspace, false, true) : await commandForNode(ctx, node, "git_status", { workspace: repo.workspace, refreshUpstream: true });
       const status = extractGitStatus(statusResult);
       results.push(summarizeRelatedRepoStatus(repo, status));
     } catch (e) {
@@ -944,11 +1122,13 @@ function buildBranchConvergence(mesh, node, status, dirty, uncommittedChanges) {
   const ahead = readNumeric(status?.ahead);
   const behind = readNumeric(status?.behind);
   const upstream = readString(status?.upstream) ?? null;
+  const upstreamStatus = readString(status?.upstreamStatus) ?? (upstream ? "unchecked" : "no_upstream");
   const hasConflicts = status?.hasConflicts === true || Array.isArray(status?.conflictFiles) && status.conflictFiles.length > 0;
   const base = {
     defaultBranch,
     branch,
     upstream,
+    upstreamStatus,
     ahead,
     behind,
     isWorktree: node.isLocalWorktree === true,
@@ -982,6 +1162,15 @@ function buildBranchConvergence(mesh, node, status, dirty, uncommittedChanges) {
     };
   }
   if (branch === defaultBranch) {
+    if (upstream && upstreamStatus !== "fresh") {
+      return {
+        ...base,
+        status: "blocked_review",
+        needsConvergence: true,
+        reason: "default_branch_upstream_unverified",
+        nextStep: `Refresh ${defaultBranch}'s upstream refs or resolve the fetch failure before declaring convergence complete for node '${node.id}'.`
+      };
+    }
     if (ahead > 0 || behind > 0) {
       return {
         ...base,
@@ -1008,6 +1197,15 @@ function buildBranchConvergence(mesh, node, status, dirty, uncommittedChanges) {
       nextStep: `Run mesh_refine_node(node_id: "${node.id}") or explicitly classify this worktree as blocked_review/not_mergeable before ending the task.`
     };
   }
+  if (upstream && upstreamStatus !== "fresh") {
+    return {
+      ...base,
+      status: "blocked_review",
+      needsConvergence: true,
+      reason: "feature_branch_upstream_unverified",
+      nextStep: `Refresh branch '${branch}' upstream refs or resolve the fetch failure before deciding whether it is ready to merge into ${defaultBranch}.`
+    };
+  }
   if (!upstream || ahead > 0 || behind > 0) {
     return {
       ...base,
@@ -1051,6 +1249,79 @@ async function commandForNode(ctx, node, command, args = {}) {
   }
   throw new Error(`Command '${command}' requires daemon IPC/local transport for node '${node.id}'`);
 }
+function normalizePendingMeshCoordinatorEvents(value) {
+  const payload = unwrapCommandPayload(value);
+  const events = Array.isArray(payload?.events) ? payload.events : Array.isArray(value?.events) ? value.events : [];
+  return events.filter((event) => event && typeof event === "object");
+}
+function buildMeshForwardPayloadFromPendingEvent(event) {
+  const metadataEvent = event?.metadataEvent && typeof event.metadataEvent === "object" ? event.metadataEvent : {};
+  return {
+    event: readString(event?.event),
+    meshId: readString(event?.meshId),
+    nodeId: readString(event?.nodeId) || readString(metadataEvent.meshNodeId),
+    workspace: readString(event?.workspace) || readString(metadataEvent.workspace),
+    targetSessionId: readString(metadataEvent.targetSessionId) || readString(metadataEvent.sessionId) || readString(metadataEvent.instanceId),
+    providerType: readString(metadataEvent.providerType),
+    providerSessionId: readString(metadataEvent.providerSessionId),
+    finalSummary: readString(metadataEvent.finalSummary) || readString(metadataEvent.summary),
+    jobId: readString(metadataEvent.jobId),
+    interactionId: readString(metadataEvent.interactionId),
+    status: readString(metadataEvent.status),
+    targetDaemonId: readString(metadataEvent.targetDaemonId),
+    startedAt: readString(metadataEvent.startedAt),
+    completedAt: readString(metadataEvent.completedAt),
+    retryOfJobId: readString(metadataEvent.retryOfJobId),
+    ...metadataEvent.result && typeof metadataEvent.result === "object" && !Array.isArray(metadataEvent.result) ? { result: metadataEvent.result } : {},
+    ...metadataEvent.intentional === true ? { intentional: true } : {},
+    ...metadataEvent.intentionalStop === true ? { intentionalStop: true } : {},
+    ...metadataEvent.operatorCleanup === true ? { operatorCleanup: true } : {},
+    ...readString(metadataEvent.reason) ? { reason: readString(metadataEvent.reason) } : {},
+    ...readString(metadataEvent.stopReason) ? { stopReason: readString(metadataEvent.stopReason) } : {},
+    ...readString(metadataEvent.cleanupReason) ? { cleanupReason: readString(metadataEvent.cleanupReason) } : {},
+    ...readString(metadataEvent.source) ? { source: readString(metadataEvent.source) } : {}
+  };
+}
+async function drainCoordinatorPendingEvents(ctx, opts) {
+  const requestedNodeIds = opts?.nodeIds?.length ? new Set(opts.nodeIds) : null;
+  const matchesCurrentMesh = (event) => readString(event?.meshId) === ctx.mesh.id;
+  if (ctx.transport instanceof IpcTransport) {
+    const surfacedEvents = [];
+    try {
+      surfacedEvents.push(
+        ...normalizePendingMeshCoordinatorEvents(await ctx.transport.command("get_pending_mesh_events", { meshId: ctx.mesh.id })).filter(matchesCurrentMesh)
+      );
+    } catch {
+    }
+    for (const node of ctx.mesh.nodes) {
+      if (!node.daemonId || isLocalControlPlaneNode(ctx, node)) continue;
+      if (requestedNodeIds && !requestedNodeIds.has(node.id)) continue;
+      try {
+        const remoteEvents = normalizePendingMeshCoordinatorEvents(
+          await ctx.transport.meshCommand(node.daemonId, "get_pending_mesh_events", { meshId: ctx.mesh.id })
+        ).filter(matchesCurrentMesh);
+        if (remoteEvents.length === 0) continue;
+        for (const event of remoteEvents) {
+          const payload = buildMeshForwardPayloadFromPendingEvent(event);
+          if (!payload.event || !payload.meshId) continue;
+          await ctx.transport.command("mesh_forward_event", payload);
+        }
+      } catch {
+      }
+    }
+    try {
+      surfacedEvents.push(
+        ...normalizePendingMeshCoordinatorEvents(await ctx.transport.command("get_pending_mesh_events", { meshId: ctx.mesh.id })).filter(matchesCurrentMesh)
+      );
+    } catch {
+    }
+    return surfacedEvents;
+  }
+  if (isLocalTransport(ctx.transport)) {
+    return (0, import_daemon_core.drainPendingMeshCoordinatorEvents)(ctx.mesh.id).filter(matchesCurrentMesh);
+  }
+  return [];
+}
 function isP2pTransportUnavailableError(error) {
   return (0, import_daemon_core.isP2pRelayTransportFailure)(error);
 }
@@ -1088,7 +1359,9 @@ 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." }
     },
     required: ["message"]
   }
@@ -1148,7 +1421,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"]
   }
@@ -1206,6 +1481,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.",
@@ -1289,7 +1579,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." }
     }
   }
 };
@@ -1309,7 +1599,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: {
@@ -1318,6 +1608,43 @@ var MESH_REFINE_NODE_TOOL = {
     required: ["node_id"]
   }
 };
+var MESH_REFINE_CONFIG_SCHEMA_TOOL = {
+  name: "mesh_refine_config_schema",
+  description: "Return the Repo Mesh Refinery config JSON schema and supported repo-local config locations. This is the validation source of truth; heuristic command detection is suggestions-only.",
+  inputSchema: { type: "object", properties: {} }
+};
+var MESH_VALIDATE_REFINE_CONFIG_TOOL = {
+  name: "mesh_validate_refine_config",
+  description: "Validate the repo mesh/refine config for a node/workspace without running validation commands or merging.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Optional node/workspace whose refine config should be loaded. Defaults to the first mesh node." },
+      config: { type: "object", description: "Optional inline config object to validate instead of loading from the repo." }
+    }
+  }
+};
+var MESH_SUGGEST_REFINE_CONFIG_TOOL = {
+  name: "mesh_suggest_refine_config",
+  description: "Suggest a repo mesh/refine config scaffold from project context/package scripts. Suggestions are never executed until saved as explicit refine config.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Optional node/workspace used for suggestions. Defaults to the first mesh node." }
+    }
+  }
+};
+var MESH_REFINE_PLAN_TOOL = {
+  name: "mesh_refine_plan",
+  description: "Dry-run Refinery plan for a worktree node: reports config source, validation commands, suggestions/unavailable reason, and merge/cleanup intent without executing validation or git merge.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Node ID of the worktree node to plan." }
+    },
+    required: ["node_id"]
+  }
+};
 var ALL_MESH_TOOLS = [
   MESH_STATUS_TOOL,
   MESH_LIST_NODES_TOOL,
@@ -1330,11 +1657,16 @@ var ALL_MESH_TOOLS = [
   MESH_READ_DEBUG_TOOL,
   MESH_LAUNCH_SESSION_TOOL,
   MESH_GIT_STATUS_TOOL,
+  MESH_FAST_FORWARD_NODE_TOOL,
   MESH_CHECKPOINT_TOOL,
   MESH_APPROVE_TOOL,
   MESH_CLONE_NODE_TOOL,
   MESH_REMOVE_NODE_TOOL,
   MESH_REFINE_NODE_TOOL,
+  MESH_REFINE_CONFIG_SCHEMA_TOOL,
+  MESH_VALIDATE_REFINE_CONFIG_TOOL,
+  MESH_SUGGEST_REFINE_CONFIG_TOOL,
+  MESH_REFINE_PLAN_TOOL,
   MESH_CLEANUP_SESSIONS_TOOL,
   MESH_TASK_HISTORY_TOOL,
   MESH_RECONCILE_LEDGER_TOOL
@@ -1352,11 +1684,12 @@ async function meshStatus(ctx) {
     };
     try {
       if (!isLocalTransport(transport) && node.daemonId) {
-        const result = await transport.gitStatus(node.daemonId, node.workspace, false);
+        const result = await transport.gitStatus(node.daemonId, node.workspace, false, true);
         const status = extractGitStatus(result);
         const uncommittedChanges = countUncommittedChanges(status);
         const dirty = isGitStatusDirty(status);
         entry.health = status?.isGitRepo ? dirty ? "dirty" : "online" : "degraded";
+        assignFullGitSnapshot(entry, status);
         entry.branch = status?.branch;
         entry.isDirty = dirty;
         entry.uncommittedChanges = uncommittedChanges;
@@ -1370,6 +1703,7 @@ async function meshStatus(ctx) {
         const autoDiscover = node.policy?.autoDiscoverSubmodules !== false;
         const statusResult = await commandForNode(ctx, node, "git_status", {
           workspace: node.workspace,
+          refreshUpstream: true,
           includeSubmodules: autoDiscover,
           submoduleIgnorePaths: node.policy?.submoduleIgnorePaths || void 0
         });
@@ -1377,6 +1711,7 @@ async function meshStatus(ctx) {
         const uncommittedChanges = countUncommittedChanges(status);
         const dirty = isGitStatusDirty(status);
         entry.health = status?.isGitRepo ? dirty ? "dirty" : "online" : "degraded";
+        assignFullGitSnapshot(entry, status);
         entry.branch = status?.branch;
         entry.isDirty = dirty;
         entry.uncommittedChanges = uncommittedChanges;
@@ -1454,13 +1789,27 @@ async function meshStatus(ctx) {
     if (relatedRepos.length) entry.relatedRepos = relatedRepos;
     results.push(entry);
   }
+  const activeWorkEvidence = (0, import_daemon_core.buildMeshActiveWork)({
+    meshId: mesh.id,
+    queue: (0, import_daemon_core.getQueue)(mesh.id),
+    ledgerEntries: (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail: 500 }),
+    nodes: mesh.nodes
+  });
   const response = {
     meshId: mesh.id,
     meshName: mesh.name,
     repoIdentity: mesh.repoIdentity,
     policy: mesh.policy,
     refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceOfTruth: {
+      membership: "coordinator_daemon_live_mesh",
+      currentStatus: "live_git_and_session_probes",
+      activeWork: "mesh_queue_file_and_local_ledger",
+      historicalEvidenceOnly: ["recoveryHints", "ledgerSummary"]
+    },
     nodes: results,
+    activeWork: activeWorkEvidence.activeWork,
+    activeWorkSummary: activeWorkEvidence.summary,
     branchConvergenceSummary: summarizeBranchConvergence(results)
   };
   try {
@@ -1468,13 +1817,7 @@ async function meshStatus(ctx) {
   } catch {
   }
   try {
-    let pendingEvents = [];
-    if (ctx.transport instanceof IpcTransport) {
-      const eventsResult = await ctx.transport.command("get_pending_mesh_events", {});
-      pendingEvents = Array.isArray(eventsResult?.events) ? eventsResult.events : [];
-    } else if (isLocalTransport(ctx.transport)) {
-      pendingEvents = (0, import_daemon_core.drainPendingMeshCoordinatorEvents)();
-    }
+    const pendingEvents = await drainCoordinatorPendingEvents(ctx);
     if (pendingEvents.length > 0) {
       response.pendingCoordinatorEvents = pendingEvents;
     }
@@ -1484,6 +1827,7 @@ async function meshStatus(ctx) {
 }
 async function meshTaskHistory(ctx, args) {
   const { mesh } = ctx;
+  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 });
@@ -1587,12 +1931,13 @@ async function meshListNodes(ctx) {
   }, null, 2);
 }
 async function meshEnqueueTask(ctx, args) {
+  const taskMode = readString(args.task_mode) || readString(args.taskMode);
   try {
-    const task = (0, import_daemon_core.enqueueTask)(ctx.mesh.id, args.message);
+    const task = (0, import_daemon_core.enqueueTask)(ctx.mesh.id, args.message, { taskMode });
     if (isLocalTransport(ctx.transport) && !(ctx.transport instanceof IpcTransport)) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
-      return JSON.stringify({ success: true, taskId: task.id, status: task.status });
+      return JSON.stringify({ success: true, source: "queue", taskId: task.id, status: task.status, taskMode: task.taskMode });
     }
     if (ctx.transport instanceof IpcTransport) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
@@ -1605,11 +1950,24 @@ async function meshEnqueueTask(ctx, args) {
           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 {
               }
@@ -1620,22 +1978,32 @@ async function meshEnqueueTask(ctx, args) {
       }
       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 });
     }
-    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 });
   } catch (e) {
-    return JSON.stringify({ success: false, error: e.message });
+    const message = e?.message || String(e);
+    if (message.includes("live_debug_readonly_guardrail_violation")) {
+      return JSON.stringify({ success: false, code: "live_debug_readonly_guardrail_violation", taskMode, error: message });
+    }
+    return JSON.stringify({ success: false, error: message });
   }
 }
 async function meshViewQueue(ctx, args) {
   try {
     const statusFilter = sanitizeQueueStatusFilter(args.status);
     const view = normalizeQueueViewMode(args.view);
-    const fullQueue = annotateQueueStaleness((0, import_daemon_core.getQueue)(ctx.mesh.id), ctx.mesh);
+    const fullQueue = prioritizeActiveQueueRows(annotateQueueStaleness((0, import_daemon_core.getQueue)(ctx.mesh.id), ctx.mesh));
     const queue = filterQueueForView(fullQueue, view, statusFilter);
     const summary = buildQueueStatusSummary(fullQueue);
     const visibleSummary = buildQueueStatusSummary(queue);
     const maintenance = buildQueueMaintenanceReport(fullQueue);
+    const activeWorkEvidence = (0, import_daemon_core.buildMeshActiveWork)({
+      meshId: ctx.mesh.id,
+      queue: fullQueue,
+      ledgerEntries: (0, import_daemon_core.readLedgerEntries)(ctx.mesh.id, { tail: 500 }),
+      nodes: ctx.mesh.nodes
+    });
     const staleAssignedTasks = maintenance.staleAssignedTasks || [];
     const requestedHistoricalRows = queue.some((task) => HISTORICAL_QUEUE_STATUSES.has(String(task?.status || "")));
     return JSON.stringify({
@@ -1653,6 +2021,8 @@ async function meshViewQueue(ctx, args) {
       },
       queue,
       visibleQueue: queue,
+      activeWork: activeWorkEvidence.activeWork,
+      activeWorkSummary: activeWorkEvidence.summary,
       visibleSummary,
       summary,
       activeCounts: summary.activeCounts,
@@ -1686,6 +2056,10 @@ async function meshQueueCancel(ctx, args) {
     if (!taskId) return JSON.stringify({ success: false, error: "task_id required" });
     const task = (0, import_daemon_core.cancelTask)(ctx.mesh.id, taskId, { reason: args.reason });
     if (!task) return JSON.stringify({ success: false, error: `Queue task '${taskId}' not found` });
+    if (isLocalTransport(ctx.transport)) {
+      ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
+      });
+    }
     return JSON.stringify({ success: true, task }, null, 2);
   } catch (e) {
     return JSON.stringify({ success: false, error: e.message });
@@ -1716,6 +2090,19 @@ async function meshQueueRequeue(ctx, args) {
   }
 }
 async function meshSendTask(ctx, args) {
+  const requestedTaskMode = readString(args.task_mode) || readString(args.taskMode);
+  const modeValidation = (0, import_daemon_core.validateMeshTaskModeRequest)(requestedTaskMode, args.message);
+  if (!modeValidation.valid) {
+    return JSON.stringify({
+      success: false,
+      code: "live_debug_readonly_guardrail_violation",
+      taskMode: modeValidation.taskMode || requestedTaskMode,
+      violations: modeValidation.violations,
+      allowedOperations: modeValidation.allowedOperations,
+      error: `live_debug_readonly_guardrail_violation: forbidden operations (${modeValidation.violations.join(", ")})`
+    });
+  }
+  const taskMode = modeValidation.taskMode;
   const node = await findNodeWithRefresh(ctx, args.node_id);
   if (node.policy?.readOnly) {
     return JSON.stringify({ error: `Node '${args.node_id}' is read-only` });
@@ -1743,13 +2130,15 @@ async function meshSendTask(ctx, args) {
       const res = await ctx.transport.meshEnqueueTask(node.daemonId, {
         meshId: ctx.mesh.id,
         message: args.message,
-        targetNodeId: args.node_id
+        targetNodeId: args.node_id,
+        ...taskMode ? { taskMode } : {}
       });
       return JSON.stringify(res);
     }
     const isLocalNode = isLocalControlPlaneNode(ctx, node);
     if (ctx.transport instanceof IpcTransport && node.daemonId && !isLocalNode) {
       const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id || ""));
+      const taskId = (0, import_node_crypto.randomUUID)();
       const result2 = await ipcDispatchToRemoteAgent(ctx, node, {
         session_id: args.session_id,
         message: args.message,
@@ -1758,60 +2147,123 @@ async function meshSendTask(ctx, args) {
       if (result2.success) {
         const dispatchedSessionId = args.session_id || result2.sessionId;
         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
+            })
           });
         } 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));
+      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);
+        if (!explicitSession) {
+          return JSON.stringify({
+            success: false,
+            recoverable: true,
+            code: "mesh_target_session_not_found",
+            reason: "mesh_target_session_not_found",
+            transport: "local_ipc",
+            retryRecommended: true,
+            nodeId: args.node_id,
+            sessionId: args.session_id,
+            error: `Local session '${args.session_id}' is not present in live status for node '${args.node_id}'.`,
+            nextAction: `Launch a fresh session with mesh_launch_session(node_id: '${args.node_id}') or retry without session_id so Repo Mesh can target a live delegate session.`
+          });
+        }
+        resolvedProviderType = resolveSessionProviderType(explicitSession);
+        if (resolvedProviderType) {
+          meshSessionProviderMetadata.set(meshSessionCacheKey(args.node_id, args.session_id), {
+            providerType: resolvedProviderType,
+            providerSessionId: readString(explicitSession?.providerSessionId) || void 0
+          });
+        }
+      }
+      if (!resolvedProviderType) {
+        return JSON.stringify({
+          success: false,
+          recoverable: true,
+          code: "mesh_target_session_provider_unknown",
+          reason: "mesh_target_session_provider_unknown",
+          transport: "local_ipc",
+          retryRecommended: false,
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          error: `Local session '${args.session_id}' is live but does not expose providerType/cliType, so agent_command cannot be routed safely.`,
+          nextAction: `Relaunch the target session on node '${args.node_id}' or retry without session_id so Repo Mesh can pick a session with provider metadata.`
+        });
+      }
       const dispatchResult = await commandForNode(ctx, node, "agent_command", {
         targetSessionId: args.session_id,
-        ...cached?.providerType ? { agentType: cached.providerType, cliType: cached.providerType, providerType: cached.providerType } : {},
+        agentType: resolvedProviderType,
+        cliType: resolvedProviderType,
+        providerType: resolvedProviderType,
         action: "send_chat",
         message: args.message
       });
       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,
           error: dispatchPayload?.error || dispatchResult?.error || "agent_command rejected the task"
         });
       }
+      const taskId = (0, import_node_crypto.randomUUID)();
       try {
         (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
           kind: "task_dispatched",
           nodeId: args.node_id,
           sessionId: args.session_id,
-          providerType: cached?.providerType,
-          payload: { message: args.message, via: "local_direct" }
+          providerType: resolvedProviderType,
+          payload: buildDirectTaskPayload(args.message, "local_direct", {
+            taskId,
+            taskMode,
+            providerType: resolvedProviderType,
+            targetSessionId: args.session_id
+          })
         });
       } catch {
       }
-      return JSON.stringify({ success: true, dispatched: true, nodeId: args.node_id, sessionId: args.session_id });
+      return JSON.stringify({ success: true, dispatched: true, source: "direct", taskId, taskMode, providerType: resolvedProviderType, nodeId: args.node_id, sessionId: args.session_id });
     }
     const task = (0, import_daemon_core.enqueueTask)(ctx.mesh.id, args.message, {
       targetNodeId: args.node_id,
-      targetSessionId: args.session_id
+      targetSessionId: args.session_id,
+      taskMode
     });
     if (isLocalTransport(ctx.transport) || ctx.transport instanceof IpcTransport) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
     }
-    const pendingEvents = isLocalTransport(ctx.transport) ? (0, import_daemon_core.drainPendingMeshCoordinatorEvents)() : [];
-    const result = { success: true, nodeId: args.node_id, taskId: task.id, status: task.status };
+    const pendingEvents = isLocalTransport(ctx.transport) ? (0, import_daemon_core.drainPendingMeshCoordinatorEvents)(ctx.mesh.id) : [];
+    const result = { success: true, source: "queue", nodeId: args.node_id, taskId: task.id, status: task.status, taskMode: task.taskMode };
     if (pendingEvents.length > 0) {
       result.pendingCoordinatorEvents = pendingEvents;
     }
@@ -1831,6 +2283,9 @@ 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;
@@ -1933,6 +2388,10 @@ async function meshLaunchSession(ctx, args) {
     const coordinatorNode = resolveCoordinatorNode(ctx);
     const coordinatorDaemonId = coordinatorNode?.daemonId || ctx.localDaemonId;
     const spawnedSessionVisibility = readSpawnedSessionVisibility(ctx.mesh.policy);
+    const isLocalNode = isLocalControlPlaneNode(ctx, node);
+    if (node.daemonId && !isLocalNode && !coordinatorDaemonId) {
+      return JSON.stringify(buildMissingCoordinatorDaemonIdFailure(ctx, node, resolvedProviderType), null, 2);
+    }
     let result;
     try {
       result = await commandForNode(ctx, node, "launch_cli", {
@@ -1973,7 +2432,6 @@ async function meshLaunchSession(ctx, args) {
       });
     } catch {
     }
-    const isLocalNode = isLocalControlPlaneNode(ctx, node);
     if (ctx.transport instanceof IpcTransport && node.daemonId && !isLocalNode) {
       ctx.transport.meshCommand(node.daemonId, "trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
@@ -1998,6 +2456,9 @@ async function meshLaunchSession(ctx, args) {
     const coordinatorNode = resolveCoordinatorNode(ctx);
     const coordinatorDaemonId = coordinatorNode?.daemonId || ctx.localDaemonId;
     const spawnedSessionVisibility = readSpawnedSessionVisibility(ctx.mesh.policy);
+    if (!coordinatorDaemonId) {
+      return JSON.stringify(buildMissingCoordinatorDaemonIdFailure(ctx, node, resolvedProviderType), null, 2);
+    }
     try {
       const res = await ctx.transport.launch(node.daemonId, {
         type: resolvedProviderType,
@@ -2036,7 +2497,7 @@ async function meshGitStatus(ctx, args) {
   const submoduleIgnorePaths = node.policy?.submoduleIgnorePaths || [];
   try {
     if (!isLocalTransport(ctx.transport) && node.daemonId) {
-      const result = await ctx.transport.gitStatus(node.daemonId, node.workspace, true);
+      const result = await ctx.transport.gitStatus(node.daemonId, node.workspace, true, true);
       return JSON.stringify({
         nodeId: args.node_id,
         workspace: node.workspace,
@@ -2048,6 +2509,7 @@ async function meshGitStatus(ctx, args) {
     } else if (isLocalTransport(ctx.transport)) {
       const statusResult = await commandForNode(ctx, node, "git_status", {
         workspace: node.workspace,
+        refreshUpstream: true,
         includeSubmodules: autoDiscoverSubmodules,
         submoduleIgnorePaths: submoduleIgnorePaths.length > 0 ? submoduleIgnorePaths : void 0
       });
@@ -2077,6 +2539,51 @@ async function meshGitStatus(ctx, args) {
     }, null, 2);
   }
 }
+async function meshFastForwardNode(ctx, args) {
+  await refreshMeshFromDaemon(ctx);
+  const node = await findNodeWithRefresh(ctx, args.node_id);
+  const submoduleIgnorePaths = node.policy?.submoduleIgnorePaths || [];
+  if (node.policy?.readOnly) {
+    return JSON.stringify({
+      success: false,
+      code: "node_read_only",
+      nodeId: args.node_id,
+      workspace: node.workspace,
+      allowed: false,
+      willRun: false,
+      executed: false,
+      blockingReasons: ["node_read_only"]
+    }, null, 2);
+  }
+  try {
+    const dryRun = args.dry_run === true || args.execute !== true;
+    const result = await commandForNode(ctx, node, "fast_forward_mesh_node", {
+      meshId: ctx.mesh.id,
+      nodeId: node.id,
+      workspace: node.workspace,
+      branch: typeof args.branch === "string" ? args.branch : void 0,
+      execute: args.execute === true && args.dry_run !== true,
+      dryRun,
+      updateSubmodules: args.update_submodules === true,
+      submoduleIgnorePaths: submoduleIgnorePaths.length > 0 ? submoduleIgnorePaths : void 0
+    });
+    return JSON.stringify(unwrapCommandPayload(result), null, 2);
+  } catch (e) {
+    const failure = buildCoordinatorP2pRelayFailure(e, {
+      command: "fast_forward_mesh_node",
+      targetDaemonId: node.daemonId,
+      nodeId: args.node_id
+    });
+    return JSON.stringify({
+      ...failure,
+      workspace: node.workspace,
+      allowed: false,
+      willRun: false,
+      executed: false,
+      blockingReasons: [failure.code || "mesh_fast_forward_unavailable"]
+    }, null, 2);
+  }
+}
 async function meshCheckpoint(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
   if (node.policy?.readOnly) {
@@ -2162,6 +2669,7 @@ async function meshCloneNode(ctx, args) {
       if (existingIndex >= 0) ctx.mesh.nodes[existingIndex] = clonePayload.node;
       else ctx.mesh.nodes.push(clonePayload.node);
       ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await syncCoordinatorDaemonMeshCache(ctx);
     }
     return JSON.stringify(result, null, 2);
   } else if (!isLocalTransport(ctx.transport) && sourceNode.daemonId) {
@@ -2179,6 +2687,7 @@ async function meshCloneNode(ctx, args) {
         if (existingIndex >= 0) ctx.mesh.nodes[existingIndex] = clonePayload.node;
         else ctx.mesh.nodes.push(clonePayload.node);
         ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await syncCoordinatorDaemonMeshCache(ctx);
       }
       return JSON.stringify(res, null, 2);
     } catch (e) {
@@ -2274,6 +2783,43 @@ async function meshRemoveNode(ctx, args) {
     return JSON.stringify({ error: "Cloud mesh remove_node requires node daemonId" });
   }
 }
+function resolveRefineConfigNode(ctx, nodeId) {
+  if (nodeId) return findNode(ctx.mesh, nodeId);
+  const node = ctx.mesh.nodes.find((entry) => !!entry.workspace);
+  if (!node) throw new Error("No mesh node with a workspace is available");
+  return node;
+}
+async function meshRefineConfigSchema(ctx) {
+  const node = resolveRefineConfigNode(ctx);
+  const result = await commandForNode(ctx, node, "get_mesh_refine_config_schema", {});
+  return JSON.stringify(result, null, 2);
+}
+async function meshValidateRefineConfig(ctx, args) {
+  const node = resolveRefineConfigNode(ctx, args.node_id);
+  const result = await commandForNode(ctx, node, "validate_mesh_refine_config", {
+    workspace: node.workspace,
+    inlineMesh: ctx.mesh,
+    ...args.config ? { config: args.config } : {}
+  });
+  return JSON.stringify(result, null, 2);
+}
+async function meshSuggestRefineConfig(ctx, args) {
+  const node = resolveRefineConfigNode(ctx, args.node_id);
+  const result = await commandForNode(ctx, node, "suggest_mesh_refine_config", {
+    workspace: node.workspace,
+    inlineMesh: ctx.mesh
+  });
+  return JSON.stringify(result, null, 2);
+}
+async function meshRefinePlan(ctx, args) {
+  const node = await findNodeWithRefresh(ctx, args.node_id);
+  const result = await commandForNode(ctx, node, "plan_mesh_refine_node", {
+    meshId: ctx.mesh.id,
+    nodeId: args.node_id,
+    inlineMesh: ctx.mesh
+  });
+  return JSON.stringify(result, null, 2);
+}
 async function meshRefineNode(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
   if (isLocalTransport(ctx.transport)) {
@@ -2282,7 +2828,7 @@ async function meshRefineNode(ctx, args) {
       nodeId: args.node_id,
       inlineMesh: ctx.mesh
     });
-    if (result?.success && result.removeResult?.removed !== false) {
+    if (result?.success && result.async !== true && result.removeResult?.removed !== false) {
       const idx = ctx.mesh.nodes.findIndex((n) => n.id === args.node_id);
       if (idx >= 0) {
         ctx.mesh.nodes.splice(idx, 1);
@@ -2297,7 +2843,7 @@ async function meshRefineNode(ctx, args) {
         nodeId: args.node_id,
         inlineMesh: ctx.mesh
       });
-      if (res?.success && res.removeResult?.removed !== false) {
+      if (res?.success && res.async !== true && res.removeResult?.removed !== false) {
         const idx = ctx.mesh.nodes.findIndex((n) => n.id === args.node_id);
         if (idx >= 0) {
           ctx.mesh.nodes.splice(idx, 1);
@@ -2334,13 +2880,13 @@ var STANDARD_TOOLS = [
 function buildMcpHelpText() {
   const meshTools = ALL_MESH_TOOLS.map((tool) => tool.name);
   return `
-adhdev-mcp \u2014 ADHDev MCP Server
+ADHDev MCP Server
 
 Usage:
-  adhdev-mcp                                    Local mode (requires standalone daemon)
-  adhdev-mcp --api-key <key>                    Cloud mode (ADHDev cloud API)
-  adhdev-mcp --mode ipc --repo-mesh <mesh_id>   Cloud daemon IPC mesh mode
-  adhdev-mcp --repo-mesh <mesh_id>              Mesh mode (coordinator-scoped tools)
+  adhdev mcp                                    Local mode (requires standalone daemon)
+  adhdev mcp --api-key <key>                    Cloud mode (ADHDev cloud API)
+  adhdev mcp --mode ipc --repo-mesh <mesh_id>   Cloud daemon IPC mesh mode
+  adhdev-mcp --help                             Compatibility bin (same server, legacy package entrypoint)
 
 Options:
   --mode <mode>           Transport: local, cloud, or ipc
@@ -2519,8 +3065,8 @@ var CloudTransport = class {
     if (!res.ok) throw new Error(`Approve failed: ${res.status}`);
     return res.json();
   }
-  async gitStatus(daemonId, workspace, includeDiff = true) {
-    const params = new URLSearchParams({ workspace, includeDiff: String(includeDiff) });
+  async gitStatus(daemonId, workspace, includeDiff = true, refreshUpstream = false) {
+    const params = new URLSearchParams({ workspace, includeDiff: String(includeDiff), refreshUpstream: String(refreshUpstream) });
     const res = await fetch(
       `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-status?${params}`,
       { headers: this.headers() }
@@ -2915,6 +3461,22 @@ 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 role = m.role === "user" ? "User" : m.role === "assistant" ? "Agent" : m.role;
+      const content = messageContent(m);
+      const truncated = content.length > 500 ? `${content.slice(0, 500)}\u2026` : content;
+      return `[${role}] ${truncated}`;
+    });
+    if (compactPayload.summary) {
+      const truncatedSummary = compactPayload.summary.length > 500 ? `${compactPayload.summary.slice(0, 500)}\u2026` : compactPayload.summary;
+      lines2.push(`[Summary] ${truncatedSummary}`);
+    }
+    if (result?.pollingAdvisory) {
+      lines2.push(`Advisory: ${result.pollingAdvisory.message}`);
+    }
+    return lines2.length > 0 ? lines2.join("\n\n") : "No messages in chat.";
+  }
   if (outputMessages.length === 0) {
     return result?.pollingAdvisory ? `No messages in chat.
 
@@ -4015,6 +4577,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;
@@ -4030,6 +4595,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;