@adhdev/daemon-standalone 0.9.77-rc.44 → 0.9.77-rc.45

package/dist/index.js

@@ -22210,7 +22210,33 @@ var require_dist2 = __commonJS({
         });
       } catch (error48) {
         const stderr = typeof error48.stderr === "string" ? error48.stderr : "";
-        throw new Error(`git worktree remove failed: ${stderr.trim() || error48.message}`);
+        const stdout = typeof error48.stdout === "string" ? error48.stdout : "";
+        const detail = `${stderr}
+${stdout}
+${error48.message || ""}`;
+        if (opts.allowSubmoduleForceFallback && SUBMODULE_WORKTREE_REMOVE_RE.test(detail)) {
+          try {
+            await execFileAsync2("git", ["worktree", "remove", "--force", worktreePath], {
+              cwd: repoRoot,
+              encoding: "utf8",
+              timeout: GIT_TIMEOUT_MS,
+              maxBuffer: GIT_MAX_BUFFER,
+              windowsHide: true
+            });
+          } catch (forceError) {
+            const forceStderr = typeof forceError.stderr === "string" ? forceError.stderr : "";
+            const forceStdout = typeof forceError.stdout === "string" ? forceError.stdout : "";
+            throw new Error(`git worktree remove --force fallback failed: ${forceStderr.trim() || forceStdout.trim() || forceError.message}`);
+          }
+          return {
+            success: true,
+            removedPath: worktreePath,
+            fallback: "git_worktree_remove_force_submodule",
+            forced: true,
+            reason: "working_trees_containing_submodules"
+          };
+        }
+        throw new Error(`git worktree remove failed: ${stderr.trim() || stdout.trim() || error48.message}`);
       }
       return { success: true, removedPath: worktreePath };
     }
@@ -22269,6 +22295,7 @@ var require_dist2 = __commonJS({
     var WORKTREE_DIR_NAME;
     var GIT_TIMEOUT_MS;
     var GIT_MAX_BUFFER;
+    var SUBMODULE_WORKTREE_REMOVE_RE;
     var init_git_worktree = __esm2({
       "src/git/git-worktree.ts"() {
         "use strict";
@@ -22281,6 +22308,7 @@ var require_dist2 = __commonJS({
         WORKTREE_DIR_NAME = ".adhdev-worktrees";
         GIT_TIMEOUT_MS = 3e4;
         GIT_MAX_BUFFER = 4 * 1024 * 1024;
+        SUBMODULE_WORKTREE_REMOVE_RE = /working trees containing submodules cannot be moved or removed/i;
       }
     });
     var config_exports = {};
@@ -23112,6 +23140,7 @@ Follow these recovery rules:
       enqueueTask: () => enqueueTask,
       getMeshQueueStats: () => getMeshQueueStats,
       getQueue: () => getQueue,
+      recordTaskAutoLaunch: () => recordTaskAutoLaunch,
       requeueTask: () => requeueTask,
       updateSessionTaskStatus: () => updateSessionTaskStatus,
       updateTaskStatus: () => updateTaskStatus
@@ -23187,6 +23216,19 @@ Follow these recovery rules:
       writeQueue(meshId, queue);
       return queue[idx];
     }
+    function recordTaskAutoLaunch(meshId, taskId, autoLaunch) {
+      const queue = readQueue(meshId);
+      const idx = queue.findIndex((q) => q.id === taskId);
+      if (idx === -1) return null;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      queue[idx].autoLaunch = {
+        ...autoLaunch,
+        updatedAt: now
+      };
+      queue[idx].updatedAt = now;
+      writeQueue(meshId, queue);
+      return queue[idx];
+    }
     function cancelTask(meshId, taskId, opts) {
       const queue = readQueue(meshId);
       const idx = queue.findIndex((q) => q.id === taskId);
@@ -23261,6 +23303,142 @@ Follow these recovery rules:
         init_mesh_ledger();
       }
     });
+    function parseVersion(raw) {
+      const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
+      return match ? match[1] : raw.split("\n")[0].slice(0, 100);
+    }
+    function shellQuote(value) {
+      if (/^[a-zA-Z0-9_./:@%+=,-]+$/.test(value)) return value;
+      return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+    }
+    function expandHome(value) {
+      const trimmed = value.trim();
+      if (!trimmed.startsWith("~")) return trimmed;
+      return path8.join(os22.homedir(), trimmed.slice(1));
+    }
+    function isExplicitCommandPath(command) {
+      const trimmed = command.trim();
+      return path8.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
+    }
+    function resolveCommandPath(command) {
+      const trimmed = command.trim();
+      if (!trimmed) return null;
+      if (isExplicitCommandPath(trimmed)) {
+        const expanded = expandHome(trimmed);
+        const candidate = path8.isAbsolute(expanded) ? expanded : path8.resolve(expanded);
+        return (0, import_fs5.existsSync)(candidate) ? candidate : null;
+      }
+      return null;
+    }
+    function execAsync(cmd, timeoutMs = 5e3) {
+      return new Promise((resolve16) => {
+        const child = (0, import_child_process.exec)(cmd, {
+          encoding: "utf-8",
+          timeout: timeoutMs,
+          ...process.platform === "win32" ? { windowsHide: true } : {}
+        }, (err, stdout) => {
+          if (err || !stdout?.trim()) {
+            resolve16(null);
+          } else {
+            resolve16(stdout.trim());
+          }
+        });
+        child.on("error", () => resolve16(null));
+      });
+    }
+    async function detectCLIs(providerLoader, options) {
+      const platform10 = os22.platform();
+      const whichCmd = platform10 === "win32" ? "where" : "which";
+      const includeVersion = options?.includeVersion !== false;
+      const cliList = providerLoader ? providerLoader.getCliDetectionList() : [];
+      const results = await Promise.all(
+        cliList.map(async (cli) => {
+          try {
+            const explicitPath = resolveCommandPath(cli.command);
+            const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(cli.command)}`);
+            if (!pathResult) return { ...cli, installed: false };
+            const firstPath = explicitPath || pathResult.split("\n")[0];
+            let version2;
+            if (includeVersion) {
+              const versionCommands = [
+                `"${firstPath}" --version`,
+                `"${firstPath}" -V`,
+                `"${firstPath}" -v`,
+                cli.versionCommand
+              ].filter((v) => !!v);
+              try {
+                for (const versionCommand of versionCommands) {
+                  const versionResult = await execAsync(versionCommand, 3e3);
+                  if (versionResult) {
+                    version2 = parseVersion(versionResult);
+                    break;
+                  }
+                }
+              } catch {
+              }
+            }
+            return { ...cli, installed: true, version: version2, path: firstPath };
+          } catch {
+            return { ...cli, installed: false };
+          }
+        })
+      );
+      return results;
+    }
+    async function detectCLI(cliId, providerLoader, options) {
+      const resolvedId = providerLoader ? providerLoader.resolveAlias(cliId) : cliId;
+      if (providerLoader) {
+        const cliList = providerLoader.getCliDetectionList();
+        const target = cliList.find((c) => c.id === resolvedId);
+        if (target) {
+          const platform10 = os22.platform();
+          const whichCmd = platform10 === "win32" ? "where" : "which";
+          try {
+            const explicitPath = resolveCommandPath(target.command);
+            const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(target.command)}`);
+            if (!pathResult) return null;
+            const firstPath = explicitPath || pathResult.split("\n")[0];
+            let version2;
+            if (options?.includeVersion !== false) {
+              const versionCommands = [
+                `"${firstPath}" --version`,
+                `"${firstPath}" -V`,
+                `"${firstPath}" -v`,
+                target.versionCommand
+              ].filter((v) => !!v);
+              try {
+                for (const versionCommand of versionCommands) {
+                  const versionResult = await execAsync(versionCommand, 3e3);
+                  if (versionResult) {
+                    version2 = parseVersion(versionResult);
+                    break;
+                  }
+                }
+              } catch {
+              }
+            }
+            return { ...target, installed: true, version: version2, path: firstPath };
+          } catch {
+            return null;
+          }
+        }
+      }
+      const all = await detectCLIs(providerLoader, options);
+      return all.find((c) => c.id === resolvedId && c.installed) || null;
+    }
+    var import_child_process;
+    var os22;
+    var path8;
+    var import_fs5;
+    var init_cli_detector = __esm2({
+      "src/detection/cli-detector.ts"() {
+        "use strict";
+        import_child_process = require("child_process");
+        os22 = __toESM2(require("os"));
+        path8 = __toESM2(require("path"));
+        import_fs5 = require("fs");
+      }
+    });
     function setLogLevel(level) {
       currentLevel = level;
       daemonLog("Logger", `Log level set to: ${level}`, "info");
@@ -23275,13 +23453,13 @@ Follow these recovery rules:
       return LOG_DIR;
     }
     function getCurrentDaemonLogPath(date5 = /* @__PURE__ */ new Date()) {
-      return path8.join(LOG_DIR, `daemon-${date5.toISOString().slice(0, 10)}.log`);
+      return path9.join(LOG_DIR, `daemon-${date5.toISOString().slice(0, 10)}.log`);
     }
     function checkDateRotation() {
       const today = getDateStr();
       if (today !== currentDate) {
         currentDate = today;
-        currentLogFile = path8.join(LOG_DIR, `daemon-${currentDate}.log`);
+        currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
         cleanOldLogs();
       }
     }
