@adhdev/daemon-standalone 0.9.82-rc.5 → 0.9.82-rc.51

package/vendor/mcp-server/index.js

@@ -143,6 +143,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 +165,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 +245,11 @@ var meshSessionProviderMetadata = /* @__PURE__ */ new Map();
 function readString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
+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 +261,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 +286,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 +338,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 +409,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);
@@ -580,22 +629,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 +709,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 +843,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) {
@@ -880,6 +1013,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 +1033,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 +1081,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 +1121,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 +1156,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 +1208,71 @@ 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),
+    ...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);
 }
@@ -1318,6 +1540,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,
@@ -1335,6 +1594,10 @@ var ALL_MESH_TOOLS = [
   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 +1615,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 +1634,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 +1642,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;
@@ -1460,6 +1726,11 @@ async function meshStatus(ctx) {
     repoIdentity: mesh.repoIdentity,
     policy: mesh.policy,
     refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceOfTruth: {
+      membership: "coordinator_daemon_live_mesh",
+      currentStatus: "live_git_and_session_probes",
+      historicalEvidenceOnly: ["recoveryHints", "ledgerSummary"]
+    },
     nodes: results,
     branchConvergenceSummary: summarizeBranchConvergence(results)
   };
@@ -1468,13 +1739,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 +1749,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 });
@@ -1775,9 +2041,52 @@ async function meshSendTask(ctx, args) {
     }
     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
       });
@@ -1795,7 +2104,7 @@ async function meshSendTask(ctx, args) {
           kind: "task_dispatched",
           nodeId: args.node_id,
           sessionId: args.session_id,
-          providerType: cached?.providerType,
+          providerType: resolvedProviderType,
           payload: { message: args.message, via: "local_direct" }
         });
       } catch {
@@ -1810,7 +2119,7 @@ async function meshSendTask(ctx, args) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
     }
-    const pendingEvents = isLocalTransport(ctx.transport) ? (0, import_daemon_core.drainPendingMeshCoordinatorEvents)() : [];
+    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 };
     if (pendingEvents.length > 0) {
       result.pendingCoordinatorEvents = pendingEvents;
@@ -1831,6 +2140,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 +2245,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 +2289,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 +2313,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 +2354,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 +2366,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
       });
@@ -2162,6 +2481,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 +2499,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 +2595,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)) {
@@ -2519,8 +2877,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 +3273,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.
 
@@ -4030,6 +4404,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;