@love-moon/conductor-cli 0.2.11 → 0.2.13

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,18 +20,13 @@ 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 FIRE_LOG_PATH = path.join(CLI_PROJECT_PATH, "conductor.log");
+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"));
@@ -107,6 +103,12 @@ const DEFAULT_POLL_INTERVAL_MS = parseInt(
   process.env.CONDUCTOR_CLI_POLL_INTERVAL_MS || process.env.CCODEX_POLL_INTERVAL_MS || "2000",
   10,
 );
+const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
+const MIN_TURN_DEADLINE_MS = 30 * 1000;
+const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
+const DEFAULT_ERROR_LOOP_WINDOW_MS = 2 * 60 * 1000;
+const DEFAULT_ERROR_LOOP_BACKOFF_MS = 3 * 60 * 1000;
+const DEFAULT_ERROR_LOOP_THRESHOLD = 3;
 
 function appendFireLocalLog(line) {
   if (!ENABLE_FIRE_LOCAL_LOG) {
@@ -121,6 +123,7 @@ function appendFireLocalLog(line) {
 
 async function main() {
   const cliArgs = parseCliArgs();
+  let runtimeProjectPath = process.cwd();
 
   if (cliArgs.showHelp) {
     return;
@@ -147,48 +150,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,
   });
 
@@ -198,6 +175,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;
 
@@ -234,6 +212,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;
   }
@@ -252,111 +245,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}`);
+      }
     }
   }
 }
@@ -374,6 +415,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);
@@ -381,12 +481,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);
@@ -419,15 +522,9 @@ export function parseCliArgs(argvInput = process.argv) {
       type: "string",
       describe: "Optional task title shown in the app task list",
     })
-    .option("from", {
-      alias: "f",
+    .option("resume", {
       type: "string",
-      describe: "Resume from local history (optional session id; otherwise pick interactively)",
-    })
-    .option("from-provider", {
-      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",
@@ -460,8 +557,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
 
@@ -475,6 +571,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"
 
@@ -504,11 +601,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 {
@@ -517,22 +616,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 [];
@@ -655,6 +766,7 @@ function deriveTaskTitle(prompt, explicit, backend = "codex") {
 
 const BACKEND_PROFILE_MAP = {
   codex: "codex",
+  code: "codex",
   claude: "claude-code",
   "claude-code": "claude-code",
   copilot: "copilot",
@@ -677,6 +789,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();
@@ -690,11 +1024,48 @@ 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);
 }
 
+function getBoundedEnvInt(envName, fallback, min, max) {
+  const fallbackNumber = Number(fallback);
+  const normalizedFallback = Number.isFinite(fallbackNumber)
+    ? Math.min(Math.max(Math.round(fallbackNumber), min), max)
+    : min;
+  const raw = process.env[envName];
+  const parsed = Number.parseInt(String(raw ?? ""), 10);
+  if (!Number.isFinite(parsed)) {
+    return normalizedFallback;
+  }
+  return Math.min(Math.max(parsed, min), max);
+}
+
+function normalizeExecutionErrorKey(errorMessage) {
+  const normalized = sanitizeForLog(errorMessage, 280).toLowerCase();
+  if (!normalized) {
+    return "unknown_error";
+  }
+  if (normalized.includes("pty session already spawned")) {
+    return "pty_session_already_spawned";
+  }
+  if (normalized.includes("tui process has exited")) {
+    return "tui_process_exited";
+  }
+  if (normalized.includes("cannot proceed: tui process has exited")) {
+    return "cannot_proceed_tui_exited";
+  }
+  if (normalized.includes("turn exceeded hard deadline")) {
+    return "turn_timeout";
+  }
+  return normalized;
+}
+
 function tailLines(value, count = 6) {
   if (!value) return "";
   const lines = String(value).split(/\r?\n/);
@@ -705,9 +1076,15 @@ 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;
+    this.sessionInfo = null;
 
     const allowCliList = options.configFile ? loadAllowCliList(options.configFile) : DEFAULT_ALLOW_CLI_LIST;
     const cliCommand = CUSTOM_CLI_COMMAND || allowCliList[backend] || backend;
@@ -715,8 +1092,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))
@@ -725,6 +1103,15 @@ class TuiDriverSession {
     this.lastSignalSignature = "";
     this.lastPollSignature = "";
     this.lastSnapshotHash = "";
+    this.closeRequested = false;
+    this.closed = false;
+    this.closeWaiters = new Set();
+    this.turnDeadlineMs = getBoundedEnvInt(
+      "CONDUCTOR_TURN_DEADLINE_MS",
+      DEFAULT_TURN_DEADLINE_MS,
+      MIN_TURN_DEADLINE_MS,
+      MAX_TURN_DEADLINE_MS,
+    );
 
     const profileName = profileNameForBackend(backend);
     if (!profileName) {
@@ -745,7 +1132,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)}`,
@@ -766,6 +1153,7 @@ class TuiDriverSession {
           ...cliEnv,
         },
       },
