@love-moon/conductor-cli 0.2.34 → 0.2.36

package/bin/conductor-fire.js

@@ -82,24 +82,149 @@ export function shouldRunReconnectRecovery({
 }
 
 // Load allow_cli_list from config file (no defaults - must be configured)
-async function loadAllowCliList(configFilePath) {
+function loadFireConfigYaml(configFilePath) {
   const home = os.homedir();
   const configPath = configFilePath || process.env.CONDUCTOR_CONFIG || path.join(home, ".conductor", "config.yaml");
-  let parsed = null;
   try {
     if (fs.existsSync(configPath)) {
       const content = fs.readFileSync(configPath, "utf8");
-      parsed = yaml.load(content);
+      const parsed = yaml.load(content);
+      if (parsed && typeof parsed === "object") {
+        return { configPath, parsed };
+      }
     }
   } catch (error) {
     // ignore error
   }
-  if (parsed && typeof parsed === "object" && parsed.allow_cli_list) {
+  return { configPath, parsed: null };
+}
+
+// Load allow_cli_list from config file (no defaults - must be configured)
+async function loadAllowCliList(configFilePath) {
+  const { configPath, parsed } = loadFireConfigYaml(configFilePath);
+  if (parsed && parsed.allow_cli_list) {
     return await filterRuntimeSupportedAllowCliList(parsed.allow_cli_list, { configFilePath: configPath });
   }
   return {};
 }
 
+function loadPrePromptMap(configFilePath) {
+  const { parsed } = loadFireConfigYaml(configFilePath);
+  if (parsed && parsed.pre_prompt && typeof parsed.pre_prompt === "object") {
+    return parsed.pre_prompt;
+  }
+  return {};
+}
+
+export function expandEnvVars(text, env = process.env) {
+  if (typeof text !== "string" || !text) {
+    return "";
+  }
+  return text.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (match, braced, bare) => {
+    const key = braced || bare;
+    return Object.prototype.hasOwnProperty.call(env, key) && env[key] != null ? String(env[key]) : match;
+  });
+}
+
+export function resolveConfiguredPrePrompt({ configFilePath, backend, sessionBackend, env = process.env } = {}) {
+  const prePromptMap = loadPrePromptMap(configFilePath);
+  const candidates = [backend, sessionBackend]
+    .map((value) => (typeof value === "string" ? value.trim() : ""))
+    .filter(Boolean);
+  for (const candidate of candidates) {
+    if (typeof prePromptMap[candidate] === "string") {
+      const resolved = expandEnvVars(prePromptMap[candidate], env);
+      return resolved || undefined;
+    }
+  }
+  return undefined;
+}
+
+function parseCommandParts(commandLine) {
+  const input = String(commandLine || "").trim();
+  if (!input) {
+    return [];
+  }
+
+  const parts = [];
+  let current = "";
+  let quote = "";
+  let escaping = false;
+  let tokenStarted = false;
+
+  for (const char of input) {
+    if (escaping) {
+      current += char;
+      tokenStarted = true;
+      escaping = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      escaping = true;
+      tokenStarted = true;
+      continue;
+    }
+
+    if (quote) {
+      if (char === quote) {
+        quote = "";
+      } else {
+        current += char;
+      }
+      tokenStarted = true;
+      continue;
+    }
+
+    if (char === "'" || char === "\"") {
+      quote = char;
+      tokenStarted = true;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      if (tokenStarted) {
+        parts.push(current);
+        current = "";
+        tokenStarted = false;
+      }
+      continue;
+    }
+
+    current += char;
+    tokenStarted = true;
+  }
+
+  if (tokenStarted) {
+    parts.push(current);
+  }
+
+  return parts;
+}
+
+function extractModelOptionFromCommandLine(commandLine) {
+  const parts = parseCommandParts(commandLine);
+  for (let index = 0; index < parts.length; index += 1) {
+    const token = String(parts[index] || "").trim();
+    if (!token) {
+      continue;
+    }
+    if (token === "--model") {
+      const next = String(parts[index + 1] || "").trim();
+      return next || "";
+    }
+    if (token.startsWith("--model=")) {
+      return token.slice("--model=".length).trim();
+    }
+  }
+  return "";
+}
+
+function extractAiSessionOptionsFromCommandLine(commandLine) {
+  const model = extractModelOptionFromCommandLine(commandLine);
+  return model ? { model } : {};
+}
+
 export function resolveAiSessionCommandLine(backend, allowCliList, env = process.env, sessionBackend = backend) {
   const normalizedBackend = normalizeRuntimeBackendName(backend);
   const normalizedSessionBackend = normalizeRuntimeBackendName(sessionBackend);
@@ -142,6 +267,12 @@ export function resolveAiSessionCommandLine(backend, allowCliList, env = process
   return resolvedCommand;
 }
 
+export function resolveAiSessionOptions(backend, allowCliList, env = process.env, sessionBackend = backend) {
+  return extractAiSessionOptionsFromCommandLine(
+    resolveAiSessionCommandLine(backend, allowCliList, env, sessionBackend),
+  );
+}
+
 const DEFAULT_POLL_INTERVAL_MS = parseInt(
   process.env.CONDUCTOR_CLI_POLL_INTERVAL_MS || process.env.CCODEX_POLL_INTERVAL_MS || "2000",
   10,
@@ -595,6 +726,7 @@ async function main() {
       envTaskTitle: process.env.CONDUCTOR_TASK_TITLE,
       runtimeProjectPath,
     });
+    const resolvedDaemonName = resolveDaemonHost(configuredDaemonName);
 
     conductor = await ConductorClient.connect({
       projectPath: runtimeProjectPath,
@@ -623,7 +755,7 @@ async function main() {
       providedTaskId: process.env.CONDUCTOR_TASK_ID,
       requestedTitle: requestedTaskTitle,
       backend: cliArgs.backend,
-      daemonName: configuredDaemonName,
+      daemonName: resolvedDaemonName,
       projectPath: runtimeProjectPath,
     });
     injectResolvedTaskId(taskContext.taskId);
@@ -647,6 +779,7 @@ async function main() {
           project_id: process.env.CONDUCTOR_PROJECT_ID,
           project_path: runtimeProjectPath,
           backend_type: cliArgs.backend,
+          daemon_name: resolvedDaemonName,
         });
       } catch {
         // best effort only
@@ -661,14 +794,24 @@ async function main() {
       process.env,
       cliArgs.sessionBackend,
     );
+    const resolvedPrePrompt = resolveConfiguredPrePrompt({
+      configFilePath: cliArgs.configFile,
+      backend: cliArgs.backend,
+      sessionBackend: cliArgs.sessionBackend,
+      env: process.env,
+    });
 
     backendSession = createAiSession(cliArgs.sessionBackend || cliArgs.backend, {
       initialImages: cliArgs.initialImages,
       cwd: runtimeProjectPath,
       resumeSessionId: resolvedResumeSessionId,
       configFile: cliArgs.configFile,
+      ...(cliArgs.sessionOptions || {}),
       ...(sessionCommandLine ? { commandLine: sessionCommandLine } : {}),
       logger: { log },
+      ...(resolvedPrePrompt ? { prePrompt: resolvedPrePrompt } : {}),
+      sessionStoreKey: taskContext.taskId ? `task-${taskContext.taskId}` : undefined,
+      resumePersistedSession: Boolean(!resolvedResumeSessionId && taskContext.taskId),
     });
 
     log(`Using backend: ${cliArgs.backend}`);
@@ -694,7 +837,7 @@ async function main() {
       cliArgs: cliArgs.rawBackendArgs,
       backendName: cliArgs.backend,
       resumeSessionId: resolvedResumeSessionId,
-      daemonName: configuredDaemonName,
+      daemonName: resolvedDaemonName,
     });
     reconnectRunner = runner;
     if (pendingRemoteStopEvent) {
@@ -1038,6 +1181,12 @@ Environment:
   const sessionBackend =
     configuredBackend?.runtimeBackend ||
     (backend ? await normalizeRuntimeBackendAlias(backend, { configFilePath: configFileFromArgs }) : "");
+  const sessionOptions = resolveAiSessionOptions(
+    backend,
+    allowCliList,
+    process.env,
+    sessionBackend || backend,
+  );
   const shouldRequireBackend =
     !Boolean(conductorArgs.listBackends) &&
     !listBackendsWithoutSeparator &&
@@ -1086,6 +1235,7 @@ Environment:
     hasExplicitTaskTitle: typeof conductorArgs.title === "string" && Boolean(conductorArgs.title.trim()),
     configFile: conductorArgs.configFile,
     sessionBackend,
+    sessionOptions,
     resumeSessionId,
     showVersion: Boolean(conductorArgs.version) || versionWithoutSeparator,
     listBackends: Boolean(conductorArgs.listBackends) || listBackendsWithoutSeparator,
@@ -1288,7 +1438,7 @@ export async function resolveProjectId(conductor, explicit, opts = {}) {
   return resolveDefaultProjectId(conductor);
 }
 
-function resolveDaemonHost(daemonName) {
+export function resolveDaemonHost(daemonName) {
   if (typeof daemonName === "string" && daemonName.trim()) {
     return daemonName.trim();
   }
@@ -1708,6 +1858,7 @@ export class BridgeRunner {
         session_file_path:
           typeof sessionFilePath === "string" && sessionFilePath.trim() ? sessionFilePath.trim() : undefined,
         backend_type: this.backendName,
+        daemon_name: this.daemonName,
       });
       this.boundSessionId = normalizedSessionId;
       return true;
@@ -2077,6 +2228,11 @@ export class BridgeRunner {
       session_file_path: payload.session_file_path || runtimeContext?.session_file_path,
       token_usage_percent: runtimeContext?.token_usage_percent,
       context_usage_percent: runtimeContext?.context_usage_percent,
+      tool_name: payload.tool_name ? String(payload.tool_name) : undefined,
+      tool_id: payload.tool_id ? String(payload.tool_id) : undefined,
+      item_id: payload.item_id ? String(payload.item_id) : undefined,
+      turn_started_at: payload.turn_started_at ? String(payload.turn_started_at) : undefined,
+      event_count: typeof payload.event_count === "number" ? payload.event_count : undefined,
     };
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.34",
-  "gitCommitId": "c3c936c",
+  "version": "0.2.36",
+  "gitCommitId": "54d9de4",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -18,8 +18,9 @@
   },
   "dependencies": {
     "@love-moon/ai-bridge": "0.1.4",
-    "@love-moon/ai-sdk": "0.2.34",
-    "@love-moon/conductor-sdk": "0.2.34",
+    "@love-moon/ai-manager": "0.2.36",
+    "@love-moon/ai-sdk": "0.2.36",
+    "@love-moon/conductor-sdk": "0.2.36",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
     "dotenv": "^16.4.5",
@@ -39,6 +40,7 @@
     ],
     "overrides": {
       "@love-moon/ai-sdk": "file:../modules/ai-sdk",
+      "@love-moon/ai-manager": "file:../modules/ai-manager",
       "@love-moon/conductor-sdk": "file:../modules/conductor-sdk"
     }
   }

package/src/ai-manager-handlers.js

@@ -0,0 +1,158 @@
+// Daemon-side glue between the realtime WebSocket and the @love-moon/ai-manager module.
+// The web backend sends `ai_manager_request`; we dispatch by `action`, run it, and
+// reply with `ai_manager_response` carrying the same `request_id`.
+
+import { AiManager } from "@love-moon/ai-manager";
+
+const VALID_ACTIONS = new Set(["status", "quota", "list_accounts", "switch_account"]);
+
+/**
+ * @param {object} opts
+ * @param {string} [opts.configPath] Path to ~/.conductor/config.yaml. Defaults to ai-manager's default.
+ */
+export function createAiManagerHandlers(opts = {}) {
+  const manager = new AiManager(opts.configPath ? { configPath: opts.configPath } : undefined);
+
+  async function status() {
+    // Probe install first; only check network for tools that are actually
+    // present so we don't pay an outbound HTTP timeout for a CLI the user
+    // never installed.
+    const [install, current] = await Promise.all([
+      manager.checkInstallAll(),
+      manager.getCurrentCodexAccount().catch(() => null),
+    ]);
+    const network = {};
+    const tools = ["codex", "claude", "kimi"];
+    await Promise.all(
+      tools.map(async (tool) => {
+        if (install[tool]?.installed) {
+          network[tool] = await manager.checkNetwork(tool);
+        } else {
+          network[tool] = {
+            reachable: false,
+            endpoint: "",
+            error: "not installed",
+          };
+        }
+      }),
+    );
+    return { install, network, currentCodexAccount: current };
+  }
+
+  async function quota(args = {}) {
+    const tools = pickToolFilter(args);
+    const out = {};
+    if (tools.has("codex")) {
+      try {
+        out.codex = await manager.getCodexQuota({
+          forceRefresh: Boolean(args.forceRefresh),
+        });
+      } catch (err) {
+        out.codex = { tool: "codex", error: errMsg(err), source: "unknown" };
+      }
+    }
+    if (tools.has("claude")) {
+      try {
+        out.claude = await manager.getClaudeQuota({
+          forceRefresh: Boolean(args.forceRefresh),
+        });
+      } catch (err) {
+        out.claude = { tool: "claude", error: errMsg(err), source: "unknown" };
+      }
+    }
+    if (tools.has("kimi")) {
+      try {
+        out.kimi = await manager.getKimiQuota({
+          forceRefresh: Boolean(args.forceRefresh),
+        });
+      } catch (err) {
+        out.kimi = { tool: "kimi", error: errMsg(err), source: "unknown" };
+      }
+    }
+    return out;
+  }
+
+  async function listAccounts() {
+    return { accounts: await manager.listCodexAccounts() };
+  }
+
+  async function switchAccount(args = {}) {
+    if (!args.name || typeof args.name !== "string") {
+      throw new Error("switch_account requires a `name` string");
+    }
+    return await manager.switchCodexAccount(args.name);
+  }
+
+  /**
+   * Run a single action and return a `result` object, never throwing.
+   * @param {{action:string,args?:object}} payload
+   */
+  async function dispatch(payload) {
+    const action = payload?.action;
+    if (!VALID_ACTIONS.has(action)) {
+      return { error: `unknown action: ${action}` };
+    }
+    try {
+      switch (action) {
+        case "status":
+          return { result: await status() };
+        case "quota":
+          return { result: await quota(payload?.args ?? {}) };
+        case "list_accounts":
+          return { result: await listAccounts() };
+        case "switch_account":
+          return { result: await switchAccount(payload?.args ?? {}) };
+        default:
+          return { error: `unhandled action: ${action}` };
+      }
+    } catch (err) {
+      return { error: errMsg(err) };
+    }
+  }
+
+  return { dispatch, manager };
+}
+
+/**
+ * Wire a handler against an event payload from the web backend, sending the
+ * response back through `client.sendJson` once the action completes.
+ *
+ * @param {object} client - conductor websocket client (must have sendJson)
+ * @param {ReturnType<typeof createAiManagerHandlers>} handlers
+ * @param {object} payload - event.payload with shape { request_id, action, args }
+ */
+export async function handleAiManagerRequest(client, handlers, payload) {
+  const requestId = payload?.request_id ? String(payload.request_id) : "";
+  const action = payload?.action ? String(payload.action) : "";
+  if (!requestId) {
+    // Without a request_id we cannot route the response anywhere; drop and log upstream.
+    return { error: "missing request_id" };
+  }
+
+  const out = await handlers.dispatch({ action, args: payload?.args });
+  await client
+    .sendJson({
+      type: "ai_manager_response",
+      payload: {
+        request_id: requestId,
+        action,
+        result: out.result,
+        error: out.error,
+      },
+    })
+    .catch(() => {});
+  return out;
+}
+
+function pickToolFilter(args) {
+  const t = args?.tool;
+  if (t === "codex") return new Set(["codex"]);
+  if (t === "claude") return new Set(["claude"]);
+  if (t === "kimi") return new Set(["kimi"]);
+  return new Set(["codex", "claude", "kimi"]);
+}
+
+function errMsg(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}

package/src/daemon.js

@@ -16,6 +16,7 @@ import {
   ProjectContext,
 } from "@love-moon/conductor-sdk";
 import { DaemonLogCollector } from "./log-collector.js";
+import { createAiManagerHandlers, handleAiManagerRequest } from "./ai-manager-handlers.js";
 import { resolveResumeContext } from "./fire/resume.js";
 import {
   filterRuntimeSupportedAllowCliList,
@@ -354,6 +355,35 @@ export function ensureNodePtySpawnHelperExecutable(deps = {}) {
   return { helperPath, updated: true };
 }
 
+export function isSafeTaskWorktreeRoot(projectWorkspacePath, worktreeRoot) {
+  const normalizedWorkspacePath =
+    typeof projectWorkspacePath === "string" ? projectWorkspacePath.trim() : "";
+  const normalizedWorktreeRoot =
+    typeof worktreeRoot === "string" ? worktreeRoot.trim() : "";
+  if (!normalizedWorkspacePath || !normalizedWorktreeRoot) {
+    return false;
+  }
+
+  const resolvedWorkspacePath = path.resolve(normalizedWorkspacePath);
+  const resolvedWorktreeRoot = path.resolve(normalizedWorktreeRoot);
+  if (resolvedWorkspacePath === resolvedWorktreeRoot) {
+    return false;
+  }
+
+  const expectedParent = path.resolve(resolvedWorkspacePath, ".conductor", "worktrees");
+  const relativeToExpectedParent = path.relative(expectedParent, resolvedWorktreeRoot);
+  if (
+    !relativeToExpectedParent ||
+    relativeToExpectedParent === "." ||
+    relativeToExpectedParent.startsWith("..") ||
+    path.isAbsolute(relativeToExpectedParent)
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
 function normalizeOptionalString(value) {
   if (typeof value !== "string") {
     return null;
@@ -638,6 +668,7 @@ export function startDaemon(config = {}, deps = {}) {
   const autoUpdateForceLocal = parseBooleanEnv(process.env.CONDUCTOR_AUTO_UPDATE_FORCE_LOCAL);
   const autoUpdateSupportedInstall =
     autoUpdateForceLocal || isManagedInstallPathFn(installedPackageRoot);
+  const skipPidLockCheck = parseBooleanEnv(process.env.CONDUCTOR_TUI_DEBUG);
   const lockHandoffToken =
     normalizeOptionalString(config.LOCK_HANDOFF_TOKEN) ||
     normalizeOptionalString(process.env.CONDUCTOR_LOCK_HANDOFF_TOKEN);
@@ -738,6 +769,30 @@ export function startDaemon(config = {}, deps = {}) {
     return resolvedPath;
   }
 
+  const PROJECT_SETTINGS_TEMPLATE = [
+    "worktree:",
+    "  sync_branch: false",
+    "  symlink: []",
+    "  # Example: symlink paths from the parent workspace into each worktree",
+    "  # symlink:",
+    "  #   - node_modules",
+    "  #   - .env",
+    "",
+  ].join("\n");
+
+  function ensureProjectSettingsTemplate(projectWorkspacePath) {
+    const settingsPath = path.join(projectWorkspacePath, ".conductor", "settings.yaml");
+    if (existsSyncFn(settingsPath)) {
+      return;
+    }
+    try {
+      mkdirSyncFn(path.join(projectWorkspacePath, ".conductor"), { recursive: true });
+      writeFileSyncFn(settingsPath, PROJECT_SETTINGS_TEMPLATE, "utf8");
+    } catch (_error) {
+      // best-effort; do not block project validation if template creation fails
+    }
+  }
+
   function readProjectWorktreeSettings(projectWorkspacePath) {
     const settingsCandidates = [
       path.join(projectWorkspacePath, ".conductor", "settings.yaml"),
@@ -759,6 +814,7 @@ export function startDaemon(config = {}, deps = {}) {
             : {};
         return {
           symlinkPaths: normalizeConfiguredPathList(worktreeSettings.symlink, projectWorkspacePath),
+          syncBranch: worktreeSettings.sync_branch === true || worktreeSettings.syncBranch === true,
           settingsPath,
         };
       } catch (error) {
@@ -768,6 +824,7 @@ export function startDaemon(config = {}, deps = {}) {
 
     return {
       symlinkPaths: [],
+      syncBranch: false,
       settingsPath: null,
     };
   }
@@ -811,9 +868,10 @@ export function startDaemon(config = {}, deps = {}) {
 
   async function runSpawnProcess(command, args, options = {}) {
     let child;
+    const { timeoutMs, ...spawnOptions } = options || {};
     try {
       child = spawnFn(command, args, {
-        ...options,
+        ...spawnOptions,
         stdio: ["ignore", "pipe", "pipe"],
       });
     } catch (error) {
@@ -824,12 +882,17 @@ export function startDaemon(config = {}, deps = {}) {
       let stdout = "";
       let stderr = "";
       let settled = false;
+      let timeoutHandle = null;
 
       const finishResolve = () => {
         if (settled) {
           return;
         }
         settled = true;
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+          timeoutHandle = null;
+        }
         resolve({ stdout, stderr });
       };
 
@@ -838,9 +901,26 @@ export function startDaemon(config = {}, deps = {}) {
           return;
         }
         settled = true;
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+          timeoutHandle = null;
+        }
         reject(error instanceof Error ? error : new Error(String(error)));
       };
 
+      if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
+        timeoutHandle = setTimeout(() => {
+          try {
+            if (child && typeof child.kill === "function") {
+              child.kill("SIGTERM");
+            }
+          } catch {
+            // ignore process kill failures; the timeout error is the useful signal
+          }
+          finishReject(new Error(`${command} ${args.join(" ")} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+      }
+
       if (child.stdout && typeof child.stdout.on === "function") {
         child.stdout.on("data", (chunk) => {
           stdout += String(chunk ?? "");
@@ -888,6 +968,48 @@ export function startDaemon(config = {}, deps = {}) {
     const finalCwd = resolveTaskWorktreeCwd(worktreeRoot, worktreeConfig.projectRelativePath);
     const gitMarkerPath = path.join(worktreeRoot, ".git");
     if (!existsSyncFn(gitMarkerPath)) {
+      const { syncBranch } = readProjectWorktreeSettings(worktreeConfig.projectWorkspacePath);
+      if (syncBranch) {
+        try {
+          const { stdout: remoteStdout } = await runSpawnProcess(
+            "git",
+            ["-C", worktreeConfig.projectRepoRoot, "remote"],
+            { cwd: worktreeConfig.projectRepoRoot, timeoutMs: WORKTREE_SYNC_TIMEOUT_MS },
+          );
+          const hasRemote = remoteStdout.trim().length > 0;
+          if (hasRemote) {
+            await runSpawnProcess(
+              "git",
+              ["-C", worktreeConfig.projectRepoRoot, "fetch"],
+              { cwd: worktreeConfig.projectRepoRoot, timeoutMs: WORKTREE_SYNC_TIMEOUT_MS },
+            );
+            const { stdout: branchStdout } = await runSpawnProcess(
+              "git",
+              ["-C", worktreeConfig.projectRepoRoot, "rev-parse", "--abbrev-ref", "HEAD"],
+              { cwd: worktreeConfig.projectRepoRoot, timeoutMs: WORKTREE_SYNC_TIMEOUT_MS },
+            );
+            const currentBranch = branchStdout.trim();
+            if (currentBranch && currentBranch !== "HEAD") {
+              const { stdout: trackingStdout } = await runSpawnProcess(
+                "git",
+                ["-C", worktreeConfig.projectRepoRoot, "rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`],
+                { cwd: worktreeConfig.projectRepoRoot, timeoutMs: WORKTREE_SYNC_TIMEOUT_MS },
+              ).catch(() => ({ stdout: "" }));
+              const upstream = trackingStdout.trim();
+              if (upstream) {
+                await runSpawnProcess(
+                  "git",
+                  ["-C", worktreeConfig.projectRepoRoot, "merge", "--ff-only", upstream],
+                  { cwd: worktreeConfig.projectRepoRoot, timeoutMs: WORKTREE_SYNC_TIMEOUT_MS },
+                ).catch(() => {});
+              }
+            }
+          }
+        } catch (_syncError) {
+          // sync_branch is best-effort; proceed with worktree creation even if sync fails
+        }
+      }
+
       mkdirSyncFn(path.dirname(worktreeRoot), { recursive: true });
       try {
         await runSpawnProcess(
@@ -962,6 +1084,10 @@ export function startDaemon(config = {}, deps = {}) {
     process.env.CONDUCTOR_DAEMON_FORCE_KILL_WAIT_MS,
     2_000,
   );
+  const WORKTREE_SYNC_TIMEOUT_MS = parsePositiveInt(
+    process.env.CONDUCTOR_WORKTREE_SYNC_TIMEOUT_MS,
+    5_000,
+  );
   const SHUTDOWN_STATUS_REPORT_TIMEOUT_MS = parsePositiveInt(
     process.env.CONDUCTOR_SHUTDOWN_STATUS_REPORT_TIMEOUT_MS,
     1000,
@@ -1073,87 +1199,94 @@ export function startDaemon(config = {}, deps = {}) {
 
   const LOCK_FILE = path.join(WORKSPACE_ROOT, "daemon.pid");
   try {
-    if (existsSyncFn(LOCK_FILE)) {
-      const lockState = readLockState();
-      const pid = lockState?.pid;
-      if (pid) {
-        const handoffMatched = hasMatchingLockHandoff(lockState);
-        try {
-          if (handoffMatched) {
-            log(`Taking over daemon lock from PID ${pid} via handoff`);
-          } else {
-            const alive = isProcessAlive(pid);
-            if (alive) {
-              if (config.FORCE) {
-                log(`Force enabled: stopping existing daemon PID ${pid}`);
-                let alreadyExited = false;
-                try {
-                  killFn(pid, "SIGTERM");
-                } catch (killErr) {
-                  if (killErr?.code === "ESRCH") {
-                    alreadyExited = true;
-                  } else {
-                    logError(`Failed to stop existing daemon PID ${pid}: ${killErr.message}`);
-                    return exitAndReturn(1);
+    if (skipPidLockCheck) {
+      log("CONDUCTOR_TUI_DEBUG enabled; skipping daemon PID lock enforcement");
+    } else {
+      if (existsSyncFn(LOCK_FILE)) {
+        const lockState = readLockState();
+        const pid = lockState?.pid;
+        if (pid) {
+          const handoffMatched = hasMatchingLockHandoff(lockState);
+          try {
+            if (handoffMatched) {
+              log(`Taking over daemon lock from PID ${pid} via handoff`);
+            } else {
+              const alive = isProcessAlive(pid);
+              if (alive) {
+                if (config.FORCE) {
+                  log(`Force enabled: stopping existing daemon PID ${pid}`);
+                  let alreadyExited = false;
+                  try {
+                    killFn(pid, "SIGTERM");
+                  } catch (killErr) {
+                    if (killErr?.code === "ESRCH") {
+                      alreadyExited = true;
+                    } else {
+                      logError(`Failed to stop existing daemon PID ${pid}: ${killErr.message}`);
+                      return exitAndReturn(1);
+                    }
                   }
-                }
-                try {
-                  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);
+                  try {
+                    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);
                     }
-                    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.`);
+                    if (!exited) {
+                      logError(`Existing daemon PID ${pid} is still running after force restart; please stop it manually.`);
+                      return exitAndReturn(1);
+                    }
+                  } catch (checkErr) {
+                    logError(`Failed to verify daemon PID ${pid}: ${checkErr.message}`);
                     return exitAndReturn(1);
                   }
-                } catch (checkErr) {
-                  logError(`Failed to verify daemon PID ${pid}: ${checkErr.message}`);
+                  log("Removing lock file after force stop");
+                  if (existsSyncFn(LOCK_FILE)) {
+                    unlinkSyncFn(LOCK_FILE);
+                  }
+                } else {
+                  logError(`Daemon already running with PID ${pid}`);
                   return exitAndReturn(1);
                 }
-                log("Removing lock file after force stop");
-                if (existsSyncFn(LOCK_FILE)) {
-                  unlinkSyncFn(LOCK_FILE);
-                }
               } else {
-                logError(`Daemon already running with PID ${pid}`);
-                return exitAndReturn(1);
+                log("Removing stale lock file");
+                unlinkSyncFn(LOCK_FILE);
               }
+            }
+          } catch (e) {
+            if (handoffMatched) {
+              log(`Taking over daemon lock from PID ${pid} via handoff`);
             } else {
-              log("Removing stale lock file");
-              unlinkSyncFn(LOCK_FILE);
+              logError(`Daemon already running with PID ${pid} (access denied)`);
+              return exitAndReturn(1);
             }
           }
-        } catch (e) {
-          if (handoffMatched) {
-            log(`Taking over daemon lock from PID ${pid} via handoff`);
-          } else {
-            logError(`Daemon already running with PID ${pid} (access denied)`);
-            return exitAndReturn(1);
-          }
+        } else {
+          log("Removing malformed lock file");
+          unlinkSyncFn(LOCK_FILE);
         }
-      } else {
-        log("Removing malformed lock file");
-        unlinkSyncFn(LOCK_FILE);
       }
+      writeFileSyncFn(LOCK_FILE, process.pid.toString());
     }
-    writeFileSyncFn(LOCK_FILE, process.pid.toString());
   } catch (err) {
     logError("Failed to acquire lock:", err);
     return exitAndReturn(1);
   }
 
   const cleanupLock = () => {
+    if (skipPidLockCheck) {
+      return;
+    }
     try {
       if (existsSyncFn(LOCK_FILE)) {
         const lockState = readLockState();
@@ -1167,6 +1300,9 @@ export function startDaemon(config = {}, deps = {}) {
   };
 
   const writeLockHandoff = ({ handoffToken, handoffFromPid, handoffExpiresAt }) => {
+    if (skipPidLockCheck) {
+      return;
+    }
     writeFileSyncFn(
       LOCK_FILE,
       JSON.stringify({
@@ -1321,6 +1457,8 @@ export function startDaemon(config = {}, deps = {}) {
   if (advertisedCapabilities.length > 0) {
     extraHeaders["x-conductor-capabilities"] = advertisedCapabilities.join(",");
   }
+  const aiManagerHandlers = createAiManagerHandlers({ configPath: config.CONFIG_FILE });
+
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders,
     onConnected: ({ isReconnect, connectedAt } = { isReconnect: false, connectedAt: Date.now() }) => {
@@ -2874,6 +3012,30 @@ export function startDaemon(config = {}, deps = {}) {
       logError(`Failed to report agent_command_ack(cleanup_task_worktree) for ${taskId}: ${error?.message || error}`);
     });
 
+    if (activeTaskProcesses.has(taskId) || activePtySessions.has(taskId)) {
+      if (forceCleanup) {
+        const stopStarted = stopActiveTaskProcess(taskId, {
+          reason: "cleanup_task_worktree",
+          suppressExitStatusReport: true,
+        });
+        if (stopStarted) {
+          const stopped = await waitForTaskToStop(taskId);
+          if (!stopped && (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;
+          }
+        }
+      }
+    }
+
     if (activeTaskProcesses.has(taskId) || activePtySessions.has(taskId)) {
       await reportTaskWorktreeCleanupResult({
         requestId,
@@ -2891,6 +3053,19 @@ export function startDaemon(config = {}, deps = {}) {
       worktreeConfig.projectWorkspacePath,
       worktreeConfig.worktreeId,
     );
+    if (!isSafeTaskWorktreeRoot(worktreeConfig.projectWorkspacePath, worktreeRoot)) {
+      await reportTaskWorktreeCleanupResult({
+        requestId,
+        taskId,
+        worktreeBranch: worktreeConfig.worktreeBranch,
+        removedPath: worktreeRoot,
+        cleaned: false,
+        error: `Refusing to remove unsafe worktree path: ${worktreeRoot}`,
+      }).catch((error) => {
+        logError(`Failed to report task_worktree_cleanup_result for ${taskId}: ${error?.message || error}`);
+      });
+      return;
+    }
     const worktreeCwd = resolveTaskWorktreeCwd(worktreeRoot, worktreeConfig.projectRelativePath);
     const statusCwd = existsSyncFn(worktreeCwd) ? worktreeCwd : worktreeRoot;
 
@@ -3259,6 +3434,11 @@ export function startDaemon(config = {}, deps = {}) {
     if (event.type === "validate_project_path") {
       void handleValidateProjectPath(event.payload);
     }
+    if (event.type === "ai_manager_request") {
+      handleAiManagerRequest(client, aiManagerHandlers, event.payload).catch((error) => {
+        logError(`Unhandled ai_manager_request failure: ${error?.message || error}`);
+      });
+    }
   }
 
   function markWatchdogHealthy(signal, at = Date.now()) {
@@ -3367,12 +3547,14 @@ export function startDaemon(config = {}, deps = {}) {
         };
       } else {
         const snapshot = await Promise.resolve(resolveProjectSnapshotFn(resolvedPath));
+        const effectiveWorkspace =
+          typeof snapshot?.projectRoot === "string" && snapshot.projectRoot.trim()
+            ? snapshot.projectRoot.trim()
+            : resolvedPath;
+        ensureProjectSettingsTemplate(effectiveWorkspace);
         result = {
           ...result,
-          workspacePath:
-            typeof snapshot?.projectRoot === "string" && snapshot.projectRoot.trim()
-              ? snapshot.projectRoot.trim()
-              : resolvedPath,
+          workspacePath: effectiveWorkspace,
           repoRoot:
             typeof snapshot?.repoRoot === "string" && snapshot.repoRoot.trim()
               ? snapshot.repoRoot.trim()
@@ -3420,57 +3602,25 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
-  function handleStopTask(payload) {
-    const taskId = payload?.task_id;
-    if (!taskId) return;
-    const requestId = payload?.request_id ? String(payload.request_id) : "";
-    if (requestId && !markRequestSeen(requestId)) {
-      log(`Duplicate stop_task ignored for ${taskId} (request_id=${requestId})`);
-      sendAgentCommandAck({
-        requestId,
-        taskId,
-        eventType: "stop_task",
-        accepted: true,
-      }).catch(() => {});
-      return;
-    }
-
-    const sendStopAck = (accepted) => {
-      if (!requestId) return;
-      client
-        .sendJson({
-          type: "task_stop_ack",
-          payload: {
-            task_id: taskId,
-            request_id: requestId,
-            accepted: Boolean(accepted),
-          },
-        })
-        .catch((err) => {
-          logError(`Failed to report task_stop_ack for ${taskId}: ${err?.message || err}`);
-        });
-      sendAgentCommandAck({
-        requestId,
-        taskId,
-        eventType: "stop_task",
-        accepted,
-      }).catch((err) => {
-        logError(`Failed to report agent_command_ack(stop_task) for ${taskId}: ${err?.message || err}`);
-      });
-    };
-
+  function stopActiveTaskProcess(
+    taskId,
+    {
+      reason = "",
+      suppressExitStatusReport = false,
+    } = {},
+  ) {
     const processRecord = activeTaskProcesses.get(taskId);
     const ptyRecord = activePtySessions.get(taskId);
     if ((!processRecord || !processRecord.child) && !ptyRecord) {
-      log(`Stop requested for task ${taskId}, but no active process found`);
-      sendStopAck(false);
-      return;
+      return false;
     }
 
-    const reason = payload?.reason ? ` (${payload.reason})` : "";
-    log(`Stopping task ${taskId}${reason}`);
+    if (suppressExitStatusReport) {
+      suppressedExitStatusReports.add(taskId);
+    }
 
-    sendStopAck(true);
+    const reasonSuffix = reason ? ` (${reason})` : "";
+    log(`Stopping task ${taskId}${reasonSuffix}`);
 
     const activeRecord = processRecord || ptyRecord;
     if (activeRecord?.stopForceKillTimer) {
@@ -3528,6 +3678,75 @@ export function startDaemon(config = {}, deps = {}) {
     if (typeof activeRecord.stopForceKillTimer?.unref === "function") {
       activeRecord.stopForceKillTimer.unref();
     }
+
+    return true;
+  }
+
+  async function waitForTaskToStop(taskId, timeoutMs = DAEMON_FORCE_STOP_GRACE_MS) {
+    const deadline = Date.now() + Math.max(timeoutMs, 0);
+
+    while (activeTaskProcesses.has(taskId) || activePtySessions.has(taskId)) {
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) {
+        return false;
+      }
+      await new Promise((resolve) =>
+        setTimeout(resolve, Math.min(DAEMON_FORCE_STOP_POLL_INTERVAL_MS, remainingMs)),
+      );
+    }
+
+    return true;
+  }
+
+  function handleStopTask(payload) {
+    const taskId = payload?.task_id;
+    if (!taskId) return;
+    const requestId = payload?.request_id ? String(payload.request_id) : "";
+    if (requestId && !markRequestSeen(requestId)) {
+      log(`Duplicate stop_task ignored for ${taskId} (request_id=${requestId})`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "stop_task",
+        accepted: true,
+      }).catch(() => {});
+      return;
+    }
+
+    const sendStopAck = (accepted) => {
+      if (!requestId) return;
+      client
+        .sendJson({
+          type: "task_stop_ack",
+          payload: {
+            task_id: taskId,
+            request_id: requestId,
+            accepted: Boolean(accepted),
+          },
+        })
+        .catch((err) => {
+          logError(`Failed to report task_stop_ack for ${taskId}: ${err?.message || err}`);
+        });
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "stop_task",
+        accepted,
+      }).catch((err) => {
+        logError(`Failed to report agent_command_ack(stop_task) for ${taskId}: ${err?.message || err}`);
+      });
+    };
+
+    const processRecord = activeTaskProcesses.get(taskId);
+    const ptyRecord = activePtySessions.get(taskId);
+    if ((!processRecord || !processRecord.child) && !ptyRecord) {
+      log(`Stop requested for task ${taskId}, but no active process found`);
+      sendStopAck(false);
+      return;
+    }
+
+    sendStopAck(true);
+    stopActiveTaskProcess(taskId, { reason: payload?.reason });
   }
 
   async function getProjectLocalPath(projectId) {

package/src/runtime-backends.js

@@ -17,16 +17,29 @@ const LEGACY_RUNTIME_BACKEND_ALIASES = new Set([
 const externalRuntimeCatalogPromises = new Map();
 let externalRuntimeImportNonce = 0;
 
-function normalizeProviderPathEnv(value) {
-  return String(value || "").trim();
+function appendProviderModulePaths(parts, value) {
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      appendProviderModulePaths(parts, entry);
+    }
+    return;
+  }
+  const raw = String(value || "").trim();
+  if (!raw) {
+    return;
+  }
+  for (const item of raw.split(process.platform === "win32" ? ";" : ":")) {
+    const normalized = item.trim();
+    if (normalized) {
+      parts.push(normalized);
+    }
+  }
 }
 
 function listProviderModulePaths(providerPathEnv) {
-  const raw = normalizeProviderPathEnv(providerPathEnv);
-  if (!raw) {
-    return [];
-  }
-  return [...new Set(raw.split(process.platform === "win32" ? ";" : ":").map((item) => item.trim()).filter(Boolean))];
+  const parts = [];
+  appendProviderModulePaths(parts, providerPathEnv);
+  return [...new Set(parts)];
 }
 
 function normalizeRuntimeBackendName(backend) {
@@ -221,18 +234,17 @@ function readConfigEnvValue(configFilePath, key) {
     if (!parsed || typeof parsed !== "object") {
       return "";
     }
-    const value = parsed?.envs?.[key];
-    return typeof value === "string" ? value.trim() : "";
+    return parsed?.envs?.[key];
   } catch {
-    return "";
+    return undefined;
   }
 }
 
-function resolveProviderPathEnv(options = {}) {
-  return (
-    normalizeProviderPathEnv(process.env.AISDK_PROVIDER_PATH) ||
-    normalizeProviderPathEnv(readConfigEnvValue(options.configFilePath, "AISDK_PROVIDER_PATH"))
-  );
+function resolveProviderModulePaths(options = {}) {
+  return [
+    ...listProviderModulePaths(process.env.AISDK_PROVIDER_PATH),
+    ...listProviderModulePaths(readConfigEnvValue(options.configFilePath, "AISDK_PROVIDER_PATH")),
+  ].filter((value, index, array) => array.indexOf(value) === index);
 }
 
 function createEmptyExternalCatalog() {
@@ -342,15 +354,16 @@ async function loadExternalRuntimeCatalog(providerPathEnv) {
 }
 
 async function getExternalRuntimeCatalog(options = {}) {
-  const providerPathEnv = resolveProviderPathEnv(options);
-  if (!externalRuntimeCatalogPromises.has(providerPathEnv)) {
-    const loadPromise = loadExternalRuntimeCatalog(providerPathEnv).catch((error) => {
-      externalRuntimeCatalogPromises.delete(providerPathEnv);
+  const modulePaths = resolveProviderModulePaths(options);
+  const cacheKey = modulePaths.join("\0");
+  if (!externalRuntimeCatalogPromises.has(cacheKey)) {
+    const loadPromise = loadExternalRuntimeCatalog(modulePaths).catch((error) => {
+      externalRuntimeCatalogPromises.delete(cacheKey);
       throw error;
     });
-    externalRuntimeCatalogPromises.set(providerPathEnv, loadPromise);
+    externalRuntimeCatalogPromises.set(cacheKey, loadPromise);
   }
-  return externalRuntimeCatalogPromises.get(providerPathEnv);
+  return externalRuntimeCatalogPromises.get(cacheKey);
 }
 
 export async function normalizeRuntimeBackendAlias(backend, options = {}) {