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

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "1428e9d027beefe860a77f34dea34d202db80f00" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "1428e9d0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:05:49.524Z" : 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 version = 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:47:57.092Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2193,6 +2193,21 @@ var init_recent_activity = __esm({
   }
 });
 
+// src/system/hash.ts
+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 = __esm({
+  "src/system/hash.ts"() {
+    "use strict";
+    import_node_crypto = require("crypto");
+  }
+});
+
 // src/mesh/mesh-host-ownership.ts
 function readObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -2470,7 +2485,7 @@ function normalizeManualHostAddress(hostAddress) {
   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;
@@ -2705,6 +2720,7 @@ var init_mesh_config = __esm({
     import_fs3 = require("fs");
     import_path3 = require("path");
     import_crypto3 = require("crypto");
+    init_hash();
     init_config();
     init_repo_mesh_types();
     init_mesh_host_ownership();
@@ -7087,7 +7103,7 @@ function replaceLegacyCliCommandMcpArgs(command, args) {
 function resolveHermesCoordinatorHome(meshId, workspace) {
   const key = `${meshId || "mesh"}
 ${(0, import_node_path.resolve)(workspace || os4.tmpdir())}`;
-  const hash = (0, import_node_crypto.createHash)("sha256").update(key).digest("hex").slice(0, 16);
+  const hash = shortHash(key);
   return (0, import_node_path.join)(os4.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
@@ -7296,16 +7312,16 @@ async function execUnderPty(command, args, options = {}) {
     });
   });
 }
-var import_node_crypto, import_node_fs3, os4, import_session_host_core, import_node_path, DEFAULT_SERVER_NAME, DEFAULT_ADHDEV_MCP_COMMAND, HERMES_CLI_TYPE, HERMES_MCP_CONFIG_PATH;
+var import_node_fs3, os4, import_session_host_core, import_node_path, DEFAULT_SERVER_NAME, DEFAULT_ADHDEV_MCP_COMMAND, HERMES_CLI_TYPE, HERMES_MCP_CONFIG_PATH;
 var init_mesh_coordinator = __esm({
   "src/commands/mesh-coordinator.ts"() {
     "use strict";
-    import_node_crypto = require("crypto");
     import_node_fs3 = require("fs");
     os4 = __toESM(require("os"));
     import_session_host_core = require("@adhdev/session-host-core");
     import_node_path = require("path");
     init_logger();
+    init_hash();
     DEFAULT_SERVER_NAME = "adhdev-mesh";
     DEFAULT_ADHDEV_MCP_COMMAND = "adhdev";
     HERMES_CLI_TYPE = "hermes-cli";
@@ -8174,6 +8190,46 @@ function classifyDirectDispatch(params) {
   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 record = {
+    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, terminalRow };
+}
 function buildMeshActiveWorkSummary(activeWork) {
   const statusCounts = {
     pending: 0,
@@ -8279,49 +8335,13 @@ function buildMeshActiveWork(opts) {
     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 record = {
-        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, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
       if (terminalRow) {
         terminalDirectWork.push(record);
         if (opts.includeTerminalDirect !== true) continue;
       }
-      if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
+      if (record.staleReason && !terminalRow) {
         staleDirectWork.push(record);
         continue;
       }
@@ -8331,48 +8351,12 @@ function buildMeshActiveWork(opts) {
     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 record = {
-        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, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
       if (terminalRow) {
         terminalDirectWork.push(record);
         if (opts.includeTerminalDirect !== true) continue;
       }
-      if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
+      if (record.staleReason && !terminalRow) {
         staleDirectWork.push(record);
         continue;
       }
@@ -34739,6 +34723,9 @@ var lowFamilyRegistry = new Map(
   })
 );
 
+// src/commands/med-family/cli-agent.ts
+init_dist();
+
 // src/commands/cli-manager.ts
 var os21 = __toESM(require("os"));
 var path27 = __toESM(require("path"));
@@ -34752,6 +34739,7 @@ init_config();
 init_state_store();
 init_workspaces();
 init_recent_activity();
+init_hash();
 init_coordinator_registry();
 init_summary_metadata();
 
@@ -41145,7 +41133,7 @@ function hasConfigOverride(args, key) {
 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;
@@ -42113,6 +42101,156 @@ Run 'adhdev doctor' for detailed diagnostics.`
   }
 };
 
+// src/commands/med-family/cli-agent.ts
+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);
+  }
+};
+
 // src/launch.ts
 var import_child_process9 = require("child_process");
 var net = __toESM(require("net"));
@@ -45938,12 +46076,1342 @@ function getAvailableIdeIds() {
   return getProviderLoader().getAvailableIdeTypes();
 }
 
-// src/commands/router.ts
+// src/commands/med-family/ide.ts
 init_config();
 init_state_store();
 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
+    },
+    loadConfig()
+  );
+  const launchArgs = {
+    ideId: ideKey,
+    workspace: resolvedWorkspace,
+    newWindow: args?.newWindow
+  };
+  LOG.info("LaunchIDE", `target=${ideKey || "auto"}`);
+  const result = await launchWithCdp(launchArgs);
+  if (result.success && result.port && result.ideId && !ctx.deps.cdpManagers.has(result.ideId)) {
+    const logFn = ctx.deps.getCdpLogFn ? ctx.deps.getCdpLogFn(result.ideId) : LOG.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);
+      LOG.info("CDP", `Connected: ${result.ideId} (port ${result.port})`);
+      LOG.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 };
+  }
+};
+
+// src/commands/med-family/mesh-crud.ts
+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: loadConfig().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 loadConfig().machineId || "";
+          } catch {
+            return "";
+          }
+        })();
+        const isCoordinatorBaseNode = !!selfDaemonId && (nodeDaemonId === selfDaemonId || nodeMachineId === selfDaemonId) || !!selfMachineId && (nodeDaemonId === selfMachineId || nodeMachineId === selfMachineId);
+        if (isCoordinatorBaseNode) {
+          return {
+            success: false,
+            removed: false,
+            code: "mesh_remove_coordinator_base_node_protected",
+            error: `Refusing to remove the coordinator's own base node '${typeof node.workspace === "string" ? node.workspace : nodeId}'. It is the local non-worktree node bound to this coordinator daemon; removing it breaks live mesh membership and forces a restart.`,
+            recoveryHint: "Remove worktree clone nodes instead, or pass force:true only if you are intentionally tearing down this mesh and accept that the coordinator must be re-registered/restarted."
+          };
+        }
+      }
+      const sessionCleanupMode = 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((error) => {
+          const failedState = {
+            ...runningBootstrapState,
+            status: "failed",
+            completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            error: error?.message || String(error)
+          };
+          void persistWorktreeSetupState(failedState);
+          void appendCloneLedger(false, failedState);
+          emitBootstrapEvent("bootstrap_failed", failedState, bootstrapStartedMs, { error: error?.message || String(error) });
+        });
+        return {
+          success: true,
+          async: true,
+          status: "accepted",
+          node,
+          worktreePath: result.worktreePath,
+          branch: result.branch,
+          worktreeBootstrap: runningBootstrapState,
+          worktreeSetup: {
+            status: "running",
+            setupWaitMs,
+            message: "Worktree node is registered; submodule/bootstrap setup is continuing in the background."
+          }
+        };
+      }
+      const { submodulesInitialized, bootstrapState } = setupResult.value;
+      emitBootstrapEvent("bootstrap_complete", bootstrapState, bootstrapStartedMs);
+      return {
+        success: true,
+        node,
+        worktreePath: result.worktreePath,
+        branch: result.branch,
+        submodulesInitialized,
+        worktreeBootstrap: bootstrapState
+      };
+    } catch (e) {
+      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 };
+    }
+  }
+};
+
+// src/commands/med-family/mesh-host-pairing.ts
+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 };
+    }
+  }
+};
+
+// src/commands/med-family/mesh-queue.ts
+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 };
+    }
+  }
+};
+
+// src/commands/med-family/fast-forward.ts
+init_dist();
+init_mesh_fast_forward();
+
+// src/mesh/mesh-init.ts
+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, config) {
+  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(config, 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 refine = applyConfigSuggestion({
+    workspace,
+    relativePath: MESH_INIT_REFINE_CONFIG_PATH,
+    existing: loadMeshRefineConfig(mesh, workspace).config,
+    suggestedConfig: suggestMeshRefineConfig(mesh, workspace).suggestedConfig,
+    validate: (config) => validateMeshRefineConfig(config, 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: (config) => validateMeshWorktreeBootstrapConfig(config, MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH).valid,
+    write,
+    overwrite
+  });
+  const providers = suggestNodeProviderPriority(detected);
+  return {
+    success: true,
+    workspace,
+    dryRun: !write,
+    refine,
+    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 };
+}
+
+// src/commands/med-family/fast-forward.ts
+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);
+  }
+};
+
+// src/commands/med-family/index.ts
+var medFamilyRegistry = new Map(
+  Object.entries({
+    ...cliAgentHandlers,
+    ...ideHandlers,
+    ...meshCrudHandlers,
+    ...meshHostPairingHandlers,
+    ...meshQueueHandlers,
+    ...fastForwardHandlers
+  })
+);
+
+// src/commands/router.ts
+init_config();
+init_cli_detector();
 init_git_status();
 init_dist();
 init_logger();