@@ -23295,7 +23473,7 @@ Follow these recovery rules:
           const dateMatch = file2.match(/daemon-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs22.unlinkSync(path8.join(LOG_DIR, file2));
+              fs22.unlinkSync(path9.join(LOG_DIR, file2));
             } catch {
             }
           }
@@ -23412,8 +23590,8 @@ Follow these recovery rules:
       writeToFile(`Log level: ${currentLevel}`);
     }
     var fs22;
-    var path8;
-    var os22;
+    var path9;
+    var os32;
     var LEVEL_NUM;
     var LEVEL_LABEL;
     var currentLevel;
@@ -23435,12 +23613,12 @@ Follow these recovery rules:
       "src/logging/logger.ts"() {
         "use strict";
         fs22 = __toESM2(require("fs"));
-        path8 = __toESM2(require("path"));
-        os22 = __toESM2(require("os"));
+        path9 = __toESM2(require("path"));
+        os32 = __toESM2(require("os"));
         LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
         LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
         currentLevel = "info";
-        LOG_DIR = process.platform === "win32" ? path8.join(process.env.LOCALAPPDATA || process.env.APPDATA || path8.join(os22.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path8.join(os22.homedir(), "Library", "Logs", "adhdev") : path8.join(os22.homedir(), ".local", "share", "adhdev", "logs");
+        LOG_DIR = process.platform === "win32" ? path9.join(process.env.LOCALAPPDATA || process.env.APPDATA || path9.join(os32.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os32.homedir(), "Library", "Logs", "adhdev") : path9.join(os32.homedir(), ".local", "share", "adhdev", "logs");
         MAX_LOG_SIZE = 5 * 1024 * 1024;
         MAX_LOG_DAYS = 7;
         try {
@@ -23448,16 +23626,16 @@ Follow these recovery rules:
         } catch {
         }
         currentDate = getDateStr();
-        currentLogFile = path8.join(LOG_DIR, `daemon-${currentDate}.log`);
+        currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
         cleanOldLogs();
         try {
-          const oldLog = path8.join(LOG_DIR, "daemon.log");
+          const oldLog = path9.join(LOG_DIR, "daemon.log");
           if (fs22.existsSync(oldLog)) {
             const stat2 = fs22.statSync(oldLog);
             const oldDate = stat2.mtime.toISOString().slice(0, 10);
-            fs22.renameSync(oldLog, path8.join(LOG_DIR, `daemon-${oldDate}.log`));
+            fs22.renameSync(oldLog, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
           }
-          const oldLogBackup = path8.join(LOG_DIR, "daemon.log.old");
+          const oldLogBackup = path9.join(LOG_DIR, "daemon.log.old");
           if (fs22.existsSync(oldLogBackup)) {
             fs22.unlinkSync(oldLogBackup);
           }
@@ -23489,7 +23667,7 @@ Follow these recovery rules:
           }
         };
         interceptorInstalled = false;
-        LOG_PATH = path8.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+        LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
       }
     });
     var mesh_events_exports = {};
@@ -23559,7 +23737,235 @@ Follow these recovery rules:
       });
       return true;
     }
