@adhdev/daemon-core 0.9.82-rc.514 → 0.9.82-rc.516

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

@@ -11,6 +11,7 @@
  * (e.g. `from '.../commands/router.js'`) keep working.
  */
 import type { ProviderLoader } from '../providers/provider-loader.js';
+import type { MeshReportedMemberState } from '../repo-mesh-types.js';
 import { awaitWithWarmupDeadline } from '../mesh/mesh-warmup-deadline.js';
 export declare function readProviderPriorityFromPolicy(policy: unknown): string[];
 /**
@@ -51,6 +52,7 @@ export declare function recordInlineMeshDirectGitTruth(node: any, git: Record<st
     reporterMachineNickname: string | null;
     reporterProviderVersions: Record<string, string> | null;
     reporterDaemonBuildVersion: string | null;
+    reportedMemberState: MeshReportedMemberState | null;
 };
 /**
  * Persist the live self-reported platform/arch onto the local meshes.json node
@@ -69,6 +71,7 @@ export declare function persistNodeReporterPlatform(meshSource: 'inline_cache' |
     reporterMachineNickname?: string | null;
     reporterProviderVersions?: Record<string, string> | null;
     reporterDaemonBuildVersion?: string | null;
+    reportedMemberState?: MeshReportedMemberState | null;
 }): void;
 export declare function inlineMeshCarriesTransientNodeTruth(inlineMesh: any): boolean;
 export declare function readInlineMeshNodeId(node: any): string;

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

@@ -13,8 +13,19 @@ import { type NodeCapabilitySlot } from '@adhdev/mesh-shared';
 /** Ordered, de-duplicated providerPriority from a node policy (defensive). */
 export declare function normalizeProviderPriority(policy: unknown): string[];
 /**
- * Resolve a node's capability slots: explicit `policy.slots` when present, else
- * derived from the legacy `providerPriority` + machine-global difficultyBrains.
+ * Resolve a node's capability slots — coordinator-owned config is the single source
+ * of truth for ALL nodes (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix).
+ *
+ * The coordinator's local meshes.json owns `policy.slots` for every node in the mesh
+ * (self AND remote members alike — a remote member's mesh config lives on the
+ * coordinator, its own on-disk meshes.json is empty). So slots resolve directly from
+ * the coordinator's locally-owned `node.policy.slots`, with no remote reporter
+ * round-trip: there is no per-node "reported slots" mirror to consult.
+ *
+ * Precedence:
+ *   1. `policy.slots` — coordinator-owned, authoritative for self and remote alike.
+ *   2. Legacy-derived from `providerPriority` + machine-global difficultyBrains.
+ *
  * (The former per-provider `providerRoles` cap has been removed; a persisted
  * meshes.json is migrated to slots on load, so by the time a node reaches routing
  * its cap already lives on `slots[].maxParallel`.)

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

@@ -300,6 +300,32 @@ export interface RepoMeshRelatedRepo {
  * persisted meshes.json that still carries it is migrated to `slots` on load
  * (see migrateLoadedMeshConfig).
  */
