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

package/dist/index.mjs

@@ -404,10 +404,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 ? "ed8842e811aa362a2b4cc530498bc1fc7e1a7e4a" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "ed8842e8" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.461" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-04T15:00:03.344Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3258,6 +3258,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")) {
@@ -3601,9 +3607,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}`);
@@ -4167,6 +4180,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";
@@ -4195,12 +4300,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",
@@ -7529,6 +7650,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();
@@ -11326,6 +11475,95 @@ import { randomUUID as randomUUID8 } from "crypto";
 function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
   return expandDaemonIdForms(coordinatorDaemonId);
 }
+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 bump = (k) => {
+    if (ctx.countMetrics) meshV2DrainCounters[k]++;
+  };
+  const kept = [];
+  for (const event of events) {
+    if (!isV2Event(event)) {
+      bump("v1BroadcastAccepted");
+      kept.push(event);
+      continue;
+    }
+    let validated;
+    try {
+      validated = assertPendingMeshCoordinatorEventV2(event);
+    } catch (e) {
+      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);
@@ -11544,6 +11782,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 {
@@ -11666,6 +11934,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 = [];
@@ -11712,7 +11986,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;
@@ -11743,9 +12022,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) => {
@@ -11769,7 +12054,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;
@@ -11785,7 +12075,7 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
     }
   }
 }
-var REFINE_TERMINAL_EVENTS, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
+var 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";
@@ -11796,6 +12086,24 @@ 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
+    };
+    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,10 +13161,46 @@ async function detectCLI(cliId, providerLoader, options) {
   const all = await detectCLIs(providerLoader, options);
   return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
+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 PROVIDER_VERSIONS_TTL_MS, cachedProviderVersions, cachedProviderVersionsAt, providerVersionsRefreshInFlight;
 var init_cli_detector = __esm({
   "src/detection/cli-detector.ts"() {
     "use strict";
     init_provider_cli_shared();
+    PROVIDER_VERSIONS_TTL_MS = 5 * 60 * 1e3;
+    cachedProviderVersions = {};
+    cachedProviderVersionsAt = 0;
+    providerVersionsRefreshInFlight = null;
   }
 });
 
@@ -17545,7 +17889,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}` : ""})`);
@@ -17658,7 +18008,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) {
@@ -19085,7 +19440,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) {
@@ -19159,9 +19521,11 @@ __export(mesh_events_exports, {
   isMeshCoordinatorEvent: () => isMeshCoordinatorEvent,
   isSessionActivelyGenerating: () => isSessionActivelyGenerating,
   queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
+  readV2EnvelopeFromWire: () => readV2EnvelopeFromWire,
   reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
   resolveCoordinatorDrainDeliverability: () => resolveCoordinatorDrainDeliverability,
   runMeshReconcileTick: () => runMeshReconcileTick,
+  serializeV2EnvelopeToWire: () => serializeV2EnvelopeToWire,
   setupMeshEventForwarding: () => setupMeshEventForwarding,
   setupMeshReconcileLoop: () => setupMeshReconcileLoop,
   shouldHoldPendingDrainForBusyLocalCoordinator: () => shouldHoldPendingDrainForBusyLocalCoordinator,
@@ -25501,7 +25865,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 } : {}),
@@ -25519,7 +25883,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();
@@ -25606,12 +25971,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": {
@@ -53496,6 +53872,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: [],
@@ -54269,7 +54651,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();
@@ -54296,7 +54684,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;
@@ -54320,8 +54729,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) {
@@ -54978,6 +55397,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;
@@ -66919,6 +67342,7 @@ function launchIDE(ide, workspacePath) {
 
 // src/boot/daemon-lifecycle.ts
 init_cli_detector();
+init_build_info();
 
 // src/sessions/registry.ts
 var SessionRegistry = class {
@@ -67120,7 +67544,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?.();
@@ -67842,6 +68278,7 @@ export {
   readLedgerSliceFromStore,
   readMeshCompletionSummary,
   readOperatingNotes,
+  readV2EnvelopeFromWire,
   reconcileDirectDispatchCompletionFromTranscript,
   recordCompletionConflict,
   recordDebugTrace,
@@ -67882,6 +68319,7 @@ export {
   runMeshWorktreeBootstrap,
   saveConfig,
   saveState,
+  serializeV2EnvelopeToWire,
   setDebugRuntimeConfig,
   setLogLevel,
   setMagiKindPanel,