@love-moon/conductor-cli 0.2.10 → 0.2.12

package/bin/conductor-fire.js

@@ -11,6 +11,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
+import readline from "node:readline";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
 
@@ -19,17 +20,14 @@ import { hideBin } from "yargs/helpers";
 import yaml from "js-yaml";
 import { TuiDriver, claudeCodeProfile, codexProfile, copilotProfile } from "@love-moon/tui-driver";
 import { ConductorClient, loadConfig } from "@love-moon/conductor-sdk";
-import {
-  loadHistoryFromSpec,
-  parseFromSpec,
-  selectHistorySession,
-  SUPPORTED_FROM_PROVIDERS,
-} from "../src/fire/history.js";
+import { findSessionPath } from "../src/fire/history.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const PKG_ROOT = path.join(__dirname, "..");
-const CLI_PROJECT_PATH = process.cwd();
+const INITIAL_CLI_PROJECT_PATH = process.cwd();
+const FIRE_LOG_PATH = path.join(INITIAL_CLI_PROJECT_PATH, "conductor.log");
+const ENABLE_FIRE_LOCAL_LOG = !process.env.CONDUCTOR_CLI_COMMAND;
 
 const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
 const CLI_NAME = (process.env.CONDUCTOR_CLI_NAME || path.basename(process.argv[1] || "conductor-fire")).replace(
@@ -106,8 +104,20 @@ const DEFAULT_POLL_INTERVAL_MS = parseInt(
   10,
 );
 
+function appendFireLocalLog(line) {
+  if (!ENABLE_FIRE_LOCAL_LOG) {
+    return;
+  }
+  try {
+    fs.appendFileSync(FIRE_LOG_PATH, line);
+  } catch {
+    // ignore file log errors
+  }
+}
+
 async function main() {
   const cliArgs = parseCliArgs();
+  let runtimeProjectPath = process.cwd();
 
   if (cliArgs.showHelp) {
     return;
@@ -134,48 +144,22 @@ async function main() {
     return;
   }
 
-  let fromHistory = { history: [], provider: null, sessionId: null };
-  if (cliArgs.fromSpec) {
-    const provider = cliArgs.fromSpec.provider;
-    if (!SUPPORTED_FROM_PROVIDERS.includes(provider)) {
-      throw new Error(`--from only supports: ${SUPPORTED_FROM_PROVIDERS.join(", ")}`);
-    }
-
-    let resolvedSpec = cliArgs.fromSpec;
-    if (!resolvedSpec.sessionId) {
-      const selected = await selectHistorySession(provider);
-      if (!selected) {
-        log("No session selected. Starting a new conversation.");
-        resolvedSpec = null;
-      } else {
-        resolvedSpec = parseFromSpec(`${provider}:${selected.sessionId}`);
-      }
-    }
-
-    if (resolvedSpec) {
-      if (cliArgs.backend !== resolvedSpec.provider) {
-        log(
-          `Ignoring --from ${resolvedSpec.provider}:${resolvedSpec.sessionId} because backend is ${cliArgs.backend}`,
-        );
-      } else {
-        fromHistory = await loadHistoryFromSpec(resolvedSpec);
-        if (fromHistory.warning) {
-          log(fromHistory.warning);
-        } else {
-          log(
-            `Loaded ${fromHistory.history.length} history messages from ${fromHistory.provider} session ${fromHistory.sessionId}`,
-          );
-        }
-      }
-    }
+  let resumeContext = null;
+  if (cliArgs.resumeSessionId) {
+    resumeContext = await resolveResumeContext(cliArgs.backend, cliArgs.resumeSessionId);
+    log(
+      `Validated --resume ${resumeContext.sessionId} (${resumeContext.provider}) at ${resumeContext.sessionPath}`,
+    );
+    log(`Resume will run backend from ${resumeContext.cwd}`);
+    runtimeProjectPath = await applyWorkingDirectory(resumeContext.cwd);
+    log(`Switched working directory to ${runtimeProjectPath} before Conductor connect`);
   }
 
   // Create backend session using tui-driver
   const backendSession = new TuiDriverSession(cliArgs.backend, {
     initialImages: cliArgs.initialImages,
-    cwd: CLI_PROJECT_PATH,
-    initialHistory: fromHistory.history,
-    resumeSessionId: fromHistory.sessionId,
+    cwd: runtimeProjectPath,
+    resumeSessionId: cliArgs.resumeSessionId,
     configFile: cliArgs.configFile,
   });
 
@@ -185,6 +169,7 @@ async function main() {
   const launchedByDaemon = Boolean(process.env.CONDUCTOR_CLI_COMMAND);
   let reconnectRunner = null;
   let reconnectTaskId = null;
+  let pendingRemoteStopEvent = null;
   let conductor = null;
   let reconnectResumeInFlight = false;
 
@@ -221,6 +206,21 @@ async function main() {
     })();
   };
 
+  const handleStopTaskCommand = async (event) => {
+    if (!event || typeof event !== "object") {
+      return;
+    }
+    const taskId = typeof event.taskId === "string" ? event.taskId : "";
+    if (reconnectTaskId && taskId && taskId !== reconnectTaskId) {
+      return;
+    }
+    if (reconnectRunner && typeof reconnectRunner.requestStopFromRemote === "function") {
+      await reconnectRunner.requestStopFromRemote(event);
+      return;
+    }
+    pendingRemoteStopEvent = event;
+  };
+
   if (cliArgs.configFile) {
     env.CONDUCTOR_CONFIG = cliArgs.configFile;
   }
@@ -239,111 +239,159 @@ async function main() {
     // Ignore config loading errors, rely on env vars or defaults
   }
 
-  conductor = await ConductorClient.connect({
-    projectPath: CLI_PROJECT_PATH,
-    extraEnv: env,
-    configFile: cliArgs.configFile,
-    onConnected: scheduleReconnectRecovery,
-  });
-
-  const taskContext = await ensureTaskContext(conductor, {
-    initialPrompt: cliArgs.initialPrompt,
-    requestedProjectId: process.env.CONDUCTOR_PROJECT_ID,
-    providedTaskId: process.env.CONDUCTOR_TASK_ID,
-    requestedTitle: cliArgs.taskTitle || process.env.CONDUCTOR_TASK_TITLE,
-    backend: cliArgs.backend,
-  });
-
-  log(
-    `Attached to Conductor task ${taskContext.taskId}${
-      taskContext.appUrl ? ` (${taskContext.appUrl})` : ""
-    }`,
-  );
-  reconnectTaskId = taskContext.taskId;
-
   try {
-    await conductor.sendAgentResume({
-      active_tasks: [taskContext.taskId],
-      source: "conductor-fire",
-      metadata: { reconnect: false },
+    const requestedTaskTitle = resolveRequestedTaskTitle({
+      cliTaskTitle: cliArgs.taskTitle,
+      hasExplicitTaskTitle: cliArgs.hasExplicitTaskTitle,
+      envTaskTitle: process.env.CONDUCTOR_TASK_TITLE,
+      runtimeProjectPath,
     });
-  } catch (error) {
-    log(`Failed to report agent resume: ${error?.message || error}`);
-  }
 
-  const runner = new BridgeRunner({
-    backendSession,
-    conductor,
-    taskId: taskContext.taskId,
-    pollIntervalMs: Math.max(cliArgs.pollIntervalMs, 500),
-    initialPrompt: taskContext.shouldProcessInitialPrompt ? cliArgs.initialPrompt : "",
-    includeInitialImages: Boolean(cliArgs.initialPrompt && cliArgs.initialImages.length),
-    cliArgs: cliArgs.rawBackendArgs,
-    backendName: cliArgs.backend,
-  });
-  reconnectRunner = runner;
+    conductor = await ConductorClient.connect({
+      projectPath: runtimeProjectPath,
+      extraEnv: env,
+      configFile: cliArgs.configFile,
+      onConnected: scheduleReconnectRecovery,
+      onStopTask: handleStopTaskCommand,
+    });
 
-  const signals = new AbortController();
-  let shutdownSignal = null;
-  const onSigint = () => {
-    shutdownSignal = shutdownSignal || "SIGINT";
-    signals.abort();
-  };
-  const onSigterm = () => {
-    shutdownSignal = shutdownSignal || "SIGTERM";
-    signals.abort();
-  };
-  process.on("SIGINT", onSigint);
-  process.on("SIGTERM", onSigterm);
+    const taskContext = await ensureTaskContext(conductor, {
+      initialPrompt: cliArgs.initialPrompt,
+      requestedProjectId: process.env.CONDUCTOR_PROJECT_ID,
+      providedTaskId: process.env.CONDUCTOR_TASK_ID,
+      requestedTitle: requestedTaskTitle,
+      backend: cliArgs.backend,
+    });
+
+    log(
+      `Attached to Conductor task ${taskContext.taskId}${
+        taskContext.appUrl ? ` (${taskContext.appUrl})` : ""
+      }`,
+    );
+    reconnectTaskId = taskContext.taskId;
 
-  if (!launchedByDaemon) {
     try {
-      await conductor.sendTaskStatus(taskContext.taskId, {
-        status: "RUNNING",
+      await conductor.sendAgentResume({
+        active_tasks: [taskContext.taskId],
+        source: "conductor-fire",
+        metadata: { reconnect: false },
       });
     } catch (error) {
-      log(`Failed to report task status (RUNNING): ${error?.message || error}`);
+      log(`Failed to report agent resume: ${error?.message || error}`);
+    }
+
+    const runner = new BridgeRunner({
+      backendSession,
+      conductor,
+      taskId: taskContext.taskId,
+      pollIntervalMs: Math.max(cliArgs.pollIntervalMs, 500),
+      initialPrompt: taskContext.shouldProcessInitialPrompt ? cliArgs.initialPrompt : "",
+      includeInitialImages: Boolean(cliArgs.initialPrompt && cliArgs.initialImages.length),
+      cliArgs: cliArgs.rawBackendArgs,
+      backendName: cliArgs.backend,
+      resumeMode: Boolean(cliArgs.resumeSessionId),
+    });
+    reconnectRunner = runner;
+    if (pendingRemoteStopEvent) {
+      await runner.requestStopFromRemote(pendingRemoteStopEvent);
+      pendingRemoteStopEvent = null;
     }
-  }
 
-  let runnerError = null;
-  try {
-    await runner.start(signals.signal);
-  } catch (error) {
-    runnerError = error;
-    throw error;
-  } finally {
-    process.off("SIGINT", onSigint);
-    process.off("SIGTERM", onSigterm);
+    const signals = new AbortController();
+    let shutdownSignal = null;
+    let backendShutdownRequested = false;
+    const requestBackendShutdown = (source) => {
+      if (backendShutdownRequested) {
+        return;
+      }
+      backendShutdownRequested = true;
+      void (async () => {
+        try {
+          await backendSession.close();
+        } catch (error) {
+          log(`Failed to close backend session after ${source}: ${error?.message || error}`);
+        }
+      })();
+    };
+    const onSigint = () => {
+      shutdownSignal = shutdownSignal || "SIGINT";
+      signals.abort();
+      requestBackendShutdown("SIGINT");
+    };
+    const onSigterm = () => {
+      shutdownSignal = shutdownSignal || "SIGTERM";
+      signals.abort();
+      requestBackendShutdown("SIGTERM");
+    };
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+
     if (!launchedByDaemon) {
-      const finalStatus = shutdownSignal
-        ? {
-            status: "KILLED",
-            summary: `terminated by ${shutdownSignal}`,
-          }
-        : runnerError
+      try {
+        await conductor.sendTaskStatus(taskContext.taskId, {
+          status: "RUNNING",
+        });
+      } catch (error) {
+        log(`Failed to report task status (RUNNING): ${error?.message || error}`);
+      }
+    }
+
+    let runnerError = null;
+    try {
+      await runner.start(signals.signal);
+    } catch (error) {
+      runnerError = error;
+      throw error;
+    } finally {
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+      if (!launchedByDaemon) {
+        const remoteStopSummary = typeof runner.getRemoteStopSummary === "function" ? runner.getRemoteStopSummary() : null;
+        const finalStatus = shutdownSignal
           ? {
               status: "KILLED",
-              summary: `conductor fire failed: ${runnerError?.message || runnerError}`,
+              summary: `terminated by ${shutdownSignal}`,
             }
-          : {
-              status: "COMPLETED",
-              summary: "conductor fire exited",
-            };
-      try {
-        await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
-      } catch (error) {
-        log(`Failed to report task status (${finalStatus.status}): ${error?.message || error}`);
+          : runnerError
+            ? {
+                status: "KILLED",
+                summary: `conductor fire failed: ${runnerError?.message || runnerError}`,
+              }
+            : remoteStopSummary
+              ? {
+                  status: "KILLED",
+                  summary: remoteStopSummary,
+                }
+            : {
+                status: "COMPLETED",
+                summary: "conductor fire exited",
+              };
+        try {
+          await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
+        } catch (error) {
+          log(`Failed to report task status (${finalStatus.status}): ${error?.message || error}`);
+        }
+      }
+      if (shutdownSignal === "SIGINT") {
+        process.exitCode = 130;
+      } else if (shutdownSignal === "SIGTERM") {
+        process.exitCode = 143;
       }
     }
+  } finally {
     if (typeof backendSession.close === "function") {
-      await backendSession.close();
+      try {
+        await backendSession.close();
+      } catch (error) {
+        log(`Failed to close backend session: ${error?.message || error}`);
+      }
     }
-    await conductor.close();
-    if (shutdownSignal === "SIGINT") {
-      process.exitCode = 130;
-    } else if (shutdownSignal === "SIGTERM") {
-      process.exitCode = 143;
+    if (conductor && typeof conductor.close === "function") {
+      try {
+        await conductor.close();
+      } catch (error) {
+        log(`Failed to close conductor connection: ${error?.message || error}`);
+      }
     }
   }
 }
@@ -361,6 +409,65 @@ function extractConfigFileFromArgv(argv) {
   return undefined;
 }
 
+function hasLegacyFromFlags(argv = []) {
+  return argv.some(
+    (arg) =>
+      arg === "--from" ||
+      arg.startsWith("--from=") ||
+      arg === "--from-provider" ||
+      arg.startsWith("--from-provider="),
+  );
+}
+
+const CONDUCTOR_BOOLEAN_FLAGS = new Set([
+  "--list-backends",
+  "--version",
+  "-v",
+  "--help",
+  "-h",
+]);
+
+const CONDUCTOR_VALUE_FLAGS = new Set([
+  "--backend",
+  "-b",
+  "--config-file",
+  "--poll-interval",
+  "--title",
+  "-t",
+  "--resume",
+  "--prefill",
+]);
+
+function stripConductorArgsFromArgv(argv = []) {
+  const backendArgs = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const raw = String(argv[i] ?? "");
+    if (!raw) {
+      continue;
+    }
+    if (raw === "--") {
+      backendArgs.push(...argv.slice(i + 1));
+      break;
+    }
+
+    const eqIndex = raw.indexOf("=");
+    const flag = eqIndex > 0 ? raw.slice(0, eqIndex) : raw;
+
+    if (CONDUCTOR_BOOLEAN_FLAGS.has(flag)) {
+      continue;
+    }
+    if (CONDUCTOR_VALUE_FLAGS.has(flag)) {
+      if (eqIndex < 0) {
+        i += 1;
+      }
+      continue;
+    }
+
+    backendArgs.push(raw);
+  }
+  return backendArgs;
+}
+
 export function parseCliArgs(argvInput = process.argv) {
   const rawArgv = Array.isArray(argvInput) ? argvInput : process.argv;
   const argv = hideBin(rawArgv);
@@ -368,12 +475,15 @@ export function parseCliArgs(argvInput = process.argv) {
   
   // When no separator, parse all args first to check for conductor-specific options
   const conductorArgv = separatorIndex === -1 ? argv : argv.slice(0, separatorIndex);
-  const backendArgv = separatorIndex === -1 ? argv : argv.slice(separatorIndex + 1);
+  const backendArgv = separatorIndex === -1 ? stripConductorArgsFromArgv(argv) : argv.slice(separatorIndex + 1);
   
   // Check for version/list-backends/help without separator
   const versionWithoutSeparator = separatorIndex === -1 && (argv.includes("--version") || argv.includes("-v"));
   const listBackendsWithoutSeparator = separatorIndex === -1 && argv.includes("--list-backends");
   const helpWithoutSeparator = separatorIndex === -1 && (argv.includes("--help") || argv.includes("-h"));
+  if (hasLegacyFromFlags(conductorArgv)) {
+    throw new Error("--from and --from-provider were removed. Use --resume <session-id>.");
+  }
 
   const configFileFromArgs = extractConfigFileFromArgv(argv);
   const allowCliList = loadAllowCliList(configFileFromArgs);
@@ -406,15 +516,9 @@ export function parseCliArgs(argvInput = process.argv) {
       type: "string",
       describe: "Optional task title shown in the app task list",
     })
-    .option("from", {
-      alias: "f",
-      type: "string",
-      describe: "Resume from local history (optional session id; otherwise pick interactively)",
-    })
-    .option("from-provider", {
+    .option("resume", {
       type: "string",
-      describe: "Provider for --from picker (defaults to --backend)",
-      choices: SUPPORTED_FROM_PROVIDERS,
+      describe: "Resume from a backend session ID",
     })
     .option("prefill", {
       type: "string",
@@ -447,8 +551,7 @@ Options:
   --config-file <path>  Path to Conductor config file
   --poll-interval <ms>  Polling interval when waiting for Conductor messages
   -t, --title <text>    Optional task title shown in the app task list
-  -f, --from [id]       Resume from local history (pick if id omitted)
-  --from-provider <p>   Provider for --from picker (codex or claude)
+  --resume <id>         Resume from an existing backend session
   -v, --version         Show Conductor CLI version and exit
   -h, --help            Show this help message
 
@@ -462,6 +565,7 @@ Examples:
   ${CLI_NAME} -- "fix the bug"                    # Use default backend
   ${CLI_NAME} --backend claude -- "fix the bug"   # Use Claude CLI backend
   ${CLI_NAME} --backend copilot -- "fix the bug"  # Use GitHub Copilot CLI backend
+  ${CLI_NAME} --backend codex --resume <id>       # Resume Codex session
   ${CLI_NAME} --list-backends                     # Show configured backends
   ${CLI_NAME} --config-file ~/.conductor/config.yaml -- "fix the bug"
 
@@ -491,11 +595,13 @@ Environment:
      ? Number(conductorArgs.pollInterval)
      : DEFAULT_POLL_INTERVAL_MS;
 
-  let fromSpec = null;
-  try {
-    fromSpec = parseFromSpec(conductorArgs.from, conductorArgs.fromProvider, backend);
-  } catch (error) {
-    throw new Error(error.message);
+  const resumeRaw = conductorArgs.resume;
+  if (resumeRaw === true) {
+    throw new Error("--resume requires a session id");
+  }
+  const resumeSessionId = typeof resumeRaw === "string" ? resumeRaw.trim() : "";
+  if (resumeRaw !== undefined && !resumeSessionId) {
+    throw new Error("--resume requires a session id");
   }
 
   return {
@@ -504,22 +610,34 @@ Environment:
     initialImages,
     pollIntervalMs,
     rawBackendArgs: backendArgv,
-    taskTitle: resolveTaskTitle(conductorArgs.title),
+    taskTitle: typeof conductorArgs.title === "string" ? conductorArgs.title.trim() : "",
+    hasExplicitTaskTitle: typeof conductorArgs.title === "string" && Boolean(conductorArgs.title.trim()),
     configFile: conductorArgs.configFile,
-    fromSpec,
+    resumeSessionId,
     showVersion: Boolean(conductorArgs.version) || versionWithoutSeparator,
     listBackends: Boolean(conductorArgs.listBackends) || listBackendsWithoutSeparator,
   };
 }
 
-function resolveTaskTitle(titleFlag) {
+export function resolveTaskTitle(titleFlag, defaultPath = process.cwd()) {
   if (typeof titleFlag === "string" && titleFlag.trim()) {
     return titleFlag.trim();
   }
-  const cwdName = path.basename(CLI_PROJECT_PATH || process.cwd());
+  const targetPath = typeof defaultPath === "string" ? defaultPath.trim() : "";
+  const cwdName = path.basename(targetPath || process.cwd());
   return cwdName || "";
 }
 
+export function resolveRequestedTaskTitle({
+  cliTaskTitle,
+  hasExplicitTaskTitle,
+  envTaskTitle,
+  runtimeProjectPath,
+}) {
+  const explicit = hasExplicitTaskTitle ? cliTaskTitle : envTaskTitle;
+  return resolveTaskTitle(explicit, runtimeProjectPath);
+}
+
 function normalizeArray(value) {
   if (!value) {
     return [];
@@ -642,6 +760,7 @@ function deriveTaskTitle(prompt, explicit, backend = "codex") {
 
 const BACKEND_PROFILE_MAP = {
   codex: "codex",
+  code: "codex",
   claude: "claude-code",
   "claude-code": "claude-code",
   copilot: "copilot",
@@ -664,6 +783,228 @@ function parseCommandParts(commandLine) {
   };
 }
 
+export function buildResumeArgsForBackend(backend, sessionId) {
+  const resumeSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
+  if (!resumeSessionId) {
+    return [];
+  }
+  const normalizedBackend = String(backend || "").trim().toLowerCase();
+  if (normalizedBackend === "codex" || normalizedBackend === "code") {
+    return ["resume", resumeSessionId];
+  }
+  if (normalizedBackend === "claude" || normalizedBackend === "claude-code") {
+    return ["--resume", resumeSessionId];
+  }
+  if (normalizedBackend === "copilot") {
+    return [`--resume=${resumeSessionId}`];
+  }
+  throw new Error(`--resume is not supported for backend "${backend}"`);
+}
+
+export function resumeProviderForBackend(backend) {
+  const normalizedBackend = String(backend || "").trim().toLowerCase();
+  if (normalizedBackend === "codex" || normalizedBackend === "code") {
+    return "codex";
+  }
+  if (normalizedBackend === "claude" || normalizedBackend === "claude-code") {
+    return "claude";
+  }
+  if (normalizedBackend === "copilot") {
+    return "copilot";
+  }
+  return null;
+}
+
+export async function resolveSessionRunDirectory(sessionPath) {
+  const normalizedPath = typeof sessionPath === "string" ? sessionPath.trim() : "";
+  if (!normalizedPath) {
+    throw new Error("Invalid session path");
+  }
+  let stats;
+  try {
+    stats = await fs.promises.stat(normalizedPath);
+  } catch {
+    throw new Error(`Session path does not exist: ${normalizedPath}`);
+  }
+  return stats.isDirectory() ? normalizedPath : path.dirname(normalizedPath);
+}
+
+async function isExistingDirectory(targetPath) {
+  const normalizedPath = typeof targetPath === "string" ? targetPath.trim() : "";
+  if (!normalizedPath) {
+    return false;
+  }
+  try {
+    const stats = await fs.promises.stat(normalizedPath);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function extractCodexResumeCwd(sessionPath) {
+  if (!sessionPath.endsWith(".jsonl")) {
+    return null;
+  }
+  const rl = readline.createInterface({
+    input: fs.createReadStream(sessionPath),
+    crlfDelay: Infinity,
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const maybeCwd = entry?.type === "session_meta" ? entry?.payload?.cwd : null;
+    if (typeof maybeCwd === "string" && maybeCwd.trim()) {
+      return maybeCwd.trim();
+    }
+  }
+  return null;
+}
+
+async function extractClaudeResumeCwd(sessionPath, sessionId) {
+  if (!sessionPath.endsWith(".jsonl")) {
+    return null;
+  }
+  const rl = readline.createInterface({
+    input: fs.createReadStream(sessionPath),
+    crlfDelay: Infinity,
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const idMatches = String(entry?.sessionId || "").trim() === sessionId;
+    const maybeCwd = entry?.cwd;
+    if (idMatches && typeof maybeCwd === "string" && maybeCwd.trim()) {
+      return maybeCwd.trim();
+    }
+  }
+  return null;
+}
+
+async function extractCopilotResumeCwd(sessionPath) {
+  let stats;
+  try {
+    stats = await fs.promises.stat(sessionPath);
+  } catch {
+    return null;
+  }
+
+  if (stats.isDirectory()) {
+    const workspaceYamlPath = path.join(sessionPath, "workspace.yaml");
+    try {
+      const yamlContent = await fs.promises.readFile(workspaceYamlPath, "utf8");
+      const parsed = yaml.load(yamlContent);
+      const maybeCwd = parsed && typeof parsed === "object" ? parsed.cwd : null;
+      if (typeof maybeCwd === "string" && maybeCwd.trim()) {
+        return maybeCwd.trim();
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+
+  if (!sessionPath.endsWith(".jsonl")) {
+    return null;
+  }
+
+  const rl = readline.createInterface({
+    input: fs.createReadStream(sessionPath),
+    crlfDelay: Infinity,
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const maybeCwd = entry?.data?.context?.cwd || entry?.data?.cwd;
+    if (typeof maybeCwd === "string" && maybeCwd.trim()) {
+      return maybeCwd.trim();
+    }
+  }
+  return null;
+}
+
+async function extractResumeCwdFromSession(provider, sessionPath, sessionId) {
+  if (provider === "codex") {
+    return extractCodexResumeCwd(sessionPath);
+  }
+  if (provider === "claude") {
+    return extractClaudeResumeCwd(sessionPath, sessionId);
+  }
+  if (provider === "copilot") {
+    return extractCopilotResumeCwd(sessionPath);
+  }
+  return null;
+}
+
+export async function resolveResumeContext(backend, sessionId, options = {}) {
+  const normalizedSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
+  if (!normalizedSessionId) {
+    throw new Error("--resume requires a session id");
+  }
+  const provider = resumeProviderForBackend(backend);
+  if (!provider) {
+    throw new Error(`--resume is not supported for backend "${backend}"`);
+  }
+
+  const sessionPath = await findSessionPath(provider, normalizedSessionId, options);
+  if (!sessionPath) {
+    throw new Error(`Invalid --resume session id for ${provider}: ${normalizedSessionId}`);
+  }
+
+  const cwdFromSession = await extractResumeCwdFromSession(provider, sessionPath, normalizedSessionId);
+  const fallbackCwd = await resolveSessionRunDirectory(sessionPath);
+  const cwd = cwdFromSession || fallbackCwd;
+  if (!(await isExistingDirectory(cwd))) {
+    throw new Error(`Resume workspace path does not exist: ${cwd}`);
+  }
+  return {
+    provider,
+    sessionId: normalizedSessionId,
+    sessionPath,
+    cwd,
+  };
+}
+
+export async function applyWorkingDirectory(targetPath) {
+  const normalizedPath = typeof targetPath === "string" ? targetPath.trim() : "";
+  if (!normalizedPath) {
+    throw new Error("Cannot switch working directory: empty path");
+  }
+  if (!(await isExistingDirectory(normalizedPath))) {
+    throw new Error(`Cannot switch working directory: ${normalizedPath}`);
+  }
+  try {
+    process.chdir(normalizedPath);
+  } catch (error) {
+    throw new Error(`Cannot switch working directory to ${normalizedPath}: ${error?.message || error}`);
+  }
+  return process.cwd();
+}
+
 function truncateText(value, maxLen = 240) {
   if (!value) return "";
   const text = String(value).trim();
@@ -677,6 +1018,10 @@ function isTruthyEnv(value) {
   return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
 }
 
+function isSessionClosedError(error) {
+  return Boolean(error && typeof error === "object" && error.reason === "session_closed");
+}
+
 function sanitizeForLog(value, maxLen = 180) {
   if (!value) return "";
   return truncateText(String(value).replace(/\s+/g, " ").trim(), maxLen);
@@ -692,7 +1037,12 @@ class TuiDriverSession {
   constructor(backend, options = {}) {
     this.backend = backend;
     this.options = options;
-    this.sessionId = options.resumeSessionId || `${backend}-${Date.now()}`;
+    this.cwd =
+      typeof options.cwd === "string" && options.cwd.trim()
+        ? options.cwd.trim()
+        : INITIAL_CLI_PROJECT_PATH;
+    const resumeSessionId = typeof options.resumeSessionId === "string" ? options.resumeSessionId.trim() : "";
+    this.sessionId = resumeSessionId || `${backend}-${Date.now()}`;
     this.history = Array.isArray(options.initialHistory) ? [...options.initialHistory] : [];
     this.pendingHistorySeed = this.history.length > 0;
 
@@ -702,8 +1052,9 @@ class TuiDriverSession {
     if (!command) {
       throw new Error(`Invalid command for backend "${backend}"`);
     }
+    const resumeArgs = buildResumeArgsForBackend(backend, resumeSessionId);
     this.command = command;
-    this.args = args;
+    this.args = [...args, ...resumeArgs];
     this.tuiDebug = isTruthyEnv(process.env.CONDUCTOR_TUI_DEBUG);
     this.tuiTrace = this.tuiDebug || isTruthyEnv(process.env.CONDUCTOR_TUI_TRACE);
     this.tuiTraceLines = Number.isFinite(Number.parseInt(process.env.CONDUCTOR_TUI_TRACE_LINES || "", 10))
@@ -712,6 +1063,9 @@ class TuiDriverSession {
     this.lastSignalSignature = "";
     this.lastPollSignature = "";
     this.lastSnapshotHash = "";
+    this.closeRequested = false;
+    this.closed = false;
+    this.closeWaiters = new Set();
 
     const profileName = profileNameForBackend(backend);
     if (!profileName) {
@@ -732,7 +1086,7 @@ class TuiDriverSession {
       log(`Using proxy: ${proxyEnv.http_proxy || proxyEnv.https_proxy || proxyEnv.all_proxy}`);
     }
 
-    log(`Using TUI command for ${backend}: ${cliCommand}`);
+    log(`Using TUI command for ${backend}: ${[this.command, ...this.args].join(" ")} (cwd: ${this.cwd})`);
     if (this.tuiTrace) {
       log(
         `[${this.backend}] [tui-trace] profile=${baseProfile.name} command=${this.command} args=${JSON.stringify(this.args)}`,
@@ -753,6 +1107,7 @@ class TuiDriverSession {
           ...cliEnv,
         },
       },
+      cwd: this.cwd,
       debug: this.tuiDebug,
       onSnapshot: this.tuiTrace
         ? (snapshot, state) => {
@@ -784,7 +1139,57 @@ class TuiDriverSession {
     return { model: this.backend };
   }
 
+  createSessionClosedError() {
+    const error = new Error("TUI session closed");
+    error.reason = "session_closed";
+    return error;
+  }
+
+  createCloseGuard() {
+    if (this.closeRequested) {
+      return {
+        promise: Promise.reject(this.createSessionClosedError()),
+        cleanup: () => {},
+      };
+    }
+    let waiter = null;
+    const promise = new Promise((_, reject) => {
+      waiter = () => {
+        reject(this.createSessionClosedError());
+      };
+      this.closeWaiters.add(waiter);
+    });
+    return {
+      promise,
+      cleanup: () => {
+        if (waiter) {
+          this.closeWaiters.delete(waiter);
+        }
+      },
+    };
+  }
+
+  flushCloseWaiters() {
+    if (!this.closeWaiters || this.closeWaiters.size === 0) {
+      return;
+    }
+    for (const waiter of this.closeWaiters) {
+      try {
+        waiter();
+      } catch {
+        // best effort
+      }
+    }
+    this.closeWaiters.clear();
+  }
+
   async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.closeRequested = true;
+    this.flushCloseWaiters();
     if (this.driver) {
       this.driver.kill();
     }
@@ -889,6 +1294,10 @@ class TuiDriverSession {
   }
 
   async runTurn(promptText, { useInitialImages = false, onProgress } = {}) {
+    if (this.closeRequested) {
+      throw this.createSessionClosedError();
+    }
+
     const effectivePrompt = this.buildPrompt(promptText, { useInitialImages });
     if (!effectivePrompt) {
       return {
@@ -945,8 +1354,19 @@ class TuiDriverSession {
       signalTimer.unref();
     }
 
+    const previousCwd = process.cwd();
+    const shouldSwitchCwd = this.cwd && this.cwd !== previousCwd;
+    if (shouldSwitchCwd) {
+      try {
+        process.chdir(this.cwd);
+      } catch (error) {
+        throw new Error(`Failed to switch backend cwd to ${this.cwd}: ${error?.message || error}`);
+      }
+    }
+    const closeGuard = this.createCloseGuard();
+
     try {
-      const result = await this.driver.ask(effectivePrompt);
+      const result = await Promise.race([this.driver.ask(effectivePrompt), closeGuard.promise]);
       const answer = String(result.answer || result.replyText || "").trim();
       this.trace(
         `runTurn finished success=${Boolean(result.success)} elapsedMs=${result.elapsedMs} answerLen=${answer.length} state=${this.driver.state}`,
@@ -990,6 +1410,10 @@ class TuiDriverSession {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       const errorReason = error?.reason || "unknown";
+      if (errorReason === "session_closed") {
+        this.trace("runTurn interrupted because backend session is closing");
+        throw error instanceof Error ? error : new Error(errorMessage);
+      }
 
       // 特殊处理登录和权限错误
       if (errorReason === "login_required") {
@@ -1024,21 +1448,34 @@ class TuiDriverSession {
         log(`[${this.backend}] Error: ${errorMessage}`);
       }
 
-      const latestSignals = this.driver.getSignals();
+      let latestSignals = {};
+      try {
+        latestSignals = this.driver.getSignals();
+      } catch {
+        // driver may already be disposed while closing
+      }
       const summary = this.formatSignalSummary(latestSignals);
       this.trace(
         `runTurn exception state=${this.driver.state} error="${sanitizeForLog(errorMessage, 220)}" status="${summary.status || ""}" done="${summary.done || ""}" preview="${summary.replyPreview || ""}"`,
       );
       throw error instanceof Error ? error : new Error(errorMessage);
     } finally {
+      if (shouldSwitchCwd) {
+        try {
+          process.chdir(previousCwd);
+        } catch (error) {
+          log(`Failed to restore cwd to ${previousCwd}: ${error?.message || error}`);
+        }
+      }
       clearInterval(signalTimer);
       this.driver.off("stateChange", handleStateChange);
+      closeGuard.cleanup();
       this.trace(`runTurn cleanup state=${this.driver.state}`);
     }
   }
 }
 
-class BridgeRunner {
+export class BridgeRunner {
   constructor({
     backendSession,
     conductor,
@@ -1048,6 +1485,7 @@ class BridgeRunner {
     includeInitialImages,
     cliArgs,
     backendName,
+    resumeMode,
   }) {
     this.backendSession = backendSession;
     this.conductor = conductor;
@@ -1057,25 +1495,55 @@ class BridgeRunner {
     this.includeInitialImages = includeInitialImages;
     this.cliArgs = cliArgs;
     this.backendName = backendName || "codex";
+    this.resumeMode = Boolean(resumeMode);
+    this.isCopilotBackend = String(this.backendName).toLowerCase() === "copilot";
+    this.copilotDebug =
+      this.isCopilotBackend &&
+      (isTruthyEnv(process.env.CONDUCTOR_COPILOT_DEBUG) || isTruthyEnv(process.env.CONDUCTOR_DEBUG));
     this.stopped = false;
     this.runningTurn = false;
     this.processedMessageIds = new Set();
     this.lastRuntimeStatusSignature = null;
     this.lastRuntimeStatusPayload = null;
     this.needsReconnectRecovery = false;
+    this.remoteStopInfo = null;
+  }
+
+  copilotLog(message) {
+    if (!this.copilotDebug) {
+      return;
+    }
+    log(`[copilot-debug] task=${this.taskId} ${message}`);
   }
 
   async start(abortSignal) {
     abortSignal?.addEventListener("abort", () => {
       this.stopped = true;
     });
+    if (this.stopped) {
+      return;
+    }
 
     if (this.initialPrompt) {
+      this.copilotLog("processing initial prompt");
       await this.handleSyntheticMessage(this.initialPrompt, {
         includeImages: this.includeInitialImages,
       });
     }
+    if (this.stopped) {
+      return;
+    }
+    if (this.resumeMode) {
+      await this.drainBufferedMessagesForResume();
+    }
+    if (this.stopped) {
+      return;
+    }
+    this.copilotLog("running startup backfill");
     await this.backfillPendingUserMessages();
+    if (this.stopped) {
+      return;
+    }
 
     while (!this.stopped) {
       if (this.needsReconnectRecovery && !this.runningTurn) {
@@ -1085,10 +1553,13 @@ class BridgeRunner {
       try {
         processed = await this.processIncomingBatch();
       } catch (error) {
+        if (this.stopped && (this.remoteStopInfo || isSessionClosedError(error))) {
+          break;
+        }
         log(`Error while processing messages: ${error.message}`);
         await this.reportError(`处理任务失败: ${error.message}`);
       }
-      if (!processed) {
+      if (!processed && !this.stopped) {
         await delay(this.pollIntervalMs);
       }
     }
@@ -1098,6 +1569,42 @@ class BridgeRunner {
     this.needsReconnectRecovery = true;
   }
 
+  getRemoteStopSummary() {
+    if (!this.remoteStopInfo) {
+      return null;
+    }
+    const reason = this.remoteStopInfo.reason || "killed by app";
+    return `task stopped by app: ${reason}`;
+  }
+
+  async requestStopFromRemote(event = {}) {
+    const taskId = typeof event.taskId === "string" ? event.taskId.trim() : "";
+    if (taskId && taskId !== this.taskId) {
+      return;
+    }
+    const requestId = typeof event.requestId === "string" ? event.requestId.trim() : "";
+    const reason = typeof event.reason === "string" ? event.reason.trim() : "";
+    if (!this.remoteStopInfo) {
+      this.remoteStopInfo = {
+        requestId: requestId || null,
+        reason: reason || null,
+      };
+      log(
+        `Received stop_task for ${this.taskId}${
+          reason ? ` (${reason})` : ""
+        }; stopping conductor fire`,
+      );
+    }
+    this.stopped = true;
+    if (typeof this.backendSession?.close === "function") {
+      try {
+        await this.backendSession.close();
+      } catch (error) {
+        log(`Failed to stop backend session for ${this.taskId}: ${error?.message || error}`);
+      }
+    }
+  }
+
   async recoverAfterReconnect() {
     if (!this.needsReconnectRecovery) {
       return;
@@ -1114,23 +1621,68 @@ class BridgeRunner {
     await this.replayLastRuntimeStatus();
   }
 
+  async drainBufferedMessagesForResume() {
+    let drainedCount = 0;
+    let drainedBatches = 0;
+
+    while (!this.stopped) {
+      const result = await this.conductor.receiveMessages(this.taskId, 50);
+      const messages = Array.isArray(result?.messages) ? result.messages : [];
+      if (messages.length === 0) {
+        break;
+      }
+
+      drainedBatches += 1;
+      for (const message of messages) {
+        const replyTo = message?.message_id ? String(message.message_id) : "";
+        if (replyTo) {
+          this.processedMessageIds.add(replyTo);
+        }
+        drainedCount += 1;
+      }
+
+      const ackToken = result.next_ack_token || result.nextAckToken;
+      if (ackToken) {
+        await this.conductor.ackMessages(this.taskId, ackToken);
+      }
+    }
+
+    if (drainedCount > 0) {
+      log(
+        `Resume startup skipped ${drainedCount} buffered message(s) in ${drainedBatches} batch(es) for task ${this.taskId}`,
+      );
+    } else {
+      this.copilotLog("resume startup found no buffered messages to skip");
+    }
+  }
+
   async processIncomingBatch() {
     const result = await this.conductor.receiveMessages(this.taskId, 20);
     const messages = Array.isArray(result?.messages) ? result.messages : [];
     if (messages.length === 0) {
       return false;
     }
+    const ackToken = result.next_ack_token || result.nextAckToken;
+    this.copilotLog(
+      `received batch size=${messages.length} hasMore=${Boolean(result?.has_more)} ackToken=${ackToken ? "yes" : "no"} roles=${messages
+        .map((item) => String(item?.role || "unknown").toLowerCase())
+        .join(",")}`,
+    );
 
     for (const message of messages) {
+      if (this.stopped) {
+        break;
+      }
       if (!this.shouldRespond(message)) {
+        this.copilotLog(`skip message role=${String(message?.role || "unknown").toLowerCase()}`);
         continue;
       }
       await this.respondToMessage(message);
     }
 
-    const ackToken = result.next_ack_token || result.nextAckToken;
     if (ackToken) {
       await this.conductor.ackMessages(this.taskId, ackToken);
+      this.copilotLog(`acked batch ackToken=${truncateText(String(ackToken), 40)}`);
     }
     const hasMore = Boolean(result?.has_more);
     return hasMore;
@@ -1148,6 +1700,7 @@ class BridgeRunner {
     const backendUrl = process.env.CONDUCTOR_BACKEND_URL;
     const token = process.env.CONDUCTOR_AGENT_TOKEN;
     if (!backendUrl || !token) {
+      this.copilotLog("skip backfill: missing backend url or token");
       return;
     }
 
@@ -1163,10 +1716,12 @@ class BridgeRunner {
         },
       );
       if (!response.ok) {
+        this.copilotLog(`backfill request failed status=${response.status}`);
         return;
       }
       const history = await response.json();
       if (!Array.isArray(history) || history.length === 0) {
+        this.copilotLog("backfill: no history messages");
         return;
       }
 
@@ -1178,12 +1733,41 @@ class BridgeRunner {
         }
       }
 
+      const historyUserIds = history
+        .filter((item) => String(item?.role || "").toLowerCase() === "user")
+        .map((item) => (item?.id ? String(item.id) : ""))
+        .filter(Boolean);
+
+      const handledUserIds = history
+        .slice(0, lastSdkIndex + 1)
+        .filter((item) => String(item?.role || "").toLowerCase() === "user")
+        .map((item) => (item?.id ? String(item.id) : ""))
+        .filter(Boolean);
+
+      for (const handledId of handledUserIds) {
+        this.processedMessageIds.add(handledId);
+      }
+
       const pendingUserMessages = history
         .slice(lastSdkIndex + 1)
         .filter((item) => String(item?.role || "").toLowerCase() === "user")
         .filter((item) => typeof item?.content === "string" && item.content.trim());
 
+      if (this.resumeMode) {
+        for (const historyId of historyUserIds) {
+          this.processedMessageIds.add(historyId);
+        }
+        this.copilotLog(
+          `resume mode: seeded processed ids=${historyUserIds.length}, skip startup backfill replay`,
+        );
+        return;
+      }
+      this.copilotLog(
+        `backfill loaded history=${history.length} handledUsers=${handledUserIds.length} pendingUsers=${pendingUserMessages.length} lastSdkIndex=${lastSdkIndex}`,
+      );
+
       for (const pending of pendingUserMessages) {
+        this.copilotLog(`backfill replay message id=${pending.id ? String(pending.id) : "unknown"}`);
         await this.respondToMessage({
           message_id: pending.id ? String(pending.id) : undefined,
           role: "user",
@@ -1238,6 +1822,11 @@ class BridgeRunner {
     this.lastRuntimeStatusPayload = {
       ...runtime,
     };
+    this.copilotLog(
+      `runtime replyTo=${replyTo || "latest"} state=${runtime.state || ""} phase=${runtime.phase || ""} inProgress=${Boolean(
+        runtime.reply_in_progress,
+      )} status="${sanitizeForLog(runtime.status_line || "", 120)}" done="${sanitizeForLog(runtime.status_done_line || "", 120)}" preview="${sanitizeForLog(runtime.reply_preview || "", 120)}"`,
+    );
 
     try {
       await this.conductor.sendRuntimeStatus(this.taskId, {
@@ -1266,14 +1855,32 @@ class BridgeRunner {
   async respondToMessage(message) {
     const content = String(message.content || "").trim();
     if (!content) {
+      this.copilotLog(`skip empty message replyTo=${message?.message_id || "latest"}`);
       return;
     }
     const replyTo = message.message_id;
     if (replyTo && this.processedMessageIds.has(replyTo)) {
+      this.copilotLog(`skip duplicated message replyTo=${replyTo}`);
       return;
     }
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
+    const turnStartedAt = Date.now();
+    let turnWatchdog = null;
+    if (this.isCopilotBackend) {
+      turnWatchdog = setInterval(() => {
+        const runtime = this.lastRuntimeStatusPayload || {};
+        this.copilotLog(
+          `turn waiting replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} state=${runtime.state || ""} phase=${runtime.phase || ""} status="${sanitizeForLog(runtime.status_line || runtime.status_done_line || "", 120)}"`,
+        );
+      }, 30000);
+      if (typeof turnWatchdog.unref === "function") {
+        turnWatchdog.unref();
+      }
+    }
+    this.copilotLog(
+      `turn start replyTo=${replyTo || "latest"} role=${String(message.role || "").toLowerCase()} contentLen=${content.length} preview="${sanitizeForLog(content, 120)}"`,
+    );
     log(`Processing message ${replyTo} (${message.role})`);
     try {
       await this.reportRuntimeStatus(
@@ -1291,6 +1898,11 @@ class BridgeRunner {
           void this.reportRuntimeStatus(payload, replyTo);
         },
       });
+      this.copilotLog(
+        `runTurn completed replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} answerLen=${String(
+          result.text || "",
+        ).trim().length} items=${Array.isArray(result.items) ? result.items.length : 0}`,
+      );
 
       await this.reportRuntimeStatus(
         {
@@ -1320,8 +1932,18 @@ class BridgeRunner {
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
+      this.copilotLog(`sdk_message sent replyTo=${replyTo || "latest"} responseLen=${responseText.length}`);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
+      if (this.stopped && (this.remoteStopInfo || isSessionClosedError(error))) {
+        this.copilotLog(
+          `turn interrupted by stop_task replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt}`,
+        );
+        return;
+      }
+      this.copilotLog(
+        `turn failed replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} error="${sanitizeForLog(errorMessage, 200)}"`,
+      );
       await this.reportRuntimeStatus(
         {
           state: "ERROR",
@@ -1333,6 +1955,12 @@ class BridgeRunner {
       );
       await this.reportError(`${this.backendName} 处理失败: ${errorMessage}`, replyTo);
     } finally {
+      if (turnWatchdog) {
+        clearInterval(turnWatchdog);
+      }
+      this.copilotLog(
+        `turn end replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} processedIds=${this.processedMessageIds.size}`,
+      );
       this.runningTurn = false;
     }
   }
@@ -1340,6 +1968,8 @@ class BridgeRunner {
   async handleSyntheticMessage(content, { includeImages }) {
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
+    const startedAt = Date.now();
+    this.copilotLog(`synthetic turn start includeImages=${Boolean(includeImages)} contentLen=${String(content || "").length}`);
     try {
       const result = await this.backendSession.runTurn(content, {
         useInitialImages: includeImages,
@@ -1347,6 +1977,9 @@ class BridgeRunner {
           void this.reportRuntimeStatus(payload, "initial");
         },
       });
+      this.copilotLog(
+        `synthetic runTurn completed elapsedMs=${Date.now() - startedAt} answerLen=${String(result.text || "").trim().length}`,
+      );
       const backendLabel = this.backendName.charAt(0).toUpperCase() + this.backendName.slice(1);
       const intro = `${backendLabel} 已根据初始提示给出回复：`;
       const replyText =
@@ -1364,9 +1997,18 @@ class BridgeRunner {
         cli_args: this.cliArgs,
         synthetic: true,
       });
+      this.copilotLog(`synthetic sdk_message sent responseLen=${text.length}`);
     } catch (error) {
+      if (this.stopped && (this.remoteStopInfo || isSessionClosedError(error))) {
+        this.copilotLog(`synthetic turn interrupted by stop_task elapsedMs=${Date.now() - startedAt}`);
+        return;
+      }
+      this.copilotLog(
+        `synthetic turn failed elapsedMs=${Date.now() - startedAt} error="${sanitizeForLog(error?.message || error, 200)}"`,
+      );
       await this.reportError(`初始提示执行失败: ${error.message}`);
     } finally {
+      this.copilotLog(`synthetic turn end elapsedMs=${Date.now() - startedAt}`);
       this.runningTurn = false;
     }
   }
@@ -1424,7 +2066,9 @@ function extractAgentTextFromMetadata(metadata) {
 
 function log(message) {
   const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-  process.stdout.write(`[${CLI_NAME} ${ts}] ${message}\n`);
+  const line = `[${CLI_NAME} ${ts}] ${message}\n`;
+  process.stdout.write(line);
+  appendFireLocalLog(line);
 }
 
 function logBackendReply(backend, text, { usage, replyTo }) {
@@ -1432,6 +2076,22 @@ function logBackendReply(backend, text, { usage, replyTo }) {
   log(`${backend} reply (${replyTo}): ${text}${usageSuffix}`);
 }
 
+export function formatFatalError(error, opts = {}) {
+  const showStack =
+    typeof opts.showStack === "boolean"
+      ? opts.showStack
+      : isTruthyEnv(process.env.CONDUCTOR_CLI_SHOW_STACK) ||
+        isTruthyEnv(process.env.CONDUCTOR_DEBUG);
+  const message = error instanceof Error ? error.message : String(error);
+  if (!showStack) {
+    return message;
+  }
+  if (error instanceof Error && typeof error.stack === "string" && error.stack.trim()) {
+    return error.stack;
+  }
+  return message;
+}
+
 function isDirectRun() {
   try {
     if (!process.argv[1]) {
@@ -1448,7 +2108,9 @@ function isDirectRun() {
 if (isDirectRun()) {
   main().catch((error) => {
     const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-    process.stderr.write(`[${CLI_NAME} ${ts}] failed: ${error.stack || error.message}\n`);
+    const line = `[${CLI_NAME} ${ts}] failed: ${formatFatalError(error)}\n`;
+    process.stderr.write(line);
+    appendFireLocalLog(line);
     process.exitCode = 1;
   });
 }