adhdev 0.9.82-rc.30 → 0.9.82-rc.32

package/dist/index.js

@@ -45650,13 +45650,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 path35 = 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, path35);
     if (!path35 || !commit || !repoPath) return null;
     return {
       path: path35,
@@ -45676,10 +45684,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,
@@ -45712,6 +45721,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;
@@ -45754,7 +45783,6 @@ function stripInlineMeshTransientNodeState(node) {
     session_id: _sessionIdLegacy,
     providerType: _providerType,
     provider_type: _providerTypeLegacy,
-    providers: _providers,
     ...rest
   } = node;
   if (cachedStatus && !shouldDiscardCachedInlineMeshStatus(node)) {
@@ -45764,7 +45792,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) || "";
@@ -45890,6 +45923,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((_2, 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",
@@ -46429,8 +46565,10 @@ var init_router = __esm({
         if (preferInline) {
           const cached3 = this.getCachedInlineMesh(meshId);
           if (cached3) return { mesh: cached3, 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));
@@ -47438,8 +47576,38 @@ var init_router = __esm({
             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() : "";
@@ -48367,25 +48535,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((_2, 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;
@@ -48396,12 +48590,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;
                       }
@@ -48410,6 +48604,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 {
@@ -48425,7 +48620,7 @@ ${block}`);
                 } else {
                   applyCachedInlineMeshNodeStatus(status, node);
                 }
-                status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
                 nodeStatuses.push(status);
               }
               return {
@@ -67283,7 +67478,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.30" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.32" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;