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

package/dist/config/mesh-config.d.ts

@@ -5,7 +5,7 @@
  * Cloud mode syncs these to D1 via server routes; standalone mode
  * uses this file as the single source of truth.
  */
-import type { LocalMeshEntry, LocalMeshNodeEntry, RepoMeshPolicy, RepoMeshNodePolicy, RepoMeshNodeCapabilities, RepoMeshCoordinatorConfig, RepoMeshHostMetadata, RepoMeshDaemonRole } from '../repo-mesh-types.js';
+import type { LocalMeshEntry, LocalMeshNodeEntry, RepoMeshPolicy, RepoMeshNodePolicy, RepoMeshNodeCapabilities, RepoMeshCoordinatorConfig, RepoMeshHostMetadata, RepoMeshDaemonRole, MeshReportedMemberState } from '../repo-mesh-types.js';
 import type { MagiKindPanelMap, MagiSlot, DifficultyBrainMap } from '@adhdev/mesh-shared';
 /**
  * Migrate a node policy's legacy `providerRoles` cap onto `slots[].maxParallel`,
@@ -159,6 +159,11 @@ export declare function updateNode(meshId: string, nodeId: string, opts: {
      *  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;
 /**
  * Validate + normalize a kind-panel's slots (the SOLE MAGI slot normalizer): provider

package/dist/detection/cli-detector.d.ts

@@ -38,6 +38,13 @@ export declare function detectCLI(cliId: string, providerLoader?: ProviderLoader
  * what the git_status envelope carries and the mesh_status skew check compares.
  */
 export declare function buildProviderVersions(detected: CLIInfo[]): Record<string, string>;
