@adhdev/daemon-core 0.9.82-rc.446 → 0.9.82-rc.447

package/dist/mesh/mesh-node-identity.d.ts

@@ -48,6 +48,7 @@ export declare function buildLivePeerGitConnection(connection: Record<string, un
 export declare function recordInlineMeshDirectGitTruth(node: any, git: Record<string, unknown>, source: 'selected_coordinator_local_git' | 'selected_coordinator_mesh_p2p_git'): {
     reporterPlatform: string | null;
     reporterArch: string | null;
+    reporterMachineNickname: string | null;
 };
 /**
  * Persist the live self-reported platform/arch onto the local meshes.json node
@@ -63,6 +64,7 @@ export declare function recordInlineMeshDirectGitTruth(node: any, git: Record<st
 export declare function persistNodeReporterPlatform(meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config', mesh: any, nodeId: string | undefined, reporter: {
     reporterPlatform: string | null;
     reporterArch: string | null;
+    reporterMachineNickname?: string | null;
 }): void;
 export declare function inlineMeshCarriesTransientNodeTruth(inlineMesh: any): boolean;
 export declare function readInlineMeshNodeId(node: any): string;

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

@@ -580,6 +580,16 @@ export interface LocalMeshNodeEntry {
      */
     reportedPlatform?: string;
     reportedArch?: string;
+    /**
+     * The operator-set machine nickname (config.machineNickname) of the daemon
+     * that owns this node's workspace. The local coordinator stamps its own
+     * config value onto its self/base node; a remote member self-reports its
+     * value on the git_status envelope (reporterMachineNickname), which the
+     * coordinator persists here on each direct git probe. Feeds
+     * buildMeshNodeDisplayLabel so the mesh UI renders the friendly nickname
+     * instead of a raw daemonId/nodeId. Absent until set/first-reported.
+     */
+    machineNickname?: 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.446",
+  "version": "0.9.82-rc.447",
   "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.446",
+    "@adhdev/mesh-shared": "0.9.82-rc.447",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

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

@@ -180,6 +180,13 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                     const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
 
                     const localMachineId = loadConfig().machineId || '';
+                    // Local daemon's operator-set nickname — stamped onto the self/base
+                    // node at render time so the friendly label resolves even before the
+                    // persisted node record (addNode) has been rewritten with it.
+                    const localMachineNickname = (() => {
+                        const nick = loadConfig().machineNickname;
+                        return typeof nick === 'string' && nick.trim() ? nick.trim() : '';
+                    })();
                     const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
                     // Shared probe gate for this mesh_status call: the bootstrap
                     // hydrate below and the per-node render loop further down both
@@ -302,6 +309,14 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                             daemonId && (daemonIdsEquivalent(daemonId, localMachineId) || daemonIdsEquivalent(daemonId, ctx.deps.statusInstanceId)),
                         ) || Boolean(meshRecord?.inline && nodeIndex === 0)
                             || sparseConfiguredCoordinatorNode;
