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

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "4c5b30b1b0527ec5234c037893ba4fc24b88a8a0" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "4c5b30b1" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.363" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-23T16:14:01.927Z" : void 0);
+      const commit = readInjected(true ? "fe24f3fb158efc949e806b79bca2479b1c29d753" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "fe24f3fb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.365" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-24T00:48:25.762Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -31927,6 +31927,19 @@ ${error48.message || ""}`;
         MAX_ACTIVITY = 30;
       }
     });
+    function sha256Hex(input) {
+      return (0, import_node_crypto.createHash)("sha256").update(input).digest("hex");
+    }
+    function shortHash(input, length = 16) {
+      return sha256Hex(input).slice(0, length);
+    }
+    var import_node_crypto;
+    var init_hash = __esm2({
+      "src/system/hash.ts"() {
+        "use strict";
+        import_node_crypto = require("crypto");
+      }
+    });
     function readObject(value) {
       return value && typeof value === "object" && !Array.isArray(value) ? value : null;
     }
@@ -32201,7 +32214,7 @@ ${error48.message || ""}`;
       return normalized;
     }
     function tokenIdForManualPairing(token) {
-      return `tok_${(0, import_crypto3.createHash)("sha256").update(token).digest("hex").slice(0, 16)}`;
+      return `tok_${shortHash(token)}`;
     }
     function normalizeTokenExpiry(value) {
       if (typeof value !== "string" || !value.trim()) return void 0;
@@ -32440,6 +32453,7 @@ ${error48.message || ""}`;
         import_fs3 = require("fs");
         import_path3 = require("path");
         import_crypto3 = require("crypto");
+        init_hash();
         init_config();
         init_repo_mesh_types();
         init_mesh_host_ownership();
@@ -36860,7 +36874,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     function resolveHermesCoordinatorHome(meshId, workspace) {
       const key = `${meshId || "mesh"}
 ${(0, import_node_path.resolve)(workspace || os42.tmpdir())}`;
-      const hash2 = (0, import_node_crypto.createHash)("sha256").update(key).digest("hex").slice(0, 16);
+      const hash2 = shortHash(key);
       return (0, import_node_path.join)(os42.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash2}`);
     }
     function resolveMcpConfigPath(configPath, workspace) {
@@ -37069,7 +37083,6 @@ ${rendered}`, "utf-8");
         });
       });
     }
-    var import_node_crypto;
     var import_node_fs3;
     var os42;
     var import_session_host_core4;
@@ -37081,12 +37094,12 @@ ${rendered}`, "utf-8");
     var init_mesh_coordinator = __esm2({
       "src/commands/mesh-coordinator.ts"() {
         "use strict";
-        import_node_crypto = require("crypto");
         import_node_fs3 = require("fs");
         os42 = __toESM2(require("os"));
         import_session_host_core4 = require_dist();
         import_node_path = require("path");
         init_logger();
+        init_hash();
         DEFAULT_SERVER_NAME = "adhdev-mesh";
         DEFAULT_ADHDEV_MCP_COMMAND = "adhdev";
         HERMES_CLI_TYPE = "hermes-cli";
@@ -37953,6 +37966,46 @@ ${rendered}`, "utf-8");
       const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !liveStaleReason);
       return { ledgerOnlyStaleReason, isFreshUnacknowledged };
     }
+    function buildLedgerDirectDispatchRecord(dispatch, ctx) {
+      const taskId = directDispatchTaskId(dispatch);
+      const terminal = ctx.terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
+      const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
+      const live = sessionStatusFromNodes(ctx.nodes, dispatch.nodeId, dispatch.sessionId);
+      const status = terminalStatus || live.status || "assigned";
+      const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
+      const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
+        status,
+        isTerminalRow: terminalRow,
+        hasTerminalStatus: Boolean(terminalStatus),
+        liveStatus: live.status,
+        liveStaleReason: live.staleReason,
+        dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true
+      });
+      const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
+      const { title, summary } = summarizeMessage(message);
+      const record2 = {
+        taskId,
+        source: "direct",
+        status,
+        nodeId: dispatch.nodeId,
+        sessionId: dispatch.sessionId,
+        providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
+        taskTitle: readString6(dispatch.payload?.taskTitle) || title,
+        taskSummary: readString6(dispatch.payload?.taskSummary) || summary,
+        message,
+        taskMode: readString6(dispatch.payload?.taskMode),
+        createdAt: dispatch.timestamp,
+        updatedAt: terminal?.timestamp || dispatch.timestamp,
+        dispatchedAt: dispatch.timestamp,
+        elapsedMs: elapsedSince(dispatch.timestamp, ctx.now),
+        terminal: terminalRow,
+        terminalKind: terminal?.kind,
+        terminalAt: terminal?.timestamp,
+        staleReason: live.staleReason || ledgerOnlyStaleReason,
+        ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
+      };
+      return { record: record2, terminalRow };
+    }
     function buildMeshActiveWorkSummary(activeWork) {
       const statusCounts = {
         pending: 0,
@@ -38058,49 +38111,13 @@ ${rendered}`, "utf-8");
         const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
         const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
         for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
-          const taskId = directDispatchTaskId(dispatch);
-          if (dbTaskIds.has(taskId)) continue;
-          const terminal = terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
-          const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
-          const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
-          const status = terminalStatus || live.status || "assigned";
-          const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
-          const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
-            status,
-            isTerminalRow: terminalRow,
-            hasTerminalStatus: Boolean(terminalStatus),
-            liveStatus: live.status,
-            liveStaleReason: live.staleReason,
-            dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true
-          });
-          const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
-          const { title, summary: summary2 } = summarizeMessage(message);
-          const record2 = {
-            taskId,
-            source: "direct",
-            status,
-            nodeId: dispatch.nodeId,
-            sessionId: dispatch.sessionId,
-            providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
-            taskTitle: readString6(dispatch.payload?.taskTitle) || title,
-            taskSummary: readString6(dispatch.payload?.taskSummary) || summary2,
-            message,
-            taskMode: readString6(dispatch.payload?.taskMode),
-            createdAt: dispatch.timestamp,
-            updatedAt: terminal?.timestamp || dispatch.timestamp,
-            dispatchedAt: dispatch.timestamp,
-            elapsedMs: elapsedSince(dispatch.timestamp, now),
-            terminal: terminalRow,
-            terminalKind: terminal?.kind,
-            terminalAt: terminal?.timestamp,
-            staleReason: live.staleReason || ledgerOnlyStaleReason,
-            ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
-          };
+          if (dbTaskIds.has(directDispatchTaskId(dispatch))) continue;
+          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
           if (terminalRow) {
             terminalDirectWork.push(record2);
             if (opts.includeTerminalDirect !== true) continue;
           }
-          if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
+          if (record2.staleReason && !terminalRow) {
             staleDirectWork.push(record2);
             continue;
           }
