@adhdev/daemon-core 0.9.82-rc.326 → 0.9.82-rc.327

package/dist/mesh/mesh-work-queue.d.ts

@@ -84,6 +84,8 @@ export declare function buildMeshNodeCapabilityTags(node: {
     isLocalWorktree?: unknown;
     worktreeBranch?: unknown;
     userOverrides?: unknown;
+    reportedPlatform?: unknown;
+    reportedArch?: unknown;
 } | undefined, providerType?: string): string[];
 export declare function nodeSatisfiesRequiredTags(requiredTags: unknown, capabilityTags: unknown): boolean;
 /**

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

@@ -418,6 +418,18 @@ export interface LocalMeshNodeEntry {
     /** Operator-defined capability tags used by mesh queue matching. */
     capabilities?: string[];
     userOverrides: Partial<RepoMeshNodeCapabilities>;
+    /**
+     * Live, self-healed platform/arch reported by the daemon that owns this
+     * node's workspace (its own process.platform/process.arch), carried on the
+     * git_status envelope and persisted by the coordinator on each direct git
+     * probe. This is auto-detected truth, kept DISTINCT from `userOverrides`
+     * (operator intent) so capability-tag derivation can prefer an explicit
+     * operator override while still self-correcting auto-detected nodes — and so
+     * a stale value is overwritten by the next report rather than sticking.
+     * Absent until the first direct probe succeeds.
+     */
+    reportedPlatform?: string;
+    reportedArch?: string;
     policy: RepoMeshNodePolicy;
     /**
      * Per-node instruction surfaced in the coordinator prompt so the LLM

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.326",
+  "version": "0.9.82-rc.327",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.326",
+    "@adhdev/mesh-shared": "0.9.82-rc.327",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/router.ts

@@ -407,8 +407,10 @@ function recordInlineMeshDirectGitTruth(
     node: any,
     git: Record<string, unknown>,
     source: 'selected_coordinator_local_git' | 'selected_coordinator_mesh_p2p_git',
-): void {
-    if (!node || typeof node !== 'object' || Array.isArray(node)) return;
+): { reporterPlatform: string | null; reporterArch: string | null } {
+    if (!node || typeof node !== 'object' || Array.isArray(node)) {
+        return { reporterPlatform: null, reporterArch: null };
+    }
     const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
     const updatedAt = new Date(checkedAt).toISOString();
     const nextGit: Record<string, unknown> = {
@@ -439,6 +441,13 @@ function recordInlineMeshDirectGitTruth(
     const reporterPlatform = readStringValue(git.reporterPlatform) ?? (isLocalSource ? process.platform : null);
     const reporterArch = readStringValue(git.reporterArch) ?? (isLocalSource ? process.arch : null);
     stampNodeReporterPlatform(node, reporterPlatform, reporterArch);
+    // Mirror onto the in-memory node's dedicated reporter fields too (distinct
+    // from userOverrides). For a local_config mesh the caller also persists these
+    // to meshes.json via updateNode so the value survives a coordinator restart;
+    // for an inline/cache mesh this keeps the runtime object self-consistent.
+    if (reporterPlatform) node.reportedPlatform = reporterPlatform;
+    if (reporterArch) node.reportedArch = reporterArch;
+    return { reporterPlatform, reporterArch };
 }
 
 /**
@@ -460,6 +469,34 @@ function stampNodeReporterPlatform(node: any, platform: string | null, arch: str
     if (changed) node.userOverrides = overrides;
 }
 
+/**
+ * Persist the live self-reported platform/arch onto the local meshes.json node
+ * record so capability-tag os=/arch= self-heals across coordinator restarts.
+ *
+ * The in-memory stamp done by recordInlineMeshDirectGitTruth lives on the
+ * mesh_status assembly object and is discarded after the response; only a
+ * `local_config` mesh has a backing meshes.json node to write through to. Inline
+ * cache/bootstrap meshes have no local node to update, so we no-op for them.
+ * Fire-and-forget (same pattern as the worktreeBootstrap writer) — a persistence
+ * failure must never block the status response.
+ */
+function persistNodeReporterPlatform(
+    meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config',
+    mesh: any,
+    nodeId: string | undefined,
+    reporter: { reporterPlatform: string | null; reporterArch: string | null },
+): void {
+    if (meshSource !== 'local_config') return;
+    const meshId = readStringValue(mesh?.id);
+    if (!meshId || !nodeId) return;
+    const reportedPlatform = reporter.reporterPlatform ?? undefined;
+    const reportedArch = reporter.reporterArch ?? undefined;
+    if (!reportedPlatform && !reportedArch) return;
+    void import('../config/mesh-config.js')
+        .then(({ updateNode }) => updateNode(meshId, nodeId, { reportedPlatform, reportedArch }))
+        .catch(() => { /* best-effort self-heal; never block status assembly */ });
+}
+
 function buildCachedInlineMeshGitStatus(node: any): Record<string, unknown> | undefined {
     const liveGit = buildInlineMeshTransitGitStatus(node);
     if (liveGit) return liveGit;
@@ -1323,7 +1360,8 @@ async function hydrateInlineMeshDirectTruth(args: {
             try {
                 const localGit = await getGitRepoStatus(workspace, { timeoutMs: 10_000, refreshUpstream: true });
                 if (localGit?.isGitRepo) {
-                    recordInlineMeshDirectGitTruth(node, localGit as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                    const reporter = recordInlineMeshDirectGitTruth(node, localGit as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                    persistNodeReporterPlatform(args.meshSource, args.mesh, nodeId, reporter);
                     localConfirmedCount += 1;
                     continue;
                 }
@@ -1375,7 +1413,8 @@ async function hydrateInlineMeshDirectTruth(args: {
             ? await args.probeCache.probe(daemonId, workspace, runProbe)
             : await runProbe();
         if (remoteGit) {
-            recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+            const reporter = recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+            persistNodeReporterPlatform(args.meshSource, args.mesh, nodeId, reporter);
             peerConfirmedCount += 1;
             continue;
         }
@@ -9299,7 +9338,8 @@ export class DaemonCommandRouter {
                                         if (!connectionReported || connectionState === 'unknown') {
                                             status.connection = buildLivePeerGitConnection(connection, refreshedAt);
                                         }
-                                        recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+                                        const reporter = recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+                                        persistNodeReporterPlatform(meshRecord.source, mesh, nodeId, reporter);
                                         remoteProbeApplied = true;
                                     }
                                 }
@@ -9340,7 +9380,8 @@ export class DaemonCommandRouter {
                                 try {
                                     const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 10_000, refreshUpstream: true });
                                     status.git = gitStatus;
-                                    recordInlineMeshDirectGitTruth(node, gitStatus as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                                    const reporter = recordInlineMeshDirectGitTruth(node, gitStatus as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                                    persistNodeReporterPlatform(meshRecord.source, mesh, nodeId, reporter);
                                     if (gitStatus.isGitRepo) {
                                         status.health = deriveMeshNodeHealthFromGit(gitStatus as unknown as Record<string, unknown>);
                                     } else {

package/src/config/mesh-config.ts

@@ -604,6 +604,11 @@ export function updateNode(
         /** Per-node instruction surfaced in the coordinator prompt. Pass an
          *  empty string or undefined to clear it. */
         systemPrompt?: string;
+        /** Live self-reported platform/arch from the owning daemon's git_status
+         *  envelope. Persisted distinctly from userOverrides (auto-detected, not
+         *  operator intent) so capability-tag os=/arch= self-heals across loads. */
+        reportedPlatform?: string;
+        reportedArch?: string;
     },
 ): LocalMeshNodeEntry | undefined {
     const config = loadMeshConfig();
@@ -614,6 +619,8 @@ export function updateNode(
     if (!node) return undefined;
 
     if (opts.userOverrides) node.userOverrides = { ...node.userOverrides, ...opts.userOverrides };
+    if (opts.reportedPlatform && opts.reportedPlatform.trim()) node.reportedPlatform = opts.reportedPlatform.trim();
+    if (opts.reportedArch && opts.reportedArch.trim()) node.reportedArch = opts.reportedArch.trim();
     if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
     if (opts.worktreeBootstrap) node.worktreeBootstrap = opts.worktreeBootstrap;
     if (Object.prototype.hasOwnProperty.call(opts, 'systemPrompt')) {

package/src/mesh/mesh-work-queue.ts

@@ -385,8 +385,20 @@ function readNodeOverride(node: { userOverrides?: unknown } | undefined, key: 'p
     return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
 
+/**
+ * Live, self-reported platform/arch the owning daemon stamped onto the node from
+ * its own process.platform/process.arch via the git_status envelope. Kept on a
+ * field DISTINCT from userOverrides so capability-tag derivation can prefer an
+ * explicit operator override while still self-healing auto-detected nodes — and
+ * so the value reflects the node's real OS rather than the coordinator's.
+ */
+function readNodeReporter(node: { reportedPlatform?: unknown; reportedArch?: unknown } | undefined, key: 'platform' | 'arch'): string | null {
+    const value = key === 'platform' ? node?.reportedPlatform : node?.reportedArch;
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
 export function buildMeshNodeCapabilityTags(
-    node: { capabilities?: unknown; policy?: unknown; isLocalWorktree?: unknown; worktreeBranch?: unknown; userOverrides?: unknown } | undefined,
+    node: { capabilities?: unknown; policy?: unknown; isLocalWorktree?: unknown; worktreeBranch?: unknown; userOverrides?: unknown; reportedPlatform?: unknown; reportedArch?: unknown } | undefined,
     providerType?: string,
 ): string[] {
     const provider = typeof providerType === 'string' && providerType.trim()
@@ -395,17 +407,25 @@ export function buildMeshNodeCapabilityTags(
     const worktreeBranch = typeof node?.worktreeBranch === 'string' && node.worktreeBranch.trim()
         ? node.worktreeBranch.trim()
         : null;
-    // Per-node platform/arch: prefer the value the remote daemon stamped into
-    // its node record (userOverrides.platform/arch) so a Windows member advertises
-    // os=win32 even though the COORDINATOR computing these tags runs on darwin.
-    // Fall back to process.platform/process.arch only when absent — that covers the
-    // local coordinator node and local worktree nodes, where process.* IS correct.
+    // Per-node platform/arch precedence (highest → lowest):
+    //   1. userOverrides.platform/arch — an EXPLICIT operator override always wins.
+    //   2. reportedPlatform/reportedArch — the live OS the owning daemon
+    //      self-reported (its own process.platform/process.arch via the git_status
+    //      envelope), persisted to the node record on each direct probe. This is
+    //      why a Windows member advertises os=win32 even though the COORDINATOR
+    //      computing these tags runs on darwin — without it the consumer reads the
+    //      persistent node (operator userOverrides empty) and would fall straight
+    //      through to the coordinator's own process.platform, mislabeling every
+    //      node os=darwin. We prefer this LIVE value over any stale auto-stamp.
+    //   3. process.platform/process.arch — last-resort fallback, correct only for
+    //      the local coordinator node / local worktree nodes that have not yet
+    //      been probed (their workspace lives on THIS machine anyway).
     // Vocabulary is raw process.platform/process.arch ("darwin"/"win32"/"linux",
     // "arm64"/"x64") on both the advertiser and the required_tags matcher, which
     // compares with plain string equality (nodeSatisfiesRequiredTags) — so this
     // keeps the win32/darwin/linux vocabulary the matcher already expects.
-    const os = readNodeOverride(node, 'platform') ?? process.platform;
-    const arch = readNodeOverride(node, 'arch') ?? process.arch;
+    const os = readNodeOverride(node, 'platform') ?? readNodeReporter(node, 'platform') ?? process.platform;
+    const arch = readNodeOverride(node, 'arch') ?? readNodeReporter(node, 'arch') ?? process.arch;
     return normalizeMeshCapabilityTags([
         ...(Array.isArray(node?.capabilities) ? node.capabilities : []),
         `os=${os}`,

package/src/repo-mesh-types.ts

@@ -533,6 +533,18 @@ export interface LocalMeshNodeEntry {
     /** Operator-defined capability tags used by mesh queue matching. */
     capabilities?: string[];
     userOverrides: Partial<RepoMeshNodeCapabilities>;
+    /**
+     * Live, self-healed platform/arch reported by the daemon that owns this
+     * node's workspace (its own process.platform/process.arch), carried on the
+     * git_status envelope and persisted by the coordinator on each direct git
+     * probe. This is auto-detected truth, kept DISTINCT from `userOverrides`
+     * (operator intent) so capability-tag derivation can prefer an explicit
+     * operator override while still self-correcting auto-detected nodes — and so
+     * a stale value is overwritten by the next report rather than sticking.
+     * Absent until the first direct probe succeeds.
+     */
+    reportedPlatform?: string;
+    reportedArch?: string;
     policy: RepoMeshNodePolicy;
     /**
      * Per-node instruction surfaced in the coordinator prompt so the LLM