+                        // The self/base node's friendly label comes from THIS daemon's
+                        // local config.machineNickname. Stamp it onto the node record (if
+                        // not already carried) so buildMeshNodeDisplayLabel below resolves
+                        // to the nickname and labelSource reads 'explicit_metadata' even
+                        // before addNode's persisted record has been rewritten.
+                        if (isSelfNode && localMachineNickname && !readStringValue(node.machineNickname, node.machine_nickname)) {
+                            node.machineNickname = localMachineNickname;
+                        }
                         const machineIdentity = buildMeshNodeMachineIdentity(node as Record<string, unknown>, {
                             localMachineId,
                             localDaemonId: ctx.deps.statusInstanceId,

package/src/config/mesh-config.ts

@@ -10,7 +10,7 @@ import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { randomBytes, randomUUID } from 'crypto';
 import { shortHash } from '../system/hash.js';
-import { getConfigDir } from './config.js';
+import { getConfigDir, loadConfig } from './config.js';
 import type {
     LocalMeshConfig,
     LocalMeshEntry,
@@ -492,6 +492,11 @@ export interface AddNodeOptions {
     clonedFromNodeId?: string;
     worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
     role?: RepoMeshDaemonRole;
+    /** Owning daemon's machine nickname. Defaults to this daemon's local
+     *  config.machineNickname when omitted — a node is always added by (and on)
+     *  the daemon that owns its workspace (self/base node or a local worktree
+     *  clone), so the local config is the correct source. */
+    machineNickname?: string;
 }
 
 export function addNode(meshId: string, opts: AddNodeOptions): LocalMeshNodeEntry | undefined {
@@ -508,12 +513,27 @@ export function addNode(meshId: string, opts: AddNodeOptions): LocalMeshNodeEntr
         throw new Error('This workspace is already in the mesh');
     }
 
+    // A node is always added by the daemon that owns its workspace (the self/base
+    // node, or a local worktree clone spawned from this daemon), so this daemon's
+    // config.machineNickname is the correct owner nickname. Explicit opt wins.
+    const machineNickname = (() => {
+        const explicit = typeof opts.machineNickname === 'string' ? opts.machineNickname.trim() : '';
+        if (explicit) return explicit;
+        try {
+            const local = loadConfig().machineNickname;
+            return typeof local === 'string' && local.trim() ? local.trim() : undefined;
+        } catch {
+            return undefined;
+        }
+    })();
+
     const node: LocalMeshNodeEntry = {
         id: `node_${randomUUID().replace(/-/g, '')}`,
         workspace: opts.workspace.trim(),
         repoRoot: opts.repoRoot,
         daemonId: opts.daemonId,
         machineId: opts.machineId,
+        ...(machineNickname ? { machineNickname } : {}),
         capabilities: normalizeCapabilityTags(opts.capabilities),
         userOverrides: opts.userOverrides || {},
         policy: opts.policy || {},
@@ -559,6 +579,10 @@ export function updateNode(
          *  operator intent) so capability-tag os=/arch= self-heals across loads. */
         reportedPlatform?: string;
         reportedArch?: string;
+        /** Owning daemon's self-reported machine nickname, carried on the
+         *  git_status envelope. Persisted so the friendly label survives across
+         *  coordinator restarts (mirrors reportedPlatform/reportedArch). */
+        reportedMachineNickname?: string;
     },
 ): LocalMeshNodeEntry | undefined {
     const config = loadMeshConfig();
@@ -571,6 +595,7 @@ export function updateNode(
     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.reportedMachineNickname && opts.reportedMachineNickname.trim()) node.machineNickname = opts.reportedMachineNickname.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/git/git-commands.ts

@@ -4,6 +4,7 @@ import { getGitDiffSummary, getGitFileDiff } from './git-diff.js';
 import { GitCommandError, isPathInside, resolveGitRepository, runGit } from './git-executor.js';
 import { createGitSnapshotStore } from './git-snapshot-store.js';
 import { getGitRepoStatus } from './git-status.js';
+import { loadConfig } from '../config/config.js';
 import type {
   GitCommandName,
   GitDiffSummary,
@@ -113,7 +114,9 @@ type GitCommandSuccess =
   // reporterPlatform/reporterArch carry the responding daemon's process.platform/
   // process.arch so a mesh coordinator probing this node over P2P can self-heal the
   // node's userOverrides.platform/arch (the fields capability-tag routing reads).
-  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string }
+  // reporterMachineNickname carries the responding daemon's config.machineNickname
+  // so the coordinator can populate node.machineNickname → the friendly display label.
+  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string; reporterMachineNickname?: string }
   | { success: true; diffSummary: GitDiffSummary }
   | { success: true; diff: GitFileDiff }
   | { success: true; snapshot: GitSnapshot }
@@ -315,7 +318,23 @@ export async function handleGitCommand(
       // stamps it onto the node's userOverrides.platform/arch (the fields
       // buildMeshNodeCapabilityTags reads). These are siblings of `status`, not
       // part of GitRepoStatus, so the git payload shape is untouched.
-      return { success: true, status, reporterPlatform: process.platform, reporterArch: process.arch };
+      // The machine nickname rides the same channel so the coordinator can render
+      // this node's friendly label instead of a raw daemonId/nodeId.
+      const reporterMachineNickname = (() => {
+        try {
+          const nick = loadConfig().machineNickname;
+          return typeof nick === 'string' && nick.trim() ? nick.trim() : undefined;
+        } catch {
+          return undefined;
+        }
+      })();
+      return {
+        success: true,
+        status,
+        reporterPlatform: process.platform,
+        reporterArch: process.arch,
+        ...(reporterMachineNickname ? { reporterMachineNickname } : {}),
+      };
     }
 
     case 'git_diff_summary': {

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

@@ -319,9 +319,9 @@ export function recordInlineMeshDirectGitTruth(
     node: any,
     git: Record<string, unknown>,
     source: 'selected_coordinator_local_git' | 'selected_coordinator_mesh_p2p_git',
-): { reporterPlatform: string | null; reporterArch: string | null } {
+): { reporterPlatform: string | null; reporterArch: string | null; reporterMachineNickname: string | null } {
     if (!node || typeof node !== 'object' || Array.isArray(node)) {
-        return { reporterPlatform: null, reporterArch: null };
+        return { reporterPlatform: null, reporterArch: null, reporterMachineNickname: null };
     }
     const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
     const updatedAt = new Date(checkedAt).toISOString();
@@ -359,7 +359,14 @@ export function recordInlineMeshDirectGitTruth(
     // 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 };
+    // Machine nickname: only a remote member self-reports it (reporterMachineNickname
+    // rides the git_status envelope). For a local_source probe the workspace lives on
+    // THIS machine, but the self/base node already carries the local config nickname
+    // (addNode stamps it), so we only stamp from an explicit report here — never
+    // overwrite an existing nickname with an empty value.
+    const reporterMachineNickname = readStringValue(git.reporterMachineNickname) ?? null;
+    if (reporterMachineNickname) node.machineNickname = reporterMachineNickname;
+    return { reporterPlatform, reporterArch, reporterMachineNickname };
 }
 
 /**
@@ -396,16 +403,17 @@ export function persistNodeReporterPlatform(
     meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config',
     mesh: any,
     nodeId: string | undefined,
-    reporter: { reporterPlatform: string | null; reporterArch: string | null },
+    reporter: { reporterPlatform: string | null; reporterArch: string | null; reporterMachineNickname?: 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;
+    const reportedMachineNickname = reporter.reporterMachineNickname ?? undefined;
+    if (!reportedPlatform && !reportedArch && !reportedMachineNickname) return;
     void import('../config/mesh-config.js')
-        .then(({ updateNode }) => updateNode(meshId, nodeId, { reportedPlatform, reportedArch }))
+        .then(({ updateNode }) => updateNode(meshId, nodeId, { reportedPlatform, reportedArch, reportedMachineNickname }))
         .catch(() => { /* best-effort self-heal; never block status assembly */ });
 }
 
@@ -1409,9 +1417,11 @@ async function probeRemoteMeshGitStatus(args: {
     // persist them to node.userOverrides without touching the git status shape.
     const reporterPlatform = readStringValue(remoteResult?.reporterPlatform);
     const reporterArch = readStringValue(remoteResult?.reporterArch);
+    const reporterMachineNickname = readStringValue(remoteResult?.reporterMachineNickname);
     const git = remoteGit as Record<string, unknown>;
     if (reporterPlatform) git.reporterPlatform = reporterPlatform;
     if (reporterArch) git.reporterArch = reporterArch;
+    if (reporterMachineNickname) git.reporterMachineNickname = reporterMachineNickname;
     return git;
 }
 

package/src/repo-mesh-types.ts

@@ -849,6 +849,16 @@ export interface LocalMeshNodeEntry {
      */
     reportedPlatform?: string;
     reportedArch?: string;
+    /**
+     * The operator-set machine nickname (config.machineNickname) of the daemon
+     * that owns this node's workspace. The local coordinator stamps its own
+     * config value onto its self/base node; a remote member self-reports its
+     * value on the git_status envelope (reporterMachineNickname), which the
+     * coordinator persists here on each direct git probe. Feeds
+     * buildMeshNodeDisplayLabel so the mesh UI renders the friendly nickname
+     * instead of a raw daemonId/nodeId. Absent until set/first-reported.
+     */
+    machineNickname?: string;
     policy: RepoMeshNodePolicy;
     /**
      * Per-node instruction surfaced in the coordinator prompt so the LLM