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

package/dist/index.js

@@ -409,10 +409,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "f8ce1329d3bdef9564c4130a1e7f0b607738f3cd" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "f8ce1329" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.460" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-04T14:24:11.778Z" : void 0);
+  const commit = readInjected(true ? "1481e2078cc0eceea283a2370cccb4cd9102e4ff" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "1481e207" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.462" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-04T16:50:21.874Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3261,6 +3261,12 @@ function updateNode(meshId, nodeId, opts) {
   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")) {
@@ -3604,9 +3610,16 @@ function buildNodeStatusSection(nodes) {
     const healthIcon = n.health === "online" ? "\u{1F7E2}" : n.health === "dirty" ? "\u{1F7E1}" : n.health === "offline" ? "\u26AB" : "\u{1F534}";
     const sessions = n.activeSessions.length > 0 ? `sessions: ${n.activeSessions.join(", ")}` : "no active sessions";
     const branch = n.git?.branch ? `branch: \`${n.git.branch}\`` : "";
+    const providerVersions = n.providerVersions && typeof n.providerVersions === "object" ? n.providerVersions : void 0;
+    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}`);
@@ -4174,6 +4187,98 @@ var init_load_better_sqlite3 = __esm({
 });
 
 // src/mesh/contracts.ts
+function isSupportedMeshProtocolVersion(value) {
+  return typeof value === "string" && SUPPORTED_MESH_PROTOCOL_VERSIONS.includes(value);
+}
+function coordinatorIdentityEquals(a, b) {
+  return daemonIdsEquivalent(a.daemonId, b.daemonId) && a.coordinatorRunId === b.coordinatorRunId && (a.sessionId ?? "") === (b.sessionId ?? "");
+}
+function coordinatorIdentityKey(identity) {
+  const daemonCore = machineCoreFromDaemonId(identity.daemonId) ?? identity.daemonId;
+  return `${daemonCore}|${identity.coordinatorRunId}|${identity.sessionId ?? ""}`;
+}
+function isMeshEventScope(value) {
+  return typeof value === "string" && MESH_EVENT_SCOPES.includes(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function assertCoordinatorIdentity(raw, path44) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, path44, "must be an object");
+  }
+  const obj = raw;
+  if (!isNonEmptyString(obj.daemonId)) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.daemonId`, "must be a non-empty string");
+  }
+  if (!isNonEmptyString(obj.coordinatorRunId)) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.coordinatorRunId`, "must be a non-empty string");
+  }
+  const sessionId = obj.sessionId;
+  if (sessionId !== void 0 && !isNonEmptyString(sessionId)) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.sessionId`, "must be a non-empty string when provided");
+  }
+  return sessionId !== void 0 ? { daemonId: obj.daemonId, coordinatorRunId: obj.coordinatorRunId, sessionId } : { daemonId: obj.daemonId, coordinatorRunId: obj.coordinatorRunId };
+}
+function assertPendingMeshCoordinatorEventV2(raw, path44 = "$") {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, path44, "must be an object");
+  }
+  const obj = raw;
+  if (!isSupportedMeshProtocolVersion(obj.protocolVersion)) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.protocolVersion`, `must be one of ${SUPPORTED_MESH_PROTOCOL_VERSIONS.join(", ")}`);
+  }
+  if (!isNonEmptyString(obj.eventId)) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.eventId`, "must be a non-empty string");
+  }
+  if (!isMeshEventScope(obj.scope)) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.scope`, `must be one of ${MESH_EVENT_SCOPES.join(", ")}`);
+  }
+  if (!isNonEmptyString(obj.event)) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.event`, "must be a non-empty string");
+  }
+  if (!isNonEmptyString(obj.meshId)) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.meshId`, "must be a non-empty string");
+  }
+  const dispatchedBy = assertCoordinatorIdentity(obj.dispatchedBy, `${path44}.dispatchedBy`);
+  if (obj.scope === "unicast") {
+    if (!obj.intendedFor) {
+      throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.intendedFor`, "unicast scope requires intendedFor");
+    }
+  } else if (obj.intendedFor !== void 0) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.intendedFor`, "only unicast scope may set intendedFor");
+  }
+  const intendedFor = obj.intendedFor ? assertCoordinatorIdentity(obj.intendedFor, `${path44}.intendedFor`) : void 0;
+  const metadata = obj.metadataEvent && typeof obj.metadataEvent === "object" && !Array.isArray(obj.metadataEvent) ? obj.metadataEvent : null;
+  if (!metadata) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.metadataEvent`, "must be an object");
+  }
+  const queuedAt = typeof obj.queuedAt === "number" && Number.isFinite(obj.queuedAt) ? obj.queuedAt : null;
+  if (queuedAt === null) {
+    throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path44}.queuedAt`, "must be a finite number");
+  }
+  return {
+    event: obj.event,
+    meshId: obj.meshId,
+    nodeLabel: isNonEmptyString(obj.nodeLabel) ? obj.nodeLabel : "",
+    nodeId: typeof obj.nodeId === "string" ? obj.nodeId : void 0,
+    workspace: typeof obj.workspace === "string" ? obj.workspace : void 0,
+    metadataEvent: metadata,
+    coordinatorMessage: typeof obj.coordinatorMessage === "string" ? obj.coordinatorMessage : void 0,
+    queuedAt,
+    protocolVersion: obj.protocolVersion,
+    eventId: obj.eventId,
+    scope: obj.scope,
+    dispatchedBy,
+    ...intendedFor ? { intendedFor } : {}
+  };
+}
+function shouldDeliverPendingEventToCoordinator(event, drainer) {
+  if (event.scope === "system") return false;
+  if (event.scope === "broadcast") return true;
+  if (!event.intendedFor) return false;
+  return coordinatorIdentityEquals(event.intendedFor, drainer);
+}
 function defaultScopeForEvent(eventName) {
   if (SYSTEM_EVENTS.has(eventName)) return "system";
   if (TERMINAL_TASK_EVENTS.has(eventName)) return "unicast";
@@ -4202,12 +4307,28 @@ function buildPendingEventEmitStamp(opts) {
     ...intendedFor ? { intendedFor } : {}
   };
 }
-var MESH_PROTOCOL_VERSION_V2, TERMINAL_TASK_EVENTS, SYSTEM_EVENTS;
+var MESH_PROTOCOL_VERSION_V1, MESH_PROTOCOL_VERSION_V2, SUPPORTED_MESH_PROTOCOL_VERSIONS, MESH_EVENT_SCOPES, MeshContractViolationError, TERMINAL_TASK_EVENTS, SYSTEM_EVENTS;
 var init_contracts = __esm({
   "src/mesh/contracts.ts"() {
     "use strict";
     init_dist();
+    MESH_PROTOCOL_VERSION_V1 = "1.0";
     MESH_PROTOCOL_VERSION_V2 = "2.0";
+    SUPPORTED_MESH_PROTOCOL_VERSIONS = [
+      MESH_PROTOCOL_VERSION_V1,
+      MESH_PROTOCOL_VERSION_V2
+    ];
+    MESH_EVENT_SCOPES = ["unicast", "broadcast", "system"];
+    MeshContractViolationError = class extends Error {
+      violationPath;
+      protocolVersion;
+      constructor(protocolVersion, violationPath, detail) {
+        super(`mesh contract ${protocolVersion} violation at ${violationPath}: ${detail}`);
+        this.name = "MeshContractViolationError";
+        this.violationPath = violationPath;
+        this.protocolVersion = protocolVersion;
+      }
+    };
     TERMINAL_TASK_EVENTS = /* @__PURE__ */ new Set([
       "agent:generating_completed",
       "agent:stopped",
@@ -7536,6 +7657,34 @@ var init_mesh_runtime_store = __esm({
         ).get(meshId, fingerprint);
         return row !== void 0;
       }
+      /**
+       * 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, eventId) {
+        if (!eventId) return false;
+        const row = this.db.prepare(
+          "SELECT 1 FROM mesh_pending_events WHERE mesh_id = ? AND event_id = ? AND drained = 1 LIMIT 1"
+        ).get(meshId, eventId);
+        return row !== void 0;
+      }
+      /**
+       * 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) {
+        const rows = this.db.prepare(
+          "SELECT DISTINCT event_id FROM mesh_pending_events WHERE mesh_id = ? AND drained = 1 AND event_id IS NOT NULL"
+        ).all(meshId);
+        return new Set(rows.map((r) => r.event_id));
+      }
       // ── M3: Mission Records ─────────────────────────────────────────────────
       upsertMission(mission) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -11330,6 +11479,145 @@ var init_mesh_events_utils = __esm({
 function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
   return expandDaemonIdForms(coordinatorDaemonId);
 }
+function isMeshProtocolV2EnforceEnabled() {
+  const raw = readNonEmptyString2(process.env.MESH_PROTOCOL_V2_ENFORCE);
+  if (!raw) return false;
+  const v = raw.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "on" || v === "yes";
+}
+function ledgerRecordQuarantinedEvent(event, reason) {
+  try {
+    const finalSummary = readMeshCompletionSummary(event.metadataEvent || {});
+    appendLedgerEntry(event.meshId, {
+      kind: "event_held",
+      ...event.nodeId ? { nodeId: event.nodeId } : {},
+      payload: {
+        event: event.event,
+        reason,
+        recoverable: true,
+        nodeLabel: event.nodeLabel,
+        ...event.workspace ? { workspace: event.workspace } : {},
+        targetCoordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
+        ...readNonEmptyString2(event.eventId) ? { eventId: event.eventId } : {},
+        queuedAt: event.queuedAt,
+        ...finalSummary ? { finalSummary } : {}
+      }
+    });
+  } catch (e) {
+    LOG.warn("MeshEventsV2", `Failed to ledger-record v2-quarantined ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
+  }
+}
+function getMeshV2DrainCounters() {
+  return { ...meshV2DrainCounters };
+}
+function warnV2Once(key2, message) {
+  if (warnedV2Violations.has(key2)) return;
+  warnedV2Violations.add(key2);
+  if (warnedV2Violations.size > 2e3) {
+    const first = warnedV2Violations.values().next().value;
+    if (first !== void 0) warnedV2Violations.delete(first);
+  }
+  LOG.warn("MeshEventsV2", message);
+}
+function resolveDrainerIdentity(daemonIds, explicit) {
+  if (explicit) return explicit;
+  return coordinatorIdentityFromEmitFields({ daemonId: daemonIds[0] });
+}
+function isV2Event(event) {
+  return event.protocolVersion === MESH_PROTOCOL_VERSION_V2;
+}
+function runIdIsDaemonFormFallback(identity) {
+  return daemonIdsEquivalent(identity.coordinatorRunId, identity.daemonId);
+}
+function identityDeliversTo(intendedFor, drainer) {
+  if (runIdIsDaemonFormFallback(intendedFor) && runIdIsDaemonFormFallback(drainer)) {
+    if (!daemonIdsEquivalent(intendedFor.daemonId, drainer.daemonId)) return false;
+    if (intendedFor.sessionId && drainer.sessionId) {
+      return intendedFor.sessionId === drainer.sessionId;
+    }
+    return true;
+  }
+  return coordinatorIdentityEquals(intendedFor, drainer);
+}
+function routeV2EventsForDrainer(events, drainer, ctx) {
+  if (!drainer) return events;
+  const enforce = isMeshProtocolV2EnforceEnabled();
+  const bump = (k) => {
+    if (ctx.countMetrics) meshV2DrainCounters[k]++;
+  };
+  const kept = [];
+  for (const event of events) {
+    if (!isV2Event(event)) {
+      if (enforce) {
+        bump("v1UnversionedQuarantined");
+        if (ctx.countMetrics) ledgerRecordQuarantinedEvent(event, "v2_enforce_unversioned_quarantined");
+        warnV2Once(
+          `${event.meshId}::${event.eventId ?? event.event}::v1-quarantined`,
+          `v2 ENFORCE: unversioned ${event.event} on mesh ${event.meshId} QUARANTINED (no v2 envelope \u2014 held back, not delivered; ledger-recorded recoverable). A producer path still emits v1.`
+        );
+        continue;
+      }
+      bump("v1BroadcastAccepted");
+      kept.push(event);
+      continue;
+    }
+    let validated;
+    try {
+      validated = assertPendingMeshCoordinatorEventV2(event);
+    } catch (e) {
+      if (enforce) {
+        bump("v2ValidationFailedQuarantined");
+        if (ctx.countMetrics) ledgerRecordQuarantinedEvent(event, "v2_enforce_validation_failed_quarantined");
+        warnV2Once(
+          `${event.meshId}::${event.eventId ?? event.event}::invalid-quarantined`,
+          `v2 ENFORCE: envelope validation failed for ${event.event} on mesh ${event.meshId} \u2014 QUARANTINED (held back, not delivered; ledger-recorded recoverable): ${e?.message || e}`
+        );
+        continue;
+      }
+      bump("v2ValidationFailedAccepted");
+      warnV2Once(
+        `${event.meshId}::${event.eventId ?? event.event}::invalid`,
+        `v2 envelope validation failed for ${event.event} on mesh ${event.meshId} \u2014 PASSED THROUGH (accept mode): ${e?.message || e}`
+      );
+      kept.push(event);
+      continue;
+    }
+    const eventId = validated.eventId;
+    if (ctx.batchSeen.has(eventId) || ctx.alreadyDrained(eventId)) {
+      bump("v2DedupSkipped");
+      continue;
+    }
+    if (validated.scope !== "unicast") {
+      if (shouldDeliverPendingEventToCoordinator(validated, drainer)) {
+        ctx.batchSeen.add(eventId);
+        bump("v2Delivered");
+        kept.push(event);
+      } else {
+        bump("v2RoutedAway");
+      }
+      continue;
+    }
+    if (validated.intendedFor && identityDeliversTo(validated.intendedFor, drainer)) {
+      ctx.batchSeen.add(eventId);
+      bump("v2Delivered");
+      kept.push(event);
+      continue;
+    }
+    const realRunIdMismatch = !runIdIsDaemonFormFallback(validated.intendedFor) || !runIdIsDaemonFormFallback(drainer);
+    if (validated.intendedFor && realRunIdMismatch && daemonIdsEquivalent(validated.intendedFor.daemonId, drainer.daemonId)) {
+      ctx.batchSeen.add(eventId);
+      bump("v2ReattributedToDrainer");
+      warnV2Once(
+        `${event.meshId}::${eventId}::reattributed`,
+        `v2 unicast ${event.event} on mesh ${event.meshId} re-attributed to current coordinator ${coordinatorIdentityKey(drainer)} (originating coordinatorRunId no longer live)`
+      );
+      kept.push(event);
+      continue;
+    }
+    bump("v2RoutedAway");
+  }
+  return kept;
+}
 function readRefineJobId2(event) {
   const metadata = readRecord5(event.metadataEvent) || event;
   const result = readRecord5(metadata.result);
@@ -11548,6 +11836,36 @@ function stampPendingEventV2(event, hint) {
     ...stamp.intendedFor ? { intendedFor: stamp.intendedFor } : {}
   };
 }
