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

package/package.json

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

package/src/boot/daemon-lifecycle.ts

@@ -25,7 +25,7 @@ import { VersionArchive, detectAllVersions } from '../providers/version-archive.
 import { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { DevServer } from '../daemon/dev-server.js';
 import { detectIDEs, type IDEInfo } from '../detection/ide-detector.js';
-import { detectCLI, detectCLIs, getCachedProviderVersions } from '../detection/cli-detector.js';
+import { detectCLI, detectCLIs, getCachedProviderVersions, setDefaultProviderLoader } from '../detection/cli-detector.js';
 import { getDaemonBuildInfo } from '../build-info.js';
 import { SessionRegistry } from '../sessions/registry.js';
 import { LOG, installGlobalInterceptor } from '../logging/logger.js';
@@ -192,6 +192,12 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
     // commands (and the REST endpoint at /api/v1/providers/updates).
     providerLoader.loadAll();
     providerLoader.registerToDetector();
+    // Register this loader as the default for loader-less provider-version reads.
+    // The coordinator's own self/worktree node self-heal (mesh-node-identity.ts) reads
+    // getCachedProviderVersions() with no loader in scope; without this the detection
+    // list is empty and the self node's provider-version chips never populate, even
+    // though remote nodes (which self-report via the git_status envelope) do.
+    setDefaultProviderLoader(providerLoader);
 
     // 2.5 Provider version detection & archive
     // Run after startup work continues. The detector still performs expensive

package/src/commands/high-family/mesh-status.ts

@@ -555,6 +555,18 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                         }
                         applyInlineMeshBranchConvergence(mesh, node, status);
                         finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode, directTruthUnavailable: directTruthUnavailableNodeIds.has(nodeId) });
+                        // T7: providerVersions/daemonBuildVersion are stamped onto the initial
+                        // status snapshot above from node.reported* — but recordInlineMeshDirectGitTruth
+                        // (which self-heals those node fields from the local version cache for the
+                        // coordinator's own self/worktree nodes) runs AFTER that snapshot. Re-sync from
+                        // the now-stamped node here so the self node surfaces its chips in the same call
+                        // rather than lagging a poll cycle. Additive; skipped when the node never reported.
+                        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()];

package/src/detection/cli-detector.ts

@@ -235,11 +235,31 @@ let cachedProviderVersions: Record<string, string> = {};
 let cachedProviderVersionsAt = 0;
 let providerVersionsRefreshInFlight: Promise<void> | null = null;
 
+// The daemon's active ProviderLoader, registered once at boot. detectCLIs only
+// builds its detection list from a loader (no loader ⇒ empty list ⇒ empty version
+// map), and getCachedProviderVersions is reachable on paths that have no loader in
+// scope — most importantly the coordinator's own self/worktree node self-heal in
+// mesh-node-identity.ts, which is a pure module with no daemon handle. Registering
+// the loader here lets those loader-less reads still detect providers instead of
+// silently returning {}. An explicit loader argument always wins over this default.
+let defaultProviderLoader: ProviderLoader | undefined;
+
+/**
+ * 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 function setDefaultProviderLoader(providerLoader: ProviderLoader): void {
+    defaultProviderLoader = providerLoader;
+}
+
 function refreshProviderVersionsSnapshot(providerLoader?: ProviderLoader): Promise<void> {
     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 {