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

package/vendor/mcp-server/index.js

@@ -25094,6 +25094,7 @@ __export(dist_exports, {
   MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS: () => MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS: () => MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
   NodePtyTransportFactory: () => NodePtyTransportFactory,
+  P2pRelayFailureError: () => P2pRelayFailureError,
   ProviderCliAdapter: () => ProviderCliAdapter,
   ProviderInstanceManager: () => ProviderInstanceManager,
   ProviderLoader: () => ProviderLoader,
@@ -25110,6 +25111,7 @@ __export(dist_exports, {
   buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
   buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
   buildMachineInfo: () => buildMachineInfo,
+  buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
   buildRuntimeSystemChatMessage: () => buildRuntimeSystemChatMessage,
   buildSessionEntries: () => buildSessionEntries,
@@ -25124,6 +25126,7 @@ __export(dist_exports, {
   claimNextTask: () => claimNextTask,
   classifyChatMessageVisibility: () => classifyChatMessageVisibility,
   classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush,
+  classifyP2pRelayFailure: () => classifyP2pRelayFailure,
   clearDebugTrace: () => clearDebugTrace,
   compareGitSnapshots: () => compareGitSnapshots,
   configureDebugTraceStore: () => configureDebugTraceStore,
@@ -25191,6 +25194,7 @@ __export(dist_exports, {
   isInternalChatMessage: () => isInternalChatMessage,
   isManagedStatusWaiting: () => isManagedStatusWaiting,
   isManagedStatusWorking: () => isManagedStatusWorking,
+  isP2pRelayTransportFailure: () => isP2pRelayTransportFailure,
   isPathInside: () => isPathInside,
   isSessionHostLiveRuntime: () => isSessionHostLiveRuntime,
   isSessionHostRecoverySnapshot: () => isSessionHostRecoverySnapshot,
@@ -25331,7 +25335,33 @@ async function removeWorktree(repoRoot, worktreePath, opts = {}) {
     });
   } 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 };
 }
@@ -26092,6 +26122,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);
@@ -26154,6 +26197,129 @@ function getMeshQueueStats(meshId) {
     }))
   };
 }
