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

package/dist/index.js

@@ -46184,8 +46184,12 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       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;
@@ -47054,10 +47058,69 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         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 cached2 = this.aggregateMeshStatusCache.get(meshId);
         if (!cached2?.snapshot || cached2.snapshot.success !== true || !Array.isArray(cached2.snapshot.nodes)) return null;
-        const snapshot = this.cloneJsonValue(cached2.snapshot);
+        let snapshot = this.cloneJsonValue(cached2.snapshot);
+        snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
         const ageMs = Math.max(0, Date.now() - cached2.builtAt);
         const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
         snapshot.sourceOfTruth = {
@@ -47117,7 +47180,14 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         const preferInline = options?.preferInline === true;
         if (preferInline) {
           const cached22 = this.getCachedInlineMesh(meshId);
-          if (cached22) return { mesh: cached22, inline: true, source: "inline_cache" };
+          if (cached22) {
+            if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
+              const merged = reconcileInlineMeshCache(cached22, inlineMesh);
+              this.inlineMeshCache.set(meshId, sanitizeInlineMesh(merged));
+              return { mesh: merged, inline: true, source: "inline_cache" };
+            }
+            return { mesh: cached22, inline: true, source: "inline_cache" };
+          }
           if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
             this.warmInlineMeshCache(meshId, inlineMesh);
             return { mesh: inlineMesh, inline: true, source: "inline_bootstrap" };
@@ -49097,7 +49167,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,
@@ -49132,7 +49202,7 @@ ${block}`);
                 peerConfirmedCount: 0,
                 unavailableNodeIds: []
               };
-              const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
+              const directTruthSatisfied = !requireDirectPeerTruth || directTruth.directEvidenceCount > 0 && directTruth.unavailableNodeIds.length === 0;
               if (requireDirectPeerTruth && !directTruthSatisfied) {
                 const failureResult = {
                   success: false,