+      cwd: this.cwd,
       debug: this.tuiDebug,
       onSnapshot: this.tuiTrace
         ? (snapshot, state) => {
@@ -787,6 +1175,10 @@ class TuiDriverSession {
       }
       log(`[${this.backend}] [WARN] Please run "${this.command} login" or authenticate manually.`);
     });
+
+    this.driver.on("session", (session) => {
+      this.applySessionInfo(session);
+    });
   }
 
   get threadId() {
@@ -797,7 +1189,157 @@ class TuiDriverSession {
     return { model: this.backend };
   }
 
+  applySessionInfo(session) {
+    if (!session || typeof session !== "object") {
+      return;
+    }
+    const sessionId = typeof session.sessionId === "string" ? session.sessionId.trim() : "";
+    const sessionFilePath =
+      typeof session.sessionFilePath === "string" ? session.sessionFilePath.trim() : "";
+    if (!sessionId) {
+      return;
+    }
+    this.sessionId = sessionId;
+    this.sessionInfo = {
+      backend: this.backend,
+      sessionId,
+      sessionFilePath: sessionFilePath || undefined,
+    };
+    this.trace(
+      `session id=${sessionId} file="${sanitizeForLog(sessionFilePath, 180)}"`,
+    );
+  }
+
+  getSessionInfo() {
+    if (this.sessionInfo) {
+      return { ...this.sessionInfo };
+    }
+    return null;
+  }
+
+  async ensureSessionInfo() {
+    if (!this.driver) {
+      return null;
+    }
+    try {
+      await this.driver.boot();
+    } catch (error) {
+      this.trace(`session boot failed: ${sanitizeForLog(error?.message || error, 180)}`);
+      return this.getSessionInfo();
+    }
+
+    try {
+      if (typeof this.driver.ensureSessionInfo === "function") {
+        const detected = await this.driver.ensureSessionInfo();
+        this.applySessionInfo(detected);
+      } else if (typeof this.driver.getSessionInfo === "function") {
+        this.applySessionInfo(this.driver.getSessionInfo());
+      }
+    } catch (error) {
+      this.trace(`session detect failed: ${sanitizeForLog(error?.message || error, 180)}`);
+    }
+
+    return this.getSessionInfo();
+  }
+
+  async getSessionUsageSummary() {
+    if (!this.driver || typeof this.driver.getSessionUsageSummary !== "function") {
+      return null;
+    }
+    try {
+      const summary = await this.driver.getSessionUsageSummary();
+      return summary && typeof summary === "object" ? summary : null;
+    } catch (error) {
+      this.trace(`session usage detect failed: ${sanitizeForLog(error?.message || error, 180)}`);
+      return null;
+    }
+  }
+
+  createSessionClosedError() {
+    const error = new Error("TUI session closed");
+    error.reason = "session_closed";
+    return error;
+  }
+
+  createTurnTimeoutError(timeoutMs) {
+    const seconds = Math.max(1, Math.round(timeoutMs / 1000));
+    const error = new Error(`Turn exceeded hard deadline (${seconds}s)`);
+    error.reason = "turn_timeout";
+    error.timeoutMs = timeoutMs;
+    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);
+        }
+      },
+    };
+  }
+
+  createTurnTimeoutGuard() {
+    if (!Number.isFinite(this.turnDeadlineMs) || this.turnDeadlineMs <= 0) {
+      return {
+        promise: new Promise(() => {}),
+        cleanup: () => {},
+      };
+    }
+    let timer = null;
+    const promise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(this.createTurnTimeoutError(this.turnDeadlineMs));
+      }, this.turnDeadlineMs);
+      if (typeof timer.unref === "function") {
+        timer.unref();
+      }
+    });
+    return {
+      promise,
+      cleanup: () => {
+        if (timer) {
+          clearTimeout(timer);
+        }
+      },
+    };
+  }
+
+  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();
     }
