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

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,10 +13,37 @@ 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 with EXPLICIT self-vs-remote precedence
+ * (REMOTE-NODE-SLOT-CAP-CHIP fix, Direction B).
+ *
+ * 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 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

@@ -300,6 +300,39 @@ export interface RepoMeshRelatedRepo {
  * persisted meshes.json that still carries it is migrated to `slots` on load
  * (see migrateLoadedMeshConfig).
  */
+/**
+ * Direction-B unified mirrored member state (REMOTE-NODE-SLOT-CAP-CHIP 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
+ * (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).
+ */
+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;
+}
 export interface RepoMeshNodePolicy {
     readOnly?: boolean;
     canPush?: boolean;
@@ -634,6 +667,24 @@ 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. 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.
+     */
+    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.515",
   "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.515",
+    "@adhdev/session-host-core": "0.9.82-rc.515",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/boot/daemon-lifecycle.ts

@@ -37,6 +37,7 @@ 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';
@@ -312,15 +313,24 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         instanceManager,
         sessionRegistry,
         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: () => {
+            // 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) => {
                 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

@@ -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,11 @@ 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. */
+        reportedMemberState?: MeshReportedMemberState;
     },
 ): LocalMeshNodeEntry | undefined {
     const config = loadMeshConfig();
@@ -662,6 +668,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,18 @@ 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;
+    /**
+     * 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[];
+  };
 }
 
 type GitCommandFailure = {
@@ -124,7 +135,11 @@ 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 Direction-B unified envelope (versions + build + the
+  // reporter node's own resolved capability slots + lastReportedAt). 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; diffSummary: GitDiffSummary }
   | { success: true; diff: GitFileDiff }
   | { success: true; snapshot: GitSnapshot }
@@ -346,7 +361,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 +374,23 @@ 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.
+      const reporterMemberState =
+        reporterProviderVersions || reporterDaemonBuildVersion || reporterSlots
+          ? {
+              ...(reporterProviderVersions ? { providerVersions: reporterProviderVersions } : {}),
+              ...(reporterDaemonBuildVersion ? { daemonBuildVersion: reporterDaemonBuildVersion } : {}),
+              ...(reporterSlots ? { slots: reporterSlots } : {}),
+              lastReportedAt: Date.now(),
+            }
+          : undefined;
       return {
         success: true,
         status,
@@ -367,6 +399,7 @@ export async function handleGitCommand(
         ...(reporterMachineNickname ? { reporterMachineNickname } : {}),
         ...(reporterProviderVersions ? { reporterProviderVersions } : {}),
         ...(reporterDaemonBuildVersion ? { reporterDaemonBuildVersion } : {}),
+        ...(reporterMemberState ? { reporterMemberState } : {}),
       };
     }
 

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

@@ -15,7 +15,8 @@ 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 } from '@adhdev/mesh-shared';
+import { normalizeGitStatus as sharedNormalizeGitStatus, pickBestTransitGitStatus as sharedPickBestTransitGitStatus, summarizeGitShape as sharedSummarizeGitShape, normalizeMeshNodeId, daemonIdsEquivalent, meshWorkspacesEquivalent, sessionIdsEquivalent, withStatusProbeMarker, normalizeNodeCapabilitySlots, type NodeCapabilitySlot } 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,81 @@ 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 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).
+    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) {
+            node.reportedMemberState = mirrored;
+        }
+    }
     return {
         reporterPlatform,
         reporterArch,
         reporterMachineNickname,
         reporterProviderVersions,
         reporterDaemonBuildVersion,
+        reportedMemberState: (!isLocalSource ? (node.reportedMemberState ?? null) : null) as MeshReportedMemberState | null,
+    };
+}
+
+/**
+ * Direction-B: 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.
+ */
+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) {
+        return null;
+    }
+    return {
+        ...(providerVersions ? { providerVersions } : {}),
+        ...(daemonBuildVersion ? { daemonBuildVersion } : {}),
+        ...(slots.length ? { slots } : {}),
+        ...(lastReportedAt !== undefined ? { lastReportedAt } : {}),
     };
 }
 
@@ -493,6 +556,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 +567,16 @@ 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).
+    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,12 @@ 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.
+    const reporterMemberState = normalizeReportedMemberState(remoteResult?.reporterMemberState);
+    if (reporterMemberState) git.reporterMemberState = reporterMemberState;
     return git;
 }
 

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

@@ -12,9 +12,10 @@
 import {
     deriveSlotsFromLegacy,
     normalizeNodeCapabilitySlots,
+    meshWorkspacesEquivalent,
     type NodeCapabilitySlot,
 } from '@adhdev/mesh-shared';
-import { getDifficultyBrains } from '../config/mesh-config.js';
+import { getDifficultyBrains, listMeshes } from '../config/mesh-config.js';
 
 /** Ordered, de-duplicated providerPriority from a node policy (defensive). */
 export function normalizeProviderPriority(policy: unknown): string[] {
@@ -34,8 +35,25 @@ 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 with EXPLICIT self-vs-remote precedence
+ * (REMOTE-NODE-SLOT-CAP-CHIP fix, Direction B).
+ *
+ * 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 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`.)
@@ -43,6 +61,13 @@ 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({
@@ -50,3 +75,31 @@ 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

@@ -398,6 +398,40 @@ export interface RepoMeshRelatedRepo {
  * (see migrateLoadedMeshConfig).
  */
 
+/**
+ * Direction-B unified mirrored member state (REMOTE-NODE-SLOT-CAP-CHIP 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
+ * (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).
+ */
+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;
+}
+
 export interface RepoMeshNodePolicy {
     readOnly?: boolean;
     canPush?: boolean;
@@ -915,6 +949,24 @@ 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. 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.
+     */
+    reportedMemberState?: MeshReportedMemberState;
     /**
      * The operator-set machine nickname (config.machineNickname) of the daemon
      * that owns this node's workspace. The local coordinator stamps its own