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

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "1428e9d027beefe860a77f34dea34d202db80f00" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "1428e9d0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.364" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-24T00:06:20.085Z" : void 0);
+      const commit = readInjected(true ? "fe24f3fb158efc949e806b79bca2479b1c29d753" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "fe24f3fb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.365" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-24T00:48:25.762Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -31927,6 +31927,19 @@ ${error48.message || ""}`;
         MAX_ACTIVITY = 30;
       }
     });
+    function sha256Hex(input) {
+      return (0, import_node_crypto.createHash)("sha256").update(input).digest("hex");
+    }
+    function shortHash(input, length = 16) {
+      return sha256Hex(input).slice(0, length);
+    }
+    var import_node_crypto;
+    var init_hash = __esm2({
+      "src/system/hash.ts"() {
+        "use strict";
+        import_node_crypto = require("crypto");
+      }
+    });
     function readObject(value) {
       return value && typeof value === "object" && !Array.isArray(value) ? value : null;
     }
@@ -32201,7 +32214,7 @@ ${error48.message || ""}`;
       return normalized;
     }
     function tokenIdForManualPairing(token) {
-      return `tok_${(0, import_crypto3.createHash)("sha256").update(token).digest("hex").slice(0, 16)}`;
+      return `tok_${shortHash(token)}`;
     }
     function normalizeTokenExpiry(value) {
       if (typeof value !== "string" || !value.trim()) return void 0;
@@ -32440,6 +32453,7 @@ ${error48.message || ""}`;
         import_fs3 = require("fs");
         import_path3 = require("path");
         import_crypto3 = require("crypto");
+        init_hash();
         init_config();
         init_repo_mesh_types();
         init_mesh_host_ownership();
@@ -36860,7 +36874,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     function resolveHermesCoordinatorHome(meshId, workspace) {
       const key = `${meshId || "mesh"}
 ${(0, import_node_path.resolve)(workspace || os42.tmpdir())}`;
-      const hash2 = (0, import_node_crypto.createHash)("sha256").update(key).digest("hex").slice(0, 16);
+      const hash2 = shortHash(key);
       return (0, import_node_path.join)(os42.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash2}`);
     }
     function resolveMcpConfigPath(configPath, workspace) {
@@ -37069,7 +37083,6 @@ ${rendered}`, "utf-8");
         });
       });
     }
-    var import_node_crypto;
     var import_node_fs3;
     var os42;
     var import_session_host_core4;
@@ -37081,12 +37094,12 @@ ${rendered}`, "utf-8");
     var init_mesh_coordinator = __esm2({
       "src/commands/mesh-coordinator.ts"() {
         "use strict";
-        import_node_crypto = require("crypto");
         import_node_fs3 = require("fs");
         os42 = __toESM2(require("os"));
         import_session_host_core4 = require_dist();
         import_node_path = require("path");
         init_logger();
+        init_hash();
         DEFAULT_SERVER_NAME = "adhdev-mesh";
         DEFAULT_ADHDEV_MCP_COMMAND = "adhdev";
         HERMES_CLI_TYPE = "hermes-cli";
@@ -37953,6 +37966,46 @@ ${rendered}`, "utf-8");
       const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !liveStaleReason);
       return { ledgerOnlyStaleReason, isFreshUnacknowledged };
     }
+    function buildLedgerDirectDispatchRecord(dispatch, ctx) {
+      const taskId = directDispatchTaskId(dispatch);
+      const terminal = ctx.terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
+      const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
+      const live = sessionStatusFromNodes(ctx.nodes, dispatch.nodeId, dispatch.sessionId);
+      const status = terminalStatus || live.status || "assigned";
+      const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
+      const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
+        status,
+        isTerminalRow: terminalRow,
+        hasTerminalStatus: Boolean(terminalStatus),
+        liveStatus: live.status,
+        liveStaleReason: live.staleReason,
+        dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true
+      });
+      const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
+      const { title, summary } = summarizeMessage(message);
+      const record2 = {
+        taskId,
+        source: "direct",
+        status,
+        nodeId: dispatch.nodeId,
+        sessionId: dispatch.sessionId,
+        providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
+        taskTitle: readString6(dispatch.payload?.taskTitle) || title,
+        taskSummary: readString6(dispatch.payload?.taskSummary) || summary,
+        message,
+        taskMode: readString6(dispatch.payload?.taskMode),
+        createdAt: dispatch.timestamp,
+        updatedAt: terminal?.timestamp || dispatch.timestamp,
+        dispatchedAt: dispatch.timestamp,
+        elapsedMs: elapsedSince(dispatch.timestamp, ctx.now),
+        terminal: terminalRow,
+        terminalKind: terminal?.kind,
+        terminalAt: terminal?.timestamp,
+        staleReason: live.staleReason || ledgerOnlyStaleReason,
+        ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
+      };
+      return { record: record2, terminalRow };
+    }
     function buildMeshActiveWorkSummary(activeWork) {
       const statusCounts = {
         pending: 0,
@@ -38058,49 +38111,13 @@ ${rendered}`, "utf-8");
         const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
         const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
         for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
-          const taskId = directDispatchTaskId(dispatch);
-          if (dbTaskIds.has(taskId)) continue;
-          const terminal = terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
-          const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
-          const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
-          const status = terminalStatus || live.status || "assigned";
-          const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
-          const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
-            status,
-            isTerminalRow: terminalRow,
-            hasTerminalStatus: Boolean(terminalStatus),
-            liveStatus: live.status,
-            liveStaleReason: live.staleReason,
-            dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true
-          });
-          const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
-          const { title, summary: summary2 } = summarizeMessage(message);
-          const record2 = {
-            taskId,
-            source: "direct",
-            status,
-            nodeId: dispatch.nodeId,
-            sessionId: dispatch.sessionId,
-            providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
-            taskTitle: readString6(dispatch.payload?.taskTitle) || title,
-            taskSummary: readString6(dispatch.payload?.taskSummary) || summary2,
-            message,
-            taskMode: readString6(dispatch.payload?.taskMode),
-            createdAt: dispatch.timestamp,
-            updatedAt: terminal?.timestamp || dispatch.timestamp,
-            dispatchedAt: dispatch.timestamp,
-            elapsedMs: elapsedSince(dispatch.timestamp, now),
-            terminal: terminalRow,
-            terminalKind: terminal?.kind,
-            terminalAt: terminal?.timestamp,
-            staleReason: live.staleReason || ledgerOnlyStaleReason,
-            ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
-          };
+          if (dbTaskIds.has(directDispatchTaskId(dispatch))) continue;
+          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
           if (terminalRow) {
             terminalDirectWork.push(record2);
             if (opts.includeTerminalDirect !== true) continue;
           }
-          if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
+          if (record2.staleReason && !terminalRow) {
             staleDirectWork.push(record2);
             continue;
           }