+/**
+ * Unified mirrored member state — the per-machine RUNTIME facts a remote member
+ * self-reports (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix).
+ *
+ * A single self-reported observability envelope stamped by the daemon that OWNS a
+ * node's workspace and carried wholesale on the git_status envelope
+ * (reporterMemberState), consolidating the previously per-field self-heal of
+ * providerVersions and daemonBuildVersion. The coordinator ingests this whole object
+ * onto the mirrored remote node in one place
+ * (mesh-node-identity.recordInlineMeshDirectGitTruth).
+ *
+ * Source-of-truth model: provider VERSIONS + daemon BUILD are per-machine runtime
+ * facts (e.g. a member has claude-cli@2.1.168 while the coordinator has @2.1.170), so
+ * they are reported here. SLOTS are NOT reported — they are coordinator-owned config
+ * (node.policy.slots for every node, self and remote alike; see
+ * resolveNodeCapabilitySlots), a single source of truth on the coordinator with no
+ * reporter round-trip.
+ */
+export interface MeshReportedMemberState {
+    /** Reporter node's detected provider CLI/ACP versions (keyed by provider id). */
+    providerVersions?: Record<string, string>;
+    /** Reporter daemon's build version (getDaemonBuildInfo().version). */
+    daemonBuildVersion?: string;
+    /** Epoch ms the report was stamped; used for mirror staleness reasoning. */
+    lastReportedAt?: number;
+}
 export interface RepoMeshNodePolicy {
     readOnly?: boolean;
     canPush?: boolean;
@@ -634,6 +660,20 @@ export interface LocalMeshNodeEntry {
      *  owning daemon, carried on the git_status envelope (reporterDaemonBuildVersion)
      *  alongside the provider versions. Absent until first reported. */
     reportedDaemonBuildVersion?: string;
+    /**
+     * Unified mirrored "member state" self-reported by the daemon that owns this
+     * node's workspace, carried wholesale on the git_status envelope
+     * (reporterMemberState) and ingested by the coordinator in one place. It carries
+     * the per-machine RUNTIME facts (reportedProviderVersions, reportedDaemonBuildVersion)
+     * consolidated into one envelope — NOT slots, which are coordinator-owned config
+     * resolved from node.policy.slots for every node, not reported
+     * (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix). The legacy flat fields above stay
+     * populated in parallel during rollout for back-compat (see mesh-node-identity
+     * ingest). `lastReportedAt` is the epoch ms the report was stamped, so a
+     * partitioned node's mirror does not linger as fresh forever. Absent until the
+     * first envelope carrying it is ingested.
+     */
+    reportedMemberState?: MeshReportedMemberState;
     /**
      * The operator-set machine nickname (config.machineNickname) of the daemon
      * that owns this node's workspace. The local coordinator stamps its own

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.514",
+  "version": "0.9.82-rc.516",
   "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.514",
-    "@adhdev/session-host-core": "0.9.82-rc.514",
+    "@adhdev/mesh-shared": "0.9.82-rc.516",
+    "@adhdev/session-host-core": "0.9.82-rc.516",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/boot/daemon-lifecycle.ts

@@ -314,7 +314,18 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         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.
+            // providerVersions/build (the blue version chips) — these are per-machine
+            // RUNTIME facts (e.g. this node has claude-cli@2.1.168 while the
+            // coordinator has @2.1.170), so they stay reported. Non-blocking: reads a
+            // TTL cache, lazily refreshed. (setDefaultProviderLoader is registered
+            // above so getCachedProviderVersions is not empty — see the 380556d3
+            // version-chip lesson.)
+            //
+            // Slots are NOT reported: they are coordinator-owned config
+            // (node.policy.slots for every node, resolved via
+            // resolveNodeCapabilitySlots), not a per-machine runtime fact — the
+            // reporter round-trip for slots was removed (REMOTE-NODE-SLOTS-
+            // COORDINATOR-LOCAL fix).
             getReporterProviderVersions: () => {
                 const providerVersions = getCachedProviderVersions(providerLoader);
                 const daemonBuildVersion = getDaemonBuildInfo().version;

package/src/config/mesh-config.ts

@@ -21,6 +21,7 @@ import type {
     RepoMeshCoordinatorConfig,
     RepoMeshHostMetadata,
     RepoMeshDaemonRole,
+    MeshReportedMemberState,
 } from '../repo-mesh-types.js';
 import type { MagiKindPanelMap, MagiSlot, MagiTaskKind, DifficultyBrainMap, NodeCapabilitySlot } from '@adhdev/mesh-shared';
 import { normalizeDifficultyBrainMap, DEFAULT_DIFFICULTY_BRAINS, normalizeNodeCapabilitySlots, deriveSlotsFromLegacy } from '@adhdev/mesh-shared';
@@ -643,6 +644,13 @@ export function updateNode(
          *  is overwritten by the next report. */
         reportedProviderVersions?: Record<string, string>;
         reportedDaemonBuildVersion?: string;
+        /** Unified mirrored member state (per-machine runtime facts: provider versions
+         *  + daemon build + lastReportedAt) self-reported by the owning daemon on the
+         *  git_status envelope. Persisted wholesale so a remote node's version chips
+         *  survive a coordinator restart, mirroring the per-field reported* self-heal.
+         *  Slots are NOT carried — they are coordinator-owned config
+         *  (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix). */
+        reportedMemberState?: MeshReportedMemberState;
     },
 ): LocalMeshNodeEntry | undefined {
     const config = loadMeshConfig();
@@ -662,6 +670,12 @@ export function updateNode(
     if (opts.reportedDaemonBuildVersion && opts.reportedDaemonBuildVersion.trim()) {
         node.reportedDaemonBuildVersion = opts.reportedDaemonBuildVersion.trim();
     }
+    if (opts.reportedMemberState) {
+        // Whole-object replace (auto-detected observability, overwritten by the next
+        // report so a stale mirror never sticks — same policy as the flat reported*
+        // fields). normalizeReportedMemberState upstream guarantees a clean shape.
+        node.reportedMemberState = opts.reportedMemberState;
+    }
     if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
     if (Object.prototype.hasOwnProperty.call(opts, 'capabilities')) {
         // Explicit replace: normalize (trim/dedup/drop-empties); an empty result

package/src/git/git-commands.ts

@@ -109,7 +109,10 @@ export interface GitCommandServices {
    * same way it does platform/arch. Wired at daemon boot from the cached CLI
    * detection snapshot; omitted (⇒ versions not reported) when unavailable.
    */
-  getReporterProviderVersions?: () => { providerVersions?: Record<string, string>; daemonBuildVersion?: string };
+  getReporterProviderVersions?: (workspace?: string) => {
+    providerVersions?: Record<string, string>;
+    daemonBuildVersion?: string;
+  };
 }
 
 type GitCommandFailure = {
@@ -124,7 +127,13 @@ type GitCommandSuccess =
   // node's userOverrides.platform/arch (the fields capability-tag routing reads).
   // reporterMachineNickname carries the responding daemon's config.machineNickname
   // so the coordinator can populate node.machineNickname → the friendly display label.
-  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string; reporterMachineNickname?: string; reporterProviderVersions?: Record<string, string>; reporterDaemonBuildVersion?: string }
+  // reporterMemberState is the unified envelope carrying the reporter node's
+  // per-machine RUNTIME facts (provider versions + daemon build + lastReportedAt).
+  // Slots are NOT carried here — they are coordinator-owned config, not reported
+  // (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix). The legacy flat
+  // reporterProviderVersions/reporterDaemonBuildVersion fields are ALSO emitted for
+  // back-compat during a mixed-version-mesh rollout.
+  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string; reporterMachineNickname?: string; reporterProviderVersions?: Record<string, string>; reporterDaemonBuildVersion?: string; reporterMemberState?: { providerVersions?: Record<string, string>; daemonBuildVersion?: string; lastReportedAt?: number } }
   | { success: true; diffSummary: GitDiffSummary }
   | { success: true; diff: GitFileDiff }
   | { success: true; snapshot: GitSnapshot }
@@ -346,7 +355,7 @@ export async function handleGitCommand(
       // snapshot, so a cold cache simply omits the fields on this probe.
       const reporterVersions = (() => {
         try {
-          return services.getReporterProviderVersions?.() ?? {};
+          return services.getReporterProviderVersions?.(workspace) ?? {};
         } catch {
           return {};
         }
@@ -359,6 +368,20 @@ export async function handleGitCommand(
         typeof reporterVersions.daemonBuildVersion === 'string' && reporterVersions.daemonBuildVersion.trim()
           ? reporterVersions.daemonBuildVersion.trim()
           : undefined;
+      // Unified envelope: fold the reporter's per-machine RUNTIME facts
+      // (versions/build) into ONE object the coordinator ingests wholesale. Slots are
+      // NOT carried — they are coordinator-owned config, not reported
+      // (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix). Emitted only when at least one
+      // field is present so a fully-cold reporter doesn't ship an empty stub. The
+      // legacy flat fields above ride alongside for back-compat during rollout.
+      const reporterMemberState =
+        reporterProviderVersions || reporterDaemonBuildVersion
+          ? {
+              ...(reporterProviderVersions ? { providerVersions: reporterProviderVersions } : {}),
+              ...(reporterDaemonBuildVersion ? { daemonBuildVersion: reporterDaemonBuildVersion } : {}),
+              lastReportedAt: Date.now(),
+            }
+          : undefined;
       return {
         success: true,
         status,
@@ -367,6 +390,7 @@ export async function handleGitCommand(
         ...(reporterMachineNickname ? { reporterMachineNickname } : {}),
         ...(reporterProviderVersions ? { reporterProviderVersions } : {}),
         ...(reporterDaemonBuildVersion ? { reporterDaemonBuildVersion } : {}),
+        ...(reporterMemberState ? { reporterMemberState } : {}),
       };
     }
 

package/src/mesh/mesh-node-identity.ts

@@ -16,6 +16,7 @@ import { detectCLI, getCachedProviderVersions } from '../detection/cli-detector.
 import { getDaemonBuildInfo } from '../build-info.js';
 import { getGitRepoStatus } from '../git/git-status.js';
 import { normalizeGitStatus as sharedNormalizeGitStatus, pickBestTransitGitStatus as sharedPickBestTransitGitStatus, summarizeGitShape as sharedSummarizeGitShape, normalizeMeshNodeId, daemonIdsEquivalent, meshWorkspacesEquivalent, sessionIdsEquivalent, withStatusProbeMarker } from '@adhdev/mesh-shared';
+import type { MeshReportedMemberState } from '../repo-mesh-types.js';
 import { LOG } from '../logging/logger.js';
 import { getSessionHostSurfaceKind } from '../session-host/runtime-surface.js';
 import { awaitWithWarmupDeadline, resolveWarmupDeadlineOpts } from '../mesh/mesh-warmup-deadline.js';
@@ -326,6 +327,7 @@ export function recordInlineMeshDirectGitTruth(
     reporterMachineNickname: string | null;
     reporterProviderVersions: Record<string, string> | null;
     reporterDaemonBuildVersion: string | null;
+    reportedMemberState: MeshReportedMemberState | null;
 } {
     if (!node || typeof node !== 'object' || Array.isArray(node)) {
         return {
@@ -334,6 +336,7 @@ export function recordInlineMeshDirectGitTruth(
             reporterMachineNickname: null,
             reporterProviderVersions: null,
             reporterDaemonBuildVersion: null,
+            reportedMemberState: null,
         };
     }
     const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
@@ -389,21 +392,79 @@ export function recordInlineMeshDirectGitTruth(
     // carries no reporter* versions — mirror the platform/arch self-heal above and read
     // this daemon's own warm version cache directly, so the coordinator's self node gets
     // the same provider/build chips a remote node does.
+    // Direction-B: parse the UNIFIED reportedMemberState envelope first (versions +
+    // build + the member's own resolved slots), falling back to the flat legacy
+    // fields so a mixed-version mesh during rollout still ingests. This is the single
+    // place the coordinator mirrors a remote member's reported state wholesale.
+    const unified = normalizeReportedMemberState(git.reporterMemberState);
     const reporterProviderVersions =
-        readProviderVersionsRecord(git.reporterProviderVersions)
+        (unified?.providerVersions ? readProviderVersionsRecord(unified.providerVersions) : null)
+        ?? readProviderVersionsRecord(git.reporterProviderVersions)
         ?? (isLocalSource ? readLocalReporterProviderVersions() : null);
     if (reporterProviderVersions) node.reportedProviderVersions = reporterProviderVersions;
     const reporterDaemonBuildVersion =
-        (readStringValue(git.reporterDaemonBuildVersion)
+        (readStringValue(unified?.daemonBuildVersion)
+            ?? readStringValue(git.reporterDaemonBuildVersion)
             ?? (isLocalSource ? readLocalReporterDaemonBuildVersion() : null))
         ?? null;
     if (reporterDaemonBuildVersion) node.reportedDaemonBuildVersion = reporterDaemonBuildVersion;
+    // Mirror the unified state onto the node record for observability. Only stamped
+    // for a REMOTE member (!isLocalSource): the coordinator's own / worktree nodes
+    // read their runtime facts from the local warm cache above, so a self node
+    // deliberately carries NO reportedMemberState. Carries the per-machine RUNTIME
+    // facts (provider versions + daemon build) — NOT slots, which are coordinator-
+    // owned config resolved from node.policy.slots, not reported
+    // (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix). Synthesizes from the legacy flat
+    // fields when a node reports only those (no unified envelope yet).
+    if (!isLocalSource) {
+        const mirrored: {
+            providerVersions?: Record<string, string>;
+            daemonBuildVersion?: string;
+            lastReportedAt?: number;
+        } = {
+            ...(reporterProviderVersions ? { providerVersions: reporterProviderVersions } : {}),
+            ...(reporterDaemonBuildVersion ? { daemonBuildVersion: reporterDaemonBuildVersion } : {}),
+            lastReportedAt: readNumberValue(unified?.lastReportedAt) ?? checkedAt,
+        };
+        // Only stamp when there's actual reported content beyond the timestamp — a
+        // bare {lastReportedAt} carries no observability and would just churn the
+        // record on every probe.
+        if (mirrored.providerVersions || mirrored.daemonBuildVersion) {
+            node.reportedMemberState = mirrored;
+        }
+    }
     return {
         reporterPlatform,
         reporterArch,
         reporterMachineNickname,
         reporterProviderVersions,
         reporterDaemonBuildVersion,
+        reportedMemberState: (!isLocalSource ? (node.reportedMemberState ?? null) : null) as MeshReportedMemberState | null,
+    };
+}
+
+/**
+ * Coerce an unknown git-envelope `reporterMemberState` into a clean
+ * {@link MeshReportedMemberState}. Reuses readProviderVersionsRecord for the version
+ * map. Carries the per-machine RUNTIME facts (provider versions + daemon build) only
+ * — slots are coordinator-owned config, not reported (REMOTE-NODE-SLOTS-COORDINATOR-
+ * LOCAL fix), and any stray `slots` on a legacy envelope is ignored. Returns null
+ * when nothing usable is present (bare/absent envelope) so callers fall back to the
+ * legacy flat fields. Best-effort, never throws.
+ */
+function normalizeReportedMemberState(value: unknown): MeshReportedMemberState | null {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+    const raw = value as Record<string, unknown>;
+    const providerVersions = readProviderVersionsRecord(raw.providerVersions);
+    const daemonBuildVersion = readStringValue(raw.daemonBuildVersion);
+    const lastReportedAt = readNumberValue(raw.lastReportedAt);
+    if (!providerVersions && !daemonBuildVersion && lastReportedAt === undefined) {
+        return null;
+    }
+    return {
+        ...(providerVersions ? { providerVersions } : {}),
+        ...(daemonBuildVersion ? { daemonBuildVersion } : {}),
+        ...(lastReportedAt !== undefined ? { lastReportedAt } : {}),
     };
 }
 
@@ -493,6 +554,7 @@ export function persistNodeReporterPlatform(
         reporterMachineNickname?: string | null;
         reporterProviderVersions?: Record<string, string> | null;
         reporterDaemonBuildVersion?: string | null;
+        reportedMemberState?: MeshReportedMemberState | null;
     },
 ): void {
     if (meshSource !== 'local_config') return;
@@ -503,12 +565,18 @@ export function persistNodeReporterPlatform(
     const reportedMachineNickname = reporter.reporterMachineNickname ?? undefined;
     const reportedProviderVersions = reporter.reporterProviderVersions ?? undefined;
     const reportedDaemonBuildVersion = reporter.reporterDaemonBuildVersion ?? undefined;
+    // Persist the unified mirrored member state so a remote node's version chips
+    // survive a coordinator restart (mirrors the per-field self-heal). Carries
+    // per-machine runtime facts only (versions + build) — slots are coordinator-owned
+    // config, not reported (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix).
+    const reportedMemberState = reporter.reportedMemberState ?? undefined;
     if (
         !reportedPlatform &&
         !reportedArch &&
         !reportedMachineNickname &&
         !reportedProviderVersions &&
-        !reportedDaemonBuildVersion
+        !reportedDaemonBuildVersion &&
+        !reportedMemberState
     ) {
         return;
     }
@@ -519,6 +587,7 @@ export function persistNodeReporterPlatform(
             reportedMachineNickname,
             reportedProviderVersions,
             reportedDaemonBuildVersion,
+            reportedMemberState,
         }))
         .catch(() => { /* best-effort self-heal; never block status assembly */ });
 }
@@ -1549,6 +1618,13 @@ async function probeRemoteMeshGitStatus(args: {
     if (reporterProviderVersions) git.reporterProviderVersions = reporterProviderVersions;
     const reporterDaemonBuildVersion = readStringValue(remoteResult?.reporterDaemonBuildVersion);
     if (reporterDaemonBuildVersion) git.reporterDaemonBuildVersion = reporterDaemonBuildVersion;
+    // Propagate the member's UNIFIED reportedMemberState (per-machine runtime facts:
+    // versions + build + lastReportedAt) on the same channel so the coordinator can
+    // ingest it wholesale. Slots are NOT carried — coordinator-owned config
+    // (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix). Carried alongside the legacy flat
+    // fields above for a mixed-version-mesh rollout.
+    const reporterMemberState = normalizeReportedMemberState(remoteResult?.reporterMemberState);
+    if (reporterMemberState) git.reporterMemberState = reporterMemberState;
     return git;
 }
 

package/src/mesh/mesh-node-slots.ts

@@ -34,8 +34,19 @@ export function normalizeProviderPriority(policy: unknown): string[] {
 }
 
 /**
- * Resolve a node's capability slots: explicit `policy.slots` when present, else
- * derived from the legacy `providerPriority` + machine-global difficultyBrains.
+ * Resolve a node's capability slots — coordinator-owned config is the single source
+ * of truth for ALL nodes (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix).
+ *
+ * The coordinator's local meshes.json owns `policy.slots` for every node in the mesh
+ * (self AND remote members alike — a remote member's mesh config lives on the
+ * coordinator, its own on-disk meshes.json is empty). So slots resolve directly from
+ * the coordinator's locally-owned `node.policy.slots`, with no remote reporter
+ * round-trip: there is no per-node "reported slots" mirror to consult.
+ *
+ * Precedence:
+ *   1. `policy.slots` — coordinator-owned, authoritative for self and remote alike.
+ *   2. Legacy-derived from `providerPriority` + machine-global difficultyBrains.
+ *
  * (The former per-provider `providerRoles` cap has been removed; a persisted
  * meshes.json is migrated to slots on load, so by the time a node reaches routing
  * its cap already lives on `slots[].maxParallel`.)

package/src/repo-mesh-types.ts

@@ -398,6 +398,33 @@ export interface RepoMeshRelatedRepo {
  * (see migrateLoadedMeshConfig).
  */
 
+/**
+ * Unified mirrored member state — the per-machine RUNTIME facts a remote member
+ * self-reports (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix).
+ *
+ * A single self-reported observability envelope stamped by the daemon that OWNS a
+ * node's workspace and carried wholesale on the git_status envelope
+ * (reporterMemberState), consolidating the previously per-field self-heal of
+ * providerVersions and daemonBuildVersion. The coordinator ingests this whole object
+ * onto the mirrored remote node in one place
+ * (mesh-node-identity.recordInlineMeshDirectGitTruth).
+ *
+ * Source-of-truth model: provider VERSIONS + daemon BUILD are per-machine runtime
+ * facts (e.g. a member has claude-cli@2.1.168 while the coordinator has @2.1.170), so
+ * they are reported here. SLOTS are NOT reported — they are coordinator-owned config
+ * (node.policy.slots for every node, self and remote alike; see
+ * resolveNodeCapabilitySlots), a single source of truth on the coordinator with no
+ * reporter round-trip.
+ */
+export interface MeshReportedMemberState {
+    /** Reporter node's detected provider CLI/ACP versions (keyed by provider id). */
+    providerVersions?: Record<string, string>;
+    /** Reporter daemon's build version (getDaemonBuildInfo().version). */
+    daemonBuildVersion?: string;
+    /** Epoch ms the report was stamped; used for mirror staleness reasoning. */
+    lastReportedAt?: number;
+}
+
 export interface RepoMeshNodePolicy {
     readOnly?: boolean;
     canPush?: boolean;
@@ -915,6 +942,20 @@ export interface LocalMeshNodeEntry {
      *  owning daemon, carried on the git_status envelope (reporterDaemonBuildVersion)
      *  alongside the provider versions. Absent until first reported. */
     reportedDaemonBuildVersion?: string;
+    /**
+     * Unified mirrored "member state" self-reported by the daemon that owns this
+     * node's workspace, carried wholesale on the git_status envelope
+     * (reporterMemberState) and ingested by the coordinator in one place. It carries
+     * the per-machine RUNTIME facts (reportedProviderVersions, reportedDaemonBuildVersion)
+     * consolidated into one envelope — NOT slots, which are coordinator-owned config
+     * resolved from node.policy.slots for every node, not reported
+     * (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix). The legacy flat fields above stay
+     * populated in parallel during rollout for back-compat (see mesh-node-identity
+     * ingest). `lastReportedAt` is the epoch ms the report was stamped, so a
+     * partitioned node's mirror does not linger as fresh forever. Absent until the
+     * first envelope carrying it is ingested.
+     */
+    reportedMemberState?: MeshReportedMemberState;
     /**
      * The operator-set machine nickname (config.machineNickname) of the daemon
      * that owns this node's workspace. The local coordinator stamps its own