-    function triggerMeshQueue(components, meshId) {
+    function normalizeProviderPriority(policy) {
+      const raw = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerPriority : void 0;
+      if (!Array.isArray(raw)) return [];
+      const seen = /* @__PURE__ */ new Set();
+      return raw.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean).filter((type) => {
+        if (seen.has(type)) return false;
+        seen.add(type);
+        return true;
+      });
+    }
+    function isTerminalSessionStatus(status) {
+      return ["stopped", "failed", "terminated", "exited", "closed"].includes(status);
+    }
+    function isIdleSessionState(state) {
+      const status = readNonEmptyString(state?.status).toLowerCase();
+      if (isTerminalSessionStatus(status)) return false;
+      return status === "idle" || state?.activeChat?.status === "waiting_input";
+    }
+    function isDirtyNode(node) {
+      return node?.health === "dirty" || node?.git?.dirty === true;
+    }
+    function isLaunchableNode(node) {
+      if (!node || node.status === "disabled" || node.status === "removed") return false;
+      const health = readNonEmptyString(node.health).toLowerCase();
+      if (!health) return true;
+      return health === "online" || health === "unknown";
+    }
+    function localAutoLaunchSkipReason(node) {
+      const daemonId = readNonEmptyString(node?.daemonId);
+      const machineId = readNonEmptyString(node?.machineId);
+      const appConfig = loadConfig2();
+      const localMachineId = readNonEmptyString(appConfig.machineId) || readNonEmptyString(appConfig.registeredMachineId);
+      const cloudDaemonId = localMachineId ? `daemon_${localMachineId}` : "";
+      const standaloneDaemonId = localMachineId ? `standalone_${localMachineId}` : "";
+      const daemonMatchesLocal = !daemonId || daemonId === cloudDaemonId || daemonId === standaloneDaemonId;
+      const machineMatchesLocal = !machineId || localMachineId && machineId === localMachineId;
+      if (node?.isLocalWorktree === true) {
+        return daemonMatchesLocal && machineMatchesLocal ? null : "remote_auto_launch_unsupported";
+      }
+      if (daemonId || machineId) {
+        return daemonMatchesLocal && machineMatchesLocal ? null : "remote_auto_launch_unsupported";
+      }
+      return null;
+    }
+    function activeAssignedCount(meshId) {
+      return getQueue(meshId, { status: ["assigned"] }).length;
+    }
+    function nodeHasActiveAssignment(meshId, nodeId) {
+      return getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedNodeId === nodeId);
+    }
+    function liveSessionCountForNode(components, meshId, nodeId) {
+      return components.instanceManager.getByCategory("cli").filter((inst) => {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (instNodeId !== nodeId) return false;
+        const status = readNonEmptyString(state.status).toLowerCase();
+        return !isTerminalSessionStatus(status);
+      }).length;
+    }
+    function recordAutoLaunchEvent(meshId, args) {
+      try {
+        appendLedgerEntry(meshId, {
+          kind: "session_auto_launch",
+          nodeId: args.nodeId,
+          sessionId: args.sessionId,
+          providerType: args.providerType,
+          payload: {
+            phase: args.phase,
+            taskId: args.taskId,
+            reason: args.reason,
+            error: args.error
+          }
+        });
+      } catch (e) {
+        LOG2.warn("MeshQueue", `Failed to record auto-launch ledger event: ${e?.message || e}`);
+      }
+    }
+    function markAutoLaunch(meshId, taskId, args) {
+      recordTaskAutoLaunch(meshId, taskId, {
+        status: args.status,
+        reason: args.reason || args.error,
+        nodeId: args.nodeId,
+        providerType: args.providerType,
+        sessionId: args.sessionId
+      });
+      recordAutoLaunchEvent(meshId, {
+        phase: args.status,
+        taskId,
+        nodeId: args.nodeId,
+        providerType: args.providerType,
+        sessionId: args.sessionId,
+        reason: args.reason,
+        error: args.error
+      });
+    }
+    async function resolveUsableProvider(components, nodeId, node) {
+      const providerPriority = normalizeProviderPriority(node?.policy);
+      if (!providerPriority.length) return { reason: "missing_provider_priority" };
+      const providerLoader = components.providerLoader;
+      if (!providerLoader) return { reason: "provider_loader_unavailable" };
+      const failed = [];
+      for (const requestedType of providerPriority) {
+        const normalizedType = typeof providerLoader.resolveAlias === "function" ? providerLoader.resolveAlias(requestedType) : requestedType;
+        if (typeof providerLoader.isMachineProviderEnabled === "function" && !providerLoader.isMachineProviderEnabled(normalizedType)) {
+          failed.push(`${requestedType}: disabled`);
+          continue;
+        }
+        let detected;
+        try {
+          detected = await detectCLI(normalizedType, providerLoader, { includeVersion: false });
+        } catch (e) {
+          failed.push(`${requestedType}: detect failed: ${e?.message || e}`);
+          continue;
+        }
+        if (typeof providerLoader.setCliDetectionResults === "function") {
+          providerLoader.setCliDetectionResults([{
+            id: normalizedType,
+            installed: !!detected,
+            path: detected?.path
+          }], false);
+        }
+        components.onStatusChange?.();
+        if (detected) return { providerType: normalizedType };
+        failed.push(`${requestedType}: not detected`);
+      }
+      return { reason: `provider_priority_unusable: ${failed.join("; ") || nodeId}` };
+    }
+    async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
+      const queue = getQueue(meshId);
+      const pending = queue.filter((task) => task.status === "pending");
+      if (!pending.length) return false;
+      const maxParallelTasks = Math.max(1, Math.floor(Number(mesh?.policy?.maxParallelTasks) || 2));
+      for (const task of pending) {
+        if (activeAssignedCount(meshId) >= maxParallelTasks) {
+          markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_parallel_tasks_reached" });
+          return false;
+        }
+        if (task.targetSessionId) {
+          markAutoLaunch(meshId, task.id, { status: "skipped", reason: "target_session_constraint" });
+          continue;
+        }
+        const candidateNodes = Array.isArray(mesh?.nodes) ? mesh.nodes.filter((node) => task.targetNodeId ? node?.id === task.targetNodeId : true) : [];
+        if (!candidateNodes.length) {
+          markAutoLaunch(meshId, task.id, { status: "skipped", reason: "no_matching_node", nodeId: task.targetNodeId });
+          continue;
+        }
+        for (const node of candidateNodes) {
+          const nodeId = readNonEmptyString(node?.id);
+          if (!nodeId) continue;
+          const launchKey = `${meshId}:${nodeId}`;
+          const cooldownUntil = autoLaunchCooldownUntil.get(launchKey) || 0;
+          if (autoLaunchInProgress.has(launchKey)) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "auto_launch_in_progress", nodeId });
+            continue;
+          }
+          if (Date.now() < cooldownUntil) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "auto_launch_cooldown", nodeId });
+            continue;
+          }
+          if (isDirtyNode(node)) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "dirty_workspace", nodeId });
+            continue;
+          }
+          if (!isLaunchableNode(node)) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_not_launch_ready", nodeId });
+            continue;
+          }
+          const localSkipReason = localAutoLaunchSkipReason(node);
+          if (localSkipReason) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: localSkipReason, nodeId });
+            continue;
+          }
+          if (nodeHasActiveAssignment(meshId, nodeId)) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_has_active_assignment", nodeId });
+            continue;
+          }
+          const maxConcurrentSessions = Number(node?.policy?.maxConcurrentSessions);
+          if (Number.isFinite(maxConcurrentSessions) && maxConcurrentSessions >= 0 && liveSessionCountForNode(components, meshId, nodeId) >= maxConcurrentSessions) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_concurrent_sessions_reached", nodeId });
+            continue;
+          }
+          autoLaunchInProgress.add(launchKey);
+          try {
+            const resolved = await resolveUsableProvider(components, nodeId, node);
+            if (!resolved.providerType) {
+              markAutoLaunch(meshId, task.id, { status: "skipped", reason: resolved.reason || "provider_unusable", nodeId });
+              continue;
+            }
+            markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: resolved.providerType });
+            const launchResult = await components.cliManager.handleCliCommand("launch_cli", {
+              cliType: resolved.providerType,
+              dir: node.workspace,
+              settings: {
+                meshNodeFor: meshId,
+                meshNodeId: nodeId,
+                spawnedSessionVisibility: mesh?.policy?.spawnedSessionVisibility || "hidden",
+                launchedByCoordinator: true,
+                autoLaunchedForQueueTaskId: task.id
+              }
+            });
+            if (!launchResult?.success) {
+              const reason = launchResult?.error || "launch_cli_failed";
+              markAutoLaunch(meshId, task.id, { status: "failed", reason, nodeId, providerType: resolved.providerType });
+              autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+              return false;
+            }
+            const sessionId = readNonEmptyString(launchResult.sessionId) || readNonEmptyString(launchResult.id) || readNonEmptyString(launchResult.runtimeSessionId);
+            if (!sessionId) {
+              markAutoLaunch(meshId, task.id, { status: "failed", reason: "launch_missing_session_id", nodeId, providerType: resolved.providerType });
+              autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+              return false;
+            }
+            markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId });
+            tryAssignQueueTask(components, meshId, nodeId, sessionId, resolved.providerType);
+            return true;
+          } catch (e) {
+            markAutoLaunch(meshId, task.id, { status: "failed", error: e?.message || String(e), nodeId });
+            autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+            return false;
+          } finally {
+            autoLaunchInProgress.delete(launchKey);
+          }
+        }
+      }
+      return false;
+    }
+    async function triggerMeshQueue(components, meshId) {
       const mesh = getMeshWithCache(components, meshId);
       if (!mesh) return;
       const cliInstances = components.instanceManager.getByCategory("cli");
@@ -23570,9 +23976,7 @@ Follow these recovery rules:
         if (instMeshId !== meshId) continue;
         const nodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
         if (!nodeId) continue;
-        const status = readNonEmptyString(state.status).toLowerCase();
-        if (["stopped", "failed", "terminated", "exited", "closed"].includes(status)) continue;
-        if (status !== "idle" && state.activeChat?.status !== "waiting_input") continue;
+        if (!isIdleSessionState(state)) continue;
         const sessionId = state.instanceId;
         const providerType = state.type || readNonEmptyString(settings.providerType);
         if (providerType) {
@@ -23588,6 +23992,7 @@ Follow these recovery rules:
           }
         }
       }
