@adhdev/daemon-core 0.9.82-rc.460 → 0.9.82-rc.461

package/dist/mesh/mesh-events-pending.d.ts

@@ -52,6 +52,31 @@ export interface PendingEventEmitHint {
     /** coordinatorRunId to fold into the derived identity when the event lacks one. */
     coordinatorRunId?: string;
 }
+/** Observability counters for the accept-and-warn rollout. Read by tests and (later,
+ *  B4) surfaced in mesh_status. Process-lifetime totals — never reset in production. */
+declare const meshV2DrainCounters: {
+    /** v2 events that passed validation and unicast/broadcast routing → delivered. */
+    v2Delivered: number;
+    /** v2 unicast events skipped because intendedFor addressed another coordinator. */
+    v2RoutedAway: number;
+    /** v2 events skipped because their eventId was already drained (idempotency). */
+    v2DedupSkipped: number;
+    /** v2 events that failed assertPendingMeshCoordinatorEventV2 but were PASSED
+     *  THROUGH (accept mode). Non-zero here is the rollout signal that a producer
+     *  emits a malformed envelope. */
+    v2ValidationFailedAccepted: number;
+    /** unicast events re-attributed to the drainer via daemon-core match (a
+     *  coordinatorRunId change orphaned them). */
+    v2ReattributedToDrainer: number;
+    /** v1 (unversioned) events passed through as broadcast (rollout baseline). */
+    v1BroadcastAccepted: number;
+};
+/** Test/observability accessor for the v2 drain counters (snapshot copy). */
+export declare function getMeshV2DrainCounters(): Readonly<typeof meshV2DrainCounters>;
+/** Test helper: zero the v2 drain counters so a test starts from a clean slate. */
+export declare function __resetMeshV2DrainCountersForTests(): void;
+/** Test helper: clear the one-shot WARN dedup set. */
+export declare function __resetMeshV2WarnDedupForTests(): void;
 export declare function readRefineJobId(event: {
     metadataEvent?: Record<string, unknown>;
 } | Record<string, unknown>): string;
@@ -73,6 +98,19 @@ export declare function hasPendingCoordinatorEventDuplicate(event: PendingMeshCo
  * key is stable across re-delivery. An already-stamped event is returned as-is.
  */
 export declare function stampPendingEventV2(event: PendingMeshCoordinatorEvent, hint?: PendingEventEmitHint): PendingMeshCoordinatorEvent;
+/**
+ * Copy the v2 envelope fields that are present on `event` onto a flat wire
+ * payload. Only sets a field when it is present, so a v1 event contributes
+ * nothing (the payload stays v1-shaped and version-skew safe).
+ */
+export declare function serializeV2EnvelopeToWire(event: PendingMeshCoordinatorEvent): Record<string, unknown>;
+/**
+ * Restore the v2 envelope fields from a flat wire payload for a re-queue. Only
+ * returns fields that survive validation; a payload missing/malforming a field
+ * yields a partial (or empty) object so the re-queue path stays v1-safe. The
+ * eventId is returned verbatim — its preservation is the idempotency guarantee.
+ */
+export declare function readV2EnvelopeFromWire(payload: Record<string, unknown>): Partial<Pick<PendingMeshCoordinatorEvent, 'protocolVersion' | 'eventId' | 'scope' | 'dispatchedBy' | 'intendedFor'>>;
 export declare function queuePendingMeshCoordinatorEvent(rawEvent: PendingMeshCoordinatorEvent, hint?: PendingEventEmitHint): boolean;
 /**
  * Drain and return pending coordinator events for meshId, removing the drained
@@ -87,6 +125,7 @@ export declare function queuePendingMeshCoordinatorEvent(rawEvent: PendingMeshCo
  */
 export declare function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string | ReadonlyArray<string>, opts?: {
     onlyEvents?: ReadonlySet<string>;
+    drainerIdentity?: CoordinatorIdentity;
 }): PendingMeshCoordinatorEvent[];
 /**
  * FALSE-BLOCKER-CLONE-QUEUE: retract any still-UNDELIVERED `mesh:dispatch_blocked`
@@ -103,7 +142,9 @@ export declare function drainPendingMeshCoordinatorEvents(meshId?: string, coord
  */
 export declare function retractPendingDispatchBlockedEvent(meshId: string | undefined, taskId: string | undefined, coordinatorDaemonId?: string): number;
 /** Peek at pending coordinator events without draining (non-destructive). */