@@ -38110,48 +38127,12 @@ ${rendered}`, "utf-8");
         const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
         const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
         for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
-          const taskId = directDispatchTaskId(dispatch);
-          const terminal = terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
-          const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
-          const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
-          const status = terminalStatus || live.status || "assigned";
-          const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
-          const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
-            status,
-            isTerminalRow: terminalRow,
-            hasTerminalStatus: Boolean(terminalStatus),
-            liveStatus: live.status,
-            liveStaleReason: live.staleReason,
-            dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true
-          });
-          const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
-          const { title, summary: summary2 } = summarizeMessage(message);
-          const record2 = {
-            taskId,
-            source: "direct",
-            status,
-            nodeId: dispatch.nodeId,
-            sessionId: dispatch.sessionId,
-            providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
-            taskTitle: readString6(dispatch.payload?.taskTitle) || title,
-            taskSummary: readString6(dispatch.payload?.taskSummary) || summary2,
-            message,
-            taskMode: readString6(dispatch.payload?.taskMode),
-            createdAt: dispatch.timestamp,
-            updatedAt: terminal?.timestamp || dispatch.timestamp,
-            dispatchedAt: dispatch.timestamp,
-            elapsedMs: elapsedSince(dispatch.timestamp, now),
-            terminal: terminalRow,
-            terminalKind: terminal?.kind,
-            terminalAt: terminal?.timestamp,
-            staleReason: live.staleReason || ledgerOnlyStaleReason,
-            ...isFreshUnacknowledged ? { staleDispatchUnacknowledged: true } : {}
-          };
+          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
           if (terminalRow) {
             terminalDirectWork.push(record2);
             if (opts.includeTerminalDirect !== true) continue;
           }
-          if ((live.staleReason || ledgerOnlyStaleReason) && !terminalRow) {
+          if (record2.staleReason && !terminalRow) {
             staleDirectWork.push(record2);
             continue;
           }
@@ -64392,6 +64373,7 @@ ${body}
         ...meshNodeLogsHandlers
       })
     );
+    init_dist();
     var os21 = __toESM2(require("os"));
     var path27 = __toESM2(require("path"));
     var crypto5 = __toESM2(require("crypto"));
@@ -64404,6 +64386,7 @@ ${body}
     init_state_store();
     init_workspaces();
     init_recent_activity();
+    init_hash();
     init_coordinator_registry();
     init_summary_metadata();
     var os20 = __toESM2(require("os"));
@@ -64729,6 +64712,11 @@ ${body}
       lastWin32WriteAt = 0;
       /** Pending paced chunk-write timer for a large win32 body (see writeWin32Body). */
       win32WriteTimer = null;
+      /** Timer driving the win32 verification-based modal-confirm CR resend loop (see
+       *  scheduleWin32ModalConfirm). A lone CR that confirms an approval/picker choice
+       *  is absorbed by ConPTY the same way a send_message submit CR is, so the confirm
+       *  must be resent until the modal actually resolves (status leaves 'approval'). */
+      win32ModalConfirmTimer = null;
       currentEval = null;
       stateHistory = [];
       prevStateAt = 0;
@@ -64853,6 +64841,10 @@ ${body}
           clearTimeout(this.win32WriteTimer);
           this.win32WriteTimer = null;
         }
+        if (this.win32ModalConfirmTimer) {
+          clearTimeout(this.win32ModalConfirmTimer);
+          this.win32ModalConfirmTimer = null;
+        }
         this.specWatcher?.close();
         this.adapter.kill();
       }
@@ -65448,10 +65440,61 @@ ${body}
           const nav = step.repeat(Math.abs(delta));
           const confirm = (rule.key_for_index || "\r").replace(/\{index\}/g, "") || "\r";
           if (nav) this.adapter.send_keys(nav);
-          this.adapter.send_keys(confirm);
+          this.submitModalConfirm(confirm);
           return;
         }
-        this.adapter.send_keys(btn.key);
+        this.submitModalConfirm(btn.key);
+      }
+      /**
+       * Submit a modal-confirm key sequence (the choice key + its trailing CR).
+       *
+       * On win32 the trailing CR is the SAME lone-CR-swallow case as a send_message
+       * submit: ConPTY can absorb a single CR as a literal newline instead of a
+       * confirm, so the approval/picker modal never resolves and the FSM flaps
+       * approval↔busy while auto-approve keeps firing into the void (APPROVESTUCK).
+       * So we split any non-CR prefix (e.g. the "1" of "1\r") off, write it once, and
+       * resend the CR on a fixed cadence until the modal actually resolves (status
+       * leaves 'approval'). Non-win32 keeps the single direct write — its CR submits
+       * on the first try.
+       */
+      submitModalConfirm(keys) {
+        if (process.platform !== "win32") {
+          this.adapter.send_keys(keys);
+          return;
+        }
+        const m = /^([\s\S]*?)([\r\n]+)$/.exec(keys);
+        const prefix = m ? m[1] : keys;
+        const cr = m ? m[2] : "";
+        if (prefix) this.adapter.send_keys(prefix);
+        if (!cr) return;
+        this.scheduleWin32ModalConfirm(cr);
+      }
+      /**
+       * win32 modal-confirm CR resend loop. Mirrors scheduleWin32Submit's phase-2
+       * verified resend, but gated on still being IN a modal (status 'approval')
+       * rather than still idle: the first CR fires immediately, then resends every
+       * WIN32_SUBMIT_RESEND_GAP_MS while the FSM is still showing the modal, up to
+       * WIN32_SUBMIT_MAX_RESENDS. The instant the modal resolves (status flips to
+       * generating/idle) we stop, so no stray CR leaks into the next turn's composer.
+       */
+      scheduleWin32ModalConfirm(submitKey) {
+        if (this.win32ModalConfirmTimer) {
+          clearTimeout(this.win32ModalConfirmTimer);
+          this.win32ModalConfirmTimer = null;
+        }
+        const fire = (attempt) => {
+          this.win32ModalConfirmTimer = null;
+          this.adapter.send_keys(submitKey);
+          if (attempt + 1 >= WIN32_SUBMIT_MAX_RESENDS) return;
+          this.win32ModalConfirmTimer = setTimeout(() => {
+            if (this.currentStatus() !== "approval") {
+              this.win32ModalConfirmTimer = null;
+              return;
+            }
+            fire(attempt + 1);
+          }, WIN32_SUBMIT_RESEND_GAP_MS);
+        };
+        fire(0);
       }
       handleAttachImage(blob, mime) {
         const ctl = (this.spec.control_bar ?? []).find((c) => c.action.type === "attach_image");
@@ -70697,7 +70740,7 @@ ${rawInput}` : rawInput;
     function ensureEmptyDelegatedMcpConfig(workspace) {
       const baseDir = path27.join(os21.tmpdir(), "adhdev-delegated-agent-empty-mcp");
       (0, import_fs15.mkdirSync)(baseDir, { recursive: true });
-      const workspaceHash = crypto5.createHash("sha256").update(path27.resolve(workspace || os21.tmpdir())).digest("hex").slice(0, 16);
+      const workspaceHash = shortHash(path27.resolve(workspace || os21.tmpdir()));
       const filePath = path27.join(baseDir, `${workspaceHash}.json`);
       (0, import_fs15.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
       return filePath;
@@ -71664,6 +71707,154 @@ Run 'adhdev doctor' for detailed diagnostics.`
         return null;
       }
     };
+    init_state_store();
+    init_recent_activity();
+    init_mesh_events_utils();
+    var cliAgentHandlers = {
+      launch_cli: async (ctx, args) => {
+        const launchResult = await ctx.deps.cliManager.handleCliCommand("launch_cli", args);
+        const meshNodeId = readStringValue(args?.settings?.meshNodeId);
+        const meshId = readStringValue(args?.settings?.meshNodeFor);
+        if (meshNodeId && meshId && launchResult?.success !== false) {
+          try {
+            const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            const meshObj = getMesh2(meshId) ?? ctx.getCachedInlineMesh(meshId);
+            const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => meshNodeIdMatches(n, meshNodeId)) : void 0;
+            const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
+            if (bootstrapStatus === "running") {
+              return { success: true, ...launchResult, bootstrapPending: true };
+            }
+          } catch {
+          }
+        }
+        return launchResult;
+      },
+      stop_cli: async (ctx, args) => {
+        return ctx.deps.cliManager.handleCliCommand("stop_cli", args);
+      },
+      set_cli_view_mode: async (ctx, args) => {
+        return ctx.deps.cliManager.handleCliCommand("set_cli_view_mode", args);
+      },
+      record_provider_pty: async (ctx, args) => {
+        return ctx.deps.cliManager.handleCliCommand("record_provider_pty", args);
+      },
+      agent_command: async (ctx, args) => {
+        {
+          const dispatchSessionId = readStringValue(args?.targetSessionId, args?.sessionId, args?.instanceId);
+          const dispatchMeshContext = args?.meshContext;
+          if (dispatchSessionId && dispatchMeshContext) {
+            try {
+              const inst = ctx.deps.instanceManager.getInstance(dispatchSessionId);
+              if (inst && typeof inst.updateSettings === "function") {
+                const stamp = buildMeshWorkerRelayStamp(
+                  inst.getState?.()?.settings,
+                  {
+                    meshId: dispatchMeshContext.meshId,
+                    nodeId: dispatchMeshContext.nodeId,
+                    coordinatorDaemonId: dispatchMeshContext.coordinatorDaemonId,
+                    // Session-level anchor: preserved across the P2P dispatch to a
+                    // remote worker so its completion echoes back to the right session.
+                    coordinatorSessionId: dispatchMeshContext.coordinatorSessionId
+                  }
+                );
+                if (stamp) inst.updateSettings(stamp);
+              }
+            } catch {
+            }
+          }
+        }
+        const agentResult = await ctx.deps.cliManager.handleCliCommand("agent_command", args);
+        const meshCtx = args?.meshContext;
+        const dispatchNodeId = readStringValue(meshCtx?.nodeId);
+        const dispatchMeshId = readStringValue(meshCtx?.meshId);
+        if (dispatchNodeId && dispatchMeshId && agentResult?.success !== false) {
+          try {
+            const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            const meshObj = getMesh2(dispatchMeshId) ?? ctx.getCachedInlineMesh(dispatchMeshId);
+            const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => meshNodeIdMatches(n, dispatchNodeId)) : void 0;
+            const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
+            if (bootstrapStatus === "running") {
+              return {
+                success: true,
+                ...agentResult,
+                dispatchAcknowledgementRisk: true,
+                dispatchAcknowledgementRiskReason: "bootstrap_still_running",
+                nextAction: "Wait for worktree_bootstrap_complete event before dispatching work to this node."
+              };
+            }
+          } catch {
+          }
+        }
+        return agentResult;
+      },
+      // ─── Logs ───
+      list_saved_sessions: async (ctx, args) => {
+        const providerType = typeof args?.providerType === "string" ? args.providerType.trim() : typeof args?.agentType === "string" ? args.agentType.trim() : "";
+        const kind = args?.kind === "acp" ? "acp" : "cli";
+        if (!providerType) {
+          return { success: false, error: "providerType required" };
+        }
+        const wantsAll = args?.all === true;
+        const offset = wantsAll ? 0 : Math.max(0, Number(args?.offset) || 0);
+        const limit = wantsAll ? Number.MAX_SAFE_INTEGER : Math.max(1, Math.min(100, Number(args?.limit) || 30));
+        const requestedWorkspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
+        const requestedProviderSessionId = typeof args?.providerSessionId === "string" ? args.providerSessionId.trim() : typeof args?.activeProviderSessionId === "string" ? args.activeProviderSessionId.trim() : "";
+        const providerMeta = ctx.deps.providerLoader.resolve?.(providerType) || ctx.deps.providerLoader.getMeta(providerType);
+        const { sessions: historySessions, hasMore, source } = listProviderHistorySessions(providerType, {
+          canonicalHistory: providerMeta?.nativeHistory,
+          offset,
+          limit,
+          historyBehavior: providerMeta?.historyBehavior,
+          scripts: providerMeta?.scripts
+        });
+        const state = loadState();
+        const savedSessions = getSavedProviderSessions(state, { providerType, kind });
+        const recentSessions = getRecentActivity(state, 200).filter((entry) => entry.providerType === providerType && entry.kind === kind && entry.providerSessionId);
+        const savedSessionById = new Map(savedSessions.map((entry) => [entry.providerSessionId, entry]));
+        const recentSessionById = new Map(recentSessions.map((entry) => [entry.providerSessionId, entry]));
+        const canResumeById = supportsExplicitSessionResume(providerMeta?.resume);
+        return {
+          success: true,
+          sessions: historySessions.map((session) => {
+            const saved = savedSessionById.get(session.historySessionId);
+            const recent = recentSessionById.get(session.historySessionId);
+            const workspace = saved?.workspace || recent?.workspace || session.workspace || (requestedWorkspace && requestedProviderSessionId === session.historySessionId ? requestedWorkspace : void 0);
+            return {
+              id: session.historySessionId,
+              providerSessionId: session.historySessionId,
+              providerType,
+              providerName: saved?.providerName || recent?.providerName || providerType,
+              kind: saved?.kind || recent?.kind || kind,
+              title: saved?.title || recent?.title || session.sessionTitle || session.preview || providerType,
+              workspace,
+              summaryMetadata: saved?.summaryMetadata || recent?.summaryMetadata,
+              preview: session.preview,
+              messageCount: session.messageCount,
+              firstMessageAt: session.firstMessageAt,
+              lastMessageAt: session.lastMessageAt,
+              canResume: !!workspace && canResumeById,
+              historySource: session.source,
+              sourcePath: session.sourcePath,
+              sourceMtimeMs: session.sourceMtimeMs
+            };
+          }),
+          hasMore,
+          source
+        };
+      },
+      // ─── restart_session: IDE / CLI / ACP unified ───
+      restart_session: async (ctx, args) => {
+        const targetType = args?.cliType || args?.agentType || args?.ideType;
+        if (!targetType) throw new Error("cliType or ideType required");
+        const isIde = ctx.deps.cdpManagers.has(targetType) || ctx.deps.providerLoader.getMeta(targetType)?.category === "ide";
+        if (isIde) {
+          await ctx.stopIde(targetType, true);
+          const launchResult = await ctx.launchIde({ ideType: targetType, enableCdp: true, workspace: args?.workspace });
+          return { success: true, restarted: true, ideType: targetType, launch: launchResult };
+        }
+        return ctx.deps.cliManager.handleCliCommand("restart_session", args);
+      }
+    };
     var import_child_process9 = require("child_process");
     var net3 = __toESM2(require("net"));
     var os26 = __toESM2(require("os"));
@@ -75468,326 +75659,1071 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_workspaces();
     init_recent_activity();
     init_cli_detector();
-    init_git_status();
-    init_dist();
     init_logger();
-    var fs26 = __toESM2(require("fs"));
-    var path36 = __toESM2(require("path"));
-    var os27 = __toESM2(require("os"));
-    var ADHDEV_HOME2 = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim() ? process.env.ADHDEV_CONFIG_DIR.trim() : path36.join(os27.homedir(), ".adhdev");
-    var LOG_DIR2 = path36.join(ADHDEV_HOME2, "logs");
-    var MAX_FILE_SIZE = 5 * 1024 * 1024;
-    var MAX_DAYS = 7;
-    try {
-      fs26.mkdirSync(LOG_DIR2, { recursive: true });
-    } catch {
-    }
-    var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
-      "token",
-      "password",
-      "secret",
-      "apiKey",
-      "api_key",
-      "connectionToken",
-      "content",
-      "message",
-      "text"
-    ]);
-    function maskArgs(args) {
-      if (!args || typeof args !== "object") return void 0;
-      const masked = {};
-      for (const [key, value] of Object.entries(args)) {
-        if (SENSITIVE_KEYS.has(key)) {
-          masked[key] = typeof value === "string" ? `[${value.length} chars]` : "[masked]";
-        } else if (key.startsWith("_")) {
-          masked[key] = value;
-        } else if (typeof value === "object" && value !== null) {
-          masked[key] = Array.isArray(value) ? `[Array(${value.length})]` : `[Object]`;
-        } else {
-          masked[key] = value;
+    async function launchIde(ctx, args) {
+      const ideKey = args?.ideId || args?.ideType;
+      const resolvedWorkspace = resolveIdeLaunchWorkspace(
+        {
+          workspace: args?.workspace,
+          workspaceId: args?.workspaceId,
+          useDefaultWorkspace: args?.useDefaultWorkspace
+        },
+        loadConfig2()
+      );
+      const launchArgs = {
+        ideId: ideKey,
+        workspace: resolvedWorkspace,
+        newWindow: args?.newWindow
+      };
+      LOG2.info("LaunchIDE", `target=${ideKey || "auto"}`);
+      const result = await launchWithCdp(launchArgs);
+      if (result.success && result.port && result.ideId && !ctx.deps.cdpManagers.has(result.ideId)) {
+        const logFn = ctx.deps.getCdpLogFn ? ctx.deps.getCdpLogFn(result.ideId) : LOG2.forComponent(`CDP:${result.ideId}`).asLogFn();
+        const provider = ctx.deps.providerLoader.getMeta(result.ideId);
+        const manager = new DaemonCdpManager(result.port, logFn, void 0, provider?.targetFilter);
+        const connected = await manager.connect();
+        if (connected) {
+          registerExtensionProviders(ctx.deps.providerLoader, manager, result.ideId);
+          ctx.deps.cdpManagers.set(result.ideId, manager);
+          LOG2.info("CDP", `Connected: ${result.ideId} (port ${result.port})`);
+          LOG2.info("CDP", `${ctx.deps.cdpManagers.size} IDE(s) connected`);
+          ctx.deps.onCdpManagerCreated?.(result.ideId, manager);
+        }
+      }
+      ctx.deps.onIdeConnected?.();
+      try {
+        const results = await detectIDEs(ctx.deps.providerLoader);
+        ctx.deps.detectedIdes.value = results;
+        ctx.deps.providerLoader.setIdeDetectionResults(results, true);
+      } catch {
+      }
+      if (result.success && resolvedWorkspace) {
+        try {
+          const next = appendRecentActivity(loadState(), {
+            kind: "ide",
+            providerType: result.ideId || ideKey,
+            providerName: result.ideId || ideKey,
+            workspace: resolvedWorkspace,
+            title: result.ideId || ideKey
+          });
+          saveState(next);
+        } catch {
+        }
+      } else if (result.success && (result.ideId || ideKey)) {
+        try {
+          saveState(appendRecentActivity(loadState(), {
+            kind: "ide",
+            providerType: result.ideId || ideKey,
+            providerName: result.ideId || ideKey,
+            title: result.ideId || ideKey
+          }));
+        } catch {
         }
       }
-      return masked;
-    }
-    function getDateStr2() {
-      return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      return { ...result };
     }
-    var currentDate2 = getDateStr2();
-    var currentFile = path36.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
-    var writeCount2 = 0;
-    function checkRotation() {
-      const today = getDateStr2();
-      if (today !== currentDate2) {
-        currentDate2 = today;
-        currentFile = path36.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
-        cleanOldFiles();
+    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 };
       }
-    }
-    function cleanOldFiles() {
-      try {
-        const files = fs26.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
-        const cutoff = /* @__PURE__ */ new Date();
-        cutoff.setDate(cutoff.getDate() - MAX_DAYS);
-        const cutoffStr = cutoff.toISOString().slice(0, 10);
-        for (const file2 of files) {
-          const dateMatch = file2.match(/commands-(\d{4}-\d{2}-\d{2})/);
-          if (dateMatch && dateMatch[1] < cutoffStr) {
+    };
+    init_dist();
+    init_mesh_host_ownership();
+    init_mesh_events();
+    init_config();
+    var meshCrudHandlers = {
+      list_meshes: async (_ctx, _args) => {
+        try {
+          const { listMeshes: listMeshes2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          return { success: true, meshes: listMeshes2() };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      get_mesh: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+        if (!meshRecord?.mesh) return { success: false, error: "Mesh not found" };
+        const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+        const probeRemotePeers = args?.refresh === true || args?.forceRefresh === true;
+        const directTruth = await hydrateInlineMeshDirectTruth({
+          mesh: meshRecord.mesh,
+          meshSource: meshRecord.source,
+          dispatchMeshCommand: ctx.deps.dispatchMeshCommand,
+          getMeshPeerConnectionStatus: ctx.deps.getMeshPeerConnectionStatus,
+          statusInstanceId: ctx.deps.statusInstanceId,
+          localMachineId: loadConfig2().machineId || "",
+          probeRemotePeers,
+          probeCache: ctx.meshGitProbeCache
+        });
+        const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
+        const sourceOfTruth = {
+          membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+          coordinatorOwnsLiveTruth: directTruthSatisfied,
+          directPeerTruth: {
+            required: requireDirectPeerTruth,
+            satisfied: directTruthSatisfied,
+            directEvidenceCount: directTruth.directEvidenceCount,
+            localConfirmedCount: directTruth.localConfirmedCount,
+            peerAttemptedCount: directTruth.peerAttemptedCount,
+            peerConfirmedCount: directTruth.peerConfirmedCount,
+            unavailableNodeIds: directTruth.unavailableNodeIds
+          }
+        };
+        if (requireDirectPeerTruth && !directTruthSatisfied) {
+          return {
+            success: false,
+            code: "mesh_direct_peer_truth_unavailable",
+            error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct get_mesh probes succeed.",
+            sourceOfTruth
+          };
+        }
+        return { success: true, mesh: meshRecord.mesh, sourceOfTruth };
+      },
+      create_mesh: async (_ctx, args) => {
+        const name = typeof args?.name === "string" ? args.name.trim() : "";
+        const repoIdentity = typeof args?.repoIdentity === "string" ? args.repoIdentity.trim() : "";
+        const repoRemoteUrl = typeof args?.repoRemoteUrl === "string" ? args.repoRemoteUrl.trim() : void 0;
+        const defaultBranch = typeof args?.defaultBranch === "string" ? args.defaultBranch.trim() : void 0;
+        if (!name) return { success: false, error: "name required" };
+        try {
+          const { createMesh: createMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const meshHost = args?.meshHost && typeof args.meshHost === "object" && !Array.isArray(args.meshHost) ? args.meshHost : void 0;
+          const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy, meshHost });
+          return { success: true, mesh };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      update_mesh: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { updateMesh: updateMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const patch = {};
+          if (typeof args?.name === "string") patch.name = args.name;
+          if (typeof args?.defaultBranch === "string") patch.defaultBranch = args.defaultBranch;
+          if (args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy)) patch.policy = args.policy;
+          if (args?.coordinator && typeof args.coordinator === "object" && !Array.isArray(args.coordinator)) patch.coordinator = args.coordinator;
+          if (args?.meshHost && typeof args.meshHost === "object" && !Array.isArray(args.meshHost)) patch.meshHost = args.meshHost;
+          if (!Object.keys(patch).length) return { success: false, error: "No updates provided" };
+          const mesh = updateMesh2(meshId, patch);
+          if (!mesh) return { success: false, error: "Mesh not found" };
+          ctx.inlineMeshCache.set(meshId, mesh);
+          ctx.invalidateAggregateMeshStatus(meshId);
+          return { success: true, mesh };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      delete_mesh: async (_ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { deleteMesh: deleteMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const deleted = deleteMesh2(meshId);
+          return { success: true, deleted };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      add_mesh_node: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        if (!workspace) return { success: false, error: "workspace required" };
+        const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node addition");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const { addNode: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const providerPriority = Array.isArray(args?.providerPriority) ? args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean) : [];
+          const readOnly = args?.readOnly === true;
+          const providerRoles = normalizeProviderRoles(args?.providerRoles);
+          const policy = {
+            ...readOnly ? { readOnly: true } : {},
+            ...providerPriority.length ? { providerPriority } : {},
+            ...providerRoles.length ? { providerRoles } : {}
+          };
+          const role = normalizeMeshDaemonRole(args?.role);
+          const daemonId = typeof args?.daemonId === "string" && args.daemonId.trim() ? args.daemonId.trim() : void 0;
+          const machineId = typeof args?.machineId === "string" && args.machineId.trim() ? args.machineId.trim() : void 0;
+          const repoRoot = typeof args?.repoRoot === "string" && args.repoRoot.trim() ? args.repoRoot.trim() : void 0;
+          const node = addNode2(meshId, {
+            workspace,
+            ...repoRoot ? { repoRoot } : {},
+            ...daemonId ? { daemonId } : {},
+            ...machineId ? { machineId } : {},
+            ...policy ? { policy } : {},
+            ...role ? { role } : {}
+          });
+          if (!node) return { success: false, error: "Mesh not found" };
+          ctx.invalidateAggregateMeshStatus(meshId);
+          return { success: true, node };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      update_mesh_node: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node update");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const policy = args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy) ? { ...args.policy } : {};
+          if (Array.isArray(args?.providerPriority)) {
+            const providerPriority = args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean);
+            delete policy.provider_priority;
+            if (providerPriority.length) {
+              policy.providerPriority = providerPriority;
+            } else {
+              delete policy.providerPriority;
+            }
+          }
+          if (Array.isArray(args?.providerRoles)) {
+            const providerRoles = normalizeProviderRoles(args.providerRoles);
+            if (providerRoles.length) {
+              policy.providerRoles = providerRoles;
+            } else {
+              delete policy.providerRoles;
+            }
+          }
+          const patch = { policy };
+          if (typeof args?.systemPrompt === "string") {
+            const trimmed = args.systemPrompt.trim();
+            patch.systemPrompt = trimmed || void 0;
+          } else if (args?.systemPrompt === null) {
+            patch.systemPrompt = void 0;
+          }
+          const node = updateNode2(meshId, nodeId, patch);
+          if (!node) return { success: false, error: "Mesh node not found" };
+          ctx.invalidateAggregateMeshStatus(meshId);
+          return { success: true, node };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      cleanup_mesh_sessions: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node removal");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const mesh = meshRecord?.mesh;
+          if (!mesh) return { success: false, error: "Mesh not found" };
+          const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
+          const mode = ctx.normalizeMeshSessionCleanupMode(args?.mode ?? mesh?.policy?.sessionCleanupOnNodeRemove);
+          const sessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.map((id) => typeof id === "string" ? id.trim() : "").filter(Boolean) : void 0;
+          const result = await ctx.cleanupMeshSessions({
+            meshId,
+            nodeId,
+            node,
+            mode,
+            sessionIds,
+            dryRun: args?.dryRun === true,
+            source: "mesh_cleanup_sessions"
+          });
+          return result;
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      remove_mesh_node: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        try {
+          const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const mesh = meshRecord?.mesh;
+          const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          if (node && !args?._meshDirectDispatch && node.isLocalWorktree !== true && args?.force !== true) {
+            const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : "";
+            const nodeMachineId = readMeshNodeMachineId(node) || "";
+            const selfDaemonId = ctx.deps.statusInstanceId || "";
+            const selfMachineId = (() => {
+              try {
+                return loadConfig2().machineId || "";
+              } catch {
+                return "";
+              }
+            })();
+            const isCoordinatorBaseNode = !!selfDaemonId && (nodeDaemonId === selfDaemonId || nodeMachineId === selfDaemonId) || !!selfMachineId && (nodeDaemonId === selfMachineId || nodeMachineId === selfMachineId);
+            if (isCoordinatorBaseNode) {
+              return {
+                success: false,
+                removed: false,
+                code: "mesh_remove_coordinator_base_node_protected",
+                error: `Refusing to remove the coordinator's own base node '${typeof node.workspace === "string" ? node.workspace : nodeId}'. It is the local non-worktree node bound to this coordinator daemon; removing it breaks live mesh membership and forces a restart.`,
+                recoveryHint: "Remove worktree clone nodes instead, or pass force:true only if you are intentionally tearing down this mesh and accept that the coordinator must be re-registered/restarted."
+              };
+            }
+          }
+          const sessionCleanupMode = ctx.normalizeMeshSessionCleanupMode(
+            args?.sessionCleanupMode ?? args?.session_cleanup_mode ?? mesh?.policy?.sessionCleanupOnNodeRemove
+          );
+          const explicitSessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
+          let sessionCleanup;
+          if (node && sessionCleanupMode !== "preserve") {
+            sessionCleanup = await ctx.cleanupMeshSessions({
+              meshId,
+              nodeId,
+              node,
+              mode: sessionCleanupMode,
+              ...explicitSessionIds && explicitSessionIds.length > 0 ? { sessionIds: explicitSessionIds } : {},
+              source: "mesh_remove_node"
+            });
+            if (sessionCleanup.success === false) return { success: false, removed: false, sessionCleanup };
+          }
+          let worktreeCleanup;
+          if (node?.isLocalWorktree) {
+            const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
+            const isRemoteWorktree = nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, ctx.deps.statusInstanceId) && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch;
+            if (isRemoteWorktree) {
+              const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "remove_mesh_node", {
+                ...typeof args === "object" && args !== null ? args : {},
+                _meshDirectDispatch: true
+              });
+              return forwarded ?? { success: false, error: "no response from remote node" };
+            }
+            const cleanupResult = await ctx.cleanupLocalWorktreeNode({ mesh, node, nodeId, force: args?.force === true });
+            if (cleanupResult.success === false) {
+              return {
+                success: false,
+                removed: false,
+                code: cleanupResult.code,
+                error: cleanupResult.error,
+                recoveryHint: cleanupResult.recoveryHint,
+                ...sessionCleanup ? { sessionCleanup } : {},
+                worktreeCleanup: cleanupResult
+              };
+            }
+            worktreeCleanup = cleanupResult;
+          }
+          let removed = false;
+          if (meshRecord?.inline) {
+            removed = ctx.removeInlineMeshNode(meshId, mesh, nodeId);
+            if (removed) ctx.invalidateAggregateMeshStatus(meshId);
+            if (!removed && !node) removed = true;
+          } else {
+            const { removeNode: removeNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            removed = removeNode2(meshId, nodeId);
+            if (!removed && !node) removed = true;
+            if (removed) ctx.invalidateAggregateMeshStatus(meshId);
+          }
+          if (removed) {
             try {
-              fs26.unlinkSync(path36.join(LOG_DIR2, file2));
+              const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+              appendLedgerEntry2(meshId, {
+                kind: "node_removed",
+                nodeId,
+                payload: {
+                  worktree: !!node?.isLocalWorktree,
+                  sessionCleanupMode,
+                  workspace: typeof node?.workspace === "string" ? node.workspace : void 0,
+                  daemonId: typeof node?.daemonId === "string" ? node.daemonId : void 0,
+                  worktreeBranch: typeof node?.worktreeBranch === "string" ? node.worktreeBranch : void 0,
+                  worktreeCleanupFallback: typeof worktreeCleanup?.fallback === "string" ? worktreeCleanup.fallback : void 0,
+                  forced: worktreeCleanup?.forced === true ? true : void 0,
+                  forceFallbackReason: typeof worktreeCleanup?.reason === "string" ? worktreeCleanup.reason : void 0
+                }
+              });
             } catch {
             }
           }
+          const residueWarning = worktreeCleanup?.residue === true && typeof worktreeCleanup?.residueWarning === "string" ? worktreeCleanup.residueWarning : void 0;
+          return {
+            success: true,
+            removed,
+            ...residueWarning ? { residueWarning } : {},
+            ...sessionCleanup ? { sessionCleanup } : {},
+            ...worktreeCleanup ? { worktreeCleanup } : {}
+          };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      clone_mesh_node: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const sourceNodeId = typeof args?.sourceNodeId === "string" ? args.sourceNodeId.trim() : "";
+        const branch = typeof args?.branch === "string" ? args.branch.trim() : "";
+        const baseBranch = typeof args?.baseBranch === "string" ? args.baseBranch.trim() : void 0;
+        if (!meshId) return { success: false, error: "meshId required" };
+        if (!sourceNodeId) return { success: false, error: "sourceNodeId required" };
+        if (!branch) return { success: false, error: "branch required" };
+        const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "worktree clone");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const mesh = meshRecord?.mesh;
+          if (!mesh) return { success: false, error: "Mesh not found" };
+          const sourceNode = mesh.nodes?.find((n) => meshNodeIdMatches(n, sourceNodeId));
+          if (!sourceNode) return { success: false, error: `Source node '${sourceNodeId}' not found in mesh` };
+          const sourceDaemonId = typeof sourceNode.daemonId === "string" ? sourceNode.daemonId.trim() : void 0;
+          if (sourceDaemonId && !daemonIdsEquivalent(sourceDaemonId, ctx.deps.statusInstanceId) && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+            const forwarded = await ctx.deps.dispatchMeshCommand(sourceDaemonId, "clone_mesh_node", {
+              ...typeof args === "object" && args !== null ? args : {},
+              _meshDirectDispatch: true
+            });
+            return forwarded ?? { success: false, error: "no response from remote node" };
+          }
+          const repoRoot = sourceNode.repoRoot || sourceNode.workspace;
+          const { createWorktree: createWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
+          const result = await createWorktree2({
+            repoRoot,
+            branch,
+            baseBranch,
+            meshName: mesh.name
+          });
+          let node;
+          if (meshRecord.inline) {
+            const { randomUUID: randomUUID15 } = await import("crypto");
+            node = {
+              id: `node_${randomUUID15().replace(/-/g, "")}`,
+              workspace: result.worktreePath,
+              repoRoot: result.worktreePath,
+              daemonId: sourceNode.daemonId,
+              machineId: sourceNode.machineId ?? sourceNode.machine_id,
+              userOverrides: { ...sourceNode.userOverrides || {} },
+              policy: { ...sourceNode.policy || {} },
+              isLocalWorktree: true,
+              worktreeBranch: result.branch,
+              clonedFromNodeId: sourceNodeId
+            };
+            ctx.updateInlineMeshNode(meshId, mesh, node);
+          } else {
+            const { addNode: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+            node = addNode2(meshId, {
+              workspace: result.worktreePath,
+              repoRoot: result.worktreePath,
+              daemonId: sourceNode.daemonId,
+              machineId: sourceNode.machineId ?? sourceNode.machine_id,
+              userOverrides: { ...sourceNode.userOverrides || {} },
+              isLocalWorktree: true,
+              worktreeBranch: result.branch,
+              clonedFromNodeId: sourceNodeId,
+              policy: { ...sourceNode.policy || {} }
+            });
+            if (!node) return { success: false, error: "Failed to register worktree node" };
+            const inlineForReconcile = ctx.getCachedInlineMesh(meshId);
+            if (inlineForReconcile) ctx.updateInlineMeshNode(meshId, inlineForReconcile, node);
+            ctx.invalidateAggregateMeshStatus(meshId);
+          }
+          const persistWorktreeSetupState = async (bootstrapState2) => {
+            node.worktreeBootstrap = bootstrapState2;
+            if (meshRecord.inline) {
+              ctx.updateInlineMeshNode(meshId, mesh, node);
+              return;
+            }
+            try {
+              const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              updateNode2(meshId, node.id, { worktreeBootstrap: bootstrapState2 });
+              ctx.invalidateAggregateMeshStatus(meshId);
+            } catch {
+            }
+          };
+          const appendCloneLedger = async (initSubmodules2, bootstrapState2) => {
+            try {
+              const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+              appendLedgerEntry2(meshId, {
+                kind: "node_cloned",
+                nodeId: node.id,
+                payload: {
+                  sourceNodeId,
+                  branch: result.branch,
+                  worktreePath: result.worktreePath,
+                  submodulesInitialized: initSubmodules2,
+                  worktreeBootstrap: {
+                    status: bootstrapState2.status,
+                    required: bootstrapState2.required,
+                    configSource: bootstrapState2.configSource,
+                    configSourceType: bootstrapState2.configSourceType,
+                    lastCommand: bootstrapState2.lastCommand,
+                    exitCode: bootstrapState2.exitCode
+                  }
+                }
+              });
+            } catch {
+            }
+          };
+          const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
+          const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, result.worktreePath);
+          const runningBootstrapState = {
+            status: "running",
+            required: loadedBootstrap.config?.required !== false,
+            configSource: loadedBootstrap.path || loadedBootstrap.source,
+            configSourceType: loadedBootstrap.sourceType,
+            startedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          await persistWorktreeSetupState(runningBootstrapState);
+          const finishWorktreeSetup = async () => {
+            let submodulesInitialized2 = false;
+            if (initSubmodules) {
+              try {
+                const { runGit: runGit3 } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
+                await runGit3(
+                  { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
+                  ["submodule", "update", "--init", "--recursive"],
+                  { timeoutMs: 12e4 }
+                );
+                submodulesInitialized2 = true;
+                const sourceWorkspace = sourceNode.repoRoot || sourceNode.workspace;
+                if (sourceWorkspace) {
+                  try {
+                    const { runGit: rg } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
+                    const sourceCtx = { workspace: sourceWorkspace, repoRoot: sourceWorkspace, isGitRepo: true };
+                    const worktreeCtx = { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true };
+                    const sourceStatusOut = await rg(sourceCtx, ["submodule", "status", "oss"], { timeoutMs: 1e4 });
+                    const sourceStatusLine = (typeof sourceStatusOut === "string" ? sourceStatusOut : sourceStatusOut?.stdout ?? "").trim();
+                    const sourceShaMatch = sourceStatusLine.match(/^[+\- ]?([0-9a-f]{40})/);
+                    const sourceSha = sourceShaMatch?.[1];
+                    if (sourceSha) {
+                      const ossCtx = { workspace: `${result.worktreePath}/oss`, repoRoot: `${result.worktreePath}/oss`, isGitRepo: true };
+                      const worktreeOssHeadOut = await rg(ossCtx, ["rev-parse", "HEAD"], { timeoutMs: 1e4 });
+                      const worktreeOssSha = (typeof worktreeOssHeadOut === "string" ? worktreeOssHeadOut : worktreeOssHeadOut?.stdout ?? "").trim();
+                      if (worktreeOssSha !== sourceSha) {
+                        await rg(ossCtx, ["fetch", `${sourceWorkspace}/oss`, "HEAD"], { timeoutMs: 6e4 });
+                        await rg(ossCtx, ["checkout", sourceSha], { timeoutMs: 1e4 });
+                        await rg(worktreeCtx, ["add", "oss"], { timeoutMs: 1e4 });
+                        await rg(worktreeCtx, ["commit", "-m", "chore: sync oss to source node HEAD on clone"], { timeoutMs: 1e4 });
+                        console.log(`[mesh] Synced oss submodule to source HEAD ${sourceSha.slice(0, 8)} in worktree`);
+                      }
+                    }
+                  } catch (ossErr) {
+                    console.warn("[mesh] oss submodule sync to source HEAD failed (best-effort):", ossErr.message);
+                  }
+                }
+              } catch (subErr) {
+                console.warn("[mesh] Submodule init failed for worktree:", subErr.message);
+              }
+            }
+            const bootstrapState2 = await runMeshWorktreeBootstrap(mesh, result.worktreePath);
+            await persistWorktreeSetupState(bootstrapState2);
+            await appendCloneLedger(submodulesInitialized2, bootstrapState2);
+            return { submodulesInitialized: submodulesInitialized2, bootstrapState: bootstrapState2 };
+          };
+          const requestedSetupWaitMs = Number(args?.setupWaitMs ?? args?.bootstrapWaitMs ?? 8e3);
+          const setupWaitMs = Number.isFinite(requestedSetupWaitMs) ? Math.min(Math.max(requestedSetupWaitMs, 0), 14e3) : 8e3;
+          const setupPromise = finishWorktreeSetup();
+          const setupResult = await Promise.race([
+            setupPromise.then((value) => ({ completed: true, value })),
+            new Promise((resolve24) => setTimeout(() => resolve24({ completed: false }), setupWaitMs))
+          ]);
+          const emitBootstrapEvent = (eventStatus2, bootstrapState2, startedAtMs, extraPayload) => {
+            try {
+              const durationMs = Date.now() - startedAtMs;
+              const event = `worktree_${eventStatus2}`;
+              const metadataEvent = {
+                source: "clone_mesh_node_bootstrap",
+                nodeId: node.id,
+                status: eventStatus2,
+                worktreePath: result.worktreePath,
+                durationMs,
+                bootstrapStatus: bootstrapState2.status,
+                ...bootstrapState2.error ? { error: bootstrapState2.error } : {},
+                ...bootstrapState2.exitCode !== void 0 ? { exitCode: bootstrapState2.exitCode } : {},
+                ...extraPayload || {}
+              };
+              if (typeof ctx.deps.instanceManager?.getByCategory === "function") {
+                const forwarded = handleMeshForwardEvent(
+                  { instanceManager: ctx.deps.instanceManager },
+                  { event, meshId, nodeId: node.id, workspace: result.worktreePath, metadataEvent }
+                );
+                if (forwarded?.success === true) return;
+              }
+              queuePendingMeshCoordinatorEvent({
+                event,
+                meshId,
+                nodeLabel: node.id,
+                nodeId: node.id,
+                workspace: result.worktreePath,
+                metadataEvent,
+                queuedAt: Date.now()
+              });
+            } catch {
+            }
+          };
+          const bootstrapStartedMs = Date.now();
+          if (!setupResult.completed) {
+            setupPromise.then(({ bootstrapState: bootstrapState2 }) => {
+              emitBootstrapEvent("bootstrap_complete", bootstrapState2, bootstrapStartedMs);
+            }).catch((error48) => {
+              const failedState = {
+                ...runningBootstrapState,
+                status: "failed",
+                completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                error: error48?.message || String(error48)
+              };
+              void persistWorktreeSetupState(failedState);
+              void appendCloneLedger(false, failedState);
+              emitBootstrapEvent("bootstrap_failed", failedState, bootstrapStartedMs, { error: error48?.message || String(error48) });
+            });
+            return {
+              success: true,
+              async: true,
+              status: "accepted",
+              node,
+              worktreePath: result.worktreePath,
+              branch: result.branch,
+              worktreeBootstrap: runningBootstrapState,
+              worktreeSetup: {
+                status: "running",
+                setupWaitMs,
+                message: "Worktree node is registered; submodule/bootstrap setup is continuing in the background."
+              }
+            };
+          }
+          const { submodulesInitialized, bootstrapState } = setupResult.value;
+          emitBootstrapEvent("bootstrap_complete", bootstrapState, bootstrapStartedMs);
+          return {
+            success: true,
+            node,
+            worktreePath: result.worktreePath,
+            branch: result.branch,
+            submodulesInitialized,
+            worktreeBootstrap: bootstrapState
+          };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
+      retry_mesh_node_bootstrap: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        if (!nodeId) return { success: false, error: "nodeId required" };
+        const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "bootstrap retry");
+        if (ownerFailure) return ownerFailure;
+        try {
+          const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const mesh = meshRecord?.mesh;
+          if (!mesh) return { success: false, error: "Mesh not found" };
+          const node = mesh.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
+          if (!node.isLocalWorktree) return { success: false, error: "Node is not a local worktree node" };
+          const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
+          if (nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, ctx.deps.statusInstanceId) && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+            const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "retry_mesh_node_bootstrap", {
+              ...typeof args === "object" && args !== null ? args : {},
+              _meshDirectDispatch: true
+            });
+            return forwarded ?? { success: false, error: "no response from remote node" };
+          }
+          const currentBootstrap = node.worktreeBootstrap;
+          if (currentBootstrap?.status === "running") {
+            return { success: false, error: "Bootstrap is already running for this node" };
+          }
+          const worktreePath = node.workspace || node.repoRoot;
+          if (!worktreePath) return { success: false, error: "Node has no workspace path" };
+          const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, worktreePath);
+          const runningState = {
+            status: "running",
+            required: loadedBootstrap.config?.required !== false,
+            configSource: loadedBootstrap.path || loadedBootstrap.source,
+            configSourceType: loadedBootstrap.sourceType,
+            startedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          const persistState = async (bootstrapState2) => {
+            node.worktreeBootstrap = bootstrapState2;
+            if (meshRecord.inline) {
+              ctx.updateInlineMeshNode(meshId, mesh, node);
+              return;
+            }
+            try {
+              const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              updateNode2(meshId, node.id, { worktreeBootstrap: bootstrapState2 });
+              ctx.invalidateAggregateMeshStatus(meshId);
+            } catch {
+            }
+          };
+          await persistState(runningState);
+          const bootstrapState = await runMeshWorktreeBootstrap(mesh, worktreePath);
+          await persistState(bootstrapState);
+          return { success: true, bootstrapState };
+        } catch (e) {
+          return { success: false, error: e.message };
         }
