@adhdev/daemon-core 0.9.82-rc.45 → 0.9.82-rc.47

package/dist/index.js

@@ -24194,6 +24194,21 @@ function normalizeInlineMeshGitStatus(status, node, options) {
     ...submodules ? { submodules } : {}
   };
 }
+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);
@@ -24205,11 +24220,36 @@ function buildInlineMeshTransitGitStatus(node) {
   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) return normalized;
-  }
-  return void 0;
+    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;
@@ -25103,8 +25143,16 @@ var DaemonCommandRouter = class {
       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;
-      if (readStringValue(nextStatus.error) === "waiting for live peer git snapshot") delete nextStatus.error;
+      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;
@@ -25141,6 +25189,7 @@ var DaemonCommandRouter = class {
     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 = {
@@ -27186,6 +27235,7 @@ ${block}`);
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
           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) {
@@ -27198,7 +27248,7 @@ ${block}`);
               return cachedStatus;
             }
           }
-          const refreshReason = refreshRequested ? "explicit_refresh" : "cold_cache_miss";
+          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);
@@ -27222,7 +27272,9 @@ ${block}`);
             peerConfirmedCount: 0,
             unavailableNodeIds: []
           };
-          const directTruthSatisfied = !requireDirectPeerTruth || directTruth.directEvidenceCount > 0 && directTruth.unavailableNodeIds.length === 0;
+          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,
@@ -27252,7 +27304,7 @@ ${block}`);
             });
             return failureResult;
           }
-          const directTruthUnavailableNodeIds = new Set(directTruth.unavailableNodeIds);
+          const directTruthUnavailableNodeIds = new Set(effectiveDirectTruth.unavailableNodeIds);
           const selectedCoordinatorNodeId = readStringValue(
             mesh.coordinator?.preferredNodeId,
             mesh.nodes?.[0]?.id,
@@ -27347,6 +27399,12 @@ ${block}`);
                 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 {
@@ -27359,6 +27417,12 @@ ${block}`);
                     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;
                     }
@@ -27377,6 +27441,12 @@ ${block}`);
                         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;
                         }
@@ -27445,11 +27515,11 @@ ${block}`);
                 directPeerTruth: {
                   required: true,
                   satisfied: directTruthSatisfied,
-                  directEvidenceCount: directTruth.directEvidenceCount,
-                  localConfirmedCount: directTruth.localConfirmedCount,
-                  peerAttemptedCount: directTruth.peerAttemptedCount,
-                  peerConfirmedCount: directTruth.peerConfirmedCount,
-                  unavailableNodeIds: directTruth.unavailableNodeIds
+                  directEvidenceCount: effectiveDirectTruth.directEvidenceCount,
+                  localConfirmedCount: effectiveDirectTruth.localConfirmedCount,
+                  peerAttemptedCount: effectiveDirectTruth.peerAttemptedCount,
+                  peerConfirmedCount: effectiveDirectTruth.peerConfirmedCount,
+                  unavailableNodeIds: effectiveDirectTruth.unavailableNodeIds
                 }
               } : {},
               historicalEvidenceOnly: ["recoveryHints", "ledger.summary", "queue.summary"]