+function readCoordinatorIdentityFromWire(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const obj = raw;
+  const daemonId = readNonEmptyString2(obj.daemonId);
+  const coordinatorRunId = readNonEmptyString2(obj.coordinatorRunId);
+  if (!daemonId || !coordinatorRunId) return void 0;
+  const sessionId = readNonEmptyString2(obj.sessionId);
+  return { daemonId, coordinatorRunId, ...sessionId ? { sessionId } : {} };
+}
+function serializeV2EnvelopeToWire(event) {
+  const out = {};
+  if (event.protocolVersion) out.protocolVersion = event.protocolVersion;
+  if (readNonEmptyString2(event.eventId)) out.eventId = event.eventId;
+  if (event.scope) out.scope = event.scope;
+  if (event.dispatchedBy) out.dispatchedBy = event.dispatchedBy;
+  if (event.intendedFor) out.intendedFor = event.intendedFor;
+  return out;
+}
+function readV2EnvelopeFromWire(payload) {
+  const out = {};
+  if (payload.protocolVersion === MESH_PROTOCOL_VERSION_V2) out.protocolVersion = MESH_PROTOCOL_VERSION_V2;
+  const eventId = readNonEmptyString2(payload.eventId);
+  if (eventId) out.eventId = eventId;
+  if (isMeshEventScope(payload.scope)) out.scope = payload.scope;
+  const dispatchedBy = readCoordinatorIdentityFromWire(payload.dispatchedBy);
+  if (dispatchedBy) out.dispatchedBy = dispatchedBy;
+  const intendedFor = readCoordinatorIdentityFromWire(payload.intendedFor);
+  if (intendedFor) out.intendedFor = intendedFor;
+  return out;
+}
 function queuePendingMeshCoordinatorEvent(rawEvent, hint) {
   const event = stampPendingEventV2(rawEvent, hint);
   try {
@@ -11670,6 +11988,12 @@ function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId, opts) {
   if (!meshId) return [];
   const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
   const primaryDaemonId = daemonIds[0];
+  const drainer = resolveDrainerIdentity(daemonIds, opts?.drainerIdentity);
+  let priorDrainedEventIds = /* @__PURE__ */ new Set();
+  try {
+    priorDrainedEventIds = MeshRuntimeStore.getInstance().drainedEventIdsForMesh(meshId);
+  } catch {
+  }
   const onlyEvents = opts?.onlyEvents;
   const matchesFilter = (eventName) => !onlyEvents || onlyEvents.has(eventName);
   const merged = [];
@@ -11716,7 +12040,12 @@ function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId, opts) {
     for (const event of filtered) pushUnique(event);
   }
   if (merged.length === 0) return [];
-  return reconcilePendingMeshCoordinatorEvents(meshId, merged);
+  const routed = routeV2EventsForDrainer(merged, drainer, {
+    alreadyDrained: (eventId) => priorDrainedEventIds.has(eventId),
+    batchSeen: /* @__PURE__ */ new Set(),
+    countMetrics: true
+  });
+  return reconcilePendingMeshCoordinatorEvents(meshId, routed);
 }
 function retractPendingDispatchBlockedEvent(meshId, taskId, coordinatorDaemonId) {
   if (!meshId || !taskId) return 0;
@@ -11747,9 +12076,15 @@ function retractPendingDispatchBlockedEvent(meshId, taskId, coordinatorDaemonId)
   }
   return removed;
 }
