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

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

@@ -52,6 +52,63 @@ export interface PendingEventEmitHint {
     /** coordinatorRunId to fold into the derived identity when the event lacks one. */
     coordinatorRunId?: string;
 }
+/**
+ * T6 (B3c) enforce switch. When ON, the drain path stops passing an unversioned
+ * (v1) or a validation-failing v2 event through to the coordinator — it QUARANTINES
+ * it instead (excluded from the delivered batch + WARN + counter), and unicast
+ * routing is the only delivery path (there is no v1 broadcast fallback). Off (the
+ * default) preserves the accept-and-warn rollout behaviour exactly.
+ *
+ * Per the rollout plan (§1 decision 4): enforce is `MESH_PROTOCOL_V2_ENFORCE` (env)
+ * — its activation is a deliberate operational step taken ONLY after daemonBuilds
+ * confirms every node emits v2 (§배포 게이트 1 / risk §4). So the code default is
+ * OFF; flipping the env back to accept mode is a pure-env rollback (no code change,
+ * no data migration — the schema is additive). Read at call time so a test /
+ * operator can toggle it without a restart.
+ *
+ * Quarantine (not drop) keeps the loss-free invariant. The DESTRUCTIVE drain has
+ * already consumed the event from its store by the time routing runs, so "held
+ * back" here means: excluded from the delivered batch AND mirrored into the mesh
+ * ledger as a recoverable `event_held` entry (the same recovery channel the
+ * pending-trim path uses). It is observable via the counters + the ledger, so an
+ * operator can requeue it after fixing the producer. The non-destructive PEEK path
+ * (countMetrics=false) merely omits the event from the returned list — it never
+ * consumed it and must not ledger-record on every status poll.
+ */
+export declare function isMeshProtocolV2EnforceEnabled(): boolean;
+/** Observability counters for the v2 drain path. Read by tests and surfaced in
+ *  mesh_status (B4/T6). 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;
+    /** T6 enforce: v2 events that FAILED validation and were QUARANTINED (held back
+     *  from delivery, not dropped). Non-zero here means a producer is still emitting a
+     *  malformed envelope after enforce was turned on. */
+    v2ValidationFailedQuarantined: number;
+    /** T6 enforce: v1 (unversioned) events QUARANTINED because no v2 envelope could be
+     *  derived at emit time. Non-zero here means a producer path still emits v1 after
+     *  enforce — it should reach 0 once every node is on a v2-stamping build. */
+    v1UnversionedQuarantined: 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 +130,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 +157,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 +174,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 +184,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,6 +1,6 @@
 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, getMeshV2DrainCounters, isMeshProtocolV2EnforceEnabled, } from './mesh-events-pending.js';
 export { reconcileDirectDispatchCompletionFromTranscript, } from './mesh-events-stale.js';
-export { setupMeshReconcileLoop, runMeshReconcileTick, resolveCoordinatorDrainDeliverability, shouldHoldPendingDrainForBusyLocalCoordinator, } from './mesh-reconcile-loop.js';
+export { setupMeshReconcileLoop, runMeshReconcileTick, resolveCoordinatorDrainDeliverability, shouldHoldPendingDrainForBusyLocalCoordinator, getMeshV2BackstopCounters, } from './mesh-reconcile-loop.js';
 export type { MeshQueueTriggerResult } from './mesh-events-coordinator.js';
 export { tryAssignQueueTask, isSessionActivelyGenerating, triggerMeshQueue, handleMeshForwardEvent, setupMeshEventForwarding, isMeshCoordinatorEvent, __resetIdleAutoFastForwardForTests, __resetMeshWorkspaceCacheForTests, } 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-reconcile-loop.d.ts