@@ -46099,9 +47567,7 @@ init_mesh_coordinator();
 init_coordinator_registry();
 init_mesh_events();
 init_mesh_routing();
-init_mesh_events_utils();
 init_mesh_host_ownership();
-init_mesh_fast_forward();
 
 // src/mesh/mesh-refine-batch.ts
 var import_node_child_process4 = require("child_process");
@@ -46274,121 +47740,6 @@ function buildPreviewFreshness(repoRoot) {
 
 // src/commands/router.ts
 init_mesh_refine_status();
-
-// src/mesh/mesh-init.ts
-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, config) {
-  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(config, 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 refine = applyConfigSuggestion({
-    workspace,
-    relativePath: MESH_INIT_REFINE_CONFIG_PATH,
-    existing: loadMeshRefineConfig(mesh, workspace).config,
-    suggestedConfig: suggestMeshRefineConfig(mesh, workspace).suggestedConfig,
-    validate: (config) => validateMeshRefineConfig(config, 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: (config) => validateMeshWorktreeBootstrapConfig(config, MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH).valid,
-    write,
-    overwrite
-  });
-  const providers = suggestNodeProviderPriority(detected);
-  return {
-    success: true,
-    workspace,
-    dryRun: !write,
-    refine,
-    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 };
-}
-
-// src/commands/router.ts
 init_mesh_work_queue();
 init_repo_mesh_types();
 var import_os3 = require("os");
@@ -48940,6 +50291,37 @@ var DaemonCommandRouter = class {
     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;
@@ -50855,6 +52237,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": {
@@ -50875,1315 +52261,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
-          },
-          loadConfig()
-        );
-        const launchArgs = {
-          ideId: ideKey,
-          workspace: resolvedWorkspace,
-          newWindow: args?.newWindow
-        };
-        LOG.info("LaunchIDE", `target=${ideKey || "auto"}`);
-        const result = await launchWithCdp(launchArgs);
-        if (result.success && result.port && result.ideId && !this.deps.cdpManagers.has(result.ideId)) {
-          const logFn = this.deps.getCdpLogFn ? this.deps.getCdpLogFn(result.ideId) : LOG.forComponent(`CDP:${result.ideId}`).asLogFn();
-          const provider = this.deps.providerLoader.getMeta(result.ideId);
-          const manager = new DaemonCdpManager(result.port, logFn, 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);
-            LOG.info("CDP", `Connected: ${result.ideId} (port ${result.port})`);
-            LOG.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: loadConfig().machineId || "",
-          probeRemotePeers,
-          probeCache: this.meshGitProbeCache
-        });
-        const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
-        const sourceOfTruth = {
-          membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
-          coordinatorOwnsLiveTruth: directTruthSatisfied,
-          directPeerTruth: {
-            required: requireDirectPeerTruth,
-            satisfied: directTruthSatisfied,
-            directEvidenceCount: directTruth.directEvidenceCount,
-            localConfirmedCount: directTruth.localConfirmedCount,
-            peerAttemptedCount: directTruth.peerAttemptedCount,
-            peerConfirmedCount: directTruth.peerConfirmedCount,
-            unavailableNodeIds: directTruth.unavailableNodeIds
-          }
-        };
-        if (requireDirectPeerTruth && !directTruthSatisfied) {
-          return {
-            success: false,
-            code: "mesh_direct_peer_truth_unavailable",
-            error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct get_mesh probes succeed.",
-            sourceOfTruth
-          };
-        }
-        return { success: true, mesh: meshRecord.mesh, sourceOfTruth };
-      }
-      case "create_mesh": {
-        const name = typeof args?.name === "string" ? args.name.trim() : "";
-        const repoIdentity = typeof args?.repoIdentity === "string" ? args.repoIdentity.trim() : "";
-        const repoRemoteUrl = typeof args?.repoRemoteUrl === "string" ? args.repoRemoteUrl.trim() : 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 loadConfig().machineId || "";
-              } catch {
-                return "";
-              }
-            })();
-            const isCoordinatorBaseNode = !!selfDaemonId && (nodeDaemonId === selfDaemonId || nodeMachineId === selfDaemonId) || !!selfMachineId && (nodeDaemonId === selfMachineId || nodeMachineId === selfMachineId);
-            if (isCoordinatorBaseNode) {
-              return {
-                success: false,
-                removed: false,
-                code: "mesh_remove_coordinator_base_node_protected",
-                error: `Refusing to remove the coordinator's own base node '${typeof node.workspace === "string" ? node.workspace : nodeId}'. It is the local non-worktree node bound to this coordinator daemon; removing it breaks live mesh membership and forces a restart.`,
-                recoveryHint: "Remove worktree clone nodes instead, or pass force:true only if you are intentionally tearing down this mesh and accept that the coordinator must be re-registered/restarted."
-              };
-            }
-          }
-          const sessionCleanupMode = this.normalizeMeshSessionCleanupMode(
-            args?.sessionCleanupMode ?? args?.session_cleanup_mode ?? mesh?.policy?.sessionCleanupOnNodeRemove
-          );
-          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((error) => {
-              const failedState = {
-                ...runningBootstrapState,
-                status: "failed",
-                completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-                error: error?.message || String(error)
-              };
-              void persistWorktreeSetupState(failedState);
-              void appendCloneLedger(false, failedState);
-              emitBootstrapEvent("bootstrap_failed", failedState, bootstrapStartedMs, { error: error?.message || String(error) });
-            });
-            return {
-              success: true,
-              async: true,
-              status: "accepted",
-              node,
-              worktreePath: result.worktreePath,
-              branch: result.branch,
-              worktreeBootstrap: runningBootstrapState,
-              worktreeSetup: {
-                status: "running",
-                setupWaitMs,
-                message: "Worktree node is registered; submodule/bootstrap setup is continuing in the background."
-              }
-            };
-          }
-          const { submodulesInitialized, bootstrapState } = setupResult.value;
-          emitBootstrapEvent("bootstrap_complete", bootstrapState, bootstrapStartedMs);
-          return {
-            success: true,
-            node,
-            worktreePath: result.worktreePath,
-            branch: result.branch,
-            submodulesInitialized,
-            worktreeBootstrap: bootstrapState
-          };
-        } catch (e) {
-          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() : "";