-      } catch {
       }
-    }
-    function checkSize() {
-      try {
-        const stat2 = fs26.statSync(currentFile);
-        if (stat2.size > MAX_FILE_SIZE) {
-          const backup = currentFile.replace(".jsonl", ".1.jsonl");
+    };
+    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 {
-            fs26.unlinkSync(backup);
+            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 {
           }
-          fs26.renameSync(currentFile, backup);
+          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 };
         }
-      } catch {
-      }
-    }
-    var SKIP_COMMANDS = /* @__PURE__ */ new Set([
-      "heartbeat",
-      "status_report",
-      "read_chat",
-      "mark_session_seen",
-      "delete_notification",
-      "mark_notification_unread"
-    ]);
-    function shouldLogCommand(cmd) {
-      return !SKIP_COMMANDS.has(cmd);
-    }
-    function logCommand(entry) {
-      if (!shouldLogCommand(entry.cmd)) return;
-      try {
-        if (++writeCount2 % 500 === 0) {
-          checkRotation();
-          checkSize();
+      },
+      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." };
         }
-        const line = JSON.stringify({
-          ts: entry.ts,
-          cmd: entry.cmd,
-          src: entry.source,
-          ...entry.interactionId ? { interactionId: entry.interactionId } : {},
-          ...entry.args ? { args: maskArgs(entry.args) } : {},
-          ...entry.success !== void 0 ? { ok: entry.success } : {},
-          ...entry.error ? { err: entry.error } : {},
-          ...entry.durationMs !== void 0 ? { ms: entry.durationMs } : {}
-        });
-        fs26.appendFileSync(currentFile, line + "\n");
-      } catch {
-      }
-    }
-    function getRecentCommands(count = 50) {
-      try {
-        if (!fs26.existsSync(currentFile)) return [];
-        const content = fs26.readFileSync(currentFile, "utf-8");
-        const lines = content.trim().split("\n").filter(Boolean);
-        return lines.slice(-count).map((line) => {
-          try {
-            const parsed = JSON.parse(line);
+        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 {
-              ts: parsed.ts,
-              cmd: parsed.cmd,
-              source: parsed.src,
-              interactionId: parsed.interactionId,
-              args: parsed.args,
-              success: parsed.ok,
-              error: parsed.err,
-              durationMs: parsed.ms
+              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."
             };
-          } catch {
-            return { ts: "", cmd: "parse_error", source: "unknown" };
           }
-        });
-      } catch {
-        return [];
+          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 };
+        }
       }