@@ -1,4 +1,16 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+declare const meshV2BackstopCounters: {
+    /** PHASE-4 transcript synthesis actually reconciled a missing completion. */
+    phase4SynthesisFired: number;
+    /** Acked-hold transcript fast-track promoted a synth ahead of the death deadline. */
+    ackedHoldFastTrackFired: number;
+    /** Acked-hold death-deadline backstop released a held synth (the 8-min net). */
+    ackedHoldDeathDeadlineFired: number;
+};
+/** Test/observability accessor for the v2 last-resort backstop counters (snapshot). */
+export declare function getMeshV2BackstopCounters(): Readonly<typeof meshV2BackstopCounters>;
+/** Test helper: zero the backstop counters so a case starts from a clean slate. */
+export declare function __resetMeshV2BackstopCountersForTests(): void;
 export declare function __resetReconcileInFlightSynthDebounceForTests(): void;
 /**
  * DRAIN-WITHOUT-INJECT guard. Classify, for a mesh on THIS daemon, whether a

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/providers/approval-utils.d.ts

@@ -1,4 +1,5 @@
 import type { ProviderModule } from './contracts.js';
+export declare function normalizeApprovalLabel(value: string): string;
 /**
  * True when any of the given button labels reads as a decline/negative option
  * (No / Deny / Cancel / Skip / …). Used as the second half of an approval-modal

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,76 @@ 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;
+    /**
+     * T6 (B3c): live process-lifetime mesh-protocol-v2 enforce counters from THIS
+     * daemon — the enforce flag state, drain-routing tallies (deliver / route-away /
+     * dedup / quarantine), and the last-resort backstop fire counts (PHASE-4 synth,
+     * acked-hold fast-track / death-deadline). Diagnostic-only and never cached (a
+     * live snapshot). Under enforce, non-zero quarantine or backstop counts are the
+     * rollout-health signal (target 0). Omitted when unavailable.
+     */
+    meshProtocolV2Counters?: MeshProtocolV2Counters;
+}
+/** T6 (B3c) live v2 enforce/observability counters (see RepoMeshStatus.meshProtocolV2Counters). */
+export interface MeshProtocolV2Counters {
+    /** True when MESH_PROTOCOL_V2_ENFORCE is active on this daemon. */
+    enforce: boolean;
+    /** Drain-path routing tallies (accept + enforce). Process-lifetime totals. */
+    drain: {
+        v2Delivered: number;
+        v2RoutedAway: number;
+        v2DedupSkipped: number;
+        v2ValidationFailedAccepted: number;
+        v2ReattributedToDrainer: number;
+        v1BroadcastAccepted: number;
+        v2ValidationFailedQuarantined: number;
+        v1UnversionedQuarantined: number;
+    };
+    /** Last-resort backstop fire counts. Target 0 under a healthy v2 contract. */
+    backstop: {
+        phase4SynthesisFired: number;
+        ackedHoldFastTrackFired: number;
+        ackedHoldDeathDeadlineFired: number;
+    };
+}
+/** 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 +841,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.462",
   "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.462",
+    "@adhdev/session-host-core": "0.9.82-rc.462",
     "@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-events.ts

@@ -12,6 +12,9 @@ import {
     drainPendingMeshCoordinatorEvents,
     shouldHoldPendingDrainForBusyLocalCoordinator,
     resolveCoordinatorDrainDeliverability,
+    getMeshV2DrainCounters,
+    getMeshV2BackstopCounters,
+    isMeshProtocolV2EnforceEnabled,
 } from '../../mesh/mesh-events.js';
 import { normalizeInteractivePromptResponse } from '../../providers/types/interactive-prompt.js';
 import type { HighFamilyContext, HighFamilyHandler } from './types.js';
@@ -66,11 +69,21 @@ export const meshEventsHandlers: Record<string, HighFamilyHandler> = {
             return { success: true, events: [], heldForBusyLocalCoordinator: true, hasLiveCliCoordinator };
         }
         const events = drainPendingMeshCoordinatorEvents(meshId || undefined, coordinatorDaemonId);
+        // T6 (B3c): ride the live v2 enforce/backstop counters on the drain response so a
+        // pure stdio MCP coordinator (which reads its inbox via this IPC call, not the
+        // daemon-core mesh_status command) sees the same enforce state + quarantine /
+        // last-resort-backstop tallies. Process-lifetime snapshot; the counters were just
+        // updated by the drain above. Additive — omitting it keeps version-skewed pullers safe.
+        const meshProtocolV2Counters = {
+            enforce: isMeshProtocolV2EnforceEnabled(),
+            drain: { ...getMeshV2DrainCounters() },
+            backstop: { ...getMeshV2BackstopCounters() },
+        };
         // SELF-COORDINATOR INBOX LEVEL-DRAIN: when the busy local coordinator drained its OWN
         // inbox (selfCoordinatorInboxRead), tell the puller these events were surfaced through
         // the caller's tool result — it must NOT re-forward them into the (busy) PTY (that is the
         // lossy path). Absent the flag, delivery is unchanged (reconcile-owned PTY / remote pull).
-        return { success: true, events, hasLiveCliCoordinator, ...(selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {}) };
+        return { success: true, events, hasLiveCliCoordinator, meshProtocolV2Counters, ...(selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {}) };
     },
 
     interactive_prompt_response: async (ctx: HighFamilyContext, args: any) => {

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

@@ -19,7 +19,13 @@ import {
     normalizeMeshNodeId,
     daemonIdsEquivalent,
 } from '@adhdev/mesh-shared';
-import { getPendingMeshCoordinatorEvents } from '../../mesh/mesh-events.js';
+import {
+    getPendingMeshCoordinatorEvents,
+    getMeshV2DrainCounters,
+    getMeshV2BackstopCounters,
+    isMeshProtocolV2EnforceEnabled,
+} from '../../mesh/mesh-events.js';
+import type { MeshProtocolV2Counters } from '../../repo-mesh-types.js';
 import { getRecentUnroutableDeliveries } from '../../mesh/mesh-routing.js';
 import { normalizeMeshDaemonRole, resolveMeshHostStatus } from '../../mesh/mesh-host-ownership.js';
 import { buildPreviewFreshness } from '../../mesh/preview-freshness.js';
@@ -340,6 +346,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: [],
@@ -582,6 +598,15 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                     // that a worker completion was lost (envelope present, mesh unresolved) instead
                     // of it vanishing silently. Diagnostic-only — never cached (see omit below).
                     const unroutableDeliveries = getRecentUnroutableDeliveries();
+                    // T6 (B3c): live enforce/observability counters from this daemon. A
+                    // process-lifetime snapshot (never cached — like unroutableDeliveries)
+                    // so an operator/coordinator can read enforce state, quarantine tallies,
+                    // and last-resort backstop fires straight from the aggregate status.
+                    const meshProtocolV2Counters: MeshProtocolV2Counters = {
+                        enforce: isMeshProtocolV2EnforceEnabled(),
+                        drain: { ...getMeshV2DrainCounters() },
+                        backstop: { ...getMeshV2BackstopCounters() },
+                    };
                     const previewFreshness = (() => {
                         const localRepoRoot = nodeStatuses
                             .map((node: any) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace))
@@ -697,6 +722,7 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                         ...(historicalSessions ? { historicalSessions } : {}),
                         ...(pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {}),
                         ...(unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {}),
+                        meshProtocolV2Counters,
                         activeRefineJobs: Array.from(ctx.runningRefineJobs.values())
                             .filter(job => job.meshId === meshId)
                             .map(job => ({
@@ -708,7 +734,7 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                                 targetCoordinatorDaemonId: job.targetCoordinatorDaemonId,
                             })),
                     };
-                    const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult as any;
+                    const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, meshProtocolV2Counters: _meshProtocolV2Counters, ...cacheableStatusResult } = statusResult as any;
                     // Verbose carries full mission goals; never store it in the shared
                     // (compact) aggregate cache or a later compact poll would return the
                     // heavy goals from cache. Return it without caching.
@@ -719,6 +745,7 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                         ...rememberedStatus,
                         ...(pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {}),
                         ...(unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {}),
+                        meshProtocolV2Counters,
                     };
                     logRepoMeshStatusDebug('return_live', {
                         meshId,

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 };
+}