-function getPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
+function getPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId, opts) {
   if (!meshId) return [];
   const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
+  const drainer = resolveDrainerIdentity(daemonIds, opts?.drainerIdentity);
+  let priorDrainedEventIds = /* @__PURE__ */ new Set();
+  try {
+    priorDrainedEventIds = MeshRuntimeStore.getInstance().drainedEventIdsForMesh(meshId);
+  } catch {
+  }
   const merged = [];
   const seenFingerprints = /* @__PURE__ */ new Set();
   const pushUnique = (event) => {
@@ -11773,7 +12108,12 @@ function getPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   for (const event of readPendingMeshCoordinatorEventsFromDisk(meshId, daemonIds)) {
     pushUnique(event);
   }
-  return reconcilePendingMeshCoordinatorEvents(meshId, merged);
+  const routed = routeV2EventsForDrainer(merged, drainer, {
+    alreadyDrained: (eventId) => priorDrainedEventIds.has(eventId),
+    batchSeen: /* @__PURE__ */ new Set(),
+    countMetrics: false
+  });
+  return reconcilePendingMeshCoordinatorEvents(meshId, routed);
 }
 function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   if (!meshId) return;
@@ -11789,7 +12129,7 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
     }
   }
 }
-var import_fs11, import_path10, import_crypto8, REFINE_TERMINAL_EVENTS, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
+var import_fs11, import_path10, import_crypto8, REFINE_TERMINAL_EVENTS, meshV2DrainCounters, warnedV2Violations, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
 var init_mesh_events_pending = __esm({
   "src/mesh/mesh-events-pending.ts"() {
     "use strict";
@@ -11803,6 +12143,32 @@ var init_mesh_events_pending = __esm({
     init_dist();
     init_contracts();
     REFINE_TERMINAL_EVENTS = /* @__PURE__ */ new Set(["refine:completed", "refine:failed"]);
+    meshV2DrainCounters = {
+      /** v2 events that passed validation and unicast/broadcast routing → delivered. */
+      v2Delivered: 0,
+      /** v2 unicast events skipped because intendedFor addressed another coordinator. */
+      v2RoutedAway: 0,
+      /** v2 events skipped because their eventId was already drained (idempotency). */
+      v2DedupSkipped: 0,
+      /** 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: 0,
+      /** unicast events re-attributed to the drainer via daemon-core match (a
+       *  coordinatorRunId change orphaned them). */
+      v2ReattributedToDrainer: 0,
+      /** v1 (unversioned) events passed through as broadcast (rollout baseline). */
+      v1BroadcastAccepted: 0,
+      /** 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: 0,
+      /** 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: 0
+    };
+    warnedV2Violations = /* @__PURE__ */ new Set();
     TERMINAL_COMPLETION_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
     MAX_PENDING_EVENTS_BYTES = 100 * 1024;
     MAX_PENDING_EVENTS_KEEP = 50;
@@ -12853,7 +13219,38 @@ async function detectCLI(cliId, providerLoader, options) {
   const all = await detectCLIs(providerLoader, options);
   return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
-var import_child_process2, os6, path12, import_fs12;
+function buildProviderVersions(detected) {
+  const out = {};
+  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;
+}
+function refreshProviderVersionsSnapshot(providerLoader) {
+  if (providerVersionsRefreshInFlight) return providerVersionsRefreshInFlight;
+  providerVersionsRefreshInFlight = (async () => {
+    try {
+      const detected = await detectCLIs(providerLoader, { includeVersion: true });
+      cachedProviderVersions = buildProviderVersions(detected);
+      cachedProviderVersionsAt = Date.now();
+    } catch {
+    } finally {
+      providerVersionsRefreshInFlight = null;
+    }
+  })();
+  return providerVersionsRefreshInFlight;
+}
+function getCachedProviderVersions(providerLoader) {
+  const stale = Date.now() - cachedProviderVersionsAt > PROVIDER_VERSIONS_TTL_MS;
+  if (stale) {
+    void refreshProviderVersionsSnapshot(providerLoader);
+  }
+  return { ...cachedProviderVersions };
+}
+var import_child_process2, os6, path12, import_fs12, PROVIDER_VERSIONS_TTL_MS, cachedProviderVersions, cachedProviderVersionsAt, providerVersionsRefreshInFlight;
 var init_cli_detector = __esm({
   "src/detection/cli-detector.ts"() {
     "use strict";
@@ -12862,6 +13259,10 @@ var init_cli_detector = __esm({
     path12 = __toESM(require("path"));
     import_fs12 = require("fs");
     init_provider_cli_shared();
+    PROVIDER_VERSIONS_TTL_MS = 5 * 60 * 1e3;
+    cachedProviderVersions = {};
+    cachedProviderVersionsAt = 0;
+    providerVersionsRefreshInFlight = null;
   }
 });
 
@@ -17550,7 +17951,13 @@ function injectMeshSystemMessage(components, args) {
     ...workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {},
     // 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 } : {}
+    ...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}` : ""})`);
@@ -17663,7 +18070,12 @@ function handleMeshForwardEvent(components, payload) {
     nodeId,
     nodeLabel,
     event: eventName,
-    metadataEvent: buildRelayMetadataEvent(payload)
+    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)
   });
 }
 function enqueueCoordinatorForwardPush(coordinatorDaemonId, run) {
@@ -17958,6 +18370,21 @@ function resolveAckedDeathDeadlineMs() {
 function resolveAckedTranscriptFastTrackGraceMs() {
   return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_TRANSCRIPT_FASTTRACK_GRACE_MS", 4e4, 0, 5 * 6e4);
 }
+function getMeshV2BackstopCounters() {
+  return { ...meshV2BackstopCounters };
+}
+function meshProtocolV2EnforceOn() {
+  const raw = process.env.MESH_PROTOCOL_V2_ENFORCE;
+  if (typeof raw !== "string") return false;
+  const v = raw.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "on" || v === "yes";
+}
+function recordBackstopFire(kind, detail) {
+  meshV2BackstopCounters[kind]++;
+  if (meshProtocolV2EnforceOn()) {
+    LOG.warn("MeshReconcileV2", `v2 ENFORCE last-resort backstop fired (${kind}): ${detail}. Under a healthy v2 completion contract this should be 0 \u2014 a worker's real terminal emit was lost/late.`);
+  }
+}
 function inFlightSynthKey(meshId, taskId) {
   return `${meshId}::${taskId}`;
 }
@@ -18872,6 +19299,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
     };
     const synthKey = inFlightSynthKey(mesh.id, taskId);
     const isAcked = dispatch.status === "acked";
+    let backstopKind;
     let payload = null;
     let readFailed = false;
     try {
@@ -18936,6 +19364,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
         const idleHeldMs = nowMs - idleSinceMs;
         if (idleHeldMs >= fastTrackGraceMs) {
           fastTrackReady = true;
+          backstopKind = "ackedHoldFastTrackFired";
           LOG.info("MeshReconcile", `Acked-hold transcript fast-track: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle WITH a final assistant message for ${Math.round(idleHeldMs / 1e3)}s continuous (grace ${Math.round(fastTrackGraceMs / 1e3)}s) \u2014 promoting the synth ahead of the ${Math.round(deathDeadlineMs / 1e3)}s death backstop; the worker's real emit was lost/late and a later one no-ops idempotently.`);
         }
       } else if (holdState?.transcriptIdleSinceMs !== void 0) {
@@ -18946,6 +19375,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
         continue;
       }
       if (!fastTrackReady) {
+        backstopKind = "ackedHoldDeathDeadlineFired";
         LOG.warn("MeshReconcile", `Acked-hold death deadline reached: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) still idle ${Math.round(sinceAckMs / 1e3)}s after the ack (deadline ${Math.round(deathDeadlineMs / 1e3)}s) \u2014 synthesizing the missing completion as a notification-loss net (a real emit, if it ever lands, no-ops idempotently).`);
       }
     }
@@ -18990,6 +19420,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
         source: "daemon_reconcile_transcript_completion"
       });
       if (result.reconciled) {
+        recordBackstopFire(backstopKind ?? "phase4SynthesisFired", `task ${taskId} on node ${nodeId} (mesh ${mesh.id}), kind=${result.kind}`);
         LOG.info("MeshReconcile", `Synthesized missing completion (${result.kind}) for task ${taskId} on node ${nodeId} (mesh ${mesh.id})`);
       }
     } catch (e) {
@@ -19090,7 +19521,14 @@ function buildForwardPayloadFromPending(event) {
     ...(() => {
       const tid = readNonEmptyString2(metadata.taskId) || readNonEmptyString2(metadata.meshActiveTaskId);
       return tid ? { taskId: tid } : {};
-    })()
+    })(),
+    // T4 (B3b): carry the v2 envelope (protocolVersion/eventId/scope/dispatchedBy/
+    // intendedFor) across the P2P relay boundary at the TOP LEVEL. These live on the
+    // pending event itself, not inside metadataEvent, so without this the remote pull
+    // re-queue would re-stamp a fresh eventId — breaking cross-machine idempotency and
+    // downgrading the relayed completion to v1 broadcast routing. Spread LAST so the
+    // authoritative envelope always wins over any stale key the metadata spread carried.
+    ...serializeV2EnvelopeToWire(event)
   };
 }
 function setupMeshReconcileLoop(components) {
@@ -19112,7 +19550,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, rehydratedHoldMeshes, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, rehydratedHoldMeshes, meshV2BackstopCounters, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -19140,6 +19578,14 @@ var init_mesh_reconcile_loop = __esm({
     ACKED_DEATH_CONSECUTIVE_READ_FAILURES = 3;
     inFlightAckedHoldState = /* @__PURE__ */ new Map();
     rehydratedHoldMeshes = /* @__PURE__ */ new Set();
+    meshV2BackstopCounters = {
+      /** PHASE-4 transcript synthesis actually reconciled a missing completion. */
+      phase4SynthesisFired: 0,
+      /** Acked-hold transcript fast-track promoted a synth ahead of the death deadline. */
+      ackedHoldFastTrackFired: 0,
+      /** Acked-hold death-deadline backstop released a held synth (the 8-min net). */
+      ackedHoldDeathDeadlineFired: 0
+    };
     coordinatorModalParkState = /* @__PURE__ */ new Map();
     heldEventLedgerRecorded = /* @__PURE__ */ new Set();
     ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
@@ -19159,14 +19605,19 @@ __export(mesh_events_exports, {
   __resetMeshWorkspaceCacheForTests: () => __resetMeshWorkspaceCacheForTests,
   clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
   drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
+  getMeshV2BackstopCounters: () => getMeshV2BackstopCounters,
+  getMeshV2DrainCounters: () => getMeshV2DrainCounters,
   getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
   handleMeshForwardEvent: () => handleMeshForwardEvent,
   isMeshCoordinatorEvent: () => isMeshCoordinatorEvent,
+  isMeshProtocolV2EnforceEnabled: () => isMeshProtocolV2EnforceEnabled,
   isSessionActivelyGenerating: () => isSessionActivelyGenerating,
   queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
+  readV2EnvelopeFromWire: () => readV2EnvelopeFromWire,
   reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
   resolveCoordinatorDrainDeliverability: () => resolveCoordinatorDrainDeliverability,
   runMeshReconcileTick: () => runMeshReconcileTick,
+  serializeV2EnvelopeToWire: () => serializeV2EnvelopeToWire,
   setupMeshEventForwarding: () => setupMeshEventForwarding,
   setupMeshReconcileLoop: () => setupMeshReconcileLoop,
   shouldHoldPendingDrainForBusyLocalCoordinator: () => shouldHoldPendingDrainForBusyLocalCoordinator,
@@ -25109,6 +25560,7 @@ __export(index_exports, {
   readLedgerSliceFromStore: () => readLedgerSliceFromStore,
   readMeshCompletionSummary: () => readMeshCompletionSummary,
   readOperatingNotes: () => readOperatingNotes,
+  readV2EnvelopeFromWire: () => readV2EnvelopeFromWire,
   reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
   recordCompletionConflict: () => recordCompletionConflict,
   recordDebugTrace: () => recordDebugTrace,
@@ -25149,6 +25601,7 @@ __export(index_exports, {
   runMeshWorktreeBootstrap: () => runMeshWorktreeBootstrap,
   saveConfig: () => saveConfig,
   saveState: () => saveState,
+  serializeV2EnvelopeToWire: () => serializeV2EnvelopeToWire,
   setDebugRuntimeConfig: () => setDebugRuntimeConfig,
   setLogLevel: () => setLogLevel,
   setMagiKindPanel: () => setMagiKindPanel,
@@ -25917,7 +26370,7 @@ var defaultSnapshotStore = createGitSnapshotStore({
   getStatus: (workspace) => getGitRepoStatus(workspace),
   getDiffSummary: (workspace) => getGitDiffSummary(workspace)
 });
-function createDefaultGitCommandServices() {
+function createDefaultGitCommandServices(overrides) {
   return {
     getStatus: ({ workspace, refreshUpstream }) => getGitRepoStatus(workspace, { refreshUpstream }),
     getDiffSummary: ({ workspace, base }) => getGitDiffSummary(workspace, base ? { baseRef: base } : {}),
@@ -25935,7 +26388,8 @@ function createDefaultGitCommandServices() {
     stashPop: async ({ workspace, stashRef }) => gitStashPop(workspace, stashRef),
     checkoutFiles: async ({ workspace, paths }) => gitCheckoutFiles(workspace, paths),
     getRemoteUrl: async ({ workspace, remote = "origin" }) => gitGetRemoteUrl(workspace, remote),
-    push: async ({ workspace, remote = "origin", branch, setUpstream = false }) => gitPush(workspace, remote, branch, setUpstream)
+    push: async ({ workspace, remote = "origin", branch, setUpstream = false }) => gitPush(workspace, remote, branch, setUpstream),
+    ...overrides?.getReporterProviderVersions ? { getReporterProviderVersions: overrides.getReporterProviderVersions } : {}
   };
 }
 var defaultGitCommandServices = createDefaultGitCommandServices();
@@ -26022,12 +26476,23 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
           return void 0;
         }
       })();
+      const reporterVersions = (() => {
+        try {
+          return services.getReporterProviderVersions?.() ?? {};
+        } catch {
+          return {};
+        }
+      })();
+      const reporterProviderVersions = reporterVersions.providerVersions && Object.keys(reporterVersions.providerVersions).length > 0 ? reporterVersions.providerVersions : void 0;
+      const reporterDaemonBuildVersion = typeof reporterVersions.daemonBuildVersion === "string" && reporterVersions.daemonBuildVersion.trim() ? reporterVersions.daemonBuildVersion.trim() : void 0;
       return {
         success: true,
         status,
         reporterPlatform: process.platform,
         reporterArch: process.arch,
-        ...reporterMachineNickname ? { reporterMachineNickname } : {}
+        ...reporterMachineNickname ? { reporterMachineNickname } : {},
+        ...reporterProviderVersions ? { reporterProviderVersions } : {},
+        ...reporterDaemonBuildVersion ? { reporterDaemonBuildVersion } : {}
       };
     }
     case "git_diff_summary": {
@@ -43458,10 +43923,10 @@ var CliProviderInstance = class _CliProviderInstance {
     if (buttonIndex < 0 || !hasReliableConsentAnchor) {
       return autoApproveActive;
     }
+    const affirmativeAnchor = normalizeApprovalLabel(buttonLabel);
     const modalSignature = [
       typeof modal?.message === "string" ? modal.message.trim() : "",
-      buttons.join("|"),
-      buttonIndex
+      affirmativeAnchor
     ].join("::");
     const approvalEntrySeq = typeof adapterStatus?.approvalEntrySeq === "number" ? adapterStatus.approvalEntrySeq : 0;
     const busySignature = `${approvalEntrySeq}::${modalSignature}`;
@@ -53068,7 +53533,12 @@ var meshEventsHandlers = {
       return { success: true, events: [], heldForBusyLocalCoordinator: true, hasLiveCliCoordinator };
     }
     const events = drainPendingMeshCoordinatorEvents(meshId || void 0, coordinatorDaemonId);
-    return { success: true, events, hasLiveCliCoordinator, ...selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {} };
+    const meshProtocolV2Counters = {
+      enforce: isMeshProtocolV2EnforceEnabled(),
+      drain: { ...getMeshV2DrainCounters() },
+      backstop: { ...getMeshV2BackstopCounters() }
+    };
+    return { success: true, events, hasLiveCliCoordinator, meshProtocolV2Counters, ...selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {} };
   },
   interactive_prompt_response: async (ctx, args) => {
     const sessionId = typeof args?.targetSessionId === "string" && args.targetSessionId.trim() ? args.targetSessionId.trim() : typeof args?.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : "";
@@ -53900,6 +54370,12 @@ var meshStatusHandlers = {
           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: [],
@@ -54088,6 +54564,11 @@ var meshStatusHandlers = {
       const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : ctx.deps.statusInstanceId || void 0;
       const pendingCoordinatorEvents = getPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
       const unroutableDeliveries = getRecentUnroutableDeliveries();
+      const meshProtocolV2Counters = {
+        enforce: isMeshProtocolV2EnforceEnabled(),
+        drain: { ...getMeshV2DrainCounters() },
+        backstop: { ...getMeshV2BackstopCounters() }
+      };
       const previewFreshness = (() => {
         const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs27.existsSync(candidate));
         return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
@@ -54177,6 +54658,7 @@ var meshStatusHandlers = {
         ...historicalSessions ? { historicalSessions } : {},
         ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
         ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {},
+        meshProtocolV2Counters,
         activeRefineJobs: Array.from(ctx.runningRefineJobs.values()).filter((job) => job.meshId === meshId).map((job) => ({
           jobId: job.jobId,
           nodeId: job.targetNodeId,
@@ -54186,12 +54668,13 @@ var meshStatusHandlers = {
           targetCoordinatorDaemonId: job.targetCoordinatorDaemonId
         }))
       };
-      const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult;
+      const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, meshProtocolV2Counters: _meshProtocolV2Counters, ...cacheableStatusResult } = statusResult;
       const rememberedStatus = verboseMissions ? cacheableStatusResult : ctx.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
       const returnedStatus = {
         ...rememberedStatus,
         ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
-        ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {}
+        ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {},
+        meshProtocolV2Counters
       };
       logRepoMeshStatusDebug("return_live", {
         meshId,
@@ -54673,7 +55156,13 @@ function buildLivePeerGitConnection(connection, timestamp = (/* @__PURE__ */ new
 }
 function recordInlineMeshDirectGitTruth(node, git, source) {
   if (!node || typeof node !== "object" || Array.isArray(node)) {
-    return { reporterPlatform: null, reporterArch: null, reporterMachineNickname: null };
+    return {
+      reporterPlatform: null,
+      reporterArch: null,
+      reporterMachineNickname: null,
+      reporterProviderVersions: null,
+      reporterDaemonBuildVersion: null
+    };
   }
   const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
   const updatedAt = new Date(checkedAt).toISOString();
@@ -54700,7 +55189,28 @@ function recordInlineMeshDirectGitTruth(node, git, source) {
   if (reporterArch) node.reportedArch = reporterArch;
   const reporterMachineNickname = readStringValue(git.reporterMachineNickname) ?? null;
   if (reporterMachineNickname) node.machineNickname = reporterMachineNickname;
-  return { reporterPlatform, reporterArch, reporterMachineNickname };
+  const reporterProviderVersions = readProviderVersionsRecord(git.reporterProviderVersions);
+  if (reporterProviderVersions) node.reportedProviderVersions = reporterProviderVersions;
+  const reporterDaemonBuildVersion = readStringValue(git.reporterDaemonBuildVersion) ?? null;
+  if (reporterDaemonBuildVersion) node.reportedDaemonBuildVersion = reporterDaemonBuildVersion;
+  return {
+    reporterPlatform,
+    reporterArch,
+    reporterMachineNickname,
+    reporterProviderVersions,
+    reporterDaemonBuildVersion
+  };
+}
+function readProviderVersionsRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const out = {};
+  for (const [key2, raw] of Object.entries(value)) {
+    if (typeof key2 !== "string" || !key2.trim()) continue;
+    const version = typeof raw === "string" ? raw.trim() : "";
+    if (!version) continue;
+    out[key2] = version;
+  }
+  return Object.keys(out).length > 0 ? out : null;
 }
 function stampNodeReporterPlatform(node, platform10, arch2) {
   if (!node || typeof node !== "object" || Array.isArray(node)) return;
@@ -54724,8 +55234,18 @@ function persistNodeReporterPlatform(meshSource, mesh, nodeId, reporter) {
   const reportedPlatform = reporter.reporterPlatform ?? void 0;
   const reportedArch = reporter.reporterArch ?? void 0;
   const reportedMachineNickname = reporter.reporterMachineNickname ?? void 0;
-  if (!reportedPlatform && !reportedArch && !reportedMachineNickname) return;
-  void Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports)).then(({ updateNode: updateNode2 }) => updateNode2(meshId, nodeId, { reportedPlatform, reportedArch, reportedMachineNickname })).catch(() => {
+  const reportedProviderVersions = reporter.reporterProviderVersions ?? void 0;
+  const reportedDaemonBuildVersion = reporter.reporterDaemonBuildVersion ?? void 0;
+  if (!reportedPlatform && !reportedArch && !reportedMachineNickname && !reportedProviderVersions && !reportedDaemonBuildVersion) {
+    return;
+  }
+  void Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports)).then(({ updateNode: updateNode2 }) => updateNode2(meshId, nodeId, {
+    reportedPlatform,
+    reportedArch,
+    reportedMachineNickname,
+    reportedProviderVersions,
+    reportedDaemonBuildVersion
+  })).catch(() => {
   });
 }
 function buildCachedInlineMeshGitStatus(node) {
@@ -55382,6 +55902,10 @@ async function probeRemoteMeshGitStatus(args) {
   if (reporterPlatform) git.reporterPlatform = reporterPlatform;
   if (reporterArch) git.reporterArch = reporterArch;
   if (reporterMachineNickname) git.reporterMachineNickname = reporterMachineNickname;
+  const reporterProviderVersions = readProviderVersionsRecord(remoteResult?.reporterProviderVersions);
+  if (reporterProviderVersions) git.reporterProviderVersions = reporterProviderVersions;
+  const reporterDaemonBuildVersion = readStringValue(remoteResult?.reporterDaemonBuildVersion);
+  if (reporterDaemonBuildVersion) git.reporterDaemonBuildVersion = reporterDaemonBuildVersion;
   return git;
 }
 var MESH_DIRECT_PROBE_MAX_RETRIES = 2;
@@ -67313,6 +67837,7 @@ function launchIDE(ide, workspacePath) {
 
 // src/boot/daemon-lifecycle.ts
 init_cli_detector();
+init_build_info();
 
 // src/sessions/registry.ts
 var SessionRegistry = class {
@@ -67514,7 +68039,19 @@ async function initDaemonComponents(config) {
     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?.();
@@ -68237,6 +68774,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   readLedgerSliceFromStore,
   readMeshCompletionSummary,
   readOperatingNotes,
+  readV2EnvelopeFromWire,
   reconcileDirectDispatchCompletionFromTranscript,
   recordCompletionConflict,
   recordDebugTrace,
@@ -68277,6 +68815,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   runMeshWorktreeBootstrap,
   saveConfig,
   saveState,
+  serializeV2EnvelopeToWire,
   setDebugRuntimeConfig,
   setLogLevel,
   setMagiKindPanel,