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

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

@@ -13,37 +13,21 @@ 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 with EXPLICIT self-vs-remote precedence
- * (REMOTE-NODE-SLOT-CAP-CHIP fix, Direction B).
+ * Resolve a node's capability slots — coordinator-owned config is the single source
+ * of truth for ALL nodes (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix).
  *
- * Precedence, avoiding the precedence-inversion a blind `policy.slots || mirror`
- * would introduce:
- *   1. Local `policy.slots` — authoritative for the SELF/locally-owned node (the
- *      node owns its own config locally). This ALSO wins for a remote node in the
- *      unusual case an operator configured slots on the coordinator side.
- *   2. `reportedMemberState.slots` — the remote member's OWN resolved slots,
- *      mirrored wholesale over P2P. Authoritative for a REMOTE mirrored node whose
- *      coordinator-side policy copy is the stale join-time empty `{}` (which
- *      normalizes to []). This is the field the coordinator's join-time copy lacks
- *      — the reason remote slot-cap chips were missing.
- *   3. Legacy-derived from `providerPriority` + machine-global difficultyBrains.
+ * 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 mirror only ever fills the gap left by an empty local policy — it can never
- * shadow a populated local policy — so there is no inversion. And a self node never
- * carries a reportedMemberState (the ingest path stamps it ONLY for remote
- * members), so a self node's local policy is always used directly.
  * (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`.)
  */
 export declare function resolveNodeCapabilitySlots(node: any): NodeCapabilitySlot[];
-/**
- * Reporter-side helper (Direction B): resolve THIS daemon's own capability slots for
- * a given workspace by finding the local meshes.json node whose workspace matches
- * and running the same {@link resolveNodeCapabilitySlots} over its real local policy.
- * Used at the git_status reporter wiring so a member node self-reports its own
- * resolved slots inside the unified reporterMemberState envelope. Returns [] when no
- * local node matches the workspace or slots can't be resolved (best-effort, never
- * throws) so the reporter simply omits the field.
- */
-export declare function resolveLocalNodeSlotsForWorkspace(workspace: string | undefined): NodeCapabilitySlot[];

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

@@ -301,35 +301,28 @@ export interface RepoMeshRelatedRepo {
  * (see migrateLoadedMeshConfig).
  */
 /**
- * Direction-B unified mirrored member state (REMOTE-NODE-SLOT-CAP-CHIP fix).
+ * 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), replacing the fragmented per-field self-heal that mirrored
- * providerVersions and daemonBuildVersion ad-hoc but silently dropped `slots`. The
- * coordinator ingests this whole object onto the mirrored remote node in one place
+ * (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: EACH NODE owns its own slots/versions locally; the
- * coordinator is a pure mirror of a remote member's reported state. Its own
- * join-time `policy` copy for a remote member is a stale empty `{}` and must never
- * shadow this mirror (that would be a precedence inversion — see
- * resolveNodeCapabilitySlots).
+ * 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;
-    /**
-     * Reporter node's OWN resolved capability slots (resolveNodeCapabilitySlots over
-     * its LOCAL real policy). This is the field the coordinator's join-time policy
-     * copy lacks for a remote member, and the reason remote slot-cap chips were
-     * missing. For a remote mirrored node this is authoritative over the (empty)
-     * local policy.slots; for the coordinator's own node the local policy is used
-     * directly (never mirrored here).
-     */
-    slots?: NodeCapabilitySlot[];
     /** Epoch ms the report was stamped; used for mirror staleness reasoning. */
     lastReportedAt?: number;
 }
@@ -670,19 +663,15 @@ export interface LocalMeshNodeEntry {
     /**
      * 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. This is
-     * the Direction-B consolidation of the previously per-field self-heal
-     * (reportedProviderVersions, reportedDaemonBuildVersion — and now the node's
-     * OWN resolved capability `slots`, which the coordinator's join-time policy copy
-     * for a remote member does NOT carry). Each node owns its own slots/versions
-     * locally; the coordinator is a pure mirror of what a remote member reports over
-     * P2P — it must never treat its stale join-time policy copy as authoritative for
-     * a remote node's slots. The legacy flat fields above stay populated in parallel
-     * during rollout for back-compat (see mesh-node-identity ingest). `slots` is the
-     * reporter node's own resolved capability slots (resolveNodeCapabilitySlots over
-     * its LOCAL real policy). `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.
+     * (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;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.515",
+  "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.515",
-    "@adhdev/session-host-core": "0.9.82-rc.515",
+    "@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

@@ -37,7 +37,6 @@ import { loadConfig } from '../config/config.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import type { IdeProviderInstance } from '../providers/ide-provider-instance.js';
 import { createDefaultGitCommandServices } from '../git/git-commands.js';
-import { resolveLocalNodeSlotsForWorkspace } from '../mesh/mesh-node-slots.js';
 import { setupMeshEventForwarding } from '../mesh/mesh-events.js';
 import { setupMeshReconcileLoop } from '../mesh/mesh-reconcile-loop.js';
 import { loadMeshCoordinatorRegistry } from '../mesh/coordinator-registry.js';
@@ -313,24 +312,26 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         instanceManager,
         sessionRegistry,
         gitCommandServices: createDefaultGitCommandServices({
-            // T7 + Direction-B: fold this daemon's cached provider versions + build
-            // version AND its OWN resolved capability slots for the reported workspace
-            // onto the git_status envelope so the mesh coordinator self-heals each
-            // node's providerVersions AND its slot-cap chips (REMOTE-NODE-SLOT-CAP-CHIP
-            // fix). Non-blocking: reads a TTL cache + local meshes.json, lazily
-            // refreshed. The slots the reporter resolves are its LOCAL real policy's
-            // slots — the coordinator mirrors them wholesale for a remote member whose
-            // join-time policy copy is empty. (setDefaultProviderLoader is registered
-            // above so getCachedProviderVersions/slot resolution is not empty — see
-            // the 380556d3 version-chip lesson.)
-            getReporterProviderVersions: (workspace?: string) => {
+            // 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/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;
-                const slots = resolveLocalNodeSlotsForWorkspace(workspace);
                 return {
                     ...(Object.keys(providerVersions).length > 0 ? { providerVersions } : {}),
                     ...(daemonBuildVersion && daemonBuildVersion !== 'unknown' ? { daemonBuildVersion } : {}),
-                    ...(slots.length > 0 ? { slots } : {}),
                 };
             },
         }),

package/src/config/mesh-config.ts

@@ -644,10 +644,12 @@ export function updateNode(
          *  is overwritten by the next report. */
         reportedProviderVersions?: Record<string, string>;
         reportedDaemonBuildVersion?: string;
-        /** Direction-B unified mirrored member state (versions + build + own resolved
-         *  slots + lastReportedAt) self-reported by the owning daemon on the git_status
-         *  envelope. Persisted wholesale so a remote node's slot-cap chips survive a
-         *  coordinator restart, mirroring the per-field reported* self-heal. */
+        /** 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 {

package/src/git/git-commands.ts

@@ -112,14 +112,6 @@ export interface GitCommandServices {
   getReporterProviderVersions?: (workspace?: string) => {
     providerVersions?: Record<string, string>;
     daemonBuildVersion?: string;
-    /**
-     * Direction-B: the reporter node's OWN resolved capability slots
-     * (resolveNodeCapabilitySlots over its LOCAL policy for this workspace). Carried
-     * inside the unified reporterMemberState so a remote node's slot-cap chips
-     * self-heal on the coordinator the same way versions do. Best-effort; omitted
-     * when the reporter cannot resolve slots for the workspace.
-     */
-    slots?: unknown[];
   };
 }
 
@@ -135,11 +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.
-  // reporterMemberState is the Direction-B unified envelope (versions + build + the
-  // reporter node's own resolved capability slots + lastReportedAt). The legacy flat
+  // 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; slots?: unknown[]; lastReportedAt?: number } }
+  | { 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 }
@@ -374,20 +368,17 @@ export async function handleGitCommand(
         typeof reporterVersions.daemonBuildVersion === 'string' && reporterVersions.daemonBuildVersion.trim()
           ? reporterVersions.daemonBuildVersion.trim()
           : undefined;
-      const reporterSlots =
-        Array.isArray(reporterVersions.slots) && reporterVersions.slots.length > 0
-          ? reporterVersions.slots
-          : undefined;
-      // Direction-B unified envelope: fold versions/build/slots into ONE object the
-      // coordinator ingests wholesale. 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.
+      // 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 || reporterSlots
+        reporterProviderVersions || reporterDaemonBuildVersion
           ? {
               ...(reporterProviderVersions ? { providerVersions: reporterProviderVersions } : {}),
               ...(reporterDaemonBuildVersion ? { daemonBuildVersion: reporterDaemonBuildVersion } : {}),
-              ...(reporterSlots ? { slots: reporterSlots } : {}),
               lastReportedAt: Date.now(),
             }
           : undefined;

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

@@ -15,7 +15,7 @@ import type { ProviderLoader } from '../providers/provider-loader.js';
 import { detectCLI, getCachedProviderVersions } from '../detection/cli-detector.js';
 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, normalizeNodeCapabilitySlots, type NodeCapabilitySlot } from '@adhdev/mesh-shared';
+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';
@@ -408,30 +408,28 @@ export function recordInlineMeshDirectGitTruth(
             ?? (isLocalSource ? readLocalReporterDaemonBuildVersion() : null))
         ?? null;
     if (reporterDaemonBuildVersion) node.reportedDaemonBuildVersion = reporterDaemonBuildVersion;
-    // Mirror the unified state onto the node record so resolveNodeCapabilitySlots can
-    // read the remote member's OWN resolved slots. Only stamped for a REMOTE member
-    // (!isLocalSource): the coordinator's own / worktree nodes own their slots via
-    // local policy.slots, so a self node deliberately carries NO reportedMemberState
-    // — this is what keeps the resolver's precedence inversion-free (a self node's
-    // local policy is never shadowed by a mirror it doesn't have). Synthesize from
-    // the legacy flat fields when a node reports only those (no unified envelope yet).
+    // 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 reportedSlots = normalizeNodeCapabilitySlots(unified?.slots);
         const mirrored: {
             providerVersions?: Record<string, string>;
             daemonBuildVersion?: string;
-            slots?: NodeCapabilitySlot[];
             lastReportedAt?: number;
         } = {
             ...(reporterProviderVersions ? { providerVersions: reporterProviderVersions } : {}),
             ...(reporterDaemonBuildVersion ? { daemonBuildVersion: reporterDaemonBuildVersion } : {}),
-            ...(reportedSlots.length ? { slots: reportedSlots } : {}),
             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 || mirrored.slots) {
+        if (mirrored.providerVersions || mirrored.daemonBuildVersion) {
             node.reportedMemberState = mirrored;
         }
     }
@@ -446,26 +444,26 @@ export function recordInlineMeshDirectGitTruth(
 }
 
 /**
- * Direction-B: coerce an unknown git-envelope `reporterMemberState` into a clean
+ * Coerce an unknown git-envelope `reporterMemberState` into a clean
  * {@link MeshReportedMemberState}. Reuses readProviderVersionsRecord for the version
- * map and normalizeNodeCapabilitySlots for slots (dropping provider-less entries).
- * Returns null when nothing usable is present (bare/absent envelope) so callers fall
- * back to the legacy flat fields. Best-effort, never throws.
+ * 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 slots = normalizeNodeCapabilitySlots(raw.slots);
     const lastReportedAt = readNumberValue(raw.lastReportedAt);
-    if (!providerVersions && !daemonBuildVersion && !slots.length && lastReportedAt === undefined) {
+    if (!providerVersions && !daemonBuildVersion && lastReportedAt === undefined) {
         return null;
     }
     return {
         ...(providerVersions ? { providerVersions } : {}),
         ...(daemonBuildVersion ? { daemonBuildVersion } : {}),
-        ...(slots.length ? { slots } : {}),
         ...(lastReportedAt !== undefined ? { lastReportedAt } : {}),
     };
 }
@@ -567,8 +565,10 @@ export function persistNodeReporterPlatform(
     const reportedMachineNickname = reporter.reporterMachineNickname ?? undefined;
     const reportedProviderVersions = reporter.reporterProviderVersions ?? undefined;
     const reportedDaemonBuildVersion = reporter.reporterDaemonBuildVersion ?? undefined;
-    // Direction-B: persist the unified mirrored member state so a remote node's
-    // slot-cap chips survive a coordinator restart (mirrors the per-field self-heal).
+    // 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 &&
@@ -1618,10 +1618,11 @@ async function probeRemoteMeshGitStatus(args: {
     if (reporterProviderVersions) git.reporterProviderVersions = reporterProviderVersions;
     const reporterDaemonBuildVersion = readStringValue(remoteResult?.reporterDaemonBuildVersion);
     if (reporterDaemonBuildVersion) git.reporterDaemonBuildVersion = reporterDaemonBuildVersion;
-    // Direction-B: propagate the member's UNIFIED reportedMemberState (versions +
-    // build + its own resolved slots + lastReportedAt) on the same channel so the
-    // coordinator can ingest it wholesale. Carried alongside the legacy flat fields
-    // above for a mixed-version-mesh rollout.
+    // 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

@@ -12,10 +12,9 @@
 import {
     deriveSlotsFromLegacy,
     normalizeNodeCapabilitySlots,
-    meshWorkspacesEquivalent,
     type NodeCapabilitySlot,
 } from '@adhdev/mesh-shared';
-import { getDifficultyBrains, listMeshes } from '../config/mesh-config.js';
+import { getDifficultyBrains } from '../config/mesh-config.js';
 
 /** Ordered, de-duplicated providerPriority from a node policy (defensive). */
 export function normalizeProviderPriority(policy: unknown): string[] {
@@ -35,25 +34,19 @@ export function normalizeProviderPriority(policy: unknown): string[] {
 }
 
 /**
- * Resolve a node's capability slots with EXPLICIT self-vs-remote precedence
- * (REMOTE-NODE-SLOT-CAP-CHIP fix, Direction B).
+ * Resolve a node's capability slots — coordinator-owned config is the single source
+ * of truth for ALL nodes (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix).
  *
- * Precedence, avoiding the precedence-inversion a blind `policy.slots || mirror`
- * would introduce:
- *   1. Local `policy.slots` — authoritative for the SELF/locally-owned node (the
- *      node owns its own config locally). This ALSO wins for a remote node in the
- *      unusual case an operator configured slots on the coordinator side.
- *   2. `reportedMemberState.slots` — the remote member's OWN resolved slots,
- *      mirrored wholesale over P2P. Authoritative for a REMOTE mirrored node whose
- *      coordinator-side policy copy is the stale join-time empty `{}` (which
- *      normalizes to []). This is the field the coordinator's join-time copy lacks
- *      — the reason remote slot-cap chips were missing.
- *   3. Legacy-derived from `providerPriority` + machine-global difficultyBrains.
+ * 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 mirror only ever fills the gap left by an empty local policy — it can never
- * shadow a populated local policy — so there is no inversion. And a self node never
- * carries a reportedMemberState (the ingest path stamps it ONLY for remote
- * members), so a self node's local policy is always used directly.
  * (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`.)
@@ -61,13 +54,6 @@ export function normalizeProviderPriority(policy: unknown): string[] {
 export function resolveNodeCapabilitySlots(node: any): NodeCapabilitySlot[] {
     const explicit = normalizeNodeCapabilitySlots(node?.policy?.slots);
     if (explicit.length) return explicit;
-    // Remote mirror: the member's own resolved slots, carried on the git_status
-    // envelope and ingested onto the node record. Preferred over the legacy derive
-    // (it is the member's real resolved profile), but only when the local policy is
-    // empty — so it fills the coordinator's join-time gap without overriding an
-    // explicit local override.
-    const mirrored = normalizeNodeCapabilitySlots(node?.reportedMemberState?.slots);
-    if (mirrored.length) return mirrored;
     let difficultyBrains: any;
     try { difficultyBrains = getDifficultyBrains(); } catch { difficultyBrains = undefined; }
     return deriveSlotsFromLegacy({
@@ -75,31 +61,3 @@ export function resolveNodeCapabilitySlots(node: any): NodeCapabilitySlot[] {
         difficultyBrains,
     });
 }
-
-/**
- * Reporter-side helper (Direction B): resolve THIS daemon's own capability slots for
- * a given workspace by finding the local meshes.json node whose workspace matches
- * and running the same {@link resolveNodeCapabilitySlots} over its real local policy.
- * Used at the git_status reporter wiring so a member node self-reports its own
- * resolved slots inside the unified reporterMemberState envelope. Returns [] when no
- * local node matches the workspace or slots can't be resolved (best-effort, never
- * throws) so the reporter simply omits the field.
- */
-export function resolveLocalNodeSlotsForWorkspace(workspace: string | undefined): NodeCapabilitySlot[] {
-    const ws = typeof workspace === 'string' ? workspace.trim() : '';
-    if (!ws) return [];
-    let meshes: any[];
-    try { meshes = listMeshes(); } catch { return []; }
-    for (const mesh of Array.isArray(meshes) ? meshes : []) {
-        for (const node of Array.isArray(mesh?.nodes) ? mesh.nodes : []) {
-            const nodeWs = typeof node?.workspace === 'string' ? node.workspace : '';
-            if (nodeWs && meshWorkspacesEquivalent(nodeWs, ws)) {
-                // Resolve from the LOCAL node's real policy only — never re-read its
-                // own reportedMemberState (a member does not mirror itself).
-                const slots = resolveNodeCapabilitySlots({ policy: node?.policy });
-                if (slots.length) return slots;
-            }
-        }
-    }
-    return [];
-}

package/src/repo-mesh-types.ts

@@ -399,35 +399,28 @@ export interface RepoMeshRelatedRepo {
  */
 
 /**
- * Direction-B unified mirrored member state (REMOTE-NODE-SLOT-CAP-CHIP fix).
+ * 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), replacing the fragmented per-field self-heal that mirrored
- * providerVersions and daemonBuildVersion ad-hoc but silently dropped `slots`. The
- * coordinator ingests this whole object onto the mirrored remote node in one place
+ * (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: EACH NODE owns its own slots/versions locally; the
- * coordinator is a pure mirror of a remote member's reported state. Its own
- * join-time `policy` copy for a remote member is a stale empty `{}` and must never
- * shadow this mirror (that would be a precedence inversion — see
- * resolveNodeCapabilitySlots).
+ * 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;
-    /**
-     * Reporter node's OWN resolved capability slots (resolveNodeCapabilitySlots over
-     * its LOCAL real policy). This is the field the coordinator's join-time policy
-     * copy lacks for a remote member, and the reason remote slot-cap chips were
-     * missing. For a remote mirrored node this is authoritative over the (empty)
-     * local policy.slots; for the coordinator's own node the local policy is used
-     * directly (never mirrored here).
-     */
-    slots?: NodeCapabilitySlot[];
     /** Epoch ms the report was stamped; used for mirror staleness reasoning. */
     lastReportedAt?: number;
 }
@@ -952,19 +945,15 @@ export interface LocalMeshNodeEntry {
     /**
      * 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. This is
-     * the Direction-B consolidation of the previously per-field self-heal
-     * (reportedProviderVersions, reportedDaemonBuildVersion — and now the node's
-     * OWN resolved capability `slots`, which the coordinator's join-time policy copy
-     * for a remote member does NOT carry). Each node owns its own slots/versions
-     * locally; the coordinator is a pure mirror of what a remote member reports over
-     * P2P — it must never treat its stale join-time policy copy as authoritative for
-     * a remote node's slots. The legacy flat fields above stay populated in parallel
-     * during rollout for back-compat (see mesh-node-identity ingest). `slots` is the
-     * reporter node's own resolved capability slots (resolveNodeCapabilitySlots over
-     * its LOCAL real policy). `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.
+     * (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;
     /**