@adhdev/daemon-core 0.9.81 → 0.9.82-rc.10

package/dist/index.js

@@ -1896,10 +1896,18 @@ __export(mesh_events_exports, {
   drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
   getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
   handleMeshForwardEvent: () => handleMeshForwardEvent,
+  queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   setupMeshEventForwarding: () => setupMeshEventForwarding,
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
+function queuePendingMeshCoordinatorEvent(event) {
+  if (pendingMeshCoordinatorEvents.length >= MAX_PENDING_EVENTS) {
+    return false;
+  }
+  pendingMeshCoordinatorEvents.push(event);
+  return true;
+}
 function drainPendingMeshCoordinatorEvents() {
   return pendingMeshCoordinatorEvents.splice(0);
 }
@@ -2471,17 +2479,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 };
@@ -5860,6 +5869,7 @@ __export(index_exports, {
   prepareSessionChatTailUpdate: () => prepareSessionChatTailUpdate,
   prepareSessionModalUpdate: () => prepareSessionModalUpdate,
   probeCdpPort: () => probeCdpPort,
+  queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   readChatHistory: () => readChatHistory,
   readLedgerEntries: () => readLedgerEntries,
   readLedgerSlice: () => readLedgerSlice,
@@ -5913,8 +5923,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;
@@ -5929,6 +5945,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,
@@ -5953,6 +5972,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,
@@ -6047,6 +6120,7 @@ function emptyStatus(workspace, lastCheckedAt, error) {
     headCommit: null,
     headMessage: null,
     upstream: null,
+    upstreamStatus: "unavailable",
     ahead: 0,
     behind: 0,
     staged: 0,
@@ -6327,6 +6401,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,
@@ -6671,7 +6748,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({
@@ -6757,7 +6834,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": {
@@ -23814,6 +23891,240 @@ function readProviderPriorityFromPolicy(policy) {
     return true;
   });
 }
+function readObjectRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readStringValue(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function readNumberValue(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function readBooleanValue(...values) {
+  for (const value of values) {
+    if (typeof value === "boolean") return value;
+  }
+  return void 0;
+}
+function readGitSubmodules(value) {
+  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);
+    if (!path28 || !commit || !repoPath) return null;
+    return {
+      path: path28,
+      commit,
+      repoPath,
+      dirty: readBooleanValue(submodule.dirty) ?? false,
+      outOfSync: readBooleanValue(submodule.outOfSync, submodule.out_of_sync) ?? false,
+      lastCheckedAt: readNumberValue(submodule.lastCheckedAt, submodule.last_checked_at) ?? Date.now(),
+      ...readStringValue(submodule.error) ? { error: readStringValue(submodule.error) } : {}
+    };
+  }).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 : {};
+  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);
+  return {
+    workspace: readStringValue(status.workspace, node?.workspace) || "",
+    repoRoot: readStringValue(status.repoRoot, node?.repoRoot, node?.workspace) || null,
+    isGitRepo,
+    branch: readStringValue(status.branch) ?? null,
+    headCommit: readStringValue(status.headCommit) ?? null,
+    headMessage: readStringValue(status.headMessage) ?? null,
+    upstream: readStringValue(status.upstream) ?? null,
+    ahead: readNumberValue(status.ahead) ?? 0,
+    behind: readNumberValue(status.behind) ?? 0,
+    staged: readNumberValue(status.staged) ?? 0,
+    modified: readNumberValue(status.modified) ?? 0,
+    untracked: readNumberValue(status.untracked) ?? 0,
+    deleted: readNumberValue(status.deleted) ?? 0,
+    renamed: readNumberValue(status.renamed) ?? 0,
+    hasConflicts,
+    conflictFiles,
+    stashCount: readNumberValue(status.stashCount) ?? 0,
+    lastCheckedAt: Date.now(),
+    ...submodules ? { submodules } : {}
+  };
+}
+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 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 applyCachedInlineMeshNodeStatus(status, node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const git = buildCachedInlineMeshGitStatus(node);
+  const error = readStringValue(cachedStatus.error, node?.error);
+  const health = readStringValue(cachedStatus.health, node?.health);
+  const machineStatus = readStringValue(cachedStatus.machineStatus, node?.machineStatus);
+  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) {
+    status.health = deriveMeshNodeHealthFromGit(git);
+    return true;
+  }
+  return activeSessions.length > 0 || !!machineStatus || !!lastSeenAt || !!updatedAt;
+}
 async function resolveProviderTypeFromPriority(args) {
   if (!args.providerPriority.length) {
     return { error: `Node '${args.nodeId}' has no providerPriority policy; pass cliType explicitly or configure node.policy.providerPriority` };
@@ -24215,7 +24526,12 @@ var DaemonCommandRouter = class {
     }
     return this.inlineMeshCache.get(meshId);
   }
-  async getMeshForCommand(meshId, inlineMesh) {
+  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 };
+    }
     try {
       const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
       const mesh = getMesh3(meshId);
@@ -26038,7 +26354,7 @@ ${block}`);
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
         try {
-          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
           const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
@@ -26047,84 +26363,102 @@ ${block}`);
           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 inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? readStringValue(mesh.nodes[0]?.id, mesh.nodes[0]?.nodeId) : 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,
+              daemonId,
               machineId: node.machineId,
+              machineStatus: node.machineStatus,
               health: "unknown",
               providers: node.providers || [],
-              activeSessions: []
+              providerPriority,
+              activeSessions: [],
+              activeSessionDetails: [],
+              launchReady: false
             };