-export declare function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string | ReadonlyArray<string>): readonly PendingMeshCoordinatorEvent[];
+export declare function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string | ReadonlyArray<string>, opts?: {
+    drainerIdentity?: CoordinatorIdentity;
+}): readonly PendingMeshCoordinatorEvent[];
 /**
  * Test helper: purge all pending-event state for a mesh — SQLite rows
  * (including drained fingerprint history) and JSONL files.
@@ -111,3 +152,4 @@ export declare function getPendingMeshCoordinatorEvents(meshId?: string, coordin
 export declare function __clearMeshPendingEventsForTests(meshId: string): void;
 /** Explicitly clear all pending coordinator events for a mesh (and coordinator if scoped). */
 export declare function clearPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): void;
+export {};

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

@@ -1,5 +1,5 @@
 export type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
-export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, } from './mesh-events-pending.js';
+export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, serializeV2EnvelopeToWire, readV2EnvelopeFromWire, } from './mesh-events-pending.js';
 export { reconcileDirectDispatchCompletionFromTranscript, } from './mesh-events-stale.js';
 export { setupMeshReconcileLoop, runMeshReconcileTick, resolveCoordinatorDrainDeliverability, shouldHoldPendingDrainForBusyLocalCoordinator, } from './mesh-reconcile-loop.js';
 export type { MeshQueueTriggerResult } from './mesh-events-coordinator.js';

package/dist/mesh/mesh-node-identity.d.ts

