@adhdev/daemon-core 0.9.76-rc.8 → 0.9.76

package/src/commands/router.ts

@@ -30,14 +30,19 @@ import { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
 import { logCommand } from '../logging/command-log.js';
 import type { CommandLogEntry } from '../logging/command-log.js';
+import * as yaml from 'js-yaml';
 import { getRecentLogs, LOG_PATH } from '../logging/logger.js';
 import { createInteractionId, getRecentDebugTrace, recordDebugTrace } from '../logging/debug-trace.js';
 import { getSessionHostSurfaceKind, partitionSessionHostRecords } from '../session-host/runtime-surface.js';
-import { resolveMeshCoordinatorSetup } from './mesh-coordinator.js';
+import { createHermesManualMeshCoordinatorSetup, resolveMeshCoordinatorSetup } from './mesh-coordinator.js';
 import { buildSessionEntries } from '../status/builders.js';
+import { handleMeshForwardEvent, drainPendingMeshCoordinatorEvents } from '../mesh/mesh-events.js';
 import { buildMachineInfo, buildStatusSnapshot } from '../status/snapshot.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
 import { execNpmCommandSync, resolveCurrentGlobalInstallSurface, spawnDetachedDaemonUpgradeHelper } from './upgrade-helper.js';
+import type { RepoMeshSessionCleanupMode } from '../repo-mesh-types.js';
+import { homedir } from 'os';
+import { join as pathJoin, resolve as pathResolve } from 'path';
 
 type ReleaseChannel = 'stable' | 'preview';
 const CHANNEL_NPM_TAG: Record<ReleaseChannel, 'latest' | 'next'> = { stable: 'latest', preview: 'next' };
@@ -61,14 +66,115 @@ function resolveUpgradeChannel(args: any): ReleaseChannel {
         || normalizeReleaseChannel(loadConfig().updateChannel)
         || 'stable';
 }
+
+function readProviderPriorityFromPolicy(policy: unknown): string[] {
+    const record = policy && typeof policy === 'object' && !Array.isArray(policy)
+        ? policy as Record<string, unknown>
+        : {};
+    const raw = record.providerPriority;
+    if (!Array.isArray(raw)) return [];
+    const seen = new Set<string>();
+    return raw
+        .map(type => typeof type === 'string' ? type.trim() : '')
+        .filter(Boolean)
+        .filter(type => {
+            if (seen.has(type)) return false;
+            seen.add(type);
+            return true;
+        });
+}
+
+async function resolveProviderTypeFromPriority(args: {
+    nodeId: string;
+    providerPriority: string[];
+    providerLoader: ProviderLoader;
+    onStatusChange?: () => void;
+}): Promise<{ providerType?: string; error?: string }> {
+    if (!args.providerPriority.length) {
+        return { error: `Node '${args.nodeId}' has no providerPriority policy; pass cliType explicitly or configure node.policy.providerPriority` };
+    }
+
+    const failed: string[] = [];
+    for (const requestedType of args.providerPriority) {
+        const normalizedType = args.providerLoader.resolveAlias(requestedType);
+        if (!args.providerLoader.isMachineProviderEnabled(normalizedType)) {
+            failed.push(`${requestedType}: disabled`);
+            continue;
+        }
+        const detected = await detectCLI(normalizedType, args.providerLoader, { includeVersion: false });
+        args.providerLoader.setCliDetectionResults([{
+            id: normalizedType,
+            installed: !!detected,
+            path: detected?.path,
+        }], false);
+        args.onStatusChange?.();
+        if (detected) return { providerType: normalizedType };
+        failed.push(`${requestedType}: not detected`);
+    }
+
+    return { error: `No usable provider detected for node '${args.nodeId}' from providerPriority: ${failed.join('; ')}` };
+}
 import * as fs from 'fs';
 
+type MeshCoordinatorConfigFormat = 'claude_mcp_json' | 'hermes_config_yaml';
+
+function loadYamlModule(): { load: (input: string) => any; dump: (input: any, options?: Record<string, any>) => string } {
+    return yaml as { load: (input: string) => any; dump: (input: any, options?: Record<string, any>) => string };
+}
+
+function getMcpServersKey(format: MeshCoordinatorConfigFormat): 'mcpServers' | 'mcp_servers' {
+    return format === 'hermes_config_yaml' ? 'mcp_servers' : 'mcpServers';
+}
+
+function parseMeshCoordinatorMcpConfig(text: string, format: MeshCoordinatorConfigFormat): Record<string, any> {
+    if (!text.trim()) return {};
+    if (format === 'claude_mcp_json') return JSON.parse(text);
+    const parsed = loadYamlModule().load(text);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+}
+
+function serializeMeshCoordinatorMcpConfig(config: Record<string, any>, format: MeshCoordinatorConfigFormat): string {
+    if (format === 'claude_mcp_json') return JSON.stringify(config, null, 2);
+    return loadYamlModule().dump(config, { noRefs: true, lineWidth: 120 });
+}
+
+function resolveHermesUserHome(): string {
+    const explicitHome = process.env.HERMES_HOME?.trim();
+    return explicitHome || pathJoin(homedir(), '.hermes');
+}
+
+function loadHermesCoordinatorBaseConfig(targetConfigPath: string): { config: Record<string, any>; sourceHome: string; sourceConfigPath: string } {
+    const sourceHome = resolveHermesUserHome();
+    const sourceConfigPath = pathJoin(sourceHome, 'config.yaml');
+    if (!fs.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+    if (pathResolve(sourceConfigPath) === pathResolve(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+
+    const parsed = parseMeshCoordinatorMcpConfig(fs.readFileSync(sourceConfigPath, 'utf-8'), 'hermes_config_yaml');
+    const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
+    return { config: baseConfig, sourceHome, sourceConfigPath };
+}
+
+function copyHermesCoordinatorCredentialFiles(sourceHome: string, targetHome: string) {
+    if (pathResolve(sourceHome) === pathResolve(targetHome)) return;
+    for (const fileName of ['.env', 'auth.json']) {
+        const sourcePath = pathJoin(sourceHome, fileName);
+        const targetPath = pathJoin(targetHome, fileName);
+        if (!fs.existsSync(sourcePath)) continue;
+        try {
+            fs.copyFileSync(sourcePath, targetPath);
+        } catch (error: any) {
+            LOG.warn('MeshCoordinator', `Could not copy Hermes ${fileName} into isolated coordinator home: ${error?.message || error}`);
+        }
+    }
+}
+
 // ─── Types ───
 
 export interface SessionHostControlPlane {
     getDiagnostics(payload?: { includeSessions?: boolean; limit?: number }): Promise<any>;
     listSessions(): Promise<any[]>;
     stopSession(sessionId: string): Promise<any>;
+    deleteSession(sessionId: string, opts?: { force?: boolean }): Promise<any>;
     resumeSession(sessionId: string): Promise<any>;
     restartSession(sessionId: string): Promise<any>;
     sendSignal(sessionId: string, signal: string): Promise<any>;
@@ -226,6 +332,184 @@ export class DaemonCommandRouter {
         this.deps = deps;
     }
 
+    private getCachedInlineMesh(meshId: string, inlineMesh?: unknown): any | undefined {
+        if (inlineMesh && typeof inlineMesh === 'object') {
+            this.inlineMeshCache.set(meshId, inlineMesh as any);
+            return inlineMesh as any;
+        }
+        return this.inlineMeshCache.get(meshId);
+    }
+
+    private async getMeshForCommand(meshId: string, inlineMesh?: unknown): Promise<{ mesh: any; inline: boolean } | null> {
+        try {
+            const { getMesh } = await import('../config/mesh-config.js');
+            const mesh = getMesh(meshId);
+            if (mesh) return { mesh, inline: false };
+        } catch { /* fall through to inline cache */ }
+        const cached = this.getCachedInlineMesh(meshId, inlineMesh);
+        return cached ? { mesh: cached, inline: true } : null;
+    }
+
+    private updateInlineMeshNode(meshId: string, mesh: any, node: any): void {
+        if (!mesh || !Array.isArray(mesh.nodes) || !node?.id) return;
+        const idx = mesh.nodes.findIndex((entry: any) => entry?.id === node.id || entry?.nodeId === node.id);
+        if (idx >= 0) mesh.nodes[idx] = node;
+        else mesh.nodes.push(node);
+        mesh.updatedAt = new Date().toISOString();
+        this.inlineMeshCache.set(meshId, mesh);
+    }
+
+    private removeInlineMeshNode(meshId: string, mesh: any, nodeId: string): boolean {
+        if (!mesh || !Array.isArray(mesh.nodes)) return false;
+        const idx = mesh.nodes.findIndex((entry: any) => entry?.id === nodeId || entry?.nodeId === nodeId);
+        if (idx === -1) return false;
+        mesh.nodes.splice(idx, 1);
+        mesh.updatedAt = new Date().toISOString();
+        this.inlineMeshCache.set(meshId, mesh);
+        return true;
+    }
+
+    private normalizeMeshSessionCleanupMode(value: unknown): RepoMeshSessionCleanupMode {
+        return value === 'stop'
+            || value === 'delete_stopped'
+            || value === 'stop_and_delete'
+            || value === 'preserve'
+            ? value
+            : 'preserve';
+    }
+
+    private sessionMatchesMeshNode(record: any, node: any, nodeId: string, sessionIds?: Set<string>): boolean {
+        const sessionId = typeof record?.sessionId === 'string' ? record.sessionId : '';
+        if (!sessionId) return false;
+        if (sessionIds?.size) return sessionIds.has(sessionId);
+        const workspace = typeof node?.workspace === 'string' ? node.workspace : '';
+        if (workspace && record?.workspace === workspace) return true;
+        if (record?.meta?.meshNodeId === nodeId) return true;
+        return false;
+    }
+
+    private isCompletedHostedSession(record: any): boolean {
+        return record?.lifecycle === 'stopped' || record?.lifecycle === 'failed' || record?.lifecycle === 'interrupted';
+    }
+
+    private async cleanupMeshSessions(args: {
+        meshId: string;
+        nodeId: string;
+        node: any;
+        mode: RepoMeshSessionCleanupMode;
+        sessionIds?: string[];
+        dryRun?: boolean;
+    }): Promise<{ success: boolean; [key: string]: unknown }> {
+        if (args.mode === 'preserve') {
+            return { success: true, mode: 'preserve', matchedCount: 0, stoppedSessionIds: [], deletedSessionIds: [], skippedSessionIds: [] };
+        }
+        if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+
+        const requestedSessionIds = Array.isArray(args.sessionIds)
+            ? new Set(args.sessionIds.map(id => typeof id === 'string' ? id.trim() : '').filter(Boolean))
+            : undefined;
+        const sessions = await this.deps.sessionHostControl.listSessions();
+        const matched = sessions.filter(record => this.sessionMatchesMeshNode(record, args.node, args.nodeId, requestedSessionIds));
+        const hasExplicitSessionIds = !!requestedSessionIds?.size;
+        const stoppedSessionIds: string[] = [];
+        const deletedSessionIds: string[] = [];
+        const skippedSessionIds: string[] = [];
+        const skippedLiveSessionIds: string[] = [];
+        const deleteUnsupportedSessionIds: string[] = [];
+        const recordsRemainSessionIds: string[] = [];
+        const errors: Array<{ sessionId: string; error: string }> = [];
+        const matchedBySurfaceKind = {
+            live_runtime: 0,
+            recovery_snapshot: 0,
+            inactive_record: 0,
+        };
+
+        for (const record of matched) {
+            const surfaceKind = getSessionHostSurfaceKind(record);
+            matchedBySurfaceKind[surfaceKind] += 1;
+        }
+
+        for (const record of matched) {
+            const sessionId = String(record.sessionId);
+            const completed = this.isCompletedHostedSession(record);
+            const surfaceKind = getSessionHostSurfaceKind(record);
+            const liveRuntime = surfaceKind === 'live_runtime';
+            if (!hasExplicitSessionIds && liveRuntime) {
+                skippedSessionIds.push(sessionId);
+                skippedLiveSessionIds.push(sessionId);
+                continue;
+            }
+            try {
+                if (args.mode === 'stop') {
+                    if (!completed) {
+                        if (!args.dryRun) await this.deps.sessionHostControl.stopSession(sessionId);
+                        stoppedSessionIds.push(sessionId);
+                    } else {
+                        skippedSessionIds.push(sessionId);
+                    }
+                    continue;
+                }
+
+                if (args.mode === 'delete_stopped') {
+                    if (completed) {
+                        if (!args.dryRun) await this.deps.sessionHostControl.deleteSession(sessionId, { force: false });
+                        deletedSessionIds.push(sessionId);
+                    } else {
+                        skippedSessionIds.push(sessionId);
+                    }
+                    continue;
+                }
+
+                if (args.mode === 'stop_and_delete') {
+                    if (!args.dryRun) await this.deps.sessionHostControl.deleteSession(sessionId, { force: true });
+                    deletedSessionIds.push(sessionId);
+                    continue;
+                }
+            } catch (e: any) {
+                const message = e?.message || String(e);
+                if (message.includes('Unsupported session host request: delete_session')
+                    && (args.mode === 'delete_stopped' || args.mode === 'stop_and_delete')) {
+                    deleteUnsupportedSessionIds.push(sessionId);
+                    recordsRemainSessionIds.push(sessionId);
+                    if (args.mode === 'stop_and_delete' && !completed) {
+                        try {
+                            await this.deps.sessionHostControl.stopSession(sessionId);
+                            stoppedSessionIds.push(sessionId);
+                        } catch (stopError: any) {
+                            errors.push({ sessionId, error: stopError?.message || String(stopError) });
+                            continue;
+                        }
+                    }
+                    skippedSessionIds.push(sessionId);
+                    continue;
+                }
+                errors.push({ sessionId, error: message });
+            }
+        }
+
+        const deleteUnsupported = deleteUnsupportedSessionIds.length > 0;
+        return {
+            success: errors.length === 0,
+            mode: args.mode,
+            dryRun: args.dryRun === true,
+            matchedCount: matched.length,
+            matchedBySurfaceKind,
+            stoppedSessionIds,
+            deletedSessionIds,
+            skippedSessionIds,
+            skippedLiveSessionIds,
+            ...(deleteUnsupported ? {
+                deleteUnsupported: true,
+                effectiveCleanup: args.mode === 'stop_and_delete'
+                    ? 'stopped_only_records_remain'
+                    : 'delete_unsupported_records_remain',
+                deleteUnsupportedSessionIds,
+                recordsRemainSessionIds,
+            } : {}),
+            ...(errors.length ? { errors } : {}),
+        };
+    }
+
     private async traceSessionHostAction<T>(
         action: string,
         args: any,
@@ -363,6 +647,15 @@ export class DaemonCommandRouter {
     private async executeDaemonCommand(cmd: string, args: any): Promise<CommandRouterResult | null> {
         switch (cmd) {
             // ─── CLI / ACP commands ───
+            case 'mesh_forward_event': {
+                return handleMeshForwardEvent({ instanceManager: this.deps.instanceManager } as any, args as Record<string, unknown>);
+            }
+
+            case 'get_pending_mesh_events': {
+                const events = drainPendingMeshCoordinatorEvents();
+                return { success: true, events };
+            }
+
             case 'launch_cli':
             case 'stop_cli':
             case 'set_cli_view_mode':
@@ -983,7 +1276,27 @@ export class DaemonCommandRouter {
                 if (!name) return { success: false, error: 'name required' };
                 try {
                     const { createMesh } = await import('../config/mesh-config.js');
-                    const mesh = createMesh({ name, repoIdentity, repoRemoteUrl, defaultBranch });
+                    const mesh = createMesh({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy });
+                    return { success: true, mesh };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'update_mesh': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                if (!meshId) return { success: false, error: 'meshId required' };
+                try {
+                    const { updateMesh } = await import('../config/mesh-config.js');
+                    const patch: Record<string, unknown> = {};
+                    if (typeof args?.name === 'string') patch.name = args.name;
+                    if (typeof args?.defaultBranch === 'string') patch.defaultBranch = args.defaultBranch;
+                    if (args?.policy && typeof args.policy === 'object' && !Array.isArray(args.policy)) patch.policy = args.policy;
+                    if (args?.coordinator && typeof args.coordinator === 'object' && !Array.isArray(args.coordinator)) patch.coordinator = args.coordinator;
+                    if (!Object.keys(patch).length) return { success: false, error: 'No updates provided' };
+                    const mesh = updateMesh(meshId, patch as any);
+                    if (!mesh) return { success: false, error: 'Mesh not found' };
+                    this.inlineMeshCache.set(meshId, mesh);
                     return { success: true, mesh };
                 } catch (e: any) {
                     return { success: false, error: e.message };
@@ -1009,7 +1322,15 @@ export class DaemonCommandRouter {
                 if (!workspace) return { success: false, error: 'workspace required' };
                 try {
                     const { addNode } = await import('../config/mesh-config.js');
-                    const node = addNode(meshId, { workspace });
+                    const providerPriority = Array.isArray(args?.providerPriority)
+                        ? args.providerPriority.map((type: any) => typeof type === 'string' ? type.trim() : '').filter(Boolean)
+                        : [];
+                    const readOnly = args?.readOnly === true;
+                    const policy = {
+                        ...(readOnly ? { readOnly: true } : {}),
+                        ...(providerPriority.length ? { providerPriority } : {}),
+                    };
+                    const node = addNode(meshId, { workspace, ...(policy ? { policy } : {}) });
                     if (!node) return { success: false, error: 'Mesh not found' };
                     return { success: true, node };
                 } catch (e: any) {
@@ -1017,14 +1338,172 @@ export class DaemonCommandRouter {
                 }
             }
 
+            case 'update_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 { updateNode } = await import('../config/mesh-config.js');
+                    const policy = args?.policy && typeof args.policy === 'object' && !Array.isArray(args.policy)
+                        ? { ...(args.policy as Record<string, unknown>) }
+                        : {};
+                    if (Array.isArray(args?.providerPriority)) {
+                        const providerPriority = args.providerPriority
+                            .map((type: any) => typeof type === 'string' ? type.trim() : '')
+                            .filter(Boolean);
+                        delete (policy as any).provider_priority;
+                        if (providerPriority.length) {
+                            (policy as any).providerPriority = providerPriority;
+                        } else {
+                            delete (policy as any).providerPriority;
+                        }
+                    }
+                    const node = updateNode(meshId, nodeId, { policy: policy as any });
+                    if (!node) return { success: false, error: 'Mesh node not found' };
+                    return { success: true, node };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'cleanup_mesh_sessions': {
+                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 meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+                    const mesh = meshRecord?.mesh;
+                    if (!mesh) return { success: false, error: 'Mesh not found' };
+                    const node = mesh?.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
+                    if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
+                    const mode = this.normalizeMeshSessionCleanupMode(args?.mode ?? mesh?.policy?.sessionCleanupOnNodeRemove);
+                    const sessionIds = Array.isArray(args?.sessionIds)
+                        ? args.sessionIds.map((id: any) => typeof id === 'string' ? id.trim() : '').filter(Boolean)
+                        : undefined;
+                    const result = await this.cleanupMeshSessions({
+                        meshId,
+                        nodeId,
+                        node,
+                        mode,
+                        sessionIds,
+                        dryRun: args?.dryRun === true,
+                    });
+                    return result;
+                } 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 };
+                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+                    const mesh = meshRecord?.mesh;
+                    const node = mesh?.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
+
+                    const sessionCleanupMode = this.normalizeMeshSessionCleanupMode(
+                        args?.sessionCleanupMode ?? args?.session_cleanup_mode ?? mesh?.policy?.sessionCleanupOnNodeRemove,
+                    );
+                    let sessionCleanup: Record<string, unknown> | undefined;
+                    if (node && sessionCleanupMode !== 'preserve') {
+                        sessionCleanup = await this.cleanupMeshSessions({ meshId, nodeId, node, mode: sessionCleanupMode });
+                        if (sessionCleanup.success === false) return { success: false, removed: false, sessionCleanup };
+                    }
+
+                    // If this is a worktree node, clean up the git worktree first
+                    if (node?.isLocalWorktree && node.workspace) {
+                        try {
+                            const sourceNode = node.clonedFromNodeId
+                                ? mesh?.nodes.find((n: any) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId)
+                                : mesh?.nodes.find((n: any) => !n.isLocalWorktree);
+                            const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
+                            if (repoRoot) {
+                                const { removeWorktree } = await import('../git/git-worktree.js');
+                                await removeWorktree(repoRoot, node.workspace);
+                            }
+                        } catch (e: any) {
+                            LOG.warn('MeshNode', `Worktree cleanup failed for ${nodeId}: ${e.message}`);
+                            // Continue with node removal even if worktree cleanup fails
+                        }
+                    }
+
+                    let removed = false;
+                    if (meshRecord?.inline) {
+                        removed = this.removeInlineMeshNode(meshId, mesh, nodeId);
+                    } else {
+                        const { removeNode } = await import('../config/mesh-config.js');
+                        removed = removeNode(meshId, nodeId);
+                    }
+                    return { success: true, removed, ...(sessionCleanup ? { sessionCleanup } : {}) };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'clone_mesh_node': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const sourceNodeId = typeof args?.sourceNodeId === 'string' ? args.sourceNodeId.trim() : '';
+                const branch = typeof args?.branch === 'string' ? args.branch.trim() : '';
+                const baseBranch = typeof args?.baseBranch === 'string' ? args.baseBranch.trim() : undefined;
+                if (!meshId) return { success: false, error: 'meshId required' };
+                if (!sourceNodeId) return { success: false, error: 'sourceNodeId required' };
+                if (!branch) return { success: false, error: 'branch required' };
+
+                try {
+                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+                    const mesh = meshRecord?.mesh;
+                    if (!mesh) return { success: false, error: 'Mesh not found' };
+
+                    const sourceNode = mesh.nodes?.find((n: any) => n.id === sourceNodeId || n.nodeId === sourceNodeId);
+                    if (!sourceNode) return { success: false, error: `Source node '${sourceNodeId}' not found in mesh` };
+
+                    const repoRoot = sourceNode.repoRoot || sourceNode.workspace;
+                    const { createWorktree } = await import('../git/git-worktree.js');
+                    const result = await createWorktree({
+                        repoRoot,
+                        branch,
+                        baseBranch,
+                        meshName: mesh.name,
+                    });
+
+                    let node: any;
+                    if (meshRecord.inline) {
+                        const { randomUUID } = await import('crypto');
+                        node = {
+                            id: `node_${randomUUID().replace(/-/g, '')}`,
+                            workspace: result.worktreePath,
+                            repoRoot: result.worktreePath,
+                            daemonId: sourceNode.daemonId,
+                            userOverrides: { ...(sourceNode.userOverrides || {}) },
+                            policy: { ...(sourceNode.policy || {}) },
+                            isLocalWorktree: true,
+                            worktreeBranch: result.branch,
+                            clonedFromNodeId: sourceNodeId,
+                        };
+                        this.updateInlineMeshNode(meshId, mesh, node);
+                    } else {
+                        const { addNode } = await import('../config/mesh-config.js');
+                        node = addNode(meshId, {
+                            workspace: result.worktreePath,
+                            repoRoot: result.worktreePath,
+                            daemonId: sourceNode.daemonId,
+                            userOverrides: { ...(sourceNode.userOverrides || {}) },
+                            isLocalWorktree: true,
+                            worktreeBranch: result.branch,
+                            clonedFromNodeId: sourceNodeId,
+                            policy: { ...(sourceNode.policy || {}) },
+                        });
+                        if (!node) return { success: false, error: 'Failed to register worktree node' };
+                    }
+
+                    return {
+                        success: true,
+                        node,
+                        worktreePath: result.worktreePath,
+                        branch: result.branch,
+                    };
                 } catch (e: any) {
                     return { success: false, error: e.message };
                 }
@@ -1033,7 +1512,7 @@ export class DaemonCommandRouter {
             // ─── 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';
+                let cliType = typeof args?.cliType === 'string' ? args.cliType.trim() : '';
                 if (!meshId) return { success: false, error: 'meshId required' };
 
                 try {
@@ -1071,9 +1550,29 @@ export class DaemonCommandRouter {
                     }
                     const workspace = typeof coordinatorNode.workspace === 'string' ? coordinatorNode.workspace.trim() : '';
                     if (!workspace) return { success: false, error: 'Coordinator node workspace required', meshId, cliType };
+                    if (!cliType) {
+                        const resolved = await resolveProviderTypeFromPriority({
+                            nodeId: String(coordinatorNode.id || coordinatorNode.nodeId || preferredCoordinatorNodeId || 'coordinator'),
+                            providerPriority: readProviderPriorityFromPolicy(coordinatorNode.policy),
+                            providerLoader: this.deps.providerLoader,
+                            onStatusChange: this.deps.onStatusChange,
+                        });
+                        if (!resolved.providerType) {
+                            return {
+                                success: false,
+                                code: 'mesh_coordinator_provider_priority_unusable',
+                                error: resolved.error || 'No usable provider found from node providerPriority',
+                                meshId,
+                                cliType,
+                                workspace,
+                            };
+                        }
+                        cliType = resolved.providerType;
+                    }
                     const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
                     const coordinatorSetup = resolveMeshCoordinatorSetup({
                         provider: providerMeta,
+                        cliType,
                         meshId,
                         workspace,
                     });
@@ -1101,7 +1600,8 @@ export class DaemonCommandRouter {
                         };
                     }
 
-                    if (coordinatorSetup.configFormat !== 'claude_mcp_json') {
+                    const configFormat = coordinatorSetup.configFormat as MeshCoordinatorConfigFormat;
+                    if (configFormat !== 'claude_mcp_json' && configFormat !== 'hermes_config_yaml') {
                         return {
                             success: false,
                             code: 'mesh_coordinator_unsupported',
@@ -1112,19 +1612,51 @@ export class DaemonCommandRouter {
                         };
                     }
 
-                    // 1. Write provider-declared MCP config to workspace for CLIs that auto-import it.
-                    const { existsSync, readFileSync, writeFileSync, copyFileSync } = await import('fs');
-                    const mcpConfigPath = coordinatorSetup.configPath;
+                    // Build the coordinator prompt before mutating workspace config or launching.
+                    // Prompt generation failures are configuration/data-shape errors; fail closed so
+                    // broken mesh state is visible instead of silently launching with weaker rules.
+                    let systemPrompt = '';
+                    try {
+                        systemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType });
+                    } catch (error: any) {
+                        const message = error?.message || String(error);
+                        LOG.error('MeshCoordinator', `Failed to build coordinator prompt: ${message}`);
+                        return {
+                            success: false,
+                            code: 'mesh_coordinator_prompt_failed',
+                            error: `Failed to build Repo Mesh coordinator prompt: ${message}`,
+                            meshId,
+                            cliType,
+                            workspace,
+                        };
+                    }
 
-                    // Backup existing MCP config if present.
-                    const hadExistingMcpConfig = existsSync(mcpConfigPath);
-                    let existingMcpConfig: any = {};
-                    if (hadExistingMcpConfig) {
+                    // 1. Write provider-declared MCP config for CLIs that auto-import it.
+                    const { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync } = await import('fs');
+                    const { dirname } = await import('path');
+                    const mcpConfigPath = coordinatorSetup.configPath;
+                    const hermesManualFallback = cliType === 'hermes-cli' && configFormat === 'hermes_config_yaml'
+                        ? createHermesManualMeshCoordinatorSetup(meshId, workspace)
+                        : null;
+                    let hermesBaseConfig: { config: Record<string, any>; sourceHome: string; sourceConfigPath: string } | null = null;
+                    if (hermesManualFallback) {
                         try {
-                            existingMcpConfig = JSON.parse(readFileSync(mcpConfigPath, 'utf-8'));
-                            copyFileSync(mcpConfigPath, mcpConfigPath + '.backup');
-                        } catch { /* empty */ }
+                            hermesBaseConfig = loadHermesCoordinatorBaseConfig(mcpConfigPath);
+                        } catch (error: any) {
+                            const message = `Failed to parse Hermes base config for automatic coordinator setup: ${error?.message || error}`;
+                            LOG.error('MeshCoordinator', message);
+                            return { success: false, code: 'mesh_coordinator_config_parse_failed', error: message, meshId, cliType, workspace };
+                        }
                     }
+                    const returnManualFallback = (message: string) => ({
+                        success: false,
+                        code: 'mesh_coordinator_manual_mcp_setup_required',
+                        error: message,
+                        meshId,
+                        cliType,
+                        workspace,
+                        meshCoordinatorSetup: hermesManualFallback,
+                    });
 
                     // Merge ADHDev mesh server into existing config.
                     // Pass full mesh data as env var so the MCP server can bootstrap
@@ -1139,39 +1671,81 @@ export class DaemonCommandRouter {
                             ADHDEV_MCP_TRANSPORT: 'ipc',
                         };
                     }
+
+                    try {
+                        mkdirSync(dirname(mcpConfigPath), { recursive: true });
+                    } catch (error: any) {
+                        const message = `Could not prepare MCP config path for automatic setup: ${error?.message || error}`;
+                        LOG.error('MeshCoordinator', message);
+                        if (hermesManualFallback) return returnManualFallback(message);
+                        return { success: false, code: 'mesh_coordinator_config_write_failed', error: message, meshId, cliType, workspace };
+                    }
+
+                    // Backup existing MCP config if present.
+                    const hadExistingMcpConfig = existsSync(mcpConfigPath);
+                    let existingMcpConfig: Record<string, any> = hermesBaseConfig?.config || {};
+                    if (hermesBaseConfig) {
+                        copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname(mcpConfigPath));
+                    }
+                    if (hadExistingMcpConfig) {
+                        try {
+                            const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync(mcpConfigPath, 'utf-8'), configFormat);
+                            existingMcpConfig = { ...existingMcpConfig, ...parsedExistingMcpConfig };
+                            copyFileSync(mcpConfigPath, mcpConfigPath + '.backup');
+                        } catch (error: any) {
+                            LOG.error('MeshCoordinator', `Failed to parse existing MCP config ${mcpConfigPath}: ${error?.message || error}`);
+                            return {
+                                success: false,
+                                code: 'mesh_coordinator_config_parse_failed',
+                                error: `Failed to parse existing MCP config at ${mcpConfigPath}`,
+                            };
+                        }
+                    }
+
+                    const mcpServersKey = getMcpServersKey(configFormat);
+                    const existingServers = existingMcpConfig[mcpServersKey];
                     const mcpConfig = {
                         ...existingMcpConfig,
-                        mcpServers: {
-                            ...(existingMcpConfig.mcpServers || {}),
+                        [mcpServersKey]: {
+                            ...(existingServers && typeof existingServers === 'object' && !Array.isArray(existingServers) ? existingServers : {}),
                             [coordinatorSetup.serverName]: mcpServerEntry,
                         },
                     };
-                    writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
-                    LOG.info('MeshCoordinator', `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} 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).`;
+                        writeFileSync(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), 'utf-8');
+                    } catch (error: any) {
+                        const message = `Could not write MCP config for automatic setup: ${error?.message || error}`;
+                        LOG.error('MeshCoordinator', message);
+                        if (hermesManualFallback) return returnManualFallback(message);
+                        return { success: false, code: 'mesh_coordinator_config_write_failed', error: message, meshId, cliType, workspace };
                     }
+                    LOG.info('MeshCoordinator', `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} server`);
 
                     const cliArgs: string[] = [];
+                    const launchEnv: Record<string, string> = {};
+                    if (configFormat === 'hermes_config_yaml') {
+                        launchEnv.HERMES_HOME = dirname(mcpConfigPath);
+                        launchEnv.HERMES_IGNORE_USER_CONFIG = '';
+                    }
                     if (systemPrompt) {
-                        cliArgs.push('--append-system-prompt', systemPrompt);
+                        if (configFormat === 'hermes_config_yaml') {
+                            launchEnv.HERMES_EPHEMERAL_SYSTEM_PROMPT = systemPrompt;
+                        } else {
+                            cliArgs.push('--append-system-prompt', systemPrompt);
+                        }
                     }
                     if (cliType === 'claude-cli') {
                         cliArgs.push('--mcp-config', coordinatorSetup.configPath);
                     }
 
-                    // 3. Launch CLI session via existing cliManager
-                    // Pass coordinator system prompt via --append-system-prompt so the
-                    // CLI inherits its default behavior AND knows it is a mesh coordinator.
+                    // 3. Launch CLI session via existing cliManager.
+                    // Provider-specific prompt injection remains fail-closed: Claude gets
+                    // explicit CLI args, while Hermes reads HERMES_EPHEMERAL_SYSTEM_PROMPT.
                     const launchResult: any = await this.deps.cliManager.handleCliCommand('launch_cli', {
                         cliType,
                         dir: workspace,
                         cliArgs: cliArgs.length > 0 ? cliArgs : undefined,
+                        env: Object.keys(launchEnv).length > 0 ? launchEnv : undefined,
                         settings: {
                             meshCoordinatorFor: meshId
                         }