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

package/dist/index.mjs

@@ -123,7 +123,33 @@ async function removeWorktree(repoRoot, worktreePath, opts = {}) {
     });
   } catch (error) {
     const stderr = typeof error.stderr === "string" ? error.stderr : "";
-    throw new Error(`git worktree remove failed: ${stderr.trim() || error.message}`);
+    const stdout = typeof error.stdout === "string" ? error.stdout : "";
+    const detail = `${stderr}
+${stdout}
+${error.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() || error.message}`);
   }
   return { success: true, removedPath: worktreePath };
 }
@@ -173,7 +199,7 @@ async function pruneWorktrees(repoRoot) {
   } catch {
   }
 }
-var execFileAsync2, WORKTREE_DIR_NAME, GIT_TIMEOUT_MS, GIT_MAX_BUFFER;
+var execFileAsync2, WORKTREE_DIR_NAME, GIT_TIMEOUT_MS, GIT_MAX_BUFFER, SUBMODULE_WORKTREE_REMOVE_RE;
 var init_git_worktree = __esm({
   "src/git/git-worktree.ts"() {
     "use strict";
@@ -181,6 +207,7 @@ var init_git_worktree = __esm({
     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;
   }
 });
 
@@ -1004,6 +1031,7 @@ __export(mesh_work_queue_exports, {
   enqueueTask: () => enqueueTask,
   getMeshQueueStats: () => getMeshQueueStats,
   getQueue: () => getQueue,
+  recordTaskAutoLaunch: () => recordTaskAutoLaunch,
   requeueTask: () => requeueTask,
   updateSessionTaskStatus: () => updateSessionTaskStatus,
   updateTaskStatus: () => updateTaskStatus
@@ -1082,6 +1110,19 @@ function updateTaskStatus(meshId, taskId, status) {
   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);
@@ -1151,10 +1192,144 @@ var init_mesh_work_queue = __esm({
   }
 });
 
+// src/detection/cli-detector.ts
+import { exec } from "child_process";
+import * as os2 from "os";
+import * as path8 from "path";
+import { existsSync as existsSync7 } from "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 path8.join(os2.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 existsSync7(candidate) ? candidate : null;
+  }
+  return null;
+}
+function execAsync(cmd, timeoutMs = 5e3) {
+  return new Promise((resolve16) => {
+    const child = 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 = os2.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 version;
+        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) {
+                version = parseVersion(versionResult);
+                break;
+              }
+            }
+          } catch {
+          }
+        }
+        return { ...cli, installed: true, version, 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 = os2.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 version;
+        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) {
+                version = parseVersion(versionResult);
+                break;
+              }
+            }
+          } catch {
+          }
+        }
+        return { ...target, installed: true, version, path: firstPath };
+      } catch {
+        return null;
+      }
+    }
+  }
+  const all = await detectCLIs(providerLoader, options);
+  return all.find((c) => c.id === resolvedId && c.installed) || null;
+}
+var init_cli_detector = __esm({
+  "src/detection/cli-detector.ts"() {
+    "use strict";
+  }
+});
+
 // src/logging/logger.ts
 import * as fs2 from "fs";