+/**
+ * Register this daemon's ProviderLoader as the fallback used by loader-less
+ * provider-version reads (getCachedProviderVersions() with no argument). Called
+ * once at boot. Without it the coordinator's self node never resolves a CLI list,
+ * so its provider-version chips stay empty even though remote nodes populate.
+ */
+export declare function setDefaultProviderLoader(providerLoader: ProviderLoader): void;
 /**
  * Return the current cached provider-versions map for this daemon, triggering a
  * lazy background refresh when the snapshot is stale/cold. Never blocks: returns

package/dist/git/git-commands.d.ts

@@ -119,9 +119,17 @@ 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?: () => {
+    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 = {
@@ -137,6 +145,12 @@ type GitCommandSuccess = {
     reporterMachineNickname?: string;
     reporterProviderVersions?: Record<string, string>;
     reporterDaemonBuildVersion?: string;
+    reporterMemberState?: {
+        providerVersions?: Record<string, string>;
+        daemonBuildVersion?: string;
+        slots?: unknown[];
+        lastReportedAt?: number;
+    };
 } | {
     success: true;
     diffSummary: GitDiffSummary;

package/dist/index.js

@@ -417,10 +417,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "e32fbf96c63cca603a29156a0f70f41ff8e1b252" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "e32fbf96" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.513" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-13T05:58:35.132Z" : void 0);
+  const commit = readInjected(true ? "6dbb06b08d25abd9e91c2f87d5aa3dee08bcc19c" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "6dbb06b0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.515" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-13T09:44:33.291Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3533,6 +3533,9 @@ function updateNode(meshId, nodeId, opts) {
   if (opts.reportedDaemonBuildVersion && opts.reportedDaemonBuildVersion.trim()) {
     node.reportedDaemonBuildVersion = opts.reportedDaemonBuildVersion.trim();
   }
+  if (opts.reportedMemberState) {
+    node.reportedMemberState = opts.reportedMemberState;
+  }
   if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
   if (Object.prototype.hasOwnProperty.call(opts, "capabilities")) {
     const tags = normalizeCapabilityTags(opts.capabilities);
@@ -3672,6 +3675,8 @@ function normalizeProviderPriority(policy) {
 function resolveNodeCapabilitySlots(node) {
   const explicit = normalizeNodeCapabilitySlots(node?.policy?.slots);
   if (explicit.length) return explicit;
+  const mirrored = normalizeNodeCapabilitySlots(node?.reportedMemberState?.slots);
+  if (mirrored.length) return mirrored;
   let difficultyBrains;
   try {
     difficultyBrains = getDifficultyBrains();
@@ -3683,6 +3688,26 @@ function resolveNodeCapabilitySlots(node) {
     difficultyBrains
   });
 }
+function resolveLocalNodeSlotsForWorkspace(workspace) {
+  const ws = typeof workspace === "string" ? workspace.trim() : "";
+  if (!ws) return [];
+  let meshes;
+  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)) {
+        const slots = resolveNodeCapabilitySlots({ policy: node?.policy });
+        if (slots.length) return slots;
+      }
+    }
+  }
+  return [];
+}
 var init_mesh_node_slots = __esm({
   "src/mesh/mesh-node-slots.ts"() {
     "use strict";
@@ -14179,11 +14204,15 @@ function buildProviderVersions(detected) {
   }
   return out;
 }
+function setDefaultProviderLoader(providerLoader) {
+  defaultProviderLoader = providerLoader;
+}
 function refreshProviderVersionsSnapshot(providerLoader) {
   if (providerVersionsRefreshInFlight) return providerVersionsRefreshInFlight;
+  const loader = providerLoader ?? defaultProviderLoader;
   providerVersionsRefreshInFlight = (async () => {
     try {
-      const detected = await detectCLIs(providerLoader, { includeVersion: true });
+      const detected = await detectCLIs(loader, { includeVersion: true });
       cachedProviderVersions = buildProviderVersions(detected);
       cachedProviderVersionsAt = Date.now();
     } catch {
@@ -14200,7 +14229,7 @@ function getCachedProviderVersions(providerLoader) {
   }
   return { ...cachedProviderVersions };
 }
-var import_child_process2, os6, path12, import_fs12, PROVIDER_VERSIONS_TTL_MS, cachedProviderVersions, cachedProviderVersionsAt, providerVersionsRefreshInFlight;
+var import_child_process2, os6, path12, import_fs12, PROVIDER_VERSIONS_TTL_MS, cachedProviderVersions, cachedProviderVersionsAt, providerVersionsRefreshInFlight, defaultProviderLoader;
 var init_cli_detector = __esm({
   "src/detection/cli-detector.ts"() {
     "use strict";
@@ -14585,7 +14614,8 @@ function recordInlineMeshDirectGitTruth(node, git, source) {
       reporterArch: null,
       reporterMachineNickname: null,
       reporterProviderVersions: null,
-      reporterDaemonBuildVersion: null
+      reporterDaemonBuildVersion: null,
+      reportedMemberState: null
     };
   }
   const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
@@ -14613,16 +14643,47 @@ function recordInlineMeshDirectGitTruth(node, git, source) {
   if (reporterArch) node.reportedArch = reporterArch;
   const reporterMachineNickname = readStringValue(git.reporterMachineNickname) ?? null;
   if (reporterMachineNickname) node.machineNickname = reporterMachineNickname;
-  const reporterProviderVersions = readProviderVersionsRecord(git.reporterProviderVersions) ?? (isLocalSource ? readLocalReporterProviderVersions() : null);
+  const unified = normalizeReportedMemberState(git.reporterMemberState);
+  const reporterProviderVersions = (unified?.providerVersions ? readProviderVersionsRecord(unified.providerVersions) : null) ?? readProviderVersionsRecord(git.reporterProviderVersions) ?? (isLocalSource ? readLocalReporterProviderVersions() : null);
   if (reporterProviderVersions) node.reportedProviderVersions = reporterProviderVersions;
-  const reporterDaemonBuildVersion = readStringValue(git.reporterDaemonBuildVersion) ?? (isLocalSource ? readLocalReporterDaemonBuildVersion() : null) ?? null;
+  const reporterDaemonBuildVersion = readStringValue(unified?.daemonBuildVersion) ?? readStringValue(git.reporterDaemonBuildVersion) ?? (isLocalSource ? readLocalReporterDaemonBuildVersion() : null) ?? null;
   if (reporterDaemonBuildVersion) node.reportedDaemonBuildVersion = reporterDaemonBuildVersion;
+  if (!isLocalSource) {
+    const reportedSlots = normalizeNodeCapabilitySlots(unified?.slots);
+    const mirrored = {
+      ...reporterProviderVersions ? { providerVersions: reporterProviderVersions } : {},
+      ...reporterDaemonBuildVersion ? { daemonBuildVersion: reporterDaemonBuildVersion } : {},
+      ...reportedSlots.length ? { slots: reportedSlots } : {},
+      lastReportedAt: readNumberValue(unified?.lastReportedAt) ?? checkedAt
+    };
+    if (mirrored.providerVersions || mirrored.daemonBuildVersion || mirrored.slots) {
+      node.reportedMemberState = mirrored;
+    }
+  }
   return {
     reporterPlatform,
     reporterArch,
     reporterMachineNickname,
     reporterProviderVersions,
-    reporterDaemonBuildVersion
+    reporterDaemonBuildVersion,
+    reportedMemberState: !isLocalSource ? node.reportedMemberState ?? null : null
+  };
+}
+function normalizeReportedMemberState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  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 === void 0) {
+    return null;
+  }
+  return {
+    ...providerVersions ? { providerVersions } : {},
+    ...daemonBuildVersion ? { daemonBuildVersion } : {},
+    ...slots.length ? { slots } : {},
+    ...lastReportedAt !== void 0 ? { lastReportedAt } : {}
   };
 }
 function readProviderVersionsRecord(value) {
@@ -14675,7 +14736,8 @@ function persistNodeReporterPlatform(meshSource, mesh, nodeId, reporter) {
   const reportedMachineNickname = reporter.reporterMachineNickname ?? void 0;
   const reportedProviderVersions = reporter.reporterProviderVersions ?? void 0;
   const reportedDaemonBuildVersion = reporter.reporterDaemonBuildVersion ?? void 0;
-  if (!reportedPlatform && !reportedArch && !reportedMachineNickname && !reportedProviderVersions && !reportedDaemonBuildVersion) {
+  const reportedMemberState = reporter.reportedMemberState ?? void 0;
+  if (!reportedPlatform && !reportedArch && !reportedMachineNickname && !reportedProviderVersions && !reportedDaemonBuildVersion && !reportedMemberState) {
     return;
   }
   void Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports)).then(({ updateNode: updateNode2 }) => updateNode2(meshId, nodeId, {
@@ -14683,7 +14745,8 @@ function persistNodeReporterPlatform(meshSource, mesh, nodeId, reporter) {
     reportedArch,
     reportedMachineNickname,
     reportedProviderVersions,
-    reportedDaemonBuildVersion
+    reportedDaemonBuildVersion,
+    reportedMemberState
   })).catch(() => {
   });
 }
@@ -15289,6 +15352,8 @@ async function probeRemoteMeshGitStatus(args) {
   if (reporterProviderVersions) git.reporterProviderVersions = reporterProviderVersions;
   const reporterDaemonBuildVersion = readStringValue(remoteResult?.reporterDaemonBuildVersion);
   if (reporterDaemonBuildVersion) git.reporterDaemonBuildVersion = reporterDaemonBuildVersion;
+  const reporterMemberState = normalizeReportedMemberState(remoteResult?.reporterMemberState);
+  if (reporterMemberState) git.reporterMemberState = reporterMemberState;
   return git;
 }
 function readMeshConnectionState(connection) {
@@ -29511,13 +29576,20 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
       })();
       const reporterVersions = (() => {
         try {
-          return services.getReporterProviderVersions?.() ?? {};
+          return services.getReporterProviderVersions?.(workspace) ?? {};
         } catch {
           return {};
         }
       })();
       const reporterProviderVersions = reporterVersions.providerVersions && Object.keys(reporterVersions.providerVersions).length > 0 ? reporterVersions.providerVersions : void 0;
       const reporterDaemonBuildVersion = typeof reporterVersions.daemonBuildVersion === "string" && reporterVersions.daemonBuildVersion.trim() ? reporterVersions.daemonBuildVersion.trim() : void 0;
+      const reporterSlots = Array.isArray(reporterVersions.slots) && reporterVersions.slots.length > 0 ? reporterVersions.slots : void 0;
+      const reporterMemberState = reporterProviderVersions || reporterDaemonBuildVersion || reporterSlots ? {
+        ...reporterProviderVersions ? { providerVersions: reporterProviderVersions } : {},
+        ...reporterDaemonBuildVersion ? { daemonBuildVersion: reporterDaemonBuildVersion } : {},
+        ...reporterSlots ? { slots: reporterSlots } : {},
+        lastReportedAt: Date.now()
+      } : void 0;
       return {
         success: true,
         status,
@@ -29525,7 +29597,8 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
         reporterArch: process.arch,
         ...reporterMachineNickname ? { reporterMachineNickname } : {},
         ...reporterProviderVersions ? { reporterProviderVersions } : {},
-        ...reporterDaemonBuildVersion ? { reporterDaemonBuildVersion } : {}
+        ...reporterDaemonBuildVersion ? { reporterDaemonBuildVersion } : {},
+        ...reporterMemberState ? { reporterMemberState } : {}
       };
     }
     case "git_diff_summary": {
@@ -58679,6 +58752,12 @@ var meshStatusHandlers = {
         }
         applyInlineMeshBranchConvergence(mesh, node, status);
         finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode, directTruthUnavailable: directTruthUnavailableNodeIds.has(nodeId) });
+        if (node.reportedProviderVersions && typeof node.reportedProviderVersions === "object") {
+          status.providerVersions = node.reportedProviderVersions;
+        }
+        if (typeof node.reportedDaemonBuildVersion === "string" && node.reportedDaemonBuildVersion) {
+          status.daemonBuildVersion = node.reportedDaemonBuildVersion;
+        }
         return status;
       };
       const meshNodeEntries = [...(mesh.nodes || []).entries()];
@@ -70842,6 +70921,7 @@ var SessionRegistry = class {
 init_logger();
 init_runtime_defaults();
 init_config();
+init_mesh_node_slots();
 init_mesh_events();
 init_mesh_reconcile_loop();
 init_coordinator_registry();
@@ -70891,6 +70971,7 @@ async function initDaemonComponents(config) {
   });
   providerLoader.loadAll();
   providerLoader.registerToDetector();
+  setDefaultProviderLoader(providerLoader);
   const versionArchive = new VersionArchive();
   providerLoader.setVersionArchive(versionArchive);
   setTimeout(() => {
@@ -70982,15 +71063,24 @@ async function initDaemonComponents(config) {
     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) => {
         const providerVersions = getCachedProviderVersions(providerLoader);
         const daemonBuildVersion = getDaemonBuildInfo().version;
+        const slots = resolveLocalNodeSlotsForWorkspace(workspace);
         return {
           ...Object.keys(providerVersions).length > 0 ? { providerVersions } : {},
-          ...daemonBuildVersion && daemonBuildVersion !== "unknown" ? { daemonBuildVersion } : {}
+          ...daemonBuildVersion && daemonBuildVersion !== "unknown" ? { daemonBuildVersion } : {},
+          ...slots.length > 0 ? { slots } : {}
         };
       }
     }),