@adhdev/daemon-core 0.9.66 → 0.9.68

package/dist/mesh/coordinator-prompt.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Coordinator Prompt — System prompt template for mesh coordinator sessions
+ *
+ * When an MCP server starts in mesh mode, this prompt is injected into the
+ * coordinator agent's context so it understands:
+ *   1. What the mesh is (repo, nodes, policy)
+ *   2. What tools are available
+ *   3. How to orchestrate work across nodes
+ *
+ * The prompt is generated dynamically from the current mesh state.
+ */
+import type { LocalMeshEntry, RepoMeshStatus } from '../repo-mesh-types.js';
+export interface CoordinatorPromptContext {
+    mesh: LocalMeshEntry;
+    status?: RepoMeshStatus;
+    userInstruction?: string;
+}
+export declare function buildCoordinatorSystemPrompt(ctx: CoordinatorPromptContext): string;

package/dist/mesh/mesh-sync.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Mesh Sync — Sync local mesh config to/from cloud D1
+ *
+ * When cloud is available, this module pushes local mesh config
+ * to the server and pulls remote meshes that were created from
+ * other machines. The local ~/.adhdev/meshes.json remains the
+ * canonical source; cloud is a persistence/relay layer.
+ *
+ * This is called lazily (not on daemon startup) — only when the
+ * user explicitly opens the mesh page or runs `adhdev mesh sync`.
+ */
+export interface MeshSyncTransport {
+    /** GET /api/v1/repo-meshes */
+    listRemoteMeshes(): Promise<{
+        meshes: RemoteMeshRecord[];
+    }>;
+    /** POST /api/v1/repo-meshes */
+    createRemoteMesh(data: {
+        name: string;
+        repo_identity: string;
+        repo_remote_url?: string;
+        default_branch?: string;
+        policy?: string;
+    }): Promise<{
+        mesh: RemoteMeshRecord;
+    }>;
+    /** DELETE /api/v1/repo-meshes/:id */
+    deleteRemoteMesh(meshId: string): Promise<void>;
+}
+export interface RemoteMeshRecord {
+    id: string;
+    name: string;
+    repo_identity: string;
+    repo_remote_url: string | null;
+    default_branch: string | null;
+    policy: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface MeshSyncResult {
+    pushed: number;
+    pulled: number;
+    deleted: number;
+    errors: string[];
+}
+/**
+ * Push local meshes to cloud (upsert by repo_identity).
+ * Pull remote meshes that don't exist locally.
+ */
+export declare function syncMeshes(transport: MeshSyncTransport): Promise<MeshSyncResult>;

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

@@ -0,0 +1,168 @@
+/**
+ * Repo Mesh Types — Cross-package type definitions for repo-scoped orchestration
+ *
+ * A Repo Mesh is a repo-scoped execution environment that groups
+ * machines/workspaces around one Git repository identity. A coordinator
+ * agent delegates work to mesh nodes via natural conversation.
+ *
+ * These types are OSS-level and usable without cloud infrastructure.
+ * Import via: import type { ... } from '@adhdev/daemon-core/repo-mesh-types'
+ *
+ * IMPORTANT: This file must remain runtime-free (types only).
+ */
+import type { GitRepoStatus, GitCompactSummary } from './git/git-types.js';
+export interface RepoMesh {
+    id: string;
+    name: string;
+    repoIdentity: string;
+    repoRemoteUrl?: string;
+    defaultBranch?: string;
+    policy: RepoMeshPolicy;
+    coordinator: RepoMeshCoordinatorConfig;
+    projectContext: ProjectContextSnapshot;
+    nodes: RepoMeshNode[];
+    status: 'active' | 'archived' | 'deleted';
+}
+export interface RepoMeshNode {
+    id: string;
+    daemonId: string;
+    machineId?: string;
+    machineLabel: string;
+    workspace: string;
+    repoRoot?: string;
+    git?: GitCompactSummary;
+    providers: string[];
+    detectedCapabilities: RepoMeshNodeCapabilities;
+    userOverrides: Partial<RepoMeshNodeCapabilities>;
+    effectiveCapabilities: RepoMeshNodeCapabilities;
+    policy: RepoMeshNodePolicy;
+    health: RepoMeshNodeHealth;
+    status: 'enabled' | 'disabled' | 'removed';
+}
+export type RepoMeshNodeHealth = 'online' | 'offline' | 'degraded' | 'dirty' | 'wrong_branch' | 'unknown';
+export interface RepoMeshPolicy {
+    requirePreTaskCheckpoint: boolean;
+    requirePostTaskCheckpoint: boolean;
+    requireApprovalForPush: boolean;
+    requireApprovalForDestructiveGit: boolean;
+    dirtyWorkspaceBehavior: 'block' | 'warn' | 'checkpoint_then_continue';
+    maxParallelTasks: number;
+    allowedProviders?: string[];
+}
+export interface RepoMeshNodePolicy {
+    readOnly?: boolean;
+    canPush?: boolean;
+    maxConcurrentSessions?: number;
+}
+export declare const DEFAULT_MESH_POLICY: RepoMeshPolicy;
+export interface RepoMeshNodeCapabilities {
+    platform?: string;
+    packageManagers?: string[];
+    detectedCommands?: DetectedCommand[];
+    canRunLongJobs?: boolean;
+    canRunDocker?: boolean;
+    canRunBrowserE2E?: boolean;
+    canAccessSecrets?: boolean;
+    canPush?: boolean;
+    readOnly?: boolean;
+    userLabels?: string[];
+}
+export interface DetectedCommand {
+    command: string;
+    sourcePath: string;
+    confidence: 'high' | 'medium' | 'low';
+    requiresApproval?: boolean;
+}
+export interface ProjectContextSnapshot {
+    version: number;
+    generatedAt: string;
+    sources: ProjectContextSource[];
+    repo: {
+        identity: string;
+        remoteUrl?: string;
+        defaultBranch?: string;
+        currentBranches: string[];
+    };
+    layout: {
+        packageManager?: string;
+        workspaceFiles: string[];
+        packageRoots: string[];
+        likelyEntryPoints: string[];
+    };
+    commands: {
+        build?: DetectedCommand[];
+        test?: DetectedCommand[];
+        typecheck?: DetectedCommand[];
+        lint?: DetectedCommand[];
+        e2e?: DetectedCommand[];
+    };
+    instructions: {
+        files: string[];
+        summary: string;
+    };
+    conventions: {
+        pathHints: string[];
+        validationNotes: string[];
+        riskyAreas: string[];
+    };
+}
+export interface ProjectContextSource {
+    kind: 'daemon_status' | 'git' | 'project_file' | 'instruction_file' | 'user_override' | 'probe_error';
+    nodeId?: string;
+    path?: string;
+    observedAt: string;
+    confidence: 'high' | 'medium' | 'low';
+}
+export interface RepoMeshCoordinatorConfig {
+    /** Provider to use for coordinator session (e.g. 'claude-cli', 'cursor') */
+    providerType?: string;
+    /** Preferred node to run coordinator on (null = auto) */
+    preferredNodeId?: string;
+    /** Additional system prompt context for coordinator */
+    systemPromptSuffix?: string;
+}
+/**
+ * Local mesh configuration stored in ~/.adhdev/meshes.json
+ * Used by OSS standalone mode without cloud infrastructure.
+ */
+export interface LocalMeshConfig {
+    meshes: LocalMeshEntry[];
+}
+export interface LocalMeshEntry {
+    id: string;
+    name: string;
+    repoIdentity: string;
+    repoRemoteUrl?: string;
+    defaultBranch?: string;
+    policy: RepoMeshPolicy;
+    coordinator: RepoMeshCoordinatorConfig;
+    nodes: LocalMeshNodeEntry[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface LocalMeshNodeEntry {
+    id: string;
+    workspace: string;
+    repoRoot?: string;
+    userOverrides: Partial<RepoMeshNodeCapabilities>;
+    policy: RepoMeshNodePolicy;
+    /** For single-machine mesh: same daemon, different worktree */
+    isLocalWorktree?: boolean;
+}
+export interface RepoMeshStatus {
+    meshId: string;
+    meshName: string;
+    repoIdentity: string;
+    refreshedAt: string;
+    nodes: RepoMeshNodeStatus[];
+}
+export interface RepoMeshNodeStatus {
+    nodeId: string;
+    machineLabel: string;
+    workspace: string;
+    health: RepoMeshNodeHealth;
+    git?: GitRepoStatus;
+    providers: string[];
+    activeSessions: string[];
+    error?: string;
+}

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.66",
+  "version": "0.9.68",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.66",
+  "version": "0.9.68",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -920,6 +920,162 @@ export class DaemonCommandRouter {
                 return { success: true };
             }
 
+            // ─── Mesh CRUD (local meshes.json) ───
+            case 'list_meshes': {
+                try {
+                    const { listMeshes } = await import('../config/mesh-config.js');
+                    return { success: true, meshes: listMeshes() };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'get_mesh': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                if (!meshId) return { success: false, error: 'meshId required' };
+                try {
+                    const { getMesh } = await import('../config/mesh-config.js');
+                    const mesh = getMesh(meshId);
+                    if (!mesh) return { success: false, error: 'Mesh not found' };
+                    return { success: true, mesh };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'create_mesh': {
+                const name = typeof args?.name === 'string' ? args.name.trim() : '';
+                const repoIdentity = typeof args?.repoIdentity === 'string' ? args.repoIdentity.trim() : '';
+                const repoRemoteUrl = typeof args?.repoRemoteUrl === 'string' ? args.repoRemoteUrl.trim() : undefined;
+                const defaultBranch = typeof args?.defaultBranch === 'string' ? args.defaultBranch.trim() : undefined;
+                if (!name) return { success: false, error: 'name required' };
+                try {
+                    const { createMesh } = await import('../config/mesh-config.js');
+                    const mesh = createMesh({ name, repoIdentity, repoRemoteUrl, defaultBranch });
+                    return { success: true, mesh };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'delete_mesh': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                if (!meshId) return { success: false, error: 'meshId required' };
+                try {
+                    const { deleteMesh } = await import('../config/mesh-config.js');
+                    const deleted = deleteMesh(meshId);
+                    return { success: true, deleted };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'add_mesh_node': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const workspace = typeof args?.workspace === 'string' ? args.workspace.trim() : '';
+                if (!meshId) return { success: false, error: 'meshId required' };
+                if (!workspace) return { success: false, error: 'workspace required' };
+                try {
+                    const { addNode } = await import('../config/mesh-config.js');
+                    const node = addNode(meshId, { workspace });
+                    if (!node) return { success: false, error: 'Mesh not found' };
+                    return { success: true, node };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'remove_mesh_node': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const nodeId = typeof args?.nodeId === 'string' ? args.nodeId.trim() : '';
+                if (!meshId || !nodeId) return { success: false, error: 'meshId and nodeId required' };
+                try {
+                    const { removeNode } = await import('../config/mesh-config.js');
+                    const removed = removeNode(meshId, nodeId);
+                    return { success: true, removed };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            // ─── Mesh Coordinator Launch ───
+            case 'launch_mesh_coordinator': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const cliType = typeof args?.cliType === 'string' ? args.cliType.trim() : 'claude-cli';
+                if (!meshId) return { success: false, error: 'meshId required' };
+
+                try {
+                    const { getMesh } = await import('../config/mesh-config.js');
+                    const { buildCoordinatorSystemPrompt } = await import('../mesh/coordinator-prompt.js');
+                    const mesh = getMesh(meshId);
+                    if (!mesh) return { success: false, error: 'Mesh not found' };
+                    if (mesh.nodes.length === 0) return { success: false, error: 'No nodes in mesh' };
+
+                    const workspace = mesh.nodes[0].workspace;
+
+                    // 1. Write .mcp.json to workspace so Claude CLI auto-discovers mesh tools
+                    const { existsSync, readFileSync, writeFileSync, copyFileSync } = await import('fs');
+                    const { join } = await import('path');
+                    const mcpConfigPath = join(workspace, '.mcp.json');
+
+                    // Backup existing .mcp.json if present
+                    const hadExistingMcpConfig = existsSync(mcpConfigPath);
+                    let existingMcpConfig: any = {};
+                    if (hadExistingMcpConfig) {
+                        try {
+                            existingMcpConfig = JSON.parse(readFileSync(mcpConfigPath, 'utf-8'));
+                            copyFileSync(mcpConfigPath, mcpConfigPath + '.backup');
+                        } catch { /* empty */ }
+                    }
+
+                    // Merge adhdev-mesh server into existing config
+                    const mcpConfig = {
+                        ...existingMcpConfig,
+                        mcpServers: {
+                            ...(existingMcpConfig.mcpServers || {}),
+                            'adhdev-mesh': {
+                                command: 'adhdev-mcp',
+                                args: ['--repo-mesh', meshId],
+                            },
+                        },
+                    };
+                    writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
+                    LOG.info('MeshCoordinator', `Wrote .mcp.json to ${workspace} with adhdev-mesh server`);
+
+                    // 2. Build coordinator system prompt
+                    let systemPrompt = '';
+                    try {
+                        systemPrompt = buildCoordinatorSystemPrompt({ mesh });
+                    } catch {
+                        systemPrompt = `You are a Repo Mesh Coordinator for "${mesh.name}". Use the adhdev-mesh MCP tools (mesh_status, mesh_list_nodes, mesh_send_task, mesh_read_chat, mesh_launch_session, etc.) to orchestrate work across ${mesh.nodes.length} node(s).`;
+                    }
+
+                    // 3. Launch CLI session via existing cliManager
+                    const launchResult: any = await this.deps.cliManager.handleCliCommand('launch_cli', {
+                        cliType,
+                        dir: workspace,
+                        initialPrompt: systemPrompt,
+                    });
+
+                    if (!launchResult?.success) {
+                        return { success: false, error: launchResult?.error || 'Failed to launch CLI session' };
+                    }
+
+                    LOG.info('MeshCoordinator', `Launched ${cliType} coordinator for mesh ${meshId} in ${workspace}`);
+                    return {
+                        success: true,
+                        meshId,
+                        cliType,
+                        workspace,
+                        sessionId: launchResult.sessionId || launchResult.id,
+                        mcpConfigWritten: true,
+                    };
+                } catch (e: any) {
+                    LOG.error('MeshCoordinator', `Failed: ${e.message}`);
+                    return { success: false, error: e.message };
+                }
+            }
+
             default:
                 break;
         }

package/src/config/mesh-config.ts

@@ -0,0 +1,228 @@
+/**
+ * Repo Mesh Config — Local mesh configuration stored in ~/.adhdev/meshes.json
+ *
+ * Manages repo mesh definitions for OSS standalone mode.
+ * Cloud mode syncs these to D1 via server routes; standalone mode
+ * uses this file as the single source of truth.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+import { getConfigDir } from './config.js';
+import type {
+    LocalMeshConfig,
+    LocalMeshEntry,
+    LocalMeshNodeEntry,
+    RepoMeshPolicy,
+    RepoMeshNodePolicy,
+    RepoMeshNodeCapabilities,
+    RepoMeshCoordinatorConfig,
+} from '../repo-mesh-types.js';
+import { DEFAULT_MESH_POLICY } from '../repo-mesh-types.js';
+
+// ─── Persistence ────────────────────────────────
+
+function getMeshConfigPath(): string {
+    return join(getConfigDir(), 'meshes.json');
+}
+
+function loadMeshConfig(): LocalMeshConfig {
+    const path = getMeshConfigPath();
+    if (!existsSync(path)) return { meshes: [] };
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf-8'));
+        if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
+        return raw as LocalMeshConfig;
+    } catch {
+        return { meshes: [] };
+    }
+}
+
+function saveMeshConfig(config: LocalMeshConfig): void {
+    const path = getMeshConfigPath();
+    writeFileSync(path, JSON.stringify(config, null, 2), { encoding: 'utf-8', mode: 0o600 });
+}
+
+// ─── Repo Identity Normalization ────────────────
+
+/**
+ * Normalize a Git remote URL into a stable identity string.
+ * e.g. "git@github.com:user/repo.git" → "github.com/user/repo"
+ *      "https://github.com/user/repo.git" → "github.com/user/repo"
+ */
+export function normalizeRepoIdentity(remoteUrl: string): string {
+    let identity = remoteUrl.trim();
+
+    // HTTPS format first (takes priority over SSH fallback)
+    if (identity.startsWith('http://') || identity.startsWith('https://')) {
+        try {
+            const url = new URL(identity);
+            const path = url.pathname.replace(/^\//, '').replace(/\.git$/, '');
+            return `${url.hostname}/${path}`;
+        } catch {
+            // fall through
+        }
+    }
+
+    // SSH format: git@host:owner/repo.git or ssh://git@host/owner/repo.git
+    const sshMatch = identity.match(/^(?:ssh:\/\/)?[\w.-]+@([\w.-]+)[:/]([\w.\-/]+?)(?:\.git)?$/);
+    if (sshMatch) return `${sshMatch[1]}/${sshMatch[2]}`;
+
+    return identity;
+}
+
+// ─── CRUD Operations ────────────────────────────
+
+export function listMeshes(): LocalMeshEntry[] {
+    return loadMeshConfig().meshes;
+}
+
+export function getMesh(meshId: string): LocalMeshEntry | undefined {
+    return loadMeshConfig().meshes.find(m => m.id === meshId);
+}
+
+export function getMeshByRepo(repoIdentity: string): LocalMeshEntry | undefined {
+    return loadMeshConfig().meshes.find(m => m.repoIdentity === repoIdentity);
+}
+
+export interface CreateMeshOptions {
+    name: string;
+    repoRemoteUrl?: string;
+    repoIdentity?: string;
+    defaultBranch?: string;
+    policy?: Partial<RepoMeshPolicy>;
+    coordinator?: RepoMeshCoordinatorConfig;
+}
+
+export function createMesh(opts: CreateMeshOptions): LocalMeshEntry {
+    const config = loadMeshConfig();
+
+    if (config.meshes.length >= 20) {
+        throw new Error('Maximum 20 meshes allowed');
+    }
+
+    const repoIdentity = opts.repoIdentity || (opts.repoRemoteUrl ? normalizeRepoIdentity(opts.repoRemoteUrl) : '');
+    if (!repoIdentity) throw new Error('Either repoRemoteUrl or repoIdentity is required');
+
+    const now = new Date().toISOString();
+    const mesh: LocalMeshEntry = {
+        id: `mesh_${randomUUID().replace(/-/g, '')}`,
+        name: opts.name.trim().slice(0, 100),
+        repoIdentity,
+        repoRemoteUrl: opts.repoRemoteUrl,
+        defaultBranch: opts.defaultBranch,
+        policy: { ...DEFAULT_MESH_POLICY, ...opts.policy },
+        coordinator: opts.coordinator || {},
+        nodes: [],
+        createdAt: now,
+        updatedAt: now,
+    };
+
+    config.meshes.push(mesh);
+    saveMeshConfig(config);
+    return mesh;
+}
+
+export interface UpdateMeshOptions {
+    name?: string;
+    defaultBranch?: string;
+    policy?: Partial<RepoMeshPolicy>;
+    coordinator?: RepoMeshCoordinatorConfig;
+}
+
+export function updateMesh(meshId: string, opts: UpdateMeshOptions): LocalMeshEntry | undefined {
+    const config = loadMeshConfig();
+    const mesh = config.meshes.find(m => m.id === meshId);
+    if (!mesh) return undefined;
+
+    if (opts.name !== undefined) mesh.name = opts.name.trim().slice(0, 100);
+    if (opts.defaultBranch !== undefined) mesh.defaultBranch = opts.defaultBranch;
+    if (opts.policy) mesh.policy = { ...mesh.policy, ...opts.policy };
+    if (opts.coordinator) mesh.coordinator = opts.coordinator;
+    mesh.updatedAt = new Date().toISOString();
+
+    saveMeshConfig(config);
+    return mesh;
+}
+
+export function deleteMesh(meshId: string): boolean {
+    const config = loadMeshConfig();
+    const idx = config.meshes.findIndex(m => m.id === meshId);
+    if (idx === -1) return false;
+    config.meshes.splice(idx, 1);
+    saveMeshConfig(config);
+    return true;
+}
+
+// ─── Node Operations ────────────────────────────
+
+export interface AddNodeOptions {
+    workspace: string;
+    repoRoot?: string;
+    userOverrides?: Partial<RepoMeshNodeCapabilities>;
+    policy?: RepoMeshNodePolicy;
+    isLocalWorktree?: boolean;
+}
+
+export function addNode(meshId: string, opts: AddNodeOptions): LocalMeshNodeEntry | undefined {
+    const config = loadMeshConfig();
+    const mesh = config.meshes.find(m => m.id === meshId);
+    if (!mesh) return undefined;
+
+    if (mesh.nodes.length >= 10) {
+        throw new Error('Maximum 10 nodes per mesh');
+    }
+
+    // Check duplicate workspace
+    if (mesh.nodes.some(n => n.workspace === opts.workspace)) {
+        throw new Error('This workspace is already in the mesh');
+    }
+
+    const node: LocalMeshNodeEntry = {
+        id: `node_${randomUUID().replace(/-/g, '')}`,
+        workspace: opts.workspace.trim(),
+        repoRoot: opts.repoRoot,
+        userOverrides: opts.userOverrides || {},
+        policy: opts.policy || {},
+        isLocalWorktree: opts.isLocalWorktree,
+    };
+
+    mesh.nodes.push(node);
+    mesh.updatedAt = new Date().toISOString();
+    saveMeshConfig(config);
+    return node;
+}
+
+export function removeNode(meshId: string, nodeId: string): boolean {
+    const config = loadMeshConfig();
+    const mesh = config.meshes.find(m => m.id === meshId);
+    if (!mesh) return false;
+
+    const idx = mesh.nodes.findIndex(n => n.id === nodeId);
+    if (idx === -1) return false;
+
+    mesh.nodes.splice(idx, 1);
+    mesh.updatedAt = new Date().toISOString();
+    saveMeshConfig(config);
+    return true;
+}
+
+export function updateNode(
+    meshId: string,
+    nodeId: string,
+    opts: { userOverrides?: Partial<RepoMeshNodeCapabilities>; policy?: RepoMeshNodePolicy },
+): LocalMeshNodeEntry | undefined {
+    const config = loadMeshConfig();
+    const mesh = config.meshes.find(m => m.id === meshId);
+    if (!mesh) return undefined;
+
+    const node = mesh.nodes.find(n => n.id === nodeId);
+    if (!node) return undefined;
+
+    if (opts.userOverrides) node.userOverrides = { ...node.userOverrides, ...opts.userOverrides };
+    if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
+    mesh.updatedAt = new Date().toISOString();
+    saveMeshConfig(config);
+    return node;
+}