+      await maybeAutoLaunchOneQueueSession(components, meshId, mesh);
     }
     function buildMeshSystemMessage(args) {
       const metadata = formatCompletionMetadata(args.metadataEvent);
@@ -23869,10 +24274,15 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
     var pendingMeshCoordinatorEvents;
     var MESH_COORDINATOR_EVENTS;
     var EVENT_TO_LEDGER_KIND;
+    var autoLaunchInProgress;
+    var autoLaunchCooldownUntil;
+    var AUTO_LAUNCH_COOLDOWN_MS;
     var init_mesh_events = __esm2({
       "src/mesh/mesh-events.ts"() {
         "use strict";
+        init_config();
         init_mesh_config();
+        init_cli_detector();
         init_logger();
         init_mesh_ledger();
         init_mesh_work_queue();
@@ -23893,6 +24303,9 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           "agent:stopped": "task_failed",
           "monitor:long_generating": "task_stalled"
         };
+        autoLaunchInProgress = /* @__PURE__ */ new Set();
+        autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
+        AUTO_LAUNCH_COOLDOWN_MS = 5e3;
       }
     });
     function normalizeCategories(categories) {
@@ -27011,6 +27424,7 @@ ${lastSnapshot}`;
       MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS: () => MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS2,
       MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS: () => MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS2,
       NodePtyTransportFactory: () => NodePtyTransportFactory,
+      P2pRelayFailureError: () => P2pRelayFailureError,
       ProviderCliAdapter: () => ProviderCliAdapter,
       ProviderInstanceManager: () => ProviderInstanceManager,
       ProviderLoader: () => ProviderLoader,
@@ -27027,6 +27441,7 @@ ${lastSnapshot}`;
       buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
       buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
       buildMachineInfo: () => buildMachineInfo2,
+      buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
       buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
       buildRuntimeSystemChatMessage: () => buildRuntimeSystemChatMessage,
       buildSessionEntries: () => buildSessionEntries,
@@ -27041,6 +27456,7 @@ ${lastSnapshot}`;
       claimNextTask: () => claimNextTask,
       classifyChatMessageVisibility: () => classifyChatMessageVisibility,
       classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush2,
+      classifyP2pRelayFailure: () => classifyP2pRelayFailure,
       clearDebugTrace: () => clearDebugTrace,
       compareGitSnapshots: () => compareGitSnapshots,
       configureDebugTraceStore: () => configureDebugTraceStore,
@@ -27108,6 +27524,7 @@ ${lastSnapshot}`;
       isInternalChatMessage: () => isInternalChatMessage,
       isManagedStatusWaiting: () => isManagedStatusWaiting,
       isManagedStatusWorking: () => isManagedStatusWorking,
+      isP2pRelayTransportFailure: () => isP2pRelayTransportFailure,
       isPathInside: () => isPathInside,
       isSessionHostLiveRuntime: () => isSessionHostLiveRuntime,
       isSessionHostRecoverySnapshot: () => isSessionHostRecoverySnapshot,
@@ -29036,7 +29453,115 @@ ${lastSnapshot}`;
     init_mesh_ledger();
     init_mesh_work_queue();
     init_mesh_events();
-    var import_fs5 = require("fs");
+    var NO_FALLBACK_REASON = "Repo Mesh command/data-plane is P2P-only; WS/REST command fallback is intentionally disabled to preserve the transport boundary.";
+    var P2P_NEXT_ACTION = "Check daemon/P2P health, wait briefly for connection establishment, then do one bounded retry or requeue the mesh task after clearing stale target session metadata.";
+    var NON_P2P_NEXT_ACTION = "Inspect the provider/command error and fix the underlying logic or configuration before retrying.";
+    function messageFromError(error48) {
+      if (error48 instanceof Error) return error48.message;
+      if (typeof error48 === "string") return error48;
+      if (error48 && typeof error48 === "object") {
+        const candidate = error48.error ?? error48.message ?? error48.reason;
+        if (typeof candidate === "string") return candidate;
+      }
+      return String(error48 || "mesh relay command failed");
+    }
+    function classifyP2pRelayFailure(error48, _context = {}) {
+      const message = messageFromError(error48);
+      const lower = message.toLowerCase();
+      const hasP2pSignal = /p2p|datachannel|node-datachannel|webrtc|ice|mesh_relay_command|daemon_mesh_p2p_transport/i.test(message);
+      const hasFailureSignal = /unavailable|missing|failed|failure|timeout|timed out|not connected|closed|disconnected|offline|no route|route unavailable|cannot send|cannot establish/i.test(message);
+      if (/requires targetdaemonid and command|providerpriority|no inference provider|permission denied|read-only|not a member/i.test(message)) {
+        return {
+          code: "mesh_logic_or_provider_failure",
+          reason: "mesh_logic_or_provider_failure",
+          transport: "unknown",
+          recoverable: false,
+          retryRecommended: false,
+          nextAction: NON_P2P_NEXT_ACTION,
+          noFallbackReason: NO_FALLBACK_REASON
+        };
+      }
+      let code = null;
+      let reason = "";
+      if (/timeout|timed out/i.test(message) && (hasP2pSignal || /mesh transport/i.test(message))) {
+        code = "p2p_timeout";
+        reason = "daemon_mesh_p2p_timeout";
+      } else if (/no route|route unavailable/i.test(message)) {
+        code = "p2p_no_route";
+        reason = "daemon_mesh_p2p_no_route";
+      } else if (/offline|not owned|not found|not connected to server/i.test(message) && /daemon|peer|target/i.test(message)) {
+        code = "p2p_daemon_offline";
+        reason = "daemon_mesh_target_offline";
+      } else if (/closed|disconnected/i.test(message) && (hasP2pSignal || /state changed/i.test(message))) {
+        code = "p2p_datachannel_closed";
+        reason = "daemon_mesh_p2p_datachannel_closed";
+      } else if (/not connected|cannot send|cannot establish/i.test(message) && hasP2pSignal) {
+        code = "p2p_not_connected";
+        reason = "daemon_mesh_p2p_not_connected";
+      } else if (hasP2pSignal && hasFailureSignal) {
+        code = "p2p_unavailable";
+        reason = "daemon_mesh_p2p_transport_unavailable";
+      }
+      if (!code) {
+        return {
+          code: "mesh_logic_or_provider_failure",
+          reason: "mesh_logic_or_provider_failure",
+          transport: "unknown",
+          recoverable: false,
+          retryRecommended: false,
+          nextAction: NON_P2P_NEXT_ACTION,
+          noFallbackReason: NO_FALLBACK_REASON
+        };
+      }
+      return {
+        code,
+        reason,
+        transport: "p2p",
+        recoverable: true,
+        retryRecommended: true,
+        nextAction: P2P_NEXT_ACTION,
+        noFallbackReason: NO_FALLBACK_REASON
+      };
+    }
+    function isP2pRelayTransportFailure(error48) {
+      return classifyP2pRelayFailure(error48).recoverable === true;
+    }
+    function buildP2pRelayFailurePayload(error48, context = {}) {
+      const classification = classifyP2pRelayFailure(error48, context);
+      return {
+        success: false,
+        ...classification,
+        error: messageFromError(error48),
+        ...context.command ? { command: context.command } : {},
+        ...context.targetDaemonId ? { targetDaemonId: context.targetDaemonId } : {}
+      };
+    }
+    var P2pRelayFailureError = class extends Error {
+      code;
+      reason;
+      transport;
+      recoverable;
+      retryRecommended;
+      nextAction;
+      noFallbackReason;
+      command;
+      targetDaemonId;
+      constructor(message, context = {}) {
+        super(message);
+        this.name = "P2pRelayFailureError";
+        const payload = buildP2pRelayFailurePayload(message, context);
+        this.code = payload.code;
+        this.reason = payload.reason;
+        this.transport = payload.transport;
+        this.recoverable = payload.recoverable;
+        this.retryRecommended = payload.retryRecommended;
+        this.nextAction = payload.nextAction;
+        this.noFallbackReason = payload.noFallbackReason;
+        this.command = context.command;
+        this.targetDaemonId = context.targetDaemonId;
+      }
+    };
+    var import_fs6 = require("fs");
     var import_path5 = require("path");
     init_config();
     var DEFAULT_STATE = {
@@ -29087,11 +29612,11 @@ ${lastSnapshot}`;
     }
     function loadState() {
       const statePath = getStatePath();
-      if (!(0, import_fs5.existsSync)(statePath)) {
+      if (!(0, import_fs6.existsSync)(statePath)) {
         return { ...DEFAULT_STATE };
       }
       try {
-        const raw = (0, import_fs5.readFileSync)(statePath, "utf-8");
+        const raw = (0, import_fs6.readFileSync)(statePath, "utf-8");
         return normalizeState(JSON.parse(raw));
       } catch {
         return { ...DEFAULT_STATE };
@@ -29100,15 +29625,15 @@ ${lastSnapshot}`;
     function saveState(state) {
       const statePath = getStatePath();
       const normalized = normalizeState(state);
-      (0, import_fs5.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+      (0, import_fs6.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
     }
     function resetState() {
       saveState({ ...DEFAULT_STATE });
     }
-    var import_child_process = require("child_process");
-    var import_fs6 = require("fs");
+    var import_child_process2 = require("child_process");
+    var import_fs7 = require("fs");
     var import_os22 = require("os");
-    var path9 = __toESM2(require("path"));
+    var path10 = __toESM2(require("path"));
     var BUILTIN_IDE_DEFINITIONS = [];
     var registeredIDEs = /* @__PURE__ */ new Map();
     function registerIDEDefinition(def) {
@@ -29127,13 +29652,13 @@ ${lastSnapshot}`;
     function findCliCommand(command) {
       const trimmed = String(command || "").trim();
       if (!trimmed) return null;
-      if (path9.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
-        const candidate = trimmed.startsWith("~") ? path9.join((0, import_os22.homedir)(), trimmed.slice(1)) : trimmed;
-        const resolved = path9.isAbsolute(candidate) ? candidate : path9.resolve(candidate);
-        return (0, import_fs6.existsSync)(resolved) ? resolved : null;
+      if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
+        const candidate = trimmed.startsWith("~") ? path10.join((0, import_os22.homedir)(), trimmed.slice(1)) : trimmed;
+        const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
+        return (0, import_fs7.existsSync)(resolved) ? resolved : null;
       }
       try {
-        const result = (0, import_child_process.execSync)(
+        const result = (0, import_child_process2.execSync)(
           (0, import_os22.platform)() === "win32" ? `where ${trimmed}` : `which ${trimmed}`,
           { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
         ).trim();
@@ -29144,7 +29669,7 @@ ${lastSnapshot}`;
     }
     function getIdeVersion(cliCommand) {
       try {
-        const result = (0, import_child_process.execSync)(`"${cliCommand}" --version`, {
+        const result = (0, import_child_process2.execSync)(`"${cliCommand}" --version`, {
           encoding: "utf-8",
           timeout: 1e4,
           stdio: ["pipe", "pipe", "pipe"]
@@ -29157,13 +29682,13 @@ ${lastSnapshot}`;
     function checkPathExists(paths) {
       const home = (0, import_os22.homedir)();
       for (const p of paths) {
-        const normalized = p.startsWith("~") ? path9.join(home, p.slice(1)) : p;
+        const normalized = p.startsWith("~") ? path10.join(home, p.slice(1)) : p;
         if (normalized.includes("*")) {
           const username = home.split(/[\\/]/).pop() || "";
           const resolved = normalized.replace("*", username);
-          if ((0, import_fs6.existsSync)(resolved)) return resolved;
+          if ((0, import_fs7.existsSync)(resolved)) return resolved;
         } else {
-          if ((0, import_fs6.existsSync)(normalized)) return normalized;
+          if ((0, import_fs7.existsSync)(normalized)) return normalized;
         }
       }
       return null;
@@ -29177,7 +29702,7 @@ ${lastSnapshot}`;
         let resolvedCli = cliPath;
         if (!resolvedCli && appPath && os222 === "darwin") {
           const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-          if ((0, import_fs6.existsSync)(bundledCli)) resolvedCli = bundledCli;
+          if ((0, import_fs7.existsSync)(bundledCli)) resolvedCli = bundledCli;
         }
         if (!resolvedCli && appPath && os222 === "win32") {
           const { dirname: dirname9 } = await import("path");
@@ -29190,7 +29715,7 @@ ${lastSnapshot}`;
             `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
           ];
           for (const c of candidates) {
-            if ((0, import_fs6.existsSync)(c)) {
+            if ((0, import_fs7.existsSync)(c)) {
               resolvedCli = c;
               break;
             }
@@ -29211,133 +29736,7 @@ ${lastSnapshot}`;
       }
       return results;
     }
-    var import_child_process2 = require("child_process");
-    var os32 = __toESM2(require("os"));
-    var path10 = __toESM2(require("path"));
-    var import_fs7 = require("fs");
-    function parseVersion(raw) {
-      const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
-      return match ? match[1] : raw.split("\n")[0].slice(0, 100);
-    }
-    function shellQuote(value) {
-      if (/^[a-zA-Z0-9_./:@%+=,-]+$/.test(value)) return value;
-      return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
-    }
-    function expandHome(value) {
-      const trimmed = value.trim();
-      if (!trimmed.startsWith("~")) return trimmed;
-      return path10.join(os32.homedir(), trimmed.slice(1));
-    }
-    function isExplicitCommandPath(command) {
-      const trimmed = command.trim();
-      return path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
-    }
-    function resolveCommandPath(command) {
-      const trimmed = command.trim();
-      if (!trimmed) return null;
-      if (isExplicitCommandPath(trimmed)) {
-        const expanded = expandHome(trimmed);
-        const candidate = path10.isAbsolute(expanded) ? expanded : path10.resolve(expanded);
-        return (0, import_fs7.existsSync)(candidate) ? candidate : null;
-      }
-      return null;
-    }
-    function execAsync(cmd, timeoutMs = 5e3) {
-      return new Promise((resolve16) => {
-        const child = (0, import_child_process2.exec)(cmd, {
-          encoding: "utf-8",
-          timeout: timeoutMs,
-          ...process.platform === "win32" ? { windowsHide: true } : {}
-        }, (err, stdout) => {
-          if (err || !stdout?.trim()) {
-            resolve16(null);
-          } else {
-            resolve16(stdout.trim());
-          }
-        });
-        child.on("error", () => resolve16(null));
-      });
-    }
-    async function detectCLIs(providerLoader, options) {
-      const platform10 = os32.platform();
-      const whichCmd = platform10 === "win32" ? "where" : "which";
-      const includeVersion = options?.includeVersion !== false;
-      const cliList = providerLoader ? providerLoader.getCliDetectionList() : [];
-      const results = await Promise.all(
-        cliList.map(async (cli) => {
-          try {
-            const explicitPath = resolveCommandPath(cli.command);
-            const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(cli.command)}`);
-            if (!pathResult) return { ...cli, installed: false };
-            const firstPath = explicitPath || pathResult.split("\n")[0];
-            let version2;
-            if (includeVersion) {
-              const versionCommands = [
-                `"${firstPath}" --version`,
-                `"${firstPath}" -V`,
-                `"${firstPath}" -v`,
-                cli.versionCommand
-              ].filter((v) => !!v);
-              try {
-                for (const versionCommand of versionCommands) {
-                  const versionResult = await execAsync(versionCommand, 3e3);
-                  if (versionResult) {
-                    version2 = parseVersion(versionResult);
-                    break;
-                  }
-                }
-              } catch {
-              }
-            }
-            return { ...cli, installed: true, version: version2, path: firstPath };
-          } catch {
-            return { ...cli, installed: false };
-          }
-        })
-      );
-      return results;
-    }
-    async function detectCLI(cliId, providerLoader, options) {
-      const resolvedId = providerLoader ? providerLoader.resolveAlias(cliId) : cliId;
-      if (providerLoader) {
-        const cliList = providerLoader.getCliDetectionList();
-        const target = cliList.find((c) => c.id === resolvedId);
-        if (target) {
-          const platform10 = os32.platform();
-          const whichCmd = platform10 === "win32" ? "where" : "which";
-          try {
-            const explicitPath = resolveCommandPath(target.command);
-            const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(target.command)}`);
-            if (!pathResult) return null;
-            const firstPath = explicitPath || pathResult.split("\n")[0];
-            let version2;
-            if (options?.includeVersion !== false) {
-              const versionCommands = [
-                `"${firstPath}" --version`,
-                `"${firstPath}" -V`,
-                `"${firstPath}" -v`,
-                target.versionCommand
-              ].filter((v) => !!v);
-              try {
-                for (const versionCommand of versionCommands) {
-                  const versionResult = await execAsync(versionCommand, 3e3);
-                  if (versionResult) {
-                    version2 = parseVersion(versionResult);
-                    break;
-                  }
-                }
-              } catch {
-              }
-            }
-            return { ...target, installed: true, version: version2, path: firstPath };
-          } catch {
-            return null;
-          }
-        }
-      }
-      const all = await detectCLIs(providerLoader, options);
-      return all.find((c) => c.id === resolvedId && c.installed) || null;
-    }
+    init_cli_detector();
     var os42 = __toESM2(require("os"));
     var import_child_process3 = require("child_process");
     function parseDarwinAvailableBytes(totalMem) {
@@ -38361,6 +38760,7 @@ ${effect.notification.body || ""}`.trim();
     var import_child_process6 = require("child_process");
     var import_chalk = __toESM2((init_source(), __toCommonJS(source_exports)));
     init_provider_cli_adapter();
+    init_cli_detector();
     init_config();
     var os12 = __toESM2(require("os"));
     var path16 = __toESM2(require("path"));
@@ -43914,6 +44314,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       return getProviderLoader().getAvailableIdeTypes();
     }
     init_config();
+    init_cli_detector();
     init_logger();
     var fs8 = __toESM2(require("fs"));
     var path21 = __toESM2(require("path"));
@@ -45046,6 +45447,209 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       }
       return { error: `No usable provider detected for node '${args.nodeId}' from providerPriority: ${failed.join("; ")}` };
     }
+    var REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
+    var REFINE_VALIDATION_TIMEOUT_MS = 12e4;
+    var REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
+    var REFINE_VALIDATION_SUMMARY_CHARS = 2e3;
+    var REFINE_VALIDATION_MAX_COMMANDS = 4;
+    function truncateValidationOutput(value) {
+      const text = typeof value === "string" ? value : value == null ? "" : String(value);
+      if (text.length <= REFINE_VALIDATION_SUMMARY_CHARS) return text;
+      return `${text.slice(0, REFINE_VALIDATION_SUMMARY_CHARS)}
+[truncated ${text.length - REFINE_VALIDATION_SUMMARY_CHARS} chars]`;
+    }
+    function readPackageScripts(workspace) {
+      try {
+        const packageJsonPath = (0, import_path6.join)(workspace, "package.json");
+        const parsed = JSON.parse(fs10.readFileSync(packageJsonPath, "utf-8"));
+        return parsed?.scripts && typeof parsed.scripts === "object" && !Array.isArray(parsed.scripts) ? parsed.scripts : {};
+      } catch {
+        return {};
+      }
+    }
+    function tokenizeValidationCommand(command) {
+      const trimmed = command.trim();
+      if (!trimmed) return null;
+      if (/[;&|<>`$\\\n\r'\"]/.test(trimmed)) return null;
+      const tokens = trimmed.split(/\s+/).filter(Boolean);
+      if (!tokens.length) return null;
+      if (tokens.some((token) => !/^[A-Za-z0-9_@./:=+-]+$/.test(token))) return null;
+      return tokens;
+    }
+    function scriptMatchesValidationCategory(scriptName, category) {
+      return scriptName === category || scriptName.startsWith(`${category}:`);
+    }
+    function parsePackageManagerValidationCommand(rawCommand, category, scripts, source) {
+      const tokens = tokenizeValidationCommand(rawCommand);
+      if (!tokens) {
+        return { rejected: { command: rawCommand, category, source, reason: "unsafe command string is not allowlisted" } };
+      }
+      const [binary, second, third, ...rest] = tokens;
+      let scriptName = "";
+      let command = binary;
+      let args = [];
+      if ((binary === "npm" || binary === "pnpm" || binary === "bun") && second === "run" && third) {
+        scriptName = third;
+        args = ["run", scriptName, ...rest];
+      } else if (binary === "npm" && second === "test" && !third) {
+        scriptName = "test";
+        args = ["test"];
+      } else if (binary === "yarn" && second === "run" && third) {
+        scriptName = third;
+        args = ["run", scriptName, ...rest];
+      } else if (binary === "yarn" && second && !third) {
+        scriptName = second;
+        args = [scriptName];
+      } else {
+        return { rejected: { command: rawCommand, category, source, reason: "command is not a supported package-manager script invocation" } };
+      }
+      if (!scriptName || !Object.prototype.hasOwnProperty.call(scripts, scriptName)) {
+        return { rejected: { command: rawCommand, category, source, script: scriptName, reason: "script is not declared in package.json" } };
+      }
+      if (!scriptMatchesValidationCategory(scriptName, category)) {
+        return { rejected: { command: rawCommand, category, source, script: scriptName, reason: "script name is outside the validation category allowlist" } };
+      }
+      return {
+        command: {
+          command,
+          args,
+          displayCommand: [command, ...args].join(" "),
+          category,
+          source
+        }
+      };
+    }
+    function collectProjectContextValidationCandidates(mesh) {
+      const commands = mesh?.projectContext?.commands;
+      if (!commands || typeof commands !== "object" || Array.isArray(commands)) return [];
+      const candidates = [];
+      for (const category of REFINE_VALIDATION_CATEGORIES) {
+        const entries = Array.isArray(commands[category]) ? commands[category] : [];
+        for (const entry of entries) {
+          if (typeof entry?.command !== "string") continue;
+          candidates.push({
+            command: entry.command,
+            category,
+            source: typeof entry.sourcePath === "string" ? entry.sourcePath : "projectContext.commands",
+            confidence: typeof entry.confidence === "string" ? entry.confidence : void 0
+          });
+        }
+      }
+      return candidates.sort((a, b) => {
+        const rank = (value) => value === "high" ? 0 : value === "medium" ? 1 : 2;
+        return rank(a.confidence) - rank(b.confidence);
+      });
+    }
+    function collectPolicyValidationCandidates(mesh) {
+      const policy = mesh?.policy && typeof mesh.policy === "object" && !Array.isArray(mesh.policy) ? mesh.policy : {};
+      const configured = Array.isArray(policy.validationCommands) ? policy.validationCommands : Array.isArray(policy.validationGate?.commands) ? policy.validationGate.commands : [];
+      return configured.map((entry) => typeof entry === "string" ? { command: entry, category: "", source: "mesh.policy.validationCommands" } : entry).filter((entry) => entry && typeof entry.command === "string").map((entry) => {
+        const commandText = entry.command.trim();
+        const category = REFINE_VALIDATION_CATEGORIES.find((cat) => commandText.includes(` ${cat}`)) ?? "";
+        return { command: commandText, category, source: "mesh.policy.validationCommands" };
+      }).filter((entry) => !!entry.category);
+    }
+    function selectMeshRefineValidationCommands(mesh, workspace) {
+      const scripts = readPackageScripts(workspace);
+      const rejectedCommands = [];
+      const selected = [];
+      const seen = /* @__PURE__ */ new Set();
+      const candidates = [
+        ...collectPolicyValidationCandidates(mesh),
+        ...collectProjectContextValidationCandidates(mesh)
+      ];
+      for (const candidate of candidates) {
+        const parsed = parsePackageManagerValidationCommand(candidate.command, candidate.category, scripts, candidate.source);
+        if (parsed.rejected) {
+          rejectedCommands.push(parsed.rejected);
+          continue;
+        }
+        if (!parsed.command || seen.has(parsed.command.displayCommand)) continue;
+        selected.push(parsed.command);
+        seen.add(parsed.command.displayCommand);
+        if (selected.length >= REFINE_VALIDATION_MAX_COMMANDS) break;
+      }
+      if (!selected.length && candidates.length === 0) {
+        for (const category of REFINE_VALIDATION_CATEGORIES) {
+          if (!Object.prototype.hasOwnProperty.call(scripts, category)) continue;
+          const fallback = parsePackageManagerValidationCommand(`npm run ${category}`, category, scripts, "package.json:scripts");
+          if (fallback.command && !seen.has(fallback.command.displayCommand)) {
+            selected.push(fallback.command);
+            seen.add(fallback.command.displayCommand);
+          } else if (fallback.rejected) {
+            rejectedCommands.push(fallback.rejected);
+          }
+          if (selected.length >= 2) break;
+        }
+      }
+      return {
+        commands: selected,
+        rejectedCommands,
+        source: selected.some((command) => command.source === "mesh.policy.validationCommands") ? "mesh_policy" : selected.some((command) => command.source !== "package.json:scripts") ? "project_context" : selected.length ? "package_json_scripts" : "unavailable"
+      };
+    }
+    async function runMeshRefineValidationGate(mesh, workspace) {
+      const { execFile: execFile3 } = await import("child_process");
+      const { promisify: promisify3 } = await import("util");
+      const execFileAsync3 = promisify3(execFile3);
+      const selection = selectMeshRefineValidationCommands(mesh, workspace);
+      const summary = {
+        status: "skipped",
+        required: true,
+        commandsRun: [],
+        rejectedCommands: selection.rejectedCommands,
+        skippedReason: void 0,
+        timeoutMs: REFINE_VALIDATION_TIMEOUT_MS,
+        outputLimitBytes: REFINE_VALIDATION_OUTPUT_LIMIT_BYTES
+      };
+      if (!selection.commands.length) {
+        summary.skippedReason = "validation_unavailable: no allowlisted projectContext, mesh policy, or package.json build/test/typecheck/lint command was available";
+        return summary;
+      }
+      for (const candidate of selection.commands) {
+        const startedAt = Date.now();
+        try {
+          const result = await execFileAsync3(candidate.command, candidate.args, {
+            cwd: workspace,
+            encoding: "utf8",
+            timeout: REFINE_VALIDATION_TIMEOUT_MS,
+            maxBuffer: REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
+            env: { ...process.env, CI: process.env.CI || "1" }
+          });
+          summary.commandsRun.push({
+            command: candidate.command,
+            args: candidate.args,
+            displayCommand: candidate.displayCommand,
+            category: candidate.category,
+            source: candidate.source,
+            passed: true,
+            exitCode: 0,
+            durationMs: Date.now() - startedAt,
+            stdout: truncateValidationOutput(result.stdout),
+            stderr: truncateValidationOutput(result.stderr)
+          });
+        } catch (error48) {
+          summary.commandsRun.push({
+            command: candidate.command,
+            args: candidate.args,
+            displayCommand: candidate.displayCommand,
+            category: candidate.category,
+            source: candidate.source,
+            passed: false,
+            exitCode: typeof error48?.code === "number" ? error48.code : null,
+            signal: typeof error48?.signal === "string" ? error48.signal : null,
+            timedOut: error48?.killed === true || /timed out/i.test(String(error48?.message || "")),
+            durationMs: Date.now() - startedAt,
+            stdout: truncateValidationOutput(error48?.stdout),
+            stderr: truncateValidationOutput(error48?.stderr || error48?.message)
+          });
+          summary.status = "failed";
+          return summary;
+        }
+      }
+      summary.status = "passed";
+      return summary;
+    }
     function loadYamlModule() {
       return yaml;
     }
@@ -45329,20 +45933,98 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             recoveryHint: "Inspect the worktree branch and mesh metadata before retrying cleanup."
           };
         }
+        const forceFallbackConvergence = await this.getWorktreeForceCleanupConvergence({
+          repoRoot,
+          workspace,
+          node: args.node
+        });
         try {
-          const result = await removeWorktree2(repoRoot, workspace, { requireClean: true });
-          return { success: true, removedPath: result.removedPath, repoRoot };
+          const result = await removeWorktree2(repoRoot, workspace, {
+            requireClean: true,
+            allowSubmoduleForceFallback: forceFallbackConvergence.allow
+          });
+          return {
+            success: true,
+            removedPath: result.removedPath,
+            repoRoot,
+            ...result.fallback ? {
+              fallback: result.fallback,
+              forced: result.forced,
+              reason: result.reason,
+              convergence: forceFallbackConvergence
+            } : {}
+          };
         } catch (e) {
           const message = String(e?.message || e || "worktree cleanup failed");
           const dirty = message.includes("dirty worktree") || message.includes("local changes");
+          const submoduleForceBlocked = /working trees containing submodules cannot be moved or removed/i.test(message) && !forceFallbackConvergence.allow;
           return {
             success: false,
-            code: dirty ? "mesh_worktree_cleanup_dirty" : "mesh_worktree_cleanup_failed",
-            error: message,
-            recoveryHint: dirty ? "Commit, stash, or intentionally discard the worktree changes before retrying mesh_remove_node. The mesh registry entry is preserved until cleanup is safe." : "Inspect git worktree status/list from the source repo and retry after resolving the reported cleanup failure."
+            code: dirty ? "mesh_worktree_cleanup_dirty" : submoduleForceBlocked ? "mesh_worktree_cleanup_force_fallback_blocked" : "mesh_worktree_cleanup_failed",
+            error: submoduleForceBlocked ? `${message}; refusing --force fallback because convergence could not be verified: ${forceFallbackConvergence.error || "unknown convergence state"}` : message,
+            recoveryHint: dirty ? "Commit, stash, or intentionally discard the worktree changes before retrying mesh_remove_node. The mesh registry entry is preserved until cleanup is safe." : submoduleForceBlocked ? "Verify the worktree branch is merged/contained in the source default branch (for example origin/main) or mark the node with a safe branchConvergence final state before retrying. The mesh registry entry is preserved." : "Inspect git worktree status/list from the source repo and retry after resolving the reported cleanup failure.",
+            ...submoduleForceBlocked ? { convergence: forceFallbackConvergence } : {}
           };
         }
       }
+      async getWorktreeForceCleanupConvergence(args) {
+        const metadataStatus = typeof args.node?.branchConvergence?.status === "string" ? args.node.branchConvergence.status : "";
+        if (metadataStatus === "merged_to_main" || metadataStatus === "cleanup_candidate") {
+          return { allow: true, status: metadataStatus, source: "node_branch_convergence" };
+        }
+        const { execFile: execFile3 } = await import("child_process");
+        const { promisify: promisify3 } = await import("util");
+        const execFileAsync3 = promisify3(execFile3);
+        const runGit2 = async (gitArgs, cwd) => {
+          const { stdout } = await execFileAsync3("git", gitArgs, {
+            cwd,
+            encoding: "utf8",
+            timeout: 3e4,
+            maxBuffer: 4 * 1024 * 1024,
+            windowsHide: true
+          });
+          return String(stdout || "").trim();
+        };
+        let head = "";
+        try {
+          head = await runGit2(["rev-parse", "HEAD"], args.workspace);
+        } catch (e) {
+          return { allow: false, error: `could not resolve worktree HEAD: ${e?.message || e}` };
+        }
+        if (!head) return { allow: false, error: "worktree HEAD is empty" };
+        const candidateRefs = [];
+        try {
+          const defaultBranch = await runGit2(["branch", "--show-current"], args.repoRoot);
+          if (defaultBranch) {
+            candidateRefs.push(defaultBranch, `origin/${defaultBranch}`);
+          }
+        } catch {
+        }
+        candidateRefs.push("origin/main", "origin/master", "main", "master");
+        const seen = /* @__PURE__ */ new Set();
+        const checkedRefs = [];
+        for (const ref of candidateRefs) {
+          if (!ref || seen.has(ref)) continue;
+          seen.add(ref);
+          let commit = "";
+          try {
+            commit = await runGit2(["rev-parse", "--verify", `${ref}^{commit}`], args.repoRoot);
+          } catch {
+            continue;
+          }
+          checkedRefs.push(ref);
+          try {
+            await runGit2(["merge-base", "--is-ancestor", head, commit], args.repoRoot);
+            return { allow: true, status: "merged_to_default_ref", source: "git_merge_base", ref };
+          } catch {
+          }
+        }
+        return {
+          allow: false,
+          status: metadataStatus || void 0,
+          error: checkedRefs.length ? `worktree HEAD is not contained in checked refs: ${checkedRefs.join(", ")}` : "no default/main refs were available for convergence verification"
+        };
+      }
       isCompletedHostedSession(record2) {
         return record2?.lifecycle === "stopped" || record2?.lifecycle === "failed" || record2?.lifecycle === "interrupted";
       }
@@ -46302,10 +46984,61 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               if (!branch) return { success: false, error: "Could not determine branch of the worktree node" };
               const { stdout: baseBranchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
               const baseBranch = baseBranchStdout.trim();
+              const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace);
+              if (validationSummary.status === "failed") {
+                return {
+                  success: false,
+                  code: "validation_failed",
+                  convergenceStatus: "blocked_review",
+                  error: "Refinery validation gate failed; merge/refine was not attempted.",
+                  branch,
+                  into: baseBranch,
+                  validationSummary,
+                  finalBranchConvergenceState: {
+                    branch,
+                    baseBranch,
+                    merged: false,
+                    removed: false,
+                    validation: "failed",
+                    status: "blocked_review"
+                  }
+                };
+              }
+              if (validationSummary.status === "skipped") {
+                return {
+                  success: false,
+                  code: "validation_unavailable",
+                  convergenceStatus: "blocked_review",
+                  error: "Refinery validation gate is required but no allowlisted validation command was available; merge/refine was not attempted.",
+                  branch,
+                  into: baseBranch,
+                  validationSummary,
+                  finalBranchConvergenceState: {
+                    branch,
+                    baseBranch,
+                    merged: false,
+                    removed: false,
+                    validation: "unavailable",
+                    status: "blocked_review"
+                  }
+                };
+              }
               try {
                 await execFileAsync3("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
               } catch (e) {
-                return { success: false, error: `Merge failed (conflicts?): ${e.message}` };
+                return {
+                  success: false,
+                  error: `Merge failed (conflicts?): ${e.message}`,
+                  validationSummary,
+                  finalBranchConvergenceState: {
+                    branch,
+                    baseBranch,
+                    merged: false,
+                    removed: false,
+                    validation: "passed",
+                    status: "not_mergeable"
+                  }
+                };
               }
               const removeResult = await this.execute("remove_mesh_node", {
                 meshId,
@@ -46318,11 +47051,27 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 appendLedgerEntry2(meshId, {
                   kind: "node_removed",
                   nodeId,
-                  payload: { refined: true, mergedBranch: branch, into: baseBranch }
+                  payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary }
                 });
               } catch {
               }
-              return { success: true, merged: true, branch, into: baseBranch, removeResult };
+              return {
+                success: true,
+                merged: true,
+                branch,
+                into: baseBranch,
+                removeResult,
+                validationSummary,
+                finalBranchConvergenceState: {
+                  branch: baseBranch,
+                  mergedBranch: branch,
+                  baseBranch,
+                  merged: true,
+                  removed: removeResult?.success !== false,
+                  validation: "passed",
+                  status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
+                }
+              };
             } catch (e) {
               return { success: false, error: e.message };
             }
@@ -46377,7 +47126,10 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                       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
+                      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 {
@@ -54460,6 +55212,7 @@ data: ${JSON.stringify(msg.data)}
         return false;
       }
     }
+    init_cli_detector();
     var SessionRegistry = class {
       bySessionId = /* @__PURE__ */ new Map();
       byManagerKey = /* @__PURE__ */ new Map();