@love-moon/conductor-cli 0.2.31 → 0.2.33

package/src/daemon.js

@@ -8,13 +8,21 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import dotenv from "dotenv";
 import yaml from "js-yaml";
 
-import { ConductorWebSocketClient, ConductorConfig, loadConfig, ConfigFileNotFound } from "@love-moon/conductor-sdk";
+import {
+  ConductorWebSocketClient,
+  ConductorConfig,
+  loadConfig,
+  ConfigFileNotFound,
+  ProjectContext,
+} from "@love-moon/conductor-sdk";
 import { DaemonLogCollector } from "./log-collector.js";
 import { resolveResumeContext } from "./fire/resume.js";
 import {
-  RUNTIME_SUPPORTED_BACKENDS,
+  filterRuntimeSupportedAllowCliList,
+  listAdvertisedBackends,
+  resolveConfiguredRuntimeBackend,
+  isBuiltInRuntimeBackend,
   isRuntimeSupportedBackend,
-  listRuntimeSupportedBackends,
   normalizeRuntimeBackendAlias,
   normalizeRuntimeBackendName,
 } from "./runtime-backends.js";
@@ -59,6 +67,7 @@ const DEFAULT_TERMINAL_ROWS = 40;
 const DEFAULT_TERMINAL_RING_BUFFER_MAX_BYTES = 2 * 1024 * 1024;
 const DEFAULT_TERMINAL_RESUME_SNAPSHOT_MAX_BYTES = 128 * 1024;
 const DEFAULT_RTC_MODULE_CANDIDATES = ["@roamhq/wrtc", "wrtc"];