-    }
-    cleanOldFiles();
-    var yaml4 = __toESM2(require_js_yaml());
-    init_mesh_coordinator();
-    init_coordinator_registry();
-    init_mesh_events();
-    init_mesh_routing();
-    init_mesh_events_utils();
-    init_mesh_host_ownership();
-    init_mesh_fast_forward();
-    var import_node_child_process4 = require("child_process");
-    var import_node_util4 = require("util");
-    var execFileAsync3 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
-    var MAX_CHANGED_FILES2 = 500;
-    function topLevel(path422) {
-      const slash = path422.indexOf("/");
-      return slash === -1 ? path422 : path422.slice(0, slash);
-    }
-    async function analyzeMeshRefineNodeChangeArea(args) {
-      const { nodeId, workspace, branch, baseRef, branchRef, diffCwd, submodulePaths } = args;
-      const base = {
-        nodeId,
-        workspace,
-        branch,
-        changedTopLevelPaths: [],
-        changedFiles: [],
-        touchedSubmodulePaths: [],
-        touchesSubmodule: false,
-        aheadCount: 0
-      };
-      try {
-        let mergeBase = baseRef;
+    };
+    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 { stdout } = await execFileAsync3("git", ["merge-base", baseRef, branchRef], { cwd: diffCwd, encoding: "utf8" });
-          const resolved = stdout.trim();
-          if (resolved) mergeBase = resolved;
-        } catch {
+          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 };
         }
-        const { stdout: countStdout } = await execFileAsync3(
-          "git",
-          ["rev-list", "--count", `${mergeBase}..${branchRef}`],
-          { cwd: diffCwd, encoding: "utf8" }
-        );
-        base.aheadCount = Number.parseInt(countStdout.trim(), 10) || 0;
-        const { stdout: nameStdout } = await execFileAsync3(
-          "git",
-          ["diff", "--name-only", `${mergeBase}..${branchRef}`],
-          { cwd: diffCwd, encoding: "utf8" }
-        );
-        const files = nameStdout.split("\n").map((line) => line.trim()).filter(Boolean).slice(0, MAX_CHANGED_FILES2);
-        base.changedFiles = files;
-        const topSet = /* @__PURE__ */ new Set();
-        const submoduleSet = /* @__PURE__ */ new Set();
-        for (const file2 of files) {
-          const top = topLevel(file2);
-          topSet.add(top);
-          if (submodulePaths.has(file2) || submodulePaths.has(top)) {
-            submoduleSet.add(submodulePaths.has(file2) ? file2 : top);
+      },
+      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 };
         }
-        base.changedTopLevelPaths = [...topSet].sort();
-        base.touchedSubmodulePaths = [...submoduleSet].sort();
-        base.touchesSubmodule = submoduleSet.size > 0;
-        return base;
-      } catch (e) {
-        base.error = e?.message || String(e);
-        return base;
-      }
-    }
-    function orderMeshRefineBatchNodes(changeAreas) {
-      const areaById = {};
-      for (const area of changeAreas) areaById[area.nodeId] = area;
-      const ranked = [...changeAreas].sort((a, b) => {
-        const aSub = a.touchesSubmodule ? 1 : 0;
-        const bSub = b.touchesSubmodule ? 1 : 0;
-        if (aSub !== bSub) return aSub - bSub;
-        const aBreadth = a.changedTopLevelPaths.length;
-        const bBreadth = b.changedTopLevelPaths.length;
-        if (aBreadth !== bBreadth) return aBreadth - bBreadth;
-        return a.nodeId.localeCompare(b.nodeId);
-      });
-      const rationale = [];
-      const nonSub = ranked.filter((a) => !a.touchesSubmodule).map((a) => a.nodeId);
-      const sub = ranked.filter((a) => a.touchesSubmodule).map((a) => a.nodeId);
-      if (nonSub.length) {
-        rationale.push(`Non-submodule nodes first (no submodule-main advance, conflict-free ordering): ${nonSub.join(", ")}`);
-      }
-      if (sub.length) {
-        rationale.push(`Submodule-touching nodes last, serialized (each merge advances submodule main, forcing rebase of the next): ${sub.join(", ")}`);
-      }
-      for (const area of ranked) {
-        if (area.error) rationale.push(`Node ${area.nodeId}: change-area analysis degraded (${area.error}); placed with neutral priority.`);
-      }
-      return { order: ranked.map((a) => a.nodeId), changeAreas: areaById, rationale };
-    }
-    var import_node_child_process5 = require("child_process");
-    var import_node_fs4 = require("fs");
-    var import_node_path2 = require("path");
-    var PREVIEW_DEPLOY_RECORD = ".adhdev/preview-deploy.json";
-    function runGit2(repoRoot, args) {
-      try {
-        return (0, import_node_child_process5.execFileSync)("git", args, {
-          cwd: repoRoot,
-          encoding: "utf8",
-          stdio: ["ignore", "pipe", "ignore"],
-          timeout: 5e3
-        }).trim();
-      } catch {
-        return "";
-      }
-    }
-    function readRecord5(repoRoot) {
-      const path422 = (0, import_node_path2.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
-      if (!(0, import_node_fs4.existsSync)(path422)) return null;
-      try {
-        const parsed = JSON.parse((0, import_node_fs4.readFileSync)(path422, "utf8"));
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-      } catch {
-        return null;
-      }
-    }
-    function normalizeCommit(value) {
-      return typeof value === "string" && /^[0-9a-f]{7,40}$/i.test(value.trim()) ? value.trim() : null;
-    }
-    function readTargetFreshness(record2, currentCommit) {
-      const targets = record2?.targets && typeof record2.targets === "object" && !Array.isArray(record2.targets) ? record2.targets : {};
-      const result = {};
-      for (const targetName of ["npm", "server", "web"]) {
-        const targetRecord = targets[targetName] && typeof targets[targetName] === "object" && !Array.isArray(targets[targetName]) ? targets[targetName] : {};
-        const commit = normalizeCommit(targetRecord.commit);
-        result[targetName] = {
-          commit,
-          deployedAt: typeof targetRecord.deployedAt === "string" ? targetRecord.deployedAt : void 0,
-          status: commit && currentCommit ? commit === currentCommit ? "fresh" : "stale" : "unknown"
-        };
-      }
-      return result;
-    }
-    function readCurrentMainCommit(repoRoot) {
-      const originMain = runGit2(repoRoot, ["rev-parse", "--verify", "origin/main^{commit}"]);
-      if (originMain) {
-        return { currentMainCommit: originMain, currentMainCommitSource: "origin/main" };
-      }
-      const head = runGit2(repoRoot, ["rev-parse", "--verify", "HEAD"]);
-      if (head) {
-        return { currentMainCommit: head, currentMainCommitSource: "HEAD" };
       }
-      return { currentMainCommit: null, currentMainCommitSource: "unknown" };
-    }
-    function buildPreviewFreshness(repoRoot) {
-      const current = readCurrentMainCommit(repoRoot);
-      const record2 = readRecord5(repoRoot);
-      const lastPreviewCommit = normalizeCommit(record2?.lastPreviewCommit);
-      const targets = readTargetFreshness(record2, current.currentMainCommit);
-      let status = "unknown";
-      let nextAction = "Run npm run deploy:preview from the current main commit, then smoke preview.";
-      if (lastPreviewCommit && current.currentMainCommit) {
-        status = lastPreviewCommit === current.currentMainCommit ? "fresh" : "stale";
-        nextAction = status === "fresh" ? "No preview deploy action needed." : "Run npm run deploy:preview from origin/main, then smoke preview.";
-      } else if (!current.currentMainCommit) {
-        nextAction = "Resolve the current main commit before judging preview freshness.";
-      }
-      return {
-        status,
-        lastPreviewCommit,
-        currentMainCommit: current.currentMainCommit,
-        currentMainCommitSource: current.currentMainCommitSource,
-        recordPath: PREVIEW_DEPLOY_RECORD,
-        lastDeployedAt: typeof record2?.updatedAt === "string" ? record2.updatedAt : void 0,
-        lastTarget: typeof record2?.target === "string" ? record2.target : void 0,
-        previewVersion: typeof record2?.previewVersion === "string" ? record2.previewVersion : void 0,
-        targets,
-        nextAction
-      };
-    }
-    init_mesh_refine_status();
+    };
+    init_dist();
+    init_mesh_fast_forward();
     var import_fs16 = require("fs");
     var import_path11 = require("path");
     var MESH_INIT_REFINE_CONFIG_PATH = MESH_REFINE_CONFIG_LOCATIONS[0];
@@ -75899,6 +76835,462 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       const writtenPath = writeConfigFile(workspace, relativePath, suggestedConfig);
       return { path: writtenPath, relativePath, written: true, config: suggestedConfig };
     }
