@adhdev/daemon-core 0.9.82-rc.30 → 0.9.82-rc.32

package/dist/index.mjs

@@ -23839,13 +23839,21 @@ function readBooleanValue(...values) {
   }
   return void 0;
 }
-function readGitSubmodules(value) {
+function joinRepoPath(root, relativePath) {
+  const normalizedRoot = typeof root === "string" ? root.trim().replace(/[\\/]+$/, "") : "";
+  const normalizedPath = typeof relativePath === "string" ? relativePath.trim() : "";
+  if (!normalizedPath) return void 0;
+  if (/^(?:[A-Za-z]:[\\/]|\/)/.test(normalizedPath)) return normalizedPath;
+  if (!normalizedRoot) return void 0;
+  return `${normalizedRoot}/${normalizedPath.replace(/^[\\/]+/, "")}`;
+}
+function readGitSubmodules(value, parentRepoRoot) {
   if (!Array.isArray(value)) return void 0;
   const submodules = value.map((entry) => {
     const submodule = readObjectRecord(entry);
     const path28 = readStringValue(submodule.path);
     const commit = readStringValue(submodule.commit);
-    const repoPath = readStringValue(submodule.repoPath, submodule.repo_root);
+    const repoPath = readStringValue(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path28);
     if (!path28 || !commit || !repoPath) return null;
     return {
       path: path28,
@@ -23865,10 +23873,11 @@ function normalizeInlineMeshGitStatus(status, node, options) {
   const conflictFiles = Array.isArray(status.conflictFiles) ? status.conflictFiles.filter((value) => typeof value === "string") : [];
   const conflictCount = readNumberValue(status.conflicts) ?? conflictFiles.length;
   const hasConflicts = readBooleanValue(status.hasConflicts) ?? conflictCount > 0;
-  const submodules = readGitSubmodules(status.submodules);
+  const repoRoot = readStringValue(status.repoRoot, status.repo_root, node?.repoRoot, node?.repo_root, status.workspace, node?.workspace) || void 0;
+  const submodules = readGitSubmodules(status.submodules, repoRoot);
   return {
     workspace: readStringValue(status.workspace, node?.workspace) || "",
-    repoRoot: readStringValue(status.repoRoot, node?.repoRoot, node?.workspace) || null,
+    repoRoot: repoRoot ?? null,
     isGitRepo,
     branch: readStringValue(status.branch) ?? null,
     headCommit: readStringValue(status.headCommit) ?? null,
@@ -23901,6 +23910,26 @@ function buildInlineMeshTransitGitStatus(node) {
   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() });
 }
+function recordInlineMeshDirectGitTruth(node, git, source) {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return;
+  const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
+  const updatedAt = new Date(checkedAt).toISOString();
+  const nextGit = {
+    ...git,
+    lastCheckedAt: checkedAt
+  };
+  node.lastGit = {
+    source,
+    checkedAt,
+    status: nextGit
+  };
+  node.last_git = node.lastGit;
+  node.machineStatus = "online";
+  node.updatedAt = updatedAt;
+  node.lastSeenAt = updatedAt;
+  const repoRoot = readStringValue(nextGit.repoRoot);
+  if (repoRoot && !readStringValue(node.repoRoot)) node.repoRoot = repoRoot;
+}
 function buildCachedInlineMeshGitStatus(node) {
   const liveGit = buildInlineMeshTransitGitStatus(node);
   if (liveGit) return liveGit;
@@ -23943,7 +23972,6 @@ function stripInlineMeshTransientNodeState(node) {
     session_id: _sessionIdLegacy,
     providerType: _providerType,
     provider_type: _providerTypeLegacy,
-    providers: _providers,
     ...rest
   } = node;
   if (cachedStatus && !shouldDiscardCachedInlineMeshStatus(node)) {
@@ -23953,7 +23981,12 @@ function stripInlineMeshTransientNodeState(node) {
 }
 function hasInlineMeshTransientNodeState(node) {
   if (!node || typeof node !== "object" || Array.isArray(node)) return false;
-  return "cachedStatus" in node || "lastGit" in node || "last_git" in node || "lastProbe" in node || "last_probe" in node || "error" in node || "health" in node || "machineStatus" in node || "lastSeenAt" in node || "last_seen_at" in node || "updatedAt" in node || "updated_at" in node || "activeSession" in node || "active_session" in node || "activeSessionId" in node || "active_session_id" in node || "sessionId" in node || "session_id" in node || "providerType" in node || "provider_type" in node || "providers" in node;
+  return "cachedStatus" in node || "lastGit" in node || "last_git" in node || "lastProbe" in node || "last_probe" in node || "error" in node || "health" in node || "machineStatus" in node || "lastSeenAt" in node || "last_seen_at" in node || "updatedAt" in node || "updated_at" in node || "activeSession" in node || "active_session" in node || "activeSessionId" in node || "active_session_id" in node || "sessionId" in node || "session_id" in node || "providerType" in node || "provider_type" in node;
+}
+function inlineMeshCarriesTransientNodeTruth(inlineMesh) {
+  if (!inlineMesh || typeof inlineMesh !== "object" || Array.isArray(inlineMesh)) return false;
+  if (!Array.isArray(inlineMesh.nodes) || inlineMesh.nodes.length === 0) return false;
+  return inlineMesh.nodes.some((node) => hasInlineMeshTransientNodeState(node));
 }
 function readInlineMeshNodeId(node) {
   return readStringValue(node?.id, node?.nodeId) || "";
@@ -24079,6 +24112,109 @@ function toIsoTimestamp(value) {
   const stringValue = readStringValue(value);
   return stringValue || null;
 }
+function synthesizeMeshNodeFreshnessFromConnection(status) {
+  const connection = readObjectRecord(status.connection);
+  const connectionFreshAt = toIsoTimestamp(connection.lastCommandAt ?? connection.lastConnectedAt ?? connection.lastStateChangeAt);
+  const git = readObjectRecord(status.git);
+  const gitCheckedAt = toIsoTimestamp(git.lastCheckedAt);
+  if (!status.lastSeenAt && connectionFreshAt) status.lastSeenAt = connectionFreshAt;
+  if (!status.updatedAt && (gitCheckedAt || connectionFreshAt)) {
+    status.updatedAt = gitCheckedAt ?? connectionFreshAt;
+  }
+}
+function finalizeMeshNodeStatus(args) {
+  const { status, node, daemonId, isSelfNode } = args;
+  if (!readStringValue(status.machineStatus)) {
+    const cachedStatus = readObjectRecord(node?.cachedStatus);
+    const machineStatus = readStringValue(cachedStatus.machineStatus, cachedStatus.machine_status, node?.machineStatus);
+    if (machineStatus) status.machineStatus = machineStatus;
+  }
+  synthesizeMeshNodeFreshnessFromConnection(status);
+  const connectionState = readStringValue(readObjectRecord(status.connection).state);
+  status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || connectionState === "connected" || isSelfNode);
+}
+async function probeRemoteMeshGitStatus(args) {
+  if (!args.dispatchMeshCommand) return null;
+  const remoteResult = await Promise.race([
+    args.dispatchMeshCommand(args.daemonId, "git_status", { workspace: args.workspace }),
+    new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), args.timeoutMs))
+  ]);
+  const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
+  return remoteGit && typeof remoteGit === "object" && typeof remoteGit.isGitRepo === "boolean" ? remoteGit : null;
+}
+async function hydrateInlineMeshDirectTruth(args) {
+  const nodes = Array.isArray(args.mesh?.nodes) ? args.mesh.nodes : [];
+  if (!nodes.length) {
+    return {
+      directEvidenceCount: 0,
+      localConfirmedCount: 0,
+      peerAttemptedCount: 0,
+      peerConfirmedCount: 0,
+      unavailableNodeIds: []
+    };
+  }
+  const selectedCoordinatorNodeId = readStringValue(
+    args.mesh?.coordinator?.preferredNodeId,
+    nodes[0]?.id,
+    nodes[0]?.nodeId
+  );
+  let localConfirmedCount = 0;
+  let peerAttemptedCount = 0;
+  let peerConfirmedCount = 0;
+  const unavailableNodeIds = [];
+  for (const [nodeIndex, node] of nodes.entries()) {
+    const nodeId = readStringValue(node?.id, node?.nodeId) || `node_${nodeIndex}`;
+    const workspace = readStringValue(node?.workspace);
+    const daemonId = readStringValue(node?.daemonId);
+    const isSelfNode = Boolean(
+      nodeId && selectedCoordinatorNodeId && nodeId === selectedCoordinatorNodeId
+    ) || Boolean(
+      daemonId && (daemonId === args.localMachineId || daemonId === args.statusInstanceId)
+    ) || Boolean(args.meshSource !== "local_config" && nodeIndex === 0);
+    if (!workspace) {
+      if (!isSelfNode && daemonId) unavailableNodeIds.push(nodeId);
+      continue;
+    }
+    if (isSelfNode && fs10.existsSync(workspace)) {
+      try {
+        const localGit = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+        if (localGit?.isGitRepo) {
+          recordInlineMeshDirectGitTruth(node, localGit, "selected_coordinator_local_git");
+          localConfirmedCount += 1;
+          continue;
+        }
+      } catch {
+      }
+    }
+    if (!daemonId || !args.dispatchMeshCommand) {
+      if (!isSelfNode) unavailableNodeIds.push(nodeId);
+      continue;
+    }
+    peerAttemptedCount += 1;
+    try {
+      const remoteGit = await probeRemoteMeshGitStatus({
+        dispatchMeshCommand: args.dispatchMeshCommand,
+        daemonId,
+        workspace,
+        timeoutMs: 8e3
+      });
+      if (remoteGit) {
+        recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+        peerConfirmedCount += 1;
+        continue;
+      }
+    } catch {
+    }
+    unavailableNodeIds.push(nodeId);
+  }
+  return {
+    directEvidenceCount: localConfirmedCount + peerConfirmedCount,
+    localConfirmedCount,
+    peerAttemptedCount,
+    peerConfirmedCount,
+    unavailableNodeIds
+  };
+}
 function summarizeMeshSessionRecord(record) {
   return {
     sessionId: readStringValue(record?.sessionId) || "unknown",
@@ -24581,8 +24717,10 @@ var DaemonCommandRouter = class {
     if (preferInline) {
       const cached2 = this.getCachedInlineMesh(meshId);
       if (cached2) return { mesh: cached2, inline: true, source: "inline_cache" };
-      const warmedInline2 = this.warmInlineMeshCache(meshId, inlineMesh);
-      if (warmedInline2) return { mesh: warmedInline2, inline: true, source: "inline_bootstrap" };
+      if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
+        this.warmInlineMeshCache(meshId, inlineMesh);
+        return { mesh: inlineMesh, inline: true, source: "inline_bootstrap" };
+      }
     }
     try {
       const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
@@ -25590,8 +25728,38 @@ var DaemonCommandRouter = class {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
         const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-        if (meshRecord?.mesh) return { success: true, mesh: meshRecord.mesh };
-        return { success: false, error: "Mesh not found" };
+        if (!meshRecord?.mesh) return { success: false, error: "Mesh not found" };
+        const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+        const directTruth = await hydrateInlineMeshDirectTruth({
+          mesh: meshRecord.mesh,
+          meshSource: meshRecord.source,
+          dispatchMeshCommand: this.deps.dispatchMeshCommand,
+          statusInstanceId: this.deps.statusInstanceId,
+          localMachineId: loadConfig().machineId || ""
+        });
+        const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
+        const sourceOfTruth = {
+          membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+          coordinatorOwnsLiveTruth: directTruthSatisfied,
+          directPeerTruth: {
+            required: requireDirectPeerTruth,
+            satisfied: directTruthSatisfied,
+            directEvidenceCount: directTruth.directEvidenceCount,
+            localConfirmedCount: directTruth.localConfirmedCount,
+            peerAttemptedCount: directTruth.peerAttemptedCount,
+            peerConfirmedCount: directTruth.peerConfirmedCount,
+            unavailableNodeIds: directTruth.unavailableNodeIds
+          }
+        };
+        if (requireDirectPeerTruth && !directTruthSatisfied) {
+          return {
+            success: false,
+            code: "mesh_direct_peer_truth_unavailable",
+            error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct get_mesh probes succeed.",
+            sourceOfTruth
+          };
+        }
+        return { success: true, mesh: meshRecord.mesh, sourceOfTruth };
       }
       case "create_mesh": {
         const name = typeof args?.name === "string" ? args.name.trim() : "";
@@ -26519,25 +26687,51 @@ ${block}`);
             }
             if (workspace) {
               if (!fs10.existsSync(workspace)) {
+                const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
                 let remoteProbeApplied = false;
-                if (!isSelfNode && daemonId && this.deps.dispatchMeshCommand) {
+                if (inlineTransitGit) {
+                  status.git = inlineTransitGit;
+                  status.health = inlineTransitGit.isGitRepo ? deriveMeshNodeHealthFromGit(inlineTransitGit) : "degraded";
+                  remoteProbeApplied = true;
+                } else if (!isSelfNode && daemonId && this.deps.dispatchMeshCommand) {
                   try {
-                    const remoteResult = await Promise.race([
-                      this.deps.dispatchMeshCommand(daemonId, "git_status", { workspace }),
-                      new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 8e3))
-                    ]);
-                    const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
-                    if (remoteGit && typeof remoteGit === "object" && typeof remoteGit.isGitRepo === "boolean") {
+                    const remoteGit = await probeRemoteMeshGitStatus({
+                      dispatchMeshCommand: this.deps.dispatchMeshCommand,
+                      daemonId,
+                      workspace,
+                      timeoutMs: 8e3
+                    });
+                    if (remoteGit) {
                       status.git = remoteGit;
                       status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
+                      recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
                       remoteProbeApplied = true;
                     }
                   } catch {
+                    const refreshedConnection = this.deps.getMeshPeerConnectionStatus?.(daemonId);
+                    const refreshedConnectionState = readStringValue(refreshedConnection?.state);
+                    if (refreshedConnection && refreshedConnectionState === "connected") {
+                      status.connection = refreshedConnection;
+                      try {
+                        const remoteGit = await probeRemoteMeshGitStatus({
+                          dispatchMeshCommand: this.deps.dispatchMeshCommand,
+                          daemonId,
+                          workspace,
+                          timeoutMs: 12e3
+                        });
+                        if (remoteGit) {
+                          status.git = remoteGit;
+                          status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
+                          recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+                          remoteProbeApplied = true;
+                        }
+                      } catch {
+                      }
+                    }
                   }
                 }
                 if (!remoteProbeApplied) {
                   const connectionState = readStringValue(status.connection?.state);
-                  const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
                   const pendingPeerGitProbe = !inlineTransitGit && !isSelfNode && !!daemonId && (readStringValue(status.machineStatus) === "online" || readStringValue(status.health) === "online" || connectionState === "connecting" || connectionState === "connected" || connectionState === "unknown");
                   if (pendingPeerGitProbe) {
                     status.gitProbePending = true;
@@ -26548,12 +26742,12 @@ ${block}`);
                     node,
                     pendingPeerGitProbe ? { skipGit: true, skipError: true, skipHealth: true } : void 0
                   )) {
-                    status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
                     nodeStatuses.push(status);
                     continue;
                   }
                   if (meshRecord?.source === "inline_cache" && !isSelfNode) {
-                    status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
                     nodeStatuses.push(status);
                     continue;
                   }
@@ -26562,6 +26756,7 @@ ${block}`);
                 try {
                   const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
                   status.git = gitStatus;
+                  recordInlineMeshDirectGitTruth(node, gitStatus, "selected_coordinator_local_git");
                   if (gitStatus.isGitRepo) {
                     status.health = deriveMeshNodeHealthFromGit(gitStatus);
                   } else {
@@ -26577,7 +26772,7 @@ ${block}`);
             } else {
               applyCachedInlineMeshNodeStatus(status, node);
             }
-            status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+            finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
             nodeStatuses.push(status);
           }
           return {