adhdev 0.9.82-rc.45 → 0.9.82-rc.47

package/dist/cli/index.js

@@ -46760,6 +46760,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);
@@ -46771,11 +46786,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, timestamp2 = (/* @__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) ?? timestamp2
+  };
 }
 function recordInlineMeshDirectGitTruth(node, git, source) {
   if (!node || typeof node !== "object" || Array.isArray(node)) return;
@@ -47706,8 +47746,16 @@ var init_router = __esm({
           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;
@@ -47744,6 +47792,7 @@ var init_router = __esm({
         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 = {
@@ -49789,6 +49838,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) {
@@ -49801,7 +49851,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);
@@ -49825,7 +49875,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,
@@ -49855,7 +49907,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,
@@ -49950,6 +50002,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 {
@@ -49962,6 +50020,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;
                         }
@@ -49980,6 +50044,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;
                             }
@@ -50048,11 +50118,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"]
@@ -99306,7 +99376,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.45" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.47" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;