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

package/dist/index.mjs

@@ -657,23 +657,97 @@ var init_config = __esm({
   }
 });
 
+// src/mesh/mesh-host-ownership.ts
+function readObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function normalizeMeshDaemonRole(value) {
+  return value === "host" || value === "member" ? value : void 0;
+}
+function resolveMeshHostStatus(mesh) {
+  const meshRecord = readObject(mesh);
+  const raw = readObject(meshRecord?.meshHost);
+  const role = normalizeMeshDaemonRole(raw?.role) ?? "host";
+  const pairing = readObject(raw?.pairing);
+  const normalized = {
+    role,
+    canOwnCoordinator: role === "host",
+    canOwnQueue: role === "host",
+    defaulted: !raw
+  };
+  const hostDaemonId = readString(raw?.hostDaemonId);
+  const hostNodeId = readString(raw?.hostNodeId);
+  const hostAddress = readString(raw?.hostAddress);
+  if (hostDaemonId) normalized.hostDaemonId = hostDaemonId;
+  if (hostNodeId) normalized.hostNodeId = hostNodeId;
+  if (hostAddress) normalized.hostAddress = hostAddress;
+  if (pairing) {
+    const status = pairing.status === "pairing" || pairing.status === "paired" || pairing.status === "rejected" || pairing.status === "revoked" ? pairing.status : "not_configured";
+    normalized.pairing = {
+      status,
+      ...readString(pairing.tokenId) ? { tokenId: readString(pairing.tokenId) } : {},
+      ...readString(pairing.joinedAt) ? { joinedAt: readString(pairing.joinedAt) } : {},
+      ...readString(pairing.lastPairedAt) ? { lastPairedAt: readString(pairing.lastPairedAt) } : {},
+      ...readString(pairing.lastRejectedAt) ? { lastRejectedAt: readString(pairing.lastRejectedAt) } : {},
+      ...readString(pairing.expiresAt) ? { expiresAt: readString(pairing.expiresAt) } : {}
+    };
+  }
+  return normalized;
+}
+function isMeshHostOwner(mesh) {
+  return resolveMeshHostStatus(mesh).role === "host";
+}
+function buildMeshHostRequiredFailure(mesh, operation) {
+  const meshHost = resolveMeshHostStatus(mesh);
+  return {
+    success: false,
+    code: "mesh_host_required",
+    error: `Mesh Host daemon required for ${operation}; member daemons must pair with the host and cannot own coordinator/queue mutations.`,
+    meshHost
+  };
+}
+function requireMeshHostQueueOwner(opts) {
+  if (opts?.ownerRole === "member") {
+    throw new Error("Mesh Host daemon required to mutate mesh queue; member daemons must use the host-owned queue.");
+  }
+}
+function createDefaultMeshHostMetadata() {
+  return {
+    role: "host",
+    pairing: { status: "not_configured" }
+  };
+}
+var init_mesh_host_ownership = __esm({
+  "src/mesh/mesh-host-ownership.ts"() {
+    "use strict";
+  }
+});
+
 // src/config/mesh-config.ts
 var mesh_config_exports = {};
 __export(mesh_config_exports, {
   addNode: () => addNode,
+  applyMeshHostJoinRequest: () => applyMeshHostJoinRequest,
+  configureMeshHostPairing: () => configureMeshHostPairing,
   createMesh: () => createMesh,
+  createMeshHostPairingToken: () => createMeshHostPairingToken,
   deleteMesh: () => deleteMesh,
   getMesh: () => getMesh,
   getMeshByRepo: () => getMeshByRepo,
   listMeshes: () => listMeshes,
+  markMeshHostPairingJoined: () => markMeshHostPairingJoined,
   normalizeRepoIdentity: () => normalizeRepoIdentity,
   removeNode: () => removeNode,
+  tokenIdForManualPairing: () => tokenIdForManualPairing,
   updateMesh: () => updateMesh,
   updateNode: () => updateNode
 });
 import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join4 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+import { createHash, randomBytes, randomUUID as randomUUID3 } from "crypto";
 function getMeshConfigPath() {
   return join4(getConfigDir(), "meshes.json");
 }
