@adhdev/daemon-core 0.9.82-rc.44 → 0.9.82-rc.46

package/dist/index.mjs

@@ -23971,8 +23971,12 @@ function buildInlineMeshTransitGitStatus(node) {
   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 : {};
-  return normalizeInlineMeshGitStatus(status, node, { lastCheckedAt: Date.now() });
+  const candidates = [directStatus, nestedStatus, probeDirectStatus, probeNestedStatus];
+  for (const status of candidates) {
+    const normalized = normalizeInlineMeshGitStatus(status, node, { lastCheckedAt: Date.now() });
+    if (normalized) return normalized;
+  }
+  return void 0;
 }
 function recordInlineMeshDirectGitTruth(node, git, source) {
   if (!node || typeof node !== "object" || Array.isArray(node)) return;
@@ -24841,10 +24845,69 @@ var DaemonCommandRouter = class {
     if (typeof structuredClone === "function") return structuredClone(value);
     return JSON.parse(JSON.stringify(value));
   }
-  getCachedAggregateMeshStatus(meshId) {
+  hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options) {
+    if (!mesh || typeof mesh !== "object" || !Array.isArray(mesh.nodes) || !Array.isArray(snapshot?.nodes)) return snapshot;
+    const inlineNodesById = /* @__PURE__ */ new Map();
+    for (const node of mesh.nodes) {
+      const nodeId = readInlineMeshNodeId(node);
+      if (nodeId) inlineNodesById.set(nodeId, node);
+    }
+    if (!inlineNodesById.size) return snapshot;
+    let changed = false;
+    const unavailableNodeIds = /* @__PURE__ */ new Set();
+    const sourceOfTruth = readObjectRecord(snapshot.sourceOfTruth);
+    const directPeerTruth = readObjectRecord(sourceOfTruth.directPeerTruth);
+    for (const entry of Array.isArray(directPeerTruth.unavailableNodeIds) ? directPeerTruth.unavailableNodeIds : []) {
+      const nodeId = readStringValue(entry);
+      if (nodeId) unavailableNodeIds.add(nodeId);
+    }
+    const nodes = snapshot.nodes.map((statusNode) => {
+      const nodeId = readStringValue(statusNode?.nodeId, statusNode?.id);
+      const inlineNode = nodeId ? inlineNodesById.get(nodeId) : void 0;
+      if (!inlineNode) return statusNode;
+      const liveGit = buildInlineMeshTransitGitStatus(inlineNode);
+      if (!liveGit) return statusNode;
+      const nextStatus = { ...statusNode };
+      nextStatus.git = liveGit;
+      nextStatus.health = deriveMeshNodeHealthFromGit(liveGit);
+      delete nextStatus.gitProbePending;
+      if (readStringValue(nextStatus.error) === "waiting for live peer git snapshot") delete nextStatus.error;
+      if (!readStringValue(nextStatus.machineStatus)) nextStatus.machineStatus = "online";
+      if (nodeId) unavailableNodeIds.delete(nodeId);
+      changed = true;
+      return nextStatus;
+    });
+    if (!changed && !(options?.requireDirectPeerTruth && unavailableNodeIds.size > 0)) return snapshot;
+    const nextSourceOfTruth = {
+      ...sourceOfTruth,
+      ...Object.keys(directPeerTruth).length ? {
+        directPeerTruth: {
+          ...directPeerTruth,
+          satisfied: options?.requireDirectPeerTruth === true ? unavailableNodeIds.size === 0 : directPeerTruth.satisfied,
+          unavailableNodeIds: [...unavailableNodeIds]
+        },
+        ...options?.requireDirectPeerTruth === true ? {
+          coordinatorOwnsLiveTruth: unavailableNodeIds.size === 0,
+          currentStatus: unavailableNodeIds.size === 0 ? "live_git_and_session_probes" : "direct_peer_truth_unavailable"
+        } : {}
+      } : {}
+    };
+    return {
+      ...snapshot,
+      ...options?.requireDirectPeerTruth === true && unavailableNodeIds.size > 0 ? {
+        success: false,
+        code: "mesh_direct_peer_truth_unavailable",
+        error: "Selected coordinator could not confirm direct mesh truth for every remote node yet."
+      } : {},
+      sourceOfTruth: nextSourceOfTruth,
+      nodes
+    };
+  }
+  getCachedAggregateMeshStatus(meshId, mesh, options) {
     const cached = this.aggregateMeshStatusCache.get(meshId);
     if (!cached?.snapshot || cached.snapshot.success !== true || !Array.isArray(cached.snapshot.nodes)) return null;
-    const snapshot = this.cloneJsonValue(cached.snapshot);
+    let snapshot = this.cloneJsonValue(cached.snapshot);
+    snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
     const ageMs = Math.max(0, Date.now() - cached.builtAt);
     const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
     snapshot.sourceOfTruth = {
@@ -24904,7 +24967,14 @@ var DaemonCommandRouter = class {
     const preferInline = options?.preferInline === true;
     if (preferInline) {
       const cached2 = this.getCachedInlineMesh(meshId);
-      if (cached2) return { mesh: cached2, inline: true, source: "inline_cache" };
+      if (cached2) {
+        if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
+          const merged = reconcileInlineMeshCache(cached2, inlineMesh);
+          this.inlineMeshCache.set(meshId, sanitizeInlineMesh(merged));
+          return { mesh: merged, inline: true, source: "inline_cache" };
+        }
+        return { mesh: cached2, inline: true, source: "inline_cache" };
+      }
       if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
         this.warmInlineMeshCache(meshId, inlineMesh);
         return { mesh: inlineMesh, inline: true, source: "inline_bootstrap" };
@@ -26884,7 +26954,7 @@ ${block}`);
           if (!mesh) return { success: false, error: "Mesh not found" };
           const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
           if (!refreshRequested) {
-            const cachedStatus = this.getCachedAggregateMeshStatus(meshId);
+            const cachedStatus = this.getCachedAggregateMeshStatus(meshId, mesh, { requireDirectPeerTruth: args?.requireDirectPeerTruth === true });
             if (cachedStatus) {
               logRepoMeshStatusDebug("return_cached", {
                 meshId,
@@ -26919,7 +26989,9 @@ ${block}`);
             peerConfirmedCount: 0,
             unavailableNodeIds: []
           };
-          const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 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,
@@ -26949,7 +27021,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,
@@ -27142,11 +27214,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"]