@@ -49,6 +49,8 @@ export declare function recordInlineMeshDirectGitTruth(node: any, git: Record<st
     reporterPlatform: string | null;
     reporterArch: string | null;
     reporterMachineNickname: string | null;
+    reporterProviderVersions: Record<string, string> | null;
+    reporterDaemonBuildVersion: string | null;
 };
 /**
  * Persist the live self-reported platform/arch onto the local meshes.json node
@@ -65,6 +67,8 @@ export declare function persistNodeReporterPlatform(meshSource: 'inline_cache' |
     reporterPlatform: string | null;
     reporterArch: string | null;
     reporterMachineNickname?: string | null;
+    reporterProviderVersions?: Record<string, string> | null;
+    reporterDaemonBuildVersion?: string | null;
 }): void;
 export declare function inlineMeshCarriesTransientNodeTruth(inlineMesh: any): boolean;
 export declare function readInlineMeshNodeId(node: any): string;

package/dist/mesh/mesh-runtime-store.d.ts

@@ -425,6 +425,23 @@ export declare class MeshRuntimeStore {
         payload: unknown;
     }>;
     hasPendingEventFingerprint(meshId: string, fingerprint: string): boolean;
+    /**
+     * B3a — v2 eventId idempotency. Returns true when a row with this event_id has
+     * ALREADY been drained (drained = 1) for the mesh. Drained rows are retained
+     * (soft-marked, not deleted until mesh deletion), so this is a durable, restart-
+     * surviving dedup: a v2 event whose eventId was already consumed is skipped on
+     * re-delivery even when its content fingerprint differs. Scoped by mesh_id +
+     * the partial event_id index (idx_mesh_pending_events_event_id).
+     */
+    hasDrainedEventId(meshId: string, eventId: string): boolean;
+    /**
+     * B3a — snapshot of the v2 event_ids ALREADY drained (drained = 1) for the mesh.
+     * Taken BEFORE a drain call marks the current batch drained=1, so the resulting
+     * set names only PRIOR drains — the re-delivery dedup baseline. (Reading it after
+     * the drain would self-match the batch's own freshly-drained rows.) Non-v2 rows
+     * have a NULL event_id and are excluded by the index/WHERE.
+     */
+    drainedEventIdsForMesh(meshId: string): Set<string>;
     upsertMission(mission: {
         id: string;
         meshId: string;

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

@@ -447,6 +447,23 @@ export interface RepoMeshNodeCapabilities {
     canPush?: boolean;
     readOnly?: boolean;
     userLabels?: string[];
+    /**
+     * Detected provider CLI/ACP versions on this node, keyed by provider id
+     * (e.g. `{ 'claude-cli': '1.2.3', 'codex-cli': '0.9.0' }`). Populated from the
+     * same CLI detection pass that feeds providerPriority (see buildProviderVersions
+     * over detectCLIs' CLIInfo[]). Absent/undefined when detection has not run or a
+     * daemon predates the exposure — never a hard signal, purely observability so a
+     * coordinator can spot a provider-version skew across nodes before dispatch.
+     * Additive: existing status consumers ignore it.
+     */
+    providerVersions?: Record<string, string>;
+    /**
+     * The daemon build version (package.json version baked into the running bundle,
+     * see getDaemonBuildInfo().version) that detected the above providerVersions.
+     * Complements the commit-level daemonBuild stamp with a human-readable version
+     * for node-card rendering. Absent when the build define was not injected.
+     */
+    daemonBuildVersion?: string;
 }
 export interface DetectedCommand {
     command: string;
@@ -580,6 +597,19 @@ export interface LocalMeshNodeEntry {
      */
     reportedPlatform?: string;
     reportedArch?: string;
+    /**
+     * Live, self-healed provider CLI/ACP versions reported by the daemon that owns
+     * this node's workspace, carried on the git_status envelope (reporterProviderVersions)
+     * and persisted by the coordinator on each direct git probe — mirrors the
+     * reportedPlatform/reportedArch self-heal pattern. Auto-detected truth, overwritten
+     * by the next report so a stale value never sticks. Absent until the first probe
+     * carrying versions succeeds. Surfaced as RepoMeshNodeStatus.providerVersions.
+     */
+    reportedProviderVersions?: Record<string, string>;
+    /** Live, self-healed daemon build version (getDaemonBuildInfo().version) of the
+     *  owning daemon, carried on the git_status envelope (reporterDaemonBuildVersion)
+     *  alongside the provider versions. Absent until first reported. */
+    reportedDaemonBuildVersion?: string;
     /**
      * The operator-set machine nickname (config.machineNickname) of the daemon
      * that owns this node's workspace. The local coordinator stamps its own
@@ -697,6 +727,45 @@ export interface RepoMeshStatus {
      * optional. Mirrors the MCP `mesh_status` tool's `magiActivity` field.
      */
     magiActivity?: MeshMagiActivitySummary[];
+    /**
+     * T7 (visibility 7-2b): provider CLI/ACP version skew across nodes. Each entry
+     * names a provider running ≥2 distinct versions across the nodes that reported
+     * it, with the node ids per version. Observational only — never a dispatch
+     * blocker. Omitted when every reported provider is uniform (or none reported).
+     * Mirrors the MCP `mesh_status` tool's `providerVersionSkew` field.
+     */
+    providerVersionSkew?: MeshProviderVersionSkew[];
+    /** Human-readable companion warning to providerVersionSkew. Omitted when no skew. */
+    providerVersionSkewWarning?: string;
+    /**
+     * T7 (B4): mesh-protocol-v2 adoption metrics for the batch of pending events
+     * surfaced in the drain backing this status. Snapshot, not a durable counter.
+     * Omitted when nothing was drained. Mirrors the MCP tool's meshProtocolMetrics.
+     */
+    meshProtocolMetrics?: MeshProtocolMetrics;
+}
+/** One provider's version skew across mesh nodes (see RepoMeshStatus.providerVersionSkew). */
+export interface MeshProviderVersionSkew {
+    /** Provider id (e.g. 'claude-cli'). */
+    provider: string;
+    /** Each distinct detected version and the node ids running it. */
+    versions: Array<{
+        version: string;
+        nodeIds: string[];
+    }>;
+}
+/** Mesh-protocol-v2 adoption snapshot over one drain (see RepoMeshStatus.meshProtocolMetrics). */
+export interface MeshProtocolMetrics {
+    /** Total pending events surfaced in the drain. */
+    total: number;
+    /** Count carrying a v2 envelope (protocolVersion '2.0'). */
+    v2: number;
+    /** Count still on v1 (unstamped). */
+    v1: number;
+    /** v2/total, rounded to 2 decimals (0 when total is 0). */
+    v2Ratio: number;
+    /** Scope breakdown of the v2 events (unicast/broadcast/system/unspecified → count). */
+    scopes: Record<string, number>;
 }
 export type { RepoMeshSessionStatus } from '@adhdev/mesh-shared';
 import type { RepoMeshSessionStatus } from '@adhdev/mesh-shared';
@@ -741,6 +810,17 @@ export interface RepoMeshNodeStatus {
      */
     gitProbePending?: boolean;
     providers: string[];
+    /**
+     * Detected provider CLI/ACP versions on this node, keyed by provider id. Mirrors
+     * RepoMeshNodeCapabilities.providerVersions onto the status snapshot so the mesh
+     * UI / coordinator prompt can render per-provider versions and flag a version
+     * skew across nodes. Optional — omitted by daemons predating the exposure or when
+     * detection has not run. Additive; existing consumers ignore it. */
+    providerVersions?: Record<string, string>;
+    /** Human-readable daemon build version (getDaemonBuildInfo().version) of the
+     *  daemon that owns this node. Complements the per-daemon commit stamp
+     *  (daemonBuilds) for node-card display. Omitted when unknown. */
+    daemonBuildVersion?: string;
     activeSessions: string[];
     activeSessionDetails?: RepoMeshSessionStatus[];
     providerPriority?: string[];

package/package.json

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

package/src/boot/daemon-lifecycle.ts

@@ -25,7 +25,8 @@ import { VersionArchive, detectAllVersions } from '../providers/version-archive.
 import { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { DevServer } from '../daemon/dev-server.js';
 import { detectIDEs, type IDEInfo } from '../detection/ide-detector.js';
-import { detectCLI, detectCLIs } from '../detection/cli-detector.js';
+import { detectCLI, detectCLIs, getCachedProviderVersions } from '../detection/cli-detector.js';
+import { getDaemonBuildInfo } from '../build-info.js';
 import { SessionRegistry } from '../sessions/registry.js';
 import { LOG, installGlobalInterceptor } from '../logging/logger.js';
 import {
@@ -304,7 +305,19 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         providerLoader,
         instanceManager,
         sessionRegistry,
-        gitCommandServices: createDefaultGitCommandServices(),
+        gitCommandServices: createDefaultGitCommandServices({
+            // T7: fold this daemon's cached provider versions + build version onto the
+            // git_status envelope so the mesh coordinator self-heals each node's
+            // providerVersions. Non-blocking: reads a TTL cache, lazily refreshed.
+            getReporterProviderVersions: () => {
+                const providerVersions = getCachedProviderVersions(providerLoader);
+                const daemonBuildVersion = getDaemonBuildInfo().version;
+                return {
+                    ...(Object.keys(providerVersions).length > 0 ? { providerVersions } : {}),
+                    ...(daemonBuildVersion && daemonBuildVersion !== 'unknown' ? { daemonBuildVersion } : {}),
+                };
+            },
+        }),
         onProviderSettingChanged: async (providerType) => {
             await refreshProviderAvailability(providerType);
             config.onStatusChange?.();

package/src/commands/high-family/mesh-status.ts

@@ -340,6 +340,16 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                             machineStatus: node.machineStatus,
                             health: 'unknown',
                             providers: node.providers || [],
+                            // T7: surface self-healed provider versions + build version (from the
+                            // git_status envelope, persisted on the node) so the coordinator/UI can
+                            // spot a provider-version skew across nodes. Additive; omitted when a
+                            // node has never reported them.
+                            ...(node.reportedProviderVersions && typeof node.reportedProviderVersions === 'object'
+                                ? { providerVersions: node.reportedProviderVersions }
+                                : {}),
+                            ...(typeof node.reportedDaemonBuildVersion === 'string' && node.reportedDaemonBuildVersion
+                                ? { daemonBuildVersion: node.reportedDaemonBuildVersion }
+                                : {}),
                             providerPriority,
                             activeSessions: [],
                             activeSessionDetails: [],

package/src/config/mesh-config.ts

@@ -583,6 +583,13 @@ export function updateNode(
          *  git_status envelope. Persisted so the friendly label survives across
          *  coordinator restarts (mirrors reportedPlatform/reportedArch). */
         reportedMachineNickname?: string;
+        /** Owning daemon's self-reported provider CLI/ACP versions + build version,
+         *  carried on the git_status envelope. Persisted distinctly from userOverrides
+         *  (auto-detected observability, not operator intent), mirroring the
+         *  reportedPlatform/reportedArch self-heal so the value survives restarts and
+         *  is overwritten by the next report. */
+        reportedProviderVersions?: Record<string, string>;
+        reportedDaemonBuildVersion?: string;
     },
 ): LocalMeshNodeEntry | undefined {
     const config = loadMeshConfig();
@@ -596,6 +603,12 @@ export function updateNode(
     if (opts.reportedPlatform && opts.reportedPlatform.trim()) node.reportedPlatform = opts.reportedPlatform.trim();
     if (opts.reportedArch && opts.reportedArch.trim()) node.reportedArch = opts.reportedArch.trim();
     if (opts.reportedMachineNickname && opts.reportedMachineNickname.trim()) node.machineNickname = opts.reportedMachineNickname.trim();
+    if (opts.reportedProviderVersions && Object.keys(opts.reportedProviderVersions).length > 0) {
+        node.reportedProviderVersions = { ...opts.reportedProviderVersions };
+    }
+    if (opts.reportedDaemonBuildVersion && opts.reportedDaemonBuildVersion.trim()) {
+        node.reportedDaemonBuildVersion = opts.reportedDaemonBuildVersion.trim();
+    }
     if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
     if (opts.worktreeBootstrap) node.worktreeBootstrap = opts.worktreeBootstrap;
     if (Object.prototype.hasOwnProperty.call(opts, 'systemPrompt')) {

package/src/detection/cli-detector.ts

@@ -200,3 +200,69 @@ export async function detectCLI(
     const all = await detectCLIs(providerLoader, options);
     return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
+
+/**
+ * Fold a detected CLIInfo[] into the `{ providerId: version }` map surfaced as a
+ * node's providerVersions (see RepoMeshNodeCapabilities.providerVersions). Only
+ * installed providers that produced a parseable version string are included, so a
+ * missing entry means "not installed or version unknown" — never a fabricated value.
+ * Pure/deterministic: the same detection input always yields the same map, which is
+ * what the git_status envelope carries and the mesh_status skew check compares.
+ */
+export function buildProviderVersions(detected: CLIInfo[]): Record<string, string> {
+    const out: Record<string, string> = {};
+    for (const cli of detected) {
+        if (!cli.installed) continue;
+        const version = typeof cli.version === 'string' ? cli.version.trim() : '';
+        if (!version) continue;
+        out[cli.id] = version;
+    }
+    return out;
+}
+
+// ─── Cached provider-versions snapshot (mesh visibility, T7) ────────────────
+//
+// A node's providerVersions rides the git_status envelope, which a coordinator
+// probes on every graph refresh. Running the full `--version` exec fan-out on
+// each probe would be far too costly (one spawn per provider per probe), so the
+// snapshot is memoized with a TTL and refreshed lazily in the background: a probe
+// reads the current cache immediately (empty until the first refresh completes)
+// and kicks off a refresh only when the cache is stale, never blocking the git
+// response on version detection. Best-effort observability — a cold/empty map
+// simply omits providerVersions from that probe, and the next probe carries it.
+const PROVIDER_VERSIONS_TTL_MS = 5 * 60 * 1000; // 5 min — provider installs change rarely
+let cachedProviderVersions: Record<string, string> = {};
+let cachedProviderVersionsAt = 0;
+let providerVersionsRefreshInFlight: Promise<void> | null = null;
+
+function refreshProviderVersionsSnapshot(providerLoader?: ProviderLoader): Promise<void> {
+    if (providerVersionsRefreshInFlight) return providerVersionsRefreshInFlight;
+    providerVersionsRefreshInFlight = (async () => {
+        try {
+            const detected = await detectCLIs(providerLoader, { includeVersion: true });
+            cachedProviderVersions = buildProviderVersions(detected);
+            cachedProviderVersionsAt = Date.now();
+        } catch {
+            // Best-effort: keep the last good snapshot on failure.
+        } finally {
+            providerVersionsRefreshInFlight = null;
+        }
+    })();
+    return providerVersionsRefreshInFlight;
+}
+
+/**
+ * Return the current cached provider-versions map for this daemon, triggering a
+ * lazy background refresh when the snapshot is stale/cold. Never blocks: returns
+ * whatever is currently cached (an empty object before the first refresh lands).
+ * This is the source the git_status envelope reads to self-report a node's
+ * provider versions to the mesh coordinator.
+ */
+export function getCachedProviderVersions(providerLoader?: ProviderLoader): Record<string, string> {
+    const stale = Date.now() - cachedProviderVersionsAt > PROVIDER_VERSIONS_TTL_MS;
+    if (stale) {
+        // Fire-and-forget; the current (possibly empty) snapshot is returned now.
+        void refreshProviderVersionsSnapshot(providerLoader);
+    }
+    return { ...cachedProviderVersions };
+}

package/src/git/git-commands.ts

@@ -102,6 +102,14 @@ export interface GitCommandServices {
   checkoutFiles?: (params: { workspace: string; paths: string[] }) => Promise<{ checkedOut: string[] }>;
   getRemoteUrl?: (params: { workspace: string; remote?: string }) => Promise<{ remoteUrl: string; remote: string }>;
   push?: (params: { workspace: string; remote?: string; branch?: string; setUpstream?: boolean }) => Promise<GitPushResult>;
+  /**
+   * Best-effort, non-blocking source of this daemon's detected provider CLI/ACP
+   * versions (keyed by provider id) + its build version, folded onto the git_status
+   * envelope so a mesh coordinator can self-heal each node's providerVersions the
+   * same way it does platform/arch. Wired at daemon boot from the cached CLI
+   * detection snapshot; omitted (⇒ versions not reported) when unavailable.
+   */
+  getReporterProviderVersions?: () => { providerVersions?: Record<string, string>; daemonBuildVersion?: string };
 }
 
 type GitCommandFailure = {
@@ -116,7 +124,7 @@ type GitCommandSuccess =
   // node's userOverrides.platform/arch (the fields capability-tag routing reads).
   // reporterMachineNickname carries the responding daemon's config.machineNickname
   // so the coordinator can populate node.machineNickname → the friendly display label.
-  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string; reporterMachineNickname?: string }
+  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string; reporterMachineNickname?: string; reporterProviderVersions?: Record<string, string>; reporterDaemonBuildVersion?: string }
   | { success: true; diffSummary: GitDiffSummary }
   | { success: true; diff: GitFileDiff }
   | { success: true; snapshot: GitSnapshot }
@@ -179,7 +187,9 @@ const defaultSnapshotStore = createGitSnapshotStore({
   getDiffSummary: (workspace) => getGitDiffSummary(workspace),
 });
 
-export function createDefaultGitCommandServices(): GitCommandServices {
+export function createDefaultGitCommandServices(
+  overrides?: Pick<GitCommandServices, 'getReporterProviderVersions'>,
+): GitCommandServices {
   return {
     getStatus: ({ workspace, refreshUpstream }) => getGitRepoStatus(workspace, { refreshUpstream }),
     getDiffSummary: ({ workspace, base }) => getGitDiffSummary(workspace, base ? { baseRef: base } : {}),
@@ -199,6 +209,9 @@ export function createDefaultGitCommandServices(): GitCommandServices {
     getRemoteUrl: async ({ workspace, remote = 'origin' }) => gitGetRemoteUrl(workspace, remote),
     push: async ({ workspace, remote = 'origin', branch, setUpstream = false }) =>
       gitPush(workspace, remote, branch, setUpstream),
+    ...(overrides?.getReporterProviderVersions
+      ? { getReporterProviderVersions: overrides.getReporterProviderVersions }
+      : {}),
   };
 }
 
@@ -328,12 +341,32 @@ export async function handleGitCommand(
           return undefined;
         }
       })();
+      // Provider versions + build version ride the same self-report channel (T7
+      // visibility). Best-effort and non-blocking: the service reads a cached
+      // snapshot, so a cold cache simply omits the fields on this probe.
+      const reporterVersions = (() => {
+        try {
+          return services.getReporterProviderVersions?.() ?? {};
+        } catch {
+          return {};
+        }
+      })();
+      const reporterProviderVersions =
+        reporterVersions.providerVersions && Object.keys(reporterVersions.providerVersions).length > 0
+          ? reporterVersions.providerVersions
+          : undefined;
+      const reporterDaemonBuildVersion =
+        typeof reporterVersions.daemonBuildVersion === 'string' && reporterVersions.daemonBuildVersion.trim()
+          ? reporterVersions.daemonBuildVersion.trim()
+          : undefined;
       return {
         success: true,
         status,
         reporterPlatform: process.platform,
         reporterArch: process.arch,
         ...(reporterMachineNickname ? { reporterMachineNickname } : {}),
+        ...(reporterProviderVersions ? { reporterProviderVersions } : {}),
+        ...(reporterDaemonBuildVersion ? { reporterDaemonBuildVersion } : {}),
       };
     }
 

package/src/index.ts

@@ -295,7 +295,7 @@ export { buildMeshHostRequiredFailure, createDefaultMeshHostMetadata, isMeshHost
 // export type { MeshGraph, MeshGraphNode, MeshGraphEdge, MeshGraphNodeType, MeshGraphEdgeType } from './mesh/mesh-visualization.js';
 
 // ── Mesh Events ──
-export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, reconcileDirectDispatchCompletionFromTranscript } from './mesh/mesh-events.js';
+export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, serializeV2EnvelopeToWire, readV2EnvelopeFromWire, reconcileDirectDispatchCompletionFromTranscript } from './mesh/mesh-events.js';
 export type { PendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
 // The coordinator-side preview surfaced from a worker's completion/status event
 // (finalSummary / workerResult.summary / lastMessagePreview). Same data the mobile

package/src/mesh/coordinator-prompt.ts

@@ -392,9 +392,27 @@ function buildNodeStatusSection(nodes: RepoMeshNodeStatus[]): string {
             ? `sessions: ${n.activeSessions.join(', ')}`
             : 'no active sessions';
         const branch = n.git?.branch ? `branch: \`${n.git.branch}\`` : '';
+        // Render each provider with its detected version when known (T7 visibility)
+        // so the coordinator can eyeball a per-node provider-version skew inline —
+        // e.g. `claude-cli@1.2.3`. Providers without a reported version render bare.
+        const providerVersions = n.providerVersions && typeof n.providerVersions === 'object'
+            ? n.providerVersions
+            : undefined;
+        const providersRendered = n.providers?.length
+            ? n.providers
+                .map((p) => {
+                    const version = providerVersions?.[p];
+                    return version ? `${p}@${version}` : p;
+                })
+                .join(', ')
+            : '';
+        const buildVersion = typeof n.daemonBuildVersion === 'string' && n.daemonBuildVersion
+            ? `build: ${n.daemonBuildVersion}`
+            : '';
         const context = [
             n.daemonId ? `daemon: \`${n.daemonId}\`` : '',
-            n.providers?.length ? `providers: ${n.providers.join(', ')}` : '',
+            providersRendered ? `providers: ${providersRendered}` : '',
+            buildVersion,
         ].filter(Boolean).join(' | ');
         lines.push(`- ${healthIcon} **${n.machineLabel}** (nodeId: \`${n.nodeId}\`)`);
         lines.push(`  workspace: \`${n.workspace}\`${context ? ` | ${context}` : ''} | ${branch} | ${sessions}`);

package/src/mesh/mesh-event-forwarding.ts

@@ -7,7 +7,7 @@ import type { SessionRecoveryContext } from './mesh-ledger.js';
 import { updateSessionTaskStatus, enqueueTask, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, getActiveDirectDispatches, hasPendingDependents, getQueue } from './mesh-work-queue.js';
 import { markSessionDeliveriesTerminal, updateSessionDeliveryStatus, recordCompletionConflict } from './mesh-delivery-policy.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, type PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
+import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, readV2EnvelopeFromWire, type PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent, isUnroutableDelegateRejection } from './mesh-routing.js';
 import { resolveMeshHostStatus } from './mesh-host-ownership.js';
@@ -681,6 +681,13 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     nodeLabel: string;
     event: string;
     metadataEvent: Record<string, unknown>;
+    // T4 (B3b): v2 envelope restored from a remote (P2P) relay's flat payload. Only the
+    // relay path (handleMeshForwardEvent) sets it; the in-process forward path leaves it
+    // undefined and the local emit stamp applies as usual. When present with a preserved
+    // eventId, it is spread onto the re-queued pending event so stampPendingEventV2's
+    // already-stamped short-circuit keeps the ORIGINAL eventId (cross-machine idempotency).
+    v2Envelope?: Partial<Pick<PendingMeshCoordinatorEvent,
+        'protocolVersion' | 'eventId' | 'scope' | 'dispatchedBy' | 'intendedFor'>>;
 }) {
     const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
     const eventNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
@@ -1363,6 +1370,12 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         // Top-level session anchor for the local PHASE 2 strict-match on the coordinator
         // daemon. Absent → daemon-level broadcast (legacy / single-coordinator path).
         ...(workerCoordinatorSessionId ? { targetCoordinatorSessionId: workerCoordinatorSessionId } : {}),
+        // T4 (B3b): restore the v2 envelope from the remote relay so the re-queue keeps the
+        // ORIGINAL eventId. Spread LAST so its authoritative eventId/scope/identity win over
+        // any default. queuePendingMeshCoordinatorEvent → stampPendingEventV2 then no-ops
+        // (already-stamped short-circuit) instead of minting a fresh eventId. Empty object
+        // for a v1 relay → unchanged v1 emit-stamp path (version-skew safe).
+        ...(args.v2Envelope ?? {}),
     };
     if (queuePendingMeshCoordinatorEvent(pendingEvent)) {
         LOG.info('MeshEvents', `Queued ${args.event} for coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ''}${workerCoordinatorSessionId ? `, coordinator session ${workerCoordinatorSessionId}` : ''})`);
@@ -1518,6 +1531,11 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
         nodeLabel,
         event: eventName,
         metadataEvent: buildRelayMetadataEvent(payload),
+        // T4 (B3b): restore the v2 envelope carried at the top level of the relayed flat
+        // payload (buildForwardPayloadFromPending → serializeV2EnvelopeToWire) so the
+        // re-queue preserves the original eventId (idempotency) and unicast routing rather
+        // than re-stamping a fresh v1/broadcast event. Empty for a v1 relay (version-skew safe).
+        v2Envelope: readV2EnvelopeFromWire(payload),
     });
 }