@adhdev/daemon-standalone 0.9.82-rc.1 → 0.9.82-rc.11

package/dist/index.js

@@ -24046,10 +24046,18 @@ Follow these recovery rules:
       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);
     }
@@ -24621,17 +24629,18 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         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()
+        })) {
           LOG2.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
         }
         return { success: true, forwarded: 0 };
@@ -28013,6 +28022,7 @@ ${lastSnapshot}`;
       prepareSessionChatTailUpdate: () => prepareSessionChatTailUpdate2,
       prepareSessionModalUpdate: () => prepareSessionModalUpdate2,
       probeCdpPort: () => probeCdpPort,
+      queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
       readChatHistory: () => readChatHistory,
       readLedgerEntries: () => readLedgerEntries,
       readLedgerSlice: () => readLedgerSlice,
@@ -28062,8 +28072,14 @@ ${lastSnapshot}`;
       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;
@@ -28078,6 +28094,9 @@ ${lastSnapshot}`;
           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,
@@ -28102,6 +28121,60 @@ ${lastSnapshot}`;
         );
       }
     }
+    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 (error48) {
+        return {
+          upstreamStatus: "stale",
+          upstreamFetchError: formatGitError(error48)
+        };
+      }
+    }
+    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(error48) {
+      if (error48 instanceof GitCommandError) {
+        return error48.stderr || error48.message;
+      }
+      if (error48 instanceof Error) {
+        return error48.message;
+      }
+      return String(error48);
+    }
     function parsePorcelainV2Status(output) {
       const parsed = {
         branch: null,
@@ -28196,6 +28269,7 @@ ${lastSnapshot}`;
         headCommit: null,
         headMessage: null,
         upstream: null,
+        upstreamStatus: "unavailable",
         ahead: 0,
         behind: 0,
         staged: 0,
@@ -28472,6 +28546,9 @@ ${lastSnapshot}`;
         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,
@@ -28810,7 +28887,7 @@ ${lastSnapshot}`;
     });
     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({
@@ -28896,7 +28973,7 @@ ${lastSnapshot}`;
       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": {
@@ -45791,6 +45868,240 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         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(record2) {
+      return readStringValue(
+        record2?.meta?.sessionStatus,
+        record2?.meta?.status,
+        record2?.meta?.providerStatus,
+        record2?.status,
+        record2?.state,
+        record2?.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(record2) {
+      return {
+        sessionId: readStringValue(record2?.sessionId) || "unknown",
+        providerType: readStringValue(record2?.providerType),
+        state: readLiveMeshSessionState(record2),
+        lifecycle: readStringValue(record2?.lifecycle),
+        surfaceKind: getSessionHostSurfaceKind(record2),
+        recoveryState: readStringValue(record2?.meta?.runtimeRecoveryState) ?? null,
+        workspace: readStringValue(record2?.workspace) ?? null,
+        title: readStringValue(record2?.displayName, record2?.workspaceLabel) ?? null,
+        lastActivityAt: toIsoTimestamp(record2?.updatedAt ?? record2?.lastActivityAt ?? record2?.last_activity_at),
+        isCached: false
+      };
+    }
+    function applyCachedInlineMeshNodeStatus(status, node) {
+      const cachedStatus = readObjectRecord(node?.cachedStatus);
+      const git = buildCachedInlineMeshGitStatus(node);
+      const error48 = 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 && !error48 && !health && !machineStatus && !lastSeenAt && !updatedAt && activeSessions.length === 0) return false;
+      if (git) status.git = git;
+      if (error48) status.error = error48;
+      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` };
@@ -46192,7 +46503,12 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         }
         return this.inlineMeshCache.get(meshId);
       }
-      async getMeshForCommand(meshId, inlineMesh) {
+      async getMeshForCommand(meshId, inlineMesh, options) {
+        const preferInline = options?.preferInline === true;
+        if (preferInline) {
+          const cached22 = this.getCachedInlineMesh(meshId, inlineMesh);
+          if (cached22) return { mesh: cached22, inline: true };
+        }
         try {
           const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           const mesh = getMesh3(meshId);
@@ -48015,7 +48331,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));
@@ -48024,84 +48340,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 = loadConfig2().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((record2) => this.sessionMatchesMeshNode(record2, node, nodeId));
+                if (matchedLiveSessionRecords.length > 0) {
+                  const sessionIds = matchedLiveSessionRecords.map((record2) => typeof record2?.sessionId === "string" ? record2.sessionId : "").filter(Boolean);
+                  const providerTypes = matchedLiveSessionRecords.map((record2) => readStringValue(record2?.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 {
@@ -48110,6 +48444,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 }
@@ -55985,6 +56320,7 @@ data: ${JSON.stringify(msg.data)}
         sessionHostControl: config2.sessionHostControl,
         statusInstanceId: config2.statusInstanceId,
         statusVersion: config2.statusVersion,
+        getMeshPeerConnectionStatus: config2.getMeshPeerConnectionStatus,
         getCdpLogFn: config2.getCdpLogFn || ((ideType) => LOG2.forComponent(`CDP:${ideType}`).asLogFn())
       });
       poller = new AgentStreamPoller({