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

package/package.json

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

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

@@ -12,7 +12,8 @@
  */
 
 import type { ProviderLoader } from '../providers/provider-loader.js';
-import { detectCLI } from '../detection/cli-detector.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 { LOG } from '../logging/logger.js';
@@ -382,9 +383,20 @@ export function recordInlineMeshDirectGitTruth(
     // envelope. These are best-effort observability (never routing), so the raw
     // reported map is stamped onto dedicated node fields and overwritten by the next
     // report — never merged with a stale value the way an operator override would be.
-    const reporterProviderVersions = readProviderVersionsRecord(git.reporterProviderVersions);
+    // For a remote member these ride the git_status envelope (git-commands.ts folds
+    // them in from getReporterProviderVersions). The local coordinator's own / worktree
+    // nodes probe getGitRepoStatus() directly, which bypasses handleGitCommand and so
+    // 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.
+    const reporterProviderVersions =
+        readProviderVersionsRecord(git.reporterProviderVersions)
+        ?? (isLocalSource ? readLocalReporterProviderVersions() : null);
     if (reporterProviderVersions) node.reportedProviderVersions = reporterProviderVersions;
-    const reporterDaemonBuildVersion = readStringValue(git.reporterDaemonBuildVersion) ?? null;
+    const reporterDaemonBuildVersion =
+        (readStringValue(git.reporterDaemonBuildVersion)
+            ?? (isLocalSource ? readLocalReporterDaemonBuildVersion() : null))
+        ?? null;
     if (reporterDaemonBuildVersion) node.reportedDaemonBuildVersion = reporterDaemonBuildVersion;
     return {
         reporterPlatform,
@@ -412,6 +424,35 @@ function readProviderVersionsRecord(value: unknown): Record<string, string> | nu
     return Object.keys(out).length > 0 ? out : null;
 }
 
+/**
+ * This daemon's own provider-version map, read from the same warm cache the
+ * git_status envelope self-reports from (getReporterProviderVersions is wired to
+ * getCachedProviderVersions at boot). The local self/worktree probe path calls
+ * getGitRepoStatus() directly — bypassing handleGitCommand — so it never gets the
+ * reporter* envelope; reading the cache here is the local-source analogue of the
+ * process.platform/process.arch self-heal. Returns null on a cold cache so the
+ * stamp is skipped rather than clearing an existing value.
+ */
+function readLocalReporterProviderVersions(): Record<string, string> | null {
+    try {
+        return readProviderVersionsRecord(getCachedProviderVersions());
+    } catch {
+        return null;
+    }
+}
+
+/** This daemon's own build version (see readLocalReporterProviderVersions). */
+function readLocalReporterDaemonBuildVersion(): string | null {
+    try {
+        const version = getDaemonBuildInfo().version;
+        return typeof version === 'string' && version.trim() && version !== 'unknown'
+            ? version.trim()
+            : null;
+    } catch {
+        return null;
+    }
+}
+
 /**
  * Fill node.userOverrides.platform/arch from a live report, but never overwrite a
  * value that is already present (an operator override or an earlier report). Used