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

package/dist/mesh/mesh-missions.d.ts

@@ -11,6 +11,7 @@
  * never stored — it is derived from queue task statuses (mission_id) at
  * query time.
  */
+import { type MeshMissionStats } from './mesh-task-stats.js';
 export type MeshMissionStatus = 'active' | 'paused' | 'completed' | 'abandoned';
 export declare const MESH_MISSION_STATUSES: MeshMissionStatus[];
 export interface MeshMissionRecord {
@@ -36,6 +37,13 @@ export interface MeshMissionTaskAggregate {
 }
 export interface MeshMissionSummary extends MeshMissionRecord {
     tasks: MeshMissionTaskAggregate;
+    /**
+     * Operational rollup (durations / attempts) derived from the ledger via
+     * computeMeshMissionStats. Optional: only populated by surfaces that opt in
+     * (e.g. mesh_status), since the rollup scans a bounded ledger tail per
+     * mission. Absent on the lightweight task-aggregate-only summaries.
+     */
+    stats?: MeshMissionStats;
 }
 /**
  * Slim mission summary for the mesh_status compact (default) surface. Drops the
@@ -83,6 +91,7 @@ export declare function getActiveMeshMissionSummaries(meshId: string): MeshMissi
 export declare function getMeshStatusMissionSummaries(meshId: string, options?: {
     historyLimit?: number;
     verbose?: boolean;
+    withStats?: boolean;
 }): MeshMissionSummary[] | MeshMissionSlimSummary[];
 /**
  * Read-only mission listing for the mesh_mission_list tool. Returns summaries

package/dist/repo-mesh-types.d.ts

@@ -11,7 +11,7 @@
  * IMPORTANT: This file must remain runtime-free (types only).
  */
 import type { GitRepoStatus, GitCompactSummary } from './git/git-types.js';
-import type { MeshMissionSummary } from './mesh/mesh-missions.js';
+import type { MeshMissionSummary, MeshMissionSlimSummary } from './mesh/mesh-missions.js';
 export interface RepoMesh {
     id: string;
     name: string;
@@ -393,8 +393,13 @@ export interface RepoMeshStatus {
      * capped, newest-first slice of completed/abandoned history. Omitted by older
      * daemons — the dashboard must treat this as optional and render an empty
      * state when absent. Split on each entry's `status` for live vs. history.
+     *
+     * Compact (the default) status calls send the slim shape — `goalPreview` +
+     * `goalTruncated` instead of the full `goal` — while verbose sends the full
+     * `goal`. Consumers must read `goal ?? goalPreview`. Each entry may also carry
+     * an optional `stats` operational rollup (durations / retries).
      */
-    missions?: MeshMissionSummary[];
+    missions?: (MeshMissionSummary | MeshMissionSlimSummary)[];
 }
 export type { RepoMeshSessionStatus } from '@adhdev/mesh-shared';
 import type { RepoMeshSessionStatus } from '@adhdev/mesh-shared';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.304",
+  "version": "0.9.82-rc.306",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.304",
+    "@adhdev/mesh-shared": "0.9.82-rc.306",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/router.ts

@@ -1003,17 +1003,83 @@ async function probeRemoteMeshGitStatus(args: {
         : null;
 }
 
+/** Number of bounded retries after the initial direct-peer git probe attempt. */
+const MESH_DIRECT_PROBE_MAX_RETRIES = 2;
+
+function readMeshConnectionState(connection: Record<string, unknown> | null | undefined): string | undefined {
+    return readStringValue((connection as any)?.state);
+}
+
+/**
+ * Probe a remote peer's git_status with a bounded retry budget, but only while
+ * the peer is reported `connected`. A single slow (often TURN-relayed) peer can
+ * exceed one probe window; retrying — with the connection re-checked before each
+ * attempt so we abandon a peer that dropped — recovers it without blocking the
+ * mesh forever. Shared by the bootstrap hydrate path and the per-node render
+ * path so both treat a connected-but-slow peer identically.
+ *
+ * Returns the git status on success, or null if every attempt failed/timed out
+ * (caller decides how to classify). `getConnection` is consulted before each
+ * attempt; a non-`connected` state short-circuits the retry loop (the very first
+ * attempt always runs so a missing connection getter still gets one try).
+ */
+async function probeRemoteMeshGitStatusWithRetry(args: {
+    dispatchMeshCommand?: (daemonId: string, cmd: string, args: Record<string, unknown>) => Promise<unknown>;
+    daemonId: string;
+    workspace: string;
+    timeoutMs: number;
+    /** Per-attempt timeout for retries (attempts > 0); defaults to timeoutMs. */
+    retryTimeoutMs?: number;
+    getConnection?: (daemonId: string) => Record<string, unknown> | null;
+    onConnection?: (connection: Record<string, unknown>) => void;
+}): Promise<Record<string, unknown> | null> {
+    for (let attempt = 0; attempt <= MESH_DIRECT_PROBE_MAX_RETRIES; attempt += 1) {
+        if (attempt > 0) {
+            // Re-check liveness before spending another probe window; a peer that
+            // dropped between attempts is not worth retrying.
+            const connection = args.getConnection?.(args.daemonId);
+            if (args.getConnection && readMeshConnectionState(connection) !== 'connected') break;
+            if (connection) args.onConnection?.(connection);
+            // Exponential backoff: 250ms, 500ms before attempts 1 and 2.
+            await new Promise(resolve => setTimeout(resolve, 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 {
+            // Timed out or P2P error — fall through to the next bounded attempt.
+        }
+    }
+    return null;
+}
+
 async function hydrateInlineMeshDirectTruth(args: {
     mesh: any;
     meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config';
     dispatchMeshCommand?: (daemonId: string, cmd: string, args: Record<string, unknown>) => Promise<unknown>;
+    getMeshPeerConnectionStatus?: (daemonId: string) => Record<string, unknown> | null;
     statusInstanceId?: string;
     localMachineId?: string;
+    // Standing-state model: the default (non-refresh) bootstrap load must NOT
+    // fan out a blocking git_status probe to every peer — a single slow
+    // (TURN-relayed) peer would time out and mark the whole mesh unavailable,
+    // blocking the graph. When false, a non-local node is satisfied from its
+    // held standing git truth (lastGit / cachedStatus reflected via mesh
+    // events) and is never pushed to unavailableNodeIds merely because no live
+    // probe was attempted. Only an explicit refresh (probeRemotePeers=true)
+    // performs the fan-out and classifies an unreachable peer as unavailable.
+    probeRemotePeers: boolean;
 }): Promise<{
     directEvidenceCount: number;
     localConfirmedCount: number;
     peerAttemptedCount: number;
     peerConfirmedCount: number;
+    standingEvidenceCount: number;
     unavailableNodeIds: string[];
 }> {
     const nodes = Array.isArray(args.mesh?.nodes) ? args.mesh.nodes : [];
@@ -1023,6 +1089,7 @@ async function hydrateInlineMeshDirectTruth(args: {
             localConfirmedCount: 0,
             peerAttemptedCount: 0,
             peerConfirmedCount: 0,
+            standingEvidenceCount: 0,
             unavailableNodeIds: [],
         };
     }
@@ -1036,6 +1103,7 @@ async function hydrateInlineMeshDirectTruth(args: {
     let localConfirmedCount = 0;
     let peerAttemptedCount = 0;
     let peerConfirmedCount = 0;
+    let standingEvidenceCount = 0;
     const unavailableNodeIds: string[] = [];
 
     for (const [nodeIndex, node] of nodes.entries()) {
@@ -1066,36 +1134,64 @@ async function hydrateInlineMeshDirectTruth(args: {
             }
         }
 
+        // Standing-state first: a non-local peer's held git truth (reflected
+        // from its self-emitted mesh events into node.lastGit / cachedStatus)
+        // counts as direct evidence without any probe. On the default load this
+        // is the ONLY thing we consult — no fan-out, so one slow peer can't
+        // block the bootstrap.
+        const standingGit = buildInlineMeshTransitGitStatus(node);
+        if (standingGit) {
+            standingEvidenceCount += 1;
+            continue;
+        }
+
+        if (!args.probeRemotePeers) {
+            // Default (non-refresh) load: a peer with no held truth yet is left
+            // pending (the per-node loop marks it gitProbePending and the graph
+            // shows setup inventory for it). It is NOT unavailable — the graph
+            // must still render. An explicit refresh will fan out and freshen it.
+            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 {
-            // Strict direct-only path: do not fall back to persisted cloud truth here.
+        // Bounded retry, gated on the peer staying `connected`: a slow
+        // (TURN-relayed) peer that just exceeds one probe window is recovered
+        // instead of being hard-failed. The connection is re-checked before each
+        // retry so a peer that actually dropped is abandoned promptly.
+        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;
         }
 
+        // Invariant: a connected peer that still holds standing git truth is
+        // never classified unavailable (standingGit short-circuited above, so by
+        // here there is no held truth). Only push to unavailable when the peer is
+        // not currently connected, or it is connected but every bounded probe
+        // failed — that is the genuine "connected, no truth, retries exhausted"
+        // case that drives the explicit-refresh hard-fail.
         unavailableNodeIds.push(nodeId);
     }
 
     return {
-        directEvidenceCount: localConfirmedCount + peerConfirmedCount,
+        directEvidenceCount: localConfirmedCount + peerConfirmedCount + standingEvidenceCount,
         localConfirmedCount,
         peerAttemptedCount,
         peerConfirmedCount,
+        standingEvidenceCount,
         unavailableNodeIds,
     };
 }
@@ -6504,12 +6600,17 @@ export class DaemonCommandRouter {
                 if (!meshRecord?.mesh) return { success: false, error: 'Mesh not found' };
 
                 const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+                // Only an explicit refresh fans out a blocking peer probe.
+                // Default loads are satisfied from held standing-state git truth.
+                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 || '',
+                    probeRemotePeers,
                 });
                 const directTruthSatisfied = meshRecord.source !== 'inline_bootstrap' || directTruth.directEvidenceCount > 0;
                 const sourceOfTruth = {
@@ -8396,14 +8497,20 @@ export class DaemonCommandRouter {
                             mesh,
                             meshSource: meshRecord.source,
                             dispatchMeshCommand: this.deps.dispatchMeshCommand,
+                            getMeshPeerConnectionStatus: this.deps.getMeshPeerConnectionStatus,
                             statusInstanceId: this.deps.statusInstanceId,
                             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: [] as string[],
                         };
                     // Default/cached loads may not attempt a remote peer probe yet; do not surface that as
@@ -8421,9 +8528,15 @@ export class DaemonCommandRouter {
                         && mesh.nodes
                             .filter((node: any) => unavailableDirectTruthNodeIds.has(normalizeMeshNodeId(node) ?? ''))
                             .every((node: any) => node?.isLocalWorktree === true);
+                    // Default (non-refresh) loads never hard-fail: held
+                    // standing-state truth is returned and the graph renders
+                    // immediately. The hard mesh_direct_peer_truth_unavailable
+                    // failure is reserved for an explicit refresh that actually
+                    // attempted a peer probe and could not confirm any evidence.
                     const directTruthSatisfied = !requireDirectPeerTruth
+                        || !refreshRequested
                         || (effectiveDirectTruth.directEvidenceCount > 0 && (effectiveDirectTruth.unavailableNodeIds.length === 0 || unavailableNodesAreOnlyRemovedWorktrees));
-                    if (requireDirectPeerTruth && !directTruthSatisfied) {
+                    if (requireDirectPeerTruth && refreshRequested && !directTruthSatisfied) {
                         const failureResult = {
                             success: false,
                             code: 'mesh_direct_peer_truth_unavailable',
@@ -8588,58 +8701,37 @@ export class DaemonCommandRouter {
                                         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 as unknown as Record<string, unknown>)
-                                                : '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 {
-                                        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 as unknown as Record<string, unknown>)
-                                                        : '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 {
-                                                // Probe timed out again or P2P unavailable — fall back to cached status
-                                            }
+                                } else if (refreshRequested && !isSelfNode && daemonId && this.deps.dispatchMeshCommand && !directTruthUnavailableNodeIds.has(nodeId)) {
+                                    // Only an explicit refresh fans out a blocking
+                                    // per-node git probe. On the default load a peer
+                                    // with no held truth falls through to
+                                    // gitProbePending below — the graph still renders.
+                                    // Bounded retry (shared with the bootstrap hydrate
+                                    // path), gated on the peer staying connected, so a
+                                    // slow TURN-relayed peer is recovered rather than
+                                    // dropped after a single timeout.
+                                    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; },
+                                    });
+                                    if (remoteGit) {
+                                        status.git = remoteGit;
+                                        status.health = remoteGit.isGitRepo
+                                            ? deriveMeshNodeHealthFromGit(remoteGit as unknown as Record<string, unknown>)
+                                            : '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) {
@@ -8730,7 +8822,12 @@ export class DaemonCommandRouter {
                         liveSessionRecords: liveMeshSessions,
                     });
                     const { getMeshStatusMissionSummaries } = await import('../mesh/mesh-missions.js');
-                    const missions = getMeshStatusMissionSummaries(meshId, { verbose: verboseMissions });
+                    // withStats opts in to per-mission operational rollups (durations /
+                    // retries) for the dashboard mission detail. The rollup scans a
+                    // bounded ledger tail per mission, but only over the bounded set
+                    // returned here (live + capped history), so the cost stays linear
+                    // in visible missions rather than the whole mesh history.
+                    const missions = getMeshStatusMissionSummaries(meshId, { verbose: verboseMissions, withStats: true });
                     const statusResult = {
                         success: true,
                         meshId: mesh.id,

package/src/mesh/mesh-missions.ts

@@ -15,6 +15,7 @@
 import { randomUUID } from 'crypto';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { getQueue } from './mesh-work-queue.js';
+import { computeMeshMissionStats, type MeshMissionStats } from './mesh-task-stats.js';
 
 export type MeshMissionStatus = 'active' | 'paused' | 'completed' | 'abandoned';
 
@@ -45,6 +46,13 @@ export interface MeshMissionTaskAggregate {
 
 export interface MeshMissionSummary extends MeshMissionRecord {
     tasks: MeshMissionTaskAggregate;
+    /**
+     * Operational rollup (durations / attempts) derived from the ledger via
+     * computeMeshMissionStats. Optional: only populated by surfaces that opt in
+     * (e.g. mesh_status), since the rollup scans a bounded ledger tail per
+     * mission. Absent on the lightweight task-aggregate-only summaries.
+     */
+    stats?: MeshMissionStats;
 }
 
 /**
@@ -171,7 +179,7 @@ function slimMissionSummary(summary: MeshMissionSummary): MeshMissionSlimSummary
  */
 export function getMeshStatusMissionSummaries(
     meshId: string,
-    options?: { historyLimit?: number; verbose?: boolean },
+    options?: { historyLimit?: number; verbose?: boolean; withStats?: boolean },
 ): MeshMissionSummary[] | MeshMissionSlimSummary[] {
     const historyLimit = Math.max(0, options?.historyLimit ?? 10);
     const all = getMeshMissions(meshId);
@@ -180,7 +188,15 @@ export function getMeshStatusMissionSummaries(
         .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));
+    // Operational stats (durations / attempts) are an opt-in projection: each
+    // mission's rollup scans a bounded ledger tail, so we only compute it for
+    // the bounded set we are about to return (live + capped history), not for
+    // every mission in the mesh. The dashboard graph opts in so mission detail
+    // can show wall-clock / retries without a second round trip.
+    if (options?.withStats) {
+        full = full.map(summary => ({ ...summary, stats: computeMeshMissionStats(meshId, summary.id) }));
+    }
     return options?.verbose ? full : full.map(slimMissionSummary);
 }
 

package/src/repo-mesh-types.ts

@@ -12,7 +12,7 @@
  */
 
 import type { GitRepoStatus, GitCompactSummary } from './git/git-types.js';
-import type { MeshMissionSummary } from './mesh/mesh-missions.js';
+import type { MeshMissionSummary, MeshMissionSlimSummary } from './mesh/mesh-missions.js';
 
 // ─── Core Mesh Types ────────────────────────────
 
@@ -486,8 +486,13 @@ export interface RepoMeshStatus {
      * capped, newest-first slice of completed/abandoned history. Omitted by older
      * daemons — the dashboard must treat this as optional and render an empty
      * state when absent. Split on each entry's `status` for live vs. history.
+     *
+     * Compact (the default) status calls send the slim shape — `goalPreview` +
+     * `goalTruncated` instead of the full `goal` — while verbose sends the full
+     * `goal`. Consumers must read `goal ?? goalPreview`. Each entry may also carry
+     * an optional `stats` operational rollup (durations / retries).
      */
-    missions?: MeshMissionSummary[];
+    missions?: (MeshMissionSummary | MeshMissionSlimSummary)[];
 }
 
 // RepoMeshSessionStatus shape now lives in @adhdev/mesh-shared (shared with