@adhdev/daemon-core 0.9.82-rc.367 → 0.9.82-rc.369

package/dist/boot/daemon-lifecycle.d.ts

@@ -81,6 +81,7 @@ export interface DaemonComponents {
     };
     refreshProviderAvailability: (providerType?: string) => Promise<void>;
     dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
+    getMeshPeerConnectionStatus?: (daemonId: string) => Record<string, unknown> | null;
     onMeshCoordinatorEventForwarded?: (payload: Record<string, unknown>) => void;
     meshReconcileLoop?: {
         stop(): void;

package/dist/commands/router.d.ts

@@ -14,6 +14,7 @@ import { DaemonCliManager } from './cli-manager.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { SessionRegistry } from '../sessions/registry.js';
+import { awaitWithWarmupDeadline } from '../mesh/mesh-warmup-deadline.js';
 export declare function readProviderPriorityFromPolicy(policy: unknown): string[];
 /**
  * Normalize a providerRoles array (RepoMeshNodePolicy.providerRoles) from raw
@@ -78,11 +79,46 @@ export declare function resolveMeshNodeAttribution(node: unknown): {
     machineName?: string;
 };
 export declare function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>>;
+/**
+ * Transient per-node marker the mesh_status render loop stamps onto a node
+ * `status` at the two sites that obtain git truth from a FRESH probe this call
+ * (a successful local `getGitRepoStatus`, or a successful P2P `git_status`
+ * round-trip). finalizeMeshNodeStatus consumes and deletes it. Held/standing
+ * truth (node.lastGit / cachedStatus / inline transit) is deliberately NOT
+ * stamped — its absence is exactly how the freshness marker tells "live" apart
+ * from "cached". Internal only; never serialized in the response.
+ */
+export declare const MESH_NODE_LIVE_TRUTH_MARKER = "__liveTruthProbed";
+/**
+ * Build the additive per-node `dataFreshness` marker. This NEVER mutates any
+ * existing field — it only adds an explicit, machine-readable answer to the
+ * question the legacy fields blurred: is this node's data live (just probed),
+ * cached (held truth, maybe old), or absent because the peer was unreachable?
+ *
+ * The crucial separation: an UNREACHABLE peer (P2P probe failed / not connected)
+ * is no longer indistinguishable from an idle/EMPTY node. Both used to render as
+ * `health:'unknown'` with no sessions; now `dataFreshness.dataSource` and
+ * `reachable` tell them apart so a coordinator never reads a dead peer as "online
+ * but doing nothing".
+ */
+export declare function buildMeshNodeDataFreshness(args: {
+    status: Record<string, unknown>;
+    node?: any;
+    isSelfNode: boolean;
+    daemonId?: string;
+    /** True when this node was stamped with a fresh live git probe this call. */
+    liveTruthProbed: boolean;
+    /** True when direct-peer-truth accounting classified this node unavailable. */
+    directTruthUnavailable?: boolean;
+    now?: () => number;
+}): Record<string, unknown>;
 export declare function finalizeMeshNodeStatus(args: {
     status: Record<string, unknown>;
     node: any;
     daemonId?: string;
     isSelfNode: boolean;
+    /** True when direct-peer-truth accounting classified this node unavailable. */
+    directTruthUnavailable?: boolean;
 }): void;
 export declare const MESH_DIRECT_PROBE_TIMEOUT_MS: number;
 export declare const MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS: number;
@@ -117,37 +153,7 @@ export declare class MeshGitProbeCache {
      */
     probe(daemonId: string, workspace: string, probe: () => Promise<Record<string, unknown> | null>): Promise<Record<string, unknown> | null>;
 }
-/**
- * Await `work` under a warmup-aware deadline so a cold-open DataChannel handshake
- * is NOT charged against the command response budget — the root cause of the
- * "first mesh probe to a cold peer false-times-out, the warm retry succeeds"
- * signature. Two budgets, switched by the live peer connection state:
- *
- *  - While `isConnected()` returns false the peer's channel is still opening; the
- *    cold-open `connectTimeoutMs` budget applies. This phase is deliberately
- *    generous because a TURN-relayed cross-machine handshake legitimately needs
- *    many seconds — but a genuine connect *failure* is surfaced by `work`
- *    rejecting on its own (the mesh manager fails the peer the instant its
- *    PeerConnection state goes terminal), so a real failure is never masked for
- *    the whole window.
- *  - The first time `isConnected()` returns true the channel is warm; from that
- *    instant the tight `responseTimeoutMs` governs how long the handler may take.
- *    Warm-channel callers therefore see behavior identical to the old single
- *    `Promise.race(work, responseTimeoutMs)`.
- *
- * Rejects with `Error('timeout')` when either budget is exhausted, mirroring the
- * previous single-race contract. Pure except for timers + the injected
- * `isConnected` probe, so it is unit-testable under fake timers without any real
- * WebRTC. When no connection getter is wired `isConnected` should be `() => true`
- * (the caller's choice) so the response deadline governs from t0 — the legacy
- * single-budget behavior, never a combined connect+response window.
- */
-export declare function awaitWithWarmupDeadline<T>(work: Promise<T>, opts: {
-    isConnected: () => boolean;
-    connectTimeoutMs: number;
-    responseTimeoutMs: number;
-    pollIntervalMs?: number;
-}): Promise<T>;
+export { awaitWithWarmupDeadline };
 /**
  * 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
@@ -781,4 +787,3 @@ export declare class DaemonCommandRouter {
      */
     private stopIde;
 }
-export {};