-import * as path8 from "path";
-import * as os2 from "os";
+import * as path9 from "path";
+import * as os3 from "os";
 function setLogLevel(level) {
   currentLevel = level;
   daemonLog("Logger", `Log level set to: ${level}`, "info");
@@ -1169,13 +1344,13 @@ function getDaemonLogDir() {
   return LOG_DIR;
 }
 function getCurrentDaemonLogPath(date = /* @__PURE__ */ new Date()) {
-  return path8.join(LOG_DIR, `daemon-${date.toISOString().slice(0, 10)}.log`);
+  return path9.join(LOG_DIR, `daemon-${date.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();
   }
 }
@@ -1189,7 +1364,7 @@ function cleanOldLogs() {
       const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs2.unlinkSync(path8.join(LOG_DIR, file));
+          fs2.unlinkSync(path9.join(LOG_DIR, file));
         } catch {
         }
       }
@@ -1312,7 +1487,7 @@ var init_logger = __esm({
     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(os2.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path8.join(os2.homedir(), "Library", "Logs", "adhdev") : path8.join(os2.homedir(), ".local", "share", "adhdev", "logs");
+    LOG_DIR = process.platform === "win32" ? path9.join(process.env.LOCALAPPDATA || process.env.APPDATA || path9.join(os3.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os3.homedir(), "Library", "Logs", "adhdev") : path9.join(os3.homedir(), ".local", "share", "adhdev", "logs");
     MAX_LOG_SIZE = 5 * 1024 * 1024;
     MAX_LOG_DAYS = 7;
     try {
@@ -1320,16 +1495,16 @@ var init_logger = __esm({
     } 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 (fs2.existsSync(oldLog)) {
         const stat2 = fs2.statSync(oldLog);
         const oldDate = stat2.mtime.toISOString().slice(0, 10);
-        fs2.renameSync(oldLog, path8.join(LOG_DIR, `daemon-${oldDate}.log`));
+        fs2.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 (fs2.existsSync(oldLogBackup)) {
         fs2.unlinkSync(oldLogBackup);
       }
@@ -1361,7 +1536,7 @@ var init_logger = __esm({
       }
     };
     interceptorInstalled = false;
-    LOG_PATH = path8.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+    LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
   }
 });
 
@@ -1433,7 +1608,235 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
   });
   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 = loadConfig();
+  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) {
+    LOG.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");
@@ -1444,9 +1847,7 @@ function triggerMeshQueue(components, meshId) {
     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) {
@@ -1462,6 +1863,7 @@ function triggerMeshQueue(components, meshId) {
       }
     }
   }
+  await maybeAutoLaunchOneQueueSession(components, meshId, mesh);
 }
 function buildMeshSystemMessage(args) {
   const metadata = formatCompletionMetadata(args.metadataEvent);
@@ -1738,11 +2140,13 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND;
+var remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
 var init_mesh_events = __esm({
   "src/mesh/mesh-events.ts"() {
     "use strict";
+    init_config();
     init_mesh_config();
+    init_cli_detector();
     init_logger();
     init_mesh_ledger();
     init_mesh_work_queue();
@@ -1763,6 +2167,9 @@ var init_mesh_events = __esm({
       "agent:stopped": "task_failed",
       "monitor:long_generating": "task_stalled"
     };
+    autoLaunchInProgress = /* @__PURE__ */ new Set();
+    autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
+    AUTO_LAUNCH_COOLDOWN_MS = 5e3;
   }
 });
 
@@ -6729,10 +7136,120 @@ init_mesh_ledger();
 init_mesh_work_queue();
 init_mesh_events();
 
+// src/mesh/p2p-relay-failure.ts
+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(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  if (error && typeof error === "object") {
+    const candidate = error.error ?? error.message ?? error.reason;
+    if (typeof candidate === "string") return candidate;
+  }
+  return String(error || "mesh relay command failed");
+}
+function classifyP2pRelayFailure(error, _context = {}) {
+  const message = messageFromError(error);
+  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(error) {
+  return classifyP2pRelayFailure(error).recoverable === true;
+}
+function buildP2pRelayFailurePayload(error, context = {}) {
+  const classification = classifyP2pRelayFailure(error, context);
+  return {
+    success: false,
+    ...classification,
+    error: messageFromError(error),
+    ...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;
+  }
+};
+
 // src/config/state-store.ts
 init_config();
-import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join9 } from "path";
 var DEFAULT_STATE = {
   recentActivity: [],
   savedProviderSessions: [],
@@ -6745,7 +7262,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return join8(getConfigDir(), "state.json");
+  return join9(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -6781,7 +7298,7 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!existsSync8(statePath)) {
+  if (!existsSync9(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
@@ -6802,9 +7319,9 @@ function resetState() {
 
 // src/detection/ide-detector.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync9 } from "fs";
-import { platform, homedir as homedir4 } from "os";
-import * as path9 from "path";
+import { existsSync as existsSync10 } from "fs";
+import { platform as platform2, homedir as homedir5 } from "os";
+import * as path10 from "path";
 var BUILTIN_IDE_DEFINITIONS = [];
 var registeredIDEs = /* @__PURE__ */ new Map();
 function registerIDEDefinition(def) {
@@ -6823,14 +7340,14 @@ function getMergedDefinitions() {
 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(homedir4(), trimmed.slice(1)) : trimmed;
-    const resolved = path9.isAbsolute(candidate) ? candidate : path9.resolve(candidate);
-    return existsSync9(resolved) ? resolved : null;
+  if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
+    const candidate = trimmed.startsWith("~") ? path10.join(homedir5(), trimmed.slice(1)) : trimmed;
+    const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
+    return existsSync10(resolved) ? resolved : null;
   }
   try {
     const result = execSync(
-      platform() === "win32" ? `where ${trimmed}` : `which ${trimmed}`,
+      platform2() === "win32" ? `where ${trimmed}` : `which ${trimmed}`,
       { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
     return result.split("\n")[0] || null;
@@ -6851,21 +7368,21 @@ function getIdeVersion(cliCommand) {
   }
 }
 function checkPathExists(paths) {
-  const home = homedir4();
+  const home = homedir5();
   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 (existsSync9(resolved)) return resolved;
+      if (existsSync10(resolved)) return resolved;
     } else {
-      if (existsSync9(normalized)) return normalized;
+      if (existsSync10(normalized)) return normalized;
     }
   }
   return null;
 }
 async function detectIDEs(providerLoader) {
-  const os22 = platform();
+  const os22 = platform2();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(providerLoader?.getIdeCliCommand(def.id, def.cli) || def.cli);
@@ -6873,7 +7390,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if (existsSync9(bundledCli)) resolvedCli = bundledCli;
+      if (existsSync10(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname9 } = await import("path");
@@ -6886,7 +7403,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if (existsSync9(c)) {
+        if (existsSync10(c)) {
           resolvedCli = c;
           break;
         }
@@ -6908,134 +7425,8 @@ async function detectIDEs(providerLoader) {
   return results;
 }
 
-// src/detection/cli-detector.ts
-import { exec } from "child_process";
-import * as os3 from "os";
-import * as path10 from "path";
-import { existsSync as existsSync10 } from "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(os3.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 existsSync10(candidate) ? candidate : null;
-  }
-  return null;
-}
-function execAsync(cmd, timeoutMs = 5e3) {
-  return new Promise((resolve16) => {
-    const child = 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 = os3.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 version;
-        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) {
-                version = parseVersion(versionResult);
-                break;
-              }
-            }
-          } catch {
-          }
-        }
-        return { ...cli, installed: true, version, 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 = os3.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 version;
-        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) {
-                version = parseVersion(versionResult);
-                break;
-              }
-            }
-          } catch {
-          }
-        }
-        return { ...target, installed: true, version, path: firstPath };
-      } catch {
-        return null;
-      }
-    }
-  }
-  const all = await detectCLIs(providerLoader, options);
-  return all.find((c) => c.id === resolvedId && c.installed) || null;
-}
+// src/index.ts
+init_cli_detector();
 
 // src/system/host-memory.ts
 import * as os4 from "os";
@@ -16139,13 +16530,14 @@ var DaemonCommandHandler = class {
 
 // src/commands/cli-manager.ts
 init_provider_cli_adapter();
+init_cli_detector();
+init_config();
 import * as os13 from "os";
 import * as path18 from "path";
 import * as crypto4 from "crypto";
 import { existsSync as existsSync14, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
 import { execFileSync } from "child_process";
 import chalk from "chalk";
-init_config();
 
 // src/providers/cli-provider-instance.ts
 import * as os12 from "os";
@@ -21731,6 +22123,7 @@ function getAvailableIdeIds() {
 
 // src/commands/router.ts
 init_config();
+init_cli_detector();
 init_logger();
 
 // src/logging/command-log.ts
@@ -22877,6 +23270,209 @@ async function resolveProviderTypeFromPriority(args) {
   }
   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 = pathJoin(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 (error) {
+      summary.commandsRun.push({
+        command: candidate.command,
+        args: candidate.args,
+        displayCommand: candidate.displayCommand,
+        category: candidate.category,
+        source: candidate.source,
+        passed: false,
+        exitCode: typeof error?.code === "number" ? error.code : null,
+        signal: typeof error?.signal === "string" ? error.signal : null,
+        timedOut: error?.killed === true || /timed out/i.test(String(error?.message || "")),
+        durationMs: Date.now() - startedAt,
+        stdout: truncateValidationOutput(error?.stdout),
+        stderr: truncateValidationOutput(error?.stderr || error?.message)
+      });
+      summary.status = "failed";
+      return summary;
+    }
+  }
+  summary.status = "passed";
+  return summary;
+}
 function loadYamlModule() {
   return yaml;
 }
@@ -23160,20 +23756,98 @@ var DaemonCommandRouter = class {
         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(record) {
     return record?.lifecycle === "stopped" || record?.lifecycle === "failed" || record?.lifecycle === "interrupted";
   }
@@ -24133,10 +24807,61 @@ var DaemonCommandRouter = class {
           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,
@@ -24149,11 +24874,27 @@ var DaemonCommandRouter = class {
             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 };
         }
@@ -24208,7 +24949,10 @@ var DaemonCommandRouter = class {
                   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 {
@@ -32345,6 +33089,9 @@ function launchIDE(ide, workspacePath) {
   }
 }
 
+// src/boot/daemon-lifecycle.ts
+init_cli_detector();
+
 // src/sessions/registry.ts
 var SessionRegistry = class {
   bySessionId = /* @__PURE__ */ new Map();
@@ -32681,6 +33428,7 @@ export {
   MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
   NodePtyTransportFactory,
+  P2pRelayFailureError,
   ProviderCliAdapter,
   ProviderInstanceManager,
   ProviderLoader,
@@ -32697,6 +33445,7 @@ export {
   buildChatTailDeliverySignature,
   buildCoordinatorSystemPrompt,
   buildMachineInfo,
+  buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand,
   buildRuntimeSystemChatMessage,
   buildSessionEntries,
@@ -32711,6 +33460,7 @@ export {
   claimNextTask,
   classifyChatMessageVisibility,
   classifyHotChatSessionsForSubscriptionFlush,
+  classifyP2pRelayFailure,
   clearDebugTrace,
   compareGitSnapshots,
   configureDebugTraceStore,
@@ -32778,6 +33528,7 @@ export {
   isInternalChatMessage,
   isManagedStatusWaiting,
   isManagedStatusWorking,
+  isP2pRelayTransportFailure,
   isPathInside,
   isSessionHostLiveRuntime,
   isSessionHostRecoverySnapshot,