@@ -38110,48 +38127,12 @@ ${rendered}`, "utf-8");
         const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
         const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
         for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
-          const taskId = directDispatchTaskId(dispatch);
-          const terminal = terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
-          const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
-          const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
-          const status = terminalStatus || live.status || "assigned";
-          const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
-          const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
-            status,
-            isTerminalRow: terminalRow,
-            hasTerminalStatus: Boolean(terminalStatus),
-            liveStatus: live.status,
-            liveStaleReason: live.staleReason,
-            dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true
-          });
-          const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
-          const { title, summary: summary2 } = summarizeMessage(message);
-          const record2 = {
-            taskId,
-            source: "direct",
-            status,
-            nodeId: dispatch.nodeId,
-            sessionId: dispatch.sessionId,
-            providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
-            taskTitle: readString6(dispatch.payload?.taskTitle) || title,
-            taskSummary: readString6(dispatch.payload?.taskSummary) || summary2,
-            message,
-            taskMode: readString6(dispatch.payload?.taskMode),
-            createdAt: dispatch.timestamp,
-            updatedAt: terminal?.timestamp || dispatch.timestamp,
-            dispatchedAt: dispatch.timestamp,
-            elapsedMs: elapsedSince(dispatch.timestamp, now),
-            terminal: terminalRow,
-            terminalKind: terminal?.kind,
-            terminalAt: terminal?.timestamp,
-            staleReason: live.staleReason || ledgerOnlyStaleReason,
-            ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
-          };
+          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
           if (terminalRow) {
             terminalDirectWork.push(record2);
             if (opts.includeTerminalDirect !== true) continue;
           }
-          if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
+          if (record2.staleReason && !terminalRow) {
             staleDirectWork.push(record2);
             continue;
           }
@@ -64392,6 +64373,7 @@ ${body}
         ...meshNodeLogsHandlers
       })
     );
+    init_dist();
     var os21 = __toESM2(require("os"));
     var path27 = __toESM2(require("path"));
     var crypto5 = __toESM2(require("crypto"));
@@ -64404,6 +64386,7 @@ ${body}
     init_state_store();
     init_workspaces();
     init_recent_activity();
+    init_hash();
     init_coordinator_registry();
     init_summary_metadata();
     var os20 = __toESM2(require("os"));
@@ -70757,7 +70740,7 @@ ${rawInput}` : rawInput;
     function ensureEmptyDelegatedMcpConfig(workspace) {
       const baseDir = path27.join(os21.tmpdir(), "adhdev-delegated-agent-empty-mcp");
       (0, import_fs15.mkdirSync)(baseDir, { recursive: true });
-      const workspaceHash = crypto5.createHash("sha256").update(path27.resolve(workspace || os21.tmpdir())).digest("hex").slice(0, 16);
+      const workspaceHash = shortHash(path27.resolve(workspace || os21.tmpdir()));
       const filePath = path27.join(baseDir, `${workspaceHash}.json`);
       (0, import_fs15.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
       return filePath;
@@ -71724,6 +71707,154 @@ Run 'adhdev doctor' for detailed diagnostics.`
         return null;
       }
     };
+    init_state_store();
+    init_recent_activity();
+    init_mesh_events_utils();
+    var cliAgentHandlers = {
+      launch_cli: async (ctx, args) => {
+        const launchResult = await ctx.deps.cliManager.handleCliCommand("launch_cli", args);
+        const meshNodeId = readStringValue(args?.settings?.meshNodeId);
+        const meshId = readStringValue(args?.settings?.meshNodeFor);
+        if (meshNodeId && meshId && launchResult?.success !== false) {
+          try {
+            const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            const meshObj = getMesh2(meshId) ?? ctx.getCachedInlineMesh(meshId);
+            const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => meshNodeIdMatches(n, meshNodeId)) : void 0;
+            const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
+            if (bootstrapStatus === "running") {
+              return { success: true, ...launchResult, bootstrapPending: true };
+            }
+          } catch {
+          }
+        }
+        return launchResult;
+      },
+      stop_cli: async (ctx, args) => {
+        return ctx.deps.cliManager.handleCliCommand("stop_cli", args);
+      },
+      set_cli_view_mode: async (ctx, args) => {
+        return ctx.deps.cliManager.handleCliCommand("set_cli_view_mode", args);
+      },
+      record_provider_pty: async (ctx, args) => {
+        return ctx.deps.cliManager.handleCliCommand("record_provider_pty", args);
+      },
+      agent_command: async (ctx, args) => {
+        {
+          const dispatchSessionId = readStringValue(args?.targetSessionId, args?.sessionId, args?.instanceId);
+          const dispatchMeshContext = args?.meshContext;
+          if (dispatchSessionId && dispatchMeshContext) {
+            try {
+              const inst = ctx.deps.instanceManager.getInstance(dispatchSessionId);
+              if (inst && typeof inst.updateSettings === "function") {
+                const stamp = buildMeshWorkerRelayStamp(
+                  inst.getState?.()?.settings,
+                  {
+                    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 {
+            }
+          }
+        }
+        const agentResult = await ctx.deps.cliManager.handleCliCommand("agent_command", args);
+        const meshCtx = args?.meshContext;
+        const dispatchNodeId = readStringValue(meshCtx?.nodeId);
+        const dispatchMeshId = readStringValue(meshCtx?.meshId);
+        if (dispatchNodeId && dispatchMeshId && agentResult?.success !== false) {
+          try {
+            const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            const meshObj = getMesh2(dispatchMeshId) ?? ctx.getCachedInlineMesh(dispatchMeshId);
+            const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => meshNodeIdMatches(n, dispatchNodeId)) : void 0;
+            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 {
+          }
+        }
+        return agentResult;
+      },
+      // ─── Logs ───
+      list_saved_sessions: async (ctx, args) => {
+        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 = ctx.deps.providerLoader.resolve?.(providerType) || ctx.deps.providerLoader.getMeta(providerType);
+        const { sessions: historySessions, hasMore, source } = listProviderHistorySessions(providerType, {
+          canonicalHistory: providerMeta?.nativeHistory,
+          offset,
+          limit,
+          historyBehavior: providerMeta?.historyBehavior,
+          scripts: providerMeta?.scripts
+        });
+        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 : void 0);
+            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 ───
+      restart_session: async (ctx, args) => {
+        const targetType = args?.cliType || args?.agentType || args?.ideType;
+        if (!targetType) throw new Error("cliType or ideType required");
+        const isIde = ctx.deps.cdpManagers.has(targetType) || ctx.deps.providerLoader.getMeta(targetType)?.category === "ide";
+        if (isIde) {
+          await ctx.stopIde(targetType, true);
+          const launchResult = await ctx.launchIde({ ideType: targetType, enableCdp: true, workspace: args?.workspace });
+          return { success: true, restarted: true, ideType: targetType, launch: launchResult };
+        }
+        return ctx.deps.cliManager.handleCliCommand("restart_session", args);
+      }
+    };
     var import_child_process9 = require("child_process");
     var net3 = __toESM2(require("net"));
     var os26 = __toESM2(require("os"));
@@ -75528,6 +75659,1320 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_workspaces();
     init_recent_activity();
     init_cli_detector();
+    init_logger();
+    async function launchIde(ctx, args) {
+      const ideKey = args?.ideId || args?.ideType;
+      const resolvedWorkspace = resolveIdeLaunchWorkspace(
+        {
+          workspace: args?.workspace,
+          workspaceId: args?.workspaceId,
+          useDefaultWorkspace: args?.useDefaultWorkspace
+        },
+        loadConfig2()
+      );
+      const launchArgs = {
+        ideId: ideKey,
+        workspace: resolvedWorkspace,
+        newWindow: args?.newWindow
+      };
+      LOG2.info("LaunchIDE", `target=${ideKey || "auto"}`);
+      const result = await launchWithCdp(launchArgs);
+      if (result.success && result.port && result.ideId && !ctx.deps.cdpManagers.has(result.ideId)) {
+        const logFn = ctx.deps.getCdpLogFn ? ctx.deps.getCdpLogFn(result.ideId) : LOG2.forComponent(`CDP:${result.ideId}`).asLogFn();
+        const provider = ctx.deps.providerLoader.getMeta(result.ideId);
+        const manager = new DaemonCdpManager(result.port, logFn, void 0, provider?.targetFilter);
+        const connected = await manager.connect();
+        if (connected) {
+          registerExtensionProviders(ctx.deps.providerLoader, manager, result.ideId);
+          ctx.deps.cdpManagers.set(result.ideId, manager);
+          LOG2.info("CDP", `Connected: ${result.ideId} (port ${result.port})`);
+          LOG2.info("CDP", `${ctx.deps.cdpManagers.size} IDE(s) connected`);
+          ctx.deps.onCdpManagerCreated?.(result.ideId, manager);
+        }
+      }
+      ctx.deps.onIdeConnected?.();
+      try {
+        const results = await detectIDEs(ctx.deps.providerLoader);
+        ctx.deps.detectedIdes.value = results;
+        ctx.deps.providerLoader.setIdeDetectionResults(results, true);
+      } catch {
+      }
+      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 {
+        }
+      } 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 {
+        }
+      }
+      return { ...result };
+    }
+    var ideHandlers = {
+      // ─── IDE stop ───
+      stop_ide: async (ctx, args) => {
+        const ideType = args?.ideType;
+        if (!ideType) throw new Error("ideType required");
+        const killProcess = args?.killProcess !== false;
+        await ctx.stopIde(ideType, killProcess);
+        try {
+          const results = await detectIDEs(ctx.deps.providerLoader);
+          ctx.deps.detectedIdes.value = results;
+          ctx.deps.providerLoader.setIdeDetectionResults(results, true);
+        } catch {
+        }
+        return { success: true, ideType, stopped: true, processKilled: killProcess };
+      },
+      // ─── IDE restart ───
+      restart_ide: async (ctx, args) => {
+        const ideType = args?.ideType;
+        if (!ideType) throw new Error("ideType required");
+        await ctx.stopIde(ideType, true);
+        const launchResult = await ctx.launchIde({ ideType, enableCdp: true, workspace: args?.workspace });
+        return { success: true, ideType, restarted: true, launch: launchResult };
+      },
+      // ─── IDE launch + CDP connect ───
+      launch_ide: async (ctx, args) => {
+        return launchIde(ctx, args);
+      },
+      // ─── Detect providers ───
+      detect_provider: async (ctx, args) => {
+        const providerType = typeof args?.providerType === "string" ? args.providerType.trim() : "";
+        if (!providerType) return { success: false, error: "providerType is required" };
+        const normalizedType = ctx.deps.providerLoader.resolveAlias(providerType);
+        const provider = ctx.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 (!ctx.deps.providerLoader.isMachineProviderEnabled(normalizedType)) {
+          return { success: false, error: `Provider is disabled on this machine: ${providerType}` };
+        }
+        const detected = await detectCLI(normalizedType, ctx.deps.providerLoader, { includeVersion: false });
+        ctx.deps.providerLoader.setCliDetectionResults([{
+          id: normalizedType,
+          installed: !!detected,
+          path: detected?.path
+        }], false);
+        ctx.deps.onStatusChange?.();
+        return {
+          success: true,
+          providerType: normalizedType,
+          detected: !!detected,
+          path: detected?.path || null
+        };
+      },
+      // ─── Detect IDEs ───
+      detect_ides: async (ctx, _args) => {
+        const results = await detectIDEs(ctx.deps.providerLoader);
+        ctx.deps.detectedIdes.value = results;
+        ctx.deps.providerLoader.setIdeDetectionResults(results, true);
+        return { success: true, detectedInfo: results };
+      }
+    };
+    init_dist();
+    init_mesh_host_ownership();
+    init_mesh_events();
+    init_config();
+    var meshCrudHandlers = {
+      list_meshes: async (_ctx, _args) => {
+        try {
+          const { listMeshes: listMeshes2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          return { success: true, meshes: listMeshes2() };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      get_mesh: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+        if (!meshRecord?.mesh) return { success: false, error: "Mesh not found" };
+        const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+        const probeRemotePeers = args?.refresh === true || args?.forceRefresh === true;
+        const directTruth = await hydrateInlineMeshDirectTruth({
+          mesh: meshRecord.mesh,
+          meshSource: meshRecord.source,
+          dispatchMeshCommand: ctx.deps.dispatchMeshCommand,
+          getMeshPeerConnectionStatus: ctx.deps.getMeshPeerConnectionStatus,
+          statusInstanceId: ctx.deps.statusInstanceId,
+          localMachineId: loadConfig2().machineId || "",
+          probeRemotePeers,
+          probeCache: ctx.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 };
+      },
+      create_mesh: async (_ctx, args) => {
+        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() : void 0;
+        const defaultBranch = typeof args?.defaultBranch === "string" ? args.defaultBranch.trim() : void 0;
+        if (!name) return { success: false, error: "name required" };
+        try {
+          const { createMesh: createMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const meshHost = args?.meshHost && typeof args.meshHost === "object" && !Array.isArray(args.meshHost) ? args.meshHost : void 0;
+          const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy, meshHost });
+          return { success: true, mesh };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      update_mesh: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { updateMesh: updateMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const patch = {};
+          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 = updateMesh2(meshId, patch);
+          if (!mesh) return { success: false, error: "Mesh not found" };
+          ctx.inlineMeshCache.set(meshId, mesh);
+          ctx.invalidateAggregateMeshStatus(meshId);
+          return { success: true, mesh };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      delete_mesh: async (_ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { deleteMesh: deleteMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const deleted = deleteMesh2(meshId);
+          return { success: true, deleted };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      add_mesh_node: async (ctx, args) => {
+        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 ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node addition");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const { addNode: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const providerPriority = Array.isArray(args?.providerPriority) ? args.providerPriority.map((type) => 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() : void 0;
+          const machineId = typeof args?.machineId === "string" && args.machineId.trim() ? args.machineId.trim() : void 0;
+          const repoRoot = typeof args?.repoRoot === "string" && args.repoRoot.trim() ? args.repoRoot.trim() : void 0;
+          const node = addNode2(meshId, {
+            workspace,
+            ...repoRoot ? { repoRoot } : {},
+            ...daemonId ? { daemonId } : {},
+            ...machineId ? { machineId } : {},
+            ...policy ? { policy } : {},
+            ...role ? { role } : {}
+          });
+          if (!node) return { success: false, error: "Mesh not found" };
+          ctx.invalidateAggregateMeshStatus(meshId);
+          return { success: true, node };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      update_mesh_node: async (ctx, args) => {
+        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 ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node update");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const policy = args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy) ? { ...args.policy } : {};
+          if (Array.isArray(args?.providerPriority)) {
+            const providerPriority = args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean);
+            delete policy.provider_priority;
+            if (providerPriority.length) {
+              policy.providerPriority = providerPriority;
+            } else {
+              delete policy.providerPriority;
+            }
+          }
+          if (Array.isArray(args?.providerRoles)) {
+            const providerRoles = normalizeProviderRoles(args.providerRoles);
+            if (providerRoles.length) {
+              policy.providerRoles = providerRoles;
+            } else {
+              delete policy.providerRoles;
+            }
+          }
+          const patch = { policy };
+          if (typeof args?.systemPrompt === "string") {
+            const trimmed = args.systemPrompt.trim();
+            patch.systemPrompt = trimmed || void 0;
+          } else if (args?.systemPrompt === null) {
+            patch.systemPrompt = void 0;
+          }
+          const node = updateNode2(meshId, nodeId, patch);
+          if (!node) return { success: false, error: "Mesh node not found" };
+          ctx.invalidateAggregateMeshStatus(meshId);
+          return { success: true, node };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      cleanup_mesh_sessions: async (ctx, args) => {
+        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 ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node removal");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const meshRecord = await ctx.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) => meshNodeIdMatches(n, nodeId));
+          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
+          const mode = ctx.normalizeMeshSessionCleanupMode(args?.mode ?? mesh?.policy?.sessionCleanupOnNodeRemove);
+          const sessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.map((id) => typeof id === "string" ? id.trim() : "").filter(Boolean) : void 0;
+          const result = await ctx.cleanupMeshSessions({
+            meshId,
+            nodeId,
+            node,
+            mode,
+            sessionIds,
+            dryRun: args?.dryRun === true,
+            source: "mesh_cleanup_sessions"
+          });
+          return result;
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      remove_mesh_node: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        try {
+          const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const mesh = meshRecord?.mesh;
+          const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          if (node && !args?._meshDirectDispatch && node.isLocalWorktree !== true && args?.force !== true) {
+            const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : "";
+            const nodeMachineId = readMeshNodeMachineId(node) || "";
+            const selfDaemonId = ctx.deps.statusInstanceId || "";
+            const selfMachineId = (() => {
+              try {
+                return loadConfig2().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 = ctx.normalizeMeshSessionCleanupMode(
+            args?.sessionCleanupMode ?? args?.session_cleanup_mode ?? mesh?.policy?.sessionCleanupOnNodeRemove
+          );
+          const explicitSessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
+          let sessionCleanup;
+          if (node && sessionCleanupMode !== "preserve") {
+            sessionCleanup = await ctx.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;
+          if (node?.isLocalWorktree) {
+            const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
+            const isRemoteWorktree = nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, ctx.deps.statusInstanceId) && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch;
+            if (isRemoteWorktree) {
+              const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "remove_mesh_node", {
+                ...typeof args === "object" && args !== null ? args : {},
+                _meshDirectDispatch: true
+              });
+              return forwarded ?? { success: false, error: "no response from remote node" };
+            }
+            const cleanupResult = await ctx.cleanupLocalWorktreeNode({ mesh, node, nodeId, force: args?.force === true });
+            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 = ctx.removeInlineMeshNode(meshId, mesh, nodeId);
+            if (removed) ctx.invalidateAggregateMeshStatus(meshId);
+            if (!removed && !node) removed = true;
+          } else {
+            const { removeNode: removeNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            removed = removeNode2(meshId, nodeId);
+            if (!removed && !node) removed = true;
+            if (removed) ctx.invalidateAggregateMeshStatus(meshId);
+          }
+          if (removed) {
+            try {
+              const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+              appendLedgerEntry2(meshId, {
+                kind: "node_removed",
+                nodeId,
+                payload: {
+                  worktree: !!node?.isLocalWorktree,
+                  sessionCleanupMode,
+                  workspace: typeof node?.workspace === "string" ? node.workspace : void 0,
+                  daemonId: typeof node?.daemonId === "string" ? node.daemonId : void 0,
+                  worktreeBranch: typeof node?.worktreeBranch === "string" ? node.worktreeBranch : void 0,
+                  worktreeCleanupFallback: typeof worktreeCleanup?.fallback === "string" ? worktreeCleanup.fallback : void 0,
+                  forced: worktreeCleanup?.forced === true ? true : void 0,
+                  forceFallbackReason: typeof worktreeCleanup?.reason === "string" ? worktreeCleanup.reason : void 0
+                }
+              });
+            } catch {
+            }
+          }
+          const residueWarning = worktreeCleanup?.residue === true && typeof worktreeCleanup?.residueWarning === "string" ? worktreeCleanup.residueWarning : void 0;
+          return {
+            success: true,
+            removed,
+            ...residueWarning ? { residueWarning } : {},
+            ...sessionCleanup ? { sessionCleanup } : {},
+            ...worktreeCleanup ? { worktreeCleanup } : {}
+          };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      clone_mesh_node: async (ctx, args) => {
+        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() : void 0;
+        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 ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "worktree clone");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const meshRecord = await ctx.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) => meshNodeIdMatches(n, sourceNodeId));
+          if (!sourceNode) return { success: false, error: `Source node '${sourceNodeId}' not found in mesh` };
+          const sourceDaemonId = typeof sourceNode.daemonId === "string" ? sourceNode.daemonId.trim() : void 0;
+          if (sourceDaemonId && !daemonIdsEquivalent(sourceDaemonId, ctx.deps.statusInstanceId) && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+            const forwarded = await ctx.deps.dispatchMeshCommand(sourceDaemonId, "clone_mesh_node", {
+              ...typeof args === "object" && args !== null ? args : {},
+              _meshDirectDispatch: true
+            });
+            return forwarded ?? { success: false, error: "no response from remote node" };
+          }
+          const repoRoot = sourceNode.repoRoot || sourceNode.workspace;
+          const { createWorktree: createWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
+          const result = await createWorktree2({
+            repoRoot,
+            branch,
+            baseBranch,
+            meshName: mesh.name
+          });
+          let node;
+          if (meshRecord.inline) {
+            const { randomUUID: randomUUID15 } = await import("crypto");
+            node = {
+              id: `node_${randomUUID15().replace(/-/g, "")}`,
+              workspace: result.worktreePath,
+              repoRoot: result.worktreePath,
+              daemonId: sourceNode.daemonId,
+              machineId: sourceNode.machineId ?? sourceNode.machine_id,
+              userOverrides: { ...sourceNode.userOverrides || {} },
+              policy: { ...sourceNode.policy || {} },
+              isLocalWorktree: true,
+              worktreeBranch: result.branch,
+              clonedFromNodeId: sourceNodeId
+            };
+            ctx.updateInlineMeshNode(meshId, mesh, node);
+          } else {
+            const { addNode: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            node = addNode2(meshId, {
+              workspace: result.worktreePath,
+              repoRoot: result.worktreePath,
+              daemonId: sourceNode.daemonId,
+              machineId: sourceNode.machineId ?? sourceNode.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" };
+            const inlineForReconcile = ctx.getCachedInlineMesh(meshId);
+            if (inlineForReconcile) ctx.updateInlineMeshNode(meshId, inlineForReconcile, node);
+            ctx.invalidateAggregateMeshStatus(meshId);
+          }
+          const persistWorktreeSetupState = async (bootstrapState2) => {
+            node.worktreeBootstrap = bootstrapState2;
+            if (meshRecord.inline) {
+              ctx.updateInlineMeshNode(meshId, mesh, node);
+              return;
+            }
+            try {
+              const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              updateNode2(meshId, node.id, { worktreeBootstrap: bootstrapState2 });
+              ctx.invalidateAggregateMeshStatus(meshId);
+            } catch {
+            }
+          };
+          const appendCloneLedger = async (initSubmodules2, bootstrapState2) => {
+            try {
+              const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+              appendLedgerEntry2(meshId, {
+                kind: "node_cloned",
+                nodeId: node.id,
+                payload: {
+                  sourceNodeId,
+                  branch: result.branch,
+                  worktreePath: result.worktreePath,
+                  submodulesInitialized: initSubmodules2,
+                  worktreeBootstrap: {
+                    status: bootstrapState2.status,
+                    required: bootstrapState2.required,
+                    configSource: bootstrapState2.configSource,
+                    configSourceType: bootstrapState2.configSourceType,
+                    lastCommand: bootstrapState2.lastCommand,
+                    exitCode: bootstrapState2.exitCode
+                  }
+                }
+              });
+            } catch {
+            }
+          };
+          const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
+          const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, result.worktreePath);
+          const runningBootstrapState = {
+            status: "running",
+            required: loadedBootstrap.config?.required !== false,
+            configSource: loadedBootstrap.path || loadedBootstrap.source,
+            configSourceType: loadedBootstrap.sourceType,
+            startedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          await persistWorktreeSetupState(runningBootstrapState);
+          const finishWorktreeSetup = async () => {
+            let submodulesInitialized2 = false;
+            if (initSubmodules) {
+              try {
+                const { runGit: runGit3 } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
+                await runGit3(
+                  { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
+                  ["submodule", "update", "--init", "--recursive"],
+                  { timeoutMs: 12e4 }
+                );
+                submodulesInitialized2 = true;
+                const sourceWorkspace = sourceNode.repoRoot || sourceNode.workspace;
+                if (sourceWorkspace) {
+                  try {
+                    const { runGit: rg } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
+                    const sourceCtx = { workspace: sourceWorkspace, repoRoot: sourceWorkspace, isGitRepo: true };
+                    const worktreeCtx = { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true };
+                    const sourceStatusOut = await rg(sourceCtx, ["submodule", "status", "oss"], { timeoutMs: 1e4 });
+                    const sourceStatusLine = (typeof sourceStatusOut === "string" ? sourceStatusOut : sourceStatusOut?.stdout ?? "").trim();
+                    const sourceShaMatch = sourceStatusLine.match(/^[+\- ]?([0-9a-f]{40})/);
+                    const sourceSha = sourceShaMatch?.[1];
+                    if (sourceSha) {
+                      const ossCtx = { workspace: `${result.worktreePath}/oss`, repoRoot: `${result.worktreePath}/oss`, isGitRepo: true };
+                      const worktreeOssHeadOut = await rg(ossCtx, ["rev-parse", "HEAD"], { timeoutMs: 1e4 });
+                      const worktreeOssSha = (typeof worktreeOssHeadOut === "string" ? worktreeOssHeadOut : worktreeOssHeadOut?.stdout ?? "").trim();
+                      if (worktreeOssSha !== sourceSha) {
+                        await rg(ossCtx, ["fetch", `${sourceWorkspace}/oss`, "HEAD"], { timeoutMs: 6e4 });
+                        await rg(ossCtx, ["checkout", sourceSha], { timeoutMs: 1e4 });
+                        await rg(worktreeCtx, ["add", "oss"], { timeoutMs: 1e4 });
+                        await rg(worktreeCtx, ["commit", "-m", "chore: sync oss to source node HEAD on clone"], { timeoutMs: 1e4 });
+                        console.log(`[mesh] Synced oss submodule to source HEAD ${sourceSha.slice(0, 8)} in worktree`);
+                      }
+                    }
+                  } catch (ossErr) {
+                    console.warn("[mesh] oss submodule sync to source HEAD failed (best-effort):", ossErr.message);
+                  }
+                }
+              } catch (subErr) {
+                console.warn("[mesh] Submodule init failed for worktree:", subErr.message);
+              }
+            }
+            const bootstrapState2 = await runMeshWorktreeBootstrap(mesh, result.worktreePath);
+            await persistWorktreeSetupState(bootstrapState2);
+            await appendCloneLedger(submodulesInitialized2, bootstrapState2);
+            return { submodulesInitialized: submodulesInitialized2, bootstrapState: bootstrapState2 };
+          };
+          const requestedSetupWaitMs = Number(args?.setupWaitMs ?? args?.bootstrapWaitMs ?? 8e3);
+          const setupWaitMs = Number.isFinite(requestedSetupWaitMs) ? Math.min(Math.max(requestedSetupWaitMs, 0), 14e3) : 8e3;
+          const setupPromise = finishWorktreeSetup();
+          const setupResult = await Promise.race([
+            setupPromise.then((value) => ({ completed: true, value })),
+            new Promise((resolve24) => setTimeout(() => resolve24({ completed: false }), setupWaitMs))
+          ]);
+          const emitBootstrapEvent = (eventStatus2, bootstrapState2, startedAtMs, extraPayload) => {
+            try {
+              const durationMs = Date.now() - startedAtMs;
+              const event = `worktree_${eventStatus2}`;
+              const metadataEvent = {
+                source: "clone_mesh_node_bootstrap",
+                nodeId: node.id,
+                status: eventStatus2,
+                worktreePath: result.worktreePath,
+                durationMs,
+                bootstrapStatus: bootstrapState2.status,
+                ...bootstrapState2.error ? { error: bootstrapState2.error } : {},
+                ...bootstrapState2.exitCode !== void 0 ? { exitCode: bootstrapState2.exitCode } : {},
+                ...extraPayload || {}
+              };
+              if (typeof ctx.deps.instanceManager?.getByCategory === "function") {
+                const forwarded = handleMeshForwardEvent(
+                  { instanceManager: ctx.deps.instanceManager },
+                  { 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 {
+            }
+          };
+          const bootstrapStartedMs = Date.now();
+          if (!setupResult.completed) {
+            setupPromise.then(({ bootstrapState: bootstrapState2 }) => {
+              emitBootstrapEvent("bootstrap_complete", bootstrapState2, bootstrapStartedMs);
+            }).catch((error48) => {
+              const failedState = {
+                ...runningBootstrapState,
+                status: "failed",
+                completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                error: error48?.message || String(error48)
+              };
+              void persistWorktreeSetupState(failedState);
+              void appendCloneLedger(false, failedState);
+              emitBootstrapEvent("bootstrap_failed", failedState, bootstrapStartedMs, { error: error48?.message || String(error48) });
+            });
+            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) {
+          return { success: false, error: e.message };
+        }
+      },
+      retry_mesh_node_bootstrap: async (ctx, args) => {
+        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 ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "bootstrap retry");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const meshRecord = await ctx.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) => 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" };
+          const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
+          if (nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, ctx.deps.statusInstanceId) && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+            const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "retry_mesh_node_bootstrap", {
+              ...typeof args === "object" && args !== null ? args : {},
+              _meshDirectDispatch: true
+            });
+            return forwarded ?? { success: false, error: "no response from remote node" };
+          }
+          const currentBootstrap = node.worktreeBootstrap;
+          if (currentBootstrap?.status === "running") {
+            return { success: false, error: "Bootstrap is already running for this node" };
+          }
+          const worktreePath = node.workspace || node.repoRoot;
+          if (!worktreePath) return { success: false, error: "Node has no workspace path" };
+          const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, worktreePath);
+          const runningState = {
+            status: "running",
+            required: loadedBootstrap.config?.required !== false,
+            configSource: loadedBootstrap.path || loadedBootstrap.source,
+            configSourceType: loadedBootstrap.sourceType,
+            startedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          const persistState = async (bootstrapState2) => {
+            node.worktreeBootstrap = bootstrapState2;
+            if (meshRecord.inline) {
+              ctx.updateInlineMeshNode(meshId, mesh, node);
+              return;
+            }
+            try {
+              const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              updateNode2(meshId, node.id, { worktreeBootstrap: bootstrapState2 });
+              ctx.invalidateAggregateMeshStatus(meshId);
+            } catch {
+            }
+          };
+          await persistState(runningState);
+          const bootstrapState = await runMeshWorktreeBootstrap(mesh, worktreePath);
+          await persistState(bootstrapState);
+          return { success: true, bootstrapState };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
+    };
+    init_mesh_host_ownership();
+    var meshHostPairingHandlers = {
+      get_mesh_host_pairing: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        const meshRecord = await ctx.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."
+          }
+        };
+      },
+      configure_mesh_host_pairing: async (ctx, args) => {
+        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: configureMeshHostPairing2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const configured = configureMeshHostPairing2(meshId, { hostAddress, token });
+          if (!configured) return { success: false, error: "Mesh not found" };
+          ctx.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) {
+          return { success: false, code: "mesh_host_pairing_invalid", meshId, hostAddress, error: e.message };
+        }
+      },
+      create_mesh_host_pairing_token: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { createMeshHostPairingToken: createMeshHostPairingToken2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const created = createMeshHostPairingToken2(meshId, {
+            token: typeof args?.token === "string" ? args.token : void 0,
+            expiresAt: typeof args?.expiresAt === "string" ? args.expiresAt : void 0
+          });
+          if (!created) return { success: false, error: "Mesh not found" };
+          ctx.inlineMeshCache.set(meshId, created.mesh);
+          ctx.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) {
+          return { success: false, code: "mesh_host_pairing_token_invalid", meshId, error: e.message };
+        }
+      },
+      apply_mesh_host_join: async (ctx, args) => {
+        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: applyMeshHostJoinRequest2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const applied = applyMeshHostJoinRequest2(meshId, {
+            token,
+            memberNode,
+            memberMeshId: typeof args?.memberMeshId === "string" ? args.memberMeshId : void 0
+          });
+          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 }) : void 0,
+              error: applied.reason
+            };
+          }
+          ctx.inlineMeshCache.set(meshId, applied.mesh);
+          ctx.invalidateAggregateMeshStatus(meshId);
+          try {
+            const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+            appendLedgerEntry2(meshId, {
+              kind: "node_joined",
+              nodeId: applied.node.id,
+              payload: { role: "member", tokenId: applied.tokenId, workspace: applied.node.workspace }
+            });
+          } catch {
+          }
+          return {
+            success: true,
+            code: "mesh_host_join_accepted",
+            meshId,
+            node: applied.node,
+            tokenId: applied.tokenId,
+            meshHost: resolveMeshHostStatus(applied.mesh)
+          };
+        } catch (e) {
+          return { success: false, code: "mesh_host_join_failed", meshId, error: e.message };
+        }
+      },
+      join_mesh_host_pairing: async (ctx, args) => {
+        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 ctx.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: tokenIdForManualPairing2, markMeshHostPairingJoined: markMeshHostPairingJoined2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const tokenId = tokenIdForManualPairing2(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, ctx.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;
+          let transport;
+          if (hostDaemonId && ctx.deps.dispatchMeshCommand) {
+            transport = "mesh_command_dispatch";
+            hostResult = await ctx.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 : markMeshHostPairingJoined2(meshId, {
+            tokenId: hostResult.tokenId || tokenId,
+            hostDaemonId: hostResult.meshHost?.hostDaemonId || hostDaemonId,
+            hostNodeId: hostResult.meshHost?.hostNodeId,
+            joinedAt: hostResult.meshHost?.pairing?.joinedAt
+          });
+          if (joined) {
+            ctx.inlineMeshCache.set(meshId, joined.mesh);
+            ctx.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) {
+          return { success: false, code: "mesh_host_join_failed", meshId, meshHost, error: e.message };
+        }
+      }
+    };
+    var meshQueueHandlers = {
+      get_mesh_queue: async (_ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2, describeTaskDependencyState: describeTaskDependencyState2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
+          const status = Array.isArray(args?.status) ? args.status.map((s2) => typeof s2 === "string" ? s2.trim() : "").filter(Boolean) : void 0;
+          const rawQueue = getQueue2(meshId, { status });
+          const statusById = new Map(getQueue2(meshId).map((task) => [task.id, task.status]));
+          const queue = rawQueue.map((task) => Array.isArray(task.dependsOn) && task.dependsOn.length > 0 ? { ...task, ...describeTaskDependencyState2(task, statusById) } : task);
+          const summary = getMeshQueueStats2(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) {
+          return { success: false, error: e.message };
+        }
+      },
+      cancel_mesh_queue_task: async (ctx, args) => {
+        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 ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "queue cancellation");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const { cancelTask: cancelTask2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
+          const reason = typeof args?.reason === "string" ? args.reason : void 0;
+          const task = cancelTask2(meshId, taskId, { reason });
+          if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
+          return { success: true, task };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      requeue_mesh_queue_task: async (ctx, args) => {
+        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 ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "queue requeue");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const { requeueTask: requeueTask2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
+          const task = requeueTask2(meshId, taskId, {
+            reason: typeof args?.reason === "string" ? args.reason : void 0,
+            targetNodeId: typeof args?.targetNodeId === "string" ? args.targetNodeId.trim() : void 0,
+            targetSessionId: typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : void 0,
+            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) {
+          return { success: false, error: e.message };
+        }
+      },
+      trigger_mesh_queue: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "queue trigger");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const { triggerMeshQueue: triggerMeshQueue2, tryAssignQueueTask: tryAssignQueueTask2 } = await Promise.resolve().then(() => (init_mesh_events(), mesh_events_exports));
+          const preferredNodeId = typeof args?.preferredNodeId === "string" ? args.preferredNodeId.trim() : "";
+          if (preferredNodeId) {
+            const cliInstances = ctx.deps.instanceManager.getByCategory("cli");
+            const sorted = [...cliInstances].sort((a, b) => {
+              const aSettings = a.getState().settings || {};
+              const bSettings = b.getState().settings || {};
+              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 || {};
+              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) {
+                tryAssignQueueTask2(ctx.deps, meshId, nodeId, sessionId, providerType);
+                break;
+              }
+            }
+          }
+          const trigger = await triggerMeshQueue2(ctx.deps, meshId);
+          return { success: true, trigger };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
+    };
+    init_dist();
+    init_mesh_fast_forward();
+    var import_fs16 = require("fs");
+    var import_path11 = require("path");
+    var MESH_INIT_REFINE_CONFIG_PATH = MESH_REFINE_CONFIG_LOCATIONS[0];
+    var MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH = MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS[0];
+    var CANDIDATE_STALE_INPUTS = [
+      "package-lock.json",
+      "pnpm-lock.yaml",
+      "yarn.lock",
+      "bun.lockb",
+      "Cargo.lock",
+      "go.sum",
+      "poetry.lock",
+      "requirements.txt"
+    ];
+    function writeConfigFile(workspace, relativePath, config2) {
+      const target = (0, import_path11.join)(workspace, relativePath);
+      (0, import_fs16.mkdirSync)((0, import_path11.dirname)(target), { recursive: true });
+      (0, import_fs16.writeFileSync)(target, `${JSON.stringify(config2, null, 2)}
+`, "utf-8");
+      return target;
+    }
+    function suggestMeshWorktreeBootstrapConfig(workspace) {
+      const commands = [];
+      const hasPackageJson = (0, import_fs16.existsSync)((0, import_path11.join)(workspace, "package.json"));
+      const hasNpmLock = (0, import_fs16.existsSync)((0, import_path11.join)(workspace, "package-lock.json"));
+      if (hasPackageJson) {
+        commands.push(
+          hasNpmLock ? { command: "npm", args: ["ci"] } : { command: "npm", args: ["install"] }
+        );
+      }
+      const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative5) => (0, import_fs16.existsSync)((0, import_path11.join)(workspace, relative5)));
+      if (!commands.length) {
+        return { commands, staleInputs };
+      }
+      return {
+        commands,
+        staleInputs,
+        suggestedConfig: {
+          version: 1,
+          enabled: true,
+          runOnClone: true,
+          required: false,
+          commands,
+          ...staleInputs.length ? { staleInputs } : {}
+        }
+      };
+    }
+    var PROVIDER_PRIORITY_PREFERENCE = ["claude-cli", "codex-cli", "gemini-cli"];
+    function suggestNodeProviderPriority(detected) {
+      const installed = detected.filter((cli) => cli.installed);
+      const installedIds = installed.map((cli) => cli.id);
+      const preferred = PROVIDER_PRIORITY_PREFERENCE.filter((id) => installedIds.includes(id));
+      const rest = installedIds.filter((id) => !preferred.includes(id));
+      const providerPriority = [...preferred, ...rest];
+      return {
+        providerPriority,
+        installedProviders: installed.map((cli) => ({
+          id: cli.id,
+          displayName: cli.displayName,
+          ...cli.version ? { version: cli.version } : {}
+        }))
+      };
+    }
+    function runMeshInit(mesh, workspace, detected, options = {}) {
+      const write = options.write === true;
+      const overwrite = options.overwrite === true;
+      const refine2 = applyConfigSuggestion({
+        workspace,
+        relativePath: MESH_INIT_REFINE_CONFIG_PATH,
+        existing: loadMeshRefineConfig(mesh, workspace).config,
+        suggestedConfig: suggestMeshRefineConfig(mesh, workspace).suggestedConfig,
+        validate: (config2) => validateMeshRefineConfig(config2, MESH_INIT_REFINE_CONFIG_PATH).valid,
+        write,
+        overwrite
+      });
+      const bootstrapSuggestion = suggestMeshWorktreeBootstrapConfig(workspace);
+      const worktreeBootstrap = applyConfigSuggestion({
+        workspace,
+        relativePath: MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH,
+        existing: loadMeshWorktreeBootstrapConfig(mesh, workspace).config,
+        suggestedConfig: bootstrapSuggestion.suggestedConfig,
+        validate: (config2) => validateMeshWorktreeBootstrapConfig(config2, MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH).valid,
+        write,
+        overwrite
+      });
+      const providers = suggestNodeProviderPriority(detected);
+      return {
+        success: true,
+        workspace,
+        dryRun: !write,
+        refine: refine2,
+        worktreeBootstrap,
+        providers,
+        note: write ? "Configs written to disk are the execution source of truth; suggestions are scaffold and only take effect once saved. providerPriority is a recommendation \u2014 apply it to node policy via clone/policy update." : "Dry-run: no files written. Re-run with write=true to persist the suggested configs. Heuristic suggestions never execute until saved as repo config."
+      };
+    }
+    function applyConfigSuggestion(input) {
+      const { workspace, relativePath, existing, suggestedConfig, validate, write, overwrite } = input;
+      const absolute = (0, import_path11.join)(workspace, relativePath);
+      if (existing !== void 0 && !overwrite) {
+        return { path: absolute, relativePath, written: false, skippedReason: "already_exists", config: existing };
+      }
+      if (!suggestedConfig || !validate(suggestedConfig)) {
+        return { path: absolute, relativePath, written: false, skippedReason: "no_suggestion" };
+      }
+      if (!write) {
+        return { path: absolute, relativePath, written: false, config: suggestedConfig };
+      }
+      const writtenPath = writeConfigFile(workspace, relativePath, suggestedConfig);
+      return { path: writtenPath, relativePath, written: true, config: suggestedConfig };
+    }
+    init_cli_detector();
+    var fastForwardHandlers = {
+      mesh_init: async (ctx, args) => {
+        const workspace = typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : process.cwd();
+        const mesh = args?.inlineMesh || {};
+        try {
+          const detected = await detectCLIs(ctx.deps.providerLoader, { includeVersion: true });
+          return { ...runMeshInit(mesh, workspace, detected, {
+            write: args?.write === true,
+            overwrite: args?.overwrite === true
+          }) };
+        } catch (e) {
+          return { success: false, error: e?.message || String(e) };
+        }
+      },
+      plan_mesh_refine_node: async (ctx, args) => {
+        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 meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+        const mesh = meshRecord?.mesh;
+        const node = mesh?.nodes?.find((n) => 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
+        };
+      },
+      fast_forward_mesh_node: async (ctx, args) => {
+        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) => typeof value === "string") : void 0;
+        let nodeDaemonId;
+        let allowAutoPublishSubmoduleMainCommits = false;
+        if (meshId && nodeId) {
+          const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const mesh = meshRecord?.mesh;
+          const node = mesh?.nodes?.find((n) => 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) => typeof value === "string");
+          }
+          allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
+          nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
+        }
+        const selfDaemonId = ctx.deps.statusInstanceId;
+        const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
+        if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+          const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "fast_forward_mesh_node", {
+            ...typeof args === "object" && args !== null ? args : {},
+            workspace,
+            _meshDirectDispatch: true
+          });
+          return forwarded ?? { success: false, error: "no response from remote node" };
+        }
+        const result = await fastForwardMeshNode({
+          meshId: meshId || void 0,
+          nodeId: nodeId || void 0,
+          workspace,
+          branch: typeof args?.branch === "string" ? args.branch : void 0,
+          execute: args?.execute === true,
+          dryRun: args?.dryRun === true,
+          updateSubmodules: args?.updateSubmodules === true,
+          submoduleIgnorePaths,
+          mode: args?.mode === "push" ? "push" : "merge",
+          pushSubmodules: args?.pushSubmodules === true,
+          allowAutoPublishSubmoduleMainCommits
+        });
+        return result;
+      },
+      refine_mesh_node: async (ctx, args) => {
+        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 meshRecordForForward = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const forwardNode = meshRecordForForward?.mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          const nodeDaemonId = typeof forwardNode?.daemonId === "string" ? forwardNode.daemonId.trim() : void 0;
+          const selfDaemonId = ctx.deps.statusInstanceId;
+          const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
+          if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+            const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
+            const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "refine_mesh_node", {
+              ...typeof args === "object" && args !== null ? args : {},
+              coordinatorDaemonId: callerCoordinatorDaemonId || selfDaemonId,
+              _meshDirectDispatch: true
+            });
+            return forwarded ?? { success: false, error: "no response from remote node" };
+          }
+        }
+        const isDryRun = args?.dryRun !== false && args?.execute !== true;
+        if (isDryRun) {
+          const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const mesh = meshRecord?.mesh;
+          const node = mesh?.nodes?.find((n) => 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 \u2014 no merge/push/cleanup performed. Re-invoke with execute:true to converge this node."
+          };
+        }
+        return ctx.startMeshRefineJob(meshId, nodeId, args);
+      },
+      batch_refine_mesh_nodes: async (ctx, args) => {
+        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.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
+        const isDryRun = args?.dryRun !== false && args?.execute !== true;
+        if (isDryRun) return ctx.batchRefineMeshNodes(meshId, requestedNodeIds, args);
+        return ctx.startMeshRefineBatchJob(meshId, requestedNodeIds, args);
+      }
+    };
+    var medFamilyRegistry = new Map(
+      Object.entries({
+        ...cliAgentHandlers,
+        ...ideHandlers,
+        ...meshCrudHandlers,
+        ...meshHostPairingHandlers,
+        ...meshQueueHandlers,
+        ...fastForwardHandlers
+      })
+    );
+    init_config();
+    init_cli_detector();
     init_git_status();
     init_dist();
     init_logger();
@@ -75679,9 +77124,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_coordinator_registry();
     init_mesh_events();
     init_mesh_routing();
-    init_mesh_events_utils();
     init_mesh_host_ownership();
-    init_mesh_fast_forward();
     var import_node_child_process4 = require("child_process");
     var import_node_util4 = require("util");
     var execFileAsync3 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
@@ -75848,117 +77291,6 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       };
     }
     init_mesh_refine_status();
-    var import_fs16 = require("fs");
-    var import_path11 = require("path");
-    var MESH_INIT_REFINE_CONFIG_PATH = MESH_REFINE_CONFIG_LOCATIONS[0];
-    var MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH = MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS[0];
-    var CANDIDATE_STALE_INPUTS = [
-      "package-lock.json",
-      "pnpm-lock.yaml",
-      "yarn.lock",
-      "bun.lockb",
-      "Cargo.lock",
-      "go.sum",
-      "poetry.lock",
-      "requirements.txt"
-    ];
-    function writeConfigFile(workspace, relativePath, config2) {
-      const target = (0, import_path11.join)(workspace, relativePath);
-      (0, import_fs16.mkdirSync)((0, import_path11.dirname)(target), { recursive: true });
-      (0, import_fs16.writeFileSync)(target, `${JSON.stringify(config2, null, 2)}
-`, "utf-8");
-      return target;
-    }
-    function suggestMeshWorktreeBootstrapConfig(workspace) {
-      const commands = [];
-      const hasPackageJson = (0, import_fs16.existsSync)((0, import_path11.join)(workspace, "package.json"));
-      const hasNpmLock = (0, import_fs16.existsSync)((0, import_path11.join)(workspace, "package-lock.json"));
-      if (hasPackageJson) {
-        commands.push(
-          hasNpmLock ? { command: "npm", args: ["ci"] } : { command: "npm", args: ["install"] }
-        );
-      }
-      const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative5) => (0, import_fs16.existsSync)((0, import_path11.join)(workspace, relative5)));
-      if (!commands.length) {
-        return { commands, staleInputs };
-      }
-      return {
-        commands,
-        staleInputs,
-        suggestedConfig: {
-          version: 1,
-          enabled: true,
-          runOnClone: true,
-          required: false,
-          commands,
-          ...staleInputs.length ? { staleInputs } : {}
-        }
-      };
-    }
-    var PROVIDER_PRIORITY_PREFERENCE = ["claude-cli", "codex-cli", "gemini-cli"];
-    function suggestNodeProviderPriority(detected) {
-      const installed = detected.filter((cli) => cli.installed);
-      const installedIds = installed.map((cli) => cli.id);
-      const preferred = PROVIDER_PRIORITY_PREFERENCE.filter((id) => installedIds.includes(id));
-      const rest = installedIds.filter((id) => !preferred.includes(id));
-      const providerPriority = [...preferred, ...rest];
-      return {
-        providerPriority,
-        installedProviders: installed.map((cli) => ({
-          id: cli.id,
-          displayName: cli.displayName,
-          ...cli.version ? { version: cli.version } : {}
-        }))
-      };
-    }
-    function runMeshInit(mesh, workspace, detected, options = {}) {
-      const write = options.write === true;
-      const overwrite = options.overwrite === true;
-      const refine2 = applyConfigSuggestion({
-        workspace,
-        relativePath: MESH_INIT_REFINE_CONFIG_PATH,
-        existing: loadMeshRefineConfig(mesh, workspace).config,
-        suggestedConfig: suggestMeshRefineConfig(mesh, workspace).suggestedConfig,
-        validate: (config2) => validateMeshRefineConfig(config2, MESH_INIT_REFINE_CONFIG_PATH).valid,
-        write,
-        overwrite
-      });
-      const bootstrapSuggestion = suggestMeshWorktreeBootstrapConfig(workspace);
-      const worktreeBootstrap = applyConfigSuggestion({
-        workspace,
-        relativePath: MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH,
-        existing: loadMeshWorktreeBootstrapConfig(mesh, workspace).config,
-        suggestedConfig: bootstrapSuggestion.suggestedConfig,
-        validate: (config2) => validateMeshWorktreeBootstrapConfig(config2, MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH).valid,
-        write,
-        overwrite
-      });
-      const providers = suggestNodeProviderPriority(detected);
-      return {
-        success: true,
-        workspace,
-        dryRun: !write,
-        refine: refine2,
-        worktreeBootstrap,
-        providers,
-        note: write ? "Configs written to disk are the execution source of truth; suggestions are scaffold and only take effect once saved. providerPriority is a recommendation \u2014 apply it to node policy via clone/policy update." : "Dry-run: no files written. Re-run with write=true to persist the suggested configs. Heuristic suggestions never execute until saved as repo config."
-      };
-    }
-    function applyConfigSuggestion(input) {
-      const { workspace, relativePath, existing, suggestedConfig, validate, write, overwrite } = input;
-      const absolute = (0, import_path11.join)(workspace, relativePath);
-      if (existing !== void 0 && !overwrite) {
-        return { path: absolute, relativePath, written: false, skippedReason: "already_exists", config: existing };
-      }
-      if (!suggestedConfig || !validate(suggestedConfig)) {
-        return { path: absolute, relativePath, written: false, skippedReason: "no_suggestion" };
-      }
-      if (!write) {
-        return { path: absolute, relativePath, written: false, config: suggestedConfig };
-      }
-      const writtenPath = writeConfigFile(workspace, relativePath, suggestedConfig);
-      return { path: writtenPath, relativePath, written: true, config: suggestedConfig };
-    }
     init_mesh_work_queue();
     init_repo_mesh_types();
     var import_os3 = require("os");
@@ -78510,6 +79842,37 @@ ${mergeTreeErr?.stderr || ""}`;
         this.aggregateMeshStatusCache.delete(meshId);
         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').
+       */
+      buildMedFamilyContext() {
+        const ctx = {
+          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) => launchIde(ctx, args),
+          inlineMeshCache: this.inlineMeshCache,
+          meshGitProbeCache: this.meshGitProbeCache
+        };
+        return ctx;
+      }
       async requireMeshHostMutationOwner(meshId, inlineMesh, operation) {
         const meshRecord = await this.getMeshForCommand(meshId, inlineMesh, { preferInline: true });
         const mesh = meshRecord?.mesh;
@@ -80425,6 +81788,10 @@ ${hintLines.join("\n")}` : "",
             getMeshForCommand: this.getMeshForCommand.bind(this)
           }, args);
         }
+        const medFamilyHandler = medFamilyRegistry.get(cmd);
+        if (medFamilyHandler) {
+          return await medFamilyHandler(this.buildMedFamilyContext(), args);
+        }
         switch (cmd) {
           // ─── CLI / ACP commands ───
           case "mesh_forward_event": {
@@ -80445,1315 +81812,6 @@ ${hintLines.join("\n")}` : "",
             this.deps.instanceManager.sendEvent(sessionId, "interactive_prompt_response", response);
             return { success: true };
           }
-          case "launch_cli": {
-            const launchResult = await this.deps.cliManager.handleCliCommand(cmd, args);
-            const meshNodeId = readStringValue(args?.settings?.meshNodeId);
-            const meshId = readStringValue(args?.settings?.meshNodeFor);
-            if (meshNodeId && meshId && launchResult?.success !== false) {
-              try {
-                const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                const meshObj = getMesh2(meshId) ?? this.getCachedInlineMesh(meshId);
-                const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => meshNodeIdMatches(n, meshNodeId)) : void 0;
-                const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
-                if (bootstrapStatus === "running") {
-                  return { success: true, ...launchResult, bootstrapPending: true };
-                }
-              } catch {
-              }
-            }
-            return launchResult;
-          }
-          case "stop_cli":
-          case "set_cli_view_mode":
-          case "record_provider_pty": {
-            return this.deps.cliManager.handleCliCommand(cmd, args);
-          }
-          case "agent_command": {
-            {
-              const dispatchSessionId = readStringValue(args?.targetSessionId, args?.sessionId, args?.instanceId);
-              const dispatchMeshContext = args?.meshContext;
-              if (dispatchSessionId && dispatchMeshContext) {
-                try {
-                  const inst = this.deps.instanceManager.getInstance(dispatchSessionId);
-                  if (inst && typeof inst.updateSettings === "function") {
-                    const stamp = buildMeshWorkerRelayStamp(
-                      inst.getState?.()?.settings,
-                      {
-                        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 {
-                }
-              }
-            }
-            const agentResult = await this.deps.cliManager.handleCliCommand(cmd, args);
-            const meshCtx = args?.meshContext;
-            const dispatchNodeId = readStringValue(meshCtx?.nodeId);
-            const dispatchMeshId = readStringValue(meshCtx?.meshId);
-            if (dispatchNodeId && dispatchMeshId && agentResult?.success !== false) {
-              try {
-                const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                const meshObj = getMesh2(dispatchMeshId) ?? this.getCachedInlineMesh(dispatchMeshId);
-                const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => meshNodeIdMatches(n, dispatchNodeId)) : void 0;
-                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 {
-              }
-            }
-            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
-            });
-            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 : void 0);
-                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");
-            const isIde = this.deps.cdpManagers.has(targetType) || this.deps.providerLoader.getMeta(targetType)?.category === "ide";
-            if (isIde) {
-              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 };
-            }
-            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;
-            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 {
-            }
-            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);
-            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
-              },
-              loadConfig2()
-            );
-            const launchArgs = {
-              ideId: ideKey,
-              workspace: resolvedWorkspace,
-              newWindow: args?.newWindow
-            };
-            LOG2.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) : LOG2.forComponent(`CDP:${result.ideId}`).asLogFn();
-              const provider = this.deps.providerLoader.getMeta(result.ideId);
-              const manager = new DaemonCdpManager(result.port, logFn, void 0, provider?.targetFilter);
-              const connected = await manager.connect();
-              if (connected) {
-                registerExtensionProviders(this.deps.providerLoader, manager, result.ideId);
-                this.deps.cdpManagers.set(result.ideId, manager);
-                LOG2.info("CDP", `Connected: ${result.ideId} (port ${result.port})`);
-                LOG2.info("CDP", `${this.deps.cdpManagers.size} IDE(s) connected`);
-                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 {
-            }
-            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 {
-              }
-            } 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 {
-              }
-            }
-            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: listMeshes2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              return { success: true, meshes: listMeshes2() };
-            } catch (e) {
-              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;
-            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: loadConfig2().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() : void 0;
-            const defaultBranch = typeof args?.defaultBranch === "string" ? args.defaultBranch.trim() : void 0;
-            if (!name) return { success: false, error: "name required" };
-            try {
-              const { createMesh: createMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const meshHost = args?.meshHost && typeof args.meshHost === "object" && !Array.isArray(args.meshHost) ? args.meshHost : void 0;
-              const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy, meshHost });
-              return { success: true, mesh };
-            } catch (e) {
-              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: updateMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const patch = {};
-              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 = updateMesh2(meshId, patch);
-              if (!mesh) return { success: false, error: "Mesh not found" };
-              this.inlineMeshCache.set(meshId, mesh);
-              this.invalidateAggregateMeshStatus(meshId);
-              return { success: true, mesh };
-            } catch (e) {
-              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: configureMeshHostPairing2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const configured = configureMeshHostPairing2(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) {
-              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: createMeshHostPairingToken2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const created = createMeshHostPairingToken2(meshId, {
-                token: typeof args?.token === "string" ? args.token : void 0,
-                expiresAt: typeof args?.expiresAt === "string" ? args.expiresAt : void 0
-              });
-              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) {
-              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: applyMeshHostJoinRequest2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const applied = applyMeshHostJoinRequest2(meshId, {
-                token,
-                memberNode,
-                memberMeshId: typeof args?.memberMeshId === "string" ? args.memberMeshId : void 0
-              });
-              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 }) : void 0,
-                  error: applied.reason
-                };
-              }
-              this.inlineMeshCache.set(meshId, applied.mesh);
-              this.invalidateAggregateMeshStatus(meshId);
-              try {
-                const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-                appendLedgerEntry2(meshId, {
-                  kind: "node_joined",
-                  nodeId: applied.node.id,
-                  payload: { role: "member", tokenId: applied.tokenId, workspace: applied.node.workspace }
-                });
-              } catch {
-              }
-              return {
-                success: true,
-                code: "mesh_host_join_accepted",
-                meshId,
-                node: applied.node,
-                tokenId: applied.tokenId,
-                meshHost: resolveMeshHostStatus(applied.mesh)
-              };
-            } catch (e) {
-              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: tokenIdForManualPairing2, markMeshHostPairingJoined: markMeshHostPairingJoined2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const tokenId = tokenIdForManualPairing2(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;
-              let transport;
-              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 : markMeshHostPairingJoined2(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) {
-              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: deleteMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const deleted = deleteMesh2(meshId);
-              return { success: true, deleted };
-            } catch (e) {
-              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: getMeshQueueStats2, getQueue: getQueue2, describeTaskDependencyState: describeTaskDependencyState2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
-              const status = Array.isArray(args?.status) ? args.status.map((s2) => typeof s2 === "string" ? s2.trim() : "").filter(Boolean) : void 0;
-              const rawQueue = getQueue2(meshId, { status });
-              const statusById = new Map(getQueue2(meshId).map((task) => [task.id, task.status]));
-              const queue = rawQueue.map((task) => Array.isArray(task.dependsOn) && task.dependsOn.length > 0 ? { ...task, ...describeTaskDependencyState2(task, statusById) } : task);
-              const summary = getMeshQueueStats2(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) {
-              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: cancelTask2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
-              const reason = typeof args?.reason === "string" ? args.reason : void 0;
-              const task = cancelTask2(meshId, taskId, { reason });
-              if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
-              return { success: true, task };
-            } catch (e) {
-              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: requeueTask2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
-              const task = requeueTask2(meshId, taskId, {
-                reason: typeof args?.reason === "string" ? args.reason : void 0,
-                targetNodeId: typeof args?.targetNodeId === "string" ? args.targetNodeId.trim() : void 0,
-                targetSessionId: typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : void 0,
-                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) {
-              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: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const providerPriority = Array.isArray(args?.providerPriority) ? args.providerPriority.map((type) => 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() : void 0;
-              const machineId = typeof args?.machineId === "string" && args.machineId.trim() ? args.machineId.trim() : void 0;
-              const repoRoot = typeof args?.repoRoot === "string" && args.repoRoot.trim() ? args.repoRoot.trim() : void 0;
-              const node = addNode2(meshId, {
-                workspace,
-                ...repoRoot ? { repoRoot } : {},
-                ...daemonId ? { daemonId } : {},
-                ...machineId ? { machineId } : {},
-                ...policy ? { policy } : {},
-                ...role ? { role } : {}
-              });
-              if (!node) return { success: false, error: "Mesh not found" };
-              this.invalidateAggregateMeshStatus(meshId);
-              return { success: true, node };
-            } catch (e) {
-              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: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const policy = args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy) ? { ...args.policy } : {};
-              if (Array.isArray(args?.providerPriority)) {
-                const providerPriority = args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean);
-                delete policy.provider_priority;
-                if (providerPriority.length) {
-                  policy.providerPriority = providerPriority;
-                } else {
-                  delete policy.providerPriority;
-                }
-              }
-              if (Array.isArray(args?.providerRoles)) {
-                const providerRoles = normalizeProviderRoles(args.providerRoles);
-                if (providerRoles.length) {
-                  policy.providerRoles = providerRoles;
-                } else {
-                  delete policy.providerRoles;
-                }
-              }
-              const patch = { policy };
-              if (typeof args?.systemPrompt === "string") {
-                const trimmed = args.systemPrompt.trim();
-                patch.systemPrompt = trimmed || void 0;
-              } else if (args?.systemPrompt === null) {
-                patch.systemPrompt = void 0;
-              }
-              const node = updateNode2(meshId, nodeId, patch);
-              if (!node) return { success: false, error: "Mesh node not found" };
-              this.invalidateAggregateMeshStatus(meshId);
-              return { success: true, node };
-            } catch (e) {
-              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 {
-              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) => 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) => typeof id === "string" ? id.trim() : "").filter(Boolean) : void 0;
-              const result = await this.cleanupMeshSessions({
-                meshId,
-                nodeId,
-                node,
-                mode,
-                sessionIds,
-                dryRun: args?.dryRun === true,
-                source: "mesh_cleanup_sessions"
-              });
-              return result;
-            } catch (e) {
-              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) {
-              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" };
-            const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-            const mesh = meshRecord?.mesh;
-            const node = mesh?.nodes?.find((n) => 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) => typeof value === "string") : void 0;
-            let nodeDaemonId;
-            let allowAutoPublishSubmoduleMainCommits = false;
-            if (meshId && nodeId) {
-              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-              const mesh = meshRecord?.mesh;
-              const node = mesh?.nodes?.find((n) => 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) => typeof value === "string");
-              }
-              allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
-              nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
-            }
-            const selfDaemonId = this.deps.statusInstanceId;
-            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 : {},
-                workspace,
-                _meshDirectDispatch: true
-              });
-              return forwarded ?? { success: false, error: "no response from remote node" };
-            }
-            const result = await fastForwardMeshNode({
-              meshId: meshId || void 0,
-              nodeId: nodeId || void 0,
-              workspace,
-              branch: typeof args?.branch === "string" ? args.branch : void 0,
-              execute: args?.execute === true,
-              dryRun: args?.dryRun === true,
-              updateSubmodules: args?.updateSubmodules === true,
-              submoduleIgnorePaths,
-              mode: args?.mode === "push" ? "push" : "merge",
-              pushSubmodules: args?.pushSubmodules === true,
-              allowAutoPublishSubmoduleMainCommits
-            });
-            return result;
-          }
-          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" };
-            {
-              const meshRecordForForward = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-              const forwardNode = meshRecordForForward?.mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-              const nodeDaemonId = typeof forwardNode?.daemonId === "string" ? forwardNode.daemonId.trim() : void 0;
-              const selfDaemonId = this.deps.statusInstanceId;
-              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() : void 0;
-                const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "refine_mesh_node", {
-                  ...typeof args === "object" && args !== null ? args : {},
-                  coordinatorDaemonId: callerCoordinatorDaemonId || selfDaemonId,
-                  _meshDirectDispatch: true
-                });
-                return forwarded ?? { success: false, error: "no response from remote node" };
-              }
-            }
-            const isDryRun = args?.dryRun !== false && args?.execute !== true;
-            if (isDryRun) {
-              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-              const mesh = meshRecord?.mesh;
-              const node = mesh?.nodes?.find((n) => 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 \u2014 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.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
-            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 {
-              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-              const mesh = meshRecord?.mesh;
-              const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-              if (node && !args?._meshDirectDispatch && node.isLocalWorktree !== true && args?.force !== true) {
-                const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : "";
-                const nodeMachineId = readMeshNodeMachineId(node) || "";
-                const selfDaemonId = this.deps.statusInstanceId || "";
-                const selfMachineId = (() => {
-                  try {
-                    return loadConfig2().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
-              );
-              const explicitSessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
-              let sessionCleanup;
-              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;
-              if (node?.isLocalWorktree) {
-                const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
-                const isRemoteWorktree = nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch;
-                if (isRemoteWorktree) {
-                  const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "remove_mesh_node", {
-                    ...typeof args === "object" && args !== null ? args : {},
-                    _meshDirectDispatch: true
-                  });
-                  return forwarded ?? { success: false, error: "no response from remote node" };
-                }
-                const cleanupResult = await this.cleanupLocalWorktreeNode({ mesh, node, nodeId, force: args?.force === true });
-                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);
-                if (removed) this.invalidateAggregateMeshStatus(meshId);
-                if (!removed && !node) removed = true;
-              } else {
-                const { removeNode: removeNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                removed = removeNode2(meshId, nodeId);
-                if (!removed && !node) removed = true;
-                if (removed) this.invalidateAggregateMeshStatus(meshId);
-              }
-              if (removed) {
-                try {
-                  const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-                  appendLedgerEntry2(meshId, {
-                    kind: "node_removed",
-                    nodeId,
-                    payload: {
-                      worktree: !!node?.isLocalWorktree,
-                      sessionCleanupMode,
-                      workspace: typeof node?.workspace === "string" ? node.workspace : void 0,
-                      daemonId: typeof node?.daemonId === "string" ? node.daemonId : void 0,
-                      worktreeBranch: typeof node?.worktreeBranch === "string" ? node.worktreeBranch : void 0,
-                      worktreeCleanupFallback: typeof worktreeCleanup?.fallback === "string" ? worktreeCleanup.fallback : void 0,
-                      forced: worktreeCleanup?.forced === true ? true : void 0,
-                      forceFallbackReason: typeof worktreeCleanup?.reason === "string" ? worktreeCleanup.reason : void 0
-                    }
-                  });
-                } catch {
-                }
-              }
-              const residueWarning = worktreeCleanup?.residue === true && typeof worktreeCleanup?.residueWarning === "string" ? worktreeCleanup.residueWarning : void 0;
-              return {
-                success: true,
-                removed,
-                ...residueWarning ? { residueWarning } : {},
-                ...sessionCleanup ? { sessionCleanup } : {},
-                ...worktreeCleanup ? { worktreeCleanup } : {}
-              };
-            } catch (e) {
-              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() : void 0;
-            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 {
-              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) => meshNodeIdMatches(n, sourceNodeId));
-              if (!sourceNode) return { success: false, error: `Source node '${sourceNodeId}' not found in mesh` };
-              const sourceDaemonId = typeof sourceNode.daemonId === "string" ? sourceNode.daemonId.trim() : void 0;
-              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 : {},
-                  _meshDirectDispatch: true
-                });
-                return forwarded ?? { success: false, error: "no response from remote node" };
-              }
-              const repoRoot = sourceNode.repoRoot || sourceNode.workspace;
-              const { createWorktree: createWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
-              const result = await createWorktree2({
-                repoRoot,
-                branch,
-                baseBranch,
-                meshName: mesh.name
-              });
-              let node;
-              if (meshRecord.inline) {
-                const { randomUUID: randomUUID15 } = await import("crypto");
-                node = {
-                  id: `node_${randomUUID15().replace(/-/g, "")}`,
-                  workspace: result.worktreePath,
-                  repoRoot: result.worktreePath,
-                  daemonId: sourceNode.daemonId,
-                  machineId: sourceNode.machineId ?? sourceNode.machine_id,
-                  userOverrides: { ...sourceNode.userOverrides || {} },
-                  policy: { ...sourceNode.policy || {} },
-                  isLocalWorktree: true,
-                  worktreeBranch: result.branch,
-                  clonedFromNodeId: sourceNodeId
-                };
-                this.updateInlineMeshNode(meshId, mesh, node);
-              } else {
-                const { addNode: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                node = addNode2(meshId, {
-                  workspace: result.worktreePath,
-                  repoRoot: result.worktreePath,
-                  daemonId: sourceNode.daemonId,
-                  machineId: sourceNode.machineId ?? sourceNode.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" };
-                const inlineForReconcile = this.getCachedInlineMesh(meshId);
-                if (inlineForReconcile) this.updateInlineMeshNode(meshId, inlineForReconcile, node);
-                this.invalidateAggregateMeshStatus(meshId);
-              }
-              const persistWorktreeSetupState = async (bootstrapState2) => {
-                node.worktreeBootstrap = bootstrapState2;
-                if (meshRecord.inline) {
-                  this.updateInlineMeshNode(meshId, mesh, node);
-                  return;
-                }
-                try {
-                  const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                  updateNode2(meshId, node.id, { worktreeBootstrap: bootstrapState2 });
-                  this.invalidateAggregateMeshStatus(meshId);
-                } catch {
-                }
-              };
-              const appendCloneLedger = async (initSubmodules2, bootstrapState2) => {
-                try {
-                  const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-                  appendLedgerEntry2(meshId, {
-                    kind: "node_cloned",
-                    nodeId: node.id,
-                    payload: {
-                      sourceNodeId,
-                      branch: result.branch,
-                      worktreePath: result.worktreePath,
-                      submodulesInitialized: initSubmodules2,
-                      worktreeBootstrap: {
-                        status: bootstrapState2.status,
-                        required: bootstrapState2.required,
-                        configSource: bootstrapState2.configSource,
-                        configSourceType: bootstrapState2.configSourceType,
-                        lastCommand: bootstrapState2.lastCommand,
-                        exitCode: bootstrapState2.exitCode
-                      }
-                    }
-                  });
-                } catch {
-                }
-              };
-              const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
-              const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, result.worktreePath);
-              const runningBootstrapState = {
-                status: "running",
-                required: loadedBootstrap.config?.required !== false,
-                configSource: loadedBootstrap.path || loadedBootstrap.source,
-                configSourceType: loadedBootstrap.sourceType,
-                startedAt: (/* @__PURE__ */ new Date()).toISOString()
-              };
-              await persistWorktreeSetupState(runningBootstrapState);
-              const finishWorktreeSetup = async () => {
-                let submodulesInitialized2 = false;
-                if (initSubmodules) {
-                  try {
-                    const { runGit: runGit3 } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
-                    await runGit3(
-                      { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
-                      ["submodule", "update", "--init", "--recursive"],
-                      { timeoutMs: 12e4 }
-                    );
-                    submodulesInitialized2 = true;
-                    const sourceWorkspace = sourceNode.repoRoot || sourceNode.workspace;
-                    if (sourceWorkspace) {
-                      try {
-                        const { runGit: rg } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
-                        const sourceCtx = { workspace: sourceWorkspace, repoRoot: sourceWorkspace, isGitRepo: true };
-                        const worktreeCtx = { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true };
-                        const sourceStatusOut = await rg(sourceCtx, ["submodule", "status", "oss"], { timeoutMs: 1e4 });
-                        const sourceStatusLine = (typeof sourceStatusOut === "string" ? sourceStatusOut : sourceStatusOut?.stdout ?? "").trim();
-                        const sourceShaMatch = sourceStatusLine.match(/^[+\- ]?([0-9a-f]{40})/);
-                        const sourceSha = sourceShaMatch?.[1];
-                        if (sourceSha) {
-                          const ossCtx = { workspace: `${result.worktreePath}/oss`, repoRoot: `${result.worktreePath}/oss`, isGitRepo: true };
-                          const worktreeOssHeadOut = await rg(ossCtx, ["rev-parse", "HEAD"], { timeoutMs: 1e4 });
-                          const worktreeOssSha = (typeof worktreeOssHeadOut === "string" ? worktreeOssHeadOut : worktreeOssHeadOut?.stdout ?? "").trim();
-                          if (worktreeOssSha !== sourceSha) {
-                            await rg(ossCtx, ["fetch", `${sourceWorkspace}/oss`, "HEAD"], { timeoutMs: 6e4 });
-                            await rg(ossCtx, ["checkout", sourceSha], { timeoutMs: 1e4 });
-                            await rg(worktreeCtx, ["add", "oss"], { timeoutMs: 1e4 });
-                            await rg(worktreeCtx, ["commit", "-m", "chore: sync oss to source node HEAD on clone"], { timeoutMs: 1e4 });
-                            console.log(`[mesh] Synced oss submodule to source HEAD ${sourceSha.slice(0, 8)} in worktree`);
-                          }
-                        }
-                      } catch (ossErr) {
-                        console.warn("[mesh] oss submodule sync to source HEAD failed (best-effort):", ossErr.message);
-                      }
-                    }
-                  } catch (subErr) {
-                    console.warn("[mesh] Submodule init failed for worktree:", subErr.message);
-                  }
-                }
-                const bootstrapState2 = await runMeshWorktreeBootstrap(mesh, result.worktreePath);
-                await persistWorktreeSetupState(bootstrapState2);
-                await appendCloneLedger(submodulesInitialized2, bootstrapState2);
-                return { submodulesInitialized: submodulesInitialized2, bootstrapState: bootstrapState2 };
-              };
-              const requestedSetupWaitMs = Number(args?.setupWaitMs ?? args?.bootstrapWaitMs ?? 8e3);
-              const setupWaitMs = Number.isFinite(requestedSetupWaitMs) ? Math.min(Math.max(requestedSetupWaitMs, 0), 14e3) : 8e3;
-              const setupPromise = finishWorktreeSetup();
-              const setupResult = await Promise.race([
-                setupPromise.then((value) => ({ completed: true, value })),
-                new Promise((resolve24) => setTimeout(() => resolve24({ completed: false }), setupWaitMs))
-              ]);
-              const emitBootstrapEvent = (eventStatus2, bootstrapState2, startedAtMs, extraPayload) => {
-                try {
-                  const durationMs = Date.now() - startedAtMs;
-                  const event = `worktree_${eventStatus2}`;
-                  const metadataEvent = {
-                    source: "clone_mesh_node_bootstrap",
-                    nodeId: node.id,
-                    status: eventStatus2,
-                    worktreePath: result.worktreePath,
-                    durationMs,
-                    bootstrapStatus: bootstrapState2.status,
-                    ...bootstrapState2.error ? { error: bootstrapState2.error } : {},
-                    ...bootstrapState2.exitCode !== void 0 ? { exitCode: bootstrapState2.exitCode } : {},
-                    ...extraPayload || {}
-                  };
-                  if (typeof this.deps.instanceManager?.getByCategory === "function") {
-                    const forwarded = handleMeshForwardEvent(
-                      { instanceManager: this.deps.instanceManager },
-                      { 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 {
-                }
-              };
-              const bootstrapStartedMs = Date.now();
-              if (!setupResult.completed) {
-                setupPromise.then(({ bootstrapState: bootstrapState2 }) => {
-                  emitBootstrapEvent("bootstrap_complete", bootstrapState2, bootstrapStartedMs);
-                }).catch((error48) => {
-                  const failedState = {
-                    ...runningBootstrapState,
-                    status: "failed",
-                    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-                    error: error48?.message || String(error48)
-                  };
-                  void persistWorktreeSetupState(failedState);
-                  void appendCloneLedger(false, failedState);
-                  emitBootstrapEvent("bootstrap_failed", failedState, bootstrapStartedMs, { error: error48?.message || String(error48) });
-                });
-                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) {
-              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 {
-              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) => 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" };
-              const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
-              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 : {},
-                  _meshDirectDispatch: true
-                });
-                return forwarded ?? { success: false, error: "no response from remote node" };
-              }
-              const currentBootstrap = node.worktreeBootstrap;
-              if (currentBootstrap?.status === "running") {
-                return { success: false, error: "Bootstrap is already running for this node" };
-              }
-              const worktreePath = node.workspace || node.repoRoot;
-              if (!worktreePath) return { success: false, error: "Node has no workspace path" };
-              const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, worktreePath);
-              const runningState = {
-                status: "running",
-                required: loadedBootstrap.config?.required !== false,
-                configSource: loadedBootstrap.path || loadedBootstrap.source,
-                configSourceType: loadedBootstrap.sourceType,
-                startedAt: (/* @__PURE__ */ new Date()).toISOString()
-              };
-              const persistState = async (bootstrapState2) => {
-                node.worktreeBootstrap = bootstrapState2;
-                if (meshRecord.inline) {
-                  this.updateInlineMeshNode(meshId, mesh, node);
-                  return;
-                }
-                try {
-                  const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                  updateNode2(meshId, node.id, { worktreeBootstrap: bootstrapState2 });
-                  this.invalidateAggregateMeshStatus(meshId);
-                } catch {
-                }
-              };
-              await persistState(runningState);
-              const bootstrapState = await runMeshWorktreeBootstrap(mesh, worktreePath);
-              await persistState(bootstrapState);
-              return { success: true, bootstrapState };
-            } catch (e) {
-              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: triggerMeshQueue2, tryAssignQueueTask: tryAssignQueueTask2 } = await Promise.resolve().then(() => (init_mesh_events(), mesh_events_exports));
-              const preferredNodeId = typeof args?.preferredNodeId === "string" ? args.preferredNodeId.trim() : "";
-              if (preferredNodeId) {
-                const cliInstances = this.deps.instanceManager.getByCategory("cli");
-                const sorted = [...cliInstances].sort((a, b) => {
-                  const aSettings = a.getState().settings || {};
-                  const bSettings = b.getState().settings || {};
-                  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 || {};
-                  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) {
-                    tryAssignQueueTask2(this.deps, meshId, nodeId, sessionId, providerType);
-                    break;
-                  }
-                }
-              }
-              const trigger = await triggerMeshQueue2(this.deps, meshId);
-              return { success: true, trigger };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
           // ─── Mesh Coordinator Launch ───
           case "launch_mesh_coordinator": {
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";