+    init_cli_detector();
+    var fastForwardHandlers = {
+      mesh_init: async (ctx, args) => {
+        const workspace = typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : process.cwd();
+        const mesh = args?.inlineMesh || {};
+        try {
+          const detected = await detectCLIs(ctx.deps.providerLoader, { includeVersion: true });
+          return { ...runMeshInit(mesh, workspace, detected, {
+            write: args?.write === true,
+            overwrite: args?.overwrite === true
+          }) };
+        } catch (e) {
+          return { success: false, error: e?.message || String(e) };
+        }
+      },
+      plan_mesh_refine_node: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+        const mesh = meshRecord?.mesh;
+        const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+        if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
+        return {
+          success: true,
+          dryRun: true,
+          nodeId,
+          workspace: node.workspace,
+          validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
+          mergeWillRun: false,
+          cleanupWillRun: false
+        };
+      },
+      fast_forward_mesh_node: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        let workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
+        let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths) ? args.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
+        let nodeDaemonId;
+        let allowAutoPublishSubmoduleMainCommits = false;
+        if (meshId && nodeId) {
+          const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const mesh = meshRecord?.mesh;
+          const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          if (!workspace) {
+            workspace = typeof node?.workspace === "string" ? node.workspace.trim() : "";
+          }
+          if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
+            submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string");
+          }
+          allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
+          nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
+        }
+        const selfDaemonId = ctx.deps.statusInstanceId;
+        const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
+        if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+          const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "fast_forward_mesh_node", {
+            ...typeof args === "object" && args !== null ? args : {},
+            workspace,
+            _meshDirectDispatch: true
+          });
+          return forwarded ?? { success: false, error: "no response from remote node" };
+        }
+        const result = await fastForwardMeshNode({
+          meshId: meshId || void 0,
+          nodeId: nodeId || void 0,
+          workspace,
+          branch: typeof args?.branch === "string" ? args.branch : void 0,
+          execute: args?.execute === true,
+          dryRun: args?.dryRun === true,
+          updateSubmodules: args?.updateSubmodules === true,
+          submoduleIgnorePaths,
+          mode: args?.mode === "push" ? "push" : "merge",
+          pushSubmodules: args?.pushSubmodules === true,
+          allowAutoPublishSubmoduleMainCommits
+        });
+        return result;
+      },
+      refine_mesh_node: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        {
+          const meshRecordForForward = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const forwardNode = meshRecordForForward?.mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          const nodeDaemonId = typeof forwardNode?.daemonId === "string" ? forwardNode.daemonId.trim() : void 0;
+          const selfDaemonId = ctx.deps.statusInstanceId;
+          const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
+          if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+            const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
+            const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "refine_mesh_node", {
+              ...typeof args === "object" && args !== null ? args : {},
+              coordinatorDaemonId: callerCoordinatorDaemonId || selfDaemonId,
+              _meshDirectDispatch: true
+            });
+            return forwarded ?? { success: false, error: "no response from remote node" };
+          }
+        }
+        const isDryRun = args?.dryRun !== false && args?.execute !== true;
+        if (isDryRun) {
+          const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const mesh = meshRecord?.mesh;
+          const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
+          return {
+            success: true,
+            dryRun: true,
+            nodeId,
+            workspace: node.workspace,
+            validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
+            mergeWillRun: false,
+            cleanupWillRun: false,
+            hint: "Dry-run only \u2014 no merge/push/cleanup performed. Re-invoke with execute:true to converge this node."
+          };
+        }
+        return ctx.startMeshRefineJob(meshId, nodeId, args);
+      },
+      batch_refine_mesh_nodes: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        const requestedNodeIds = Array.isArray(args?.nodeIds) ? args.nodeIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
+        const isDryRun = args?.dryRun !== false && args?.execute !== true;
+        if (isDryRun) return ctx.batchRefineMeshNodes(meshId, requestedNodeIds, args);
+        return ctx.startMeshRefineBatchJob(meshId, requestedNodeIds, args);
+      }
+    };
+    var medFamilyRegistry = new Map(
+      Object.entries({
+        ...cliAgentHandlers,
+        ...ideHandlers,
+        ...meshCrudHandlers,
+        ...meshHostPairingHandlers,
+        ...meshQueueHandlers,
+        ...fastForwardHandlers
+      })
+    );
+    init_config();
+    init_cli_detector();
+    init_git_status();
+    init_dist();
+    init_logger();
+    var fs26 = __toESM2(require("fs"));
+    var path36 = __toESM2(require("path"));
+    var os27 = __toESM2(require("os"));
+    var ADHDEV_HOME2 = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim() ? process.env.ADHDEV_CONFIG_DIR.trim() : path36.join(os27.homedir(), ".adhdev");
+    var LOG_DIR2 = path36.join(ADHDEV_HOME2, "logs");
+    var MAX_FILE_SIZE = 5 * 1024 * 1024;
+    var MAX_DAYS = 7;
+    try {
+      fs26.mkdirSync(LOG_DIR2, { recursive: true });
+    } catch {
+    }
+    var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+      "token",
+      "password",
+      "secret",
+      "apiKey",
+      "api_key",
+      "connectionToken",
+      "content",
+      "message",
+      "text"
+    ]);
+    function maskArgs(args) {
+      if (!args || typeof args !== "object") return void 0;
+      const masked = {};
+      for (const [key, value] of Object.entries(args)) {
+        if (SENSITIVE_KEYS.has(key)) {
+          masked[key] = typeof value === "string" ? `[${value.length} chars]` : "[masked]";
+        } else if (key.startsWith("_")) {
+          masked[key] = value;
+        } else if (typeof value === "object" && value !== null) {
+          masked[key] = Array.isArray(value) ? `[Array(${value.length})]` : `[Object]`;
+        } else {
+          masked[key] = value;
+        }
+      }
+      return masked;
+    }
+    function getDateStr2() {
+      return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    }
+    var currentDate2 = getDateStr2();
+    var currentFile = path36.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+    var writeCount2 = 0;
+    function checkRotation() {
+      const today = getDateStr2();
+      if (today !== currentDate2) {
+        currentDate2 = today;
+        currentFile = path36.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+        cleanOldFiles();
+      }
+    }
+    function cleanOldFiles() {
+      try {
+        const files = fs26.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
+        const cutoff = /* @__PURE__ */ new Date();
+        cutoff.setDate(cutoff.getDate() - MAX_DAYS);
+        const cutoffStr = cutoff.toISOString().slice(0, 10);
+        for (const file2 of files) {
+          const dateMatch = file2.match(/commands-(\d{4}-\d{2}-\d{2})/);
+          if (dateMatch && dateMatch[1] < cutoffStr) {
+            try {
+              fs26.unlinkSync(path36.join(LOG_DIR2, file2));
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    function checkSize() {
+      try {
+        const stat2 = fs26.statSync(currentFile);
+        if (stat2.size > MAX_FILE_SIZE) {
+          const backup = currentFile.replace(".jsonl", ".1.jsonl");
+          try {
+            fs26.unlinkSync(backup);
+          } catch {
+          }
+          fs26.renameSync(currentFile, backup);
+        }
+      } catch {
+      }
+    }
+    var SKIP_COMMANDS = /* @__PURE__ */ new Set([
+      "heartbeat",
+      "status_report",
+      "read_chat",
+      "mark_session_seen",
+      "delete_notification",
+      "mark_notification_unread"
+    ]);
+    function shouldLogCommand(cmd) {
+      return !SKIP_COMMANDS.has(cmd);
+    }
+    function logCommand(entry) {
+      if (!shouldLogCommand(entry.cmd)) return;
+      try {
+        if (++writeCount2 % 500 === 0) {
+          checkRotation();
+          checkSize();
+        }
+        const line = JSON.stringify({
+          ts: entry.ts,
+          cmd: entry.cmd,
+          src: entry.source,
+          ...entry.interactionId ? { interactionId: entry.interactionId } : {},
+          ...entry.args ? { args: maskArgs(entry.args) } : {},
+          ...entry.success !== void 0 ? { ok: entry.success } : {},
+          ...entry.error ? { err: entry.error } : {},
+          ...entry.durationMs !== void 0 ? { ms: entry.durationMs } : {}
+        });
+        fs26.appendFileSync(currentFile, line + "\n");
+      } catch {
+      }
+    }
+    function getRecentCommands(count = 50) {
+      try {
+        if (!fs26.existsSync(currentFile)) return [];
+        const content = fs26.readFileSync(currentFile, "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        return lines.slice(-count).map((line) => {
+          try {
+            const parsed = JSON.parse(line);
+            return {
+              ts: parsed.ts,
+              cmd: parsed.cmd,
+              source: parsed.src,
+              interactionId: parsed.interactionId,
+              args: parsed.args,
+              success: parsed.ok,
+              error: parsed.err,
+              durationMs: parsed.ms
+            };
+          } catch {
+            return { ts: "", cmd: "parse_error", source: "unknown" };
+          }
+        });
+      } catch {
+        return [];
+      }
+    }
+    cleanOldFiles();
+    var yaml4 = __toESM2(require_js_yaml());
+    init_mesh_coordinator();
+    init_coordinator_registry();
+    init_mesh_events();
+    init_mesh_routing();
+    init_mesh_host_ownership();
+    var import_node_child_process4 = require("child_process");
+    var import_node_util4 = require("util");
+    var execFileAsync3 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
+    var MAX_CHANGED_FILES2 = 500;
+    function topLevel(path422) {
+      const slash = path422.indexOf("/");
+      return slash === -1 ? path422 : path422.slice(0, slash);
+    }
+    async function analyzeMeshRefineNodeChangeArea(args) {
+      const { nodeId, workspace, branch, baseRef, branchRef, diffCwd, submodulePaths } = args;
+      const base = {
+        nodeId,
+        workspace,
+        branch,
+        changedTopLevelPaths: [],
+        changedFiles: [],
+        touchedSubmodulePaths: [],
+        touchesSubmodule: false,
+        aheadCount: 0
+      };
+      try {
+        let mergeBase = baseRef;
+        try {
+          const { stdout } = await execFileAsync3("git", ["merge-base", baseRef, branchRef], { cwd: diffCwd, encoding: "utf8" });
+          const resolved = stdout.trim();
+          if (resolved) mergeBase = resolved;
+        } catch {
+        }
+        const { stdout: countStdout } = await execFileAsync3(
+          "git",
+          ["rev-list", "--count", `${mergeBase}..${branchRef}`],
+          { cwd: diffCwd, encoding: "utf8" }
+        );
+        base.aheadCount = Number.parseInt(countStdout.trim(), 10) || 0;
+        const { stdout: nameStdout } = await execFileAsync3(
+          "git",
+          ["diff", "--name-only", `${mergeBase}..${branchRef}`],
+          { cwd: diffCwd, encoding: "utf8" }
+        );
+        const files = nameStdout.split("\n").map((line) => line.trim()).filter(Boolean).slice(0, MAX_CHANGED_FILES2);
+        base.changedFiles = files;
+        const topSet = /* @__PURE__ */ new Set();
+        const submoduleSet = /* @__PURE__ */ new Set();
+        for (const file2 of files) {
+          const top = topLevel(file2);
+          topSet.add(top);
+          if (submodulePaths.has(file2) || submodulePaths.has(top)) {
+            submoduleSet.add(submodulePaths.has(file2) ? file2 : top);
+          }
+        }
+        base.changedTopLevelPaths = [...topSet].sort();
+        base.touchedSubmodulePaths = [...submoduleSet].sort();
+        base.touchesSubmodule = submoduleSet.size > 0;
+        return base;
+      } catch (e) {
+        base.error = e?.message || String(e);
+        return base;
+      }
+    }
+    function orderMeshRefineBatchNodes(changeAreas) {
+      const areaById = {};
+      for (const area of changeAreas) areaById[area.nodeId] = area;
+      const ranked = [...changeAreas].sort((a, b) => {
+        const aSub = a.touchesSubmodule ? 1 : 0;
+        const bSub = b.touchesSubmodule ? 1 : 0;
+        if (aSub !== bSub) return aSub - bSub;
+        const aBreadth = a.changedTopLevelPaths.length;
+        const bBreadth = b.changedTopLevelPaths.length;
+        if (aBreadth !== bBreadth) return aBreadth - bBreadth;
+        return a.nodeId.localeCompare(b.nodeId);
+      });
+      const rationale = [];
+      const nonSub = ranked.filter((a) => !a.touchesSubmodule).map((a) => a.nodeId);
+      const sub = ranked.filter((a) => a.touchesSubmodule).map((a) => a.nodeId);
+      if (nonSub.length) {
+        rationale.push(`Non-submodule nodes first (no submodule-main advance, conflict-free ordering): ${nonSub.join(", ")}`);
+      }
+      if (sub.length) {
+        rationale.push(`Submodule-touching nodes last, serialized (each merge advances submodule main, forcing rebase of the next): ${sub.join(", ")}`);
+      }
+      for (const area of ranked) {
+        if (area.error) rationale.push(`Node ${area.nodeId}: change-area analysis degraded (${area.error}); placed with neutral priority.`);
+      }
+      return { order: ranked.map((a) => a.nodeId), changeAreas: areaById, rationale };
+    }
+    var import_node_child_process5 = require("child_process");
+    var import_node_fs4 = require("fs");
+    var import_node_path2 = require("path");
+    var PREVIEW_DEPLOY_RECORD = ".adhdev/preview-deploy.json";
+    function runGit2(repoRoot, args) {
+      try {
+        return (0, import_node_child_process5.execFileSync)("git", args, {
+          cwd: repoRoot,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"],
+          timeout: 5e3
+        }).trim();
+      } catch {
+        return "";
+      }
+    }
+    function readRecord5(repoRoot) {
+      const path422 = (0, import_node_path2.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
+      if (!(0, import_node_fs4.existsSync)(path422)) return null;
+      try {
+        const parsed = JSON.parse((0, import_node_fs4.readFileSync)(path422, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+      } catch {
+        return null;
+      }
+    }
+    function normalizeCommit(value) {
+      return typeof value === "string" && /^[0-9a-f]{7,40}$/i.test(value.trim()) ? value.trim() : null;
+    }
+    function readTargetFreshness(record2, currentCommit) {
+      const targets = record2?.targets && typeof record2.targets === "object" && !Array.isArray(record2.targets) ? record2.targets : {};
+      const result = {};
+      for (const targetName of ["npm", "server", "web"]) {
+        const targetRecord = targets[targetName] && typeof targets[targetName] === "object" && !Array.isArray(targets[targetName]) ? targets[targetName] : {};
+        const commit = normalizeCommit(targetRecord.commit);
+        result[targetName] = {
+          commit,
+          deployedAt: typeof targetRecord.deployedAt === "string" ? targetRecord.deployedAt : void 0,
+          status: commit && currentCommit ? commit === currentCommit ? "fresh" : "stale" : "unknown"
+        };
+      }
+      return result;
+    }
+    function readCurrentMainCommit(repoRoot) {
+      const originMain = runGit2(repoRoot, ["rev-parse", "--verify", "origin/main^{commit}"]);
+      if (originMain) {
+        return { currentMainCommit: originMain, currentMainCommitSource: "origin/main" };
+      }
+      const head = runGit2(repoRoot, ["rev-parse", "--verify", "HEAD"]);
+      if (head) {
+        return { currentMainCommit: head, currentMainCommitSource: "HEAD" };
+      }
+      return { currentMainCommit: null, currentMainCommitSource: "unknown" };
+    }
+    function buildPreviewFreshness(repoRoot) {
+      const current = readCurrentMainCommit(repoRoot);
+      const record2 = readRecord5(repoRoot);
+      const lastPreviewCommit = normalizeCommit(record2?.lastPreviewCommit);
+      const targets = readTargetFreshness(record2, current.currentMainCommit);
+      let status = "unknown";
+      let nextAction = "Run npm run deploy:preview from the current main commit, then smoke preview.";
+      if (lastPreviewCommit && current.currentMainCommit) {
+        status = lastPreviewCommit === current.currentMainCommit ? "fresh" : "stale";
+        nextAction = status === "fresh" ? "No preview deploy action needed." : "Run npm run deploy:preview from origin/main, then smoke preview.";
+      } else if (!current.currentMainCommit) {
+        nextAction = "Resolve the current main commit before judging preview freshness.";
+      }
+      return {
+        status,
+        lastPreviewCommit,
+        currentMainCommit: current.currentMainCommit,
+        currentMainCommitSource: current.currentMainCommitSource,
+        recordPath: PREVIEW_DEPLOY_RECORD,
+        lastDeployedAt: typeof record2?.updatedAt === "string" ? record2.updatedAt : void 0,
+        lastTarget: typeof record2?.target === "string" ? record2.target : void 0,
+        previewVersion: typeof record2?.previewVersion === "string" ? record2.previewVersion : void 0,
+        targets,
+        nextAction
+      };
+    }
+    init_mesh_refine_status();
     init_mesh_work_queue();
     init_repo_mesh_types();
     var import_os3 = require("os");
@@ -78450,6 +79842,37 @@ ${mergeTreeErr?.stderr || ""}`;
         this.aggregateMeshStatusCache.delete(meshId);
         this.deps.onMeshStateChange?.(meshId);
       }
+      /**
+       * Build the MedFamilyContext handed to RF-ROUTER MED family handlers. Binds the
+       * router-private collaborators those handlers need (mesh resolution, owner
+       * gating, inline-cache mutation, worktree / session cleanup, refine job
+       * starters, IDE stop/launch) plus the inline-mesh and git-probe caches. The
+       * `launchIde` field closes over the freshly-built context so restart_session /
+       * restart_ide invoke the IDE launch directly instead of recursing through
+       * executeDaemonCommand('launch_ide').
+       */
+      buildMedFamilyContext() {
+        const ctx = {
+          deps: this.deps,
+          getMeshForCommand: this.getMeshForCommand.bind(this),
+          getCachedInlineMesh: this.getCachedInlineMesh.bind(this),
+          requireMeshHostMutationOwner: this.requireMeshHostMutationOwner.bind(this),
+          invalidateAggregateMeshStatus: this.invalidateAggregateMeshStatus.bind(this),
+          updateInlineMeshNode: this.updateInlineMeshNode.bind(this),
+          removeInlineMeshNode: this.removeInlineMeshNode.bind(this),
+          normalizeMeshSessionCleanupMode: this.normalizeMeshSessionCleanupMode.bind(this),
+          cleanupMeshSessions: this.cleanupMeshSessions.bind(this),
+          cleanupLocalWorktreeNode: this.cleanupLocalWorktreeNode.bind(this),
+          startMeshRefineJob: this.startMeshRefineJob.bind(this),
+          batchRefineMeshNodes: this.batchRefineMeshNodes.bind(this),
+          startMeshRefineBatchJob: this.startMeshRefineBatchJob.bind(this),
+          stopIde: this.stopIde.bind(this),
+          launchIde: (args) => launchIde(ctx, args),
+          inlineMeshCache: this.inlineMeshCache,
+          meshGitProbeCache: this.meshGitProbeCache
+        };
+        return ctx;
+      }
       async requireMeshHostMutationOwner(meshId, inlineMesh, operation) {
         const meshRecord = await this.getMeshForCommand(meshId, inlineMesh, { preferInline: true });
         const mesh = meshRecord?.mesh;
@@ -80365,6 +81788,10 @@ ${hintLines.join("\n")}` : "",
             getMeshForCommand: this.getMeshForCommand.bind(this)
           }, args);
         }
+        const medFamilyHandler = medFamilyRegistry.get(cmd);
+        if (medFamilyHandler) {
+          return await medFamilyHandler(this.buildMedFamilyContext(), args);
+        }
         switch (cmd) {
           // ─── CLI / ACP commands ───
           case "mesh_forward_event": {
@@ -80385,1315 +81812,6 @@ ${hintLines.join("\n")}` : "",
             this.deps.instanceManager.sendEvent(sessionId, "interactive_prompt_response", response);
             return { success: true };
           }
-          case "launch_cli": {
-            const launchResult = await this.deps.cliManager.handleCliCommand(cmd, args);
-            const meshNodeId = readStringValue(args?.settings?.meshNodeId);
-            const meshId = readStringValue(args?.settings?.meshNodeFor);
-            if (meshNodeId && meshId && launchResult?.success !== false) {
-              try {
-                const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                const meshObj = getMesh2(meshId) ?? this.getCachedInlineMesh(meshId);
-                const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => meshNodeIdMatches(n, meshNodeId)) : void 0;
-                const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
-                if (bootstrapStatus === "running") {
-                  return { success: true, ...launchResult, bootstrapPending: true };
-                }
-              } catch {
-              }
-            }
-            return launchResult;
-          }
-          case "stop_cli":
-          case "set_cli_view_mode":
-          case "record_provider_pty": {
-            return this.deps.cliManager.handleCliCommand(cmd, args);
-          }
-          case "agent_command": {
-            {
-              const dispatchSessionId = readStringValue(args?.targetSessionId, args?.sessionId, args?.instanceId);
-              const dispatchMeshContext = args?.meshContext;
-              if (dispatchSessionId && dispatchMeshContext) {
-                try {
-                  const inst = this.deps.instanceManager.getInstance(dispatchSessionId);
-                  if (inst && typeof inst.updateSettings === "function") {
-                    const stamp = buildMeshWorkerRelayStamp(
-                      inst.getState?.()?.settings,
-                      {
-                        meshId: dispatchMeshContext.meshId,
-                        nodeId: dispatchMeshContext.nodeId,
-                        coordinatorDaemonId: dispatchMeshContext.coordinatorDaemonId,
-                        // Session-level anchor: preserved across the P2P dispatch to a
-                        // remote worker so its completion echoes back to the right session.
-                        coordinatorSessionId: dispatchMeshContext.coordinatorSessionId
-                      }
-                    );
-                    if (stamp) inst.updateSettings(stamp);
-                  }
-                } catch {
-                }
-              }
-            }
-            const agentResult = await this.deps.cliManager.handleCliCommand(cmd, args);
-            const meshCtx = args?.meshContext;
-            const dispatchNodeId = readStringValue(meshCtx?.nodeId);
-            const dispatchMeshId = readStringValue(meshCtx?.meshId);
-            if (dispatchNodeId && dispatchMeshId && agentResult?.success !== false) {
-              try {
-                const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                const meshObj = getMesh2(dispatchMeshId) ?? this.getCachedInlineMesh(dispatchMeshId);
-                const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => meshNodeIdMatches(n, dispatchNodeId)) : void 0;
-                const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
-                if (bootstrapStatus === "running") {
-                  return {
-                    success: true,
-                    ...agentResult,
-                    dispatchAcknowledgementRisk: true,
-                    dispatchAcknowledgementRiskReason: "bootstrap_still_running",
-                    nextAction: "Wait for worktree_bootstrap_complete event before dispatching work to this node."
-                  };
-                }
-              } catch {
-              }
-            }
-            return agentResult;
-          }
-          // ─── Logs ───
-          case "list_saved_sessions": {
-            const providerType = typeof args?.providerType === "string" ? args.providerType.trim() : typeof args?.agentType === "string" ? args.agentType.trim() : "";
-            const kind = args?.kind === "acp" ? "acp" : "cli";
-            if (!providerType) {
-              return { success: false, error: "providerType required" };
-            }
-            const wantsAll = args?.all === true;
-            const offset = wantsAll ? 0 : Math.max(0, Number(args?.offset) || 0);
-            const limit = wantsAll ? Number.MAX_SAFE_INTEGER : Math.max(1, Math.min(100, Number(args?.limit) || 30));
-            const requestedWorkspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
-            const requestedProviderSessionId = typeof args?.providerSessionId === "string" ? args.providerSessionId.trim() : typeof args?.activeProviderSessionId === "string" ? args.activeProviderSessionId.trim() : "";
-            const providerMeta = this.deps.providerLoader.resolve?.(providerType) || this.deps.providerLoader.getMeta(providerType);
-            const { sessions: historySessions, hasMore, source } = listProviderHistorySessions(providerType, {
-              canonicalHistory: providerMeta?.nativeHistory,
-              offset,
-              limit,
-              historyBehavior: providerMeta?.historyBehavior,
-              scripts: providerMeta?.scripts
-            });
-            const state = loadState();
-            const savedSessions = getSavedProviderSessions(state, { providerType, kind });
-            const recentSessions = getRecentActivity(state, 200).filter((entry) => entry.providerType === providerType && entry.kind === kind && entry.providerSessionId);
-            const savedSessionById = new Map(savedSessions.map((entry) => [entry.providerSessionId, entry]));
-            const recentSessionById = new Map(recentSessions.map((entry) => [entry.providerSessionId, entry]));
-            const canResumeById = supportsExplicitSessionResume(providerMeta?.resume);
-            return {
-              success: true,
-              sessions: historySessions.map((session) => {
-                const saved = savedSessionById.get(session.historySessionId);
-                const recent = recentSessionById.get(session.historySessionId);
-                const workspace = saved?.workspace || recent?.workspace || session.workspace || (requestedWorkspace && requestedProviderSessionId === session.historySessionId ? requestedWorkspace : void 0);
-                return {
-                  id: session.historySessionId,
-                  providerSessionId: session.historySessionId,
-                  providerType,
-                  providerName: saved?.providerName || recent?.providerName || providerType,
-                  kind: saved?.kind || recent?.kind || kind,
-                  title: saved?.title || recent?.title || session.sessionTitle || session.preview || providerType,
-                  workspace,
-                  summaryMetadata: saved?.summaryMetadata || recent?.summaryMetadata,
-                  preview: session.preview,
-                  messageCount: session.messageCount,
-                  firstMessageAt: session.firstMessageAt,
-                  lastMessageAt: session.lastMessageAt,
-                  canResume: !!workspace && canResumeById,
-                  historySource: session.source,
-                  sourcePath: session.sourcePath,
-                  sourceMtimeMs: session.sourceMtimeMs
-                };
-              }),
-              hasMore,
-              source
-            };
-          }
-          // ─── restart_session: IDE / CLI / ACP unified ───
-          case "restart_session": {
-            const targetType = args?.cliType || args?.agentType || args?.ideType;
-            if (!targetType) throw new Error("cliType or ideType required");
-            const isIde = this.deps.cdpManagers.has(targetType) || this.deps.providerLoader.getMeta(targetType)?.category === "ide";
-            if (isIde) {
-              await this.stopIde(targetType, true);
-              const launchResult = await this.executeDaemonCommand("launch_ide", { ideType: targetType, enableCdp: true, workspace: args?.workspace });
-              return { success: true, restarted: true, ideType: targetType, launch: launchResult };
-            }
-            return this.deps.cliManager.handleCliCommand(cmd, args);
-          }
-          // ─── IDE stop ───
-          case "stop_ide": {
-            const ideType = args?.ideType;
-            if (!ideType) throw new Error("ideType required");
-            const killProcess = args?.killProcess !== false;
-            await this.stopIde(ideType, killProcess);
-            try {
-              const results = await detectIDEs(this.deps.providerLoader);
-              this.deps.detectedIdes.value = results;
-              this.deps.providerLoader.setIdeDetectionResults(results, true);
-            } catch {
-            }
-            return { success: true, ideType, stopped: true, processKilled: killProcess };
-          }
-          // ─── IDE restart ───
-          case "restart_ide": {
-            const ideType = args?.ideType;
-            if (!ideType) throw new Error("ideType required");
-            await this.stopIde(ideType, true);
-            const launchResult = await this.executeDaemonCommand("launch_ide", { ideType, enableCdp: true, workspace: args?.workspace });
-            return { success: true, ideType, restarted: true, launch: launchResult };
-          }
-          // ─── IDE launch + CDP connect ───
-          case "launch_ide": {
-            const ideKey = args?.ideId || args?.ideType;
-            const resolvedWorkspace = resolveIdeLaunchWorkspace(
-              {
-                workspace: args?.workspace,
-                workspaceId: args?.workspaceId,
-                useDefaultWorkspace: args?.useDefaultWorkspace
-              },
-              loadConfig2()
-            );
-            const launchArgs = {
-              ideId: ideKey,
-              workspace: resolvedWorkspace,
-              newWindow: args?.newWindow
-            };
-            LOG2.info("LaunchIDE", `target=${ideKey || "auto"}`);
-            const result = await launchWithCdp(launchArgs);
-            if (result.success && result.port && result.ideId && !this.deps.cdpManagers.has(result.ideId)) {
-              const logFn = this.deps.getCdpLogFn ? this.deps.getCdpLogFn(result.ideId) : LOG2.forComponent(`CDP:${result.ideId}`).asLogFn();
-              const provider = this.deps.providerLoader.getMeta(result.ideId);
-              const manager = new DaemonCdpManager(result.port, logFn, void 0, provider?.targetFilter);
-              const connected = await manager.connect();
-              if (connected) {
-                registerExtensionProviders(this.deps.providerLoader, manager, result.ideId);
-                this.deps.cdpManagers.set(result.ideId, manager);
-                LOG2.info("CDP", `Connected: ${result.ideId} (port ${result.port})`);
-                LOG2.info("CDP", `${this.deps.cdpManagers.size} IDE(s) connected`);
-                this.deps.onCdpManagerCreated?.(result.ideId, manager);
-              }
-            }
-            this.deps.onIdeConnected?.();
-            try {
-              const results = await detectIDEs(this.deps.providerLoader);
-              this.deps.detectedIdes.value = results;
-              this.deps.providerLoader.setIdeDetectionResults(results, true);
-            } catch {
-            }
-            if (result.success && resolvedWorkspace) {
-              try {
-                const next = appendRecentActivity(loadState(), {
-                  kind: "ide",
-                  providerType: result.ideId || ideKey,
-                  providerName: result.ideId || ideKey,
-                  workspace: resolvedWorkspace,
-                  title: result.ideId || ideKey
-                });
-                saveState(next);
-              } catch {
-              }
-            } else if (result.success && (result.ideId || ideKey)) {
-              try {
-                saveState(appendRecentActivity(loadState(), {
-                  kind: "ide",
-                  providerType: result.ideId || ideKey,
-                  providerName: result.ideId || ideKey,
-                  title: result.ideId || ideKey
-                }));
-              } catch {
-              }
-            }
-            return { ...result };
-          }
-          // ─── Detect providers ───
-          case "detect_provider": {
-            const providerType = typeof args?.providerType === "string" ? args.providerType.trim() : "";
-            if (!providerType) return { success: false, error: "providerType is required" };
-            const normalizedType = this.deps.providerLoader.resolveAlias(providerType);
-            const provider = this.deps.providerLoader.getByAlias(providerType);
-            if (!provider) return { success: false, error: `Provider not found: ${providerType}` };
-            if (provider.category !== "cli" && provider.category !== "acp") {
-              return { success: false, error: `Provider detection is only supported for CLI/ACP providers: ${providerType}` };
-            }
-            if (!this.deps.providerLoader.isMachineProviderEnabled(normalizedType)) {
-              return { success: false, error: `Provider is disabled on this machine: ${providerType}` };
-            }
-            const detected = await detectCLI(normalizedType, this.deps.providerLoader, { includeVersion: false });
-            this.deps.providerLoader.setCliDetectionResults([{
-              id: normalizedType,
-              installed: !!detected,
-              path: detected?.path
-            }], false);
-            this.deps.onStatusChange?.();
-            return {
-              success: true,
-              providerType: normalizedType,
-              detected: !!detected,
-              path: detected?.path || null
-            };
-          }
-          // ─── Detect IDEs ───
-          case "detect_ides": {
-            const results = await detectIDEs(this.deps.providerLoader);
-            this.deps.detectedIdes.value = results;
-            this.deps.providerLoader.setIdeDetectionResults(results, true);
-            return { success: true, detectedInfo: results };
-          }
-          // ─── Mesh CRUD (local meshes.json) ───
-          case "list_meshes": {
-            try {
-              const { listMeshes: listMeshes2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              return { success: true, meshes: listMeshes2() };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "get_mesh": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-            if (!meshRecord?.mesh) return { success: false, error: "Mesh not found" };
-            const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
-            const probeRemotePeers = args?.refresh === true || args?.forceRefresh === true;
-            const directTruth = await hydrateInlineMeshDirectTruth({
-              mesh: meshRecord.mesh,
-              meshSource: meshRecord.source,
-              dispatchMeshCommand: this.deps.dispatchMeshCommand,
-              getMeshPeerConnectionStatus: this.deps.getMeshPeerConnectionStatus,
-              statusInstanceId: this.deps.statusInstanceId,
-              localMachineId: loadConfig2().machineId || "",
-              probeRemotePeers,
-              probeCache: this.meshGitProbeCache
-            });
-            const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
-            const sourceOfTruth = {
-              membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
-              coordinatorOwnsLiveTruth: directTruthSatisfied,
-              directPeerTruth: {
-                required: requireDirectPeerTruth,
-                satisfied: directTruthSatisfied,
-                directEvidenceCount: directTruth.directEvidenceCount,
-                localConfirmedCount: directTruth.localConfirmedCount,
-                peerAttemptedCount: directTruth.peerAttemptedCount,
-                peerConfirmedCount: directTruth.peerConfirmedCount,
-                unavailableNodeIds: directTruth.unavailableNodeIds
-              }
-            };
-            if (requireDirectPeerTruth && !directTruthSatisfied) {
-              return {
-                success: false,
-                code: "mesh_direct_peer_truth_unavailable",
-                error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct get_mesh probes succeed.",
-                sourceOfTruth
-              };
-            }
-            return { success: true, mesh: meshRecord.mesh, sourceOfTruth };
-          }
-          case "create_mesh": {
-            const name = typeof args?.name === "string" ? args.name.trim() : "";
-            const repoIdentity = typeof args?.repoIdentity === "string" ? args.repoIdentity.trim() : "";
-            const repoRemoteUrl = typeof args?.repoRemoteUrl === "string" ? args.repoRemoteUrl.trim() : void 0;
-            const defaultBranch = typeof args?.defaultBranch === "string" ? args.defaultBranch.trim() : void 0;
-            if (!name) return { success: false, error: "name required" };
-            try {
-              const { createMesh: createMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const meshHost = args?.meshHost && typeof args.meshHost === "object" && !Array.isArray(args.meshHost) ? args.meshHost : void 0;
-              const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy, meshHost });
-              return { success: true, mesh };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "update_mesh": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            try {
-              const { updateMesh: updateMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const patch = {};
-              if (typeof args?.name === "string") patch.name = args.name;
-              if (typeof args?.defaultBranch === "string") patch.defaultBranch = args.defaultBranch;
-              if (args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy)) patch.policy = args.policy;
-              if (args?.coordinator && typeof args.coordinator === "object" && !Array.isArray(args.coordinator)) patch.coordinator = args.coordinator;
-              if (args?.meshHost && typeof args.meshHost === "object" && !Array.isArray(args.meshHost)) patch.meshHost = args.meshHost;
-              if (!Object.keys(patch).length) return { success: false, error: "No updates provided" };
-              const mesh = updateMesh2(meshId, patch);
-              if (!mesh) return { success: false, error: "Mesh not found" };
-              this.inlineMeshCache.set(meshId, mesh);
-              this.invalidateAggregateMeshStatus(meshId);
-              return { success: true, mesh };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "get_mesh_host_pairing": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-            const mesh = meshRecord?.mesh;
-            if (!mesh) return { success: false, error: "Mesh not found" };
-            const meshHost = resolveMeshHostStatus(mesh);
-            const pairingStatus = meshHost.pairing?.status || "not_configured";
-            return {
-              success: true,
-              code: pairingStatus === "not_configured" ? "mesh_host_pairing_not_configured" : "mesh_host_pairing_pending",
-              meshId,
-              hostAddress: meshHost.hostAddress,
-              meshHost,
-              manualPairing: {
-                status: pairingStatus,
-                joinImplemented: true,
-                protocol: "standalone_command_direct_v1",
-                description: "Standalone manual pairing can save address/token metadata, apply a host join over direct standalone command HTTP or injected mesh command dispatch, and check persisted status. P2P signaling remains outside this slice."
-              }
-            };
-          }
-          case "configure_mesh_host_pairing": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const hostAddress = typeof args?.hostAddress === "string" ? args.hostAddress.trim() : "";
-            const token = typeof args?.token === "string" ? args.token.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            if (!hostAddress || !token) return { success: false, error: "hostAddress and token required" };
-            try {
-              const { configureMeshHostPairing: configureMeshHostPairing2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const configured = configureMeshHostPairing2(meshId, { hostAddress, token });
-              if (!configured) return { success: false, error: "Mesh not found" };
-              this.inlineMeshCache.set(meshId, configured.mesh);
-              const meshHost = resolveMeshHostStatus(configured.mesh);
-              return {
-                success: true,
-                code: "mesh_host_pairing_pending",
-                meshId,
-                hostAddress: configured.hostAddress,
-                meshHost,
-                manualPairing: {
-                  status: meshHost.pairing?.status || "pairing",
-                  joinImplemented: true,
-                  protocol: "standalone_command_direct_v1",
-                  description: "Manual Mesh Host pairing config was saved locally. Use join_mesh_host_pairing to apply it to the host. Raw token was not persisted."
-                }
-              };
-            } catch (e) {
-              return { success: false, code: "mesh_host_pairing_invalid", meshId, hostAddress, error: e.message };
-            }
-          }
-          case "create_mesh_host_pairing_token": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            try {
-              const { createMeshHostPairingToken: createMeshHostPairingToken2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const created = createMeshHostPairingToken2(meshId, {
-                token: typeof args?.token === "string" ? args.token : void 0,
-                expiresAt: typeof args?.expiresAt === "string" ? args.expiresAt : void 0
-              });
-              if (!created) return { success: false, error: "Mesh not found" };
-              this.inlineMeshCache.set(meshId, created.mesh);
-              this.invalidateAggregateMeshStatus(meshId);
-              return {
-                success: true,
-                code: "mesh_host_pairing_token_created",
-                meshId,
-                token: created.token,
-                tokenId: created.tokenId,
-                expiresAt: created.expiresAt,
-                meshHost: resolveMeshHostStatus(created.mesh),
-                warning: "Raw token is returned once and is not persisted; share it with member daemons over a trusted channel."
-              };
-            } catch (e) {
-              return { success: false, code: "mesh_host_pairing_token_invalid", meshId, error: e.message };
-            }
-          }
-          case "apply_mesh_host_join": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const token = typeof args?.token === "string" ? args.token.trim() : "";
-            const memberNode = args?.memberNode && typeof args.memberNode === "object" && !Array.isArray(args.memberNode) ? args.memberNode : null;
-            if (!meshId) return { success: false, error: "meshId required" };
-            if (!token || !memberNode) return { success: false, error: "token and memberNode required" };
-            try {
-              const { applyMeshHostJoinRequest: applyMeshHostJoinRequest2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const applied = applyMeshHostJoinRequest2(meshId, {
-                token,
-                memberNode,
-                memberMeshId: typeof args?.memberMeshId === "string" ? args.memberMeshId : void 0
-              });
-              if (!applied) return { success: false, error: "Mesh not found" };
-              if (!applied.accepted) {
-                return {
-                  success: false,
-                  code: "mesh_host_join_rejected",
-                  meshId,
-                  tokenId: applied.tokenId,
-                  meshHost: applied.meshHost ? resolveMeshHostStatus({ meshHost: applied.meshHost }) : void 0,
-                  error: applied.reason
-                };
-              }
-              this.inlineMeshCache.set(meshId, applied.mesh);
-              this.invalidateAggregateMeshStatus(meshId);
-              try {
-                const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-                appendLedgerEntry2(meshId, {
-                  kind: "node_joined",
-                  nodeId: applied.node.id,
-                  payload: { role: "member", tokenId: applied.tokenId, workspace: applied.node.workspace }
-                });
-              } catch {
-              }
-              return {
-                success: true,
-                code: "mesh_host_join_accepted",
-                meshId,
-                node: applied.node,
-                tokenId: applied.tokenId,
-                meshHost: resolveMeshHostStatus(applied.mesh)
-              };
-            } catch (e) {
-              return { success: false, code: "mesh_host_join_failed", meshId, error: e.message };
-            }
-          }
-          case "join_mesh_host_pairing": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const token = typeof args?.token === "string" ? args.token.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            if (!token) return { success: false, error: "token required because raw pairing tokens are not persisted" };
-            const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-            const mesh = meshRecord?.mesh;
-            if (!mesh) return { success: false, error: "Mesh not found" };
-            const meshHost = resolveMeshHostStatus(mesh);
-            if (meshHost.role !== "member") {
-              return { success: false, code: "mesh_host_join_not_member", meshId, meshHost, error: "join_mesh_host_pairing must run from a member daemon configured with a Mesh Host address/token." };
-            }
-            try {
-              const { tokenIdForManualPairing: tokenIdForManualPairing2, markMeshHostPairingJoined: markMeshHostPairingJoined2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const tokenId = tokenIdForManualPairing2(token);
-              if (meshHost.pairing?.tokenId && meshHost.pairing.tokenId !== tokenId) {
-                return { success: false, code: "mesh_host_join_rejected", meshId, tokenId, meshHost, error: "invalid pairing token" };
-              }
-              const memberNode = buildMemberJoinNode(mesh, args, this.deps.statusInstanceId);
-              if (!memberNode) return { success: false, error: "member node metadata unavailable" };
-              const hostMeshId = typeof args?.hostMeshId === "string" && args.hostMeshId.trim() ? args.hostMeshId.trim() : meshId;
-              const hostDaemonId = typeof args?.hostDaemonId === "string" && args.hostDaemonId.trim() ? args.hostDaemonId.trim() : meshHost.hostDaemonId;
-              let hostResult;
-              let transport;
-              if (hostDaemonId && this.deps.dispatchMeshCommand) {
-                transport = "mesh_command_dispatch";
-                hostResult = await this.deps.dispatchMeshCommand(hostDaemonId, "apply_mesh_host_join", {
-                  meshId: hostMeshId,
-                  token,
-                  memberMeshId: meshId,
-                  memberNode
-                });
-              } else if (meshHost.hostAddress) {
-                transport = "standalone_http_command";
-                const commandUrl = normalizeStandaloneHostCommandUrl(meshHost.hostAddress);
-                const response = await fetch(commandUrl, {
-                  method: "POST",
-                  headers: { "Content-Type": "application/json" },
-                  body: JSON.stringify({ type: "apply_mesh_host_join", payload: { meshId: hostMeshId, token, memberMeshId: meshId, memberNode } })
-                });
-                hostResult = await response.json().catch(() => ({ success: false, error: `Host returned HTTP ${response.status}` }));
-                if (!response.ok && hostResult?.success !== false) hostResult = { success: false, error: `Host returned HTTP ${response.status}` };
-              } else {
-                return {
-                  success: false,
-                  code: "mesh_host_join_transport_unavailable",
-                  meshId,
-                  meshHost,
-                  error: "No hostDaemonId dispatch path or hostAddress HTTP command path is available. P2P signaling join is not implemented in this slice."
-                };
-              }
-              if (!hostResult?.success) {
-                return { success: false, code: hostResult?.code || "mesh_host_join_rejected", meshId, meshHost, transport, error: hostResult?.error || "Mesh Host rejected join request", hostResult };
-              }
-              const joined = meshRecord.inline ? null : markMeshHostPairingJoined2(meshId, {
-                tokenId: hostResult.tokenId || tokenId,
-                hostDaemonId: hostResult.meshHost?.hostDaemonId || hostDaemonId,
-                hostNodeId: hostResult.meshHost?.hostNodeId,
-                joinedAt: hostResult.meshHost?.pairing?.joinedAt
-              });
-              if (joined) {
-                this.inlineMeshCache.set(meshId, joined.mesh);
-                this.invalidateAggregateMeshStatus(meshId);
-              }
-              return {
-                success: true,
-                code: "mesh_host_join_applied",
-                meshId,
-                hostMeshId,
-                transport,
-                node: hostResult.node,
-                tokenId: hostResult.tokenId || tokenId,
-                meshHost: joined ? resolveMeshHostStatus(joined.mesh) : { ...meshHost, pairing: { ...meshHost.pairing || {}, status: "paired", tokenId: hostResult.tokenId || tokenId } },
-                hostResult,
-                manualPairing: {
-                  status: "paired",
-                  joinImplemented: true,
-                  protocol: "standalone_command_direct_v1",
-                  description: "Mesh Host accepted the join and local member pairing status was marked paired. P2P runtime signaling remains outside this slice."
-                }
-              };
-            } catch (e) {
-              return { success: false, code: "mesh_host_join_failed", meshId, meshHost, error: e.message };
-            }
-          }
-          case "delete_mesh": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            try {
-              const { deleteMesh: deleteMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const deleted = deleteMesh2(meshId);
-              return { success: true, deleted };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "get_mesh_queue": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            try {
-              const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2, describeTaskDependencyState: describeTaskDependencyState2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
-              const status = Array.isArray(args?.status) ? args.status.map((s2) => typeof s2 === "string" ? s2.trim() : "").filter(Boolean) : void 0;
-              const rawQueue = getQueue2(meshId, { status });
-              const statusById = new Map(getQueue2(meshId).map((task) => [task.id, task.status]));
-              const queue = rawQueue.map((task) => Array.isArray(task.dependsOn) && task.dependsOn.length > 0 ? { ...task, ...describeTaskDependencyState2(task, statusById) } : task);
-              const summary = getMeshQueueStats2(meshId);
-              return {
-                success: true,
-                queue,
-                summary,
-                sourceOfTruth: {
-                  kind: "mesh_work_queue_file",
-                  activeStatuses: ["pending", "assigned"],
-                  historicalStatuses: ["completed", "failed", "cancelled"],
-                  notes: "pending/assigned are active work; completed/failed/cancelled are historical records."
-                }
-              };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "cancel_mesh_queue_task": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const taskId = typeof args?.taskId === "string" ? args.taskId.trim() : "";
-            if (!meshId || !taskId) return { success: false, error: "meshId and taskId required" };
-            const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "queue cancellation");
-            if (ownerFailure) return ownerFailure;
-            try {
-              const { cancelTask: cancelTask2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
-              const reason = typeof args?.reason === "string" ? args.reason : void 0;
-              const task = cancelTask2(meshId, taskId, { reason });
-              if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
-              return { success: true, task };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "requeue_mesh_queue_task": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const taskId = typeof args?.taskId === "string" ? args.taskId.trim() : "";
-            if (!meshId || !taskId) return { success: false, error: "meshId and taskId required" };
-            const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "queue requeue");
-            if (ownerFailure) return ownerFailure;
-            try {
-              const { requeueTask: requeueTask2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
-              const task = requeueTask2(meshId, taskId, {
-                reason: typeof args?.reason === "string" ? args.reason : void 0,
-                targetNodeId: typeof args?.targetNodeId === "string" ? args.targetNodeId.trim() : void 0,
-                targetSessionId: typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : void 0,
-                clearTargetNode: args?.clearTargetNode === true,
-                clearTargetSession: args?.clearTargetSession !== false
-              });
-              if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
-              return { success: true, task };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "add_mesh_node": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            if (!workspace) return { success: false, error: "workspace required" };
-            const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node addition");
-            if (ownerFailure) return ownerFailure;
-            try {
-              const { addNode: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const providerPriority = Array.isArray(args?.providerPriority) ? args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean) : [];
-              const readOnly = args?.readOnly === true;
-              const providerRoles = normalizeProviderRoles(args?.providerRoles);
-              const policy = {
-                ...readOnly ? { readOnly: true } : {},
-                ...providerPriority.length ? { providerPriority } : {},
-                ...providerRoles.length ? { providerRoles } : {}
-              };
-              const role = normalizeMeshDaemonRole(args?.role);
-              const daemonId = typeof args?.daemonId === "string" && args.daemonId.trim() ? args.daemonId.trim() : void 0;
-              const machineId = typeof args?.machineId === "string" && args.machineId.trim() ? args.machineId.trim() : void 0;
-              const repoRoot = typeof args?.repoRoot === "string" && args.repoRoot.trim() ? args.repoRoot.trim() : void 0;
-              const node = addNode2(meshId, {
-                workspace,
-                ...repoRoot ? { repoRoot } : {},
-                ...daemonId ? { daemonId } : {},
-                ...machineId ? { machineId } : {},
-                ...policy ? { policy } : {},
-                ...role ? { role } : {}
-              });
-              if (!node) return { success: false, error: "Mesh not found" };
-              this.invalidateAggregateMeshStatus(meshId);
-              return { success: true, node };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "update_mesh_node": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
-            if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
-            const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node update");
-            if (ownerFailure) return ownerFailure;
-            try {
-              const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const policy = args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy) ? { ...args.policy } : {};
-              if (Array.isArray(args?.providerPriority)) {
-                const providerPriority = args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean);
-                delete policy.provider_priority;
-                if (providerPriority.length) {
-                  policy.providerPriority = providerPriority;
-                } else {
-                  delete policy.providerPriority;
-                }
-              }
-              if (Array.isArray(args?.providerRoles)) {
-                const providerRoles = normalizeProviderRoles(args.providerRoles);
-                if (providerRoles.length) {
-                  policy.providerRoles = providerRoles;
-                } else {
-                  delete policy.providerRoles;
-                }
-              }
-              const patch = { policy };
-              if (typeof args?.systemPrompt === "string") {
-                const trimmed = args.systemPrompt.trim();
-                patch.systemPrompt = trimmed || void 0;
-              } else if (args?.systemPrompt === null) {
-                patch.systemPrompt = void 0;
-              }
-              const node = updateNode2(meshId, nodeId, patch);
-              if (!node) return { success: false, error: "Mesh node not found" };
-              this.invalidateAggregateMeshStatus(meshId);
-              return { success: true, node };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "cleanup_mesh_sessions": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
-            if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
-            const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node removal");
-            if (ownerFailure) return ownerFailure;
-            try {
-              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-              const mesh = meshRecord?.mesh;
-              if (!mesh) return { success: false, error: "Mesh not found" };
-              const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-              if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
-              const mode = this.normalizeMeshSessionCleanupMode(args?.mode ?? mesh?.policy?.sessionCleanupOnNodeRemove);
-              const sessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.map((id) => typeof id === "string" ? id.trim() : "").filter(Boolean) : void 0;
-              const result = await this.cleanupMeshSessions({
-                meshId,
-                nodeId,
-                node,
-                mode,
-                sessionIds,
-                dryRun: args?.dryRun === true,
-                source: "mesh_cleanup_sessions"
-              });
-              return result;
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "mesh_init": {
-            const workspace = typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : process.cwd();
-            const mesh = args?.inlineMesh || {};
-            try {
-              const detected = await detectCLIs(this.deps.providerLoader, { includeVersion: true });
-              return { ...runMeshInit(mesh, workspace, detected, {
-                write: args?.write === true,
-                overwrite: args?.overwrite === true
-              }) };
-            } catch (e) {
-              return { success: false, error: e?.message || String(e) };
-            }
-          }
-          case "plan_mesh_refine_node": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
-            if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
-            const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-            const mesh = meshRecord?.mesh;
-            const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-            if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
-            return {
-              success: true,
-              dryRun: true,
-              nodeId,
-              workspace: node.workspace,
-              validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
-              mergeWillRun: false,
-              cleanupWillRun: false
-            };
-          }
-          case "fast_forward_mesh_node": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
-            let workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
-            let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths) ? args.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
-            let nodeDaemonId;
-            let allowAutoPublishSubmoduleMainCommits = false;
-            if (meshId && nodeId) {
-              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-              const mesh = meshRecord?.mesh;
-              const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-              if (!workspace) {
-                workspace = typeof node?.workspace === "string" ? node.workspace.trim() : "";
-              }
-              if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
-                submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string");
-              }
-              allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
-              nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
-            }
-            const selfDaemonId = this.deps.statusInstanceId;
-            const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
-            if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
-              const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "fast_forward_mesh_node", {
-                ...typeof args === "object" && args !== null ? args : {},
-                workspace,
-                _meshDirectDispatch: true
-              });
-              return forwarded ?? { success: false, error: "no response from remote node" };
-            }
-            const result = await fastForwardMeshNode({
-              meshId: meshId || void 0,
-              nodeId: nodeId || void 0,
-              workspace,
-              branch: typeof args?.branch === "string" ? args.branch : void 0,
-              execute: args?.execute === true,
-              dryRun: args?.dryRun === true,
-              updateSubmodules: args?.updateSubmodules === true,
-              submoduleIgnorePaths,
-              mode: args?.mode === "push" ? "push" : "merge",
-              pushSubmodules: args?.pushSubmodules === true,
-              allowAutoPublishSubmoduleMainCommits
-            });
-            return result;
-          }
-          case "refine_mesh_node": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
-            if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
-            {
-              const meshRecordForForward = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-              const forwardNode = meshRecordForForward?.mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-              const nodeDaemonId = typeof forwardNode?.daemonId === "string" ? forwardNode.daemonId.trim() : void 0;
-              const selfDaemonId = this.deps.statusInstanceId;
-              const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
-              if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
-                const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
-                const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "refine_mesh_node", {
-                  ...typeof args === "object" && args !== null ? args : {},
-                  coordinatorDaemonId: callerCoordinatorDaemonId || selfDaemonId,
-                  _meshDirectDispatch: true
-                });
-                return forwarded ?? { success: false, error: "no response from remote node" };
-              }
-            }
-            const isDryRun = args?.dryRun !== false && args?.execute !== true;
-            if (isDryRun) {
-              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-              const mesh = meshRecord?.mesh;
-              const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-              if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
-              return {
-                success: true,
-                dryRun: true,
-                nodeId,
-                workspace: node.workspace,
-                validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
-                mergeWillRun: false,
-                cleanupWillRun: false,
-                hint: "Dry-run only \u2014 no merge/push/cleanup performed. Re-invoke with execute:true to converge this node."
-              };
-            }
-            return this.startMeshRefineJob(meshId, nodeId, args);
-          }
-          case "batch_refine_mesh_nodes": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            const requestedNodeIds = Array.isArray(args?.nodeIds) ? args.nodeIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
-            const isDryRun = args?.dryRun !== false && args?.execute !== true;
-            if (isDryRun) return this.batchRefineMeshNodes(meshId, requestedNodeIds, args);
-            return this.startMeshRefineBatchJob(meshId, requestedNodeIds, args);
-          }
-          case "remove_mesh_node": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
-            if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
-            try {
-              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-              const mesh = meshRecord?.mesh;
-              const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-              if (node && !args?._meshDirectDispatch && node.isLocalWorktree !== true && args?.force !== true) {
-                const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : "";
-                const nodeMachineId = readMeshNodeMachineId(node) || "";
-                const selfDaemonId = this.deps.statusInstanceId || "";
-                const selfMachineId = (() => {
-                  try {
-                    return loadConfig2().machineId || "";
-                  } catch {
-                    return "";
-                  }
-                })();
-                const isCoordinatorBaseNode = !!selfDaemonId && (nodeDaemonId === selfDaemonId || nodeMachineId === selfDaemonId) || !!selfMachineId && (nodeDaemonId === selfMachineId || nodeMachineId === selfMachineId);
-                if (isCoordinatorBaseNode) {
-                  return {
-                    success: false,
-                    removed: false,
-                    code: "mesh_remove_coordinator_base_node_protected",
-                    error: `Refusing to remove the coordinator's own base node '${typeof node.workspace === "string" ? node.workspace : nodeId}'. It is the local non-worktree node bound to this coordinator daemon; removing it breaks live mesh membership and forces a restart.`,
-                    recoveryHint: "Remove worktree clone nodes instead, or pass force:true only if you are intentionally tearing down this mesh and accept that the coordinator must be re-registered/restarted."
-                  };
-                }
-              }
-              const sessionCleanupMode = this.normalizeMeshSessionCleanupMode(
-                args?.sessionCleanupMode ?? args?.session_cleanup_mode ?? mesh?.policy?.sessionCleanupOnNodeRemove
-              );
-              const explicitSessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
-              let sessionCleanup;
-              if (node && sessionCleanupMode !== "preserve") {
-                sessionCleanup = await this.cleanupMeshSessions({
-                  meshId,
-                  nodeId,
-                  node,
-                  mode: sessionCleanupMode,
-                  ...explicitSessionIds && explicitSessionIds.length > 0 ? { sessionIds: explicitSessionIds } : {},
-                  source: "mesh_remove_node"
-                });
-                if (sessionCleanup.success === false) return { success: false, removed: false, sessionCleanup };
-              }
-              let worktreeCleanup;
-              if (node?.isLocalWorktree) {
-                const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
-                const isRemoteWorktree = nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch;
-                if (isRemoteWorktree) {
-                  const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "remove_mesh_node", {
-                    ...typeof args === "object" && args !== null ? args : {},
-                    _meshDirectDispatch: true
-                  });
-                  return forwarded ?? { success: false, error: "no response from remote node" };
-                }
-                const cleanupResult = await this.cleanupLocalWorktreeNode({ mesh, node, nodeId, force: args?.force === true });
-                if (cleanupResult.success === false) {
-                  return {
-                    success: false,
-                    removed: false,
-                    code: cleanupResult.code,
-                    error: cleanupResult.error,
-                    recoveryHint: cleanupResult.recoveryHint,
-                    ...sessionCleanup ? { sessionCleanup } : {},
-                    worktreeCleanup: cleanupResult
-                  };
-                }
-                worktreeCleanup = cleanupResult;
-              }
-              let removed = false;
-              if (meshRecord?.inline) {
-                removed = this.removeInlineMeshNode(meshId, mesh, nodeId);
-                if (removed) this.invalidateAggregateMeshStatus(meshId);
-                if (!removed && !node) removed = true;
-              } else {
-                const { removeNode: removeNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                removed = removeNode2(meshId, nodeId);
-                if (!removed && !node) removed = true;
-                if (removed) this.invalidateAggregateMeshStatus(meshId);
-              }
-              if (removed) {
-                try {
-                  const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-                  appendLedgerEntry2(meshId, {
-                    kind: "node_removed",
-                    nodeId,
-                    payload: {
-                      worktree: !!node?.isLocalWorktree,
-                      sessionCleanupMode,
-                      workspace: typeof node?.workspace === "string" ? node.workspace : void 0,
-                      daemonId: typeof node?.daemonId === "string" ? node.daemonId : void 0,
-                      worktreeBranch: typeof node?.worktreeBranch === "string" ? node.worktreeBranch : void 0,
-                      worktreeCleanupFallback: typeof worktreeCleanup?.fallback === "string" ? worktreeCleanup.fallback : void 0,
-                      forced: worktreeCleanup?.forced === true ? true : void 0,
-                      forceFallbackReason: typeof worktreeCleanup?.reason === "string" ? worktreeCleanup.reason : void 0
-                    }
-                  });
-                } catch {
-                }
-              }
-              const residueWarning = worktreeCleanup?.residue === true && typeof worktreeCleanup?.residueWarning === "string" ? worktreeCleanup.residueWarning : void 0;
-              return {
-                success: true,
-                removed,
-                ...residueWarning ? { residueWarning } : {},
-                ...sessionCleanup ? { sessionCleanup } : {},
-                ...worktreeCleanup ? { worktreeCleanup } : {}
-              };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "clone_mesh_node": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const sourceNodeId = typeof args?.sourceNodeId === "string" ? args.sourceNodeId.trim() : "";
-            const branch = typeof args?.branch === "string" ? args.branch.trim() : "";
-            const baseBranch = typeof args?.baseBranch === "string" ? args.baseBranch.trim() : void 0;
-            if (!meshId) return { success: false, error: "meshId required" };
-            if (!sourceNodeId) return { success: false, error: "sourceNodeId required" };
-            if (!branch) return { success: false, error: "branch required" };
-            const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "worktree clone");
-            if (ownerFailure) return ownerFailure;
-            try {
-              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-              const mesh = meshRecord?.mesh;
-              if (!mesh) return { success: false, error: "Mesh not found" };
-              const sourceNode = mesh.nodes?.find((n) => meshNodeIdMatches(n, sourceNodeId));
-              if (!sourceNode) return { success: false, error: `Source node '${sourceNodeId}' not found in mesh` };
-              const sourceDaemonId = typeof sourceNode.daemonId === "string" ? sourceNode.daemonId.trim() : void 0;
-              if (sourceDaemonId && !daemonIdsEquivalent(sourceDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
-                const forwarded = await this.deps.dispatchMeshCommand(sourceDaemonId, "clone_mesh_node", {
-                  ...typeof args === "object" && args !== null ? args : {},
-                  _meshDirectDispatch: true
-                });
-                return forwarded ?? { success: false, error: "no response from remote node" };
-              }
-              const repoRoot = sourceNode.repoRoot || sourceNode.workspace;
-              const { createWorktree: createWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
-              const result = await createWorktree2({
-                repoRoot,
-                branch,
-                baseBranch,
-                meshName: mesh.name
-              });
-              let node;
-              if (meshRecord.inline) {
-                const { randomUUID: randomUUID15 } = await import("crypto");
-                node = {
-                  id: `node_${randomUUID15().replace(/-/g, "")}`,
-                  workspace: result.worktreePath,
-                  repoRoot: result.worktreePath,
-                  daemonId: sourceNode.daemonId,
-                  machineId: sourceNode.machineId ?? sourceNode.machine_id,
-                  userOverrides: { ...sourceNode.userOverrides || {} },
-                  policy: { ...sourceNode.policy || {} },
-                  isLocalWorktree: true,
-                  worktreeBranch: result.branch,
-                  clonedFromNodeId: sourceNodeId
-                };
-                this.updateInlineMeshNode(meshId, mesh, node);
-              } else {
-                const { addNode: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                node = addNode2(meshId, {
-                  workspace: result.worktreePath,
-                  repoRoot: result.worktreePath,
-                  daemonId: sourceNode.daemonId,
-                  machineId: sourceNode.machineId ?? sourceNode.machine_id,
-                  userOverrides: { ...sourceNode.userOverrides || {} },
-                  isLocalWorktree: true,
-                  worktreeBranch: result.branch,
-                  clonedFromNodeId: sourceNodeId,
-                  policy: { ...sourceNode.policy || {} }
-                });
-                if (!node) return { success: false, error: "Failed to register worktree node" };
-                const inlineForReconcile = this.getCachedInlineMesh(meshId);
-                if (inlineForReconcile) this.updateInlineMeshNode(meshId, inlineForReconcile, node);
-                this.invalidateAggregateMeshStatus(meshId);
-              }
-              const persistWorktreeSetupState = async (bootstrapState2) => {
-                node.worktreeBootstrap = bootstrapState2;
-                if (meshRecord.inline) {
-                  this.updateInlineMeshNode(meshId, mesh, node);
-                  return;
-                }
-                try {
-                  const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                  updateNode2(meshId, node.id, { worktreeBootstrap: bootstrapState2 });
-                  this.invalidateAggregateMeshStatus(meshId);
-                } catch {
-                }
-              };
-              const appendCloneLedger = async (initSubmodules2, bootstrapState2) => {
-                try {
-                  const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-                  appendLedgerEntry2(meshId, {
-                    kind: "node_cloned",
-                    nodeId: node.id,
-                    payload: {
-                      sourceNodeId,
-                      branch: result.branch,
-                      worktreePath: result.worktreePath,
-                      submodulesInitialized: initSubmodules2,
-                      worktreeBootstrap: {
-                        status: bootstrapState2.status,
-                        required: bootstrapState2.required,
-                        configSource: bootstrapState2.configSource,
-                        configSourceType: bootstrapState2.configSourceType,
-                        lastCommand: bootstrapState2.lastCommand,
-                        exitCode: bootstrapState2.exitCode
-                      }
-                    }
-                  });
-                } catch {
-                }
-              };
-              const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
-              const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, result.worktreePath);
-              const runningBootstrapState = {
-                status: "running",
-                required: loadedBootstrap.config?.required !== false,
-                configSource: loadedBootstrap.path || loadedBootstrap.source,
-                configSourceType: loadedBootstrap.sourceType,
-                startedAt: (/* @__PURE__ */ new Date()).toISOString()
-              };
-              await persistWorktreeSetupState(runningBootstrapState);
-              const finishWorktreeSetup = async () => {
-                let submodulesInitialized2 = false;
-                if (initSubmodules) {
-                  try {
-                    const { runGit: runGit3 } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
-                    await runGit3(
-                      { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
-                      ["submodule", "update", "--init", "--recursive"],
-                      { timeoutMs: 12e4 }
-                    );
-                    submodulesInitialized2 = true;
-                    const sourceWorkspace = sourceNode.repoRoot || sourceNode.workspace;
-                    if (sourceWorkspace) {
-                      try {
-                        const { runGit: rg } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
-                        const sourceCtx = { workspace: sourceWorkspace, repoRoot: sourceWorkspace, isGitRepo: true };
-                        const worktreeCtx = { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true };
-                        const sourceStatusOut = await rg(sourceCtx, ["submodule", "status", "oss"], { timeoutMs: 1e4 });
-                        const sourceStatusLine = (typeof sourceStatusOut === "string" ? sourceStatusOut : sourceStatusOut?.stdout ?? "").trim();
-                        const sourceShaMatch = sourceStatusLine.match(/^[+\- ]?([0-9a-f]{40})/);
-                        const sourceSha = sourceShaMatch?.[1];
-                        if (sourceSha) {
-                          const ossCtx = { workspace: `${result.worktreePath}/oss`, repoRoot: `${result.worktreePath}/oss`, isGitRepo: true };
-                          const worktreeOssHeadOut = await rg(ossCtx, ["rev-parse", "HEAD"], { timeoutMs: 1e4 });
-                          const worktreeOssSha = (typeof worktreeOssHeadOut === "string" ? worktreeOssHeadOut : worktreeOssHeadOut?.stdout ?? "").trim();
-                          if (worktreeOssSha !== sourceSha) {
-                            await rg(ossCtx, ["fetch", `${sourceWorkspace}/oss`, "HEAD"], { timeoutMs: 6e4 });
-                            await rg(ossCtx, ["checkout", sourceSha], { timeoutMs: 1e4 });
-                            await rg(worktreeCtx, ["add", "oss"], { timeoutMs: 1e4 });
-                            await rg(worktreeCtx, ["commit", "-m", "chore: sync oss to source node HEAD on clone"], { timeoutMs: 1e4 });
-                            console.log(`[mesh] Synced oss submodule to source HEAD ${sourceSha.slice(0, 8)} in worktree`);
-                          }
-                        }
-                      } catch (ossErr) {
-                        console.warn("[mesh] oss submodule sync to source HEAD failed (best-effort):", ossErr.message);
-                      }
-                    }
-                  } catch (subErr) {
-                    console.warn("[mesh] Submodule init failed for worktree:", subErr.message);
-                  }
-                }
-                const bootstrapState2 = await runMeshWorktreeBootstrap(mesh, result.worktreePath);
-                await persistWorktreeSetupState(bootstrapState2);
-                await appendCloneLedger(submodulesInitialized2, bootstrapState2);
-                return { submodulesInitialized: submodulesInitialized2, bootstrapState: bootstrapState2 };
-              };
-              const requestedSetupWaitMs = Number(args?.setupWaitMs ?? args?.bootstrapWaitMs ?? 8e3);
-              const setupWaitMs = Number.isFinite(requestedSetupWaitMs) ? Math.min(Math.max(requestedSetupWaitMs, 0), 14e3) : 8e3;
-              const setupPromise = finishWorktreeSetup();
-              const setupResult = await Promise.race([
-                setupPromise.then((value) => ({ completed: true, value })),
-                new Promise((resolve24) => setTimeout(() => resolve24({ completed: false }), setupWaitMs))
-              ]);
-              const emitBootstrapEvent = (eventStatus2, bootstrapState2, startedAtMs, extraPayload) => {
-                try {
-                  const durationMs = Date.now() - startedAtMs;
-                  const event = `worktree_${eventStatus2}`;
-                  const metadataEvent = {
-                    source: "clone_mesh_node_bootstrap",
-                    nodeId: node.id,
-                    status: eventStatus2,
-                    worktreePath: result.worktreePath,
-                    durationMs,
-                    bootstrapStatus: bootstrapState2.status,
-                    ...bootstrapState2.error ? { error: bootstrapState2.error } : {},
-                    ...bootstrapState2.exitCode !== void 0 ? { exitCode: bootstrapState2.exitCode } : {},
-                    ...extraPayload || {}
-                  };
-                  if (typeof this.deps.instanceManager?.getByCategory === "function") {
-                    const forwarded = handleMeshForwardEvent(
-                      { instanceManager: this.deps.instanceManager },
-                      { event, meshId, nodeId: node.id, workspace: result.worktreePath, metadataEvent }
-                    );
-                    if (forwarded?.success === true) return;
-                  }
-                  queuePendingMeshCoordinatorEvent({
-                    event,
-                    meshId,
-                    nodeLabel: node.id,
-                    nodeId: node.id,
-                    workspace: result.worktreePath,
-                    metadataEvent,
-                    queuedAt: Date.now()
-                  });
-                } catch {
-                }
-              };
-              const bootstrapStartedMs = Date.now();
-              if (!setupResult.completed) {
-                setupPromise.then(({ bootstrapState: bootstrapState2 }) => {
-                  emitBootstrapEvent("bootstrap_complete", bootstrapState2, bootstrapStartedMs);
-                }).catch((error48) => {
-                  const failedState = {
-                    ...runningBootstrapState,
-                    status: "failed",
-                    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-                    error: error48?.message || String(error48)
-                  };
-                  void persistWorktreeSetupState(failedState);
-                  void appendCloneLedger(false, failedState);
-                  emitBootstrapEvent("bootstrap_failed", failedState, bootstrapStartedMs, { error: error48?.message || String(error48) });
-                });
-                return {
-                  success: true,
-                  async: true,
-                  status: "accepted",
-                  node,
-                  worktreePath: result.worktreePath,
-                  branch: result.branch,
-                  worktreeBootstrap: runningBootstrapState,
-                  worktreeSetup: {
-                    status: "running",
-                    setupWaitMs,
-                    message: "Worktree node is registered; submodule/bootstrap setup is continuing in the background."
-                  }
-                };
-              }
-              const { submodulesInitialized, bootstrapState } = setupResult.value;
-              emitBootstrapEvent("bootstrap_complete", bootstrapState, bootstrapStartedMs);
-              return {
-                success: true,
-                node,
-                worktreePath: result.worktreePath,
-                branch: result.branch,
-                submodulesInitialized,
-                worktreeBootstrap: bootstrapState
-              };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "retry_mesh_node_bootstrap": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            if (!nodeId) return { success: false, error: "nodeId required" };
-            const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "bootstrap retry");
-            if (ownerFailure) return ownerFailure;
-            try {
-              const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-              const mesh = meshRecord?.mesh;
-              if (!mesh) return { success: false, error: "Mesh not found" };
-              const node = mesh.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-              if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
-              if (!node.isLocalWorktree) return { success: false, error: "Node is not a local worktree node" };
-              const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
-              if (nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, this.deps.statusInstanceId) && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
-                const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "retry_mesh_node_bootstrap", {
-                  ...typeof args === "object" && args !== null ? args : {},
-                  _meshDirectDispatch: true
-                });
-                return forwarded ?? { success: false, error: "no response from remote node" };
-              }
-              const currentBootstrap = node.worktreeBootstrap;
-              if (currentBootstrap?.status === "running") {
-                return { success: false, error: "Bootstrap is already running for this node" };
-              }
-              const worktreePath = node.workspace || node.repoRoot;
-              if (!worktreePath) return { success: false, error: "Node has no workspace path" };
-              const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, worktreePath);
-              const runningState = {
-                status: "running",
-                required: loadedBootstrap.config?.required !== false,
-                configSource: loadedBootstrap.path || loadedBootstrap.source,
-                configSourceType: loadedBootstrap.sourceType,
-                startedAt: (/* @__PURE__ */ new Date()).toISOString()
-              };
-              const persistState = async (bootstrapState2) => {
-                node.worktreeBootstrap = bootstrapState2;
-                if (meshRecord.inline) {
-                  this.updateInlineMeshNode(meshId, mesh, node);
-                  return;
-                }
-                try {
-                  const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-                  updateNode2(meshId, node.id, { worktreeBootstrap: bootstrapState2 });
-                  this.invalidateAggregateMeshStatus(meshId);
-                } catch {
-                }
-              };
-              await persistState(runningState);
-              const bootstrapState = await runMeshWorktreeBootstrap(mesh, worktreePath);
-              await persistState(bootstrapState);
-              return { success: true, bootstrapState };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          case "trigger_mesh_queue": {
-            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-            if (!meshId) return { success: false, error: "meshId required" };
-            const ownerFailure = await this.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "queue trigger");
-            if (ownerFailure) return ownerFailure;
-            try {
-              const { triggerMeshQueue: triggerMeshQueue2, tryAssignQueueTask: tryAssignQueueTask2 } = await Promise.resolve().then(() => (init_mesh_events(), mesh_events_exports));
-              const preferredNodeId = typeof args?.preferredNodeId === "string" ? args.preferredNodeId.trim() : "";
-              if (preferredNodeId) {
-                const cliInstances = this.deps.instanceManager.getByCategory("cli");
-                const sorted = [...cliInstances].sort((a, b) => {
-                  const aSettings = a.getState().settings || {};
-                  const bSettings = b.getState().settings || {};
-                  const aNode = readStringValue(aSettings.meshNodeId, aSettings.nodeId);
-                  const bNode = readStringValue(bSettings.meshNodeId, bSettings.nodeId);
-                  return (aNode === preferredNodeId ? -1 : 0) - (bNode === preferredNodeId ? -1 : 0);
-                });
-                for (const inst of sorted) {
-                  const state = inst.getState();
-                  const settings = state.settings || {};
-                  const nodeId = readStringValue(settings.meshNodeId, settings.nodeId);
-                  if (!nodeId || nodeId !== preferredNodeId) continue;
-                  const meshNodeFor = readStringValue(settings.meshNodeFor);
-                  if (meshNodeFor !== meshId) continue;
-                  const status = (readStringValue(state.status) || "").toLowerCase();
-                  if (status !== "idle") continue;
-                  const sessionId = typeof state.instanceId === "string" ? state.instanceId : "";
-                  const providerType = readStringValue(state.type, settings.providerType) || "";
-                  if (sessionId && providerType) {
-                    tryAssignQueueTask2(this.deps, meshId, nodeId, sessionId, providerType);
-                    break;
-                  }
-                }
-              }
-              const trigger = await triggerMeshQueue2(this.deps, meshId);
-              return { success: true, trigger };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
           // ─── Mesh Coordinator Launch ───
           case "launch_mesh_coordinator": {
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";