@adhdev/daemon-core 0.9.82-rc.321 → 0.9.82-rc.322

package/dist/shared-types.d.ts

@@ -302,6 +302,15 @@ export interface SessionEntry {
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
     settings?: Record<string, any>;
+    /**
+     * True owning-daemon id for a session a coordinator synthesises into its own
+     * status snapshot (mesh delegated sessions). The dashboard attributes the session
+     * to this daemon instead of the snapshot daemon so the worker node — not the
+     * coordinator — is shown as its machine.
+     */
+    ownerDaemonId?: string;
+    /** True owning-machine display name fallback when the owning daemon is not aggregated. */
+    ownerMachineName?: string;
     /** Set when this session is acting as a mesh coordinator for the given mesh. */
     coordinator?: {
         meshId: string;

package/package.json

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

package/src/commands/router.ts

@@ -85,6 +85,7 @@ import { basename as pathBasename, join as pathJoin, resolve as pathResolve } fr
 import * as fs from 'fs';
 import { execFileSync } from 'node:child_process';
 import { normalizeInteractivePromptResponse } from '../providers/types/interactive-prompt.js';
+import { workingDirBasename } from '../providers/working-dir.js';
 
 type ReleaseChannel = 'stable' | 'preview';
 const CHANNEL_NPM_TAG: Record<ReleaseChannel, 'latest' | 'next'> = { stable: 'latest', preview: 'next' };
@@ -223,11 +224,14 @@ function logRepoMeshStatusDebug(event: string, fields: Record<string, unknown>):
 // joinRepoPath + readGitSubmodules moved to @adhdev/mesh-shared (readGitSubmodules)
 // — used via sharedNormalizeGitStatus / sharedPickBestTransitGitStatus below.
 
-function buildMeshNodeDisplayLabel(node: Record<string, unknown>, nodeId: string, providerPriority: string[]): string {
+export function buildMeshNodeDisplayLabel(node: Record<string, unknown>, nodeId: string, providerPriority: string[]): string {
     const explicit = readStringValue(node.machineLabel, node.machine_label, node.machineNickname, node.machine_nickname, node.alias);
     if (explicit) return explicit;
     const workspace = readStringValue(node.workspace, node.repoRoot, node.repo_root);
-    const workspaceName = workspace ? pathBasename(workspace) : undefined;
+    // Use the OS-agnostic basename: a workspace reported by a Windows node
+    // (`D:\gh\adhdev-cloud`) must still collapse to its trailing segment even when
+    // this coordinator's own `path.basename` is POSIX-only and would not split `\`.
+    const workspaceName = workspace ? workingDirBasename(workspace) : undefined;
     const host = readStringValue(node.machineName, node.machine_name, node.hostname, node.host, node.daemonId, node.daemon_id, node.machineId, node.machine_id);
     const provider = providerPriority[0] || (Array.isArray(node.providers) ? readStringValue(...node.providers) : undefined);
     const parts = [workspaceName, host, provider].filter(Boolean);
@@ -873,6 +877,22 @@ function readCachedInlineMeshActiveSessions(node: any): string[] {
     return sessionId ? [sessionId] : [];
 }
 
+/**
+ * Resolve the owning-node attribution for a mesh node record so a coordinator can
+ * stamp the TRUE owner onto a synthetic session entry instead of letting the
+ * dashboard fall back to the coordinator's own daemonId. Returns whichever of the
+ * owning node's `daemonId` / display machine name could be read from the node's
+ * (possibly multi-serialization-path) shape; both may be undefined for a node that
+ * never carried machine identity.
+ */
+export function resolveMeshNodeAttribution(node: unknown): { daemonId?: string; machineName?: string } {
+    const record = readObjectRecord(node);
+    return {
+        daemonId: readMeshNodeDaemonId(record),
+        machineName: readMeshNodeDisplayMachineName(record),
+    };
+}
+
 export function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>> {
     const cachedStatus = readObjectRecord(node?.cachedStatus);
     const activeSession = readObjectRecord(cachedStatus.activeSession);

package/src/config/mesh-config.ts

@@ -36,12 +36,71 @@ function loadMeshConfig(): LocalMeshConfig {
     try {
         const raw = JSON.parse(readFileSync(path, 'utf-8'));
         if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
-        return raw as LocalMeshConfig;
+        const config = raw as LocalMeshConfig;
+        const migrated = migrateLoadedMeshConfig(config);
+        // Persist eagerly when the on-load migration changed anything, so the
+        // dead field is gone from disk even on a pure-read path (mesh_status /
+        // mesh_list_nodes) that never otherwise mutates the config. Best-effort:
+        // a write failure (e.g. read-only fs) must not break reads, so swallow.
+        if (migrated) {
+            try {
+                saveMeshConfig(config);
+            } catch {
+                // keep the in-memory strip; disk converges on the next mutating op
+            }
+        }
+        return config;
     } catch {
         return { meshes: [] };
     }
 }
 
+/**
+ * In-place migration applied to every loaded meshes.json. Strips data that
+ * outlived the feature that wrote it so the persisted config converges on the
+ * current schema the next time it is saved.
+ *
+ * Currently: drops the dead `role` field from each node policy's providerRoles
+ * entries. providerRoles is retained for its `maxParallel` per-(node, provider)
+ * cap, but the routing `role` was removed (routing is governed solely by
+ * required_tags). A meshes.json written before the removal still carries
+ * `role: "validator"` etc.; this drops it on load so mesh_status / mesh_list_nodes
+ * never surface the dead field and the next saveMeshConfig() persists it gone.
+ *
+ * Returns true when the config was mutated (caller may persist eagerly).
+ */
+function migrateLoadedMeshConfig(config: LocalMeshConfig): boolean {
+    let changed = false;
+    for (const mesh of config.meshes) {
+        if (!mesh || !Array.isArray(mesh.nodes)) continue;
+        for (const node of mesh.nodes) {
+            if (stripDeadRoleFromProviderRoles(node?.policy)) changed = true;
+        }
+    }
+    return changed;
+}
+
+/**
+ * Drop the legacy `role` field from each providerRoles entry of a node policy,
+ * in place. Keeps providerType + maxParallel (the still-meaningful per-(node,
+ * provider) cap). Defensive against malformed entries — non-object items are
+ * left untouched. Returns true when at least one `role` field was removed.
+ */
+function stripDeadRoleFromProviderRoles(policy: unknown): boolean {
+    if (!policy || typeof policy !== 'object') return false;
+    const roles = (policy as { providerRoles?: unknown }).providerRoles;
+    if (!Array.isArray(roles)) return false;
+    let changed = false;
+    for (const entry of roles) {
+        if (entry && typeof entry === 'object' && !Array.isArray(entry)
+            && Object.prototype.hasOwnProperty.call(entry, 'role')) {
+            delete (entry as Record<string, unknown>).role;
+            changed = true;
+        }
+    }
+    return changed;
+}
+
 function normalizeCapabilityTags(value: unknown): string[] | undefined {
     if (!Array.isArray(value)) return undefined;
     const seen = new Set<string>();

package/src/index.ts

@@ -300,7 +300,7 @@ export type { CdpInitializerConfig } from './cdp/initializer.js';
 // ── Commands ──
 export { DaemonCommandHandler } from './commands/handler.js';
 export type { CommandResult, CommandContext } from './commands/handler.js';
-export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails } from './commands/router.js';
+export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails, resolveMeshNodeAttribution } from './commands/router.js';
 export type { CommandRouterDeps, CommandRouterResult } from './commands/router.js';
 export {
   maybeRunDaemonUpgradeHelperFromEnv,

package/src/shared-types.d.ts

@@ -206,6 +206,14 @@ export interface SessionEntry {
     completionMarker?: string;
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
+    /**
+     * True owning-daemon id for a session a coordinator synthesises into its own
+     * status snapshot (mesh delegated sessions), so the dashboard attributes it to the
+     * worker node instead of the coordinator daemon hosting the snapshot.
+     */
+    ownerDaemonId?: string;
+    /** True owning-machine display name fallback when the owning daemon is not aggregated. */
+    ownerMachineName?: string;
 }
 /**
  * Compact session metadata stored in UserSessionDO and reused by server-side

package/src/shared-types.ts

@@ -399,6 +399,15 @@ export interface SessionEntry {
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
     settings?: Record<string, any>;
+    /**
+     * True owning-daemon id for a session a coordinator synthesises into its own
+     * status snapshot (mesh delegated sessions). The dashboard attributes the session
+     * to this daemon instead of the snapshot daemon so the worker node — not the
+     * coordinator — is shown as its machine.
+     */
+    ownerDaemonId?: string;
+    /** True owning-machine display name fallback when the owning daemon is not aggregated. */
+    ownerMachineName?: string;
     /** Set when this session is acting as a mesh coordinator for the given mesh. */
     coordinator?: { meshId: string; role: 'coordinator' };
     meshQueueStats?: {