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

package/dist/index.js

@@ -46174,6 +46174,21 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         ...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);
@@ -46185,11 +46200,36 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       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;
@@ -47083,8 +47123,16 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           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 error48 = readStringValue(nextStatus.error);
+          if (error48 && /pending_git|git probe|live peer git snapshot|no peer git snapshot/i.test(error48)) delete nextStatus.error;
           if (!readStringValue(nextStatus.machineStatus)) nextStatus.machineStatus = "online";
           if (nodeId) unavailableNodeIds.delete(nodeId);
           changed = true;
@@ -47121,6 +47169,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         if (!cached2?.snapshot || cached2.snapshot.success !== true || !Array.isArray(cached2.snapshot.nodes)) return null;
         let snapshot = this.cloneJsonValue(cached2.snapshot);
         snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
+        if (shouldRefreshStalePendingAggregate(snapshot, options)) return null;
         const ageMs = Math.max(0, Date.now() - cached2.builtAt);
         const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
         snapshot.sourceOfTruth = {
@@ -49166,6 +49215,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) {
@@ -49178,7 +49228,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);
@@ -49202,7 +49252,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,
@@ -49232,7 +49284,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,
@@ -49327,6 +49379,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 {
@@ -49339,6 +49397,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;
                         }
@@ -49357,6 +49421,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;
                             }
@@ -49425,11 +49495,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"]