+const BLOCKING_SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
 let nodePtySpawnPromise = null;
 
 function resolveNodePtySpawnExport(mod) {
@@ -117,6 +126,20 @@ function logError(message) {
   appendDaemonLog(line);
 }
 
+function sleepSync(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) {
+    return;
+  }
+  try {
+    Atomics.wait(BLOCKING_SLEEP_BUFFER, 0, 0, ms);
+  } catch {
+    const deadline = Date.now() + ms;
+    while (Date.now() < deadline) {
+      // best-effort fallback for runtimes that disallow Atomics.wait
+    }
+  }
+}
+
 function getUserConfig(configFilePath) {
   try {
     const home = os.homedir();
@@ -192,14 +215,12 @@ function filterConfiguredAllowCliList(allowCliList) {
   if (!allowCliList || typeof allowCliList !== "object") {
     return {};
   }
-  const builtInBackends = new Set(RUNTIME_SUPPORTED_BACKENDS);
   const filtered = {};
   for (const [backend, command] of Object.entries(allowCliList)) {
     const normalizedBackend = normalizeRuntimeBackendName(backend);
     if (
       !normalizedBackend ||
-      LEGACY_RUNTIME_BACKEND_ALIASES.has(normalizedBackend) ||
-      !builtInBackends.has(normalizedBackend)
+      LEGACY_RUNTIME_BACKEND_ALIASES.has(normalizedBackend)
     ) {
       continue;
     }
@@ -222,10 +243,28 @@ function getAllowCliList(userConfig) {
   return DEFAULT_CLI_LIST;
 }
 
+function getRawAllowCliList(userConfig) {
+  if (userConfig.allow_cli_list && typeof userConfig.allow_cli_list === "object") {
+    return userConfig.allow_cli_list;
+  }
+  return DEFAULT_CLI_LIST;
+}
+
 function formatBackendLaunchCommand(cliCommand) {
   return typeof cliCommand === "string" && cliCommand.trim() ? cliCommand.trim() : "ai-sdk-managed";
 }
 
+function serializeRuntimeBackendMap(runtimeBackendMap) {
+  if (!runtimeBackendMap || typeof runtimeBackendMap !== "object") {
+    return "";
+  }
+  return Object.entries(runtimeBackendMap)
+    .filter(([backend, runtimeBackend]) => backend && runtimeBackend)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([backend, runtimeBackend]) => `${backend}=${runtimeBackend}`)
+    .join(",");
+}
+
 async function defaultCreatePty(command, args, options) {
   if (!nodePtySpawnPromise) {
     const spawnHelperInfo = ensureNodePtySpawnHelperExecutable();
@@ -393,6 +432,64 @@ function normalizeLaunchConfig(value) {
   return value;
 }
 
+function normalizeBooleanFlag(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return value === 1;
+  }
+  if (typeof value !== "string") {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+
+function parseTaskWorktreeLaunchConfig(launchConfig) {
+  const normalizedLaunchConfig = normalizeLaunchConfig(launchConfig);
+  const worktreeEnabled = normalizeBooleanFlag(
+    normalizedLaunchConfig.worktree ??
+      normalizedLaunchConfig.createWorktree ??
+      normalizedLaunchConfig.create_worktree,
+  );
+  if (!worktreeEnabled) {
+    return null;
+  }
+
+  const worktreeId =
+    normalizeOptionalString(normalizedLaunchConfig.worktreeId) ||
+    normalizeOptionalString(normalizedLaunchConfig.worktree_id);
+  const worktreeBranch =
+    normalizeOptionalString(normalizedLaunchConfig.worktreeBranch) ||
+    normalizeOptionalString(normalizedLaunchConfig.worktree_branch);
+  const projectRepoRoot =
+    normalizeOptionalString(normalizedLaunchConfig.projectRepoRoot) ||
+    normalizeOptionalString(normalizedLaunchConfig.project_repo_root);
+  const projectWorkspacePath =
+    normalizeOptionalString(normalizedLaunchConfig.projectWorkspacePath) ||
+    normalizeOptionalString(normalizedLaunchConfig.project_workspace_path);
+  const projectRelativePath =
+    normalizeOptionalString(normalizedLaunchConfig.projectRelativePath) ||
+    normalizeOptionalString(normalizedLaunchConfig.project_relative_path) ||
+    ".";
+  if (!worktreeId || !worktreeBranch || !projectRepoRoot || !projectWorkspacePath) {
+    return null;
+  }
+
+  return {
+    worktreeId,
+    worktreeBranch,
+    worktreeBaseRef:
+      normalizeOptionalString(normalizedLaunchConfig.worktreeBaseRef) ||
+      normalizeOptionalString(normalizedLaunchConfig.worktree_base_ref) ||
+      "HEAD",
+    projectRepoRoot,
+    projectWorkspacePath,
+    projectRelativePath,
+  };
+}
+
 function normalizeTerminalEnv(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return {};
@@ -410,6 +507,36 @@ function normalizeTerminalEnv(value) {
   return env;
 }
 
+const PTY_TASK_SCOPED_ENV_KEYS = [
+  "CONDUCTOR_PROJECT_ID",
+  "CONDUCTOR_TASK_ID",
+  "CONDUCTOR_PTY_SESSION_ID",
+  "CONDUCTOR_LAUNCHED_BY_DAEMON",
+  "CONDUCTOR_RESUME_CWD",
+];
+
+function stripPtyTaskScopedEnv(source) {
+  const env = {
+    ...(source && typeof source === "object" ? source : {}),
+  };
+  for (const key of PTY_TASK_SCOPED_ENV_KEYS) {
+    delete env[key];
+  }
+  return env;
+}
+
+function buildPtyTaskEnv(baseEnv = process.env, launchEnv = {}) {
+  const parentEnv = stripPtyTaskScopedEnv(baseEnv);
+  const taskLaunchEnv = stripPtyTaskScopedEnv(launchEnv);
+  const env = {
+    ...parentEnv,
+  };
+  return {
+    ...env,
+    ...taskLaunchEnv,
+  };
+}
+
 export function startDaemon(config = {}, deps = {}) {
   const exitFn = deps.exit || process.exit;
   const killFn = deps.kill || process.kill;
@@ -495,8 +622,10 @@ export function startDaemon(config = {}, deps = {}) {
   const CLI_PATH_VAL = config.CLI_PATH || CLI_PATH;
 
   // Get allow_cli_list from config
-  const ALLOW_CLI_LIST = getAllowCliList(userConfig);
-  let SUPPORTED_BACKENDS = Object.keys(ALLOW_CLI_LIST);
+  const RAW_ALLOW_CLI_LIST = getRawAllowCliList(userConfig);
+  let ALLOW_CLI_LIST = {};
+  let SUPPORTED_BACKENDS = [];
+  let SUPPORTED_BACKEND_RUNTIME_MAP = {};
   const fetchLatestVersionFn = deps.fetchLatestVersion || fetchLatestVersion;
   const isNewerVersionFn = deps.isNewerVersion || isNewerVersion;
   const detectPackageManagerFn = deps.detectPackageManager || detectPackageManager;
@@ -539,7 +668,11 @@ export function startDaemon(config = {}, deps = {}) {
   const mkdirSyncFn = deps.mkdirSync || fs.mkdirSync;
   const writeFileSyncFn = deps.writeFileSync || fs.writeFileSync;
   const existsSyncFn = deps.existsSync || fs.existsSync;
+  const statSyncFn = deps.statSync || fs.statSync;
+  const lstatSyncFn = deps.lstatSync || fs.lstatSync;
   const readFileSyncFn = deps.readFileSync || fs.readFileSync;
+  const readlinkSyncFn = deps.readlinkSync || fs.readlinkSync;
+  const symlinkSyncFn = deps.symlinkSync || fs.symlinkSync;
   const unlinkSyncFn = deps.unlinkSync || fs.unlinkSync;
   const renameSyncFn = deps.renameSync || fs.renameSync;
   const createWriteStreamFn = deps.createWriteStream || fs.createWriteStream;
@@ -550,6 +683,263 @@ export function startDaemon(config = {}, deps = {}) {
     deps.createWebSocketClient ||
     ((clientConfig, options) => new ConductorWebSocketClient(clientConfig, options));
   const createLogCollector = deps.createLogCollector || ((backendUrl) => new DaemonLogCollector(backendUrl));
+  const resolveProjectSnapshotFn =
+    deps.resolveProjectSnapshot || ((projectPath) => new ProjectContext(projectPath).snapshot());
+
+  function buildTaskWorktreeRoot(projectWorkspacePath, worktreeId) {
+    const sanitized = String(worktreeId).replace(/[/\\]/g, "_").replace(/\.\./g, "_");
+    return path.join(projectWorkspacePath, ".conductor", "worktrees", sanitized);
+  }
+
+  function resolveTaskWorktreeCwd(worktreeRoot, projectRelativePath) {
+    return projectRelativePath && projectRelativePath !== "."
+      ? path.join(worktreeRoot, projectRelativePath)
+      : worktreeRoot;
+  }
+
+  function normalizeConfiguredPathList(value, projectWorkspacePath = "") {
+    const rawList = typeof value === "string"
+      ? [value]
+      : Array.isArray(value)
+        ? value
+        : [];
+    const deduped = [];
+    for (const entry of rawList) {
+      const normalizedEntry = normalizeOptionalString(entry);
+      if (!normalizedEntry) continue;
+      const exactConfiguredPathExists =
+        projectWorkspacePath &&
+        existsSyncFn(path.resolve(projectWorkspacePath, normalizedEntry));
+      const normalizedEntries =
+        !exactConfiguredPathExists && /\s/.test(normalizedEntry)
+          ? normalizedEntry.split(/\s+/).map((part) => normalizeOptionalString(part)).filter(Boolean)
+          : [normalizedEntry];
+      for (const candidate of normalizedEntries) {
+        if (deduped.includes(candidate)) {
+          continue;
+        }
+        deduped.push(candidate);
+      }
+    }
+    return deduped;
+  }
+
+  function resolveProjectScopedPath(basePath, configuredPath, label) {
+    const resolvedPath = path.resolve(basePath, configuredPath);
+    const relativePath = path.relative(basePath, resolvedPath);
+    if (
+      relativePath === "" ||
+      relativePath === "." ||
+      relativePath.startsWith("..") ||
+      path.isAbsolute(relativePath)
+    ) {
+      throw new Error(`${label} must stay within ${basePath}`);
+    }
+    return resolvedPath;
+  }
+
+  function readProjectWorktreeSettings(projectWorkspacePath) {
+    const settingsCandidates = [
+      path.join(projectWorkspacePath, ".conductor", "settings.yaml"),
+      path.join(projectWorkspacePath, ".conductor", "settings.yml"),
+      path.join(projectWorkspacePath, ".conductor", "setttings.yaml"),
+      path.join(projectWorkspacePath, ".conductor", "setttings.yml"),
+    ];
+
+    for (const settingsPath of settingsCandidates) {
+      if (!existsSyncFn(settingsPath)) {
+        continue;
+      }
+      try {
+        const parsed = yaml.load(readFileSyncFn(settingsPath, "utf8"));
+        const worktreeSettings =
+          parsed && typeof parsed === "object" && !Array.isArray(parsed) &&
+          parsed.worktree && typeof parsed.worktree === "object" && !Array.isArray(parsed.worktree)
+            ? parsed.worktree
+            : {};
+        return {
+          symlinkPaths: normalizeConfiguredPathList(worktreeSettings.symlink, projectWorkspacePath),
+          settingsPath,
+        };
+      } catch (error) {
+        throw new Error(`Failed to read ${settingsPath}: ${error?.message || error}`);
+      }
+    }
+
+    return {
+      symlinkPaths: [],
+      settingsPath: null,
+    };
+  }
+
+  function ensureTaskWorktreeSymlinks({ projectWorkspacePath, finalCwd }) {
+    const { symlinkPaths } = readProjectWorktreeSettings(projectWorkspacePath);
+    for (const configuredPath of symlinkPaths) {
+      const sourcePath = resolveProjectScopedPath(
+        projectWorkspacePath,
+        configuredPath,
+        `worktree.symlink entry ${configuredPath}`,
+      );
+      const linkPath = resolveProjectScopedPath(
+        finalCwd,
+        configuredPath,
+        `worktree.symlink destination ${configuredPath}`,
+      );
+      mkdirSyncFn(path.dirname(linkPath), { recursive: true });
+
+      if (existsSyncFn(linkPath)) {
+        try {
+          const stat = lstatSyncFn(linkPath);
+          if (!stat.isSymbolicLink()) {
+            throw new Error(`worktree symlink destination already exists: ${linkPath}`);
+          }
+          const currentTarget = readlinkSyncFn(linkPath);
+          const currentResolvedTarget = path.resolve(path.dirname(linkPath), currentTarget);
+          if (currentResolvedTarget === sourcePath) {
+            continue;
+          }
+          throw new Error(`worktree symlink destination already points elsewhere: ${linkPath}`);
+        } catch (error) {
+          throw error instanceof Error ? error : new Error(String(error));
+        }
+      }
+
+      const relativeTarget = path.relative(path.dirname(linkPath), sourcePath) || ".";
+      symlinkSyncFn(relativeTarget, linkPath);
+    }
+  }
+
+  async function runSpawnProcess(command, args, options = {}) {
+    let child;
+    try {
+      child = spawnFn(command, args, {
+        ...options,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+    } catch (error) {
+      throw error instanceof Error ? error : new Error(String(error));
+    }
+
+    return await new Promise((resolve, reject) => {
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+
+      const finishResolve = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        resolve({ stdout, stderr });
+      };
+
+      const finishReject = (error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        reject(error instanceof Error ? error : new Error(String(error)));
+      };
+
+      if (child.stdout && typeof child.stdout.on === "function") {
+        child.stdout.on("data", (chunk) => {
+          stdout += String(chunk ?? "");
+        });
+      }
+      if (child.stderr && typeof child.stderr.on === "function") {
+        child.stderr.on("data", (chunk) => {
+          stderr += String(chunk ?? "");
+        });
+      }
+      if (typeof child.on === "function") {
+        child.on("error", (error) => {
+          finishReject(error);
+        });
+        child.on("close", (code, signal) => {
+          if (code === 0) {
+            finishResolve();
+            return;
+          }
+          const detail = (stderr || stdout).trim();
+          finishReject(
+            new Error(
+              `${command} ${args.join(" ")} failed` +
+                (signal ? ` (signal ${signal})` : ` (exit ${code ?? "unknown"})`) +
+                (detail ? `: ${detail}` : ""),
+            ),
+          );
+        });
+        return;
+      }
+      finishResolve();
+    });
+  }
+
+  async function ensureTaskWorktree({ taskId, projectId, launchConfig }) {
+    const worktreeConfig = parseTaskWorktreeLaunchConfig(launchConfig);
+    if (!worktreeConfig) {
+      return null;
+    }
+
+    const worktreeRoot = buildTaskWorktreeRoot(
+      worktreeConfig.projectWorkspacePath,
+      worktreeConfig.worktreeId,
+    );
+    const finalCwd = resolveTaskWorktreeCwd(worktreeRoot, worktreeConfig.projectRelativePath);
+    const gitMarkerPath = path.join(worktreeRoot, ".git");
+    if (!existsSyncFn(gitMarkerPath)) {
+      mkdirSyncFn(path.dirname(worktreeRoot), { recursive: true });
+      try {
+        await runSpawnProcess(
+          "git",
+          [
+            "-C",
+            worktreeConfig.projectRepoRoot,
+            "worktree",
+            "add",
+            "-b",
+            worktreeConfig.worktreeBranch,
+            worktreeRoot,
+            worktreeConfig.worktreeBaseRef,
+          ],
+          {
+            cwd: worktreeConfig.projectRepoRoot,
+          },
+        );
+      } catch (primaryError) {
+        if (!existsSyncFn(gitMarkerPath)) {
+          try {
+            await runSpawnProcess(
+              "git",
+              [
+                "-C",
+                worktreeConfig.projectRepoRoot,
+                "worktree",
+                "add",
+                worktreeRoot,
+                worktreeConfig.worktreeBranch,
+              ],
+              {
+                cwd: worktreeConfig.projectRepoRoot,
+              },
+            );
+          } catch (reuseError) {
+            throw new Error(
+              `Failed to prepare git worktree for ${taskId}: ${reuseError?.message || primaryError?.message || primaryError}`,
+            );
+          }
+        }
+      }
+    }
+
+    mkdirSyncFn(finalCwd, { recursive: true });
+    ensureTaskWorktreeSymlinks({
+      projectWorkspacePath: worktreeConfig.projectWorkspacePath,
+      finalCwd,
+    });
+    return finalCwd;
+  }
+
   const RTC_MODULE_CANDIDATES = resolveRtcModuleCandidates(process.env.CONDUCTOR_PTY_RTC_MODULES);
   const RTC_DIRECT_DISABLED = parseBooleanEnv(process.env.CONDUCTOR_DISABLE_PTY_DIRECT_RTC);
   const PROJECT_PATH_LOOKUP_TIMEOUT_MS = parsePositiveInt(
@@ -560,6 +950,18 @@ export function startDaemon(config = {}, deps = {}) {
     process.env.CONDUCTOR_STOP_FORCE_KILL_TIMEOUT_MS,
     5000,
   );
+  const DAEMON_FORCE_STOP_GRACE_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_FORCE_STOP_GRACE_MS,
+    15_000,
+  );
+  const DAEMON_FORCE_STOP_POLL_INTERVAL_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_FORCE_STOP_POLL_INTERVAL_MS,
+    100,
+  );
+  const DAEMON_FORCE_KILL_WAIT_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_FORCE_KILL_WAIT_MS,
+    2_000,
+  );
   const SHUTDOWN_STATUS_REPORT_TIMEOUT_MS = parsePositiveInt(
     process.env.CONDUCTOR_SHUTDOWN_STATUS_REPORT_TIMEOUT_MS,
     1000,
@@ -648,6 +1050,20 @@ export function startDaemon(config = {}, deps = {}) {
     return true;
   };
 
+  const waitForProcessExitSync = (pid, timeoutMs) => {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      if (!isProcessAlive(pid)) {
+        return true;
+      }
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) {
+        return false;
+      }
+      sleepSync(Math.min(DAEMON_FORCE_STOP_POLL_INTERVAL_MS, remainingMs));
+    }
+  };
+
   try {
     mkdirSyncFn(WORKSPACE_ROOT, { recursive: true });
   } catch (err) {
@@ -670,17 +1086,35 @@ export function startDaemon(config = {}, deps = {}) {
             if (alive) {
               if (config.FORCE) {
                 log(`Force enabled: stopping existing daemon PID ${pid}`);
+                let alreadyExited = false;
                 try {
                   killFn(pid, "SIGTERM");
                 } catch (killErr) {
-                  if (!killErr || killErr.code !== "ESRCH") {
+                  if (killErr?.code === "ESRCH") {
+                    alreadyExited = true;
+                  } else {
                     logError(`Failed to stop existing daemon PID ${pid}: ${killErr.message}`);
                     return exitAndReturn(1);
                   }
                 }
                 try {
-                  if (isProcessAlive(pid)) {
-                    logError(`Existing daemon PID ${pid} is still running; please stop it manually.`);
+                  let exited = alreadyExited || waitForProcessExitSync(pid, DAEMON_FORCE_STOP_GRACE_MS);
+                  if (!exited) {
+                    log(
+                      `Existing daemon PID ${pid} did not exit within ${DAEMON_FORCE_STOP_GRACE_MS}ms; sending SIGKILL`,
+                    );
+                    try {
+                      killFn(pid, "SIGKILL");
+                    } catch (killErr) {
+                      if (killErr?.code !== "ESRCH") {
+                        logError(`Failed to force kill existing daemon PID ${pid}: ${killErr.message}`);
+                        return exitAndReturn(1);
+                      }
+                    }
+                    exited = waitForProcessExitSync(pid, DAEMON_FORCE_KILL_WAIT_MS);
+                  }
+                  if (!exited) {
+                    logError(`Existing daemon PID ${pid} is still running after force restart; please stop it manually.`);
                     return exitAndReturn(1);
                   }
                 } catch (checkErr) {
@@ -688,7 +1122,9 @@ export function startDaemon(config = {}, deps = {}) {
                   return exitAndReturn(1);
                 }
                 log("Removing lock file after force stop");
-                unlinkSyncFn(LOCK_FILE);
+                if (existsSyncFn(LOCK_FILE)) {
+                  unlinkSyncFn(LOCK_FILE);
+                }
               } else {
                 logError(`Daemon already running with PID ${pid}`);
                 return exitAndReturn(1);
@@ -878,8 +1314,12 @@ export function startDaemon(config = {}, deps = {}) {
     "x-conductor-backends": SUPPORTED_BACKENDS.join(","),
     "x-conductor-version": cliVersion,
   };
+  const advertisedCapabilities = ["project_path_validation"];
   if (ptyTaskCapabilityEnabled) {
-    extraHeaders["x-conductor-capabilities"] = "pty_task,terminal_snapshot";
+    advertisedCapabilities.push("pty_task", "terminal_snapshot");
+  }
+  if (advertisedCapabilities.length > 0) {
+    extraHeaders["x-conductor-capabilities"] = advertisedCapabilities.join(",");
   }
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders,
@@ -937,14 +1377,31 @@ export function startDaemon(config = {}, deps = {}) {
 
   void (async () => {
     try {
-      const runtimeBackends = await listRuntimeSupportedBackends({ configFilePath: config.CONFIG_FILE });
-      const externalBackends = runtimeBackends.filter((backend) => !RUNTIME_SUPPORTED_BACKENDS.includes(backend));
-      SUPPORTED_BACKENDS = [...new Set([...Object.keys(ALLOW_CLI_LIST), ...externalBackends])];
+      ALLOW_CLI_LIST = await filterRuntimeSupportedAllowCliList(RAW_ALLOW_CLI_LIST, {
+        configFilePath: config.CONFIG_FILE,
+      });
     } catch (error) {
-      logError(`Failed to discover external backends: ${error?.message || error}`);
+      ALLOW_CLI_LIST = {};
+      logError(`Failed to filter configured backends: ${error?.message || error}`);
+    }
+
+    try {
+      const advertisedBackends = await listAdvertisedBackends(ALLOW_CLI_LIST, {
+        configFilePath: config.CONFIG_FILE,
+      });
+      SUPPORTED_BACKENDS = advertisedBackends.supportedBackends;
+      SUPPORTED_BACKEND_RUNTIME_MAP = advertisedBackends.runtimeBackendMap;
+      if (advertisedBackends.discoveryError) {
+        logError(`Failed to discover external backends: ${advertisedBackends.discoveryError?.message || advertisedBackends.discoveryError}`);
+      }
+    } catch (error) {
+      SUPPORTED_BACKENDS = [];
+      SUPPORTED_BACKEND_RUNTIME_MAP = {};
+      logError(`Failed to resolve advertised backends: ${error?.message || error}`);
     }
 
     extraHeaders["x-conductor-backends"] = SUPPORTED_BACKENDS.join(",");
+    extraHeaders["x-conductor-backend-runtime-map"] = serializeRuntimeBackendMap(SUPPORTED_BACKEND_RUNTIME_MAP);
     if (typeof client?.setExtraHeaders === "function") {
       client.setExtraHeaders(extraHeaders);
     }
@@ -1581,6 +2038,30 @@ export function startDaemon(config = {}, deps = {}) {
     });
   }
 
+  function reportTaskWorktreeCleanupResult({
+    requestId,
+    taskId,
+    worktreeBranch = null,
+    removedPath = null,
+    cleaned = true,
+    error = null,
+  }) {
+    if (!requestId || !taskId) return Promise.resolve();
+    return client.sendJson({
+      type: "task_worktree_cleanup_result",
+      payload: {
+        request_id: String(requestId),
+        task_id: String(taskId),
+        daemon_host: AGENT_NAME || os.hostname(),
+        worktree_branch: worktreeBranch || undefined,
+        removed_path: removedPath || undefined,
+        cleaned: Boolean(cleaned),
+        error: error ? String(error) : null,
+        cleaned_at: new Date().toISOString(),
+      },
+    });
+  }
+
   function sendPtyTransportStatus(payload) {
     return client.sendJson({
       type: "pty_transport_status",
@@ -2202,7 +2683,9 @@ export function startDaemon(config = {}, deps = {}) {
       rejectCreatePtyTaskDuringShutdown(payload);
       return;
     }
-    let taskDir = normalizeOptionalString(launchConfig.cwd) || boundPath;
+    let taskDir =
+      normalizeOptionalString(launchConfig.cwd) ||
+      boundPath;
     if (!taskDir) {
       const now = new Date();
       const dayDir = path.join(WORKSPACE_ROOT, formatWorkspaceDate(now));
@@ -2255,22 +2738,7 @@ export function startDaemon(config = {}, deps = {}) {
       logError(`Failed to report agent_command_ack(create_pty_task) for ${taskId}: ${err?.message || err}`);
     });
 
-    const env = {
-      ...process.env,
-      ...launchSpec.env,
-      CONDUCTOR_PROJECT_ID: projectId,
-      CONDUCTOR_TASK_ID: taskId,
-      CONDUCTOR_PTY_SESSION_ID: ptySessionId,
-    };
-    if (config.CONFIG_FILE) {
-      env.CONDUCTOR_CONFIG = config.CONFIG_FILE;
-    }
-    if (AGENT_TOKEN) {
-      env.CONDUCTOR_AGENT_TOKEN = AGENT_TOKEN;
-    }
-    if (BACKEND_HTTP) {
-      env.CONDUCTOR_BACKEND_URL = BACKEND_HTTP;
-    }
+    const env = buildPtyTaskEnv(process.env, launchSpec.env);
 
     const logPath = path.join(launchSpec.cwd, "conductor-terminal.log");
     let logStream;
@@ -2360,6 +2828,119 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
+  async function handleCleanupTaskWorktree(payload) {
+    const taskId = payload?.task_id ? String(payload.task_id) : "";
+    const projectId = payload?.project_id ? String(payload.project_id) : "";
+    const requestId = payload?.request_id ? String(payload.request_id) : "";
+    const forceCleanup = payload?.force === true;
+    const launchConfig = normalizeLaunchConfig(payload?.launch_config);
+
+    if (!taskId || !projectId || !requestId) {
+      logError(`Invalid cleanup_task_worktree payload: ${JSON.stringify(payload)}`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "cleanup_task_worktree",
+        accepted: false,
+      }).catch(() => {});
+      return;
+    }
+
+    const worktreeConfig = parseTaskWorktreeLaunchConfig(launchConfig);
+    if (!worktreeConfig) {
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "cleanup_task_worktree",
+        accepted: false,
+      }).catch(() => {});
+      await reportTaskWorktreeCleanupResult({
+        requestId,
+        taskId,
+        cleaned: false,
+        error: "Task does not use an isolated worktree",
+      }).catch((error) => {
+        logError(`Failed to report task_worktree_cleanup_result for ${taskId}: ${error?.message || error}`);
+      });
+      return;
+    }
+
+    sendAgentCommandAck({
+      requestId,
+      taskId,
+      eventType: "cleanup_task_worktree",
+      accepted: true,
+    }).catch((error) => {
+      logError(`Failed to report agent_command_ack(cleanup_task_worktree) for ${taskId}: ${error?.message || error}`);
+    });
+
+    if (activeTaskProcesses.has(taskId) || activePtySessions.has(taskId)) {
+      await reportTaskWorktreeCleanupResult({
+        requestId,
+        taskId,
+        worktreeBranch: worktreeConfig.worktreeBranch,
+        cleaned: false,
+        error: "Task is still active",
+      }).catch((error) => {
+        logError(`Failed to report task_worktree_cleanup_result for ${taskId}: ${error?.message || error}`);
+      });
+      return;
+    }
+
+    const worktreeRoot = buildTaskWorktreeRoot(
+      worktreeConfig.projectWorkspacePath,
+      worktreeConfig.worktreeId,
+    );
+    const worktreeCwd = resolveTaskWorktreeCwd(worktreeRoot, worktreeConfig.projectRelativePath);
+    const statusCwd = existsSyncFn(worktreeCwd) ? worktreeCwd : worktreeRoot;
+
+    try {
+      if (existsSyncFn(worktreeRoot)) {
+        if (!forceCleanup) {
+          const { stdout } = await runSpawnProcess(
+            "git",
+            ["-C", statusCwd, "status", "--porcelain"],
+            { cwd: statusCwd },
+          );
+          if (stdout.trim()) {
+            throw new Error("Worktree has uncommitted changes");
+          }
+        }
+        await runSpawnProcess(
+          "git",
+          [
+            "-C",
+            worktreeConfig.projectRepoRoot,
+            "worktree",
+            "remove",
+            ...(forceCleanup ? ["--force"] : []),
+            worktreeRoot,
+          ],
+          { cwd: worktreeConfig.projectRepoRoot },
+        );
+      }
+
+      await reportTaskWorktreeCleanupResult({
+        requestId,
+        taskId,
+        worktreeBranch: worktreeConfig.worktreeBranch,
+        removedPath: worktreeRoot,
+        cleaned: true,
+      });
+    } catch (error) {
+      await reportTaskWorktreeCleanupResult({
+        requestId,
+        taskId,
+        worktreeBranch: worktreeConfig.worktreeBranch,
+        removedPath: worktreeRoot,
+        cleaned: false,
+        error: error instanceof Error ? error.message : String(error),
+      }).catch((reportError) => {
+        logError(`Failed to report task_worktree_cleanup_result for ${taskId}: ${reportError?.message || reportError}`);
+      });
+    }
+  }
+
   async function handleTerminalAttach(payload) {
     const taskId = payload?.task_id ? String(payload.task_id) : "";
     if (!taskId) return;
@@ -2610,6 +3191,23 @@ export function startDaemon(config = {}, deps = {}) {
         rejectCreatePtyTaskDuringShutdown(event.payload);
         return;
       }
+      if (event.type === "cleanup_task_worktree") {
+        const requestId = event?.payload?.request_id ? String(event.payload.request_id) : "";
+        const taskId = event?.payload?.task_id ? String(event.payload.task_id) : "";
+        sendAgentCommandAck({
+          requestId,
+          taskId,
+          eventType: "cleanup_task_worktree",
+          accepted: false,
+        }).catch(() => {});
+        void reportTaskWorktreeCleanupResult({
+          requestId,
+          taskId,
+          cleaned: false,
+          error: "daemon shutting down",
+        });
+        return;
+      }
     }
 
     if (event.type === "create_task") {
@@ -2626,6 +3224,10 @@ export function startDaemon(config = {}, deps = {}) {
       void handleCreatePtyTask(event.payload);
       return;
     }
+    if (event.type === "cleanup_task_worktree") {
+      void handleCleanupTaskWorktree(event.payload);
+      return;
+    }
     if (event.type === "stop_task") {
       handleStopTask(event.payload);
       return;
@@ -2652,6 +3254,10 @@ export function startDaemon(config = {}, deps = {}) {
     }
     if (event.type === "collect_logs") {
       void handleCollectLogs(event.payload);
+      return;
+    }
+    if (event.type === "validate_project_path") {
+      void handleValidateProjectPath(event.payload);
     }
   }
 
@@ -2724,6 +3330,96 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
+  async function handleValidateProjectPath(payload) {
+    const requestId = payload?.request_id ? String(payload.request_id).trim() : "";
+    const rawWorkspacePath = payload?.workspace_path ? String(payload.workspace_path).trim() : "";
+    const validatedAt = new Date().toISOString();
+
+    if (!requestId || !rawWorkspacePath) {
+      logError(`Invalid validate_project_path payload: ${JSON.stringify(payload)}`);
+      return;
+    }
+
+    let result = {
+      workspacePath: null,
+      repoRoot: null,
+      worktreeBranch: null,
+      lastCommit: null,
+      fileCount: null,
+      error: null,
+      errorCode: null,
+      validatedAt,
+    };
+
+    try {
+      const resolvedPath = path.resolve(rawWorkspacePath);
+      if (!existsSyncFn(resolvedPath)) {
+        result = {
+          ...result,
+          error: `Workspace path does not exist on daemon ${AGENT_NAME}: ${rawWorkspacePath}`,
+          errorCode: "workspace_not_found",
+        };
+      } else if (!statSyncFn(resolvedPath).isDirectory()) {
+        result = {
+          ...result,
+          error: `Workspace path is not a directory on daemon ${AGENT_NAME}: ${rawWorkspacePath}`,
+          errorCode: "workspace_not_directory",
+        };
+      } else {
+        const snapshot = await Promise.resolve(resolveProjectSnapshotFn(resolvedPath));
+        result = {
+          ...result,
+          workspacePath:
+            typeof snapshot?.projectRoot === "string" && snapshot.projectRoot.trim()
+              ? snapshot.projectRoot.trim()
+              : resolvedPath,
+          repoRoot:
+            typeof snapshot?.repoRoot === "string" && snapshot.repoRoot.trim()
+              ? snapshot.repoRoot.trim()
+              : null,
+          worktreeBranch:
+            typeof snapshot?.worktreeBranch === "string" && snapshot.worktreeBranch.trim()
+              ? snapshot.worktreeBranch.trim()
+              : null,
+          lastCommit:
+            typeof snapshot?.lastCommit === "string" && snapshot.lastCommit.trim()
+              ? snapshot.lastCommit.trim()
+              : null,
+          fileCount:
+            typeof snapshot?.fileCount === "number" && Number.isInteger(snapshot.fileCount)
+              ? snapshot.fileCount
+              : null,
+        };
+      }
+    } catch (error) {
+      result = {
+        ...result,
+        error: `Failed to validate workspace path on daemon ${AGENT_NAME}: ${error?.message || error}`,
+        errorCode: "workspace_validation_failed",
+      };
+    }
+
+    try {
+      await client.sendJson({
+        type: "project_path_validated",
+        payload: {
+          request_id: requestId,
+          daemon_host: AGENT_NAME,
+          workspace_path: result.workspacePath,
+          repo_root: result.repoRoot,
+          worktree_branch: result.worktreeBranch,
+          last_commit: result.lastCommit,
+          file_count: result.fileCount,
+          error: result.error,
+          error_code: result.errorCode,
+          validated_at: result.validatedAt,
+        },
+      });
+    } catch (error) {
+      logError(`Failed to report project_path_validated for ${rawWorkspacePath}: ${error?.message || error}`);
+    }
+  }
+
   function handleStopTask(payload) {
     const taskId = payload?.task_id;
     if (!taskId) return;
@@ -2852,6 +3548,20 @@ export function startDaemon(config = {}, deps = {}) {
         return null;
       }
       const project = await response.json();
+      const daemonHost =
+        (typeof project.daemon_host === "string" && project.daemon_host.trim()) ||
+        (typeof project.daemonHost === "string" && project.daemonHost.trim()) ||
+        "";
+      const workspacePath =
+        (typeof project.workspace_path === "string" && project.workspace_path.trim()) ||
+        (typeof project.workspacePath === "string" && project.workspacePath.trim()) ||
+        "";
+      if (workspacePath) {
+        if (daemonHost && daemonHost !== AGENT_NAME) {
+          return null;
+        }
+        return workspacePath;
+      }
       if (!project.metadata) {
         return null;
       }
@@ -2974,8 +3684,10 @@ export function startDaemon(config = {}, deps = {}) {
   }
 
   async function resolveRestartCwd({
+    taskId,
     projectId,
     preferredCwd = "",
+    launchConfig = null,
     backendType,
     sessionId,
     sourceSessionFilePath = "",
@@ -2985,6 +3697,15 @@ export function startDaemon(config = {}, deps = {}) {
       return normalizedPreferredCwd;
     }
 
+    const worktreeCwd = await ensureTaskWorktree({
+      taskId,
+      projectId,
+      launchConfig,
+    });
+    if (worktreeCwd) {
+      return worktreeCwd;
+    }
+
     const boundPath = await getProjectLocalPath(projectId);
     if (boundPath) {
       return boundPath;
@@ -2994,8 +3715,13 @@ export function startDaemon(config = {}, deps = {}) {
     const normalizedSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
     if (normalizedSessionId && normalizedBackend && normalizedBackend !== "opencode") {
       try {
+        const configuredBackend = await resolveConfiguredRuntimeBackend(normalizedBackend, ALLOW_CLI_LIST, {
+          configFilePath: config.CONFIG_FILE,
+        });
+        const resumeBackend = configuredBackend?.runtimeBackend ||
+          await normalizeRuntimeBackendAlias(normalizedBackend, { configFilePath: config.CONFIG_FILE });
         const resumeContext = await (deps.resolveResumeContext || resolveResumeContext)(
-          normalizedBackend,
+          resumeBackend,
           normalizedSessionId,
           {
             cwd: process.cwd(),
@@ -3036,6 +3762,7 @@ export function startDaemon(config = {}, deps = {}) {
       request_id: requestIdRaw,
     } =
       payload || {};
+    const launchConfig = normalizeLaunchConfig(payload?.launch_config);
     const requestId = requestIdRaw ? String(requestIdRaw) : "";
 
     if (!taskId || !projectId) {
@@ -3082,11 +3809,22 @@ export function startDaemon(config = {}, deps = {}) {
     pendingTaskStarts.add(taskId);
     let acceptedAckSent = false;
     try {
-      const effectiveBackend = await normalizeRuntimeBackendAlias(backendType || SUPPORTED_BACKENDS[0], {
+      const requestedBackend = normalizeRuntimeBackendName(backendType || SUPPORTED_BACKENDS[0]);
+      const configuredBackend = await resolveConfiguredRuntimeBackend(requestedBackend, ALLOW_CLI_LIST, {
         configFilePath: config.CONFIG_FILE,
       });
-      if (!(await isRuntimeSupportedBackend(effectiveBackend, { configFilePath: config.CONFIG_FILE }))) {
-        logError(`Unsupported backend: ${effectiveBackend}. Supported: ${SUPPORTED_BACKENDS.join(", ")}`);
+      const effectiveBackend = configuredBackend?.runtimeBackend ||
+        await normalizeRuntimeBackendAlias(requestedBackend, { configFilePath: config.CONFIG_FILE });
+      const hasConfiguredEntry = Boolean(configuredBackend?.commandLine);
+      const selectedBackend = configuredBackend?.commandLine
+        ? configuredBackend.requestedBackend
+        : effectiveBackend;
+      const isAdvertisedBackend = SUPPORTED_BACKENDS.includes(selectedBackend);
+      const isAllowedExternalBackend =
+        !isBuiltInRuntimeBackend(effectiveBackend) &&
+        await isRuntimeSupportedBackend(effectiveBackend, { configFilePath: config.CONFIG_FILE });
+      if (!isAdvertisedBackend || (!hasConfiguredEntry && !isAllowedExternalBackend)) {
+        logError(`Unsupported backend: ${selectedBackend}. Supported: ${SUPPORTED_BACKENDS.join(", ")}`);
         sendAgentCommandAck({
           requestId,
           taskId,
@@ -3100,7 +3838,7 @@ export function startDaemon(config = {}, deps = {}) {
               task_id: taskId,
               project_id: projectId,
               status: "KILLED",
-              summary: `Unsupported backend: ${effectiveBackend}`,
+              summary: `Unsupported backend: ${selectedBackend}`,
             },
           })
           .catch(() => {});
@@ -3117,10 +3855,10 @@ export function startDaemon(config = {}, deps = {}) {
       });
       acceptedAckSent = true;
 
-      const cliCommand = ALLOW_CLI_LIST[effectiveBackend] || "";
+      const cliCommand = ALLOW_CLI_LIST[selectedBackend] || ALLOW_CLI_LIST[effectiveBackend] || "";
 
       log("");
-      log(`Creating task ${taskId} for project ${projectId} (${effectiveBackend})`);
+      log(`Creating task ${taskId} for project ${projectId} (${selectedBackend})`);
       log(`CLI command: ${formatBackendLaunchCommand(cliCommand)}`);
       client
         .sendJson({
@@ -3145,9 +3883,18 @@ export function startDaemon(config = {}, deps = {}) {
       let logPath;
       let runTimestampPart = null;
 
-      if (boundPath) {
-        taskDir = boundPath;
-        log(`Using project bound path: ${taskDir}`);
+      const resolvedTaskWorkspace =
+        (await ensureTaskWorktree({
+          taskId,
+          projectId,
+          launchConfig,
+        })) ||
+        normalizeOptionalString(launchConfig.cwd) ||
+        boundPath;
+
+      if (resolvedTaskWorkspace) {
+        taskDir = resolvedTaskWorkspace;
+        log(`Using task workspace: ${taskDir}`);
         logPath = path.join(taskDir, "conductor.log");
       } else {
         const now = new Date();
@@ -3160,8 +3907,8 @@ export function startDaemon(config = {}, deps = {}) {
       }
 
       const args = [];
-      if (effectiveBackend) {
-        args.push("--backend", effectiveBackend);
+      if (selectedBackend) {
+        args.push("--backend", selectedBackend);
       }
       if (initialContent) {
         args.push("--prefill", initialContent);
@@ -3351,6 +4098,7 @@ export function startDaemon(config = {}, deps = {}) {
     const normalizedTargetTaskId = targetTaskId ? String(targetTaskId) : "";
     const normalizedProjectId = projectId ? String(projectId) : "";
     const normalizedSourceSessionId = sourceSessionId ? String(sourceSessionId).trim() : "";
+    const targetLaunchConfig = normalizeLaunchConfig(payload?.target_launch_config);
 
     if (
       !normalizedMode ||
@@ -3405,16 +4153,27 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
-    const effectiveBackend = await normalizeRuntimeBackendAlias(targetBackendType || sourceBackendType || SUPPORTED_BACKENDS[0], {
+    const requestedBackend = normalizeRuntimeBackendName(targetBackendType || sourceBackendType || SUPPORTED_BACKENDS[0]);
+    const configuredBackend = await resolveConfiguredRuntimeBackend(requestedBackend, ALLOW_CLI_LIST, {
       configFilePath: config.CONFIG_FILE,
     });
-    if (!(await isRuntimeSupportedBackend(effectiveBackend, { configFilePath: config.CONFIG_FILE }))) {
+    const effectiveBackend = configuredBackend?.runtimeBackend ||
+      await normalizeRuntimeBackendAlias(requestedBackend, { configFilePath: config.CONFIG_FILE });
+    const hasConfiguredEntry = Boolean(configuredBackend?.commandLine);
+    const selectedBackend = configuredBackend?.commandLine
+      ? configuredBackend.requestedBackend
+      : effectiveBackend;
+    const isAdvertisedBackend = SUPPORTED_BACKENDS.includes(selectedBackend);
+    const isAllowedExternalBackend =
+      !isBuiltInRuntimeBackend(effectiveBackend) &&
+      await isRuntimeSupportedBackend(effectiveBackend, { configFilePath: config.CONFIG_FILE });
+    if (!isAdvertisedBackend || (!hasConfiguredEntry && !isAllowedExternalBackend)) {
       reportRestartFailure({
         taskId: normalizedTargetTaskId,
         projectId: normalizedProjectId,
         requestId,
         mode: normalizedMode,
-        error: new Error(`Unsupported backend: ${effectiveBackend}`),
+        error: new Error(`Unsupported backend: ${selectedBackend}`),
       });
       return;
     }
@@ -3430,7 +4189,16 @@ export function startDaemon(config = {}, deps = {}) {
         });
         return;
       }
-      if (effectiveBackend !== sourceBackendType) {
+      const normalizedSourceBackend = normalizeRuntimeBackendName(sourceBackendType);
+      const configuredSourceBackend = await resolveConfiguredRuntimeBackend(normalizedSourceBackend, ALLOW_CLI_LIST, {
+        configFilePath: config.CONFIG_FILE,
+      });
+      const sourceRuntimeBackend = configuredSourceBackend?.runtimeBackend ||
+        await normalizeRuntimeBackendAlias(normalizedSourceBackend, { configFilePath: config.CONFIG_FILE });
+      const sourceSelectedBackend = configuredSourceBackend?.commandLine
+        ? configuredSourceBackend.requestedBackend
+        : sourceRuntimeBackend;
+      if (selectedBackend !== sourceSelectedBackend) {
         reportRestartFailure({
           taskId: normalizedTargetTaskId,
           projectId: normalizedProjectId,
@@ -3451,23 +4219,32 @@ export function startDaemon(config = {}, deps = {}) {
       logError(`Failed to report agent_command_ack(restart_task) for ${normalizedTargetTaskId}: ${err?.message || err}`);
     });
 
+    const normalizedSourceBackend = normalizeRuntimeBackendName(sourceBackendType);
+    const configuredSourceBackend = await resolveConfiguredRuntimeBackend(normalizedSourceBackend, ALLOW_CLI_LIST, {
+      configFilePath: config.CONFIG_FILE,
+    });
+    const sourceRuntimeBackend = configuredSourceBackend?.runtimeBackend ||
+      await normalizeRuntimeBackendAlias(normalizedSourceBackend, { configFilePath: config.CONFIG_FILE });
+
     let resolvedResumeSessionId = normalizedSourceSessionId;
     let resolvedResumeCwd = "";
     try {
       if (normalizedMode === "bridge_to_new_task" || normalizedMode === "fork_to_new_task") {
         const sourceResumeCwd = await resolveRestartCwd({
+          taskId: normalizedTargetTaskId,
           projectId: normalizedProjectId,
           backendType: sourceBackendType,
+          launchConfig: targetLaunchConfig,
           sessionId: normalizedSourceSessionId,
           sourceSessionFilePath: sourceSessionFilePath ? String(sourceSessionFilePath) : "",
         });
         const bridgeSession = await getBridgeSessionHelper();
         const bridgeResult = await bridgeSession({
-          sourceTool: sourceBackendType,
+          sourceTool: sourceRuntimeBackend,
           sourceSessionId: normalizedSourceSessionId,
           sourceSessionPath: sourceSessionFilePath ? String(sourceSessionFilePath) : undefined,
           sourceSessionInfo: {
-            tool: sourceBackendType,
+            tool: sourceRuntimeBackend,
             sessionId: normalizedSourceSessionId,
             path: sourceSessionFilePath ? String(sourceSessionFilePath) : undefined,
             cwd: sourceResumeCwd || undefined,
@@ -3477,15 +4254,19 @@ export function startDaemon(config = {}, deps = {}) {
         });
         resolvedResumeSessionId = bridgeResult.sessionId;
         resolvedResumeCwd = await resolveRestartCwd({
+          taskId: normalizedTargetTaskId,
           projectId: normalizedProjectId,
           preferredCwd: bridgeResult.cwd,
+          launchConfig: targetLaunchConfig,
           backendType: effectiveBackend,
           sessionId: bridgeResult.sessionId,
           sourceSessionFilePath: sourceSessionFilePath ? String(sourceSessionFilePath) : "",
         });
       } else if (normalizedMode === "resume_inplace") {
         resolvedResumeCwd = await resolveRestartCwd({
+          taskId: normalizedTargetTaskId,
           projectId: normalizedProjectId,
+          launchConfig: targetLaunchConfig,
           backendType: effectiveBackend,
           sessionId: normalizedSourceSessionId,
           sourceSessionFilePath: sourceSessionFilePath ? String(sourceSessionFilePath) : "",
@@ -3517,11 +4298,11 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
-    const cliCommand = ALLOW_CLI_LIST[effectiveBackend] || "";
+    const cliCommand = ALLOW_CLI_LIST[selectedBackend] || ALLOW_CLI_LIST[effectiveBackend] || "";
 
     log("");
     log(
-      `Restarting task ${normalizedTargetTaskId} from ${normalizedSourceTaskId} (${normalizedMode} -> ${effectiveBackend})`,
+      `Restarting task ${normalizedTargetTaskId} from ${normalizedSourceTaskId} (${normalizedMode} -> ${selectedBackend})`,
     );
     log(`CLI command: ${formatBackendLaunchCommand(cliCommand)}`);
 
@@ -3570,8 +4351,8 @@ export function startDaemon(config = {}, deps = {}) {
     }
 
     const args = [];
-    if (effectiveBackend) {
-      args.push("--backend", effectiveBackend);
+    if (selectedBackend) {
+      args.push("--backend", selectedBackend);
     }
     args.push("--resume", resolvedResumeSessionId);
     args.push("--");