@@ -746,6 +820,7 @@ function createMesh(opts) {
     defaultBranch: opts.defaultBranch,
     policy: mergeMeshPolicy(void 0, opts.policy),
     coordinator: opts.coordinator || {},
+    meshHost: opts.meshHost || createDefaultMeshHostMetadata(),
     nodes: [],
     createdAt: now,
     updatedAt: now
@@ -762,6 +837,7 @@ function updateMesh(meshId, opts) {
   if (opts.defaultBranch !== void 0) mesh.defaultBranch = opts.defaultBranch;
   if (opts.policy) mesh.policy = mergeMeshPolicy(mesh.policy, opts.policy);
   if (opts.coordinator) mesh.coordinator = opts.coordinator;
+  if (opts.meshHost) mesh.meshHost = opts.meshHost;
   mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   saveMeshConfig(config);
   return mesh;
@@ -774,6 +850,186 @@ function deleteMesh(meshId) {
   saveMeshConfig(config);
   return true;
 }
+function normalizeManualHostAddress(hostAddress) {
+  const normalized = hostAddress.trim().replace(/\/+$/, "");
+  if (!normalized) throw new Error("hostAddress required");
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    throw new Error("hostAddress must be a valid http(s) or ws(s) URL");
+  }
+  if (!["http:", "https:", "ws:", "wss:"].includes(parsed.protocol)) {
+    throw new Error("hostAddress must use http, https, ws, or wss");
+  }
+  return normalized;
+}
+function tokenIdForManualPairing(token) {
+  return `tok_${createHash("sha256").update(token).digest("hex").slice(0, 16)}`;
+}
+function normalizeTokenExpiry(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) throw new Error("expiresAt must be a valid ISO date");
+  return date.toISOString();
+}
+function assertPairingTokenValid(pairing, rawToken, nowIso) {
+  const token = rawToken.trim();
+  if (!token) return { ok: false, reason: "token required" };
+  const presentedTokenId = tokenIdForManualPairing(token);
+  const expectedTokenId = pairing?.tokenId;
+  if (!expectedTokenId || pairing?.status === "not_configured" || pairing?.status === "revoked") {
+    return { ok: false, reason: "host pairing token is not configured", presentedTokenId };
+  }
+  if (pairing.expiresAt && new Date(pairing.expiresAt).getTime() <= new Date(nowIso).getTime()) {
+    return { ok: false, reason: "host pairing token expired", expectedTokenId, presentedTokenId };
+  }
+  if (presentedTokenId !== expectedTokenId) {
+    return { ok: false, reason: "invalid pairing token", expectedTokenId, presentedTokenId };
+  }
+  return { ok: true, tokenId: presentedTokenId };
+}
+function configureMeshHostPairing(meshId, opts) {
+  const hostAddress = normalizeManualHostAddress(opts.hostAddress);
+  const token = opts.token.trim();
+  if (!token) throw new Error("token required");
+  const config = loadMeshConfig();
+  const mesh = config.meshes.find((m) => m.id === meshId);
+  if (!mesh) return void 0;
+  const now = opts.now || (/* @__PURE__ */ new Date()).toISOString();
+  const previous = mesh.meshHost || createDefaultMeshHostMetadata();
+  const meshHost = {
+    ...previous,
+    role: "member",
+    hostAddress,
+    pairing: {
+      status: "pairing",
+      tokenId: tokenIdForManualPairing(token),
+      lastPairedAt: now
+    }
+  };
+  mesh.meshHost = meshHost;
+  mesh.updatedAt = now;
+  saveMeshConfig(config);
+  return { mesh, meshHost, hostAddress };
+}
+function createMeshHostPairingToken(meshId, opts = {}) {
+  const config = loadMeshConfig();
+  const mesh = config.meshes.find((m) => m.id === meshId);
+  if (!mesh) return void 0;
+  const now = opts.now || (/* @__PURE__ */ new Date()).toISOString();
+  const token = (opts.token || `mhj_${randomBytes(24).toString("base64url")}`).trim();
+  if (!token) throw new Error("token required");
+  const tokenId = tokenIdForManualPairing(token);
+  const expiresAt = normalizeTokenExpiry(opts.expiresAt);
+  const previous = mesh.meshHost || createDefaultMeshHostMetadata();
+  if (previous.role === "member") {
+    throw new Error("Mesh Host daemon required to create host pairing tokens; member daemons cannot mint host join tokens.");
+  }
+  const meshHost = {
+    ...previous,
+    role: "host",
+    pairing: {
+      status: "pairing",
+      tokenId,
+      lastPairedAt: now,
+      ...expiresAt ? { expiresAt } : {}
+    }
+  };
+  mesh.meshHost = meshHost;
+  mesh.updatedAt = now;
+  saveMeshConfig(config);
+  return { mesh, meshHost, token, tokenId, ...expiresAt ? { expiresAt } : {} };
+}
+function applyMeshHostJoinRequest(meshId, opts) {
+  const config = loadMeshConfig();
+  const mesh = config.meshes.find((m) => m.id === meshId);
+  if (!mesh) return void 0;
+  const now = opts.now || (/* @__PURE__ */ new Date()).toISOString();
+  const previous = mesh.meshHost || createDefaultMeshHostMetadata();
+  if (previous.role === "member") {
+    return { accepted: false, mesh, meshHost: previous, reason: "Mesh Host daemon required to accept join requests" };
+  }
+  const meshHost = { ...previous, role: "host" };
+  const validation = assertPairingTokenValid(meshHost.pairing, opts.token, now);
+  if (!validation.ok) {
+    mesh.meshHost = {
+      ...meshHost,
+      pairing: {
+        ...meshHost.pairing || { status: "not_configured" },
+        status: "rejected",
+        lastRejectedAt: now
+      }
+    };
+    mesh.updatedAt = now;
+    saveMeshConfig(config);
+    return { accepted: false, mesh, meshHost: mesh.meshHost, tokenId: validation.presentedTokenId, reason: validation.reason };
+  }
+  const workspace = opts.memberNode.workspace.trim();
+  if (!workspace) throw new Error("memberNode.workspace required");
+  const memberId = opts.memberNode.id?.trim();
+  let node = mesh.nodes.find((n) => memberId && n.id === memberId || n.workspace === workspace);
+  if (node) {
+    node.workspace = workspace;
+    node.repoRoot = opts.memberNode.repoRoot;
+    node.daemonId = opts.memberNode.daemonId;
+    node.machineId = opts.memberNode.machineId;
+    node.userOverrides = opts.memberNode.userOverrides || node.userOverrides || {};
+    node.policy = { ...node.policy || {}, ...opts.memberNode.policy || {} };
+    node.role = "member";
+  } else {
+    if (mesh.nodes.length >= 10) throw new Error("Maximum 10 nodes per mesh");
+    node = {
+      id: memberId || `node_${randomUUID3().replace(/-/g, "")}`,
+      workspace,
+      repoRoot: opts.memberNode.repoRoot,
+      daemonId: opts.memberNode.daemonId,
+      machineId: opts.memberNode.machineId,
+      userOverrides: opts.memberNode.userOverrides || {},
+      policy: opts.memberNode.policy || {},
+      role: "member"
+    };
+    mesh.nodes.push(node);
+  }
+  mesh.meshHost = {
+    ...meshHost,
+    pairing: {
+      ...meshHost.pairing || {},
+      status: "paired",
+      tokenId: validation.tokenId,
+      joinedAt: now,
+      lastPairedAt: meshHost.pairing?.lastPairedAt || now,
+      ...meshHost.pairing?.expiresAt ? { expiresAt: meshHost.pairing.expiresAt } : {}
+    }
+  };
+  mesh.updatedAt = now;
+  saveMeshConfig(config);
+  return { accepted: true, mesh, meshHost: mesh.meshHost, node, tokenId: validation.tokenId };
+}
+function markMeshHostPairingJoined(meshId, opts) {
+  const config = loadMeshConfig();
+  const mesh = config.meshes.find((m) => m.id === meshId);
+  if (!mesh) return void 0;
+  const now = opts.joinedAt || (/* @__PURE__ */ new Date()).toISOString();
+  const previous = mesh.meshHost || createDefaultMeshHostMetadata();
+  const tokenId = opts.tokenId || (opts.token ? tokenIdForManualPairing(opts.token) : previous.pairing?.tokenId);
+  mesh.meshHost = {
+    ...previous,
+    role: "member",
+    ...opts.hostDaemonId ? { hostDaemonId: opts.hostDaemonId } : {},
+    ...opts.hostNodeId ? { hostNodeId: opts.hostNodeId } : {},
+    pairing: {
+      ...previous.pairing || {},
+      status: "paired",
+      ...tokenId ? { tokenId } : {},
+      joinedAt: now,
+      lastPairedAt: previous.pairing?.lastPairedAt || now
+    }
+  };
+  mesh.updatedAt = now;
+  saveMeshConfig(config);
+  return { mesh, meshHost: mesh.meshHost };
+}
 function addNode(meshId, opts) {
   const config = loadMeshConfig();
   const mesh = config.meshes.find((m) => m.id === meshId);
@@ -794,7 +1050,8 @@ function addNode(meshId, opts) {
     policy: opts.policy || {},
     isLocalWorktree: opts.isLocalWorktree,
     worktreeBranch: opts.worktreeBranch,
-    clonedFromNodeId: opts.clonedFromNodeId
+    clonedFromNodeId: opts.clonedFromNodeId,
+    role: opts.role
   };
   mesh.nodes.push(node);
   mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -830,6 +1087,7 @@ var init_mesh_config = __esm({
     "use strict";
     init_config();
     init_repo_mesh_types();
+    init_mesh_host_ownership();
     SESSION_CLEANUP_MODES = /* @__PURE__ */ new Set(["preserve", "stop", "delete_stopped", "stop_and_delete"]);
     SPAWNED_SESSION_VISIBILITY_MODES = /* @__PURE__ */ new Set(["visible", "hidden"]);
   }
@@ -1007,8 +1265,8 @@ __export(mesh_ledger_exports, {
   readLedgerEntries: () => readLedgerEntries,
   readLedgerSlice: () => readLedgerSlice
 });
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, appendFileSync, statSync as statSync2, renameSync } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, appendFileSync, statSync as statSync2, renameSync } from "fs";
+import { join as join6 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter } from "events";
 function isIntentionalCleanupStopEntry(entry) {
@@ -1017,19 +1275,19 @@ function isIntentionalCleanupStopEntry(entry) {
   return payload.intentional === true && (payload.reason === "operator_cleanup" || payload.intentionalStopReason === "operator_cleanup" || payload.source === "mesh_cleanup_sessions" || payload.source === "mesh_remove_node");
 }
 function getLedgerDir() {
-  const dir = join5(getConfigDir(), LEDGER_DIR_NAME);
-  if (!existsSync5(dir)) {
+  const dir = join6(getConfigDir(), LEDGER_DIR_NAME);
+  if (!existsSync6(dir)) {
     mkdirSync3(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function getLedgerPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join5(getLedgerDir(), `${safe}.jsonl`);
+  return join6(getLedgerDir(), `${safe}.jsonl`);
 }
 function getRotatedPath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join5(getLedgerDir(), `${safe}.${index}.jsonl`);
+  return join6(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
 function buildTaskCompletionEvidence(opts) {
   const providerSessionId = opts.providerSessionId?.trim() || void 0;
@@ -1070,7 +1328,7 @@ function appendLedgerEntry(meshId, partial) {
     ...partial
   };
   const filePath = getLedgerPath(meshId);
-  if (existsSync5(filePath)) {
+  if (existsSync6(filePath)) {
     try {
       const stat2 = statSync2(filePath);
       if (stat2.size >= MAX_FILE_SIZE_BYTES) {
@@ -1137,10 +1395,10 @@ function appendRemoteLedgerEntries(meshId, entries) {
 }
 function readLedgerEntries(meshId, opts) {
   const filePath = getLedgerPath(meshId);
-  if (!existsSync5(filePath)) return [];
+  if (!existsSync6(filePath)) return [];
   let content;
   try {
-    content = readFileSync3(filePath, "utf-8");
+    content = readFileSync4(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -1312,7 +1570,7 @@ function getSessionRecoveryContext(meshId, opts) {
 }
 function rotateLedgerFile(meshId, currentPath) {
   let index = 1;
-  while (existsSync5(getRotatedPath(meshId, index))) {
+  while (existsSync6(getRotatedPath(meshId, index))) {
     index++;
     if (index > 10) break;
   }
@@ -1351,18 +1609,48 @@ __export(mesh_work_queue_exports, {
   updateSessionTaskStatus: () => updateSessionTaskStatus,
   updateTaskStatus: () => updateTaskStatus
 });
-import { existsSync as existsSync6, writeFileSync as writeFileSync3, readFileSync as readFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, writeFileSync as writeFileSync3, readFileSync as readFileSync5, openSync, closeSync, unlinkSync } from "fs";
+import { join as join7 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 function getQueuePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join6(getLedgerDir(), `${safe}.queue.json`);
+  return join7(getLedgerDir(), `${safe}.queue.json`);
+}
+function getLockPath(meshId) {
+  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join7(getLedgerDir(), `${safe}.queue.lock`);
+}
+function withQueueLock(meshId, fn) {
+  const lockPath = getLockPath(meshId);
+  let fd = -1;
+  for (let i = 0; i < 10; i++) {
+    try {
+      fd = openSync(lockPath, "wx");
+      break;
+    } catch {
+      const deadline = Date.now() + 30;
+      while (Date.now() < deadline) {
+      }
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    if (fd !== -1) try {
+      closeSync(fd);
+    } catch {
+    }
+    try {
+      unlinkSync(lockPath);
+    } catch {
+    }
+  }
 }
 function readQueue(meshId) {
   const path28 = getQueuePath(meshId);
-  if (!existsSync6(path28)) return [];
+  if (!existsSync7(path28)) return [];
   try {
-    const content = readFileSync4(path28, "utf-8");
+    const content = readFileSync5(path28, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -1373,20 +1661,23 @@ function writeQueue(meshId, queue) {
   writeFileSync3(path28, JSON.stringify(queue, null, 2), "utf-8");
 }
 function enqueueTask(meshId, message, opts) {
-  const queue = readQueue(meshId);
-  const entry = {
-    id: randomUUID5(),
-    meshId,
-    message,
-    status: "pending",
-    targetNodeId: opts?.targetNodeId,
-    targetSessionId: opts?.targetSessionId,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  queue.push(entry);
-  writeQueue(meshId, queue);
-  return entry;
+  requireMeshHostQueueOwner(opts);
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const entry = {
+      id: randomUUID5(),
+      meshId,
+      message,
+      status: "pending",
+      targetNodeId: opts?.targetNodeId,
+      targetSessionId: opts?.targetSessionId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    queue.push(entry);
+    writeQueue(meshId, queue);
+    return entry;
+  });
 }
 function getQueue(meshId, opts) {
   let queue = readQueue(meshId);
@@ -1397,100 +1688,114 @@ function getQueue(meshId, opts) {
   return queue;
 }
 function claimNextTask(meshId, nodeId, sessionId) {
-  const queue = readQueue(meshId);
-  const hasActiveAssignment = queue.some((q) => q.status === "assigned" && (q.assignedSessionId === sessionId || q.assignedNodeId === nodeId));
-  if (hasActiveAssignment) return null;
-  let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetSessionId === sessionId);
-  if (targetIdx === -1) {
-    targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
-  }
-  if (targetIdx === -1) {
-    targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
-  }
-  if (targetIdx === -1) return null;
-  const entry = queue[targetIdx];
-  entry.status = "assigned";
-  entry.assignedNodeId = nodeId;
-  entry.assignedSessionId = sessionId;
-  entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-  entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeQueue(meshId, queue);
-  return entry;
-}
-function updateTaskStatus(meshId, taskId, status) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  queue[idx].status = status;
-  queue[idx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeQueue(meshId, queue);
-  return queue[idx];
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const hasActiveAssignment = queue.some((q) => q.status === "assigned" && (q.assignedSessionId === sessionId || q.assignedNodeId === nodeId));
+    if (hasActiveAssignment) return null;
+    let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetSessionId === sessionId);
+    if (targetIdx === -1) {
+      targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
+    }
+    if (targetIdx === -1) {
+      targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
+    }
+    if (targetIdx === -1) return null;
+    const entry = queue[targetIdx];
+    entry.status = "assigned";
+    entry.assignedNodeId = nodeId;
+    entry.assignedSessionId = sessionId;
+    entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeQueue(meshId, queue);
+    return entry;
+  });
+}
+function updateTaskStatus(meshId, taskId, status, opts) {
+  requireMeshHostQueueOwner(opts);
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    queue[idx].status = status;
+    queue[idx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeQueue(meshId, queue);
+    return queue[idx];
+  });
 }
 function recordTaskAutoLaunch(meshId, taskId, autoLaunch) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  queue[idx].autoLaunch = {
-    ...autoLaunch,
-    updatedAt: now
-  };
-  queue[idx].updatedAt = now;
-  writeQueue(meshId, queue);
-  return queue[idx];
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    queue[idx].autoLaunch = { ...autoLaunch, updatedAt: now };
+    queue[idx].updatedAt = now;
+    writeQueue(meshId, queue);
+    return queue[idx];
+  });
 }
 function cancelTask(meshId, taskId, opts) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  queue[idx].status = "cancelled";
-  queue[idx].updatedAt = now;
-  queue[idx].cancelledAt = now;
-  if (opts?.reason) queue[idx].cancelReason = opts.reason;
-  writeQueue(meshId, queue);
-  return queue[idx];
+  requireMeshHostQueueOwner(opts);
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    queue[idx].status = "cancelled";
+    queue[idx].updatedAt = now;
+    queue[idx].cancelledAt = now;
+    if (opts?.reason) queue[idx].cancelReason = opts.reason;
+    writeQueue(meshId, queue);
+    return queue[idx];
+  });
 }
 function requeueTask(meshId, taskId, opts) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  const entry = queue[idx];
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  entry.status = "pending";
-  delete entry.assignedNodeId;
-  delete entry.assignedSessionId;
-  delete entry.cancelledAt;
-  delete entry.cancelReason;
-  if (opts?.clearTargetNode) delete entry.targetNodeId;
-  if (typeof opts?.targetNodeId === "string") entry.targetNodeId = opts.targetNodeId;
-  if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
-  if (typeof opts?.targetSessionId === "string") entry.targetSessionId = opts.targetSessionId;
-  entry.updatedAt = now;
-  entry.requeuedAt = now;
-  entry.requeueCount = (entry.requeueCount || 0) + 1;
-  if (opts?.reason) entry.requeueReason = opts.reason;
-  writeQueue(meshId, queue);
-  return entry;
-}
-function updateSessionTaskStatus(meshId, sessionId, status) {
-  const queue = readQueue(meshId);
-  let bestIdx = -1;
-  let bestTime = 0;
-  for (let i = queue.length - 1; i >= 0; i--) {
-    if (queue[i].assignedSessionId === sessionId && queue[i].status === "assigned") {
+  requireMeshHostQueueOwner(opts);
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    const entry = queue[idx];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    entry.status = "pending";
+    delete entry.assignedNodeId;
+    delete entry.assignedSessionId;
+    delete entry.cancelledAt;
+    delete entry.cancelReason;
+    if (opts?.clearTargetNode) delete entry.targetNodeId;
+    if (typeof opts?.targetNodeId === "string") entry.targetNodeId = opts.targetNodeId;
+    if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
+    if (typeof opts?.targetSessionId === "string") entry.targetSessionId = opts.targetSessionId;
+    entry.updatedAt = now;
+    entry.requeuedAt = now;
+    entry.requeueCount = (entry.requeueCount || 0) + 1;
+    if (opts?.reason) entry.requeueReason = opts.reason;
+    writeQueue(meshId, queue);
+    return entry;
+  });
+}
+function updateSessionTaskStatus(meshId, sessionId, status, opts) {
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const occurredAtTime = opts?.occurredAt ? new Date(opts.occurredAt).getTime() : Number.NaN;
+    const hasOccurredAt = Number.isFinite(occurredAtTime);
+    let bestIdx = -1;
+    let bestTime = 0;
+    for (let i = queue.length - 1; i >= 0; i--) {
+      if (queue[i].assignedSessionId !== sessionId || queue[i].status !== "assigned") continue;
       const time = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
+      if (hasOccurredAt && Number.isFinite(time) && time > occurredAtTime) continue;
       if (time > bestTime) {
         bestTime = time;
         bestIdx = i;
       }
     }
-  }
-  if (bestIdx === -1) return null;
-  queue[bestIdx].status = status;
-  queue[bestIdx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeQueue(meshId, queue);
-  return queue[bestIdx];
+    if (bestIdx === -1) return null;
+    queue[bestIdx].status = status;
+    queue[bestIdx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeQueue(meshId, queue);
+    return queue[bestIdx];
+  });
 }
 function getMeshQueueStats(meshId) {
   const queue = readQueue(meshId);
@@ -1530,6 +1835,7 @@ var init_mesh_work_queue = __esm({
   "src/mesh/mesh-work-queue.ts"() {
     "use strict";
     init_mesh_ledger();
+    init_mesh_host_ownership();
     ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
     HISTORICAL_MESH_QUEUE_STATUSES = ["completed", "failed", "cancelled"];
   }
@@ -1539,7 +1845,7 @@ var init_mesh_work_queue = __esm({
 import { exec } from "child_process";
 import * as os2 from "os";
 import * as path8 from "path";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 function parseVersion(raw) {
   const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
   return match ? match[1] : raw.split("\n")[0].slice(0, 100);
@@ -1563,7 +1869,7 @@ function resolveCommandPath(command) {
   if (isExplicitCommandPath(trimmed)) {
     const expanded = expandHome(trimmed);
     const candidate = path8.isAbsolute(expanded) ? expanded : path8.resolve(expanded);
-    return existsSync7(candidate) ? candidate : null;
+    return existsSync8(candidate) ? candidate : null;
   }
   return null;
 }
@@ -1890,18 +2196,77 @@ __export(mesh_events_exports, {
   drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
   getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
   handleMeshForwardEvent: () => handleMeshForwardEvent,
+  queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   setupMeshEventForwarding: () => setupMeshEventForwarding,
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
-function drainPendingMeshCoordinatorEvents() {
-  return pendingMeshCoordinatorEvents.splice(0);
+import { appendFileSync as appendFileSync3, existsSync as existsSync10, readFileSync as readFileSync6, unlinkSync as unlinkSync3 } from "fs";
+import { join as join10 } from "path";
+function sweepExpiredRemoteIdleSessions() {
+  const now = Date.now();
+  for (const [key, session] of remoteIdleSessions) {
+    if (session.expiresAt <= now) remoteIdleSessions.delete(key);
+  }
+}
+function getPendingEventsPath(meshId) {
+  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join10(getLedgerDir(), `${safe}.pending-events.jsonl`);
+}
+function queuePendingMeshCoordinatorEvent(event) {
+  try {
+    appendFileSync3(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
+    return true;
+  } catch (e) {
+    LOG.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
+    return false;
+  }
+}
+function drainPendingMeshCoordinatorEvents(meshId) {
+  if (!meshId) return [];
+  const path28 = getPendingEventsPath(meshId);
+  if (!existsSync10(path28)) return [];
+  try {
+    const raw = readFileSync6(path28, "utf-8");
+    try {
+      unlinkSync3(path28);
+    } catch {
+    }
+    return raw.split("\n").filter(Boolean).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
 }
-function getPendingMeshCoordinatorEvents() {
-  return pendingMeshCoordinatorEvents.slice();
+function getPendingMeshCoordinatorEvents(meshId) {
+  if (!meshId) return [];
+  const path28 = getPendingEventsPath(meshId);
+  if (!existsSync10(path28)) return [];
+  try {
+    const raw = readFileSync6(path28, "utf-8");
+    return raw.split("\n").filter(Boolean).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
 }
-function clearPendingMeshCoordinatorEvents() {
-  pendingMeshCoordinatorEvents.splice(0);
+function clearPendingMeshCoordinatorEvents(meshId) {
+  if (!meshId) return;
+  const path28 = getPendingEventsPath(meshId);
+  if (existsSync10(path28)) try {
+    unlinkSync3(path28);
+  } catch {
+  }
 }
 function readNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
@@ -1947,6 +2312,38 @@ function shouldSuppressIntentionalCleanupStop(args) {
   if (isIntentionalCleanupStopMetadata(args.metadataEvent)) return true;
   return hasRecentIntentionalCleanupStop(args.meshId, args.sessionId, args.nodeId);
 }
+function readEventTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric;
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+}
+function buildMeshCompletionFingerprint(args) {
+  const timestampPart = Number.isFinite(args.timestamp) ? String(args.timestamp) : readNonEmptyString(args.finalSummary).slice(0, 200);
+  return [
+    args.meshId,
+    args.event,
+    args.sessionId,
+    args.providerType || "",
+    args.providerSessionId || "",
+    timestampPart
+  ].join("::");
+}
+function isDuplicateMeshCompletionEvent(args) {
+  const fingerprint = buildMeshCompletionFingerprint(args);
+  if (!fingerprint) return false;
+  const now = Date.now();
+  for (const [key, seenAt] of recentCompletionFingerprints.entries()) {
+    if (now - seenAt > RECENT_COMPLETION_FINGERPRINT_TTL_MS) recentCompletionFingerprints.delete(key);
+  }
+  if (recentCompletionFingerprints.has(fingerprint)) return true;
+  recentCompletionFingerprints.set(fingerprint, now);
+  return false;
+}
 function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
   const task = claimNextTask(meshId, nodeId, sessionId);
   if (!task) {
@@ -1965,7 +2362,16 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
         message: task.message
       }).catch((e) => {
         LOG.error("MeshQueue", `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
-        updateTaskStatus(meshId, task.id, "failed");
+        updateTaskStatus(meshId, task.id, "pending");
+        try {
+          appendLedgerEntry(meshId, {
+            kind: "dispatch_failed",
+            nodeId,
+            sessionId,
+            payload: { taskId: task.id, error: e?.message, retryable: true }
+          });
+        } catch {
+        }
       });
       return true;
     }
@@ -2299,18 +2705,36 @@ function injectMeshSystemMessage(components, args) {
     LOG.info("MeshEvents", `Suppressed ${args.event} for intentionally cleanup-stopped session ${eventSessionId || "(unknown session)"}`);
     return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
   }
+  const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
+  if (args.event === "agent:generating_completed" && eventSessionId) {
+    const duplicateCompletion = isDuplicateMeshCompletionEvent({
+      meshId: args.meshId,
+      event: args.event,
+      sessionId: eventSessionId,
+      providerType: readNonEmptyString(args.metadataEvent.providerType) || void 0,
+      providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
+      timestamp: eventTimestamp,
+      finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
+    });
+    if (duplicateCompletion) {
+      LOG.info("MeshEvents", `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
+      return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true };
+    }
+  }
   let completedTaskForLedger = null;
   if (args.event === "agent:generating_completed") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
     const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
     const providerType = readNonEmptyString(args.metadataEvent.providerType);
     if (sessionId) {
-      const completedTask = updateSessionTaskStatus(args.meshId, sessionId, "completed");
+      const completedTask = updateSessionTaskStatus(args.meshId, sessionId, "completed", {
+        occurredAt: eventTimestamp !== null ? new Date(eventTimestamp).toISOString() : void 0
+      });
       completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
       if (nodeId && providerType) {
-        setTimeout(() => {
+        setImmediate(() => {
           tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-        }, 500);
+        });
       }
     }
   } else if (args.event === "agent:ready") {
@@ -2348,13 +2772,17 @@ function injectMeshSystemMessage(components, args) {
       }
     }
     if (sessionId && nodeId && providerType) {
-      remoteIdleSessions.set(`${nodeId}:${sessionId}`, { nodeId, sessionId, providerType });
-      setTimeout(() => {
+      sweepExpiredRemoteIdleSessions();
+      remoteIdleSessions.set(`${nodeId}:${sessionId}`, {
+        nodeId,
+        sessionId,
+        providerType,
+        expiresAt: Date.now() + REMOTE_IDLE_SESSION_TTL_MS
+      });
+      setImmediate(() => {
         const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-        if (assigned) {
-          remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
-        }
-      }, 500);
+        if (assigned) remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+      });
     }
   } else if (args.event === "agent:generating_started") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
@@ -2465,17 +2893,18 @@ function injectMeshSystemMessage(components, args) {
     return true;
   });
   if (coordinatorInstances.length === 0) {
-    if (pendingMeshCoordinatorEvents.length < MAX_PENDING_EVENTS) {
-      pendingMeshCoordinatorEvents.push({
-        event: args.event,
-        meshId: args.meshId,
-        nodeLabel: args.nodeLabel,
-        metadataEvent: {
-          ...args.metadataEvent,
-          ...recoveryContext ? { recoveryContext } : {}
-        },
-        queuedAt: Date.now()
-      });
+    if (queuePendingMeshCoordinatorEvent({
+      event: args.event,
+      meshId: args.meshId,
+      nodeLabel: args.nodeLabel,
+      nodeId: args.nodeId || void 0,
+      workspace: readNonEmptyString(args.metadataEvent.workspace),
+      metadataEvent: {
+        ...args.metadataEvent,
+        ...recoveryContext ? { recoveryContext } : {}
+      },
+      queuedAt: Date.now()
+    })) {
       LOG.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
     }
     return { success: true, forwarded: 0 };
@@ -2514,6 +2943,7 @@ function handleMeshForwardEvent(components, payload) {
       providerType: readNonEmptyString(payload.providerType),
       providerSessionId: readNonEmptyString(payload.providerSessionId),
       finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
+      ...payload.timestamp !== void 0 ? { timestamp: payload.timestamp } : {},
       intentional: payload.intentional === true,
       intentionalStop: payload.intentionalStop === true,
       operatorCleanup: payload.operatorCleanup === true,
@@ -2556,7 +2986,7 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
+var REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, recentCompletionFingerprints, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
 var init_mesh_events = __esm({
   "src/mesh/mesh-events.ts"() {
     "use strict";
@@ -2566,9 +2996,8 @@ var init_mesh_events = __esm({
     init_logger();
     init_mesh_ledger();
     init_mesh_work_queue();
+    REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
     remoteIdleSessions = /* @__PURE__ */ new Map();
-    MAX_PENDING_EVENTS = 50;
-    pendingMeshCoordinatorEvents = [];
     MESH_COORDINATOR_EVENTS = /* @__PURE__ */ new Set([
       "agent:generating_started",
       "agent:generating_completed",
@@ -2584,6 +3013,8 @@ var init_mesh_events = __esm({
       "monitor:long_generating": "task_stalled"
     };
     INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
+    RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
+    recentCompletionFingerprints = /* @__PURE__ */ new Map();
     autoLaunchInProgress = /* @__PURE__ */ new Set();
     autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
     AUTO_LAUNCH_COOLDOWN_MS = 5e3;
@@ -5676,8 +6107,14 @@ async function getGitRepoStatus(workspace, options = {}) {
   const includeSubmodules = options.includeSubmodules !== false;
   try {
     const repo = await resolveGitRepository(workspace, options);
-    const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
-    const parsed = parsePorcelainV2Status(statusOutput.stdout);
+    let parsed = await readPorcelainStatus(repo, options);
+    let upstreamProbe = getInitialUpstreamProbe(parsed);
+    if (options.refreshUpstream) {
+      upstreamProbe = await refreshTrackedUpstream(repo, parsed, options);
+      if (upstreamProbe.upstreamStatus === "fresh") {
+        parsed = await readPorcelainStatus(repo, options);
+      }
+    }
     const head = await readHead(repo, options);
     const stashCount = await readStashCount(repo, options);
     let submodules;
@@ -5692,6 +6129,9 @@ async function getGitRepoStatus(workspace, options = {}) {
       headCommit: head.commit,
       headMessage: head.message,
       upstream: parsed.upstream,
+      upstreamStatus: parsed.upstream ? upstreamProbe.upstreamStatus : "no_upstream",
+      upstreamFetchedAt: upstreamProbe.upstreamFetchedAt,
+      upstreamFetchError: upstreamProbe.upstreamFetchError,
       ahead: parsed.ahead,
       behind: parsed.behind,
       staged: parsed.staged,
@@ -5716,6 +6156,60 @@ async function getGitRepoStatus(workspace, options = {}) {
     );
   }
 }
+async function readPorcelainStatus(repo, options) {
+  const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
+  return parsePorcelainV2Status(statusOutput.stdout);
+}
+function getInitialUpstreamProbe(parsed) {
+  return {
+    upstreamStatus: parsed.upstream ? "unchecked" : "no_upstream"
+  };
+}
+async function refreshTrackedUpstream(repo, parsed, options) {
+  if (!parsed.upstream || !parsed.branch) {
+    return { upstreamStatus: "no_upstream" };
+  }
+  const remoteName = await readBranchRemote(repo, parsed.branch, options) ?? inferRemoteName(parsed.upstream);
+  if (!remoteName) {
+    return {
+      upstreamStatus: "stale",
+      upstreamFetchError: `Unable to resolve remote for upstream '${parsed.upstream}'`
+    };
+  }
+  try {
+    await runGit(repo, ["fetch", "--quiet", "--prune", "--no-tags", remoteName], options);
+    return {
+      upstreamStatus: "fresh",
+      upstreamFetchedAt: Date.now()
+    };
+  } catch (error) {
+    return {
+      upstreamStatus: "stale",
+      upstreamFetchError: formatGitError(error)
+    };
+  }
+}
+async function readBranchRemote(repo, branch, options) {
+  try {
+    const result = await runGit(repo, ["config", "--get", `branch.${branch}.remote`], options);
+    return result.stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function inferRemoteName(upstream) {
+  const [remoteName] = upstream.split("/");
+  return remoteName?.trim() || null;
+}
+function formatGitError(error) {
+  if (error instanceof GitCommandError) {
+    return error.stderr || error.message;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
 function parsePorcelainV2Status(output) {
   const parsed = {
     branch: null,
@@ -5810,6 +6304,7 @@ function emptyStatus(workspace, lastCheckedAt, error) {
     headCommit: null,
     headMessage: null,
     upstream: null,
+    upstreamStatus: "unavailable",
     ahead: 0,
     behind: 0,
     staged: 0,
@@ -6090,6 +6585,9 @@ function createGitCompactSummary(status, diffSummary) {
     isGitRepo: status.isGitRepo,
     repoRoot: status.repoRoot,
     branch: status.branch,
+    upstreamStatus: status.upstreamStatus,
+    upstreamFetchedAt: status.upstreamFetchedAt,
+    upstreamFetchError: status.upstreamFetchError,
     dirty: status.staged > 0 || status.modified > 0 || status.untracked > 0 || status.deleted > 0 || status.renamed > 0 || conflictCount > 0 || changedFiles > 0,
     changedFiles,
     ahead: status.ahead,
@@ -6434,7 +6932,7 @@ var defaultSnapshotStore = createGitSnapshotStore({
 });
 function createDefaultGitCommandServices() {
   return {
-    getStatus: ({ workspace }) => getGitRepoStatus(workspace),
+    getStatus: ({ workspace, refreshUpstream }) => getGitRepoStatus(workspace, { refreshUpstream }),
     getDiffSummary: ({ workspace }) => getGitDiffSummary(workspace),
     getDiffFile: ({ workspace, path: filePath }) => getGitFileDiff(workspace, filePath),
     createSnapshot: ({ workspace, reason, sessionId, turnId }) => defaultSnapshotStore.create({
@@ -6520,7 +7018,7 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
   switch (command) {
     case "git_status": {
       if (!services.getStatus) return serviceNotImplemented(command);
-      const status = await runService(() => services.getStatus({ workspace }));
+      const status = await runService(() => services.getStatus({ workspace, refreshUpstream: optionalBoolean(args?.refreshUpstream) }));
       return "success" in status ? status : { success: true, status };
     }
     case "git_diff_summary": {
@@ -7326,6 +7824,238 @@ function getSavedProviderSessions(state, filters) {
 init_mesh_config();
 init_coordinator_prompt();
 
+// src/mesh/refine-config.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
+import * as yaml from "js-yaml";
+var MESH_REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
+var MESH_REFINE_CONFIG_LOCATIONS = [
+  ".adhdev/refine.json",
+  ".adhdev/refine.yaml",
+  ".adhdev/refine.yml",
+  ".adhdev/repo-mesh-refine.json",
+  ".adhdev/repo-mesh-refine.yaml",
+  ".adhdev/repo-mesh-refine.yml",
+  "repo-mesh.refine.json",
+  "repo-mesh.refine.yaml",
+  "repo-mesh.refine.yml"
+];
+var MESH_REFINE_CONFIG_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  title: "ADHDev Repo Mesh Refinery Config",
+  type: "object",
+  additionalProperties: false,
+  required: ["version"],
+  properties: {
+    version: { const: 1 },
+    validation: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        required: { type: "boolean", default: true },
+        commands: {
+          type: "array",
+          minItems: 1,
+          maxItems: 8,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["command"],
+            properties: {
+              command: { type: "string", minLength: 1 },
+              args: { type: "array", items: { type: "string" } },
+              category: { enum: [...MESH_REFINE_VALIDATION_CATEGORIES, "custom"] },
+              cwd: { type: "string" },
+              timeoutMs: { type: "number", minimum: 1e3, maximum: 6e5 },
+              env: { type: "object", additionalProperties: { type: "string" } }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function tokenizeCommandString(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return null;
+  if (/[;&|<>`$\\\n\r'\"]/.test(trimmed)) return null;
+  const tokens = trimmed.split(/\s+/).filter(Boolean);
+  if (!tokens.length) return null;
+  if (tokens.some((token) => !/^[A-Za-z0-9_@./:=+-]+$/.test(token))) return null;
+  return tokens;
+}
+function validateCategory(value) {
+  return typeof value === "string" && [...MESH_REFINE_VALIDATION_CATEGORIES, "custom"].includes(value) ? value : "custom";
+}
+function normalizeCommandConfig(entry, source) {
+  if (!isRecord(entry) || typeof entry.command !== "string") {
+    return { rejected: { source, reason: "validation command must be an object with a command string" } };
+  }
+  const commandText = entry.command.trim();
+  const explicitArgs = Array.isArray(entry.args) ? entry.args : void 0;
+  if (explicitArgs && !explicitArgs.every((arg) => typeof arg === "string")) {
+    return { rejected: { source, command: commandText, reason: "args must be an array of strings" } };
+  }
+  let command = commandText;
+  let args = explicitArgs ? [...explicitArgs] : [];
+  if (!explicitArgs) {
+    const tokens = tokenizeCommandString(commandText);
+    if (!tokens) return { rejected: { source, command: commandText, reason: "unsafe command string is not allowlisted" } };
+    command = tokens[0];
+    args = tokens.slice(1);
+  } else if (!tokenizeCommandString(command)) {
+    return { rejected: { source, command: commandText, reason: "unsafe executable name is not allowlisted" } };
+  }
+  if (args.some((arg) => /[\n\r\0]/.test(arg))) {
+    return { rejected: { source, command: commandText, reason: "args cannot contain control characters" } };
+  }
+  if (entry.cwd !== void 0 && typeof entry.cwd !== "string") {
+    return { rejected: { source, command: commandText, reason: "cwd must be a string when provided" } };
+  }
+  if (entry.timeoutMs !== void 0 && (typeof entry.timeoutMs !== "number" || !Number.isFinite(entry.timeoutMs) || entry.timeoutMs < 1e3 || entry.timeoutMs > 6e5)) {
+    return { rejected: { source, command: commandText, reason: "timeoutMs must be between 1000 and 600000" } };
+  }
+  if (entry.env !== void 0 && (!isRecord(entry.env) || !Object.values(entry.env).every((value) => typeof value === "string"))) {
+    return { rejected: { source, command: commandText, reason: "env must be an object of string values" } };
+  }
+  return {
+    command: {
+      command,
+      args,
+      displayCommand: [command, ...args].join(" "),
+      category: validateCategory(entry.category),
+      source,
+      ...typeof entry.cwd === "string" && entry.cwd.trim() ? { cwd: entry.cwd.trim() } : {},
+      ...typeof entry.timeoutMs === "number" ? { timeoutMs: entry.timeoutMs } : {},
+      ...isRecord(entry.env) ? { env: entry.env } : {}
+    }
+  };
+}
+function validateMeshRefineConfig(config, source = "inline") {
+  const errors = [];
+  const commands = [];
+  const rejectedCommands = [];
+  if (!isRecord(config)) return { valid: false, errors: ["config must be an object"], commands, rejectedCommands };
+  if (config.version !== 1) errors.push("version must be 1");
+  const validation = config.validation;
+  if (validation !== void 0 && !isRecord(validation)) errors.push("validation must be an object");
+  const rawCommands = isRecord(validation) ? validation.commands : void 0;
+  if (rawCommands !== void 0 && !Array.isArray(rawCommands)) errors.push("validation.commands must be an array");
+  if (Array.isArray(rawCommands)) {
+    rawCommands.forEach((entry, index) => {
+      const normalized = normalizeCommandConfig(entry, `${source}:validation.commands[${index}]`);
+      if (normalized.command) commands.push(normalized.command);
+      if (normalized.rejected) rejectedCommands.push(normalized.rejected);
+    });
+  }
+  if (rejectedCommands.length) errors.push("one or more validation commands are invalid");
+  return { valid: errors.length === 0, errors, commands, rejectedCommands };
+}
+function parseConfigText(path28, text) {
+  if (/\.json$/i.test(path28)) return JSON.parse(text);
+  return yaml.load(text);
+}
+function loadMeshRefineConfig(mesh, workspace) {
+  const policy = mesh?.policy && typeof mesh.policy === "object" && !Array.isArray(mesh.policy) ? mesh.policy : {};
+  const inline = mesh?.refineConfig || policy.refineConfig || policy.refine;
+  if (inline !== void 0) {
+    const validation = validateMeshRefineConfig(inline, "mesh.policy.refineConfig");
+    if (!validation.valid) return { source: "mesh.policy.refineConfig", sourceType: "invalid", error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
+    return { config: inline, source: "mesh.policy.refineConfig", sourceType: "mesh_policy" };
+  }
+  for (const relative3 of MESH_REFINE_CONFIG_LOCATIONS) {
+    const configPath = join5(workspace, relative3);
+    if (!existsSync5(configPath)) continue;
+    try {
+      const parsed = parseConfigText(configPath, readFileSync3(configPath, "utf-8"));
+      const validation = validateMeshRefineConfig(parsed, relative3);
+      if (!validation.valid) return { source: relative3, sourceType: "invalid", path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
+      return { config: parsed, source: relative3, sourceType: "repo_file", path: configPath };
+    } catch (error) {
+      return { source: relative3, sourceType: "invalid", path: configPath, error: error?.message || String(error) };
+    }
+  }
+  return {
+    source: "unavailable",
+    sourceType: "unavailable",
+    error: `No repo mesh/refine config found. Checked: ${MESH_REFINE_CONFIG_LOCATIONS.join(", ")}`
+  };
+}
+function readPackageScripts(workspace) {
+  try {
+    const parsed = JSON.parse(readFileSync3(join5(workspace, "package.json"), "utf-8"));
+    return isRecord(parsed?.scripts) ? parsed.scripts : {};
+  } catch {
+    return {};
+  }
+}
+function collectProjectContextSuggestions(mesh) {
+  const commands = mesh?.projectContext?.commands;
+  if (!isRecord(commands)) return [];
+  const suggestions = [];
+  for (const category of MESH_REFINE_VALIDATION_CATEGORIES) {
+    const entries = Array.isArray(commands[category]) ? commands[category] : [];
+    for (const entry of entries) {
+      if (isRecord(entry) && typeof entry.command === "string") suggestions.push({ command: entry.command, category });
+    }
+  }
+  return suggestions;
+}
+function collectPackageScriptSuggestions(workspace) {
+  const scripts = readPackageScripts(workspace);
+  const suggestions = [];
+  for (const category of MESH_REFINE_VALIDATION_CATEGORIES) {
+    for (const scriptName of Object.keys(scripts)) {
+      if (scriptName === category || scriptName.startsWith(`${category}:`)) {
+        suggestions.push({ command: "npm", args: ["run", scriptName], category });
+      }
+    }
+  }
+  return suggestions;
+}
+function suggestMeshRefineConfig(mesh, workspace) {
+  const seen = /* @__PURE__ */ new Set();
+  const suggestions = [];
+  for (const entry of [...collectProjectContextSuggestions(mesh), ...collectPackageScriptSuggestions(workspace)]) {
+    const key = `${entry.command} ${(entry.args || []).join(" ")}`.trim();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    suggestions.push(entry);
+  }
+  return {
+    suggestions,
+    suggestedConfig: suggestions.length ? { version: 1, validation: { required: true, commands: suggestions.slice(0, 4) } } : void 0
+  };
+}
+function resolveMeshRefineValidationPlan(mesh, workspace) {
+  const loaded = loadMeshRefineConfig(mesh, workspace);
+  const suggestion = suggestMeshRefineConfig(mesh, workspace);
+  if (!loaded.config) {
+    return {
+      source: loaded.source,
+      sourceType: loaded.sourceType,
+      commands: [],
+      rejectedCommands: loaded.error ? [{ source: loaded.source, reason: loaded.error }] : [],
+      suggestions: suggestion.suggestions,
+      suggestedConfig: suggestion.suggestedConfig,
+      unavailableReason: loaded.error || "validation_unavailable: repo mesh/refine config missing"
+    };
+  }
+  const validation = validateMeshRefineConfig(loaded.config, loaded.source);
+  return {
+    source: loaded.path || loaded.source,
+    sourceType: loaded.sourceType,
+    commands: validation.commands,
+    rejectedCommands: validation.rejectedCommands,
+    suggestions: suggestion.suggestions,
+    suggestedConfig: suggestion.suggestedConfig,
+    unavailableReason: validation.commands.length ? void 0 : "validation_unavailable: repo mesh/refine config has no validation.commands"
+  };
+}
+
 // src/mesh/mesh-sync.ts
 init_mesh_config();
 async function syncMeshes(transport) {
@@ -7445,6 +8175,7 @@ function buildMeshLedgerReconciliationEvidence(meshId, replicas) {
 
 // src/index.ts
 init_mesh_work_queue();
+init_mesh_host_ownership();
 init_mesh_events();
 
 // src/mesh/p2p-relay-failure.ts
@@ -7559,8 +8290,8 @@ var P2pRelayFailureError = class extends Error {
 
 // src/config/state-store.ts
 init_config();
-import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join11 } from "path";
 var DEFAULT_STATE = {
   recentActivity: [],
   savedProviderSessions: [],
@@ -7573,7 +8304,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return join9(getConfigDir(), "state.json");
+  return join11(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -7609,11 +8340,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!existsSync9(statePath)) {
+  if (!existsSync11(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = readFileSync5(statePath, "utf-8");
+    const raw = readFileSync7(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -7630,7 +8361,7 @@ function resetState() {
 
 // src/detection/ide-detector.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { platform as platform2, homedir as homedir5 } from "os";
 import * as path10 from "path";
 var BUILTIN_IDE_DEFINITIONS = [];
@@ -7654,7 +8385,7 @@ function findCliCommand(command) {
   if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
     const candidate = trimmed.startsWith("~") ? path10.join(homedir5(), trimmed.slice(1)) : trimmed;
     const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
-    return existsSync10(resolved) ? resolved : null;
+    return existsSync12(resolved) ? resolved : null;
   }
   try {
     const result = execSync(
@@ -7685,9 +8416,9 @@ function checkPathExists(paths) {
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if (existsSync10(resolved)) return resolved;
+      if (existsSync12(resolved)) return resolved;
     } else {
-      if (existsSync10(normalized)) return normalized;
+      if (existsSync12(normalized)) return normalized;
     }
   }
   return null;
@@ -7701,7 +8432,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if (existsSync10(bundledCli)) resolvedCli = bundledCli;
+      if (existsSync12(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname9 } = await import("path");
@@ -7714,7 +8445,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if (existsSync10(c)) {
+        if (existsSync12(c)) {
           resolvedCli = c;
           break;
         }
@@ -9606,7 +10337,8 @@ var StatusMonitor = class {
 };
 
 // src/providers/chat-message-normalization.ts
-function extractFinalSummaryFromMessages(messages, maxChars = 500) {
+var DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4e3;
+function extractFinalSummaryFromMessages(messages, maxChars = DEFAULT_FINAL_SUMMARY_MAX_CHARS) {
   if (!Array.isArray(messages) || messages.length === 0) return "";
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
@@ -16869,7 +17601,7 @@ init_config();
 import * as os13 from "os";
 import * as path18 from "path";
 import * as crypto4 from "crypto";
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
 import { execFileSync } from "child_process";
 import chalk from "chalk";
 
@@ -19343,7 +20075,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return existsSync14(expandExecutable(trimmed));
+    return existsSync16(expandExecutable(trimmed));
   }
   try {
     execFileSync(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -22607,15 +23339,15 @@ cleanOldFiles();
 
 // src/commands/router.ts
 init_logger();
-import * as yaml from "js-yaml";
+import * as yaml2 from "js-yaml";
 
 // src/commands/mesh-coordinator.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync17, readdirSync as readdirSync7, realpathSync as realpathSync2 } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync19, readdirSync as readdirSync7, realpathSync as realpathSync2 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import * as os17 from "os";
-import { dirname as dirname4, isAbsolute as isAbsolute11, join as join20, resolve as resolve13 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute11, join as join22, resolve as resolve13 } from "path";
 var DEFAULT_SERVER_NAME = "adhdev-mesh";
 var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev-mcp";
 var HERMES_CLI_TYPE = "hermes-cli";
@@ -22638,7 +23370,7 @@ function resolveHermesMeshCoordinatorSetup(options) {
       reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
     };
   }
-  const configPath = join20(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
+  const configPath = join22(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
   if (!configPath.trim()) {
     return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace);
   }
@@ -22758,15 +23490,15 @@ function renderMeshCoordinatorTemplate(template, values) {
 function resolveHermesCoordinatorHome(meshId, workspace) {
   const key = `${meshId || "mesh"}
 ${resolve13(workspace || os17.tmpdir())}`;
-  const hash = createHash2("sha256").update(key).digest("hex").slice(0, 16);
-  return join20(os17.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
+  const hash = createHash3("sha256").update(key).digest("hex").slice(0, 16);
+  return join22(os17.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
   const trimmed = configPath.trim();
   if (trimmed === "~") return os17.homedir();
-  if (trimmed.startsWith("~/")) return join20(os17.homedir(), trimmed.slice(2));
+  if (trimmed.startsWith("~/")) return join22(os17.homedir(), trimmed.slice(2));
   if (isAbsolute11(trimmed)) return trimmed;
-  return join20(workspace, trimmed);
+  return join22(workspace, trimmed);
 }
 function resolveAdhdevMcpServerLaunch(options) {
   const entryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath);
@@ -22822,15 +23554,15 @@ function addNodeCandidatesFromPath(pathValue, addCandidate) {
   for (const entry of (pathValue || "").split(":")) {
     const dir = entry.trim();
     if (!dir) continue;
-    addCandidate(join20(dir, "node"));
+    addCandidate(join22(dir, "node"));
   }
 }
 function addNodeCandidatesFromNvm(homeDir, addCandidate) {
-  const versionsDir = join20(homeDir, ".nvm", "versions", "node");
+  const versionsDir = join22(homeDir, ".nvm", "versions", "node");
   try {
     const versionDirs = readdirSync7(versionsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(compareNodeVersionNamesDescending);
     for (const versionDir of versionDirs) {
-      addCandidate(join20(versionsDir, versionDir, "bin", "node"));
+      addCandidate(join22(versionsDir, versionDir, "bin", "node"));
     }
   } catch {
   }
@@ -22881,7 +23613,7 @@ function resolveAdhdevMcpEntryPath(explicitPath) {
     if (normalized) return normalized;
   }
   try {
-    const requireBase = process.argv[1] ? normalizeExistingPath(process.argv[1]) || process.argv[1] : join20(process.cwd(), "adhdev-daemon.js");
+    const requireBase = process.argv[1] ? normalizeExistingPath(process.argv[1]) || process.argv[1] : join22(process.cwd(), "adhdev-daemon.js");
     const req = createRequire2(requireBase);
     const resolvedModule = req.resolve("@adhdev/mcp-server");
     return normalizeExistingPath(resolvedModule) || resolvedModule;
@@ -22891,7 +23623,7 @@ function resolveAdhdevMcpEntryPath(explicitPath) {
 }
 function normalizeExistingPath(filePath) {
   try {
-    if (!existsSync17(filePath)) return null;
+    if (!existsSync19(filePath)) return null;
     return realpathSync2.native(filePath);
   } catch {
     return null;
@@ -22900,6 +23632,7 @@ function normalizeExistingPath(filePath) {
 
 // src/commands/router.ts
 init_mesh_events();
+init_mesh_host_ownership();
 
 // src/status/snapshot.ts
 init_config();
@@ -23603,13 +24336,85 @@ function readBooleanValue(...values) {
   }
   return void 0;
 }
-function readGitSubmodules(value) {
+function summarizeRepoMeshDebugGit(git) {
+  const record = readObjectRecord(git);
+  if (!Object.keys(record).length) return null;
+  const submodules = Array.isArray(record.submodules) ? record.submodules.map((entry) => ({
+    path: readStringValue(entry?.path) ?? null,
+    commit: readStringValue(entry?.commit)?.slice(0, 12) ?? null,
+    dirty: readBooleanValue(entry?.dirty) ?? false,
+    outOfSync: readBooleanValue(entry?.outOfSync, entry?.out_of_sync) ?? false
+  })) : [];
+  return {
+    isGitRepo: readBooleanValue(record.isGitRepo),
+    workspace: readStringValue(record.workspace) ?? null,
+    repoRoot: readStringValue(record.repoRoot, record.repo_root) ?? null,
+    branch: readStringValue(record.branch) ?? null,
+    upstream: readStringValue(record.upstream) ?? null,
+    upstreamStatus: readStringValue(record.upstreamStatus, record.upstream_status) ?? null,
+    headCommit: readStringValue(record.headCommit, record.head_commit)?.slice(0, 12) ?? null,
+    ahead: readNumberValue(record.ahead) ?? null,
+    behind: readNumberValue(record.behind) ?? null,
+    dirtyCounts: {
+      staged: readNumberValue(record.staged) ?? 0,
+      modified: readNumberValue(record.modified) ?? 0,
+      untracked: readNumberValue(record.untracked) ?? 0,
+      deleted: readNumberValue(record.deleted) ?? 0,
+      renamed: readNumberValue(record.renamed) ?? 0
+    },
+    lastCheckedAt: readNumberValue(record.lastCheckedAt, record.last_checked_at) ?? null,
+    submoduleCount: submodules.length,
+    submodules
+  };
+}
+function summarizeRepoMeshStatusDebug(status) {
+  const nodes = Array.isArray(status?.nodes) ? status.nodes : [];
+  return {
+    success: status?.success,
+    meshId: readStringValue(status?.meshId, status?.mesh_id) ?? null,
+    refreshedAt: readStringValue(status?.refreshedAt, status?.refreshed_at) ?? null,
+    sourceOfTruth: status?.sourceOfTruth ?? null,
+    nodeCount: nodes.length,
+    nodes: nodes.map((node) => ({
+      nodeId: readStringValue(node?.nodeId, node?.id) ?? null,
+      daemonId: readStringValue(node?.daemonId, node?.daemon_id) ?? null,
+      workspace: readStringValue(node?.workspace, node?.git?.workspace) ?? null,
+      health: readStringValue(node?.health) ?? null,
+      machineStatus: readStringValue(node?.machineStatus, node?.machine_status) ?? null,
+      connection: node?.connection && typeof node.connection === "object" ? {
+        state: readStringValue(node.connection.state) ?? null,
+        transport: readStringValue(node.connection.transport) ?? null,
+        source: readStringValue(node.connection.source) ?? null,
+        reported: readBooleanValue(node.connection.reported) ?? null
+      } : null,
+      gitProbePending: node?.gitProbePending === true,
+      launchReady: node?.launchReady === true,
+      git: summarizeRepoMeshDebugGit(node?.git)
+    }))
+  };
+}
+function logRepoMeshStatusDebug(event, fields) {
+  try {
+    LOG.info("MeshStatusDebug", `[RepoMeshStatusDebug] ${JSON.stringify({ event, ...fields })}`);
+  } catch {
+    LOG.info("MeshStatusDebug", `[RepoMeshStatusDebug] ${event}`);
+  }
+}
+function joinRepoPath(root, relativePath) {
+  const normalizedRoot = typeof root === "string" ? root.trim().replace(/[\\/]+$/, "") : "";
+  const normalizedPath = typeof relativePath === "string" ? relativePath.trim() : "";
+  if (!normalizedPath) return void 0;
+  if (/^(?:[A-Za-z]:[\\/]|\/)/.test(normalizedPath)) return normalizedPath;
+  if (!normalizedRoot) return void 0;
+  return `${normalizedRoot}/${normalizedPath.replace(/^[\\/]+/, "")}`;
+}
+function readGitSubmodules(value, parentRepoRoot) {
   if (!Array.isArray(value)) return void 0;
   const submodules = value.map((entry) => {
     const submodule = readObjectRecord(entry);
     const path28 = readStringValue(submodule.path);
     const commit = readStringValue(submodule.commit);
-    const repoPath = readStringValue(submodule.repoPath, submodule.repo_root);
+    const repoPath = readStringValue(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path28);
     if (!path28 || !commit || !repoPath) return null;
     return {
       path: path28,
@@ -23623,58 +24428,17 @@ function readGitSubmodules(value) {
   }).filter((entry) => entry !== null);
   return submodules.length > 0 ? submodules : void 0;
 }
-function buildCachedInlineMeshGitStatus(node) {
-  const cachedStatus = readObjectRecord(node?.cachedStatus);
-  const cachedGit = readObjectRecord(cachedStatus.git);
-  if (Object.keys(cachedGit).length) {
-    const conflictFiles2 = Array.isArray(cachedGit.conflictFiles) ? cachedGit.conflictFiles.filter((value) => typeof value === "string") : [];
-    const conflictCount2 = readNumberValue(cachedGit.conflicts) ?? conflictFiles2.length;
-    const hasConflicts2 = readBooleanValue(cachedGit.hasConflicts) ?? conflictCount2 > 0;
-    const isGitRepo2 = readBooleanValue(cachedGit.isGitRepo);
-    if (isGitRepo2 !== void 0) {
-      const submodules2 = readGitSubmodules(cachedGit.submodules);
-      return {
-        workspace: readStringValue(cachedGit.workspace, node?.workspace) || "",
-        repoRoot: readStringValue(cachedGit.repoRoot, node?.repoRoot, node?.workspace) || null,
-        isGitRepo: isGitRepo2,
-        branch: readStringValue(cachedGit.branch) ?? null,
-        headCommit: readStringValue(cachedGit.headCommit) ?? null,
-        headMessage: readStringValue(cachedGit.headMessage) ?? null,
-        upstream: readStringValue(cachedGit.upstream) ?? null,
-        ahead: readNumberValue(cachedGit.ahead) ?? 0,
-        behind: readNumberValue(cachedGit.behind) ?? 0,
-        staged: readNumberValue(cachedGit.staged) ?? 0,
-        modified: readNumberValue(cachedGit.modified) ?? 0,
-        untracked: readNumberValue(cachedGit.untracked) ?? 0,
-        deleted: readNumberValue(cachedGit.deleted) ?? 0,
-        renamed: readNumberValue(cachedGit.renamed) ?? 0,
-        hasConflicts: hasConflicts2,
-        conflictFiles: conflictFiles2,
-        stashCount: readNumberValue(cachedGit.stashCount) ?? 0,
-        lastCheckedAt: readNumberValue(cachedGit.lastCheckedAt) ?? Date.now(),
-        ...submodules2 ? { submodules: submodules2 } : {}
-      };
-    }
-  }
-  const rawGit = readObjectRecord(node?.lastGit ?? node?.last_git);
-  const gitResult = readObjectRecord(rawGit.result);
-  const directStatus = readObjectRecord(rawGit.status);
-  const nestedStatus = readObjectRecord(gitResult.status);
-  const rawProbe = readObjectRecord(node?.lastProbe ?? node?.last_probe);
-  const probeGit = readObjectRecord(rawProbe.git);
-  const probeGitResult = readObjectRecord(probeGit.result);
-  const probeDirectStatus = readObjectRecord(probeGit.status);
-  const probeNestedStatus = readObjectRecord(probeGitResult.status);
-  const status = Object.keys(directStatus).length ? directStatus : Object.keys(nestedStatus).length ? nestedStatus : Object.keys(probeDirectStatus).length ? probeDirectStatus : Object.keys(probeNestedStatus).length ? probeNestedStatus : {};
+function normalizeInlineMeshGitStatus(status, node, options) {
   const isGitRepo = readBooleanValue(status.isGitRepo);
   if (!Object.keys(status).length || isGitRepo === void 0) return void 0;
   const conflictFiles = Array.isArray(status.conflictFiles) ? status.conflictFiles.filter((value) => typeof value === "string") : [];
   const conflictCount = readNumberValue(status.conflicts) ?? conflictFiles.length;
   const hasConflicts = readBooleanValue(status.hasConflicts) ?? conflictCount > 0;
-  const submodules = readGitSubmodules(status.submodules);
+  const repoRoot = readStringValue(status.repoRoot, status.repo_root, node?.repoRoot, node?.repo_root, status.workspace, node?.workspace) || void 0;
+  const submodules = readGitSubmodules(status.submodules, repoRoot);
   return {
     workspace: readStringValue(status.workspace, node?.workspace) || "",
-    repoRoot: readStringValue(status.repoRoot, node?.repoRoot, node?.workspace) || null,
+    repoRoot: repoRoot ?? null,
     isGitRepo,
     branch: readStringValue(status.branch) ?? null,
     headCommit: readStringValue(status.headCommit) ?? null,
@@ -23690,30 +24454,456 @@ function buildCachedInlineMeshGitStatus(node) {
     hasConflicts,
     conflictFiles,
     stashCount: readNumberValue(status.stashCount) ?? 0,
-    lastCheckedAt: Date.now(),
+    lastCheckedAt: options?.lastCheckedAt ?? readNumberValue(status.lastCheckedAt) ?? Date.now(),
     ...submodules ? { submodules } : {}
   };
 }
-function applyCachedInlineMeshNodeStatus(status, node) {
+function scoreInlineMeshGitStatus(git) {
+  if (!git) return Number.NEGATIVE_INFINITY;
+  let score = 0;
+  if (readBooleanValue(git.isGitRepo) === true) score += 50;
+  if (readBooleanValue(git.isGitRepo) === false) score -= 10;
+  if (readStringValue(git.branch)) score += 20;
+  if (readStringValue(git.headCommit)) score += 20;
+  if (readStringValue(git.upstream)) score += 10;
+  if (readStringValue(git.upstreamStatus)) score += 5;
+  if (readNumberValue(git.ahead) !== void 0) score += 2;
+  if (readNumberValue(git.behind) !== void 0) score += 2;
+  if (Array.isArray(git.submodules) && git.submodules.length > 0) score += 4 + git.submodules.length;
+  if (readStringValue(git.error)) score -= 20;
+  return score;
+}
+function buildInlineMeshTransitGitStatus(node) {
+  const rawGit = readObjectRecord(node?.lastGit ?? node?.last_git);
+  const gitResult = readObjectRecord(rawGit.result);
+  const directStatus = readObjectRecord(rawGit.status);
+  const nestedStatus = readObjectRecord(gitResult.status);
+  const rawProbe = readObjectRecord(node?.lastProbe ?? node?.last_probe);
+  const probeGit = readObjectRecord(rawProbe.git);
+  const probeGitResult = readObjectRecord(probeGit.result);
+  const probeDirectStatus = readObjectRecord(probeGit.status);
+  const probeNestedStatus = readObjectRecord(probeGitResult.status);
+  const candidates = [directStatus, nestedStatus, probeDirectStatus, probeNestedStatus];
+  let best = null;
+  for (const status of candidates) {
+    const normalized = normalizeInlineMeshGitStatus(status, node, { lastCheckedAt: Date.now() });
+    if (!normalized) continue;
+    const score = scoreInlineMeshGitStatus(normalized);
+    if (!best || score > best.score) best = { git: normalized, score };
+  }
+  return best?.git;
+}
+function shouldRefreshStalePendingAggregate(snapshot, options) {
+  if (options?.requireDirectPeerTruth !== true || !Array.isArray(snapshot?.nodes)) return false;
+  return snapshot.nodes.some((node) => {
+    if (node?.gitProbePending !== true) return false;
+    const git = readObjectRecord(node?.git);
+    return !readBooleanValue(git.isGitRepo) && !readStringValue(git.branch, git.headCommit, git.upstream);
+  });
+}
+function buildLivePeerGitConnection(connection, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  const source = readStringValue(connection.source);
+  const transport = readStringValue(connection.transport);
+  return {
+    ...connection,
+    perspective: readStringValue(connection.perspective) ?? "selected_coordinator",
+    source: source && source !== "not_reported" ? source : "mesh_peer_status",
+    state: "connected",
+    transport: transport && transport !== "unknown" ? transport : "direct",
+    reported: true,
+    reason: "Live peer git snapshot reported by the selected coordinator.",
+    lastStateChangeAt: readStringValue(connection.lastStateChangeAt) ?? timestamp
+  };
+}
+function recordInlineMeshDirectGitTruth(node, git, source) {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return;
+  const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
+  const updatedAt = new Date(checkedAt).toISOString();
+  const nextGit = {
+    ...git,
+    lastCheckedAt: checkedAt
+  };
+  node.lastGit = {
+    source,
+    checkedAt,
+    status: nextGit
+  };
+  node.last_git = node.lastGit;
+  node.machineStatus = "online";
+  node.updatedAt = updatedAt;
+  node.lastSeenAt = updatedAt;
+  const repoRoot = readStringValue(nextGit.repoRoot);
+  if (repoRoot && !readStringValue(node.repoRoot)) node.repoRoot = repoRoot;
+}
+function buildCachedInlineMeshGitStatus(node) {
+  const liveGit = buildInlineMeshTransitGitStatus(node);
+  if (liveGit) return liveGit;
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const cachedGit = readObjectRecord(cachedStatus.git);
+  if (!Object.keys(cachedGit).length) return void 0;
+  return normalizeInlineMeshGitStatus(cachedGit, node);
+}
+function shouldDiscardCachedInlineMeshStatus(node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  if (!Object.keys(cachedStatus).length) return false;
+  const cachedGit = readObjectRecord(cachedStatus.git);
+  const workspaceError = readStringValue(cachedStatus.error, node?.error);
+  if (workspaceError && /workspace must be an existing directory/i.test(workspaceError)) return true;
+  const isGitRepo = readBooleanValue(cachedGit.isGitRepo);
+  const branch = readStringValue(cachedGit.branch);
+  const headCommit = readStringValue(cachedGit.headCommit);
+  return isGitRepo === false && !branch && !headCommit;
+}
+function stripInlineMeshTransientNodeState(node) {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return node;
+  const {
+    cachedStatus,
+    lastGit: _lastGit,
+    last_git: _lastGitLegacy,
+    lastProbe: _lastProbe,
+    last_probe: _lastProbeLegacy,
+    error: _error,
+    health: _health,
+    machineStatus: _machineStatus,
+    lastSeenAt: _lastSeenAt,
+    last_seen_at: _lastSeenAtLegacy,
+    updatedAt: _updatedAt,
+    updated_at: _updatedAtLegacy,
+    activeSession: _activeSession,
+    active_session: _activeSessionLegacy,
+    activeSessionId: _activeSessionId,
+    active_session_id: _activeSessionIdLegacy,
+    sessionId: _sessionId,
+    session_id: _sessionIdLegacy,
+    providerType: _providerType,
+    provider_type: _providerTypeLegacy,
+    ...rest
+  } = node;
+  if (cachedStatus && !shouldDiscardCachedInlineMeshStatus(node)) {
+    return { ...rest, cachedStatus };
+  }
+  return rest;
+}
+function hasInlineMeshTransientNodeState(node) {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return false;
+  return "cachedStatus" in node || "lastGit" in node || "last_git" in node || "lastProbe" in node || "last_probe" in node || "error" in node || "health" in node || "machineStatus" in node || "lastSeenAt" in node || "last_seen_at" in node || "updatedAt" in node || "updated_at" in node || "activeSession" in node || "active_session" in node || "activeSessionId" in node || "active_session_id" in node || "sessionId" in node || "session_id" in node || "providerType" in node || "provider_type" in node;
+}
+function inlineMeshCarriesTransientNodeTruth(inlineMesh) {
+  if (!inlineMesh || typeof inlineMesh !== "object" || Array.isArray(inlineMesh)) return false;
+  if (!Array.isArray(inlineMesh.nodes) || inlineMesh.nodes.length === 0) return false;
+  return inlineMesh.nodes.some((node) => hasInlineMeshTransientNodeState(node));
+}
+function readInlineMeshNodeId(node) {
+  return readStringValue(node?.id, node?.nodeId) || "";
+}
+function sanitizeInlineMesh(inlineMesh) {
+  if (!inlineMesh || typeof inlineMesh !== "object" || Array.isArray(inlineMesh)) return inlineMesh;
+  if (!Array.isArray(inlineMesh.nodes)) return inlineMesh;
+  let changed = false;
+  const nodes = inlineMesh.nodes.map((node) => {
+    if (!hasInlineMeshTransientNodeState(node)) return node;
+    changed = true;
+    return stripInlineMeshTransientNodeState(node);
+  });
+  if (!changed) return inlineMesh;
+  return {
+    ...inlineMesh,
+    nodes
+  };
+}
+function reconcileInlineMeshCache(cached, incoming) {
+  if (!cached || typeof cached !== "object" || Array.isArray(cached)) return incoming;
+  if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached;
+  const cachedNodes = Array.isArray(cached.nodes) ? cached.nodes : [];
+  const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
+  if (!cachedNodes.length || !incomingNodes.length) return { ...cached, ...incoming };
+  const incomingById = /* @__PURE__ */ new Map();
+  for (const node of incomingNodes) {
+    const nodeId = readInlineMeshNodeId(node);
+    if (nodeId) incomingById.set(nodeId, node);
+  }
+  const nodes = cachedNodes.map((cachedNode) => {
+    const nodeId = readInlineMeshNodeId(cachedNode);
+    const incomingNode = nodeId ? incomingById.get(nodeId) : void 0;
+    if (!incomingNode) return cachedNode;
+    if (hasInlineMeshTransientNodeState(incomingNode)) {
+      return { ...cachedNode, ...incomingNode };
+    }
+    return { ...stripInlineMeshTransientNodeState(cachedNode), ...incomingNode };
+  });
+  return {
+    ...cached,
+    ...incoming,
+    nodes
+  };
+}
+function hasGitWorktreeChanges(git) {
+  if (!git) return false;
+  return Number(git.staged || 0) + Number(git.modified || 0) + Number(git.untracked || 0) + Number(git.deleted || 0) + Number(git.renamed || 0) > 0;
+}
+function getGitSubmoduleDriftState(git) {
+  const submodules = Array.isArray(git?.submodules) ? git.submodules : [];
+  let dirty = false;
+  let outOfSync = false;
+  for (const entry of submodules) {
+    const submodule = readObjectRecord(entry);
+    if (readBooleanValue(submodule.dirty) === true) dirty = true;
+    if (readBooleanValue(submodule.outOfSync) === true || !!readStringValue(submodule.error)) outOfSync = true;
+  }
+  return { dirty, outOfSync };
+}
+function deriveMeshNodeHealthFromGit(git) {
+  if (!git || readBooleanValue(git.isGitRepo) === false) return "degraded";
+  const branch = readStringValue(git.branch);
+  if (!branch) return "degraded";
+  const submoduleDrift = getGitSubmoduleDriftState(git);
+  if (submoduleDrift.outOfSync) return "degraded";
+  if (submoduleDrift.dirty || hasGitWorktreeChanges(git)) return "dirty";
+  return "online";
+}
+function readCachedInlineMeshActiveSessions(node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const activeSession = readObjectRecord(cachedStatus.activeSession);
+  const fallbackSession = Object.keys(activeSession).length ? activeSession : readObjectRecord(node?.activeSession ?? node?.active_session);
+  const sessionId = readStringValue(fallbackSession.id, fallbackSession.sessionId, fallbackSession.session_id, node?.activeSessionId, node?.active_session_id, node?.sessionId, node?.session_id);
+  return sessionId ? [sessionId] : [];
+}
+function readCachedInlineMeshActiveSessionDetails(node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const activeSession = readObjectRecord(cachedStatus.activeSession);
+  const fallbackSession = Object.keys(activeSession).length ? activeSession : readObjectRecord(node?.activeSession ?? node?.active_session);
+  const sessionId = readStringValue(
+    fallbackSession.id,
+    fallbackSession.sessionId,
+    fallbackSession.session_id,
+    node?.activeSessionId,
+    node?.active_session_id,
+    node?.sessionId,
+    node?.session_id
+  );
+  if (!sessionId) return [];
+  return [{
+    sessionId,
+    providerType: readStringValue(
+      fallbackSession.providerType,
+      fallbackSession.provider_type,
+      fallbackSession.cliType,
+      fallbackSession.cli_type,
+      fallbackSession.provider,
+      node?.providerType,
+      node?.provider_type
+    ),
+    state: readStringValue(fallbackSession.status, fallbackSession.state, fallbackSession.lifecycle),
+    lifecycle: readStringValue(fallbackSession.lifecycle),
+    title: readStringValue(fallbackSession.title, fallbackSession.displayName, fallbackSession.display_name) ?? null,
+    workspace: readStringValue(fallbackSession.workspace, node?.workspace) ?? null,
+    lastActivityAt: readStringValue(fallbackSession.lastActivityAt, fallbackSession.last_activity_at) ?? null,
+    recoveryState: readStringValue(fallbackSession.recoveryState, fallbackSession.recovery_state) ?? null,
+    isCached: true
+  }];
+}
+function readLiveMeshSessionState(record) {
+  return readStringValue(
+    record?.meta?.sessionStatus,
+    record?.meta?.status,
+    record?.meta?.providerStatus,
+    record?.status,
+    record?.state,
+    record?.lifecycle
+  );
+}
+function toIsoTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return new Date(value).toISOString();
+  const stringValue = readStringValue(value);
+  return stringValue || null;
+}
+function synthesizeMeshNodeFreshnessFromConnection(status) {
+  const connection = readObjectRecord(status.connection);
+  const connectionFreshAt = toIsoTimestamp(connection.lastCommandAt ?? connection.lastConnectedAt ?? connection.lastStateChangeAt);
+  const git = readObjectRecord(status.git);
+  const gitCheckedAt = toIsoTimestamp(git.lastCheckedAt);
+  if (!status.lastSeenAt && connectionFreshAt) status.lastSeenAt = connectionFreshAt;
+  if (!status.updatedAt && (gitCheckedAt || connectionFreshAt)) {
+    status.updatedAt = gitCheckedAt ?? connectionFreshAt;
+  }
+}
+function finalizeMeshNodeStatus(args) {
+  const { status, node, daemonId, isSelfNode } = args;
+  if (!readStringValue(status.machineStatus)) {
+    const cachedStatus = readObjectRecord(node?.cachedStatus);
+    const machineStatus = readStringValue(cachedStatus.machineStatus, cachedStatus.machine_status, node?.machineStatus);
+    if (machineStatus) status.machineStatus = machineStatus;
+  }
+  synthesizeMeshNodeFreshnessFromConnection(status);
+  const connectionState = readStringValue(readObjectRecord(status.connection).state);
+  status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || connectionState === "connected" || isSelfNode);
+}
+async function probeRemoteMeshGitStatus(args) {
+  if (!args.dispatchMeshCommand) return null;
+  const remoteResult = await Promise.race([
+    args.dispatchMeshCommand(args.daemonId, "git_status", { workspace: args.workspace }),
+    new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), args.timeoutMs))
+  ]);
+  const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
+  return remoteGit && typeof remoteGit === "object" && typeof remoteGit.isGitRepo === "boolean" ? remoteGit : null;
+}
+async function hydrateInlineMeshDirectTruth(args) {
+  const nodes = Array.isArray(args.mesh?.nodes) ? args.mesh.nodes : [];
+  if (!nodes.length) {
+    return {
+      directEvidenceCount: 0,
+      localConfirmedCount: 0,
+      peerAttemptedCount: 0,
+      peerConfirmedCount: 0,
+      unavailableNodeIds: []
+    };
+  }
+  const selectedCoordinatorNodeId = readStringValue(
+    args.mesh?.coordinator?.preferredNodeId,
+    nodes[0]?.id,
+    nodes[0]?.nodeId
+  );
+  let localConfirmedCount = 0;
+  let peerAttemptedCount = 0;
+  let peerConfirmedCount = 0;
+  const unavailableNodeIds = [];
+  for (const [nodeIndex, node] of nodes.entries()) {
+    const nodeId = readStringValue(node?.id, node?.nodeId) || `node_${nodeIndex}`;
+    const workspace = readStringValue(node?.workspace);
+    const daemonId = readStringValue(node?.daemonId);
+    const isSelfNode = Boolean(
+      nodeId && selectedCoordinatorNodeId && nodeId === selectedCoordinatorNodeId
+    ) || Boolean(
+      daemonId && (daemonId === args.localMachineId || daemonId === args.statusInstanceId)
+    ) || Boolean(args.meshSource !== "local_config" && nodeIndex === 0);
+    if (!workspace) {
+      if (!isSelfNode && daemonId) unavailableNodeIds.push(nodeId);
+      continue;
+    }
+    if (isSelfNode && fs10.existsSync(workspace)) {
+      try {
+        const localGit = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+        if (localGit?.isGitRepo) {
+          recordInlineMeshDirectGitTruth(node, localGit, "selected_coordinator_local_git");
+          localConfirmedCount += 1;
+          continue;
+        }
+      } catch {
+      }
+    }
+    if (!daemonId || !args.dispatchMeshCommand) {
+      if (!isSelfNode) unavailableNodeIds.push(nodeId);
+      continue;
+    }
+    peerAttemptedCount += 1;
+    try {
+      const remoteGit = await probeRemoteMeshGitStatus({
+        dispatchMeshCommand: args.dispatchMeshCommand,
+        daemonId,
+        workspace,
+        timeoutMs: 8e3
+      });
+      if (remoteGit) {
+        recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+        peerConfirmedCount += 1;
+        continue;
+      }
+    } catch {
+    }
+    unavailableNodeIds.push(nodeId);
+  }
+  return {
+    directEvidenceCount: localConfirmedCount + peerConfirmedCount,
+    localConfirmedCount,
+    peerAttemptedCount,
+    peerConfirmedCount,
+    unavailableNodeIds
+  };
+}
+function summarizeMeshSessionRecord(record) {
+  return {
+    sessionId: readStringValue(record?.sessionId) || "unknown",
+    providerType: readStringValue(record?.providerType),
+    state: readLiveMeshSessionState(record),
+    lifecycle: readStringValue(record?.lifecycle),
+    surfaceKind: getSessionHostSurfaceKind(record),
+    recoveryState: readStringValue(record?.meta?.runtimeRecoveryState) ?? null,
+    workspace: readStringValue(record?.workspace) ?? null,
+    title: readStringValue(record?.displayName, record?.workspaceLabel) ?? null,
+    lastActivityAt: toIsoTimestamp(record?.updatedAt ?? record?.lastActivityAt ?? record?.last_activity_at),
+    isCached: false
+  };
+}
+function liveSessionRecordMatchesMeshNode(record, meshId, nodeId) {
+  const recordNodeId = readStringValue(record?.meta?.meshNodeId);
+  if (!recordNodeId || recordNodeId !== nodeId) return false;
+  const recordMeshId = readStringValue(record?.meta?.meshNodeFor);
+  return !recordMeshId || recordMeshId === meshId;
+}
+function liveSessionRecordMatchesMeshWorkspace(record, meshId, workspace) {
+  const recordWorkspace = readStringValue(record?.workspace);
+  if (!recordWorkspace || !workspace || recordWorkspace !== workspace) return false;
+  const recordMeshId = readStringValue(record?.meta?.meshNodeFor);
+  if (recordMeshId) return recordMeshId === meshId;
+  return record?.meta?.launchedByCoordinator === true || !!readStringValue(record?.meta?.meshNodeId);
+}
+function readLiveMeshNodeWorkspace(args) {
+  const directNodeWorkspace = args.liveSessionRecords.find((record) => liveSessionRecordMatchesMeshNode(record, args.meshId, args.nodeId) && readStringValue(record?.workspace));
+  if (directNodeWorkspace) {
+    return readStringValue(directNodeWorkspace.workspace) || "";
+  }
+  if (args.allowCoordinatorSession) {
+    const coordinatorWorkspace = args.liveSessionRecords.find((record) => readStringValue(record?.meta?.meshCoordinatorFor) === args.meshId && readStringValue(record?.workspace));
+    if (coordinatorWorkspace) {
+      return readStringValue(coordinatorWorkspace.workspace) || "";
+    }
+  }
+  return "";
+}
+function collectLiveMeshSessionRecords(args) {
+  const matches = args.liveSessionRecords.filter((record) => {
+    const nodeWorkspace = readStringValue(args.node?.workspace);
+    if (liveSessionRecordMatchesMeshNode(record, args.meshId, args.nodeId)) return true;
+    return !!nodeWorkspace && liveSessionRecordMatchesMeshWorkspace(record, args.meshId, nodeWorkspace);
+  });
+  if (args.allowCoordinatorSession) {
+    for (const record of args.liveSessionRecords) {
+      if (readStringValue(record?.meta?.meshCoordinatorFor) !== args.meshId) continue;
+      const sessionId = readStringValue(record?.sessionId);
+      if (sessionId && matches.some((entry) => readStringValue(entry?.sessionId) === sessionId)) continue;
+      matches.push(record);
+    }
+  }
+  return matches;
+}
+function applyCachedInlineMeshNodeStatus(status, node, options) {
   const cachedStatus = readObjectRecord(node?.cachedStatus);
-  const git = buildCachedInlineMeshGitStatus(node);
-  const error = readStringValue(cachedStatus.error, node?.error);
-  const health = readStringValue(cachedStatus.health, node?.health);
+  const liveGit = buildInlineMeshTransitGitStatus(node);
+  const git = options?.skipGit ? void 0 : liveGit ?? buildCachedInlineMeshGitStatus(node);
+  const error = options?.skipError ? void 0 : liveGit ? void 0 : readStringValue(cachedStatus.error, node?.error);
+  const health = options?.skipHealth ? void 0 : liveGit ? void 0 : readStringValue(cachedStatus.health, node?.health);
   const machineStatus = readStringValue(cachedStatus.machineStatus, node?.machineStatus);
-  if (!git && !error && !health) return false;
-  if (!machineStatus && !git && !error) return false;
+  const lastSeenAt = toIsoTimestamp(cachedStatus.lastSeenAt ?? cachedStatus.last_seen_at ?? node?.lastSeenAt ?? node?.last_seen_at);
+  const updatedAt = toIsoTimestamp(cachedStatus.updatedAt ?? cachedStatus.updated_at ?? node?.updatedAt ?? node?.updated_at);
+  const activeSessions = readCachedInlineMeshActiveSessions(node);
+  const activeSessionDetails = readCachedInlineMeshActiveSessionDetails(node);
+  if (!git && !error && !health && !machineStatus && !lastSeenAt && !updatedAt && activeSessions.length === 0) return false;
   if (git) status.git = git;
   if (error) status.error = error;
+  if (machineStatus) status.machineStatus = machineStatus;
+  if (lastSeenAt) status.lastSeenAt = lastSeenAt;
+  if (updatedAt) status.updatedAt = updatedAt;
+  if (activeSessions.length > 0) status.activeSessions = activeSessions;
+  if (activeSessionDetails.length > 0) status.activeSessionDetails = activeSessionDetails;
   if (health) {
     status.health = health;
     return true;
   }
   if (git) {
-    const dirty = Number(git.staged || 0) + Number(git.modified || 0) + Number(git.untracked || 0) + Number(git.deleted || 0) + Number(git.renamed || 0) > 0;
-    status.health = git.isGitRepo === false ? "degraded" : dirty ? "dirty" : "online";
+    status.health = deriveMeshNodeHealthFromGit(git);
     return true;
   }
-  return false;
+  return activeSessions.length > 0 || !!machineStatus || !!lastSeenAt || !!updatedAt;
 }
 async function resolveProviderTypeFromPriority(args) {
   if (!args.providerPriority.length) {
@@ -23738,152 +24928,116 @@ async function resolveProviderTypeFromPriority(args) {
   }
   return { error: `No usable provider detected for node '${args.nodeId}' from providerPriority: ${failed.join("; ")}` };
 }
-var REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
 var REFINE_VALIDATION_TIMEOUT_MS = 12e4;
 var REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
 var REFINE_VALIDATION_SUMMARY_CHARS = 2e3;
-var REFINE_VALIDATION_MAX_COMMANDS = 4;
+var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
 function truncateValidationOutput(value) {
   const text = typeof value === "string" ? value : value == null ? "" : String(value);
   if (text.length <= REFINE_VALIDATION_SUMMARY_CHARS) return text;
   return `${text.slice(0, REFINE_VALIDATION_SUMMARY_CHARS)}
 [truncated ${text.length - REFINE_VALIDATION_SUMMARY_CHARS} chars]`;
 }
-function readPackageScripts(workspace) {
-  try {
-    const packageJsonPath = pathJoin(workspace, "package.json");
-    const parsed = JSON.parse(fs10.readFileSync(packageJsonPath, "utf-8"));
-    return parsed?.scripts && typeof parsed.scripts === "object" && !Array.isArray(parsed.scripts) ? parsed.scripts : {};
-  } catch {
-    return {};
-  }
-}
-function tokenizeValidationCommand(command) {
-  const trimmed = command.trim();
-  if (!trimmed) return null;
-  if (/[;&|<>`$\\\n\r'\"]/.test(trimmed)) return null;
-  const tokens = trimmed.split(/\s+/).filter(Boolean);
-  if (!tokens.length) return null;
-  if (tokens.some((token) => !/^[A-Za-z0-9_@./:=+-]+$/.test(token))) return null;
-  return tokens;
-}
-function scriptMatchesValidationCategory(scriptName, category) {
-  return scriptName === category || scriptName.startsWith(`${category}:`);
-}
-function parsePackageManagerValidationCommand(rawCommand, category, scripts, source) {
-  const tokens = tokenizeValidationCommand(rawCommand);
-  if (!tokens) {
-    return { rejected: { command: rawCommand, category, source, reason: "unsafe command string is not allowlisted" } };
-  }
-  const [binary, second, third, ...rest] = tokens;
-  let scriptName = "";
-  let command = binary;
-  let args = [];
-  if ((binary === "npm" || binary === "pnpm" || binary === "bun") && second === "run" && third) {
-    scriptName = third;
-    args = ["run", scriptName, ...rest];
-  } else if (binary === "npm" && second === "test" && !third) {
-    scriptName = "test";
-    args = ["test"];
-  } else if (binary === "yarn" && second === "run" && third) {
-    scriptName = third;
-    args = ["run", scriptName, ...rest];
-  } else if (binary === "yarn" && second && !third) {
-    scriptName = second;
-    args = [scriptName];
-  } else {
-    return { rejected: { command: rawCommand, category, source, reason: "command is not a supported package-manager script invocation" } };
-  }
-  if (!scriptName || !Object.prototype.hasOwnProperty.call(scripts, scriptName)) {
-    return { rejected: { command: rawCommand, category, source, script: scriptName, reason: "script is not declared in package.json" } };
-  }
-  if (!scriptMatchesValidationCategory(scriptName, category)) {
-    return { rejected: { command: rawCommand, category, source, script: scriptName, reason: "script name is outside the validation category allowlist" } };
-  }
-  return {
-    command: {
-      command,
-      args,
-      displayCommand: [command, ...args].join(" "),
-      category,
-      source
-    }
-  };
+function recordMeshRefineStage(stages, stage, status, startedAt, details) {
+  stages.push({
+    stage,
+    status,
+    durationMs: Date.now() - startedAt,
+    ...details || {}
+  });
 }
-function collectProjectContextValidationCandidates(mesh) {
-  const commands = mesh?.projectContext?.commands;
-  if (!commands || typeof commands !== "object" || Array.isArray(commands)) return [];
-  const candidates = [];
-  for (const category of REFINE_VALIDATION_CATEGORIES) {
-    const entries = Array.isArray(commands[category]) ? commands[category] : [];
-    for (const entry of entries) {
-      if (typeof entry?.command !== "string") continue;
-      candidates.push({
-        command: entry.command,
-        category,
-        source: typeof entry.sourcePath === "string" ? entry.sourcePath : "projectContext.commands",
-        confidence: typeof entry.confidence === "string" ? entry.confidence : void 0
-      });
-    }
-  }
-  return candidates.sort((a, b) => {
-    const rank = (value) => value === "high" ? 0 : value === "medium" ? 1 : 2;
-    return rank(a.confidence) - rank(b.confidence);
+async function computeGitPatchId(cwd, fromRef, toRef) {
+  const { execFileSync: execFileSync4 } = await import("child_process");
+  const diff = execFileSync4("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
   });
+  if (!diff.trim()) return "";
+  const patchId = execFileSync4("git", ["patch-id", "--stable"], {
+    cwd,
+    input: diff,
+    encoding: "utf8",
+    maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+  }).trim();
+  return patchId.split(/\s+/)[0] || "";
 }
-function collectPolicyValidationCandidates(mesh) {
-  const policy = mesh?.policy && typeof mesh.policy === "object" && !Array.isArray(mesh.policy) ? mesh.policy : {};
-  const configured = Array.isArray(policy.validationCommands) ? policy.validationCommands : Array.isArray(policy.validationGate?.commands) ? policy.validationGate.commands : [];
-  return configured.map((entry) => typeof entry === "string" ? { command: entry, category: "", source: "mesh.policy.validationCommands" } : entry).filter((entry) => entry && typeof entry.command === "string").map((entry) => {
-    const commandText = entry.command.trim();
-    const category = REFINE_VALIDATION_CATEGORIES.find((cat) => commandText.includes(` ${cat}`)) ?? "";
-    return { command: commandText, category, source: "mesh.policy.validationCommands" };
-  }).filter((entry) => !!entry.category);
-}
-function selectMeshRefineValidationCommands(mesh, workspace) {
-  const scripts = readPackageScripts(workspace);
-  const rejectedCommands = [];
-  const selected = [];
-  const seen = /* @__PURE__ */ new Set();
-  const candidates = [
-    ...collectPolicyValidationCandidates(mesh),
-    ...collectProjectContextValidationCandidates(mesh)
-  ];
-  for (const candidate of candidates) {
-    const parsed = parsePackageManagerValidationCommand(candidate.command, candidate.category, scripts, candidate.source);
-    if (parsed.rejected) {
-      rejectedCommands.push(parsed.rejected);
-      continue;
-    }
-    if (!parsed.command || seen.has(parsed.command.displayCommand)) continue;
-    selected.push(parsed.command);
-    seen.add(parsed.command.displayCommand);
-    if (selected.length >= REFINE_VALIDATION_MAX_COMMANDS) break;
-  }
-  if (!selected.length && candidates.length === 0) {
-    for (const category of REFINE_VALIDATION_CATEGORIES) {
-      if (!Object.prototype.hasOwnProperty.call(scripts, category)) continue;
-      const fallback = parsePackageManagerValidationCommand(`npm run ${category}`, category, scripts, "package.json:scripts");
-      if (fallback.command && !seen.has(fallback.command.displayCommand)) {
-        selected.push(fallback.command);
-        seen.add(fallback.command.displayCommand);
-      } else if (fallback.rejected) {
-        rejectedCommands.push(fallback.rejected);
-      }
-      if (selected.length >= 2) break;
+async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead) {
+  const startedAt = Date.now();
+  try {
+    const { execFileSync: execFileSync4 } = await import("child_process");
+    const git = (args) => execFileSync4("git", args, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+    });
+    const mergeBase = git(["merge-base", baseHead, branchHead]).trim();
+    const mergeTreeStdout = git(["merge-tree", "--write-tree", baseHead, branchHead]);
+    const mergedTree = mergeTreeStdout.trim().split(/\s+/)[0] || "";
+    if (!mergeBase || !mergedTree) {
+      return {
+        status: "failed",
+        equivalent: false,
+        baseHead,
+        branchHead,
+        mergeBase: mergeBase || void 0,
+        mergedTree: mergedTree || void 0,
+        durationMs: Date.now() - startedAt,
+        error: "patch equivalence preflight could not resolve merge-base or synthetic merge tree",
+        stdout: truncateValidationOutput(mergeTreeStdout)
+      };
     }
+    const expectedPatchId = await computeGitPatchId(repoRoot, mergeBase, branchHead);
+    const actualPatchId = await computeGitPatchId(repoRoot, baseHead, mergedTree);
+    const equivalent = expectedPatchId === actualPatchId;
+    return {
+      status: equivalent ? "passed" : "failed",
+      equivalent,
+      baseHead,
+      branchHead,
+      mergeBase,
+      mergedTree,
+      expectedPatchId,
+      actualPatchId,
+      durationMs: Date.now() - startedAt
+    };
+  } catch (e) {
+    return {
+      status: "failed",
+      equivalent: false,
+      baseHead,
+      branchHead,
+      durationMs: Date.now() - startedAt,
+      error: e?.message || String(e),
+      stdout: truncateValidationOutput(e?.stdout),
+      stderr: truncateValidationOutput(e?.stderr)
+    };
   }
+}
+function buildMeshRefineValidationPlan(mesh, workspace) {
+  const plan = resolveMeshRefineValidationPlan(mesh, workspace);
   return {
-    commands: selected,
-    rejectedCommands,
-    source: selected.some((command) => command.source === "mesh.policy.validationCommands") ? "mesh_policy" : selected.some((command) => command.source !== "package.json:scripts") ? "project_context" : selected.length ? "package_json_scripts" : "unavailable"
+    source: plan.source,
+    sourceType: plan.sourceType,
+    commands: plan.commands.map((command) => ({
+      displayCommand: command.displayCommand,
+      category: command.category,
+      source: command.source,
+      cwd: command.cwd,
+      timeoutMs: command.timeoutMs
+    })),
+    unavailableReason: plan.unavailableReason,
+    rejectedCommands: plan.rejectedCommands,
+    suggestions: plan.suggestions,
+    suggestedConfig: plan.suggestedConfig,
+    note: plan.sourceType === "unavailable" ? "No validation command will be executed until a repo mesh/refine config is provided. Heuristics are suggestions only." : "Validation commands are resolved from repo mesh/refine config; heuristics are suggestions only."
   };
 }
 async function runMeshRefineValidationGate(mesh, workspace) {
   const { execFile: execFile3 } = await import("child_process");
   const { promisify: promisify3 } = await import("util");
   const execFileAsync3 = promisify3(execFile3);
-  const selection = selectMeshRefineValidationCommands(mesh, workspace);
+  const selection = resolveMeshRefineValidationPlan(mesh, workspace);
   const summary = {
     status: "skipped",
     required: true,
@@ -23891,21 +25045,27 @@ async function runMeshRefineValidationGate(mesh, workspace) {
     rejectedCommands: selection.rejectedCommands,
     skippedReason: void 0,
     timeoutMs: REFINE_VALIDATION_TIMEOUT_MS,
-    outputLimitBytes: REFINE_VALIDATION_OUTPUT_LIMIT_BYTES
+    outputLimitBytes: REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
+    configSource: selection.source,
+    configSourceType: selection.sourceType,
+    suggestions: selection.suggestions,
+    suggestedConfig: selection.suggestedConfig
   };
   if (!selection.commands.length) {
-    summary.skippedReason = "validation_unavailable: no allowlisted projectContext, mesh policy, or package.json build/test/typecheck/lint command was available";
+    summary.skippedReason = selection.unavailableReason || "validation_unavailable: repo mesh/refine config did not provide executable validation.commands";
     return summary;
   }
   for (const candidate of selection.commands) {
     const startedAt = Date.now();
+    const cwd = candidate.cwd ? pathResolve(workspace, candidate.cwd) : workspace;
+    const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
     try {
       const result = await execFileAsync3(candidate.command, candidate.args, {
-        cwd: workspace,
+        cwd,
         encoding: "utf8",
-        timeout: REFINE_VALIDATION_TIMEOUT_MS,
+        timeout,
         maxBuffer: REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
-        env: { ...process.env, CI: process.env.CI || "1" }
+        env: { ...process.env, CI: process.env.CI || "1", ...candidate.env || {} }
       });
       summary.commandsRun.push({
         command: candidate.command,
@@ -23913,6 +25073,7 @@ async function runMeshRefineValidationGate(mesh, workspace) {
         displayCommand: candidate.displayCommand,
         category: candidate.category,
         source: candidate.source,
+        cwd,
         passed: true,
         exitCode: 0,
         durationMs: Date.now() - startedAt,
@@ -23926,6 +25087,7 @@ async function runMeshRefineValidationGate(mesh, workspace) {
         displayCommand: candidate.displayCommand,
         category: candidate.category,
         source: candidate.source,
+        cwd,
         passed: false,
         exitCode: typeof error?.code === "number" ? error.code : null,
         signal: typeof error?.signal === "string" ? error.signal : null,
@@ -23942,7 +25104,7 @@ async function runMeshRefineValidationGate(mesh, workspace) {
   return summary;
 }
 function loadYamlModule() {
-  return yaml;
+  return yaml2;
 }
 function getMcpServersKey(format) {
   return format === "hermes_config_yaml" ? "mcp_servers" : "mcpServers";
@@ -24100,36 +25262,216 @@ function summarizeSessionHostPruneResult(result) {
     keptCount: Array.isArray(value.keptSessionIds) ? value.keptSessionIds.length : void 0
   };
 }
+function normalizeStandaloneHostCommandUrl(hostAddress) {
+  const raw = hostAddress.trim();
+  if (!raw) throw new Error("hostAddress required");
+  const url = new URL(raw.replace(/^ws:/, "http:").replace(/^wss:/, "https:"));
+  url.pathname = "/api/v1/command";
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+function buildMemberJoinNode(mesh, args, fallbackDaemonId) {
+  const requestedNodeId = typeof args?.memberNodeId === "string" ? args.memberNodeId.trim() : "";
+  const explicit = args?.memberNode && typeof args.memberNode === "object" && !Array.isArray(args.memberNode) ? args.memberNode : null;
+  const configured = Array.isArray(mesh?.nodes) ? requestedNodeId ? mesh.nodes.find((node) => node?.id === requestedNodeId || node?.nodeId === requestedNodeId) : mesh.nodes[0] : null;
+  const source = explicit || configured;
+  const workspace = typeof source?.workspace === "string" && source.workspace.trim() ? source.workspace.trim() : typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : process.cwd();
+  if (!workspace) return null;
+  const nodeId = typeof source?.id === "string" && source.id.trim() ? source.id.trim() : typeof source?.nodeId === "string" && source.nodeId.trim() ? source.nodeId.trim() : void 0;
+  return {
+    ...nodeId ? { id: nodeId } : {},
+    workspace,
+    ...typeof source?.repoRoot === "string" && source.repoRoot.trim() ? { repoRoot: source.repoRoot.trim() } : {},
+    ...typeof source?.daemonId === "string" && source.daemonId.trim() ? { daemonId: source.daemonId.trim() } : fallbackDaemonId ? { daemonId: fallbackDaemonId } : {},
+    ...typeof source?.machineId === "string" && source.machineId.trim() ? { machineId: source.machineId.trim() } : {},
+    userOverrides: source?.userOverrides && typeof source.userOverrides === "object" && !Array.isArray(source.userOverrides) ? source.userOverrides : {},
+    policy: source?.policy && typeof source.policy === "object" && !Array.isArray(source.policy) ? source.policy : {},
+    role: "member"
+  };
+}
 var DaemonCommandRouter = class {
   deps;
   /** In-memory cache for cloud-originating meshes passed via inlineMesh.
    *  Allows the MCP server to query mesh data via get_mesh even when
    *  the mesh doesn't exist in the local meshes.json file. */
   inlineMeshCache = /* @__PURE__ */ new Map();
+  /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
+  aggregateMeshStatusCache = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }
+  cloneJsonValue(value) {
+    if (typeof structuredClone === "function") return structuredClone(value);
+    return JSON.parse(JSON.stringify(value));
+  }
+  hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options) {
+    if (!mesh || typeof mesh !== "object" || !Array.isArray(mesh.nodes) || !Array.isArray(snapshot?.nodes)) return snapshot;
+    const inlineNodesById = /* @__PURE__ */ new Map();
+    for (const node of mesh.nodes) {
+      const nodeId = readInlineMeshNodeId(node);
+      if (nodeId) inlineNodesById.set(nodeId, node);
+    }
+    if (!inlineNodesById.size) return snapshot;
+    let changed = false;
+    const unavailableNodeIds = /* @__PURE__ */ new Set();
+    const sourceOfTruth = readObjectRecord(snapshot.sourceOfTruth);
+    const directPeerTruth = readObjectRecord(sourceOfTruth.directPeerTruth);
+    for (const entry of Array.isArray(directPeerTruth.unavailableNodeIds) ? directPeerTruth.unavailableNodeIds : []) {
+      const nodeId = readStringValue(entry);
+      if (nodeId) unavailableNodeIds.add(nodeId);
+    }
+    const nodes = snapshot.nodes.map((statusNode) => {
+      const nodeId = readStringValue(statusNode?.nodeId, statusNode?.id);
+      const inlineNode = nodeId ? inlineNodesById.get(nodeId) : void 0;
+      if (!inlineNode) return statusNode;
+      const liveGit = buildInlineMeshTransitGitStatus(inlineNode);
+      if (!liveGit) return statusNode;
+      const nextStatus = { ...statusNode };
+      nextStatus.git = liveGit;
+      nextStatus.health = deriveMeshNodeHealthFromGit(liveGit);
+      nextStatus.launchReady = readBooleanValue(nextStatus.launchReady) ?? true;
+      const connection = readObjectRecord(nextStatus.connection);
+      const connectionState = readStringValue(connection.state);
+      const connectionReported = readBooleanValue(connection.reported) ?? false;
+      if (!connectionReported || connectionState === "unknown") {
+        nextStatus.connection = buildLivePeerGitConnection(connection);
+      }
+      delete nextStatus.gitProbePending;
+      const error = readStringValue(nextStatus.error);
+      if (error && /pending_git|git probe|live peer git snapshot|no peer git snapshot/i.test(error)) delete nextStatus.error;
+      if (!readStringValue(nextStatus.machineStatus)) nextStatus.machineStatus = "online";
+      if (nodeId) unavailableNodeIds.delete(nodeId);
+      changed = true;
+      return nextStatus;
+    });
+    if (!changed && !(options?.requireDirectPeerTruth && unavailableNodeIds.size > 0)) return snapshot;
+    const nextSourceOfTruth = {
+      ...sourceOfTruth,
+      ...Object.keys(directPeerTruth).length ? {
+        directPeerTruth: {
+          ...directPeerTruth,
+          satisfied: options?.requireDirectPeerTruth === true ? unavailableNodeIds.size === 0 : directPeerTruth.satisfied,
+          unavailableNodeIds: [...unavailableNodeIds]
+        },
+        ...options?.requireDirectPeerTruth === true ? {
+          coordinatorOwnsLiveTruth: unavailableNodeIds.size === 0,
+          currentStatus: unavailableNodeIds.size === 0 ? "live_git_and_session_probes" : "direct_peer_truth_unavailable"
+        } : {}
+      } : {}
+    };
+    return {
+      ...snapshot,
+      ...options?.requireDirectPeerTruth === true && unavailableNodeIds.size > 0 ? {
+        success: false,
+        code: "mesh_direct_peer_truth_unavailable",
+        error: "Selected coordinator could not confirm direct mesh truth for every remote node yet."
+      } : {},
+      sourceOfTruth: nextSourceOfTruth,
+      nodes
+    };
+  }
+  getCachedAggregateMeshStatus(meshId, mesh, options) {
+    const cached = this.aggregateMeshStatusCache.get(meshId);
+    if (!cached?.snapshot || cached.snapshot.success !== true || !Array.isArray(cached.snapshot.nodes)) return null;
+    let snapshot = this.cloneJsonValue(cached.snapshot);
+    snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
+    if (shouldRefreshStalePendingAggregate(snapshot, options)) return null;
+    const ageMs = Math.max(0, Date.now() - cached.builtAt);
+    const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
+    snapshot.sourceOfTruth = {
+      ...sourceOfTruth,
+      aggregateSnapshot: {
+        ...sourceOfTruth.aggregateSnapshot && typeof sourceOfTruth.aggregateSnapshot === "object" ? sourceOfTruth.aggregateSnapshot : {},
+        owner: "coordinator_daemon_memory",
+        cached: true,
+        source: "memory",
+        refreshReason: "memory_cache_hit",
+        ageMs,
+        cachedAt: new Date(cached.builtAt).toISOString(),
+        returnedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+    return snapshot;
+  }
+  rememberAggregateMeshStatus(meshId, snapshot, refreshReason) {
+    if (!snapshot || typeof snapshot !== "object" || snapshot.success !== true || !Array.isArray(snapshot.nodes)) return snapshot;
+    const builtAt = Date.now();
+    const next = this.cloneJsonValue(snapshot);
+    const sourceOfTruth = next.sourceOfTruth && typeof next.sourceOfTruth === "object" ? next.sourceOfTruth : {};
+    next.sourceOfTruth = {
+      ...sourceOfTruth,
+      aggregateSnapshot: {
+        owner: "coordinator_daemon_memory",
+        cached: false,
+        source: "live_refresh",
+        refreshReason,
+        ageMs: 0,
+        cachedAt: new Date(builtAt).toISOString(),
+        returnedAt: new Date(builtAt).toISOString()
+      }
+    };
+    this.aggregateMeshStatusCache.set(meshId, { builtAt, snapshot: this.cloneJsonValue(next) });
+    return next;
+  }
   getCachedInlineMesh(meshId, inlineMesh) {
     if (inlineMesh && typeof inlineMesh === "object") {
-      this.inlineMeshCache.set(meshId, inlineMesh);
-      return inlineMesh;
+      return this.warmInlineMeshCache(meshId, inlineMesh);
     }
     return this.inlineMeshCache.get(meshId);
   }
+  warmInlineMeshCache(meshId, inlineMesh) {
+    if (!inlineMesh || typeof inlineMesh !== "object") return void 0;
+    const sanitizedInlineMesh = sanitizeInlineMesh(inlineMesh);
+    const cached = this.inlineMeshCache.get(meshId);
+    if (cached) {
+      const merged = reconcileInlineMeshCache(cached, sanitizedInlineMesh);
+      this.inlineMeshCache.set(meshId, merged);
+      return merged;
+    }
+    this.inlineMeshCache.set(meshId, sanitizedInlineMesh);
+    return sanitizedInlineMesh;
+  }
   async getMeshForCommand(meshId, inlineMesh, options) {
     const preferInline = options?.preferInline === true;
     if (preferInline) {
-      const cached2 = this.getCachedInlineMesh(meshId, inlineMesh);
-      if (cached2) return { mesh: cached2, inline: true };
+      const cached2 = this.getCachedInlineMesh(meshId);
+      if (cached2) {
+        if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
+          const merged = reconcileInlineMeshCache(cached2, inlineMesh);
+          this.inlineMeshCache.set(meshId, sanitizeInlineMesh(merged));
+          return { mesh: merged, inline: true, source: "inline_cache" };
+        }
+        return { mesh: cached2, inline: true, source: "inline_cache" };
+      }
+      if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
+        this.warmInlineMeshCache(meshId, inlineMesh);
+        return { mesh: inlineMesh, inline: true, source: "inline_bootstrap" };
+      }
     }
     try {
       const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
       const mesh = getMesh3(meshId);
-      if (mesh) return { mesh, inline: false };
+      if (mesh) return { mesh, inline: false, source: "local_config" };
     } catch {
     }
-    const cached = this.getCachedInlineMesh(meshId, inlineMesh);
-    return cached ? { mesh: cached, inline: true } : null;
+    const cached = this.getCachedInlineMesh(meshId);
+    if (cached) return { mesh: cached, inline: true, source: "inline_cache" };
+    const warmedInline = this.warmInlineMeshCache(meshId, inlineMesh);
+    return warmedInline ? { mesh: warmedInline, inline: true, source: "inline_bootstrap" } : null;
+  }
+  invalidateAggregateMeshStatus(meshId) {
+    this.aggregateMeshStatusCache.delete(meshId);
+  }
+  async requireMeshHostMutationOwner(meshId, inlineMesh, operation) {
+    const meshRecord = await this.getMeshForCommand(meshId, inlineMesh, { preferInline: true });
+    const mesh = meshRecord?.mesh;
+    if (!mesh) return { success: false, error: "Mesh not found" };
+    const meshHost = resolveMeshHostStatus(mesh);
+    if (!meshHost.canOwnCoordinator || !meshHost.canOwnQueue) {
+      return { ...buildMeshHostRequiredFailure(mesh, operation), success: false, meshId };
+    }
+    return null;
   }
   updateInlineMeshNode(meshId, mesh, node) {
     if (!mesh || !Array.isArray(mesh.nodes) || !node?.id) return;
@@ -24138,6 +25480,7 @@ var DaemonCommandRouter = class {
     else mesh.nodes.push(node);
     mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.inlineMeshCache.set(meshId, mesh);
+    this.invalidateAggregateMeshStatus(meshId);
   }
   removeInlineMeshNode(meshId, mesh, nodeId) {
     if (!mesh || !Array.isArray(mesh.nodes)) return false;
@@ -24146,6 +25489,7 @@ var DaemonCommandRouter = class {
     mesh.nodes.splice(idx, 1);
     mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.inlineMeshCache.set(meshId, mesh);
+    this.invalidateAggregateMeshStatus(meshId);
     return true;
   }
   normalizeMeshSessionCleanupMode(value) {
@@ -24358,6 +25702,7 @@ var DaemonCommandRouter = class {
     const deletedSessionIds = [];
     const skippedSessionIds = [];
     const skippedLiveSessionIds = [];
+    const skippedCoordinatorSessionIds = [];
     const deleteUnsupportedSessionIds = [];
     const recordsRemainSessionIds = [];
     const errors = [];
@@ -24390,6 +25735,12 @@ var DaemonCommandRouter = class {
       const completed = this.isCompletedHostedSession(record);
       const surfaceKind = getSessionHostSurfaceKind(record);
       const liveRuntime = surfaceKind === "live_runtime";
+      const coordinatorSession = readStringValue(record?.meta?.meshCoordinatorFor) === args.meshId;
+      if (!hasExplicitSessionIds && coordinatorSession) {
+        skippedSessionIds.push(sessionId);
+        skippedCoordinatorSessionIds.push(sessionId);
+        continue;
+      }
       if (!hasExplicitSessionIds && liveRuntime) {
         skippedSessionIds.push(sessionId);
         skippedLiveSessionIds.push(sessionId);
@@ -24455,6 +25806,7 @@ var DaemonCommandRouter = class {
       deletedSessionIds,
       skippedSessionIds,
       skippedLiveSessionIds,
+      skippedCoordinatorSessionIds,
       ...deleteUnsupported ? {
         deleteUnsupported: true,
         effectiveCleanup: args.mode === "stop_and_delete" ? "stopped_only_records_remain" : "delete_unsupported_records_remain",
@@ -24587,7 +25939,8 @@ var DaemonCommandRouter = class {
         return handleMeshForwardEvent({ instanceManager: this.deps.instanceManager }, args);
       }
       case "get_pending_mesh_events": {
-        const events = drainPendingMeshCoordinatorEvents();
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const events = drainPendingMeshCoordinatorEvents(meshId || void 0);
         return { success: true, events };
       }
       case "launch_cli":
@@ -25116,15 +26469,39 @@ var DaemonCommandRouter = class {
       case "get_mesh": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
-        try {
-          const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          const mesh = getMesh3(meshId);
-          if (mesh) return { success: true, mesh };
-        } catch {
+        const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+        if (!meshRecord?.mesh) return { success: false, error: "Mesh not found" };
+        const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+        const directTruth = await hydrateInlineMeshDirectTruth({
+          mesh: meshRecord.mesh,
+          meshSource: meshRecord.source,
+          dispatchMeshCommand: this.deps.dispatchMeshCommand,
+          statusInstanceId: this.deps.statusInstanceId,
+          localMachineId: loadConfig().machineId || ""
+        });
+        const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
+        const sourceOfTruth = {
+          membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+          coordinatorOwnsLiveTruth: directTruthSatisfied,
+          directPeerTruth: {
+            required: requireDirectPeerTruth,
+            satisfied: directTruthSatisfied,
+            directEvidenceCount: directTruth.directEvidenceCount,
+            localConfirmedCount: directTruth.localConfirmedCount,
+            peerAttemptedCount: directTruth.peerAttemptedCount,
+            peerConfirmedCount: directTruth.peerConfirmedCount,
+            unavailableNodeIds: directTruth.unavailableNodeIds
+          }
+        };
+        if (requireDirectPeerTruth && !directTruthSatisfied) {
+          return {
+            success: false,
+            code: "mesh_direct_peer_truth_unavailable",
+            error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct get_mesh probes succeed.",
+            sourceOfTruth
+          };
         }
-        const cached = this.inlineMeshCache.get(meshId);
-        if (cached) return { success: true, mesh: cached };
-        return { success: false, error: "Mesh not found" };
+        return { success: true, mesh: meshRecord.mesh, sourceOfTruth };
       }
       case "create_mesh": {
         const name = typeof args?.name === "string" ? args.name.trim() : "";
@@ -25134,7 +26511,8 @@ var DaemonCommandRouter = class {
         if (!name) return { success: false, error: "name required" };
         try {
           const { createMesh: createMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy });
+          const meshHost = args?.meshHost && typeof args.meshHost === "object" && !Array.isArray(args.meshHost) ? args.meshHost : void 0;
+          const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy, meshHost });
           return { success: true, mesh };
         } catch (e) {
           return { success: false, error: e.message };
@@ -25150,15 +26528,226 @@ var DaemonCommandRouter = class {
           if (typeof args?.defaultBranch === "string") patch.defaultBranch = args.defaultBranch;
           if (args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy)) patch.policy = args.policy;
           if (args?.coordinator && typeof args.coordinator === "object" && !Array.isArray(args.coordinator)) patch.coordinator = args.coordinator;
+          if (args?.meshHost && typeof args.meshHost === "object" && !Array.isArray(args.meshHost)) patch.meshHost = args.meshHost;
           if (!Object.keys(patch).length) return { success: false, error: "No updates provided" };
           const mesh = updateMesh2(meshId, patch);
           if (!mesh) return { success: false, error: "Mesh not found" };
           this.inlineMeshCache.set(meshId, mesh);
+          this.invalidateAggregateMeshStatus(meshId);
           return { success: true, mesh };
         } catch (e) {
           return { success: false, error: e.message };
         }
       }
+      case "get_mesh_host_pairing": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+        const mesh = meshRecord?.mesh;
+        if (!mesh) return { success: false, error: "Mesh not found" };
+        const meshHost = resolveMeshHostStatus(mesh);
+        const pairingStatus = meshHost.pairing?.status || "not_configured";
+        return {
+          success: true,
+          code: pairingStatus === "not_configured" ? "mesh_host_pairing_not_configured" : "mesh_host_pairing_pending",
+          meshId,
+          hostAddress: meshHost.hostAddress,
+          meshHost,
+          manualPairing: {
+            status: pairingStatus,
+            joinImplemented: true,
+            protocol: "standalone_command_direct_v1",
+            description: "Standalone manual pairing can save address/token metadata, apply a host join over direct standalone command HTTP or injected mesh command dispatch, and check persisted status. P2P signaling remains outside this slice."
+          }
+        };
+      }
+      case "configure_mesh_host_pairing": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const hostAddress = typeof args?.hostAddress === "string" ? args.hostAddress.trim() : "";
+        const token = typeof args?.token === "string" ? args.token.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        if (!hostAddress || !token) return { success: false, error: "hostAddress and token required" };
+        try {
+          const { configureMeshHostPairing: configureMeshHostPairing2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const configured = configureMeshHostPairing2(meshId, { hostAddress, token });
+          if (!configured) return { success: false, error: "Mesh not found" };
+          this.inlineMeshCache.set(meshId, configured.mesh);
+          const meshHost = resolveMeshHostStatus(configured.mesh);
+          return {
+            success: true,
+            code: "mesh_host_pairing_pending",
+            meshId,
+            hostAddress: configured.hostAddress,
+            meshHost,
+            manualPairing: {
+              status: meshHost.pairing?.status || "pairing",
+              joinImplemented: true,
+              protocol: "standalone_command_direct_v1",
+              description: "Manual Mesh Host pairing config was saved locally. Use join_mesh_host_pairing to apply it to the host. Raw token was not persisted."
+            }
+          };
+        } catch (e) {
+          return { success: false, code: "mesh_host_pairing_invalid", meshId, hostAddress, error: e.message };
+        }
+      }
+      case "create_mesh_host_pairing_token": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { createMeshHostPairingToken: createMeshHostPairingToken2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const created = createMeshHostPairingToken2(meshId, {
+            token: typeof args?.token === "string" ? args.token : void 0,
+            expiresAt: typeof args?.expiresAt === "string" ? args.expiresAt : void 0
+          });
+          if (!created) return { success: false, error: "Mesh not found" };
+          this.inlineMeshCache.set(meshId, created.mesh);
+          this.invalidateAggregateMeshStatus(meshId);
+          return {
+            success: true,
+            code: "mesh_host_pairing_token_created",
+            meshId,
+            token: created.token,
+            tokenId: created.tokenId,
+            expiresAt: created.expiresAt,
+            meshHost: resolveMeshHostStatus(created.mesh),
+            warning: "Raw token is returned once and is not persisted; share it with member daemons over a trusted channel."
+          };
+        } catch (e) {
+          return { success: false, code: "mesh_host_pairing_token_invalid", meshId, error: e.message };
+        }
+      }
+      case "apply_mesh_host_join": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const token = typeof args?.token === "string" ? args.token.trim() : "";
+        const memberNode = args?.memberNode && typeof args.memberNode === "object" && !Array.isArray(args.memberNode) ? args.memberNode : null;
+        if (!meshId) return { success: false, error: "meshId required" };
+        if (!token || !memberNode) return { success: false, error: "token and memberNode required" };
+        try {
+          const { applyMeshHostJoinRequest: applyMeshHostJoinRequest2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const applied = applyMeshHostJoinRequest2(meshId, {
+            token,
+            memberNode,
+            memberMeshId: typeof args?.memberMeshId === "string" ? args.memberMeshId : void 0
+          });
+          if (!applied) return { success: false, error: "Mesh not found" };
+          if (!applied.accepted) {
+            return {
+              success: false,
+              code: "mesh_host_join_rejected",
+              meshId,
+              tokenId: applied.tokenId,
+              meshHost: applied.meshHost ? resolveMeshHostStatus({ meshHost: applied.meshHost }) : void 0,
+              error: applied.reason
+            };
+          }
+          this.inlineMeshCache.set(meshId, applied.mesh);
+          this.invalidateAggregateMeshStatus(meshId);
+          try {
+            const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+            appendLedgerEntry2(meshId, {
+              kind: "node_joined",
+              nodeId: applied.node.id,
+              payload: { role: "member", tokenId: applied.tokenId, workspace: applied.node.workspace }
+            });
+          } catch {
+          }
+          return {
+            success: true,
+            code: "mesh_host_join_accepted",
+            meshId,
+            node: applied.node,
+            tokenId: applied.tokenId,
+            meshHost: resolveMeshHostStatus(applied.mesh)
+          };
+        } catch (e) {
+          return { success: false, code: "mesh_host_join_failed", meshId, error: e.message };
+        }
+      }
+      case "join_mesh_host_pairing": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const token = typeof args?.token === "string" ? args.token.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        if (!token) return { success: false, error: "token required because raw pairing tokens are not persisted" };
+        const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+        const mesh = meshRecord?.mesh;
+        if (!mesh) return { success: false, error: "Mesh not found" };
+        const meshHost = resolveMeshHostStatus(mesh);
+        if (meshHost.role !== "member") {
+          return { success: false, code: "mesh_host_join_not_member", meshId, meshHost, error: "join_mesh_host_pairing must run from a member daemon configured with a Mesh Host address/token." };
+        }
+        try {
+          const { tokenIdForManualPairing: tokenIdForManualPairing2, markMeshHostPairingJoined: markMeshHostPairingJoined2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const tokenId = tokenIdForManualPairing2(token);
+          if (meshHost.pairing?.tokenId && meshHost.pairing.tokenId !== tokenId) {
+            return { success: false, code: "mesh_host_join_rejected", meshId, tokenId, meshHost, error: "invalid pairing token" };
+          }
+          const memberNode = buildMemberJoinNode(mesh, args, this.deps.statusInstanceId);
+          if (!memberNode) return { success: false, error: "member node metadata unavailable" };
+          const hostMeshId = typeof args?.hostMeshId === "string" && args.hostMeshId.trim() ? args.hostMeshId.trim() : meshId;
+          const hostDaemonId = typeof args?.hostDaemonId === "string" && args.hostDaemonId.trim() ? args.hostDaemonId.trim() : meshHost.hostDaemonId;
+          let hostResult;
+          let transport;
+          if (hostDaemonId && this.deps.dispatchMeshCommand) {
+            transport = "mesh_command_dispatch";
+            hostResult = await this.deps.dispatchMeshCommand(hostDaemonId, "apply_mesh_host_join", {
+              meshId: hostMeshId,
+              token,
+              memberMeshId: meshId,
+              memberNode
+            });
+          } else if (meshHost.hostAddress) {
+            transport = "standalone_http_command";
+            const commandUrl = normalizeStandaloneHostCommandUrl(meshHost.hostAddress);
+            const response = await fetch(commandUrl, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ type: "apply_mesh_host_join", payload: { meshId: hostMeshId, token, memberMeshId: meshId, memberNode } })
+            });
+            hostResult = await response.json().catch(() => ({ success: false, error: `Host returned HTTP ${response.status}` }));
+            if (!response.ok && hostResult?.success !== false) hostResult = { success: false, error: `Host returned HTTP ${response.status}` };
+          } else {
+            return {
+              success: false,
+              code: "mesh_host_join_transport_unavailable",
+              meshId,
+              meshHost,
+              error: "No hostDaemonId dispatch path or hostAddress HTTP command path is available. P2P signaling join is not implemented in this slice."
+            };
+          }
+          if (!hostResult?.success) {
+            return { success: false, code: hostResult?.code || "mesh_host_join_rejected", meshId, meshHost, transport, error: hostResult?.error || "Mesh Host rejected join request", hostResult };
+          }
+          const joined = meshRecord.inline ? null : markMeshHostPairingJoined2(meshId, {
+            tokenId: hostResult.tokenId || tokenId,
+            hostDaemonId: hostResult.meshHost?.hostDaemonId || hostDaemonId,
+            hostNodeId: hostResult.meshHost?.hostNodeId,
+            joinedAt: hostResult.meshHost?.pairing?.joinedAt
+          });
+          if (joined) {
+            this.inlineMeshCache.set(meshId, joined.mesh);
+            this.invalidateAggregateMeshStatus(meshId);
+          }
+          return {
+            success: true,
+            code: "mesh_host_join_applied",
+            meshId,
+            hostMeshId,
+            transport,
+            node: hostResult.node,
+            tokenId: hostResult.tokenId || tokenId,
+            meshHost: joined ? resolveMeshHostStatus(joined.mesh) : { ...meshHost, pairing: { ...meshHost.pairing || {}, status: "paired", tokenId: hostResult.tokenId || tokenId } },
+            hostResult,
+            manualPairing: {
+              status: "paired",
+              joinImplemented: true,
+              protocol: "standalone_command_direct_v1",
+              description: "Mesh Host accepted the join and local member pairing status was marked paired. P2P runtime signaling remains outside this slice."
+            }
+          };
+        } catch (e) {
+          return { success: false, code: "mesh_host_join_failed", meshId, meshHost, error: e.message };
+        }
+      }
       case "delete_mesh": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
@@ -25241,6 +26830,8 @@ var DaemonCommandRouter = class {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const taskId = typeof args?.taskId === "string" ? args.taskId.trim() : "";
         if (!meshId || !taskId) return { success: false, error: "meshId and taskId required" };
+        const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "queue cancellation");
+        if (ownerFailure) return ownerFailure;
         try {
           const { cancelTask: cancelTask2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
           const reason = typeof args?.reason === "string" ? args.reason : void 0;
@@ -25255,6 +26846,8 @@ var DaemonCommandRouter = class {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const taskId = typeof args?.taskId === "string" ? args.taskId.trim() : "";
         if (!meshId || !taskId) return { success: false, error: "meshId and taskId required" };
+        const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "queue requeue");
+        if (ownerFailure) return ownerFailure;
         try {
           const { requeueTask: requeueTask2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
           const task = requeueTask2(meshId, taskId, {
@@ -25275,6 +26868,8 @@ var DaemonCommandRouter = class {
         const workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
         if (!workspace) return { success: false, error: "workspace required" };
+        const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node addition");
+        if (ownerFailure) return ownerFailure;
         try {
           const { addNode: addNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           const providerPriority = Array.isArray(args?.providerPriority) ? args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean) : [];
@@ -25283,7 +26878,8 @@ var DaemonCommandRouter = class {
             ...readOnly ? { readOnly: true } : {},
             ...providerPriority.length ? { providerPriority } : {}
           };
-          const node = addNode3(meshId, { workspace, ...policy ? { policy } : {} });
+          const role = normalizeMeshDaemonRole(args?.role);
+          const node = addNode3(meshId, { workspace, ...policy ? { policy } : {}, ...role ? { role } : {} });
           if (!node) return { success: false, error: "Mesh not found" };
           return { success: true, node };
         } catch (e) {
@@ -25294,6 +26890,8 @@ var DaemonCommandRouter = class {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
         if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node update");
+        if (ownerFailure) return ownerFailure;
         try {
           const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           const policy = args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy) ? { ...args.policy } : {};
@@ -25317,6 +26915,8 @@ var DaemonCommandRouter = class {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
         if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node removal");
+        if (ownerFailure) return ownerFailure;
         try {
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
           const mesh = meshRecord?.mesh;
@@ -25339,30 +26939,88 @@ var DaemonCommandRouter = class {
           return { success: false, error: e.message };
         }
       }
+      case "get_mesh_refine_config_schema": {
+        return {
+          success: true,
+          schema: MESH_REFINE_CONFIG_SCHEMA,
+          locations: MESH_REFINE_CONFIG_LOCATIONS,
+          sourceOfTruth: "repo mesh/refine config",
+          heuristicRole: "suggestions_only_not_execution_path"
+        };
+      }
+      case "validate_mesh_refine_config": {
+        const workspace = typeof args?.workspace === "string" ? args.workspace : process.cwd();
+        const mesh = args?.inlineMesh || {};
+        const loaded = args?.config !== void 0 ? { config: args.config, source: "inline", sourceType: "mesh_policy" } : loadMeshRefineConfig(mesh, workspace);
+        const validation = loaded.config ? validateMeshRefineConfig(loaded.config, loaded.source) : { valid: false, errors: [loaded.error || "repo mesh/refine config unavailable"], commands: [], rejectedCommands: [] };
+        return { success: validation.valid, ...loaded, ...validation };
+      }
+      case "suggest_mesh_refine_config": {
+        const workspace = typeof args?.workspace === "string" ? args.workspace : process.cwd();
+        const mesh = args?.inlineMesh || {};
+        return {
+          success: true,
+          ...suggestMeshRefineConfig(mesh, workspace),
+          note: "Suggestions are heuristic scaffold only; Refinery will not execute them until saved into repo mesh/refine config."
+        };
+      }
+      case "plan_mesh_refine_node": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+        const mesh = meshRecord?.mesh;
+        const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+        if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
+        return {
+          success: true,
+          dryRun: true,
+          nodeId,
+          workspace: node.workspace,
+          validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
+          mergeWillRun: false,
+          cleanupWillRun: false
+        };
+      }
       case "refine_mesh_node": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
         if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        const refineStages = [];
         try {
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
           const mesh = meshRecord?.mesh;
           const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
-          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
+          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh`, refineStages };
           if (!node.isLocalWorktree || !node.workspace) {
-            return { success: false, error: `Refinery requires a local worktree node` };
+            return { success: false, error: `Refinery requires a local worktree node`, refineStages };
           }
           const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId) : mesh?.nodes.find((n) => !n.isLocalWorktree);
           const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
-          if (!repoRoot) return { success: false, error: "Source node repoRoot not found" };
+          if (!repoRoot) return { success: false, error: "Source node repoRoot not found", refineStages };
           const { execFile: execFile3 } = await import("child_process");
           const { promisify: promisify3 } = await import("util");
           const execFileAsync3 = promisify3(execFile3);
+          const resolveStarted = Date.now();
           const { stdout: branchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
           const branch = branchStdout.trim();
-          if (!branch) return { success: false, error: "Could not determine branch of the worktree node" };
+          if (!branch) return { success: false, error: "Could not determine branch of the worktree node", refineStages };
           const { stdout: baseBranchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
           const baseBranch = baseBranchStdout.trim();
+          const { stdout: baseHeadStdout } = await execFileAsync3("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+          const { stdout: branchHeadStdout } = await execFileAsync3("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8" });
+          const baseHead = baseHeadStdout.trim();
+          const branchHead = branchHeadStdout.trim();
+          recordMeshRefineStage(refineStages, "resolve_refs", "passed", resolveStarted, { branch, baseBranch, baseHead, branchHead });
+          const validationStarted = Date.now();
           const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace);
+          recordMeshRefineStage(
+            refineStages,
+            "validation",
+            validationSummary.status === "passed" ? "passed" : validationSummary.status === "failed" ? "failed" : "skipped",
+            validationStarted,
+            { validationStatus: validationSummary.status, commandsRun: validationSummary.commandsRun.length }
+          );
           if (validationSummary.status === "failed") {
             return {
               success: false,
@@ -25372,6 +27030,7 @@ var DaemonCommandRouter = class {
               branch,
               into: baseBranch,
               validationSummary,
+              refineStages,
               finalBranchConvergenceState: {
                 branch,
                 baseBranch,
@@ -25391,6 +27050,7 @@ var DaemonCommandRouter = class {
               branch,
               into: baseBranch,
               validationSummary,
+              refineStages,
               finalBranchConvergenceState: {
                 branch,
                 baseBranch,
@@ -25401,37 +27061,121 @@ var DaemonCommandRouter = class {
               }
             };
           }
+          const patchEquivalenceStarted = Date.now();
+          const patchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
+          recordMeshRefineStage(refineStages, "patch_equivalence", patchEquivalence.status, patchEquivalenceStarted, {
+            equivalent: patchEquivalence.equivalent,
+            expectedPatchId: patchEquivalence.expectedPatchId,
+            actualPatchId: patchEquivalence.actualPatchId,
+            error: patchEquivalence.error
+          });
+          if (!patchEquivalence.equivalent) {
+            return {
+              success: false,
+              code: "patch_equivalence_failed",
+              convergenceStatus: "blocked_review",
+              error: "Refinery patch-equivalence preflight failed; merge/refine was not attempted.",
+              branch,
+              into: baseBranch,
+              validationSummary,
+              patchEquivalence,
+              refineStages,
+              finalBranchConvergenceState: {
+                branch,
+                baseBranch,
+                merged: false,
+                removed: false,
+                validation: "passed",
+                patchEquivalence: "failed",
+                status: "blocked_review"
+              }
+            };
+          }
+          let mergeResult;
+          const mergeStarted = Date.now();
           try {
-            await execFileAsync3("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
+            const result = await execFileAsync3("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
+            mergeResult = {
+              stdout: truncateValidationOutput(result.stdout),
+              stderr: truncateValidationOutput(result.stderr),
+              durationMs: Date.now() - mergeStarted
+            };
+            recordMeshRefineStage(refineStages, "merge", "passed", mergeStarted, mergeResult);
           } catch (e) {
+            recordMeshRefineStage(refineStages, "merge", "failed", mergeStarted, {
+              error: e?.message || String(e),
+              stdout: truncateValidationOutput(e?.stdout),
+              stderr: truncateValidationOutput(e?.stderr)
+            });
             return {
               success: false,
               error: `Merge failed (conflicts?): ${e.message}`,
               validationSummary,
+              patchEquivalence,
+              refineStages,
               finalBranchConvergenceState: {
                 branch,
                 baseBranch,
                 merged: false,
                 removed: false,
                 validation: "passed",
+                patchEquivalence: "passed",
                 status: "not_mergeable"
               }
             };
           }
+          const cleanupStarted = Date.now();
           const removeResult = await this.execute("remove_mesh_node", {
             meshId,
             nodeId,
-            sessionCleanupMode: "kill",
+            sessionCleanupMode: "preserve",
             inlineMesh: args?.inlineMesh
           });
+          recordMeshRefineStage(refineStages, "cleanup", removeResult?.success === false ? "failed" : "passed", cleanupStarted, {
+            removed: removeResult?.removed,
+            code: removeResult?.code,
+            error: removeResult?.error
+          });
+          let ledgerError;
+          const ledgerStarted = Date.now();
           try {
             const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
             appendLedgerEntry2(meshId, {
               kind: "node_removed",
               nodeId,
-              payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary }
+              payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence }
             });
-          } catch {
+            recordMeshRefineStage(refineStages, "ledger", "passed", ledgerStarted);
+          } catch (e) {
+            ledgerError = e?.message || String(e);
+            recordMeshRefineStage(refineStages, "ledger", "failed", ledgerStarted, { error: ledgerError });
+          }
+          const finalBranchConvergenceState = {
+            branch: baseBranch,
+            mergedBranch: branch,
+            baseBranch,
+            merged: true,
+            removed: removeResult?.success !== false,
+            validation: "passed",
+            patchEquivalence: "passed",
+            status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
+          };
+          if (removeResult?.success === false) {
+            return {
+              success: false,
+              code: "cleanup_failed",
+              error: "Refinery merge completed but worktree cleanup failed; manual cleanup/retry is required.",
+              merged: true,
+              branch,
+              into: baseBranch,
+              removeResult,
+              validationSummary,
+              patchEquivalence,
+              mergeResult,
+              refineStages,
+              ...ledgerError ? { ledgerError } : {},
+              finalBranchConvergenceState
+            };
           }
           return {
             success: true,
@@ -25440,18 +27184,14 @@ var DaemonCommandRouter = class {
             into: baseBranch,
             removeResult,
             validationSummary,
-            finalBranchConvergenceState: {
-              branch: baseBranch,
-              mergedBranch: branch,
-              baseBranch,
-              merged: true,
-              removed: removeResult?.success !== false,
-              validation: "passed",
-              status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
-            }
+            patchEquivalence,
+            mergeResult,
+            refineStages,
+            ...ledgerError ? { ledgerError } : {},
+            finalBranchConvergenceState
           };
         } catch (e) {
-          return { success: false, error: e.message };
+          return { success: false, error: e.message, refineStages };
         }
       }
       case "remove_mesh_node": {
@@ -25492,6 +27232,7 @@ var DaemonCommandRouter = class {
           } else {
             const { removeNode: removeNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
             removed = removeNode3(meshId, nodeId);
+            if (removed) this.invalidateAggregateMeshStatus(meshId);
           }
           if (removed) {
             try {
@@ -25526,6 +27267,8 @@ var DaemonCommandRouter = class {
         if (!meshId) return { success: false, error: "meshId required" };
         if (!sourceNodeId) return { success: false, error: "sourceNodeId required" };
         if (!branch) return { success: false, error: "branch required" };
+        const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "worktree clone");
+        if (ownerFailure) return ownerFailure;
         try {
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
           const mesh = meshRecord?.mesh;
@@ -25570,6 +27313,7 @@ var DaemonCommandRouter = class {
               policy: { ...sourceNode.policy || {} }
             });
             if (!node) return { success: false, error: "Failed to register worktree node" };
+            this.invalidateAggregateMeshStatus(meshId);
           }
           const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
           if (initSubmodules) {
@@ -25606,6 +27350,8 @@ var DaemonCommandRouter = class {
       case "trigger_mesh_queue": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
+        const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "queue trigger");
+        if (ownerFailure) return ownerFailure;
         try {
           const { triggerMeshQueue: triggerMeshQueue2 } = await Promise.resolve().then(() => (init_mesh_events(), mesh_events_exports));
           if (meshId) {
@@ -25632,6 +27378,15 @@ var DaemonCommandRouter = class {
             mesh = getMesh3(meshId);
           }
           if (!mesh) return { success: false, error: "Mesh not found" };
+          const meshHost = resolveMeshHostStatus(mesh);
+          if (!meshHost.canOwnCoordinator) {
+            return {
+              success: false,
+              ...buildMeshHostRequiredFailure(mesh, "coordinator launch"),
+              meshId,
+              cliType
+            };
+          }
           if (!Array.isArray(mesh.nodes) || mesh.nodes.length === 0) return { success: false, error: "No nodes in mesh" };
           const requestedCoordinatorNodeId = typeof args?.coordinatorNodeId === "string" ? args.coordinatorNodeId.trim() : "";
           const preferredCoordinatorNodeId = requestedCoordinatorNodeId || (typeof mesh.coordinator?.preferredNodeId === "string" ? mesh.coordinator.preferredNodeId.trim() : "");
@@ -25645,7 +27400,14 @@ var DaemonCommandRouter = class {
               cliType
             };
           }
-          const workspace = typeof coordinatorNode.workspace === "string" ? coordinatorNode.workspace.trim() : "";
+          const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
+          const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
+          const workspace = readLiveMeshNodeWorkspace({
+            meshId,
+            nodeId: String(coordinatorNode.id || coordinatorNode.nodeId || preferredCoordinatorNodeId || ""),
+            liveSessionRecords: liveMeshSessions,
+            allowCoordinatorSession: true
+          }) || (typeof coordinatorNode.workspace === "string" ? coordinatorNode.workspace.trim() : "");
           if (!workspace) return { success: false, error: "Coordinator node workspace required", meshId, cliType };
           if (!cliType) {
             const resolved = await resolveProviderTypeFromPriority({
@@ -25807,7 +27569,7 @@ ${block}`);
               workspace
             };
           }
-          const { existsSync: existsSync25, readFileSync: readFileSync17, writeFileSync: writeFileSync15, copyFileSync: copyFileSync4, mkdirSync: mkdirSync17 } = await import("fs");
+          const { existsSync: existsSync27, readFileSync: readFileSync19, writeFileSync: writeFileSync15, copyFileSync: copyFileSync4, mkdirSync: mkdirSync17 } = await import("fs");
           const { dirname: dirname9 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -25850,14 +27612,14 @@ ${block}`);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync25(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync27(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
             copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname9(mcpConfigPath));
           }
           if (hadExistingMcpConfig) {
             try {
-              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync17(mcpConfigPath, "utf-8"), configFormat);
+              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync19(mcpConfigPath, "utf-8"), configFormat);
               const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
               existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
               copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
@@ -25947,62 +27709,321 @@ ${block}`);
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
+          const meshHost = resolveMeshHostStatus(mesh);
+          const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
+          const hadAggregateCache = this.aggregateMeshStatusCache.has(meshId);
+          if (!refreshRequested) {
+            const cachedStatus = this.getCachedAggregateMeshStatus(meshId, mesh, { requireDirectPeerTruth: args?.requireDirectPeerTruth === true });
+            if (cachedStatus) {
+              logRepoMeshStatusDebug("return_cached", {
+                meshId,
+                command: "mesh_status",
+                refreshRequested,
+                summary: summarizeRepoMeshStatusDebug(cachedStatus)
+              });
+              return cachedStatus;
+            }
+          }
+          const refreshReason = refreshRequested ? "explicit_refresh" : hadAggregateCache ? "stale_pending_cache_refresh" : "cold_cache_miss";
           const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
           const queue = getQueue2(meshId);
           const queueSummary = getMeshQueueStats2(meshId);
           const { readLedgerEntries: readLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const ledgerEntries = readLedgerEntries2(meshId, { tail: 20 });
           const ledgerSummary = getLedgerSummary2(meshId);
+          const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
+          const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
+          const localMachineId = loadConfig().machineId || "";
+          const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+          const directTruth = requireDirectPeerTruth ? await hydrateInlineMeshDirectTruth({
+            mesh,
+            meshSource: meshRecord.source,
+            dispatchMeshCommand: this.deps.dispatchMeshCommand,
+            statusInstanceId: this.deps.statusInstanceId,
+            localMachineId
+          }) : {
+            directEvidenceCount: 0,
+            localConfirmedCount: 0,
+            peerAttemptedCount: 0,
+            peerConfirmedCount: 0,
+            unavailableNodeIds: []
+          };
+          const passivePeerTruthNotAttempted = requireDirectPeerTruth && !refreshRequested && directTruth.directEvidenceCount > 0 && directTruth.peerAttemptedCount === 0;
+          const effectiveDirectTruth = passivePeerTruthNotAttempted ? { ...directTruth, unavailableNodeIds: [] } : directTruth;
+          const directTruthSatisfied = !requireDirectPeerTruth || effectiveDirectTruth.directEvidenceCount > 0 && effectiveDirectTruth.unavailableNodeIds.length === 0;
+          if (requireDirectPeerTruth && !directTruthSatisfied) {
+            const failureResult = {
+              success: false,
+              code: "mesh_direct_peer_truth_unavailable",
+              error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct mesh_status probes succeed.",
+              sourceOfTruth: {
+                membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+                coordinatorOwnsLiveTruth: false,
+                currentStatus: "direct_peer_truth_unavailable",
+                directPeerTruth: {
+                  required: true,
+                  satisfied: false,
+                  directEvidenceCount: directTruth.directEvidenceCount,
+                  localConfirmedCount: directTruth.localConfirmedCount,
+                  peerAttemptedCount: directTruth.peerAttemptedCount,
+                  peerConfirmedCount: directTruth.peerConfirmedCount,
+                  unavailableNodeIds: directTruth.unavailableNodeIds
+                }
+              }
+            };
+            logRepoMeshStatusDebug("direct_truth_unavailable", {
+              meshId,
+              command: "mesh_status",
+              refreshRequested,
+              meshSource: meshRecord.source,
+              directTruth
+            });
+            return failureResult;
+          }
+          const directTruthUnavailableNodeIds = new Set(effectiveDirectTruth.unavailableNodeIds);
+          const selectedCoordinatorNodeId = readStringValue(
+            mesh.coordinator?.preferredNodeId,
+            mesh.nodes?.[0]?.id,
+            mesh.nodes?.[0]?.nodeId
+          );
+          const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? selectedCoordinatorNodeId : void 0;
+          const refreshedAt = (/* @__PURE__ */ new Date()).toISOString();
           const nodeStatuses = [];
-          for (const node of mesh.nodes || []) {
+          for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
+            const nodeId = String(node.id || node.nodeId || "");
+            const daemonId = readStringValue(node.daemonId);
+            const providerPriority = readProviderPriorityFromPolicy(node.policy);
+            const isSelfNode = Boolean(
+              nodeId && inlineCoordinatorNodeId && nodeId === inlineCoordinatorNodeId
+            ) || Boolean(
+              daemonId && (daemonId === localMachineId || daemonId === this.deps.statusInstanceId)
+            ) || Boolean(meshRecord?.inline && nodeIndex === 0);
             const status = {
-              nodeId: node.id || node.nodeId,
+              nodeId,
               machineLabel: node.machineLabel || node.id || node.nodeId,
               workspace: node.workspace,
               repoRoot: node.repoRoot,
               isLocalWorktree: node.isLocalWorktree,
               worktreeBranch: node.worktreeBranch,
-              daemonId: node.daemonId,
+              role: normalizeMeshDaemonRole(node.role) || (meshHost.hostNodeId && nodeId === meshHost.hostNodeId ? "host" : void 0),
+              daemonId,
               machineId: node.machineId,
+              machineStatus: node.machineStatus,
               health: "unknown",
               providers: node.providers || [],
-              activeSessions: []
+              providerPriority,
+              activeSessions: [],
+              activeSessionDetails: [],
+              launchReady: false
             };
-            if (node.workspace && typeof node.workspace === "string") {
-              if (!fs10.existsSync(node.workspace) && applyCachedInlineMeshNodeStatus(status, node)) {
-                nodeStatuses.push(status);
-                continue;
+            if (isSelfNode) {
+              status.connection = {
+                perspective: "selected_coordinator",
+                source: "mesh_peer_status",
+                state: "self",
+                transport: "local",
+                reported: true,
+                reason: "Selected coordinator daemon",
+                lastStateChangeAt: refreshedAt
+              };
+            } else if (daemonId) {
+              const connection = this.deps.getMeshPeerConnectionStatus?.(daemonId);
+              status.connection = connection ?? {
+                perspective: "selected_coordinator",
+                source: "not_reported",
+                state: "unknown",
+                transport: "unknown",
+                reported: false,
+                reason: "No live mesh peer telemetry reported by the selected coordinator yet."
+              };
+            } else {
+              status.connection = {
+                perspective: "selected_coordinator",
+                source: "not_reported",
+                state: "unknown",
+                transport: "unknown",
+                reported: false,
+                reason: "Node has no daemon id, so mesh transport cannot be reported from the selected coordinator."
+              };
+            }
+            const matchedLiveSessionRecords = collectLiveMeshSessionRecords({
+              meshId,
+              node,
+              nodeId,
+              liveSessionRecords: liveMeshSessions,
+              allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
+            });
+            const workspace = readLiveMeshNodeWorkspace({
+              meshId,
+              nodeId,
+              liveSessionRecords: matchedLiveSessionRecords,
+              allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
+            }) || (typeof node.workspace === "string" ? node.workspace : "");
+            status.workspace = workspace || node.workspace;
+            if (matchedLiveSessionRecords.length > 0) {
+              const sessionIds = matchedLiveSessionRecords.map((record) => typeof record?.sessionId === "string" ? record.sessionId : "").filter(Boolean);
+              const providerTypes = matchedLiveSessionRecords.map((record) => readStringValue(record?.providerType)).filter(Boolean);
+              status.activeSessions = sessionIds;
+              status.activeSessionDetails = matchedLiveSessionRecords.map(summarizeMeshSessionRecord);
+              if (providerTypes.length > 0) {
+                status.providers = Array.from(/* @__PURE__ */ new Set([...Array.isArray(status.providers) ? status.providers : [], ...providerTypes]));
               }
-              try {
-                const gitStatus = await getGitRepoStatus(node.workspace, { timeoutMs: 1e4 });
-                status.git = gitStatus;
-                if (gitStatus.isGitRepo) {
-                  const dirty = gitStatus.staged + gitStatus.modified + gitStatus.untracked + gitStatus.deleted + gitStatus.renamed > 0;
-                  status.health = gitStatus.branch ? dirty ? "dirty" : "online" : "degraded";
-                } else {
-                  status.health = "degraded";
-                  if (gitStatus.error && !status.error) status.error = gitStatus.error;
+            }
+            if (workspace) {
+              if (!fs10.existsSync(workspace)) {
+                const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
+                let remoteProbeApplied = false;
+                if (inlineTransitGit) {
+                  status.git = inlineTransitGit;
+                  status.health = inlineTransitGit.isGitRepo ? deriveMeshNodeHealthFromGit(inlineTransitGit) : "degraded";
+                  const connection = readObjectRecord(status.connection);
+                  const connectionState = readStringValue(connection.state);
+                  const connectionReported = readBooleanValue(connection.reported) ?? false;
+                  if (!connectionReported || connectionState === "unknown") {
+                    status.connection = buildLivePeerGitConnection(connection, refreshedAt);
+                  }
+                  remoteProbeApplied = true;
+                } else if (!isSelfNode && daemonId && this.deps.dispatchMeshCommand && !directTruthUnavailableNodeIds.has(nodeId)) {
+                  try {
+                    const remoteGit = await probeRemoteMeshGitStatus({
+                      dispatchMeshCommand: this.deps.dispatchMeshCommand,
+                      daemonId,
+                      workspace,
+                      timeoutMs: 8e3
+                    });
+                    if (remoteGit) {
+                      status.git = remoteGit;
+                      status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
+                      const connection = readObjectRecord(status.connection);
+                      const connectionState = readStringValue(connection.state);
+                      const connectionReported = readBooleanValue(connection.reported) ?? false;
+                      if (!connectionReported || connectionState === "unknown") {
+                        status.connection = buildLivePeerGitConnection(connection, refreshedAt);
+                      }
+                      recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+                      remoteProbeApplied = true;
+                    }
+                  } catch {
+                    const refreshedConnection = this.deps.getMeshPeerConnectionStatus?.(daemonId);
+                    const refreshedConnectionState = readStringValue(refreshedConnection?.state);
+                    if (refreshedConnection && refreshedConnectionState === "connected") {
+                      status.connection = refreshedConnection;
+                      try {
+                        const remoteGit = await probeRemoteMeshGitStatus({
+                          dispatchMeshCommand: this.deps.dispatchMeshCommand,
+                          daemonId,
+                          workspace,
+                          timeoutMs: 12e3
+                        });
+                        if (remoteGit) {
+                          status.git = remoteGit;
+                          status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
+                          const connection = readObjectRecord(status.connection);
+                          const connectionState = readStringValue(connection.state);
+                          const connectionReported = readBooleanValue(connection.reported) ?? false;
+                          if (!connectionReported || connectionState === "unknown") {
+                            status.connection = buildLivePeerGitConnection(connection, refreshedAt);
+                          }
+                          recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+                          remoteProbeApplied = true;
+                        }
+                      } catch {
+                      }
+                    }
+                  }
                 }
-              } catch {
-                if (!applyCachedInlineMeshNodeStatus(status, node)) {
-                  status.health = "degraded";
+                if (!remoteProbeApplied) {
+                  const connectionState = readStringValue(status.connection?.state);
+                  const pendingPeerGitProbe = !inlineTransitGit && !isSelfNode && !!daemonId && (readStringValue(status.machineStatus) === "online" || readStringValue(status.health) === "online" || connectionState === "connecting" || connectionState === "connected" || connectionState === "unknown");
+                  if (pendingPeerGitProbe) {
+                    status.gitProbePending = true;
+                    status.health = "unknown";
+                  }
+                  if (applyCachedInlineMeshNodeStatus(
+                    status,
+                    node,
+                    pendingPeerGitProbe ? { skipGit: true, skipError: true, skipHealth: true } : void 0
+                  )) {
+                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
+                    nodeStatuses.push(status);
+                    continue;
+                  }
+                  if (meshRecord?.source === "inline_cache" && !isSelfNode) {
+                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
+                    nodeStatuses.push(status);
+                    continue;
+                  }
+                }
+              } else {
+                try {
+                  const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+                  status.git = gitStatus;
+                  recordInlineMeshDirectGitTruth(node, gitStatus, "selected_coordinator_local_git");
+                  if (gitStatus.isGitRepo) {
+                    status.health = deriveMeshNodeHealthFromGit(gitStatus);
+                  } else {
+                    status.health = "degraded";
+                    if (gitStatus.error && !status.error) status.error = gitStatus.error;
+                  }
+                } catch {
+                  if (!applyCachedInlineMeshNodeStatus(status, node)) {
+                    status.health = "degraded";
+                  }
                 }
               }
             } else {
               applyCachedInlineMeshNodeStatus(status, node);
             }
+            finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
             nodeStatuses.push(status);
           }
-          return {
+          const statusResult = {
             success: true,
             meshId: mesh.id,
             meshName: mesh.name,
             repoIdentity: mesh.repoIdentity,
             defaultBranch: mesh.defaultBranch,
+            refreshedAt,
+            meshHost,
+            sourceOfTruth: {
+              membership: meshRecord?.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord?.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+              coordinatorOwnsLiveTruth: directTruthSatisfied,
+              meshHost: {
+                owner: "mesh_host_daemon",
+                localRole: meshHost.role,
+                hostDaemonId: meshHost.hostDaemonId,
+                hostNodeId: meshHost.hostNodeId,
+                hostAddress: meshHost.hostAddress
+              },
+              ...requireDirectPeerTruth ? {
+                currentStatus: directTruthSatisfied ? "live_git_and_session_probes" : "direct_peer_truth_unavailable",
+                directPeerTruth: {
+                  required: true,
+                  satisfied: directTruthSatisfied,
+                  directEvidenceCount: effectiveDirectTruth.directEvidenceCount,
+                  localConfirmedCount: effectiveDirectTruth.localConfirmedCount,
+                  peerAttemptedCount: effectiveDirectTruth.peerAttemptedCount,
+                  peerConfirmedCount: effectiveDirectTruth.peerConfirmedCount,
+                  unavailableNodeIds: effectiveDirectTruth.unavailableNodeIds
+                }
+              } : {},
+              historicalEvidenceOnly: ["recoveryHints", "ledger.summary", "queue.summary"]
+            },
             nodes: nodeStatuses,
             queue: { tasks: queue, summary: queueSummary },
             ledger: { entries: ledgerEntries, summary: ledgerSummary }
           };
+          const rememberedStatus = this.rememberAggregateMeshStatus(meshId, statusResult, refreshReason);
+          logRepoMeshStatusDebug("return_live", {
+            meshId,
+            command: "mesh_status",
+            refreshRequested,
+            refreshReason,
+            meshSource: meshRecord.source,
+            directTruth,
+            summary: summarizeRepoMeshStatusDebug(rememberedStatus)
+          });
+          return rememberedStatus;
         } catch (e) {
           return { success: false, error: e.message };
         }
@@ -33933,6 +35954,8 @@ async function initDaemonComponents(config) {
     sessionHostControl: config.sessionHostControl,
     statusInstanceId: config.statusInstanceId,
     statusVersion: config.statusVersion,
+    getMeshPeerConnectionStatus: config.getMeshPeerConnectionStatus,
+    dispatchMeshCommand: config.dispatchMeshCommand,
     getCdpLogFn: config.getCdpLogFn || ((ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn())
   });
   poller = new AgentStreamPoller({
@@ -34060,6 +36083,8 @@ export {
   InMemoryGitSnapshotStore,
   LOG,
   MAX_LEDGER_SLICE_LIMIT,
+  MESH_REFINE_CONFIG_LOCATIONS,
+  MESH_REFINE_CONFIG_SCHEMA,
   MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
   MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
@@ -34082,6 +36107,7 @@ export {
   buildChatTailDeliverySignature,
   buildCoordinatorSystemPrompt,
   buildMachineInfo,
+  buildMeshHostRequiredFailure,
   buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence,
   buildP2pRelayFailurePayload,
@@ -34107,6 +36133,7 @@ export {
   connectCdpManager,
   createDebugTraceStore,
   createDefaultGitCommandServices,
+  createDefaultMeshHostMetadata,
   createGitCompactSummary,
   createGitSnapshotStore,
   createGitWorkspaceMonitor,
@@ -34170,6 +36197,7 @@ export {
   isInternalChatMessage,
   isManagedStatusWaiting,
   isManagedStatusWorking,
+  isMeshHostOwner,
   isP2pRelayTransportFailure,
   isPathInside,
   isSessionHostLiveRuntime,
@@ -34183,6 +36211,7 @@ export {
   listMeshes,
   listWorktrees,
   loadConfig,
+  loadMeshRefineConfig,
   loadState,
   logCommand,
   markSetupComplete,
@@ -34196,6 +36225,7 @@ export {
   normalizeGitWorkspaceSubscriptionParams,
   normalizeInputEnvelope,
   normalizeManagedStatus,
+  normalizeMeshDaemonRole,
   normalizeMessageParts,
   normalizeRepoIdentity,
   normalizeSessionModalFields,
@@ -34207,6 +36237,7 @@ export {
   prepareSessionChatTailUpdate,
   prepareSessionModalUpdate,
   probeCdpPort,
+  queuePendingMeshCoordinatorEvent,
   readChatHistory,
   readLedgerEntries,
   readLedgerSlice,
@@ -34215,6 +36246,7 @@ export {
   removeNode,
   removeWorktree,
   requeueTask,
+  requireMeshHostQueueOwner,
   resetConfig,
   resetDebugRuntimeConfig,
   resetState,
@@ -34222,6 +36254,8 @@ export {
   resolveCurrentGlobalInstallSurface,
   resolveDebugRuntimeConfig,
   resolveGitRepository,
+  resolveMeshHostStatus,
+  resolveMeshRefineValidationPlan,
   resolveSessionHostAppName,
   resolveSessionHostAppNameResolution,
   resolveWorktreePath,
@@ -34237,6 +36271,7 @@ export {
   shutdownDaemonComponents,
   spawnDetachedDaemonUpgradeHelper,
   startDaemonDevSupport,
+  suggestMeshRefineConfig,
   summarizeGitStatus,
   syncMeshes,
   triggerMeshQueue,
@@ -34245,6 +36280,7 @@ export {
   updateNode,
   updateSessionTaskStatus,
   updateTaskStatus,
-  upsertSavedProviderSession
+  upsertSavedProviderSession,
+  validateMeshRefineConfig
 };
 //# sourceMappingURL=index.mjs.map