@@ -902,6 +1444,10 @@ class TuiDriverSession {
   }
 
   async runTurn(promptText, { useInitialImages = false, onProgress } = {}) {
+    if (this.closeRequested) {
+      throw this.createSessionClosedError();
+    }
+
     const effectivePrompt = this.buildPrompt(promptText, { useInitialImages });
     if (!effectivePrompt) {
       return {
@@ -958,8 +1504,20 @@ 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();
+    const turnTimeoutGuard = this.createTurnTimeoutGuard();
+
     try {
-      const result = await this.driver.ask(effectivePrompt);
+      const result = await Promise.race([this.driver.ask(effectivePrompt), closeGuard.promise, turnTimeoutGuard.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}`,
@@ -1003,9 +1561,28 @@ 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") {
+      if (errorReason === "turn_timeout") {
+        this.emitProgress(onProgress, {
+          state: "ERROR",
+          phase: "timeout_recovered",
+          source: "tui-driver",
+          error: errorMessage,
+          reason: errorReason,
+          timeout_ms: error?.timeoutMs,
+        });
+        log(`[${this.backend}] Turn timed out (${error?.timeoutMs || this.turnDeadlineMs}ms), restarting TUI session`);
+        try {
+          await this.driver.forceRestart();
+        } catch (restartError) {
+          log(`[${this.backend}] Failed to restart TUI after timeout: ${restartError?.message || restartError}`);
+        }
+        log(`[${this.backend}] Error: ${errorMessage}`);
+      } else if (errorReason === "login_required") {
         this.emitProgress(onProgress, {
           state: "ERROR",
           phase: "login_required",
@@ -1037,21 +1614,35 @@ 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);
+      turnTimeoutGuard.cleanup();
+      closeGuard.cleanup();
       this.trace(`runTurn cleanup state=${this.driver.state}`);
     }
   }
 }
 
-class BridgeRunner {
+export class BridgeRunner {
   constructor({
     backendSession,
     conductor,
@@ -1061,6 +1652,7 @@ class BridgeRunner {
     includeInitialImages,
     cliArgs,
     backendName,
+    resumeMode,
   }) {
     this.backendSession = backendSession;
     this.conductor = conductor;
@@ -1070,26 +1662,122 @@ 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.inFlightMessageIds = new Set();
     this.lastRuntimeStatusSignature = null;
     this.lastRuntimeStatusPayload = null;
+    this.runtimeContextSnapshot = null;
+    this.runtimeContextSnapshotAt = 0;
+    this.runtimeContextInFlight = null;
+    this.runtimeContextRefreshMs = getBoundedEnvInt(
+      "CONDUCTOR_RUNTIME_CONTEXT_REFRESH_MS",
+      2000,
+      500,
+      60 * 1000,
+    );
+    this.daemonName =
+      (typeof process.env.CONDUCTOR_AGENT_NAME === "string" && process.env.CONDUCTOR_AGENT_NAME.trim()) ||
+      (typeof process.env.CONDUCTOR_DAEMON_NAME === "string" && process.env.CONDUCTOR_DAEMON_NAME.trim()) ||
+      (typeof process.env.HOSTNAME === "string" && process.env.HOSTNAME.trim()) ||
+      os.hostname();
     this.needsReconnectRecovery = false;
+    this.remoteStopInfo = null;
+    this.sessionAnnouncementSent = false;
+    this.errorLoop = null;
+    this.errorLoopWindowMs = getBoundedEnvInt(
+      "CONDUCTOR_ERROR_LOOP_WINDOW_MS",
+      DEFAULT_ERROR_LOOP_WINDOW_MS,
+      15 * 1000,
+      30 * 60 * 1000,
+    );
+    this.errorLoopBackoffMs = getBoundedEnvInt(
+      "CONDUCTOR_ERROR_LOOP_BACKOFF_MS",
+      DEFAULT_ERROR_LOOP_BACKOFF_MS,
+      15 * 1000,
+      60 * 60 * 1000,
+    );
+    this.errorLoopThreshold = getBoundedEnvInt(
+      "CONDUCTOR_ERROR_LOOP_THRESHOLD",
+      DEFAULT_ERROR_LOOP_THRESHOLD,
+      2,
+      20,
+    );
   }
 
   copilotLog(message) {
-    if (!this.isCopilotBackend) {
+    if (!this.copilotDebug) {
       return;
     }
     log(`[copilot-debug] task=${this.taskId} ${message}`);
   }
 
+  async announceBackendSession() {
+    if (this.sessionAnnouncementSent) {
+      return;
+    }
+    if (!this.backendSession || typeof this.backendSession.ensureSessionInfo !== "function") {
+      return;
+    }
+    let sessionInfo = null;
+    try {
+      sessionInfo = await this.backendSession.ensureSessionInfo();
+    } catch (error) {
+      this.copilotLog(`session announce skipped: ${sanitizeForLog(error?.message || error, 160)}`);
+      return;
+    }
+    const sessionId = String(sessionInfo?.sessionId || "").trim();
+    const sessionFilePath = sessionInfo?.sessionFilePath ? String(sessionInfo.sessionFilePath).trim() : "";
+    const hasRealSessionId = Boolean(sessionId);
+    const message = hasRealSessionId
+      ? `${this.backendName} session started: ${sessionId}`
+      : `${this.backendName} session started`;
+    try {
+      await this.conductor.sendMessage(this.taskId, message, {
+        backend: this.backendName,
+        thread_id: hasRealSessionId ? sessionId : undefined,
+        session_id: hasRealSessionId ? sessionId : undefined,
+        session_file_path: sessionFilePath || undefined,
+        cli_args: this.cliArgs,
+        synthetic: true,
+      });
+      this.sessionAnnouncementSent = true;
+      this.copilotLog(hasRealSessionId ? `session announced id=${sessionId}` : "session announced without id");
+      await this.reportRuntimeStatus(
+        {
+          state: "WAIT_READY",
+          phase: "session_started",
+          source: "tui-driver",
+          reply_in_progress: false,
+          status_done_line: `${this.backendName} session started`,
+          backend: this.backendName,
+          thread_id: hasRealSessionId ? sessionId : undefined,
+        },
+        undefined,
+      );
+    } catch (error) {
+      log(`Failed to send session announcement: ${error?.message || error}`);
+    }
+  }
+
   async start(abortSignal) {
     abortSignal?.addEventListener("abort", () => {
       this.stopped = true;
     });
+    if (this.stopped) {
+      return;
+    }
+
+    await this.announceBackendSession();
+    if (this.stopped) {
+      return;
+    }
 
     if (this.initialPrompt) {
       this.copilotLog("processing initial prompt");
@@ -1097,8 +1785,20 @@ class BridgeRunner {
         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) {
@@ -1108,10 +1808,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);
       }
     }
@@ -1121,6 +1824,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;
@@ -1137,6 +1876,41 @@ 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 : [];
@@ -1151,6 +1925,9 @@ class BridgeRunner {
     );
 
     for (const message of messages) {
+      if (this.stopped) {
+        break;
+      }
       if (!this.shouldRespond(message)) {
         this.copilotLog(`skip message role=${String(message?.role || "unknown").toLowerCase()}`);
         continue;
@@ -1211,12 +1988,37 @@ 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} pendingUsers=${pendingUserMessages.length} lastSdkIndex=${lastSdkIndex}`,
+        `backfill loaded history=${history.length} handledUsers=${handledUserIds.length} pendingUsers=${pendingUserMessages.length} lastSdkIndex=${lastSdkIndex}`,
       );
 
       for (const pending of pendingUserMessages) {
@@ -1232,7 +2034,80 @@ class BridgeRunner {
     }
   }
 
-  createRuntimeStatus(payload, replyTo) {
+  normalizePercent(value) {
+    if (!Number.isFinite(value)) {
+      return undefined;
+    }
+    if (value < 0) {
+      return 0;
+    }
+    if (value > 100) {
+      return 100;
+    }
+    return value;
+  }
+
+  async resolveRuntimeContext() {
+    const now = Date.now();
+    if (
+      this.runtimeContextSnapshot &&
+      now - this.runtimeContextSnapshotAt < this.runtimeContextRefreshMs
+    ) {
+      return this.runtimeContextSnapshot;
+    }
+    if (this.runtimeContextInFlight) {
+      return this.runtimeContextInFlight;
+    }
+
+    this.runtimeContextInFlight = (async () => {
+      let sessionInfo = null;
+      try {
+        if (typeof this.backendSession?.getSessionInfo === "function") {
+          sessionInfo = this.backendSession.getSessionInfo();
+        }
+      } catch {
+        sessionInfo = null;
+      }
+
+      let usage = null;
+      try {
+        if (typeof this.backendSession?.getSessionUsageSummary === "function") {
+          usage = await this.backendSession.getSessionUsageSummary();
+        }
+      } catch {
+        usage = null;
+      }
+
+      const resolvedSessionId = String(
+        usage?.sessionId || sessionInfo?.sessionId || "",
+      ).trim();
+      const resolvedSessionFilePath = String(
+        usage?.sessionFilePath || sessionInfo?.sessionFilePath || "",
+      ).trim();
+      const tokenUsagePercent = this.normalizePercent(Number(usage?.tokenUsagePercent));
+      const contextUsagePercent = this.normalizePercent(Number(usage?.contextUsagePercent));
+
+      const snapshot = {
+        daemon: this.daemonName || undefined,
+        pid: process.pid,
+        session_id: resolvedSessionId || undefined,
+        session_file_path: resolvedSessionFilePath || undefined,
+        token_usage_percent: tokenUsagePercent,
+        context_usage_percent: contextUsagePercent,
+      };
+      this.runtimeContextSnapshot = snapshot;
+      this.runtimeContextSnapshotAt = Date.now();
+      return snapshot;
+    })();
+
+    try {
+      return await this.runtimeContextInFlight;
+    } finally {
+      this.runtimeContextInFlight = null;
+    }
+  }
+
+  createRuntimeStatus(payload, replyTo, runtimeContext = null) {
     if (!payload || typeof payload !== "object") {
       return null;
     }
@@ -1257,12 +2132,22 @@ class BridgeRunner {
       reply_preview: truncateText(replyPreview, 240) || undefined,
       reply_to: replyTo,
       backend: this.backendName,
-      thread_id: this.backendSession.threadId,
+      thread_id:
+        String(
+          payload.thread_id || runtimeContext?.session_id || "",
+        ).trim() || undefined,
+      daemon: runtimeContext?.daemon,
+      pid: runtimeContext?.pid,
+      session_id: runtimeContext?.session_id,
+      session_file_path: runtimeContext?.session_file_path,
+      token_usage_percent: runtimeContext?.token_usage_percent,
+      context_usage_percent: runtimeContext?.context_usage_percent,
     };
   }
 
   async reportRuntimeStatus(payload, replyTo) {
-    const runtime = this.createRuntimeStatus(payload, replyTo);
+    const runtimeContext = await this.resolveRuntimeContext();
+    const runtime = this.createRuntimeStatus(payload, replyTo, runtimeContext);
     if (!runtime) {
       return;
     }
@@ -1305,6 +2190,67 @@ class BridgeRunner {
     }
   }
 
+  resetErrorLoop() {
+    this.errorLoop = null;
+  }
+
+  evaluateErrorLoop(errorMessage) {
+    const normalizedKey = normalizeExecutionErrorKey(errorMessage);
+    const now = Date.now();
+    const current = this.errorLoop;
+
+    if (
+      !current ||
+      current.key !== normalizedKey ||
+      now - current.lastAt > this.errorLoopWindowMs
+    ) {
+      this.errorLoop = {
+        key: normalizedKey,
+        count: 1,
+        lastAt: now,
+        cooldownUntil: 0,
+      };
+      return {
+        key: normalizedKey,
+        count: 1,
+        open: false,
+        suppressReport: false,
+        cooldownMs: 0,
+      };
+    }
+
+    current.count += 1;
+    current.lastAt = now;
+    const open = current.count >= this.errorLoopThreshold;
+    let suppressReport = false;
+
+    if (open) {
+      if (current.cooldownUntil > now) {
+        suppressReport = true;
+      } else {
+        current.cooldownUntil = now + this.errorLoopBackoffMs;
+      }
+    }
+
+    this.errorLoop = current;
+    return {
+      key: normalizedKey,
+      count: current.count,
+      open,
+      suppressReport,
+      cooldownMs: suppressReport ? current.cooldownUntil - now : 0,
+    };
+  }
+
+  isExecutionFailureLoopError(errorMessage) {
+    const normalized = String(errorMessage || "").toLowerCase();
+    return (
+      normalized.includes("pty session already spawned") ||
+      normalized.includes("tui process has exited") ||
+      normalized.includes("cannot proceed: tui process has exited")
+    );
+  }
+
   async respondToMessage(message) {
     const content = String(message.content || "").trim();
     if (!content) {
@@ -1316,6 +2262,13 @@ class BridgeRunner {
       this.copilotLog(`skip duplicated message replyTo=${replyTo}`);
       return;
     }
+    if (replyTo && this.inFlightMessageIds.has(replyTo)) {
+      this.copilotLog(`skip in-flight duplicated message replyTo=${replyTo}`);
+      return;
+    }
+    if (replyTo) {
+      this.inFlightMessageIds.add(replyTo);
+    }
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
     const turnStartedAt = Date.now();
@@ -1385,9 +2338,16 @@ class BridgeRunner {
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
+      this.resetErrorLoop();
       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)}"`,
       );
@@ -1400,11 +2360,48 @@ class BridgeRunner {
         },
         replyTo,
       );
-      await this.reportError(`${this.backendName} 处理失败: ${errorMessage}`, replyTo);
+      const isExecutionFailure = this.isExecutionFailureLoopError(errorMessage);
+      const loopState = isExecutionFailure
+        ? this.evaluateErrorLoop(errorMessage)
+        : {
+            key: "non_execution_error",
+            count: 1,
+            open: false,
+            suppressReport: false,
+            cooldownMs: 0,
+          };
+      if (!isExecutionFailure) {
+        this.resetErrorLoop();
+      }
+      const executionFailureLoop = isExecutionFailure && loopState.open;
+      if (executionFailureLoop) {
+        await this.reportRuntimeStatus(
+          {
+            state: "ERROR",
+            phase: "execution_failure_loop",
+            reply_in_progress: false,
+            status_done_line: `${this.backendName} execution_failure_loop`,
+          },
+          replyTo,
+        );
+      }
+      if (isExecutionFailure && loopState.suppressReport) {
+        this.copilotLog(
+          `suppress repeated error report key=${loopState.key} count=${loopState.count} cooldownMs=${loopState.cooldownMs}`,
+        );
+        return;
+      }
+      const reportMessage = executionFailureLoop
+        ? `${this.backendName} 执行层失败循环(${loopState.key}, 连续${loopState.count}次): ${errorMessage}`
+        : `${this.backendName} 处理失败: ${errorMessage}`;
+      await this.reportError(reportMessage, replyTo);
     } finally {
       if (turnWatchdog) {
         clearInterval(turnWatchdog);
       }
+      if (replyTo) {
+        this.inFlightMessageIds.delete(replyTo);
+      }
       this.copilotLog(
         `turn end replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} processedIds=${this.processedMessageIds.size}`,
       );
@@ -1446,6 +2443,10 @@ class BridgeRunner {
       });
       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)}"`,
       );
@@ -1519,6 +2520,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]) {
@@ -1535,7 +2552,7 @@ function isDirectRun() {
 if (isDirectRun()) {
   main().catch((error) => {
     const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-    const line = `[${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;