+            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 = liveMeshSessions.filter((record) => this.sessionMatchesMeshNode(record, node, nodeId));
+            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]));
+              }
+            }
             if (node.workspace && typeof node.workspace === "string") {
+              if (!fs10.existsSync(node.workspace) && applyCachedInlineMeshNodeStatus(status, node)) {
+                status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                nodeStatuses.push(status);
+                continue;
+              }
               try {
-                const { execFile: execFile3 } = await import("child_process");
-                const { promisify: promisify3 } = await import("util");
-                const execFileAsync3 = promisify3(execFile3);
-                const runGit2 = async (args2) => {
-                  const result = await execFileAsync3("git", ["-C", node.workspace, ...args2], {
-                    encoding: "utf8",
-                    timeout: 1e4
-                  });
-                  return result.stdout.trim();
-                };
-                const branch = await runGit2(["branch", "--show-current"]).catch(() => "");
-                const porc = await runGit2(["status", "--porcelain"]).catch(() => "");
-                const headCommit = await runGit2(["rev-parse", "--short", "HEAD"]).catch(() => null);
-                const headMessage = await runGit2(["log", "-1", "--format=%s"]).catch(() => null);
-                const upstream = await runGit2(["rev-parse", "--abbrev-ref", "@{upstream}"]).catch(() => null);
-                const aheadBehind = await runGit2(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"]).catch(() => "");
-                const stashCount = await runGit2(["stash", "list"]).catch(() => "");
-                let ahead = 0, behind = 0;
-                if (aheadBehind) {
-                  const parts = aheadBehind.split(/\s+/);
-                  if (parts.length >= 2) {
-                    behind = parseInt(parts[0], 10) || 0;
-                    ahead = parseInt(parts[1], 10) || 0;
-                  }
-                }
-                const dirty = porc.length > 0;
-                const lines = porc ? porc.split("\n").filter(Boolean) : [];
-                let staged = 0, modified = 0, untracked = 0, deleted = 0, renamed = 0;
-                for (const line of lines) {
-                  const xy = line.slice(0, 2);
-                  if (xy[0] !== " " && xy[0] !== "?") staged++;
-                  if (xy[1] === "M") modified++;
-                  if (xy[1] === "D") deleted++;
-                  if (xy[0] === "R" || xy[1] === "R") renamed++;
-                  if (xy === "??") untracked++;
+                const gitStatus = await getGitRepoStatus(node.workspace, { timeoutMs: 1e4, refreshUpstream: true });
+                status.git = gitStatus;
+                if (gitStatus.isGitRepo) {
+                  status.health = deriveMeshNodeHealthFromGit(gitStatus);
+                } else {
+                  status.health = "degraded";
+                  if (gitStatus.error && !status.error) status.error = gitStatus.error;
                 }
-                status.git = {
-                  workspace: node.workspace,
-                  repoRoot: node.workspace,
-                  isGitRepo: true,
-                  branch: branch || null,
-                  headCommit,
-                  headMessage,
-                  upstream,
-                  ahead,
-                  behind,
-                  staged,
-                  modified,
-                  untracked,
-                  deleted,
-                  renamed,
-                  hasConflicts: false,
-                  conflictFiles: [],
-                  stashCount: stashCount ? stashCount.split("\n").filter(Boolean).length : 0,
-                  lastCheckedAt: Date.now()
-                };
-                status.health = branch ? dirty ? "dirty" : "online" : "degraded";
               } catch {
-                status.health = "degraded";
+                if (!applyCachedInlineMeshNodeStatus(status, node)) {
+                  status.health = "degraded";
+                }
               }
+            } else {
+              applyCachedInlineMeshNodeStatus(status, node);
             }
+            status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
             nodeStatuses.push(status);
           }
           return {
@@ -26133,6 +26467,7 @@ ${block}`);
             meshName: mesh.name,
             repoIdentity: mesh.repoIdentity,
             defaultBranch: mesh.defaultBranch,
+            refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
             nodes: nodeStatuses,
             queue: { tasks: queue, summary: queueSummary },
             ledger: { entries: ledgerEntries, summary: ledgerSummary }
@@ -34062,6 +34397,7 @@ async function initDaemonComponents(config) {
     sessionHostControl: config.sessionHostControl,
     statusInstanceId: config.statusInstanceId,
     statusVersion: config.statusVersion,
+    getMeshPeerConnectionStatus: config.getMeshPeerConnectionStatus,
     getCdpLogFn: config.getCdpLogFn || ((ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn())
   });
   poller = new AgentStreamPoller({
@@ -34337,6 +34673,7 @@ async function shutdownDaemonComponents(components) {
   prepareSessionChatTailUpdate,
   prepareSessionModalUpdate,
   probeCdpPort,
+  queuePendingMeshCoordinatorEvent,
   readChatHistory,
   readLedgerEntries,
   readLedgerSlice,