@adhdev/daemon-core 0.9.82-rc.364 → 0.9.82-rc.365

package/src/commands/router.ts

@@ -13,6 +13,9 @@ import { DaemonCdpManager } from '../cdp/manager.js';
 import { registerExtensionProviders } from '../cdp/setup.js';
 import { DaemonCommandHandler } from './handler.js';
 import { lowFamilyRegistry } from './low-family/index.js';
+import { medFamilyRegistry } from './med-family/index.js';
+import { launchIde } from './med-family/ide.js';
+import type { MedFamilyContext } from './med-family/index.js';
 import { DaemonCliManager } from './cli-manager.js';
 import { supportsExplicitSessionResume } from './cli-manager.js';
 import type { HostedCliRuntimeDescriptor } from './cli-manager.js';
@@ -114,7 +117,7 @@ function readProviderPriorityFromPolicy(policy: unknown): string[] {
  * the field entirely (full backward compat). Routing is governed by required_tags;
  * any legacy `role` field on the input is ignored.
  */
-function normalizeProviderRoles(value: unknown): Array<{ providerType: string; maxParallel?: number }> {
+export function normalizeProviderRoles(value: unknown): Array<{ providerType: string; maxParallel?: number }> {
     if (!Array.isArray(value)) return [];
     const byType = new Map<string, { providerType: string; maxParallel?: number }>();
     for (const raw of value) {
@@ -130,13 +133,13 @@ function normalizeProviderRoles(value: unknown): Array<{ providerType: string; m
     return [...byType.values()];
 }
 
-function readObjectRecord(value: unknown): Record<string, any> {
+export function readObjectRecord(value: unknown): Record<string, any> {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value as Record<string, any>
         : {};
 }
 
-function readStringValue(...values: unknown[]): string | undefined {
+export function readStringValue(...values: unknown[]): string | undefined {
     for (const value of values) {
         if (typeof value === 'string' && value.trim()) return value.trim();
     }
@@ -224,7 +227,7 @@ function normalizeMeshHostname(value: unknown): string | undefined {
     return hostname.toLowerCase().replace(/\.$/, '');
 }
 
-function readMeshNodeMachineId(node: Record<string, unknown>): string | undefined {
+export function readMeshNodeMachineId(node: Record<string, unknown>): string | undefined {
     return readStringValue(
         node.machineId,
         node.machine_id,
@@ -1156,7 +1159,7 @@ const MESH_DIRECT_PROBE_REUSE_MS = readMeshTimeoutEnvMs('MESH_DIRECT_PROBE_REUSE
  * Lives on the router instance so the gate spans separate mesh_status calls,
  * which is exactly where the refresh storm happens.
  */
-class MeshGitProbeCache {
+export class MeshGitProbeCache {
     private inflight = new Map<string, Promise<Record<string, unknown> | null>>();
     private recent = new Map<string, { at: number; value: Record<string, unknown> }>();
 
@@ -1311,7 +1314,7 @@ async function probeRemoteMeshGitStatusWithRetry(args: {
     return null;
 }
 
-async function hydrateInlineMeshDirectTruth(args: {
+export async function hydrateInlineMeshDirectTruth(args: {
     mesh: any;
     meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config';
     dispatchMeshCommand?: (daemonId: string, cmd: string, args: Record<string, unknown>) => Promise<unknown>;
@@ -3045,7 +3048,7 @@ async function runMeshRefineSubmoduleReachabilityGate(
     }
 }
 
-function buildMeshRefineValidationPlan(mesh: any, workspace: string): Record<string, unknown> {
+export function buildMeshRefineValidationPlan(mesh: any, workspace: string): Record<string, unknown> {
     const plan = resolveMeshRefineValidationPlan(mesh, workspace);
     const mapCommand = (command: MeshRefineValidationCommandPlan) => ({
         displayCommand: command.displayCommand,
@@ -3470,7 +3473,7 @@ function normalizeCommandArgsWithInteractionId(args: any): Record<string, unknow
  * basename to be a literal `*.json`, and re-joins under the verified parent so
  * the returned path can't point outside the tree. Used by get/write_spec_source.
  */
-function normalizeStandaloneHostCommandUrl(hostAddress: string): string {
+export function normalizeStandaloneHostCommandUrl(hostAddress: string): string {
     const raw = hostAddress.trim();
     if (!raw) throw new Error('hostAddress required');
     const url = new URL(raw.replace(/^ws:/, 'http:').replace(/^wss:/, 'https:'));
@@ -3480,7 +3483,7 @@ function normalizeStandaloneHostCommandUrl(hostAddress: string): string {
     return url.toString();
 }
 
-function buildMemberJoinNode(mesh: any, args: any, fallbackDaemonId?: string): Record<string, unknown> | null {
+export function buildMemberJoinNode(mesh: any, args: any, fallbackDaemonId?: string): Record<string, unknown> | null {
     const requestedNodeId = typeof args?.memberNodeId === 'string' ? args.memberNodeId.trim() : '';
     const explicit = args?.memberNode && typeof args.memberNode === 'object' && !Array.isArray(args.memberNode)
         ? args.memberNode as Record<string, any>
@@ -3862,6 +3865,38 @@ export class DaemonCommandRouter {
         this.deps.onMeshStateChange?.(meshId);
     }
 
+    /**
+     * Build the MedFamilyContext handed to RF-ROUTER MED family handlers. Binds the
+     * router-private collaborators those handlers need (mesh resolution, owner
+     * gating, inline-cache mutation, worktree / session cleanup, refine job
+     * starters, IDE stop/launch) plus the inline-mesh and git-probe caches. The
+     * `launchIde` field closes over the freshly-built context so restart_session /
+     * restart_ide invoke the IDE launch directly instead of recursing through
+     * executeDaemonCommand('launch_ide').
+     */
+    private buildMedFamilyContext(): MedFamilyContext {
+        const ctx: MedFamilyContext = {
+            deps: this.deps,
+            getMeshForCommand: this.getMeshForCommand.bind(this),
+            getCachedInlineMesh: this.getCachedInlineMesh.bind(this),
+            requireMeshHostMutationOwner: this.requireMeshHostMutationOwner.bind(this),
+            invalidateAggregateMeshStatus: this.invalidateAggregateMeshStatus.bind(this),
+            updateInlineMeshNode: this.updateInlineMeshNode.bind(this),
+            removeInlineMeshNode: this.removeInlineMeshNode.bind(this),
+            normalizeMeshSessionCleanupMode: this.normalizeMeshSessionCleanupMode.bind(this),
+            cleanupMeshSessions: this.cleanupMeshSessions.bind(this),
+            cleanupLocalWorktreeNode: this.cleanupLocalWorktreeNode.bind(this),
+            startMeshRefineJob: this.startMeshRefineJob.bind(this),
+            batchRefineMeshNodes: this.batchRefineMeshNodes.bind(this),
+            startMeshRefineBatchJob: this.startMeshRefineBatchJob.bind(this),
+            stopIde: this.stopIde.bind(this),
+            launchIde: (args: any) => launchIde(ctx, args),
+            inlineMeshCache: this.inlineMeshCache,
+            meshGitProbeCache: this.meshGitProbeCache,
+        };
+        return ctx;
+    }
+
 
     private async requireMeshHostMutationOwner(meshId: string, inlineMesh: unknown, operation: string): Promise<CommandRouterResult | null> {
         const meshRecord = await this.getMeshForCommand(meshId, inlineMesh, { preferInline: true });
@@ -6183,6 +6218,19 @@ export class DaemonCommandRouter {
             }, args);
         }
 
+        // RF-ROUTER MED family: medium-coupling commands (CLI/ACP agent, IDE
+        // lifecycle, mesh CRUD, mesh queue, mesh host pairing, fast-forward /
+        // refine convergence) are handled by the registry after the LOW family and
+        // before the switch. Unlike LOW handlers, MED handlers need router-private
+        // collaborators, so the context carries bound methods + the inline-mesh /
+        // git-probe caches + the launchIde helper (which breaks the original
+        // launch_ide ↔ restart_* self-recursion). A hit returns the same
+        // CommandRouterResult the inlined case used to; a miss falls through.
+        const medFamilyHandler = medFamilyRegistry.get(cmd);
+        if (medFamilyHandler) {
+            return await medFamilyHandler(this.buildMedFamilyContext(), args);
+        }
+
         switch (cmd) {
             // ─── CLI / ACP commands ───
             case 'mesh_forward_event': {
@@ -6215,1599 +6263,6 @@ export class DaemonCommandRouter {
                 return { success: true };
             }
 
-            case 'launch_cli': {
-                // The coordinator routing anchor (meshCoordinatorDaemonId) is stamped
-                // upstream by mesh_launch_session, which resolves
-                // coordinatorNode.daemonId || ctx.localDaemonId || ctx.localMachineId and
-                // fail-closes for a remote node when none resolve. We deliberately do NOT
-                // self-stamp this daemon's own id when the field is missing: for a
-                // P2P-relayed remote worker launch, stamping the worker's own id would make
-                // the self-forward gate (mesh-events-coordinator: daemonIdsEquivalent) treat the
-                // worker as its own coordinator, suppressing the spontaneous completion-event
-                // forward and leaving the event in the pending inbox until a read_chat
-                // reconcile drains it. If the anchor is genuinely absent here, leave it
-                // absent rather than poison the routing.
-                const launchResult = await this.deps.cliManager.handleCliCommand(cmd, args);
-                // Bug C fix (part 1): when launching a mesh node worker session, surface
-                // bootstrapPending:true if the node's worktree bootstrap is still running.
-                // This is informational — the launch is NOT blocked here (blocking is done
-                // upstream by getWorktreeBootstrapLaunchBlock in the MCP layer).
-                const meshNodeId = readStringValue((args?.settings as any)?.meshNodeId);
-                const meshId = readStringValue((args?.settings as any)?.meshNodeFor);
-                if (meshNodeId && meshId && launchResult?.success !== false) {
-                    try {
-                        const { getMesh } = await import('../config/mesh-config.js');
-                        const meshObj = getMesh(meshId) ?? this.getCachedInlineMesh(meshId);
-                        const nodeObj = Array.isArray(meshObj?.nodes)
-                            ? meshObj.nodes.find((n: any) => meshNodeIdMatches(n, meshNodeId))
-                            : undefined;
-                        const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
-                        if (bootstrapStatus === 'running') {
-                            return { success: true, ...launchResult, bootstrapPending: true };
-                        }
-                    } catch { /* best-effort — do not fail launch for bootstrap probe errors */ }
-                }
-                return launchResult;
-            }
-            case 'stop_cli':
-            case 'set_cli_view_mode':
-            case 'record_provider_pty': {
-                return this.deps.cliManager.handleCliCommand(cmd, args);
-            }
-            case 'agent_command': {
-                // Relay-safety stamp: a dispatch carrying meshContext.coordinatorDaemonId
-                // (mesh_send_task / queue assignment over P2P) is the worker daemon's chance
-                // to persist the coordinator routing anchor onto the target session BEFORE the
-                // turn runs. Without meshCoordinatorDaemonId on the session, the core forwarder
-                // (injectMeshSystemMessage) cannot resolve a remote coordinator target, so the
-                // completion event sits in the pending queue until a read_chat reconcile drains
-                // it. Stamping here makes a reused/relaunched remote session relay-safe at
-                // dispatch time even when it was not launched via mesh_launch_session.
-                {
-                    const dispatchSessionId = readStringValue(args?.targetSessionId, (args as any)?.sessionId, (args as any)?.instanceId);
-                    const dispatchMeshContext = args?.meshContext as Record<string, unknown> | undefined;
-                    if (dispatchSessionId && dispatchMeshContext) {
-                        try {
-                            const inst = this.deps.instanceManager.getInstance(dispatchSessionId);
-                            if (inst && typeof inst.updateSettings === 'function') {
-                                const stamp = buildMeshWorkerRelayStamp(
-                                    inst.getState?.()?.settings as Record<string, unknown> | undefined,
-                                    {
-                                        meshId: dispatchMeshContext.meshId,
-                                        nodeId: dispatchMeshContext.nodeId,
-                                        coordinatorDaemonId: dispatchMeshContext.coordinatorDaemonId,
-                                        // Session-level anchor: preserved across the P2P dispatch to a
-                                        // remote worker so its completion echoes back to the right session.
-                                        coordinatorSessionId: dispatchMeshContext.coordinatorSessionId,
-                                    },
-                                );
-                                if (stamp) inst.updateSettings(stamp);
-                            }
-                        } catch { /* best-effort — dispatch still proceeds without the stamp */ }
-                    }
-                }
-                const agentResult = await this.deps.cliManager.handleCliCommand(cmd, args);
-                // Bug C fix (part 2): when dispatching a task to a mesh node session, override
-                // the dispatch acknowledgement risk reason to 'bootstrap_still_running' when
-                // the target node's worktree bootstrap is still running. Informational only —
-                // dispatch is NOT blocked.
-                const meshCtx = args?.meshContext as Record<string, unknown> | undefined;
-                const dispatchNodeId = readStringValue(meshCtx?.nodeId);
-                const dispatchMeshId = readStringValue(meshCtx?.meshId);
-                if (dispatchNodeId && dispatchMeshId && agentResult?.success !== false) {
-                    try {
-                        const { getMesh } = await import('../config/mesh-config.js');
-                        const meshObj = getMesh(dispatchMeshId) ?? this.getCachedInlineMesh(dispatchMeshId);
-                        const nodeObj = Array.isArray(meshObj?.nodes)
-                            ? meshObj.nodes.find((n: any) => meshNodeIdMatches(n, dispatchNodeId))
-                            : undefined;
-                        const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
-                        if (bootstrapStatus === 'running') {
-                            return {
-                                success: true,
-                                ...agentResult,
-                                dispatchAcknowledgementRisk: true,
-                                dispatchAcknowledgementRiskReason: 'bootstrap_still_running',
-                                nextAction: 'Wait for worktree_bootstrap_complete event before dispatching work to this node.',
-                            };
-                        }
-                    } catch { /* best-effort */ }
-                }
-                return agentResult;
-            }
-
-            // ─── Logs ───
-            case 'list_saved_sessions': {
-                const providerType = typeof args?.providerType === 'string'
-                    ? args.providerType.trim()
-                    : typeof args?.agentType === 'string'
-                        ? args.agentType.trim()
-                        : '';
-                const kind = args?.kind === 'acp' ? 'acp' : 'cli';
-                if (!providerType) {
-                    return { success: false, error: 'providerType required' };
-                }
-
-                const wantsAll = args?.all === true;
-                const offset = wantsAll ? 0 : Math.max(0, Number(args?.offset) || 0);
-                const limit = wantsAll ? Number.MAX_SAFE_INTEGER : Math.max(1, Math.min(100, Number(args?.limit) || 30));
-                const requestedWorkspace = typeof args?.workspace === 'string' ? args.workspace.trim() : '';
-                const requestedProviderSessionId = typeof args?.providerSessionId === 'string'
-                    ? args.providerSessionId.trim()
-                    : typeof args?.activeProviderSessionId === 'string'
-                        ? args.activeProviderSessionId.trim()
-                        : '';
-                const providerMeta = this.deps.providerLoader.resolve?.(providerType) || this.deps.providerLoader.getMeta(providerType);
-                const { sessions: historySessions, hasMore, source } = listProviderHistorySessions(providerType, {
-                    canonicalHistory: providerMeta?.nativeHistory,
-                    offset,
-                    limit,
-                    historyBehavior: providerMeta?.historyBehavior,
-                    scripts: providerMeta?.scripts as any,
-                });
-                const state = loadState();
-                const savedSessions = getSavedProviderSessions(state, { providerType, kind });
-                const recentSessions = getRecentActivity(state, 200)
-                    .filter(entry => entry.providerType === providerType && entry.kind === kind && entry.providerSessionId);
-                const savedSessionById = new Map(savedSessions.map(entry => [entry.providerSessionId, entry]));
-                const recentSessionById = new Map(recentSessions.map(entry => [entry.providerSessionId!, entry]));
-                const canResumeById = supportsExplicitSessionResume(providerMeta?.resume);
-
-                return {
-                    success: true,
-                    sessions: historySessions.map(session => {
-                        const saved = savedSessionById.get(session.historySessionId);
-                        const recent = recentSessionById.get(session.historySessionId);
-                        const workspace = saved?.workspace
-                            || recent?.workspace
-                            || session.workspace
-                            || (requestedWorkspace && requestedProviderSessionId === session.historySessionId ? requestedWorkspace : undefined);
-                        return {
-                            id: session.historySessionId,
-                            providerSessionId: session.historySessionId,
-                            providerType,
-                            providerName: saved?.providerName || recent?.providerName || providerType,
-                            kind: saved?.kind || recent?.kind || kind,
-                            title: saved?.title || recent?.title || session.sessionTitle || session.preview || providerType,
-                            workspace,
-                            summaryMetadata: saved?.summaryMetadata || recent?.summaryMetadata,
-                            preview: session.preview,
-                            messageCount: session.messageCount,
-                            firstMessageAt: session.firstMessageAt,
-                            lastMessageAt: session.lastMessageAt,
-                            canResume: !!workspace && canResumeById,
-                            historySource: session.source,
-                            sourcePath: session.sourcePath,
-                            sourceMtimeMs: session.sourceMtimeMs,
-                        };
-                    }),
-                    hasMore,
-                    source,
-                };
-            }
-
-            // ─── restart_session: IDE / CLI / ACP unified ───
-            case 'restart_session': {
-                const targetType = args?.cliType || args?.agentType || args?.ideType;
-                if (!targetType) throw new Error('cliType or ideType required');
-
-                // Check if IDE (in cdpManagers or provider category is ide)
-                const isIde = this.deps.cdpManagers.has(targetType) ||
-                    this.deps.providerLoader.getMeta(targetType)?.category === 'ide';
-
-                if (isIde) {
-                    // IDE restart: stop (with process kill) → launch
-                    await this.stopIde(targetType, true);
-                    const launchResult = await this.executeDaemonCommand('launch_ide', { ideType: targetType, enableCdp: true, workspace: args?.workspace });
-                    return { success: true, restarted: true, ideType: targetType, launch: launchResult };
-                }
-
-                // CLI/ACP restart: delegate to CliManager
-                return this.deps.cliManager.handleCliCommand(cmd, args);
-            }
-
-            // ─── IDE stop ───
-            case 'stop_ide': {
-                const ideType = args?.ideType;
-                if (!ideType) throw new Error('ideType required');
-                const killProcess = args?.killProcess !== false; // default true
-                await this.stopIde(ideType, killProcess);
-                try {
-                    const results = await detectIDEs(this.deps.providerLoader);
-                    this.deps.detectedIdes.value = results;
-                    this.deps.providerLoader.setIdeDetectionResults(results, true);
-                } catch { /* ignore detection refresh errors */ }
-                return { success: true, ideType, stopped: true, processKilled: killProcess };
-            }
-
-            // ─── IDE restart ───
-            case 'restart_ide': {
-                const ideType = args?.ideType;
-                if (!ideType) throw new Error('ideType required');
-                await this.stopIde(ideType, true); // always kill process on restart
-                const launchResult = await this.executeDaemonCommand('launch_ide', { ideType, enableCdp: true, workspace: args?.workspace });
-                return { success: true, ideType, restarted: true, launch: launchResult };
-            }
-
-            // ─── IDE launch + CDP connect ───
-            case 'launch_ide': {
-                const ideKey = args?.ideId || args?.ideType;
-                const resolvedWorkspace = resolveIdeLaunchWorkspace(
-                    {
-                        workspace: args?.workspace,
-                        workspaceId: args?.workspaceId,
-                        useDefaultWorkspace: args?.useDefaultWorkspace,
-                    },
-                    loadConfig(),
-                );
-                const launchArgs = {
-                    ideId: ideKey,
-                    workspace: resolvedWorkspace,
-                    newWindow: args?.newWindow,
-                };
-                LOG.info('LaunchIDE', `target=${ideKey || 'auto'}`);
-                const result = await launchWithCdp(launchArgs);
-
-                if (result.success && result.port && result.ideId && !this.deps.cdpManagers.has(result.ideId)) {
-                    const logFn = this.deps.getCdpLogFn
-                        ? this.deps.getCdpLogFn(result.ideId)
-                        : LOG.forComponent(`CDP:${result.ideId}`).asLogFn();
-                    const provider = this.deps.providerLoader.getMeta(result.ideId);
-                    const manager = new DaemonCdpManager(result.port, logFn, undefined, provider?.targetFilter);
-                    const connected = await manager.connect();
-                    if (connected) {
-                        // Register active extension providers for this IDE in CDP manager
-                        registerExtensionProviders(this.deps.providerLoader, manager, result.ideId);
-                        this.deps.cdpManagers.set(result.ideId, manager);
-                        LOG.info('CDP', `Connected: ${result.ideId} (port ${result.port})`);
-                        LOG.info('CDP', `${this.deps.cdpManagers.size} IDE(s) connected`);
-
-                        // Notify consumer (e.g. setupIdeInstance)
-                        this.deps.onCdpManagerCreated?.(result.ideId, manager);
-                    }
-                }
-                this.deps.onIdeConnected?.();
-                try {
-                    const results = await detectIDEs(this.deps.providerLoader);
-                    this.deps.detectedIdes.value = results;
-                    this.deps.providerLoader.setIdeDetectionResults(results, true);
-                } catch { /* ignore detection refresh errors */ }
-                if (result.success && resolvedWorkspace) {
-                    try {
-                        const next = appendRecentActivity(loadState(), {
-                            kind: 'ide',
-                            providerType: result.ideId || ideKey,
-                            providerName: result.ideId || ideKey,
-                            workspace: resolvedWorkspace,
-                            title: result.ideId || ideKey,
-                        });
-                        saveState(next);
-                    } catch { /* ignore activity persist errors */ }
-                } else if (result.success && (result.ideId || ideKey)) {
-                    try {
-                        saveState(appendRecentActivity(loadState(), {
-                            kind: 'ide',
-                            providerType: result.ideId || ideKey,
-                            providerName: result.ideId || ideKey,
-                            title: result.ideId || ideKey,
-                        }));
-                    } catch { /* ignore activity persist errors */ }
-                }
-                return { ...result };
-            }
-
-            // ─── Detect providers ───
-            case 'detect_provider': {
-                const providerType = typeof args?.providerType === 'string' ? args.providerType.trim() : '';
-                if (!providerType) return { success: false, error: 'providerType is required' };
-                const normalizedType = this.deps.providerLoader.resolveAlias(providerType);
-                const provider = this.deps.providerLoader.getByAlias(providerType);
-                if (!provider) return { success: false, error: `Provider not found: ${providerType}` };
-                if (provider.category !== 'cli' && provider.category !== 'acp') {
-                    return { success: false, error: `Provider detection is only supported for CLI/ACP providers: ${providerType}` };
-                }
-                if (!this.deps.providerLoader.isMachineProviderEnabled(normalizedType)) {
-                    return { success: false, error: `Provider is disabled on this machine: ${providerType}` };
-                }
-                const detected = await detectCLI(normalizedType, this.deps.providerLoader, { includeVersion: false });
-                this.deps.providerLoader.setCliDetectionResults([{
-                    id: normalizedType,
-                    installed: !!detected,
-                    path: detected?.path,
-                }], false);
-                this.deps.onStatusChange?.();
-                return {
-                    success: true,
-                    providerType: normalizedType,
-                    detected: !!detected,
-                    path: detected?.path || null,
-                };
-            }
-
-            // ─── Detect IDEs ───
-            case 'detect_ides': {
-                const results = await detectIDEs(this.deps.providerLoader);
-                this.deps.detectedIdes.value = results;
-                this.deps.providerLoader.setIdeDetectionResults(results, true);
-                return { success: true, detectedInfo: results };
-            }
-
-            // ─── 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' };
-                const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-                if (!meshRecord?.mesh) return { success: false, error: 'Mesh not found' };
-
-                const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
-                // Only an explicit refresh fans out a blocking peer probe.
-                // Default loads are satisfied from held standing-state git truth.
-                const probeRemotePeers = args?.refresh === true || args?.forceRefresh === true;
-                const directTruth = await hydrateInlineMeshDirectTruth({
-                    mesh: meshRecord.mesh,
-                    meshSource: meshRecord.source,
-                    dispatchMeshCommand: this.deps.dispatchMeshCommand,
-                    getMeshPeerConnectionStatus: this.deps.getMeshPeerConnectionStatus,
-                    statusInstanceId: this.deps.statusInstanceId,
-                    localMachineId: loadConfig().machineId || '',
-                    probeRemotePeers,
-                    probeCache: this.meshGitProbeCache,
-                });
-                const directTruthSatisfied = meshRecord.source !== 'inline_bootstrap' || directTruth.directEvidenceCount > 0;
-                const sourceOfTruth = {
-                    membership: meshRecord.source === 'inline_cache'
-                        ? 'coordinator_inline_mesh_cache'
-                        : meshRecord.source === 'local_config'
-                            ? 'local_mesh_config'
-                            : 'inline_bootstrap_snapshot',
-                    coordinatorOwnsLiveTruth: directTruthSatisfied,
-                    directPeerTruth: {
-                        required: requireDirectPeerTruth,
-                        satisfied: directTruthSatisfied,
-                        directEvidenceCount: directTruth.directEvidenceCount,
-                        localConfirmedCount: directTruth.localConfirmedCount,
-                        peerAttemptedCount: directTruth.peerAttemptedCount,
-                        peerConfirmedCount: directTruth.peerConfirmedCount,
-                        unavailableNodeIds: directTruth.unavailableNodeIds,
-                    },
-                };
-                if (requireDirectPeerTruth && !directTruthSatisfied) {
-                    return {
-                        success: false,
-                        code: 'mesh_direct_peer_truth_unavailable',
-                        error: 'Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct get_mesh probes succeed.',
-                        sourceOfTruth,
-                    };
-                }
-                return { success: true, mesh: meshRecord.mesh, sourceOfTruth };
-            }
-
-            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 meshHost = args?.meshHost && typeof args.meshHost === 'object' && !Array.isArray(args.meshHost)
-                        ? args.meshHost
-                        : undefined;
-                    const mesh = createMesh({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy, meshHost });
-                    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 (args?.meshHost && typeof args.meshHost === 'object' && !Array.isArray(args.meshHost)) patch.meshHost = args.meshHost;
-                    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);
-                    this.invalidateAggregateMeshStatus(meshId);
-                    return { success: true, mesh };
-                } catch (e: any) {
-                    return { success: false, error: e.message };
-                }
-            }
-
-            case 'get_mesh_host_pairing': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                if (!meshId) return { success: false, error: 'meshId required' };
-                const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-                const mesh = meshRecord?.mesh;
-                if (!mesh) return { success: false, error: 'Mesh not found' };
-                const meshHost = resolveMeshHostStatus(mesh);
-                const pairingStatus = meshHost.pairing?.status || 'not_configured';
-                return {
-                    success: true,
-                    code: pairingStatus === 'not_configured' ? 'mesh_host_pairing_not_configured' : 'mesh_host_pairing_pending',
-                    meshId,
-                    hostAddress: meshHost.hostAddress,
-                    meshHost,
-                    manualPairing: {
-                        status: pairingStatus,
-                        joinImplemented: true,
-                        protocol: 'standalone_command_direct_v1',
-                        description: 'Standalone manual pairing can save address/token metadata, apply a host join over direct standalone command HTTP or injected mesh command dispatch, and check persisted status. P2P signaling remains outside this slice.',
-                    },
-                };
-            }
-
-            case 'configure_mesh_host_pairing': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                const hostAddress = typeof args?.hostAddress === 'string' ? args.hostAddress.trim() : '';
-                const token = typeof args?.token === 'string' ? args.token.trim() : '';
-                if (!meshId) return { success: false, error: 'meshId required' };
-                if (!hostAddress || !token) return { success: false, error: 'hostAddress and token required' };
-                try {
-                    const { configureMeshHostPairing } = await import('../config/mesh-config.js');
-                    const configured = configureMeshHostPairing(meshId, { hostAddress, token });
-                    if (!configured) return { success: false, error: 'Mesh not found' };
-                    this.inlineMeshCache.set(meshId, configured.mesh);
-                    const meshHost = resolveMeshHostStatus(configured.mesh);
-                    return {
-                        success: true,
-                        code: 'mesh_host_pairing_pending',
-                        meshId,
-                        hostAddress: configured.hostAddress,
-                        meshHost,
-                        manualPairing: {
-                            status: meshHost.pairing?.status || 'pairing',
-                            joinImplemented: true,
-                            protocol: 'standalone_command_direct_v1',
-                            description: 'Manual Mesh Host pairing config was saved locally. Use join_mesh_host_pairing to apply it to the host. Raw token was not persisted.',
-                        },
-                    };
-                } catch (e: any) {
-                    return { success: false, code: 'mesh_host_pairing_invalid', meshId, hostAddress, error: e.message };
-                }
-            }
-
-            case 'create_mesh_host_pairing_token': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                if (!meshId) return { success: false, error: 'meshId required' };
-                try {
-                    const { createMeshHostPairingToken } = await import('../config/mesh-config.js');
-                    const created = createMeshHostPairingToken(meshId, {
-                        token: typeof args?.token === 'string' ? args.token : undefined,
-                        expiresAt: typeof args?.expiresAt === 'string' ? args.expiresAt : undefined,
-                    });
-                    if (!created) return { success: false, error: 'Mesh not found' };
-                    this.inlineMeshCache.set(meshId, created.mesh);
-                    this.invalidateAggregateMeshStatus(meshId);
-                    return {
-                        success: true,
-                        code: 'mesh_host_pairing_token_created',
-                        meshId,
-                        token: created.token,
-                        tokenId: created.tokenId,
-                        expiresAt: created.expiresAt,
-                        meshHost: resolveMeshHostStatus(created.mesh),
-                        warning: 'Raw token is returned once and is not persisted; share it with member daemons over a trusted channel.',
-                    };
-                } catch (e: any) {
-                    return { success: false, code: 'mesh_host_pairing_token_invalid', meshId, error: e.message };
-                }
-            }
-
-            case 'apply_mesh_host_join': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                const token = typeof args?.token === 'string' ? args.token.trim() : '';
-                const memberNode = args?.memberNode && typeof args.memberNode === 'object' && !Array.isArray(args.memberNode)
-                    ? args.memberNode
-                    : null;
-                if (!meshId) return { success: false, error: 'meshId required' };
-                if (!token || !memberNode) return { success: false, error: 'token and memberNode required' };
-                try {
-                    const { applyMeshHostJoinRequest } = await import('../config/mesh-config.js');
-                    const applied = applyMeshHostJoinRequest(meshId, {
-                        token,
-                        memberNode: memberNode as any,
-                        memberMeshId: typeof args?.memberMeshId === 'string' ? args.memberMeshId : undefined,
-                    });
-                    if (!applied) return { success: false, error: 'Mesh not found' };
-                    if (!applied.accepted) {
-                        return {
-                            success: false,
-                            code: 'mesh_host_join_rejected',
-                            meshId,
-                            tokenId: applied.tokenId,
-                            meshHost: applied.meshHost ? resolveMeshHostStatus({ meshHost: applied.meshHost }) : undefined,
-                            error: applied.reason,
-                        };
-                    }
-                    this.inlineMeshCache.set(meshId, applied.mesh);
-                    this.invalidateAggregateMeshStatus(meshId);
-                    try {
-                        const { appendLedgerEntry } = await import('../mesh/mesh-ledger.js');
-                        appendLedgerEntry(meshId, {
-                            kind: 'node_joined',
-                            nodeId: applied.node.id,
-                            payload: { role: 'member', tokenId: applied.tokenId, workspace: applied.node.workspace },
-                        });
-                    } catch { /* ledger append is best-effort */ }
-                    return {
-                        success: true,
-                        code: 'mesh_host_join_accepted',
-                        meshId,
-                        node: applied.node,
-                        tokenId: applied.tokenId,
-                        meshHost: resolveMeshHostStatus(applied.mesh),
-                    };
-                } catch (e: any) {
-                    return { success: false, code: 'mesh_host_join_failed', meshId, error: e.message };
-                }
-            }
-
-            case 'join_mesh_host_pairing': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                const token = typeof args?.token === 'string' ? args.token.trim() : '';
-                if (!meshId) return { success: false, error: 'meshId required' };
-                if (!token) return { success: false, error: 'token required because raw pairing tokens are not persisted' };
-                const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-                const mesh = meshRecord?.mesh;
-                if (!mesh) return { success: false, error: 'Mesh not found' };
-                const meshHost = resolveMeshHostStatus(mesh);
-                if (meshHost.role !== 'member') {
-                    return { success: false, code: 'mesh_host_join_not_member', meshId, meshHost, error: 'join_mesh_host_pairing must run from a member daemon configured with a Mesh Host address/token.' };
-                }
-                try {
-                    const { tokenIdForManualPairing, markMeshHostPairingJoined } = await import('../config/mesh-config.js');
-                    const tokenId = tokenIdForManualPairing(token);
-                    if (meshHost.pairing?.tokenId && meshHost.pairing.tokenId !== tokenId) {
-                        return { success: false, code: 'mesh_host_join_rejected', meshId, tokenId, meshHost, error: 'invalid pairing token' };
-                    }
-                    const memberNode = buildMemberJoinNode(mesh, args, this.deps.statusInstanceId);
-                    if (!memberNode) return { success: false, error: 'member node metadata unavailable' };
-                    const hostMeshId = typeof args?.hostMeshId === 'string' && args.hostMeshId.trim() ? args.hostMeshId.trim() : meshId;
-                    const hostDaemonId = typeof args?.hostDaemonId === 'string' && args.hostDaemonId.trim()
-                        ? args.hostDaemonId.trim()
-                        : meshHost.hostDaemonId;
-                    let hostResult: any;
-                    let transport: string;
-                    if (hostDaemonId && this.deps.dispatchMeshCommand) {
-                        transport = 'mesh_command_dispatch';
-                        hostResult = await this.deps.dispatchMeshCommand(hostDaemonId, 'apply_mesh_host_join', {
-                            meshId: hostMeshId,
-                            token,
-                            memberMeshId: meshId,
-                            memberNode,
-                        });
-                    } else if (meshHost.hostAddress) {
-                        transport = 'standalone_http_command';
-                        const commandUrl = normalizeStandaloneHostCommandUrl(meshHost.hostAddress);
-                        const response = await fetch(commandUrl, {
-                            method: 'POST',
-                            headers: { 'Content-Type': 'application/json' },
-                            body: JSON.stringify({ type: 'apply_mesh_host_join', payload: { meshId: hostMeshId, token, memberMeshId: meshId, memberNode } }),
-                        });
-                        hostResult = await response.json().catch(() => ({ success: false, error: `Host returned HTTP ${response.status}` }));
-                        if (!response.ok && hostResult?.success !== false) hostResult = { success: false, error: `Host returned HTTP ${response.status}` };
-                    } else {
-                        return {
-                            success: false,
-                            code: 'mesh_host_join_transport_unavailable',
-                            meshId,
-                            meshHost,
-                            error: 'No hostDaemonId dispatch path or hostAddress HTTP command path is available. P2P signaling join is not implemented in this slice.',
-                        };
-                    }
-                    if (!hostResult?.success) {
-                        return { success: false, code: hostResult?.code || 'mesh_host_join_rejected', meshId, meshHost, transport, error: hostResult?.error || 'Mesh Host rejected join request', hostResult };
-                    }
-                    const joined = meshRecord.inline
-                        ? null
-                        : markMeshHostPairingJoined(meshId, {
-                            tokenId: hostResult.tokenId || tokenId,
-                            hostDaemonId: hostResult.meshHost?.hostDaemonId || hostDaemonId,
-                            hostNodeId: hostResult.meshHost?.hostNodeId,
-                            joinedAt: hostResult.meshHost?.pairing?.joinedAt,
-                        });
-                    if (joined) {
-                        this.inlineMeshCache.set(meshId, joined.mesh);
-                        this.invalidateAggregateMeshStatus(meshId);
-                    }
-                    return {
-                        success: true,
-                        code: 'mesh_host_join_applied',
-                        meshId,
-                        hostMeshId,
-                        transport,
-                        node: hostResult.node,
-                        tokenId: hostResult.tokenId || tokenId,
-                        meshHost: joined ? resolveMeshHostStatus(joined.mesh) : { ...meshHost, pairing: { ...(meshHost.pairing || {}), status: 'paired', tokenId: hostResult.tokenId || tokenId } },
-                        hostResult,
-                        manualPairing: {
-                            status: 'paired',
-                            joinImplemented: true,
-                            protocol: 'standalone_command_direct_v1',
-                            description: 'Mesh Host accepted the join and local member pairing status was marked paired. P2P runtime signaling remains outside this slice.',
-                        },
-                    };
-                } catch (e: any) {
-                    return { success: false, code: 'mesh_host_join_failed', meshId, meshHost, 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 'get_mesh_queue': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                if (!meshId) return { success: false, error: 'meshId required' };
-                try {
-                    const { getMeshQueueStats, getQueue, describeTaskDependencyState } = await import('../mesh/mesh-work-queue.js');
-                    const status = Array.isArray(args?.status)
-                        ? args.status.map((s: any) => typeof s === 'string' ? s.trim() : '').filter(Boolean)
-                        : undefined;
-                    const rawQueue = getQueue(meshId, { status: status as any });
-                    // M1: annotate dependency state at view time (waitingOn / dependenciesSatisfied).
-                    const statusById = new Map(getQueue(meshId).map(task => [task.id, task.status]));
-                    const queue = rawQueue.map(task =>
-                        Array.isArray(task.dependsOn) && task.dependsOn.length > 0
-                            ? { ...task, ...describeTaskDependencyState(task, statusById) }
-                            : task);
-                    const summary = getMeshQueueStats(meshId);
-                    return {
-                        success: true,
-                        queue,
-                        summary,
-                        sourceOfTruth: {
-                            kind: 'mesh_work_queue_file',
-                            activeStatuses: ['pending', 'assigned'],
-                            historicalStatuses: ['completed', 'failed', 'cancelled'],
-                            notes: 'pending/assigned are active work; completed/failed/cancelled are historical records.',
-                        },
-                    };
-                } catch (e: any) {
-                    return { success: false, error: e.message };
-                }
-            }
-
-            case 'cancel_mesh_queue_task': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                const taskId = typeof args?.taskId === 'string' ? args.taskId.trim() : '';
-                if (!meshId || !taskId) return { success: false, error: 'meshId and taskId required' };
-                const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'queue cancellation');
-                if (ownerFailure) return ownerFailure;
-                try {
-                    const { cancelTask } = await import('../mesh/mesh-work-queue.js');
-                    const reason = typeof args?.reason === 'string' ? args.reason : undefined;
-                    const task = cancelTask(meshId, taskId, { reason });
-                    if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
-                    return { success: true, task };
-                } catch (e: any) {
-                    return { success: false, error: e.message };
-                }
-            }
-
-            case 'requeue_mesh_queue_task': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                const taskId = typeof args?.taskId === 'string' ? args.taskId.trim() : '';
-                if (!meshId || !taskId) return { success: false, error: 'meshId and taskId required' };
-                const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'queue requeue');
-                if (ownerFailure) return ownerFailure;
-                try {
-                    const { requeueTask } = await import('../mesh/mesh-work-queue.js');
-                    const task = requeueTask(meshId, taskId, {
-                        reason: typeof args?.reason === 'string' ? args.reason : undefined,
-                        targetNodeId: typeof args?.targetNodeId === 'string' ? args.targetNodeId.trim() : undefined,
-                        targetSessionId: typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : undefined,
-                        clearTargetNode: args?.clearTargetNode === true,
-                        clearTargetSession: args?.clearTargetSession !== false,
-                    });
-                    if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
-                    return { success: true, task };
-                } 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' };
-                const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'node addition');
-                if (ownerFailure) return ownerFailure;
-                try {
-                    const { addNode } = await import('../config/mesh-config.js');
-                    const providerPriority = Array.isArray(args?.providerPriority)
-                        ? args.providerPriority.map((type: any) => typeof type === 'string' ? type.trim() : '').filter(Boolean)
-                        : [];
-                    const readOnly = args?.readOnly === true;
-                    const providerRoles = normalizeProviderRoles(args?.providerRoles);
-                    const policy = {
-                        ...(readOnly ? { readOnly: true } : {}),
-                        ...(providerPriority.length ? { providerPriority } : {}),
-                        ...(providerRoles.length ? { providerRoles } : {}),
-                    };
-                    const role = normalizeMeshDaemonRole(args?.role);
-                    const daemonId = typeof args?.daemonId === 'string' && args.daemonId.trim() ? args.daemonId.trim() : undefined;
-                    const machineId = typeof args?.machineId === 'string' && args.machineId.trim() ? args.machineId.trim() : undefined;
-                    const repoRoot = typeof args?.repoRoot === 'string' && args.repoRoot.trim() ? args.repoRoot.trim() : undefined;
-                    const node = addNode(meshId, {
-                        workspace,
-                        ...(repoRoot ? { repoRoot } : {}),
-                        ...(daemonId ? { daemonId } : {}),
-                        ...(machineId ? { machineId } : {}),
-                        ...(policy ? { policy } : {}),
-                        ...(role ? { role } : {}),
-                    });
-                    if (!node) return { success: false, error: 'Mesh not found' };
-                    // mesh_status hands back a coordinator-memory aggregate
-                    // snapshot keyed on (meshId, queueRevision). Adding a
-                    // node touches neither, so without an explicit cache
-                    // bust the dashboard graph keeps rendering the pre-add
-                    // node list (empty for a fresh mesh) even after the
-                    // user clicks Refresh.
-                    this.invalidateAggregateMeshStatus(meshId);
-                    return { success: true, node };
-                } catch (e: any) {
-                    return { success: false, error: e.message };
-                }
-            }
-
-            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' };
-                const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'node update');
-                if (ownerFailure) return ownerFailure;
-                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;
-                        }
-                    }
-                    // providerRoles: per-(node, provider) role label + maxParallel cap.
-                    // Passing an explicit (possibly empty) array clears/replaces the
-                    // declarations; omitting the arg leaves any value already on policy
-                    // untouched (a full policy object passed by the caller still carries it).
-                    if (Array.isArray(args?.providerRoles)) {
-                        const providerRoles = normalizeProviderRoles(args.providerRoles);
-                        if (providerRoles.length) {
-                            (policy as any).providerRoles = providerRoles;
-                        } else {
-                            delete (policy as any).providerRoles;
-                        }
-                    }
-                    const patch: Record<string, unknown> = { policy: policy as any };
-                    if (typeof args?.systemPrompt === 'string') {
-                        const trimmed = (args.systemPrompt as string).trim();
-                        patch.systemPrompt = trimmed || undefined;
-                    } else if (args?.systemPrompt === null) {
-                        patch.systemPrompt = undefined;
-                    }
-                    const node = updateNode(meshId, nodeId, patch as any);
-                    if (!node) return { success: false, error: 'Mesh node not found' };
-                    // Provider priority / systemPrompt changes don't touch
-                    // the queue revision, so without a manual bust the
-                    // cached aggregate keeps surfacing pre-update values
-                    // (priority chip, coordinator prompt preview, etc.).
-                    this.invalidateAggregateMeshStatus(meshId);
-                    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' };
-                const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'node removal');
-                if (ownerFailure) return ownerFailure;
-                try {
-                    // preferInline so inline-cache-only clone nodes resolve (matches owner check above).
-                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-                    const mesh = meshRecord?.mesh;
-                    if (!mesh) return { success: false, error: 'Mesh not found' };
-                    const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, 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,
-                        source: 'mesh_cleanup_sessions',
-                    });
-                    return result;
-                } catch (e: any) {
-                    return { success: false, error: e.message };
-                }
-            }
-
-            case 'mesh_init': {
-                const workspace = typeof args?.workspace === 'string' && args.workspace.trim() ? args.workspace.trim() : process.cwd();
-                const mesh = args?.inlineMesh || {};
-                try {
-                    const detected = await detectCLIs(this.deps.providerLoader, { includeVersion: true });
-                    return { ...runMeshInit(mesh, workspace, detected, {
-                        write: args?.write === true,
-                        overwrite: args?.overwrite === true,
-                    }) };
-                } catch (e: any) {
-                    return { success: false, error: e?.message || String(e) };
-                }
-            }
-
-            case 'plan_mesh_refine_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' };
-                // preferInline: plan is the dry-run sibling of refine — clone nodes must resolve.
-                const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-                const mesh = meshRecord?.mesh;
-                const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
-                if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
-                return {
-                    success: true,
-                    dryRun: true,
-                    nodeId,
-                    workspace: node.workspace,
-                    validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
-                    mergeWillRun: false,
-                    cleanupWillRun: false,
-                };
-            }
-
-            case 'fast_forward_mesh_node': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                const nodeId = typeof args?.nodeId === 'string' ? args.nodeId.trim() : '';
-                let workspace = typeof args?.workspace === 'string' ? args.workspace.trim() : '';
-                let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths)
-                    ? args.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string')
-                    : undefined;
-                let nodeDaemonId: string | undefined;
-                let allowAutoPublishSubmoduleMainCommits = false;
-                if (meshId && nodeId) {
-                    // preferInline so fast-forward can resolve inline-cache-only clone worktree nodes.
-                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-                    const mesh = meshRecord?.mesh;
-                    const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
-                    if (!workspace) {
-                        workspace = typeof node?.workspace === 'string' ? node.workspace.trim() : '';
-                    }
-                    if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
-                        submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string');
-                    }
-                    allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
-                    nodeDaemonId = typeof node?.daemonId === 'string' ? node.daemonId.trim() : undefined;
-                }
-                // If the target node belongs to a remote daemon, forward the command there.
-                // _meshDirectDispatch prevents re-forwarding (and P2P self-dial) when the stored
-                // daemonId uses a legacy format that doesn't match the receiving daemon's identity.
-                const selfDaemonId = this.deps.statusInstanceId;
-                // daemonIdsEquivalent: a legacy-form stored daemonId that resolves to THIS
-                // machine's core must be treated as local (not remote) so it is not forwarded /
-                // P2P self-dialed. Equivalent → local.
-                const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
-                if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
-                    const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId!, 'fast_forward_mesh_node', {
-                        ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
-                        workspace,
-                        _meshDirectDispatch: true,
-                    });
-                    return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
-                }
-                const result = await (fastForwardMeshNode({
-                    meshId: meshId || undefined,
-                    nodeId: nodeId || undefined,
-                    workspace,
-                    branch: typeof args?.branch === 'string' ? args.branch : undefined,
-                    execute: args?.execute === true,
-                    dryRun: args?.dryRun === true,
-                    updateSubmodules: args?.updateSubmodules === true,
-                    submoduleIgnorePaths,
-                    mode: args?.mode === 'push' ? 'push' : 'merge',
-                    pushSubmodules: args?.pushSubmodules === true,
-                    allowAutoPublishSubmoduleMainCommits,
-                }) as Promise<unknown>);
-                return result as CommandRouterResult;
-            }
-
-            case 'refine_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' };
-
-                // Remote forward: a worktree node lives on its OWN daemon's machine, so the
-                // refine (cd into node.workspace, merge → push → cleanup) must run on THAT
-                // daemon — not the coordinator, whose filesystem has no such path. The sibling
-                // fast_forward_mesh_node / clone_mesh_node handlers already forward to the
-                // node's daemon; refine_mesh_node was the gap (the coordinator would cd into a
-                // non-existent local path and fail), so remote-machine worktrees could not be
-                // converged at all. Forward both dry-run (plan reads the worktree git state)
-                // and execute (async merge job) so the same machine that owns the worktree
-                // resolves it.
-                //
-                // coordinatorDaemonId: refine is ASYNC — the completed/failed event is queued
-                // on the executing daemon's pending-events queue scoped to a coordinator id and
-                // recovered by the coordinator's reconcile loop (pullRemoteNodeQueues →
-                // get_pending_mesh_events). Without stamping our own status id, the remote
-                // daemon would fall back to ITS OWN statusInstanceId as the coordinator
-                // (startMeshRefineJob), scoping the terminal event to the wrong inbox where the
-                // real coordinator never pulls it. Stamp the canonical status id (which is in
-                // the coordinator's self-identity set used to scope the remote drain) so the
-                // event routes back here. Preserve any caller-supplied coordinatorDaemonId.
-                //
-                // _meshDirectDispatch prevents re-forwarding (and P2P self-dial) once the call
-                // has landed on the owning daemon — that daemon then executes locally even if
-                // the stored daemonId uses a legacy form that doesn't match its own identity.
-                {
-                    const meshRecordForForward = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-                    const forwardNode = meshRecordForForward?.mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
-                    const nodeDaemonId = typeof forwardNode?.daemonId === 'string' ? forwardNode.daemonId.trim() : undefined;
-                    const selfDaemonId = this.deps.statusInstanceId;
-                    // daemonIdsEquivalent: a legacy-form daemonId resolving to this machine's core
-                    // is local — execute locally instead of forwarding. Equivalent → local.
-                    const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
-                    if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
-                        const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === 'string' && args.coordinatorDaemonId.trim()
-                            ? args.coordinatorDaemonId.trim()
-                            : undefined;
-                        const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId!, 'refine_mesh_node', {
-                            ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
-                            coordinatorDaemonId: callerCoordinatorDaemonId || selfDaemonId,
-                            _meshDirectDispatch: true,
-                        });
-                        return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
-                    }
-                }
-
-                // Dry-run (plan-only) is the default and stays synchronous: it does no
-                // validation/merge/push and returns the plan instantly. Only execute=true
-                // (and not dry_run) goes through the async refine job that actually
-                // validates → merges → pushes → cleans up. Mirrors the
-                // batch_refine_mesh_nodes / fast_forward_mesh_node dry_run/execute contract.
-                const isDryRun = args?.dryRun !== false && args?.execute !== true;
-                if (isDryRun) {
-                    // preferInline: plan is the dry-run sibling of refine — clone nodes must resolve.
-                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-                    const mesh = meshRecord?.mesh;
-                    const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
-                    if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
-                    return {
-                        success: true,
-                        dryRun: true,
-                        nodeId,
-                        workspace: node.workspace,
-                        validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
-                        mergeWillRun: false,
-                        cleanupWillRun: false,
-                        hint: 'Dry-run only — no merge/push/cleanup performed. Re-invoke with execute:true to converge this node.',
-                    };
-                }
-                return this.startMeshRefineJob(meshId, nodeId, args);
-            }
-
-            case 'batch_refine_mesh_nodes': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                if (!meshId) return { success: false, error: 'meshId required' };
-                const requestedNodeIds = Array.isArray(args?.nodeIds)
-                    ? (args.nodeIds as unknown[]).filter((v): v is string => typeof v === 'string' && v.trim().length > 0).map(v => v.trim())
-                    : undefined;
-                // Dry-run (plan-only) stays synchronous: it does no validation/merge and
-                // returns instantly. Execute goes through the async batch job — immediate
-                // {async:true, status:'accepted'} + background convergence + terminal event,
-                // matching the single-node refine_mesh_node contract so long validation
-                // suites can't time out the IPC and strand the coordinator.
-                const isDryRun = args?.dryRun !== false && args?.execute !== true;
-                if (isDryRun) return this.batchRefineMeshNodes(meshId, requestedNodeIds, args);
-                return this.startMeshRefineBatchJob(meshId, requestedNodeIds, args);
-            }
-
-            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 {
-                    // preferInline so removal can resolve inline-cache-only clone worktree nodes.
-                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-                    const mesh = meshRecord?.mesh;
-                    const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
-
-                    // Guard: refuse to remove the coordinator's OWN local base node
-                    // (same machine, NOT a worktree). Removing it breaks live mesh
-                    // membership — the coordinator can no longer be reached and has
-                    // to be restarted. Worktree clones are always safe to remove;
-                    // only the non-worktree node bound to this daemon is protected.
-                    // An explicit force:true overrides for intentional mesh teardown.
-                    if (node && !args?._meshDirectDispatch && node.isLocalWorktree !== true && args?.force !== true) {
-                        const nodeDaemonId = typeof node.daemonId === 'string' ? node.daemonId.trim() : '';
-                        const nodeMachineId = readMeshNodeMachineId(node as Record<string, unknown>) || '';
-                        const selfDaemonId = this.deps.statusInstanceId || '';
-                        const selfMachineId = (() => { try { return loadConfig().machineId || ''; } catch { return ''; } })();
-                        const isCoordinatorBaseNode =
-                            (!!selfDaemonId && (nodeDaemonId === selfDaemonId || nodeMachineId === selfDaemonId))
-                            || (!!selfMachineId && (nodeDaemonId === selfMachineId || nodeMachineId === selfMachineId));
-                        if (isCoordinatorBaseNode) {
-                            return {
-                                success: false,
-                                removed: false,
-                                code: 'mesh_remove_coordinator_base_node_protected',
-                                error: `Refusing to remove the coordinator's own base node '${typeof node.workspace === 'string' ? node.workspace : nodeId}'. `
-                                    + `It is the local non-worktree node bound to this coordinator daemon; removing it breaks live mesh membership and forces a restart.`,
-                                recoveryHint: 'Remove worktree clone nodes instead, or pass force:true only if you are intentionally tearing down this mesh and accept that the coordinator must be re-registered/restarted.',
-                            };
-                        }
-                    }
-
-                    const sessionCleanupMode = this.normalizeMeshSessionCleanupMode(
-                        args?.sessionCleanupMode ?? args?.session_cleanup_mode ?? mesh?.policy?.sessionCleanupOnNodeRemove,
-                    );
-                    // Explicit sessionIds (e.g. supplied by refine auto-cleanup) bypass the
-                    // workspace-only-match guard so a delegate session that lacks a
-                    // meta.meshNodeId binding can still be stopped/deleted.
-                    const explicitSessionIds = Array.isArray(args?.sessionIds)
-                        ? (args.sessionIds as unknown[]).filter((v): v is string => typeof v === 'string' && v.trim().length > 0).map(v => v.trim())
-                        : undefined;
-                    let sessionCleanup: Record<string, unknown> | undefined;
-                    if (node && sessionCleanupMode !== 'preserve') {
-                        sessionCleanup = await this.cleanupMeshSessions({
-                            meshId,
-                            nodeId,
-                            node,
-                            mode: sessionCleanupMode,
-                            ...(explicitSessionIds && explicitSessionIds.length > 0 ? { sessionIds: explicitSessionIds } : {}),
-                            source: 'mesh_remove_node',
-                        });
-                        if (sessionCleanup.success === false) return { success: false, removed: false, sessionCleanup };
-                    }
-
-                    let worktreeCleanup: Record<string, unknown> | undefined;
-                    if (node?.isLocalWorktree) {
-                        const nodeDaemonId = typeof node.daemonId === 'string' ? node.daemonId.trim() : undefined;
-                        // daemonIdsEquivalent: an equivalent-form daemonId is this machine —
-                        // clean up locally, do not forward. Equivalent → local.
-                        const isRemoteWorktree = nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand
-                            && !args?._meshDirectDispatch;
-                        if (isRemoteWorktree) {
-                            // Worktree lives on a different machine — ask that daemon to clean it up.
-                            // _meshDirectDispatch prevents re-forwarding when stored daemonId uses legacy format.
-                            const forwarded = await this.deps.dispatchMeshCommand!(nodeDaemonId!, 'remove_mesh_node', {
-                                ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
-                                _meshDirectDispatch: true,
-                            });
-                            return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
-                        }
-                        const cleanupResult = await this.cleanupLocalWorktreeNode({ mesh, node, nodeId, force: args?.force === true });
-                        // De-gating: membership removal is NOT gated on the worktree
-                        // directory actually being deleted. cleanupLocalWorktreeNode now
-                        // returns success:true (with a residue flag) whenever the path is
-                        // proven managed and the only remaining problem is leftover
-                        // directory bytes (e.g. Windows EINVAL). A success:false here means
-                        // a genuinely-unsafe condition — missing metadata, a non-managed /
-                        // unexpected path, a branch mismatch, a dirty worktree, or an
-                        // unverified force fallback — and those still block removal.
-                        if (cleanupResult.success === false) {
-                            return {
-                                success: false,
-                                removed: false,
-                                code: cleanupResult.code,
-                                error: cleanupResult.error,
-                                recoveryHint: cleanupResult.recoveryHint,
-                                ...(sessionCleanup ? { sessionCleanup } : {}),
-                                worktreeCleanup: cleanupResult,
-                            };
-                        }
-                        worktreeCleanup = cleanupResult;
-                    }
-
-                    let removed = false;
-                    if (meshRecord?.inline) {
-                        removed = this.removeInlineMeshNode(meshId, mesh, nodeId);
-                        // Inline meshes share the same aggregate snapshot cache as
-                        // local-config meshes; without this bust the removed node
-                        // keeps showing up in the dashboard graph until the cache
-                        // ages out on its own.
-                        if (removed) this.invalidateAggregateMeshStatus(meshId);
-                        // Node was already absent from the inline mesh (e.g. removed by a
-                        // prior refine cleanup). Treat as removed so caller gets removed:true.
-                        if (!removed && !node) removed = true;
-                    } else {
-                        const { removeNode } = await import('../config/mesh-config.js');
-                        removed = removeNode(meshId, nodeId);
-                        // Node already absent from config (e.g. removed by a prior refine
-                        // cleanup after a successful Refinery merge). Treat as removed so
-                        // the response is accurate.
-                        if (!removed && !node) removed = true;
-                        if (removed) this.invalidateAggregateMeshStatus(meshId);
-                    }
-
-                    // Record in task ledger
-                    if (removed) {
-                        try {
-                            const { appendLedgerEntry } = await import('../mesh/mesh-ledger.js');
-                            appendLedgerEntry(meshId, {
-                                kind: 'node_removed',
-                                nodeId,
-                                payload: {
-                                    worktree: !!node?.isLocalWorktree,
-                                    sessionCleanupMode,
-                                    workspace: typeof node?.workspace === 'string' ? node.workspace : undefined,
-                                    daemonId: typeof node?.daemonId === 'string' ? node.daemonId : undefined,
-                                    worktreeBranch: typeof node?.worktreeBranch === 'string' ? node.worktreeBranch : undefined,
-                                    worktreeCleanupFallback: typeof worktreeCleanup?.fallback === 'string' ? worktreeCleanup.fallback : undefined,
-                                    forced: worktreeCleanup?.forced === true ? true : undefined,
-                                    forceFallbackReason: typeof worktreeCleanup?.reason === 'string' ? worktreeCleanup.reason : undefined,
-                                },
-                            });
-                        } catch { /* ledger append is best-effort */ }
-                    }
-
-                    // Surface leftover-directory residue at the top level so callers
-                    // see the node was dropped from the mesh even though the worktree
-                    // directory could not be fully removed (best-effort, non-gating).
-                    const residueWarning = worktreeCleanup?.residue === true && typeof worktreeCleanup?.residueWarning === 'string'
-                        ? worktreeCleanup.residueWarning
-                        : undefined;
-                    return {
-                        success: true,
-                        removed,
-                        ...(residueWarning ? { residueWarning } : {}),
-                        ...(sessionCleanup ? { sessionCleanup } : {}),
-                        ...(worktreeCleanup ? { worktreeCleanup } : {}),
-                    };
-                } 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' };
-                const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'worktree clone');
-                if (ownerFailure) return ownerFailure;
-
-                try {
-                    // Resolve with preferInline so the clone writes the new node into the
-                    // same representation that get_mesh reads back. The MCP coordinator
-                    // passes inlineMesh on every mesh command, so when it owns an inline
-                    // mesh the membership read path (get_mesh, preferInline: true) returns
-                    // the inline cache. Without preferInline here, clone could resolve to a
-                    // local-config mesh and write the node only to config — leaving the
-                    // inline cache (and therefore get_mesh / refreshMeshFromDaemon) without
-                    // the node, so the new worktree node is never visible in live mesh
-                    // membership even though worktree_bootstrap_complete fires.
-                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-                    const mesh = meshRecord?.mesh;
-                    if (!mesh) return { success: false, error: 'Mesh not found' };
-
-                    const sourceNode = mesh.nodes?.find((n: any) => meshNodeIdMatches(n, sourceNodeId));
-                    if (!sourceNode) return { success: false, error: `Source node '${sourceNodeId}' not found in mesh` };
-
-                    // Forward to the source node's daemon if it's on a different machine.
-                    // _meshDirectDispatch prevents infinite re-forwarding when the stored daemonId
-                    // uses a legacy format that doesn't match the receiving daemon's statusInstanceId.
-                    const sourceDaemonId = typeof sourceNode.daemonId === 'string' ? sourceNode.daemonId.trim() : undefined;
-                    // daemonIdsEquivalent: an equivalent-form source daemonId is this machine —
-                    // clone locally, do not forward. Equivalent → local.
-                    if (sourceDaemonId && !daemonIdsEquivalent(sourceDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand
-                        && !args?._meshDirectDispatch) {
-                        const forwarded = await this.deps.dispatchMeshCommand(sourceDaemonId, 'clone_mesh_node', {
-                            ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
-                            _meshDirectDispatch: true,
-                        });
-                        return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
-                    }
-
-                    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,
-                            machineId: sourceNode.machineId ?? (sourceNode as any).machine_id,
-                            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,
-                            machineId: sourceNode.machineId ?? (sourceNode as any).machine_id,
-                            userOverrides: { ...(sourceNode.userOverrides || {}) },
-                            isLocalWorktree: true,
-                            worktreeBranch: result.branch,
-                            clonedFromNodeId: sourceNodeId,
-                            policy: { ...(sourceNode.policy || {}) },
-                        });
-                        if (!node) return { success: false, error: 'Failed to register worktree node' };
-                        // Also reconcile the freshly-registered node into any warmed inline
-                        // cache for this mesh. get_mesh (preferInline: true) reads the inline
-                        // cache first when one exists; if we only wrote to local config the
-                        // node would be invisible to membership reads. updateInlineMeshNode is
-                        // a no-op when no inline cache is present.
-                        const inlineForReconcile = this.getCachedInlineMesh(meshId);
-                        if (inlineForReconcile) this.updateInlineMeshNode(meshId, inlineForReconcile, node);
-                        this.invalidateAggregateMeshStatus(meshId);
-                    }
-
-                    const persistWorktreeSetupState = async (bootstrapState: WorktreeBootstrapState): Promise<void> => {
-                        node.worktreeBootstrap = bootstrapState;
-                        if (meshRecord.inline) {
-                            this.updateInlineMeshNode(meshId, mesh, node);
-                            return;
-                        }
-                        try {
-                            const { updateNode } = await import('../config/mesh-config.js');
-                            updateNode(meshId, node.id, { worktreeBootstrap: bootstrapState });
-                            this.invalidateAggregateMeshStatus(meshId);
-                        } catch { /* bootstrap status persistence is best-effort */ }
-                    };
-
-                    const appendCloneLedger = async (initSubmodules: boolean, bootstrapState: WorktreeBootstrapState): Promise<void> => {
-                        try {
-                            const { appendLedgerEntry } = await import('../mesh/mesh-ledger.js');
-                            appendLedgerEntry(meshId, {
-                                kind: 'node_cloned',
-                                nodeId: node.id,
-                                payload: {
-                                    sourceNodeId,
-                                    branch: result.branch,
-                                    worktreePath: result.worktreePath,
-                                    submodulesInitialized: initSubmodules,
-                                    worktreeBootstrap: {
-                                        status: bootstrapState.status,
-                                        required: bootstrapState.required,
-                                        configSource: bootstrapState.configSource,
-                                        configSourceType: bootstrapState.configSourceType,
-                                        lastCommand: bootstrapState.lastCommand,
-                                        exitCode: bootstrapState.exitCode,
-                                    },
-                                },
-                            });
-                        } catch { /* ledger append is best-effort */ }
-                    };
-
-                    const initSubmodules = (sourceNode.policy as any)?.initSubmodulesOnClone !== false;
-                    const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, result.worktreePath);
-                    const runningBootstrapState: WorktreeBootstrapState = {
-                        status: 'running',
-                        required: loadedBootstrap.config?.required !== false,
-                        configSource: loadedBootstrap.path || loadedBootstrap.source,
-                        configSourceType: loadedBootstrap.sourceType,
-                        startedAt: new Date().toISOString(),
-                    };
-                    await persistWorktreeSetupState(runningBootstrapState);
-
-                    const finishWorktreeSetup = async (): Promise<{ submodulesInitialized: boolean; bootstrapState: WorktreeBootstrapState }> => {
-                        let submodulesInitialized = false;
-                        if (initSubmodules) {
-                            try {
-                                const { runGit } = await import('../git/git-executor.js');
-                                await runGit(
-                                    { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
-                                    ['submodule', 'update', '--init', '--recursive'],
-                                    { timeoutMs: 120000 },
-                                );
-                                submodulesInitialized = true;
-
-                                // Sync oss submodule to source node HEAD (best-effort)
-                                const sourceWorkspace = sourceNode.repoRoot || sourceNode.workspace;
-                                if (sourceWorkspace) {
-                                    try {
-                                        const { runGit: rg } = await import('../git/git-executor.js');
-                                        const sourceCtx = { workspace: sourceWorkspace, repoRoot: sourceWorkspace, isGitRepo: true };
-                                        const worktreeCtx = { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true };
-
-                                        // Read source node's oss submodule SHA
-                                        const sourceStatusOut = await rg(sourceCtx, ['submodule', 'status', 'oss'], { timeoutMs: 10000 });
-                                        const sourceStatusLine = (typeof sourceStatusOut === 'string' ? sourceStatusOut : (sourceStatusOut as any)?.stdout ?? '').trim();
-                                        const sourceShaMatch = sourceStatusLine.match(/^[+\- ]?([0-9a-f]{40})/);
-                                        const sourceSha = sourceShaMatch?.[1];
-
-                                        if (sourceSha) {
-                                            // Read worktree's current oss HEAD
-                                            const ossCtx = { workspace: `${result.worktreePath}/oss`, repoRoot: `${result.worktreePath}/oss`, isGitRepo: true };
-                                            const worktreeOssHeadOut = await rg(ossCtx, ['rev-parse', 'HEAD'], { timeoutMs: 10000 });
-                                            const worktreeOssSha = (typeof worktreeOssHeadOut === 'string' ? worktreeOssHeadOut : (worktreeOssHeadOut as any)?.stdout ?? '').trim();
-
-                                            if (worktreeOssSha !== sourceSha) {
-                                                // Fetch target SHA from source node's oss directory
-                                                await rg(ossCtx, ['fetch', `${sourceWorkspace}/oss`, 'HEAD'], { timeoutMs: 60000 });
-                                                await rg(ossCtx, ['checkout', sourceSha], { timeoutMs: 10000 });
-                                                await rg(worktreeCtx, ['add', 'oss'], { timeoutMs: 10000 });
-                                                await rg(worktreeCtx, ['commit', '-m', 'chore: sync oss to source node HEAD on clone'], { timeoutMs: 10000 });
-                                                console.log(`[mesh] Synced oss submodule to source HEAD ${sourceSha.slice(0, 8)} in worktree`);
-                                            }
-                                        }
-                                    } catch (ossErr: any) {
-                                        console.warn('[mesh] oss submodule sync to source HEAD failed (best-effort):', ossErr.message);
-                                    }
-                                }
-                            } catch (subErr: any) {
-                                // Submodule init is best-effort; don't fail the clone
-                                console.warn('[mesh] Submodule init failed for worktree:', subErr.message);
-                            }
-                        }
-                        const bootstrapState: WorktreeBootstrapState = await runMeshWorktreeBootstrap(mesh, result.worktreePath);
-                        await persistWorktreeSetupState(bootstrapState);
-                        await appendCloneLedger(submodulesInitialized, bootstrapState);
-                        return { submodulesInitialized, bootstrapState };
-                    };
-
-                    const requestedSetupWaitMs = Number(args?.setupWaitMs ?? args?.bootstrapWaitMs ?? 8000);
-                    const setupWaitMs = Number.isFinite(requestedSetupWaitMs)
-                        ? Math.min(Math.max(requestedSetupWaitMs, 0), 14000)
-                        : 8000;
-                    const setupPromise = finishWorktreeSetup();
-                    const setupResult = await Promise.race([
-                        setupPromise.then((value) => ({ completed: true as const, value })),
-                        new Promise<{ completed: false }>((resolve) => setTimeout(() => resolve({ completed: false }), setupWaitMs)),
-                    ]);
-
-                    const emitBootstrapEvent = (eventStatus: 'bootstrap_complete' | 'bootstrap_failed', bootstrapState: WorktreeBootstrapState, startedAtMs: number, extraPayload?: Record<string, unknown>): void => {
-                        try {
-                            const durationMs = Date.now() - startedAtMs;
-                            const event = `worktree_${eventStatus}` as const;
-                            const metadataEvent = {
-                                source: 'clone_mesh_node_bootstrap',
-                                nodeId: node.id,
-                                status: eventStatus,
-                                worktreePath: result.worktreePath,
-                                durationMs,
-                                bootstrapStatus: bootstrapState.status,
-                                ...(bootstrapState.error ? { error: bootstrapState.error } : {}),
-                                ...(bootstrapState.exitCode !== undefined ? { exitCode: bootstrapState.exitCode } : {}),
-                                ...(extraPayload || {}),
-                            };
-                            if (typeof this.deps.instanceManager?.getByCategory === 'function') {
-                                const forwarded = handleMeshForwardEvent(
-                                    { instanceManager: this.deps.instanceManager } as any,
-                                    { event, meshId, nodeId: node.id, workspace: result.worktreePath, metadataEvent },
-                                );
-                                if (forwarded?.success === true) return;
-                            }
-                            queuePendingMeshCoordinatorEvent({
-                                event,
-                                meshId,
-                                nodeLabel: node.id,
-                                nodeId: node.id,
-                                workspace: result.worktreePath,
-                                metadataEvent,
-                                queuedAt: Date.now(),
-                            });
-                        } catch { /* event emission is best-effort */ }
-                    };
-
-                    const bootstrapStartedMs = Date.now();
-
-                    if (!setupResult.completed) {
-                        setupPromise
-                            .then(({ bootstrapState }) => {
-                                emitBootstrapEvent('bootstrap_complete', bootstrapState, bootstrapStartedMs);
-                            })
-                            .catch((error: any) => {
-                                const failedState: WorktreeBootstrapState = {
-                                    ...runningBootstrapState,
-                                    status: 'failed',
-                                    completedAt: new Date().toISOString(),
-                                    error: error?.message || String(error),
-                                };
-                                void persistWorktreeSetupState(failedState);
-                                void appendCloneLedger(false, failedState);
-                                emitBootstrapEvent('bootstrap_failed', failedState, bootstrapStartedMs, { error: error?.message || String(error) });
-                            });
-                        return {
-                            success: true,
-                            async: true,
-                            status: 'accepted',
-                            node,
-                            worktreePath: result.worktreePath,
-                            branch: result.branch,
-                            worktreeBootstrap: runningBootstrapState,
-                            worktreeSetup: {
-                                status: 'running',
-                                setupWaitMs,
-                                message: 'Worktree node is registered; submodule/bootstrap setup is continuing in the background.',
-                            },
-                        };
-                    }
-
-                    const { submodulesInitialized, bootstrapState } = setupResult.value;
-                    emitBootstrapEvent('bootstrap_complete', bootstrapState, bootstrapStartedMs);
-                    return {
-                        success: true,
-                        node,
-                        worktreePath: result.worktreePath,
-                        branch: result.branch,
-                        submodulesInitialized,
-                        worktreeBootstrap: bootstrapState,
-                    };
-                } catch (e: any) {
-                    return { success: false, error: e.message };
-                }
-            }
-            case 'retry_mesh_node_bootstrap': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                const nodeId = typeof args?.nodeId === 'string' ? args.nodeId.trim() : '';
-                if (!meshId) return { success: false, error: 'meshId required' };
-                if (!nodeId) return { success: false, error: 'nodeId required' };
-                const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'bootstrap retry');
-                if (ownerFailure) return ownerFailure;
-
-                try {
-                    // preferInline so bootstrap-retry can resolve inline-cache-only clone worktree nodes.
-                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-                    const mesh = meshRecord?.mesh;
-                    if (!mesh) return { success: false, error: 'Mesh not found' };
-
-                    const node = mesh.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
-                    if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
-                    if (!node.isLocalWorktree) return { success: false, error: 'Node is not a local worktree node' };
-
-                    // Bootstrap runs scripts in the worktree path — forward to the node's daemon if remote.
-                    // _meshDirectDispatch prevents re-forwarding when stored daemonId uses legacy format.
-                    const nodeDaemonId = typeof node.daemonId === 'string' ? node.daemonId.trim() : undefined;
-                    // daemonIdsEquivalent: an equivalent-form daemonId is this machine —
-                    // bootstrap locally, do not forward. Equivalent → local.
-                    if (nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand
-                        && !args?._meshDirectDispatch) {
-                        const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, 'retry_mesh_node_bootstrap', {
-                            ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
-                            _meshDirectDispatch: true,
-                        });
-                        return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
-                    }
-
-                    const currentBootstrap = node.worktreeBootstrap as WorktreeBootstrapState | undefined;
-                    if (currentBootstrap?.status === 'running') {
-                        return { success: false, error: 'Bootstrap is already running for this node' };
-                    }
-
-                    const worktreePath: string = node.workspace || node.repoRoot;
-                    if (!worktreePath) return { success: false, error: 'Node has no workspace path' };
-
-                    const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, worktreePath);
-                    const runningState: WorktreeBootstrapState = {
-                        status: 'running',
-                        required: loadedBootstrap.config?.required !== false,
-                        configSource: loadedBootstrap.path || loadedBootstrap.source,
-                        configSourceType: loadedBootstrap.sourceType,
-                        startedAt: new Date().toISOString(),
-                    };
-
-                    const persistState = async (bootstrapState: WorktreeBootstrapState): Promise<void> => {
-                        node.worktreeBootstrap = bootstrapState;
-                        if (meshRecord.inline) {
-                            this.updateInlineMeshNode(meshId, mesh, node);
-                            return;
-                        }
-                        try {
-                            const { updateNode } = await import('../config/mesh-config.js');
-                            updateNode(meshId, node.id, { worktreeBootstrap: bootstrapState });
-                            this.invalidateAggregateMeshStatus(meshId);
-                        } catch { /* best-effort */ }
-                    };
-
-                    await persistState(runningState);
-                    const bootstrapState = await runMeshWorktreeBootstrap(mesh, worktreePath);
-                    await persistState(bootstrapState);
-
-                    return { success: true, bootstrapState };
-                } catch (e: any) {
-                    return { success: false, error: e.message };
-                }
-            }
-
-            case 'trigger_mesh_queue': {
-                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
-                if (!meshId) return { success: false, error: 'meshId required' };
-                const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'queue trigger');
-                if (ownerFailure) return ownerFailure;
-                try {
-                    const { triggerMeshQueue, tryAssignQueueTask } = await import('../mesh/mesh-events.js');
-
-                    // Bug A fix: when preferredNodeId is provided, attempt to claim a pending
-                    // task for the preferred node's idle session first, before the general
-                    // round-robin trigger picks a different node.
-                    const preferredNodeId = typeof args?.preferredNodeId === 'string' ? args.preferredNodeId.trim() : '';
-                    if (preferredNodeId) {
-                        const cliInstances = this.deps.instanceManager.getByCategory('cli');
-                        // Sort: preferred node's sessions first, others after
-                        const sorted = [...cliInstances].sort((a, b) => {
-                            const aSettings = a.getState().settings as Record<string, unknown> || {};
-                            const bSettings = b.getState().settings as Record<string, unknown> || {};
-                            const aNode = readStringValue(aSettings.meshNodeId, aSettings.nodeId);
-                            const bNode = readStringValue(bSettings.meshNodeId, bSettings.nodeId);
-                            return (aNode === preferredNodeId ? -1 : 0) - (bNode === preferredNodeId ? -1 : 0);
-                        });
-                        for (const inst of sorted) {
-                            const state = inst.getState();
-                            const settings = state.settings as Record<string, unknown> || {};
-                            const nodeId = readStringValue(settings.meshNodeId, settings.nodeId);
-                            if (!nodeId || nodeId !== preferredNodeId) continue;
-                            const meshNodeFor = readStringValue(settings.meshNodeFor);
-                            if (meshNodeFor !== meshId) continue;
-                            const status = (readStringValue(state.status) || '').toLowerCase();
-                            if (status !== 'idle') continue;
-                            const sessionId = typeof state.instanceId === 'string' ? state.instanceId : '';
-                            const providerType = readStringValue(state.type, settings.providerType) || '';
-                            if (sessionId && providerType) {
-                                tryAssignQueueTask(this.deps as any, meshId, nodeId, sessionId, providerType);
-                                break;
-                            }
-                        }
-                    }
-
-                    const trigger = await triggerMeshQueue(this.deps as any, meshId);
-                    return { success: true, trigger };
-                } 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() : '';