@adhdev/daemon-core 0.9.82-rc.304 → 0.9.82-rc.306

package/dist/index.mjs

@@ -290,10 +290,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "1d8f7eabac25d169c6344185357519db0c0ffd13" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "1d8f7eab" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.304" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-17T05:27:03.554Z" : void 0);
+  const commit = readInjected(true ? "6ded896662908225a48ad662b6eec83267dbe9ba" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "6ded8966" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.306" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-17T07:21:37.675Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -4529,6 +4529,110 @@ var init_mesh_runtime_store = __esm({
   }
 });
 
+// src/mesh/mesh-task-stats.ts
+function readPayloadTaskId(entry) {
+  const value = entry.payload?.taskId;
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+function parseTime(value) {
+  if (!value) return null;
+  const parsed = new Date(value).getTime();
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function computeMeshTaskStats(meshId, opts) {
+  const queue = getQueue(meshId);
+  const queueById = new Map(queue.map((task) => [task.id, task]));
+  let targetIds;
+  if (opts?.taskIds?.length) {
+    targetIds = [...new Set(opts.taskIds)];
+  } else if (opts?.missionId) {
+    targetIds = queue.filter((task) => task.missionId === opts.missionId).map((task) => task.id);
+  } else {
+    targetIds = queue.map((task) => task.id);
+  }
+  if (targetIds.length === 0) return [];
+  const targetSet = new Set(targetIds);
+  const entries = readLedgerEntries(meshId, { tail: opts?.tail ?? 1e3 });
+  const dispatches = /* @__PURE__ */ new Map();
+  const terminals = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const taskId = readPayloadTaskId(entry);
+    if (!taskId || !targetSet.has(taskId)) continue;
+    if (entry.kind === "task_dispatched") {
+      const existing = dispatches.get(taskId);
+      if (existing) existing.count += 1;
+      else dispatches.set(taskId, { first: entry.timestamp, count: 1 });
+    } else if (entry.kind === "task_completed" || entry.kind === "task_failed") {
+      terminals.set(taskId, { at: entry.timestamp, kind: entry.kind });
+    }
+  }
+  return targetIds.map((taskId) => {
+    const queueEntry = queueById.get(taskId);
+    const status = queueEntry?.status ?? "unknown";
+    const dispatch = dispatches.get(taskId);
+    const terminal = terminals.get(taskId);
+    const isTerminalStatus = status === "completed" || status === "failed" || status === "cancelled";
+    const dispatchTime = parseTime(dispatch?.first ?? queueEntry?.dispatchTimestamp);
+    const terminalTime = parseTime(terminal?.at);
+    const stats = {
+      taskId,
+      status,
+      dispatchedAt: dispatch?.first ?? queueEntry?.dispatchTimestamp ?? null,
+      terminalAt: terminal?.at ?? null,
+      terminalKind: terminal?.kind ?? null,
+      durationMs: null,
+      dispatchCount: dispatch?.count ?? 0,
+      requeueCount: queueEntry?.requeueCount ?? 0
+    };
+    if (dispatchTime !== null && terminalTime !== null && terminalTime >= dispatchTime) {
+      stats.durationMs = terminalTime - dispatchTime;
+    } else if (isTerminalStatus) {
+      stats.incompleteEvidence = true;
+    }
+    return stats;
+  });
+}
+function computeMeshMissionStats(meshId, missionId) {
+  const tasks = computeMeshTaskStats(meshId, { missionId });
+  const stats = {
+    missionId,
+    taskCount: tasks.length,
+    completed: 0,
+    failed: 0,
+    totalDurationMs: 0,
+    wallClockMs: null,
+    retries: 0,
+    incompleteTaskIds: []
+  };
+  let firstDispatch = null;
+  let lastTerminal = null;
+  for (const task of tasks) {
+    if (task.status === "completed") stats.completed += 1;
+    else if (task.status === "failed") stats.failed += 1;
+    stats.retries += task.requeueCount;
+    if (task.incompleteEvidence) {
+      stats.incompleteTaskIds.push(task.taskId);
+      continue;
+    }
+    if (task.durationMs !== null) stats.totalDurationMs += task.durationMs;
+    const dispatchTime = parseTime(task.dispatchedAt);
+    const terminalTime = parseTime(task.terminalAt);
+    if (dispatchTime !== null && (firstDispatch === null || dispatchTime < firstDispatch)) firstDispatch = dispatchTime;
+    if (terminalTime !== null && (lastTerminal === null || terminalTime > lastTerminal)) lastTerminal = terminalTime;
+  }
+  if (firstDispatch !== null && lastTerminal !== null && lastTerminal >= firstDispatch) {
+    stats.wallClockMs = lastTerminal - firstDispatch;
+  }
+  return stats;
+}
+var init_mesh_task_stats = __esm({
+  "src/mesh/mesh-task-stats.ts"() {
+    "use strict";
+    init_mesh_ledger();
+    init_mesh_work_queue();
+  }
+});
+
 // src/mesh/mesh-missions.ts
 var mesh_missions_exports = {};
 __export(mesh_missions_exports, {
@@ -4621,7 +4725,10 @@ function getMeshStatusMissionSummaries(meshId, options) {
   const all = getMeshMissions(meshId);
   const live = all.filter((m) => m.status === "active" || m.status === "paused");
   const history = all.filter((m) => m.status === "completed" || m.status === "abandoned").sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || "")).slice(0, historyLimit);
-  const full = [...live, ...history].map((mission) => summarizeMeshMission(meshId, mission));
+  let full = [...live, ...history].map((mission) => summarizeMeshMission(meshId, mission));
+  if (options?.withStats) {
+    full = full.map((summary) => ({ ...summary, stats: computeMeshMissionStats(meshId, summary.id) }));
+  }
   return options?.verbose ? full : full.map(slimMissionSummary);
 }
 function listMeshMissionSummaries(meshId, options) {
@@ -4654,6 +4761,7 @@ var init_mesh_missions = __esm({
     "use strict";
     init_mesh_runtime_store();
     init_mesh_work_queue();
+    init_mesh_task_stats();
     MESH_MISSION_STATUSES = ["active", "paused", "completed", "abandoned"];
     GOAL_PREVIEW_MAX = 120;
   }
@@ -17003,107 +17111,7 @@ function getSavedProviderSessions(state, filters) {
 init_mesh_config();
 init_coordinator_prompt();
 init_mesh_missions();
-
-// src/mesh/mesh-task-stats.ts
-init_mesh_ledger();
-init_mesh_work_queue();
-function readPayloadTaskId(entry) {
-  const value = entry.payload?.taskId;
-  return typeof value === "string" && value.trim() ? value.trim() : "";
-}
-function parseTime(value) {
-  if (!value) return null;
-  const parsed = new Date(value).getTime();
-  return Number.isFinite(parsed) ? parsed : null;
-}
-function computeMeshTaskStats(meshId, opts) {
-  const queue = getQueue(meshId);
-  const queueById = new Map(queue.map((task) => [task.id, task]));
-  let targetIds;
-  if (opts?.taskIds?.length) {
-    targetIds = [...new Set(opts.taskIds)];
-  } else if (opts?.missionId) {
-    targetIds = queue.filter((task) => task.missionId === opts.missionId).map((task) => task.id);
-  } else {
-    targetIds = queue.map((task) => task.id);
-  }
-  if (targetIds.length === 0) return [];
-  const targetSet = new Set(targetIds);
-  const entries = readLedgerEntries(meshId, { tail: opts?.tail ?? 1e3 });
-  const dispatches = /* @__PURE__ */ new Map();
-  const terminals = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const taskId = readPayloadTaskId(entry);
-    if (!taskId || !targetSet.has(taskId)) continue;
-    if (entry.kind === "task_dispatched") {
-      const existing = dispatches.get(taskId);
-      if (existing) existing.count += 1;
-      else dispatches.set(taskId, { first: entry.timestamp, count: 1 });
-    } else if (entry.kind === "task_completed" || entry.kind === "task_failed") {
-      terminals.set(taskId, { at: entry.timestamp, kind: entry.kind });
-    }
-  }
-  return targetIds.map((taskId) => {
-    const queueEntry = queueById.get(taskId);
-    const status = queueEntry?.status ?? "unknown";
-    const dispatch = dispatches.get(taskId);
-    const terminal = terminals.get(taskId);
-    const isTerminalStatus = status === "completed" || status === "failed" || status === "cancelled";
-    const dispatchTime = parseTime(dispatch?.first ?? queueEntry?.dispatchTimestamp);
-    const terminalTime = parseTime(terminal?.at);
-    const stats = {
-      taskId,
-      status,
-      dispatchedAt: dispatch?.first ?? queueEntry?.dispatchTimestamp ?? null,
-      terminalAt: terminal?.at ?? null,
-      terminalKind: terminal?.kind ?? null,
-      durationMs: null,
-      dispatchCount: dispatch?.count ?? 0,
-      requeueCount: queueEntry?.requeueCount ?? 0
-    };
-    if (dispatchTime !== null && terminalTime !== null && terminalTime >= dispatchTime) {
-      stats.durationMs = terminalTime - dispatchTime;
-    } else if (isTerminalStatus) {
-      stats.incompleteEvidence = true;
-    }
-    return stats;
-  });
-}
-function computeMeshMissionStats(meshId, missionId) {
-  const tasks = computeMeshTaskStats(meshId, { missionId });
-  const stats = {
-    missionId,
-    taskCount: tasks.length,
-    completed: 0,
-    failed: 0,
-    totalDurationMs: 0,
-    wallClockMs: null,
-    retries: 0,
-    incompleteTaskIds: []
-  };
-  let firstDispatch = null;
-  let lastTerminal = null;
-  for (const task of tasks) {
-    if (task.status === "completed") stats.completed += 1;
-    else if (task.status === "failed") stats.failed += 1;
-    stats.retries += task.requeueCount;
-    if (task.incompleteEvidence) {
-      stats.incompleteTaskIds.push(task.taskId);
-      continue;
-    }
-    if (task.durationMs !== null) stats.totalDurationMs += task.durationMs;
-    const dispatchTime = parseTime(task.dispatchedAt);
-    const terminalTime = parseTime(task.terminalAt);
-    if (dispatchTime !== null && (firstDispatch === null || dispatchTime < firstDispatch)) firstDispatch = dispatchTime;
-    if (terminalTime !== null && (lastTerminal === null || terminalTime > lastTerminal)) lastTerminal = terminalTime;
-  }
-  if (firstDispatch !== null && lastTerminal !== null && lastTerminal >= firstDispatch) {
-    stats.wallClockMs = lastTerminal - firstDispatch;
-  }
-  return stats;
-}
-
-// src/index.ts
+init_mesh_task_stats();
 init_mesh_review_inbox();
 
 // src/mesh/coordinator-registry.ts
@@ -42004,6 +42012,31 @@ async function probeRemoteMeshGitStatus(args) {
   const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
   return remoteGit && typeof remoteGit === "object" && typeof remoteGit.isGitRepo === "boolean" ? remoteGit : null;
 }
+var MESH_DIRECT_PROBE_MAX_RETRIES = 2;
+function readMeshConnectionState(connection) {
+  return readStringValue(connection?.state);
+}
+async function probeRemoteMeshGitStatusWithRetry(args) {
+  for (let attempt = 0; attempt <= MESH_DIRECT_PROBE_MAX_RETRIES; attempt += 1) {
+    if (attempt > 0) {
+      const connection = args.getConnection?.(args.daemonId);
+      if (args.getConnection && readMeshConnectionState(connection) !== "connected") break;
+      if (connection) args.onConnection?.(connection);
+      await new Promise((resolve24) => setTimeout(resolve24, 250 * 2 ** (attempt - 1)));
+    }
+    try {
+      const remoteGit = await probeRemoteMeshGitStatus({
+        dispatchMeshCommand: args.dispatchMeshCommand,
+        daemonId: args.daemonId,
+        workspace: args.workspace,
+        timeoutMs: attempt === 0 ? args.timeoutMs : args.retryTimeoutMs ?? args.timeoutMs
+      });
+      if (remoteGit) return remoteGit;
+    } catch {
+    }
+  }
+  return null;
+}
 async function hydrateInlineMeshDirectTruth(args) {
   const nodes = Array.isArray(args.mesh?.nodes) ? args.mesh.nodes : [];
   if (!nodes.length) {
@@ -42012,6 +42045,7 @@ async function hydrateInlineMeshDirectTruth(args) {
       localConfirmedCount: 0,
       peerAttemptedCount: 0,
       peerConfirmedCount: 0,
+      standingEvidenceCount: 0,
       unavailableNodeIds: []
     };
   }
@@ -42023,6 +42057,7 @@ async function hydrateInlineMeshDirectTruth(args) {
   let localConfirmedCount = 0;
   let peerAttemptedCount = 0;
   let peerConfirmedCount = 0;
+  let standingEvidenceCount = 0;
   const unavailableNodeIds = [];
   for (const [nodeIndex, node] of nodes.entries()) {
     const nodeId = normalizeMeshNodeId(node) || `node_${nodeIndex}`;
@@ -42048,32 +42083,40 @@ async function hydrateInlineMeshDirectTruth(args) {
       } catch {
       }
     }
+    const standingGit = buildInlineMeshTransitGitStatus(node);
+    if (standingGit) {
+      standingEvidenceCount += 1;
+      continue;
+    }
+    if (!args.probeRemotePeers) {
+      continue;
+    }
     if (!daemonId || !args.dispatchMeshCommand) {
       if (!isSelfNode) unavailableNodeIds.push(nodeId);
       continue;
     }
     peerAttemptedCount += 1;
-    try {
-      const remoteGit = await probeRemoteMeshGitStatus({
-        dispatchMeshCommand: args.dispatchMeshCommand,
-        daemonId,
-        workspace,
-        timeoutMs: MESH_DIRECT_PROBE_TIMEOUT_MS
-      });
-      if (remoteGit) {
-        recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
-        peerConfirmedCount += 1;
-        continue;
-      }
-    } catch {
+    const remoteGit = await probeRemoteMeshGitStatusWithRetry({
+      dispatchMeshCommand: args.dispatchMeshCommand,
+      daemonId,
+      workspace,
+      timeoutMs: MESH_DIRECT_PROBE_TIMEOUT_MS,
+      retryTimeoutMs: MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS,
+      getConnection: args.getMeshPeerConnectionStatus
+    });
+    if (remoteGit) {
+      recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+      peerConfirmedCount += 1;
+      continue;
     }
     unavailableNodeIds.push(nodeId);
   }
   return {
-    directEvidenceCount: localConfirmedCount + peerConfirmedCount,
+    directEvidenceCount: localConfirmedCount + peerConfirmedCount + standingEvidenceCount,
     localConfirmedCount,
     peerAttemptedCount,
     peerConfirmedCount,
+    standingEvidenceCount,
     unavailableNodeIds
   };
 }
@@ -46277,12 +46320,15 @@ ${hintLines.join("\n")}` : "",
         const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
         if (!meshRecord?.mesh) return { success: false, error: "Mesh not found" };
         const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+        const probeRemotePeers = args?.refresh === true || args?.forceRefresh === true;
         const directTruth = await hydrateInlineMeshDirectTruth({
           mesh: meshRecord.mesh,
           meshSource: meshRecord.source,
           dispatchMeshCommand: this.deps.dispatchMeshCommand,
+          getMeshPeerConnectionStatus: this.deps.getMeshPeerConnectionStatus,
           statusInstanceId: this.deps.statusInstanceId,
-          localMachineId: loadConfig().machineId || ""
+          localMachineId: loadConfig().machineId || "",
+          probeRemotePeers
         });
         const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
         const sourceOfTruth = {
@@ -47862,21 +47908,27 @@ ${ptyResult.output.slice(-2e3)}`);
             mesh,
             meshSource: meshRecord.source,
             dispatchMeshCommand: this.deps.dispatchMeshCommand,
+            getMeshPeerConnectionStatus: this.deps.getMeshPeerConnectionStatus,
             statusInstanceId: this.deps.statusInstanceId,
-            localMachineId
+            localMachineId,
+            // Standing-state model: only an explicit refresh fans
+            // out a blocking peer git probe. Default loads return
+            // held truth so one slow peer can't block the graph.
+            probeRemotePeers: refreshRequested
           }) : {
             directEvidenceCount: 0,
             localConfirmedCount: 0,
             peerAttemptedCount: 0,
             peerConfirmedCount: 0,
+            standingEvidenceCount: 0,
             unavailableNodeIds: []
           };
           const passivePeerTruthNotAttempted = requireDirectPeerTruth && !refreshRequested && directTruth.directEvidenceCount > 0 && directTruth.peerAttemptedCount === 0;
           const effectiveDirectTruth = passivePeerTruthNotAttempted ? { ...directTruth, unavailableNodeIds: [] } : directTruth;
           const unavailableDirectTruthNodeIds = new Set(effectiveDirectTruth.unavailableNodeIds);
           const unavailableNodesAreOnlyRemovedWorktrees = unavailableDirectTruthNodeIds.size > 0 && Array.isArray(mesh.nodes) && mesh.nodes.filter((node) => unavailableDirectTruthNodeIds.has(normalizeMeshNodeId(node) ?? "")).every((node) => node?.isLocalWorktree === true);
-          const directTruthSatisfied = !requireDirectPeerTruth || effectiveDirectTruth.directEvidenceCount > 0 && (effectiveDirectTruth.unavailableNodeIds.length === 0 || unavailableNodesAreOnlyRemovedWorktrees);
-          if (requireDirectPeerTruth && !directTruthSatisfied) {
+          const directTruthSatisfied = !requireDirectPeerTruth || !refreshRequested || effectiveDirectTruth.directEvidenceCount > 0 && (effectiveDirectTruth.unavailableNodeIds.length === 0 || unavailableNodesAreOnlyRemovedWorktrees);
+          if (requireDirectPeerTruth && refreshRequested && !directTruthSatisfied) {
             const failureResult = {
               success: false,
               code: "mesh_direct_peer_truth_unavailable",
@@ -48022,53 +48074,29 @@ ${ptyResult.output.slice(-2e3)}`);
                     status.connection = buildLivePeerGitConnection(connection, refreshedAt);
                   }
                   remoteProbeApplied = true;
-                } else if (!isSelfNode && daemonId && this.deps.dispatchMeshCommand && !directTruthUnavailableNodeIds.has(nodeId)) {
-                  try {
-                    const remoteGit = await probeRemoteMeshGitStatus({
-                      dispatchMeshCommand: this.deps.dispatchMeshCommand,
-                      daemonId,
-                      workspace,
-                      timeoutMs: MESH_DIRECT_PROBE_TIMEOUT_MS
-                    });
-                    if (remoteGit) {
-                      status.git = remoteGit;
-                      status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
-                      const connection = readObjectRecord(status.connection);
-                      const connectionState = readStringValue(connection.state);
-                      const connectionReported = readBooleanValue(connection.reported) ?? false;
-                      if (!connectionReported || connectionState === "unknown") {
-                        status.connection = buildLivePeerGitConnection(connection, refreshedAt);
-                      }
-                      recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
-                      remoteProbeApplied = true;
+                } else if (refreshRequested && !isSelfNode && daemonId && this.deps.dispatchMeshCommand && !directTruthUnavailableNodeIds.has(nodeId)) {
+                  const remoteGit = await probeRemoteMeshGitStatusWithRetry({
+                    dispatchMeshCommand: this.deps.dispatchMeshCommand,
+                    daemonId,
+                    workspace,
+                    timeoutMs: MESH_DIRECT_PROBE_TIMEOUT_MS,
+                    retryTimeoutMs: MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS,
+                    getConnection: this.deps.getMeshPeerConnectionStatus,
+                    onConnection: (connection) => {
+                      status.connection = connection;
                     }
-                  } 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: MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS
-                        });
-                        if (remoteGit) {
-                          status.git = remoteGit;
-                          status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
-                          const connection = readObjectRecord(status.connection);
-                          const connectionState = readStringValue(connection.state);
-                          const connectionReported = readBooleanValue(connection.reported) ?? false;
-                          if (!connectionReported || connectionState === "unknown") {
-                            status.connection = buildLivePeerGitConnection(connection, refreshedAt);
-                          }
-                          recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
-                          remoteProbeApplied = true;
-                        }
-                      } catch {
-                      }
+                  });
+                  if (remoteGit) {
+                    status.git = remoteGit;
+                    status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
+                    const connection = readObjectRecord(status.connection);
+                    const connectionState = readStringValue(connection.state);
+                    const connectionReported = readBooleanValue(connection.reported) ?? false;
+                    if (!connectionReported || connectionState === "unknown") {
+                      status.connection = buildLivePeerGitConnection(connection, refreshedAt);
                     }
+                    recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+                    remoteProbeApplied = true;
                   }
                 }
                 if (!remoteProbeApplied) {
@@ -48137,7 +48165,7 @@ ${ptyResult.output.slice(-2e3)}`);
             liveSessionRecords: liveMeshSessions
           });
           const { getMeshStatusMissionSummaries: getMeshStatusMissionSummaries2 } = await Promise.resolve().then(() => (init_mesh_missions(), mesh_missions_exports));
-          const missions = getMeshStatusMissionSummaries2(meshId, { verbose: verboseMissions });
+          const missions = getMeshStatusMissionSummaries2(meshId, { verbose: verboseMissions, withStats: true });
           const statusResult = {
             success: true,
             meshId: mesh.id,