@adhdev/daemon-standalone 0.9.82-rc.30 → 0.9.82-rc.31

package/dist/index.js

@@ -46052,13 +46052,21 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       }
       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,
@@ -46078,10 +46086,11 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       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,
@@ -46114,6 +46123,26 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       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;
@@ -46156,7 +46185,6 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         session_id: _sessionIdLegacy,
         providerType: _providerType,
         provider_type: _providerTypeLegacy,
-        providers: _providers,
         ...rest
       } = node;
       if (cachedStatus && !shouldDiscardCachedInlineMeshStatus(node)) {
@@ -46166,7 +46194,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     }
     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 readInlineMeshNodeId(node) {
       return readStringValue(node?.id, node?.nodeId) || "";
@@ -46292,6 +46320,109 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       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(record2) {
       return {
         sessionId: readStringValue(record2?.sessionId) || "unknown",
@@ -47803,8 +47934,38 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             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: loadConfig2().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() : "";
@@ -48732,25 +48893,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;
@@ -48761,12 +48948,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;
                       }
@@ -48775,6 +48962,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 {
@@ -48790,7 +48978,7 @@ ${block}`);
                 } else {
                   applyCachedInlineMeshNodeStatus(status, node);
                 }
-                status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
                 nodeStatuses.push(status);
               }
               return {