+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_fs8.existsSync)(candidate) ? candidate : null;
+  }
+  return null;
+}
+function execAsync(cmd, timeoutMs = 5e3) {
+  return new Promise((resolve162) => {
+    const child = (0, import_child_process2.exec)(cmd, {
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      ...process.platform === "win32" ? { windowsHide: true } : {}
+    }, (err, stdout) => {
+      if (err || !stdout?.trim()) {
+        resolve162(null);
+      } else {
+        resolve162(stdout.trim());
+      }
+    });
+    child.on("error", () => resolve162(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;
+}
 function setLogLevel(level) {
   currentLevel = level;
   daemonLog("Logger", `Log level set to: ${level}`, "info");
@@ -26168,13 +26334,13 @@ function getDaemonLogDir() {
   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();
   }
 }
@@ -26188,7 +26354,7 @@ function cleanOldLogs() {
       const dateMatch = file2.match(/daemon-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs2.unlinkSync(path8.join(LOG_DIR, file2));
+          fs2.unlinkSync(path9.join(LOG_DIR, file2));
         } catch {
         }
       }
@@ -26363,7 +26529,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((type2) => typeof type2 === "string" ? type2.trim() : "").filter(Boolean).filter((type2) => {
+    if (seen.has(type2)) return false;
+    seen.add(type2);
+    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");
@@ -26374,9 +26768,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) {
@@ -26392,6 +26784,7 @@ function triggerMeshQueue(components, meshId) {
       }
     }
   }
+  await maybeAutoLaunchOneQueueSession(components, meshId, mesh);
 }
 function buildMeshSystemMessage(args) {
   const metadata = formatCompletionMetadata(args.metadataEvent);
@@ -26899,7 +27292,7 @@ function findBinary(name) {
   const isWin = os9.platform() === "win32";
   try {
     const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
-    return (0, import_child_process2.execSync)(cmd, {
+    return (0, import_child_process3.execSync)(cmd, {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"],
@@ -27274,7 +27667,7 @@ async function validateWorkspace(workspace) {
         cwd: normalizedWorkspace
       });
     }
-    await (0, import_promises5.access)(normalizedWorkspace, import_fs8.constants.R_OK);
+    await (0, import_promises5.access)(normalizedWorkspace, import_fs9.constants.R_OK);
   } catch (error48) {
     if (error48 instanceof GitCommandError) throw error48;
     throw new GitCommandError("invalid_args", "Workspace must be an existing directory", {
@@ -28787,6 +29180,86 @@ async function syncMeshLedger(meshId, transport) {
     appendRemoteLedgerEntries2(meshId, res.missingEntries);
   }
 }
+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 } : {}
+  };
+}
 function isPlainObject22(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -28827,11 +29300,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!(0, import_fs9.existsSync)(statePath)) {
+  if (!(0, import_fs10.existsSync)(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = (0, import_fs9.readFileSync)(statePath, "utf-8");
+    const raw = (0, import_fs10.readFileSync)(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -28840,7 +29313,7 @@ function loadState() {
 function saveState(state) {
   const statePath = getStatePath();
   const normalized = normalizeState(state);
-  (0, import_fs9.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs10.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function resetState() {
   saveState({ ...DEFAULT_STATE });
@@ -28861,13 +29334,13 @@ 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((0, import_os3.homedir)(), trimmed.slice(1)) : trimmed;
-    const resolved = path9.isAbsolute(candidate) ? candidate : path9.resolve(candidate);
-    return (0, import_fs10.existsSync)(resolved) ? resolved : null;
+  if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
+    const candidate = trimmed.startsWith("~") ? path10.join((0, import_os3.homedir)(), trimmed.slice(1)) : trimmed;
+    const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
+    return (0, import_fs11.existsSync)(resolved) ? resolved : null;
   }
   try {
-    const result = (0, import_child_process4.execSync)(
+    const result = (0, import_child_process5.execSync)(
       (0, import_os3.platform)() === "win32" ? `where ${trimmed}` : `which ${trimmed}`,
       { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -28878,7 +29351,7 @@ function findCliCommand(command) {
 }
 function getIdeVersion(cliCommand) {
   try {
-    const result = (0, import_child_process4.execSync)(`"${cliCommand}" --version`, {
+    const result = (0, import_child_process5.execSync)(`"${cliCommand}" --version`, {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -28891,13 +29364,13 @@ function getIdeVersion(cliCommand) {
 function checkPathExists(paths) {
   const home = (0, import_os3.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_fs10.existsSync)(resolved)) return resolved;
+      if ((0, import_fs11.existsSync)(resolved)) return resolved;
     } else {
-      if ((0, import_fs10.existsSync)(normalized)) return normalized;
+      if ((0, import_fs11.existsSync)(normalized)) return normalized;
     }
   }
   return null;
@@ -28911,7 +29384,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os222 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if ((0, import_fs10.existsSync)(bundledCli)) resolvedCli = bundledCli;
+      if ((0, import_fs11.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os222 === "win32") {
       const { dirname: dirname92 } = await import("path");
@@ -28924,7 +29397,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if ((0, import_fs10.existsSync)(c)) {
+        if ((0, import_fs11.existsSync)(c)) {
           resolvedCli = c;
           break;
         }
@@ -28945,129 +29418,6 @@ async function detectIDEs(providerLoader) {
   }
   return results;
 }
-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_fs11.existsSync)(candidate) ? candidate : null;
-  }
-  return null;
-}
-function execAsync(cmd, timeoutMs = 5e3) {
-  return new Promise((resolve162) => {
-    const child = (0, import_child_process5.exec)(cmd, {
-      encoding: "utf-8",
-      timeout: timeoutMs,
-      ...process.platform === "win32" ? { windowsHide: true } : {}
-    }, (err, stdout) => {
-      if (err || !stdout?.trim()) {
-        resolve162(null);
-      } else {
-        resolve162(stdout.trim());
-      }
-    });
-    child.on("error", () => resolve162(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;
-}
 function parseDarwinAvailableBytes(totalMem) {
   if (os42.platform() !== "darwin") return null;
   try {
@@ -36589,6 +36939,204 @@ async function resolveProviderTypeFromPriority(args) {
   }
   return { error: `No usable provider detected for node '${args.nodeId}' from providerPriority: ${failed.join("; ")}` };
 }
+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_path7.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 [binary2, second, third, ...rest] = tokens;
+  let scriptName = "";
+  let command = binary2;
+  let args = [];
+  if ((binary2 === "npm" || binary2 === "pnpm" || binary2 === "bun") && second === "run" && third) {
+    scriptName = third;
+    args = ["run", scriptName, ...rest];
+  } else if (binary2 === "npm" && second === "test" && !third) {
+    scriptName = "test";
+    args = ["test"];
+  } else if (binary2 === "yarn" && second === "run" && third) {
+    scriptName = third;
+    args = ["run", scriptName, ...rest];
+  } else if (binary2 === "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 js_yaml_exports;
 }
@@ -41136,7 +41684,7 @@ async function shutdownDaemonComponents(components) {
   }
   cdpManagers.clear();
 }
-var path4, import_promises4, import_fs3, import_child_process, import_util3, import_os2, import_path, import_fs4, import_crypto2, import_fs5, import_path2, import_crypto3, import_fs6, import_path3, import_crypto4, import_events2, import_fs7, import_path4, import_crypto5, fs2, path8, os22, os8, os9, path14, import_child_process2, os10, path15, os11, import_child_process3, import_fs8, import_promises5, path, import_util4, import_promises6, path22, path32, fs, os4, path5, import_crypto6, path6, path7, import_fs9, import_path5, import_child_process4, import_fs10, import_os3, path9, import_child_process5, os32, path10, import_fs11, os42, import_child_process6, http, crypto2, fs3, path11, os5, fs4, os6, path12, import_crypto7, fs5, path13, os7, os13, path18, crypto4, import_fs12, import_child_process7, os12, path16, crypto3, fs6, import_module, path17, import_stream2, import_child_process8, import_child_process9, net2, os15, path20, fs7, path19, os14, fs8, path21, os16, import_child_process10, import_crypto8, import_fs13, import_module2, os17, import_path6, os18, import_child_process11, import_child_process12, fs9, os19, path222, import_os4, import_path7, fs10, fs11, path23, os20, import_child_process13, import_os5, http2, fs15, path27, fs12, path24, fs13, path25, fs14, path26, os21, import_child_process14, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __hasOwnProp2, __require2, __esm2, __export2, __copyProps2, __toCommonJS2, DEFAULT_MESH_POLICY, init_repo_mesh_types, git_worktree_exports, execFileAsync2, WORKTREE_DIR_NAME, GIT_TIMEOUT_MS, GIT_MAX_BUFFER, init_git_worktree, config_exports, DEFAULT_CONFIG, MACHINE_ID_PREFIX, init_config, mesh_config_exports, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES, init_mesh_config, coordinator_prompt_exports, TOOLS_SECTION, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION, init_coordinator_prompt, mesh_ledger_exports, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, RECENT_FAILURE_WINDOW_MS, meshLedgerEvents, init_mesh_ledger, mesh_work_queue_exports, init_mesh_work_queue, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH, init_logger, mesh_events_exports, remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, init_mesh_events, NORMAL_TRACE_BUFFER_SIZE, DEV_TRACE_BUFFER_SIZE, DEFAULT_CONFIG2, currentConfig, init_debug_config, DEFAULT_BINDING_CANDIDATES, cachedBinding, cachedBindingError, GhosttyVtTerminalBackend, init_ghostty_vt_backend, TerminalCtor, XtermTerminalBackend, init_xterm_backend, DEFAULT_SCROLLBACK, loggedTerminalBackends, TerminalScreen, init_terminal_screen, init_spawn_env, cachedPty, NodePtyRuntimeTransport, NodePtyTransportFactory, init_pty_transport, TerminalTranscriptAccumulator, buildCliSpawnEnv, init_provider_cli_shared, init_provider_cli_parse, init_provider_cli_config, init_provider_cli_runtime, provider_cli_adapter_exports, ProviderCliAdapter, init_provider_cli_adapter, execFileAsync, DEFAULT_TIMEOUT_MS, DEFAULT_MAX_BUFFER, GitCommandError, DEFAULT_MAX_FILES, DEFAULT_MAX_BYTES, summarizeGitStatus, InMemoryGitSnapshotStore, DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS, MIN_GIT_WORKSPACE_POLL_INTERVAL_MS, GitWorkspaceMonitor, GIT_COMMAND_NAMES, SNAPSHOT_REASONS, FAILURE_REASONS, defaultSnapshotStore, defaultGitCommandServices, BUSY_STATUSES, TERMINAL_STATUSES, TurnSnapshotTracker, MAX_WORKSPACES, MAX_ACTIVITY, MAX_SAVED_SESSIONS, DEFAULT_STATE, BUILTIN_IDE_DEFINITIONS, registeredIDEs, LIVE_LIFECYCLES, DEFAULT_ACTIVE_CHAT_POLL_STATUSES, DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS, LIVE_RUNTIME_LIFECYCLES, DaemonCdpManager, CdpDomHandlers, DEFAULT_MONITOR_CONFIG, StatusMonitor, BUILTIN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_VISIBILITIES, CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES, CHAT_MESSAGE_AUDIENCES, CHAT_MESSAGE_SOURCES, CHAT_MESSAGE_ACTIVITY_SOURCES, CHAT_MESSAGE_INTERNAL_SOURCES, KNOWN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_KIND_ALIASES, EXPLICIT_HIDDEN_VISIBILITIES, EXPLICIT_VISIBLE_VISIBILITIES, HIDDEN_AUDIENCES, ACTIVITY_SOURCE_SET, INTERNAL_SOURCE_SET, HISTORY_DIR, RETAIN_DAYS, SAVED_HISTORY_INDEX_VERSION, SAVED_HISTORY_INDEX_FILE, SAVED_HISTORY_INDEX_LOCK_SUFFIX, SAVED_HISTORY_INDEX_LOCK_WAIT_MS, SAVED_HISTORY_INDEX_LOCK_STALE_MS, SAVED_HISTORY_INDEX_LOCK_POLL_MS, SAVED_HISTORY_ROLLUP_THRESHOLD_BYTES, savedHistorySessionCache, savedHistoryFileSummaryCache, savedHistoryBackgroundRefresh, savedHistoryRollupInFlight, ChatHistoryWriter, IDE_PROVIDER_SESSION_CAPABILITIES_BASE, EXTENSION_PROVIDER_SESSION_CAPABILITIES_BASE, ExtensionProviderInstance, VALID_STATUSES, VALID_ROLES, VALID_BUBBLE_STATES, VALID_TURN_STATUSES, DEFAULT_APPROVAL_POSITIVE_HINTS, IdeProviderInstance, DEFAULT_CDP_SCAN_INTERVAL_MS, DEFAULT_CDP_DISCOVERY_INTERVAL_MS, DEFAULT_STATUS_INITIAL_REPORT_DELAY_MS, DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS, DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS, MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS, DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS, MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS, DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS, DEFAULT_SESSION_HOST_READY_TIMEOUT_MS, STANDALONE_CDP_SCAN_INTERVAL_MS, DaemonCdpScanner, DaemonCdpInitializer, WORKING_STATUSES, FULL_STATUS_ACTIVE_CHAT_OPTIONS, LIVE_STATUS_ACTIVE_CHAT_OPTIONS, STATUS_MODAL_MESSAGE_LIMIT, STATUS_MODAL_BUTTON_LIMIT, VALID_INPUT_MEDIA_TYPES, VALID_INPUT_STRATEGIES, TEXT_ONLY_MESSAGE_INPUT_SUPPORT, IDE_SESSION_CAPABILITIES, EXTENSION_SESSION_CAPABILITIES, PTY_SESSION_CAPABILITIES, CLI_CHAT_SESSION_CAPABILITIES, ACP_SESSION_CAPABILITIES, globalStore, RECENT_SEND_WINDOW_MS, READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS, HERMES_CLI_STARTING_SEND_SETTLE_MS, recentSendByTarget, DEFAULT_DEBUG_SANITIZE_OPTIONS, SECRET_KEY_PATTERN, KEY_TO_VK, COMMAND_DEBUG_LEVELS, DaemonCommandHandler, COMPLETED_FINALIZATION_RETRY_MS, COMPLETED_FINALIZATION_MAX_WAIT_MS, IMAGE_MIME_EXTENSIONS, MATERIALIZED_IMAGE_MAX_AGE_MS, MATERIALIZED_IMAGE_CLEANUP_INTERVAL_MS, lastMaterializedImageCleanupAt, CachedDatabaseSync, CliProviderInstance, AcpProviderInstance, chalkModule, chalkApi, COORDINATOR_DELEGATED_ENV_UNSETS, DaemonCliManager, VALID_CAPABILITY_MEDIA_TYPES, VALID_INPUT_STRATEGIES2, KNOWN_PROVIDER_FIELDS, VALUE_CONTROL_TYPES, ProviderLoader, _providerLoader, LOG_DIR2, MAX_FILE_SIZE, MAX_DAYS, SENSITIVE_KEYS, currentDate2, currentFile, writeCount2, SKIP_COMMANDS, DEFAULT_SERVER_NAME, DEFAULT_ADHDEV_MCP_COMMAND, HERMES_CLI_TYPE, HERMES_MCP_CONFIG_PATH, READ_DEBUG_ENABLED, recentReadDebugSignatureBySession, UPGRADE_HELPER_ENV, CHANNEL_NPM_TAG, CHANNEL_SERVER_URL, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter, DaemonStatusReporter, DEFAULT_DAEMON_PORT, DAEMON_WS_PATH, ProviderStreamAdapter, DaemonAgentStreamManager, AgentStreamPoller, ProviderInstanceManager, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive, DEV_SERVER_PORT, DevServer, SessionHostRuntimeTransport, SessionHostPtyTransportFactory, DEFAULT_SESSION_HOST_APP_NAME, DEFAULT_STANDALONE_SESSION_HOST_APP_NAME, STARTUP_TIMEOUT_MS, STARTUP_POLL_MS, SessionHostCompatibilityError, EXTENSION_CATALOG, SessionRegistry;
+var path4, import_promises4, import_fs3, import_child_process, import_util3, import_os2, import_path, import_fs4, import_crypto2, import_fs5, import_path2, import_crypto3, import_fs6, import_path3, import_crypto4, import_events2, import_fs7, import_path4, import_crypto5, import_child_process2, os22, path8, import_fs8, fs2, path9, os32, os8, os9, path14, import_child_process3, os10, path15, os11, import_child_process4, import_fs9, import_promises5, path, import_util4, import_promises6, path22, path32, fs, os4, path5, import_crypto6, path6, path7, import_fs10, import_path5, import_child_process5, import_fs11, import_os3, path10, os42, import_child_process6, http, crypto2, fs3, path11, os5, fs4, os6, path12, import_crypto7, fs5, path13, os7, os13, path18, crypto4, import_fs12, import_child_process7, os12, path16, crypto3, fs6, import_module, path17, import_stream2, import_child_process8, import_child_process9, net2, os15, path20, fs7, path19, os14, fs8, path21, os16, import_child_process10, import_crypto8, import_fs13, import_module2, os17, import_path6, os18, import_child_process11, import_child_process12, fs9, os19, path222, import_os4, import_path7, fs10, fs11, path23, os20, import_child_process13, import_os5, http2, fs15, path27, fs12, path24, fs13, path25, fs14, path26, os21, import_child_process14, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __hasOwnProp2, __require2, __esm2, __export2, __copyProps2, __toCommonJS2, DEFAULT_MESH_POLICY, init_repo_mesh_types, git_worktree_exports, execFileAsync2, WORKTREE_DIR_NAME, GIT_TIMEOUT_MS, GIT_MAX_BUFFER, SUBMODULE_WORKTREE_REMOVE_RE, init_git_worktree, config_exports, DEFAULT_CONFIG, MACHINE_ID_PREFIX, init_config, mesh_config_exports, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES, init_mesh_config, coordinator_prompt_exports, TOOLS_SECTION, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION, init_coordinator_prompt, mesh_ledger_exports, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, RECENT_FAILURE_WINDOW_MS, meshLedgerEvents, init_mesh_ledger, mesh_work_queue_exports, init_mesh_work_queue, init_cli_detector, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH, init_logger, mesh_events_exports, remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, init_mesh_events, NORMAL_TRACE_BUFFER_SIZE, DEV_TRACE_BUFFER_SIZE, DEFAULT_CONFIG2, currentConfig, init_debug_config, DEFAULT_BINDING_CANDIDATES, cachedBinding, cachedBindingError, GhosttyVtTerminalBackend, init_ghostty_vt_backend, TerminalCtor, XtermTerminalBackend, init_xterm_backend, DEFAULT_SCROLLBACK, loggedTerminalBackends, TerminalScreen, init_terminal_screen, init_spawn_env, cachedPty, NodePtyRuntimeTransport, NodePtyTransportFactory, init_pty_transport, TerminalTranscriptAccumulator, buildCliSpawnEnv, init_provider_cli_shared, init_provider_cli_parse, init_provider_cli_config, init_provider_cli_runtime, provider_cli_adapter_exports, ProviderCliAdapter, init_provider_cli_adapter, execFileAsync, DEFAULT_TIMEOUT_MS, DEFAULT_MAX_BUFFER, GitCommandError, DEFAULT_MAX_FILES, DEFAULT_MAX_BYTES, summarizeGitStatus, InMemoryGitSnapshotStore, DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS, MIN_GIT_WORKSPACE_POLL_INTERVAL_MS, GitWorkspaceMonitor, GIT_COMMAND_NAMES, SNAPSHOT_REASONS, FAILURE_REASONS, defaultSnapshotStore, defaultGitCommandServices, BUSY_STATUSES, TERMINAL_STATUSES, TurnSnapshotTracker, MAX_WORKSPACES, MAX_ACTIVITY, MAX_SAVED_SESSIONS, NO_FALLBACK_REASON, P2P_NEXT_ACTION, NON_P2P_NEXT_ACTION, P2pRelayFailureError, DEFAULT_STATE, BUILTIN_IDE_DEFINITIONS, registeredIDEs, LIVE_LIFECYCLES, DEFAULT_ACTIVE_CHAT_POLL_STATUSES, DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS, LIVE_RUNTIME_LIFECYCLES, DaemonCdpManager, CdpDomHandlers, DEFAULT_MONITOR_CONFIG, StatusMonitor, BUILTIN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_VISIBILITIES, CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES, CHAT_MESSAGE_AUDIENCES, CHAT_MESSAGE_SOURCES, CHAT_MESSAGE_ACTIVITY_SOURCES, CHAT_MESSAGE_INTERNAL_SOURCES, KNOWN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_KIND_ALIASES, EXPLICIT_HIDDEN_VISIBILITIES, EXPLICIT_VISIBLE_VISIBILITIES, HIDDEN_AUDIENCES, ACTIVITY_SOURCE_SET, INTERNAL_SOURCE_SET, HISTORY_DIR, RETAIN_DAYS, SAVED_HISTORY_INDEX_VERSION, SAVED_HISTORY_INDEX_FILE, SAVED_HISTORY_INDEX_LOCK_SUFFIX, SAVED_HISTORY_INDEX_LOCK_WAIT_MS, SAVED_HISTORY_INDEX_LOCK_STALE_MS, SAVED_HISTORY_INDEX_LOCK_POLL_MS, SAVED_HISTORY_ROLLUP_THRESHOLD_BYTES, savedHistorySessionCache, savedHistoryFileSummaryCache, savedHistoryBackgroundRefresh, savedHistoryRollupInFlight, ChatHistoryWriter, IDE_PROVIDER_SESSION_CAPABILITIES_BASE, EXTENSION_PROVIDER_SESSION_CAPABILITIES_BASE, ExtensionProviderInstance, VALID_STATUSES, VALID_ROLES, VALID_BUBBLE_STATES, VALID_TURN_STATUSES, DEFAULT_APPROVAL_POSITIVE_HINTS, IdeProviderInstance, DEFAULT_CDP_SCAN_INTERVAL_MS, DEFAULT_CDP_DISCOVERY_INTERVAL_MS, DEFAULT_STATUS_INITIAL_REPORT_DELAY_MS, DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS, DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS, MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS, DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS, MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS, DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS, DEFAULT_SESSION_HOST_READY_TIMEOUT_MS, STANDALONE_CDP_SCAN_INTERVAL_MS, DaemonCdpScanner, DaemonCdpInitializer, WORKING_STATUSES, FULL_STATUS_ACTIVE_CHAT_OPTIONS, LIVE_STATUS_ACTIVE_CHAT_OPTIONS, STATUS_MODAL_MESSAGE_LIMIT, STATUS_MODAL_BUTTON_LIMIT, VALID_INPUT_MEDIA_TYPES, VALID_INPUT_STRATEGIES, TEXT_ONLY_MESSAGE_INPUT_SUPPORT, IDE_SESSION_CAPABILITIES, EXTENSION_SESSION_CAPABILITIES, PTY_SESSION_CAPABILITIES, CLI_CHAT_SESSION_CAPABILITIES, ACP_SESSION_CAPABILITIES, globalStore, RECENT_SEND_WINDOW_MS, READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS, HERMES_CLI_STARTING_SEND_SETTLE_MS, recentSendByTarget, DEFAULT_DEBUG_SANITIZE_OPTIONS, SECRET_KEY_PATTERN, KEY_TO_VK, COMMAND_DEBUG_LEVELS, DaemonCommandHandler, COMPLETED_FINALIZATION_RETRY_MS, COMPLETED_FINALIZATION_MAX_WAIT_MS, IMAGE_MIME_EXTENSIONS, MATERIALIZED_IMAGE_MAX_AGE_MS, MATERIALIZED_IMAGE_CLEANUP_INTERVAL_MS, lastMaterializedImageCleanupAt, CachedDatabaseSync, CliProviderInstance, AcpProviderInstance, chalkModule, chalkApi, COORDINATOR_DELEGATED_ENV_UNSETS, DaemonCliManager, VALID_CAPABILITY_MEDIA_TYPES, VALID_INPUT_STRATEGIES2, KNOWN_PROVIDER_FIELDS, VALUE_CONTROL_TYPES, ProviderLoader, _providerLoader, LOG_DIR2, MAX_FILE_SIZE, MAX_DAYS, SENSITIVE_KEYS, currentDate2, currentFile, writeCount2, SKIP_COMMANDS, DEFAULT_SERVER_NAME, DEFAULT_ADHDEV_MCP_COMMAND, HERMES_CLI_TYPE, HERMES_MCP_CONFIG_PATH, READ_DEBUG_ENABLED, recentReadDebugSignatureBySession, UPGRADE_HELPER_ENV, CHANNEL_NPM_TAG, CHANNEL_SERVER_URL, REFINE_VALIDATION_CATEGORIES, REFINE_VALIDATION_TIMEOUT_MS, REFINE_VALIDATION_OUTPUT_LIMIT_BYTES, REFINE_VALIDATION_SUMMARY_CHARS, REFINE_VALIDATION_MAX_COMMANDS, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter, DaemonStatusReporter, DEFAULT_DAEMON_PORT, DAEMON_WS_PATH, ProviderStreamAdapter, DaemonAgentStreamManager, AgentStreamPoller, ProviderInstanceManager, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive, DEV_SERVER_PORT, DevServer, SessionHostRuntimeTransport, SessionHostPtyTransportFactory, DEFAULT_SESSION_HOST_APP_NAME, DEFAULT_STANDALONE_SESSION_HOST_APP_NAME, STARTUP_TIMEOUT_MS, STARTUP_POLL_MS, SessionHostCompatibilityError, EXTENSION_CATALOG, SessionRegistry;
 var init_dist2 = __esm({
   "../daemon-core/dist/index.mjs"() {
     "use strict";
@@ -41159,20 +41707,24 @@ var init_dist2 = __esm({
     import_fs7 = require("fs");
     import_path4 = require("path");
     import_crypto5 = require("crypto");
-    fs2 = __toESM(require("fs"), 1);
-    path8 = __toESM(require("path"), 1);
+    import_child_process2 = require("child_process");
     os22 = __toESM(require("os"), 1);
+    path8 = __toESM(require("path"), 1);
+    import_fs8 = require("fs");
+    fs2 = __toESM(require("fs"), 1);
+    path9 = __toESM(require("path"), 1);
+    os32 = __toESM(require("os"), 1);
     init_dist();
     os8 = __toESM(require("os"), 1);
     os9 = __toESM(require("os"), 1);
     path14 = __toESM(require("path"), 1);
-    import_child_process2 = require("child_process");
+    import_child_process3 = require("child_process");
     os10 = __toESM(require("os"), 1);
     path15 = __toESM(require("path"), 1);
     init_dist();
     os11 = __toESM(require("os"), 1);
-    import_child_process3 = require("child_process");
-    import_fs8 = require("fs");
+    import_child_process4 = require("child_process");
+    import_fs9 = require("fs");
     import_promises5 = require("fs/promises");
     path = __toESM(require("path"), 1);
     import_util4 = require("util");
@@ -41185,16 +41737,12 @@ var init_dist2 = __esm({
     import_crypto6 = require("crypto");
     path6 = __toESM(require("path"), 1);
     path7 = __toESM(require("path"), 1);
-    import_fs9 = require("fs");
-    import_path5 = require("path");
-    import_child_process4 = require("child_process");
     import_fs10 = require("fs");
-    import_os3 = require("os");
-    path9 = __toESM(require("path"), 1);
+    import_path5 = require("path");
     import_child_process5 = require("child_process");
-    os32 = __toESM(require("os"), 1);
-    path10 = __toESM(require("path"), 1);
     import_fs11 = require("fs");
+    import_os3 = require("os");
+    path10 = __toESM(require("path"), 1);
     os42 = __toESM(require("os"), 1);
     import_child_process6 = require("child_process");
     init_wrapper();
@@ -41327,6 +41875,7 @@ var init_dist2 = __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;
       }
     });
     config_exports = {};
@@ -41485,6 +42034,7 @@ Follow these recovery rules:
       enqueueTask: () => enqueueTask,
       getMeshQueueStats: () => getMeshQueueStats,
       getQueue: () => getQueue,
+      recordTaskAutoLaunch: () => recordTaskAutoLaunch,
       requeueTask: () => requeueTask,
       updateSessionTaskStatus: () => updateSessionTaskStatus,
       updateTaskStatus: () => updateTaskStatus
@@ -41495,13 +42045,18 @@ Follow these recovery rules:
         init_mesh_ledger();
       }
     });
+    init_cli_detector = __esm2({
+      "src/detection/cli-detector.ts"() {
+        "use strict";
+      }
+    });
     init_logger = __esm2({
       "src/logging/logger.ts"() {
         "use strict";
         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 {
@@ -41509,16 +42064,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 (fs2.existsSync(oldLog)) {
             const stat22 = fs2.statSync(oldLog);
             const oldDate = stat22.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);
           }
@@ -41550,7 +42105,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`);
       }
     });
     mesh_events_exports = {};
@@ -41564,7 +42119,9 @@ Follow these recovery rules:
     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();
@@ -41585,6 +42142,9 @@ Follow these recovery rules:
           "agent:stopped": "task_failed",
           "monitor:long_generating": "task_stalled"
         };
+        autoLaunchInProgress = /* @__PURE__ */ new Set();
+        autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
+        AUTO_LAUNCH_COOLDOWN_MS = 5e3;
       }
     });
     init_debug_config = __esm2({
@@ -44078,7 +44638,7 @@ ${lastSnapshot}`;
       }
     });
     init_repo_mesh_types();
-    execFileAsync = (0, import_util4.promisify)(import_child_process3.execFile);
+    execFileAsync = (0, import_util4.promisify)(import_child_process4.execFile);
     DEFAULT_TIMEOUT_MS = 5e3;
     DEFAULT_MAX_BUFFER = 1024 * 1024;
     GitCommandError = class extends Error {
@@ -44337,6 +44897,34 @@ ${lastSnapshot}`;
     init_mesh_ledger();
     init_mesh_work_queue();
     init_mesh_events();
+    NO_FALLBACK_REASON = "Repo Mesh command/data-plane is P2P-only; WS/REST command fallback is intentionally disabled to preserve the transport boundary.";
+    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.";
+    NON_P2P_NEXT_ACTION = "Inspect the provider/command error and fix the underlying logic or configuration before retrying.";
+    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;
+      }
+    };
     init_config();
     DEFAULT_STATE = {
       recentActivity: [],
@@ -44348,6 +44936,7 @@ ${lastSnapshot}`;
     };
     BUILTIN_IDE_DEFINITIONS = [];
     registeredIDEs = /* @__PURE__ */ new Map();
+    init_cli_detector();
     LIVE_LIFECYCLES = /* @__PURE__ */ new Set(["starting", "running", "stopping", "interrupted"]);
     DEFAULT_ACTIVE_CHAT_POLL_STATUSES = /* @__PURE__ */ new Set([
       "generating",
@@ -48079,6 +48668,7 @@ ${effect.notification.body || ""}`.trim();
       }
     };
     init_provider_cli_adapter();
+    init_cli_detector();
     init_config();
     init_provider_cli_adapter();
     init_logger();
@@ -52430,6 +53020,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     };
     _providerLoader = null;
     init_config();
+    init_cli_detector();
     init_logger();
     LOG_DIR2 = process.platform === "win32" ? path21.join(process.env.LOCALAPPDATA || process.env.APPDATA || path21.join(os16.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path21.join(os16.homedir(), "Library", "Logs", "adhdev") : path21.join(os16.homedir(), ".local", "share", "adhdev", "logs");
     MAX_FILE_SIZE = 5 * 1024 * 1024;
@@ -52478,6 +53069,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
       stable: "https://api.adhf.dev",
       preview: "https://api-preview.adhf.dev"
     };
+    REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
+    REFINE_VALIDATION_TIMEOUT_MS = 12e4;
+    REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
+    REFINE_VALIDATION_SUMMARY_CHARS = 2e3;
+    REFINE_VALIDATION_MAX_COMMANDS = 4;
     CHAT_COMMANDS = [
       "send_chat",
       "new_chat",
@@ -52610,20 +53206,98 @@ Run 'adhdev doctor' for detailed diagnostics.`
             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";
       }
@@ -53583,10 +54257,61 @@ Run 'adhdev doctor' for detailed diagnostics.`
               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,
@@ -53599,11 +54324,27 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 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 };
             }
@@ -53658,7 +54399,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
                       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 {
@@ -57555,6 +58299,7 @@ data: ${JSON.stringify(msg.data)}
         apiKeyName: "OpenAI/Anthropic API key"
       }
     ];
+    init_cli_detector();
     SessionRegistry = class {
       bySessionId = /* @__PURE__ */ new Map();
       byManagerKey = /* @__PURE__ */ new Map();
@@ -58040,16 +58785,38 @@ function extractLaunchPayload(value) {
 function classifyMeshLaunchFailure(error48) {
   const message = error48 instanceof Error ? error48.message : String(error48 || "launch failed");
   const lower = message.toLowerCase();
-  if (lower.includes("p2p") || lower.includes("datachannel") || lower.includes("node-datachannel")) {
-    return { code: "p2p_unavailable", reason: "daemon_mesh_p2p_transport_unavailable", transport: "daemon_mesh_p2p" };
+  const p2pClassification = classifyP2pRelayFailure(error48, { command: "launch_cli" });
+  if (p2pClassification.recoverable) {
+    return p2pClassification;
   }
   if (lower.includes("cannot connect to daemon ipc") || lower.includes("daemon ipc command")) {
-    return { code: "local_ipc_unavailable", reason: "local_daemon_ipc_unavailable", transport: "local_ipc" };
+    return {
+      code: "local_ipc_unavailable",
+      reason: "local_daemon_ipc_unavailable",
+      transport: "local_ipc",
+      recoverable: true,
+      retryRecommended: true,
+      nextAction: "Check the local daemon IPC connection, then retry mesh_launch_session once after the daemon is reachable."
+    };
   }
   if (lower.includes("timed out") || lower.includes("timeout")) {
-    return { code: "mesh_transport_timeout", reason: "mesh_transport_timeout", transport: "mesh_transport" };
+    return {
+      code: "mesh_transport_timeout",
+      reason: "mesh_transport_timeout",
+      transport: "mesh_transport",
+      recoverable: true,
+      retryRecommended: true,
+      nextAction: "Check mesh transport health, then do one bounded retry before requeueing or relaunching the task."
+    };
   }
-  return { code: "mesh_launch_failed", reason: "provider_launch_failed", transport: "mesh_transport" };
+  return {
+    code: "mesh_launch_failed",
+    reason: "provider_launch_failed",
+    transport: "mesh_transport",
+    recoverable: false,
+    retryRecommended: false,
+    nextAction: "Inspect the provider launch error and fix the underlying provider/configuration issue before retrying."
+  };
 }
 function buildWorktreeCleanupHint(node) {
   if (!node.isLocalWorktree) return void 0;
@@ -58065,10 +58832,13 @@ function buildRecoverableLaunchFailure(ctx, node, providerType, error48) {
   const cleanup = buildWorktreeCleanupHint(node);
   return {
     success: false,
-    recoverable: true,
+    recoverable: classified.recoverable,
     code: classified.code,
     reason: classified.reason,
     transport: classified.transport,
+    retryRecommended: classified.retryRecommended,
+    nextAction: classified.nextAction,
+    ...classified.noFallbackReason ? { noFallbackReason: classified.noFallbackReason } : {},
     error: message,
     meshId: ctx.mesh.id,
     nodeId: node.id,
@@ -58115,6 +58885,18 @@ function getLatestActiveLaunchFailure(meshId, nodeId) {
   }
   return null;
 }
+function buildCoordinatorP2pRelayFailure(error48, context) {
+  const payload = buildP2pRelayFailurePayload(error48, {
+    command: context.command,
+    targetDaemonId: context.targetDaemonId
+  });
+  return {
+    ...payload,
+    ...context.nodeId ? { nodeId: context.nodeId } : {},
+    ...context.sessionId ? { sessionId: context.sessionId } : {},
+    retryHint: payload.retryRecommended ? payload.nextAction : "Do not retry as a P2P transport recovery; inspect the command/provider error first."
+  };
+}
 async function ipcDispatchToRemoteAgent(ctx, node, args) {
   const transport = ctx.transport;
   const daemonId = node.daemonId;
@@ -58150,11 +58932,32 @@ async function ipcDispatchToRemoteAgent(ctx, node, args) {
     });
     const dispatchPayload = unwrapCommandPayload(dispatchResult);
     if (dispatchPayload?.success === false || dispatchResult?.success === false) {
-      return { success: false, error: `P2P dispatch failed: ${dispatchPayload?.error || dispatchResult?.error || "agent_command rejected the task"}` };
+      const source = dispatchPayload?.success === false ? dispatchPayload : dispatchResult;
+      const errorMessage = dispatchPayload?.error || dispatchResult?.error || "agent_command rejected the task";
+      return {
+        ...buildCoordinatorP2pRelayFailure(source?.error || errorMessage, {
+          command: "agent_command",
+          targetDaemonId: daemonId,
+          nodeId: node.id,
+          sessionId
+        }),
+        ...source && typeof source === "object" ? source : {},
+        success: false,
+        error: `P2P dispatch failed: ${errorMessage}`
+      };
     }
     return { success: true, dispatched: true, sessionId: sessionId || resolvedProviderType };
   } catch (e) {
-    return { success: false, error: `P2P dispatch failed: ${e?.message || String(e)}` };
+    const errorMessage = e?.message || String(e);
+    return {
+      ...buildCoordinatorP2pRelayFailure(e, {
+        command: "agent_command",
+        targetDaemonId: daemonId,
+        nodeId: node.id,
+        sessionId
+      }),
+      error: `P2P dispatch failed: ${errorMessage}`
+    };
   }
 }
 function resolveCoordinatorNode(ctx) {
@@ -58399,8 +59202,7 @@ async function commandForNode(ctx, node, command, args = {}) {
   throw new Error(`Command '${command}' requires daemon IPC/local transport for node '${node.id}'`);
 }
 function isP2pTransportUnavailableError(error48) {
-  const message = error48 instanceof Error ? error48.message : String(error48 || "");
-  return /p2p|datachannel|mesh_relay_command|daemon_mesh_p2p_transport_unavailable/i.test(message) && /unavailable|failed|timeout|timed out|not connected|closed/i.test(message);
+  return isP2pRelayTransportFailure(error48);
 }
 function buildRemoveNodeArgs(ctx, nodeId, sessionCleanupMode) {
   return {
@@ -58993,7 +59795,13 @@ async function meshSendTask(ctx, args) {
     }
     return JSON.stringify({ success: true, nodeId: args.node_id, taskId: task.id, status: task.status });
   } catch (e) {
-    return JSON.stringify({ success: false, error: e.message });
+    const failure2 = buildCoordinatorP2pRelayFailure(e, {
+      command: "mesh_send_task",
+      targetDaemonId: node.daemonId,
+      nodeId: args.node_id,
+      sessionId: args.session_id
+    });
+    return JSON.stringify(failure2);
   }
 }
 async function meshReadChat(ctx, args) {