@love-moon/conductor-cli 0.2.15 → 0.2.16

package/bin/conductor-fire.js

@@ -12,16 +12,20 @@ import { createHash } from "node:crypto";
 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";
 
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import yaml from "js-yaml";
-import { TuiDriver, claudeCodeProfile, codexProfile, copilotProfile } from "@love-moon/tui-driver";
+import { createAiSession } from "@love-moon/ai-sdk";
 import { ConductorClient, loadConfig } from "@love-moon/conductor-sdk";
-import { findSessionPath } from "../src/fire/history.js";
+import {
+  buildResumeArgsForBackend as buildCliResumeArgsForBackend,
+  resolveResumeContext as resolveCliResumeContext,
+  resolveSessionRunDirectory as resolveCliSessionRunDirectory,
+  resumeProviderForBackend as resumeProviderForCliBackend,
+} from "../src/fire/resume.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -54,59 +58,10 @@ function loadAllowCliList(configFilePath) {
   return {};
 }
 
-// Load envs config from config file
-function loadEnvConfig(configFilePath) {
-  try {
-    const home = os.homedir();
-    const configPath = configFilePath || process.env.CONDUCTOR_CONFIG || path.join(home, ".conductor", "config.yaml");
-    if (fs.existsSync(configPath)) {
-      const content = fs.readFileSync(configPath, "utf8");
-      const parsed = yaml.load(content);
-      if (parsed && typeof parsed === "object" && parsed.envs) {
-        return parsed.envs;
-      }
-    }
-  } catch (error) {
-    // ignore error
-  }
-  return null;
-}
-
-// Convert proxy env values to standard proxy environment variables
-function proxyToEnv(envConfig) {
-  if (!envConfig || typeof envConfig !== "object") {
-    return {};
-  }
-  const env = {};
-  // Support both snake_case and lowercase keys
-  const mappings = {
-    http_proxy: ["HTTP_PROXY", "http_proxy"],
-    https_proxy: ["HTTPS_PROXY", "https_proxy"],
-    all_proxy: ["ALL_PROXY", "all_proxy"],
-    no_proxy: ["NO_PROXY", "no_proxy"],
-  };
-  for (const [key, envKeys] of Object.entries(mappings)) {
-    const value = envConfig[key] || envConfig[key.toUpperCase()];
-    if (value) {
-      for (const envKey of envKeys) {
-        env[envKey] = value;
-      }
-    }
-  }
-  return env;
-}
-
-// Get CLI command from environment variable (set by daemon) or from config
-const CUSTOM_CLI_COMMAND = process.env.CONDUCTOR_CLI_COMMAND;
-const DEFAULT_ALLOW_CLI_LIST = loadAllowCliList();
-
 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;
@@ -368,32 +323,14 @@ async function main() {
       }
     }
 
-    let resolvedResumeSessionId = cliArgs.resumeSessionId;
-    if (!resolvedResumeSessionId) {
-      try {
-        const localTaskRecord = await conductor.getLocalTaskRecord({
-          task_id: taskContext.taskId,
-        });
-        const taskSessionFilePath = typeof localTaskRecord?.session_file_path === "string"
-          ? localTaskRecord.session_file_path.trim()
-          : "";
-        const taskSessionId = typeof localTaskRecord?.session_id === "string"
-          ? localTaskRecord.session_id.trim()
-          : "";
-        if (taskSessionId && taskSessionFilePath) {
-          resolvedResumeSessionId = taskSessionId;
-          log(`Using bound session ${taskSessionId} for task ${taskContext.taskId}`);
-        }
-      } catch {
-        // no local task binding yet; start a fresh backend session
-      }
-    }
+    const resolvedResumeSessionId = cliArgs.resumeSessionId;
 
-    backendSession = new TuiDriverSession(cliArgs.backend, {
+    backendSession = createAiSession(cliArgs.backend, {
       initialImages: cliArgs.initialImages,
       cwd: runtimeProjectPath,
       resumeSessionId: resolvedResumeSessionId,
       configFile: cliArgs.configFile,
+      logger: { log },
     });
 
     log(`Using backend: ${cliArgs.backend}`);
@@ -417,7 +354,7 @@ async function main() {
       includeInitialImages: Boolean(cliArgs.initialPrompt && cliArgs.initialImages.length),
       cliArgs: cliArgs.rawBackendArgs,
       backendName: cliArgs.backend,
-      resumeMode: Boolean(resolvedResumeSessionId),
+      resumeSessionId: resolvedResumeSessionId,
       daemonName: configuredDaemonName,
     });
     reconnectRunner = runner;
@@ -897,75 +834,16 @@ function deriveTaskTitle(prompt, explicit, backend = "codex") {
   return `${backendName} Task`;
 }
 
-const BACKEND_PROFILE_MAP = {
-  codex: "codex",
-  code: "codex",
-  claude: "claude-code",
-  "claude-code": "claude-code",
-  copilot: "copilot",
-};
-
-function profileNameForBackend(backend) {
-  const normalized = String(backend || "").trim().toLowerCase();
-  return BACKEND_PROFILE_MAP[normalized] || null;
-}
-
-function parseCommandParts(commandLine) {
-  const normalized = String(commandLine || "").trim();
-  if (!normalized) {
-    return { command: "", args: [] };
-  }
-  const parts = normalized.split(/\s+/);
-  return {
-    command: parts[0],
-    args: parts.slice(1),
-  };
-}
-
 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}"`);
+  return buildCliResumeArgsForBackend(backend, sessionId);
 }
 
 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;
+  return resumeProviderForCliBackend(backend);
 }
 
 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);
+  return resolveCliSessionRunDirectory(sessionPath);
 }
 
 async function isExistingDirectory(targetPath) {
@@ -981,151 +859,8 @@ async function isExistingDirectory(targetPath) {
   }
 }
 
-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,
-  };
+  return resolveCliResumeContext(backend, sessionId, options);
 }
 
 export async function applyWorkingDirectory(targetPath) {
@@ -1199,866 +934,6 @@ function normalizeExecutionErrorKey(errorMessage) {
   return normalized;
 }
 
-function tailLines(value, count = 6) {
-  if (!value) return "";
-  const lines = String(value).split(/\r?\n/);
-  return lines.slice(Math.max(0, lines.length - Math.max(1, count))).join("\n");
-}
-
-class TuiDriverSession {
-  constructor(backend, options = {}) {
-    this.backend = backend;
-    this.options = options;
-    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;
-    const { command, args } = parseCommandParts(cliCommand);
-    if (!command) {
-      throw new Error(`Invalid command for backend "${backend}"`);
-    }
-    const resumeArgs = buildResumeArgsForBackend(backend, resumeSessionId);
-    this.command = command;
-    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))
-      ? Math.max(2, Number.parseInt(process.env.CONDUCTOR_TUI_TRACE_LINES, 10))
-      : 8;
-    this.lastSignalSignature = "";
-    this.lastPollSignature = "";
-    this.lastSnapshotHash = "";
-    this.closeRequested = false;
-    this.closed = false;
-    this.closeWaiters = new Set();
-    this.sessionMessageHandler = null;
-    this.sessionMonitorPromise = null;
-    this.sessionMonitorStopRequested = false;
-    this.sessionMonitorCursor = 0;
-    this.sessionMonitorSessionId = "";
-    this.sessionMonitorSessionFilePath = "";
-    this.sessionMonitorActiveReplyTo = "";
-    this.sessionMonitorHasActiveReplyTarget = false;
-    this.sessionMonitorLastReplyTo = "";
-    this.sessionMonitorAwaitingFirstReply = false;
-    this.workingStatusHandler = null;
-    this.workingStatusMonitorPromise = null;
-    this.workingStatusMonitorStopRequested = false;
-    this.lastReportedWorkingStatusLine = "";
-    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) {
-      throw new Error(`Backend "${backend}" is not supported by tui-driver`);
-    }
-    this.useSessionFileReplyStream =
-      profileName === "codex" || profileName === "copilot";
-    this.sessionMonitorFastPollMs = getBoundedEnvInt(
-      "CONDUCTOR_CODEX_SESSION_FAST_POLL_MS",
-      700,
-      100,
-      10 * 1000,
-    );
-    this.sessionMonitorSlowPollMs = getBoundedEnvInt(
-      "CONDUCTOR_CODEX_SESSION_SLOW_POLL_MS",
-      2500,
-      300,
-      60 * 1000,
-    );
-    this.workingStatusPollMs = getBoundedEnvInt(
-      "CONDUCTOR_CODEX_TUI_STATUS_POLL_MS",
-      700,
-      100,
-      10 * 1000,
-    );
-
-    const profileMap = {
-      codex: codexProfile,
-      "claude-code": claudeCodeProfile,
-      copilot: copilotProfile,
-    };
-    const baseProfile = profileMap[profileName];
-    const effectiveDriverArgs = [...(baseProfile.args || []), ...this.args];
-    const envConfig = loadEnvConfig(options.configFile);
-    const proxyEnv = proxyToEnv(envConfig);
-    const cliEnv = envConfig && typeof envConfig === "object" ? { ...envConfig, ...proxyEnv } : proxyEnv;
-
-    if (Object.keys(proxyEnv).length > 0) {
-      log(`Using proxy: ${proxyEnv.http_proxy || proxyEnv.https_proxy || proxyEnv.all_proxy}`);
-    }
-
-    log(`Using TUI command for ${backend}: ${[this.command, ...effectiveDriverArgs].join(" ")} (cwd: ${this.cwd})`);
-    if (this.tuiTrace) {
-      log(
-        `[${this.backend}] [tui-trace] profile=${baseProfile.name} command=${this.command} args=${JSON.stringify(effectiveDriverArgs)}`,
-      );
-      log(
-        `[${this.backend}] [tui-trace] timeouts=${JSON.stringify(baseProfile.timeouts || {})} size=${baseProfile.cols || 120}x${baseProfile.rows || 40}`,
-      );
-    }
-
-    this.driver = new TuiDriver({
-      profile: {
-        ...baseProfile,
-        command: this.command,
-        args: effectiveDriverArgs,
-        env: {
-          ...process.env,
-          ...(baseProfile.env || {}),
-          ...cliEnv,
-        },
-      },
-      cwd: this.cwd,
-      expectedSessionId: resumeSessionId || undefined,
-      debug: this.tuiDebug,
-      onSnapshot: this.tuiTrace
-        ? (snapshot, state) => {
-            this.logSnapshot(state, snapshot);
-          }
-        : undefined,
-      onSignals: this.tuiTrace
-        ? (signals, snapshot, state) => {
-            this.logSignals(state, signals, snapshot);
-          }
-        : undefined,
-    });
-
-    // 监听登录需求事件
-    this.driver.on("login_required", (health) => {
-      log(`[${this.backend}] [WARN] Login required detected: ${health.message || health.reason}`);
-      if (health.matchedPattern) {
-        log(`[${this.backend}] [WARN] Matched pattern: "${health.matchedPattern}"`);
-      }
-      log(`[${this.backend}] [WARN] Please run "${this.command} login" or authenticate manually.`);
-    });
-
-    this.driver.on("session", (session) => {
-      this.applySessionInfo(session);
-    });
-  }
-
-  get threadId() {
-    return this.sessionId;
-  }
-
-  get threadOptions() {
-    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)}"`,
-    );
-    if (this.useSessionFileReplyStream) {
-      void this.ensureSessionFileMonitor();
-    }
-  }
-
-  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;
-    }
-  }
-
-  usesSessionFileReplyStream() {
-    return Boolean(this.useSessionFileReplyStream);
-  }
-
-  setSessionMessageHandler(handler) {
-    this.sessionMessageHandler = typeof handler === "function" ? handler : null;
-    if (this.useSessionFileReplyStream) {
-      void this.ensureSessionFileMonitor();
-    }
-  }
-
-  setWorkingStatusHandler(handler) {
-    this.workingStatusHandler = typeof handler === "function" ? handler : null;
-    if (this.useSessionFileReplyStream) {
-      void this.ensureWorkingStatusMonitor();
-    }
-  }
-
-  setSessionReplyTarget(replyTo) {
-    if (!this.useSessionFileReplyStream) {
-      return;
-    }
-    const normalizedReplyTo = typeof replyTo === "string" ? replyTo.trim() : "";
-    this.sessionMonitorActiveReplyTo = normalizedReplyTo;
-    this.sessionMonitorHasActiveReplyTarget = true;
-    if (normalizedReplyTo) {
-      this.sessionMonitorLastReplyTo = normalizedReplyTo;
-    }
-    this.sessionMonitorAwaitingFirstReply = true;
-    void this.ensureSessionFileMonitor();
-  }
-
-  async ensureSessionFileMonitor() {
-    if (!this.useSessionFileReplyStream || this.sessionMonitorPromise) {
-      return;
-    }
-    this.sessionMonitorStopRequested = false;
-    const monitorPromise = this.runSessionFileMonitor();
-    this.sessionMonitorPromise = monitorPromise;
-    monitorPromise.catch((error) => {
-      this.trace(`session monitor exited: ${sanitizeForLog(error?.message || error, 180)}`);
-    });
-  }
-
-  async ensureWorkingStatusMonitor() {
-    if (!this.useSessionFileReplyStream || this.workingStatusMonitorPromise) {
-      return;
-    }
-    this.workingStatusMonitorStopRequested = false;
-    const monitorPromise = this.runWorkingStatusMonitor();
-    this.workingStatusMonitorPromise = monitorPromise;
-    monitorPromise.catch((error) => {
-      this.trace(`working status monitor exited: ${sanitizeForLog(error?.message || error, 180)}`);
-    });
-  }
-
-  async runSessionFileMonitor() {
-    try {
-      while (!this.closeRequested && !this.sessionMonitorStopRequested) {
-        try {
-          await this.pollSessionFileMessages();
-        } catch (error) {
-          this.trace(`session monitor poll failed: ${sanitizeForLog(error?.message || error, 180)}`);
-        }
-        await delay(this.resolveSessionMonitorPollMs());
-      }
-    } finally {
-      this.sessionMonitorPromise = null;
-    }
-  }
-
-  async runWorkingStatusMonitor() {
-    try {
-      while (!this.closeRequested && !this.workingStatusMonitorStopRequested) {
-        try {
-          await this.pollWorkingStatus();
-        } catch (error) {
-          this.trace(`working status monitor poll failed: ${sanitizeForLog(error?.message || error, 180)}`);
-        }
-        await delay(this.workingStatusPollMs);
-      }
-    } finally {
-      this.workingStatusMonitorPromise = null;
-    }
-  }
-
-  resolveSessionMonitorPollMs() {
-    return this.sessionMonitorAwaitingFirstReply
-      ? this.sessionMonitorFastPollMs
-      : this.sessionMonitorSlowPollMs;
-  }
-
-  normalizeCodexWorkingStatusLine(statusLine) {
-    const normalized = typeof statusLine === "string" ? statusLine.trim() : "";
-    if (!normalized) {
-      return "";
-    }
-    if (/^\s*[•◦]\s*Working\b/i.test(normalized)) {
-      return normalized;
-    }
-    if (/\bWorking\s*\([^)]*\)/i.test(normalized)) {
-      return normalized;
-    }
-    return "";
-  }
-
-  normalizeCopilotWorkingStatusLine(statusLine) {
-    const normalized = typeof statusLine === "string" ? statusLine.trim() : "";
-    if (!normalized) {
-      return "";
-    }
-    // Copilot busy lines are prefixed with spinner-like bullets and include "(Esc to cancel ...)".
-    if (/^\s*[∙◉◎◐◑◒◓◔◕●○•◦]\s*.+Esc to cancel/i.test(normalized)) {
-      return normalized;
-    }
-    if (/^\s*.+Esc to cancel/i.test(normalized)) {
-      return normalized;
-    }
-    return "";
-  }
-
-  normalizeWorkingStatusLine(statusLine) {
-    if (this.backend === "copilot") {
-      return this.normalizeCopilotWorkingStatusLine(statusLine);
-    }
-    return this.normalizeCodexWorkingStatusLine(statusLine);
-  }
-
-  getCurrentReplyTarget() {
-    if (this.sessionMonitorHasActiveReplyTarget) {
-      return this.sessionMonitorActiveReplyTo || undefined;
-    }
-    return this.sessionMonitorLastReplyTo || undefined;
-  }
-
-  async pollWorkingStatus() {
-    if (!this.useSessionFileReplyStream || !this.driver || !this.driver.running) {
-      return;
-    }
-    const signals = this.driver.getSignals();
-    const workingStatusLine = this.normalizeWorkingStatusLine(signals.statusLine);
-    if (workingStatusLine === this.lastReportedWorkingStatusLine) {
-      return;
-    }
-    this.lastReportedWorkingStatusLine = workingStatusLine;
-    if (typeof this.workingStatusHandler !== "function") {
-      return;
-    }
-    if (workingStatusLine) {
-      await this.workingStatusHandler({
-        phase: "working_status_monitor",
-        source: "tui-driver",
-        reply_in_progress: true,
-        status_line: workingStatusLine,
-        replyTo: this.getCurrentReplyTarget(),
-      });
-      return;
-    }
-    await this.workingStatusHandler({
-      phase: "working_status_clear",
-      source: "tui-driver",
-      reply_in_progress: false,
-      replyTo: this.getCurrentReplyTarget(),
-    });
-  }
-
-  async pollSessionFileMessages() {
-    if (!this.useSessionFileReplyStream || !this.driver) {
-      return;
-    }
-    const sessionInfo = this.getSessionInfo();
-    if (!sessionInfo?.sessionId || !sessionInfo?.sessionFilePath) {
-      return;
-    }
-
-    const sessionId = String(sessionInfo.sessionId).trim();
-    const sessionFilePath = String(sessionInfo.sessionFilePath).trim();
-    if (!sessionId || !sessionFilePath) {
-      return;
-    }
-
-    const sessionChanged =
-      sessionId !== this.sessionMonitorSessionId ||
-      sessionFilePath !== this.sessionMonitorSessionFilePath;
-    if (sessionChanged) {
-      this.sessionMonitorSessionId = sessionId;
-      this.sessionMonitorSessionFilePath = sessionFilePath;
-      this.sessionMonitorCursor = this.sessionMonitorAwaitingFirstReply
-        ? 0
-        : await this.driver.getSessionFileSize(sessionInfo);
-      this.trace(
-        `session monitor bound id=${sessionId} file="${sanitizeForLog(sessionFilePath, 180)}" cursor=${this.sessionMonitorCursor}`,
-      );
-    }
-
-    const batch = await this.driver.readSessionAssistantMessagesSince(
-      sessionInfo,
-      this.sessionMonitorCursor,
-    );
-    this.sessionMonitorCursor = Number.isFinite(batch?.nextOffset)
-      ? batch.nextOffset
-      : this.sessionMonitorCursor;
-
-    const messages = Array.isArray(batch?.messages) ? batch.messages : [];
-    if (messages.length === 0) {
-      return;
-    }
-
-    for (const message of messages) {
-      const text = typeof message?.text === "string" ? message.text.trim() : "";
-      if (!text) {
-        continue;
-      }
-      this.history.push({ role: "assistant", content: text });
-      this.sessionMonitorAwaitingFirstReply = false;
-      if (typeof this.sessionMessageHandler !== "function") {
-        continue;
-      }
-      await this.sessionMessageHandler({
-        ...message,
-        replyTo: this.sessionMonitorHasActiveReplyTarget
-          ? this.sessionMonitorActiveReplyTo || undefined
-          : this.sessionMonitorLastReplyTo || undefined,
-      });
-    }
-  }
-
-  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.sessionMonitorStopRequested = true;
-    this.workingStatusMonitorStopRequested = true;
-    this.flushCloseWaiters();
-    if (this.driver) {
-      this.driver.kill();
-    }
-  }
-
-  /**
-   * 获取当前健康状态
-   * @returns {Object} 健康状态对象 { healthy, reason, message, matchedPattern }
-   */
-  getHealthStatus() {
-    if (!this.driver) {
-      return { healthy: false, reason: "not_initialized", message: "Driver not initialized" };
-    }
-    return this.driver.healthCheck();
-  }
-
-  buildPrompt(promptText, { useInitialImages = false } = {}) {
-    let effectivePrompt = String(promptText || "").trim();
-    if (!effectivePrompt) {
-      return "";
-    }
-
-    if (this.pendingHistorySeed) {
-      const historyText = this.history
-        .map((item) => {
-          const role = String(item?.role || "").toLowerCase() === "assistant" ? "Assistant" : "User";
-          return `${role}: ${String(item?.content || "").trim()}`;
-        })
-        .filter(Boolean)
-        .join("\n\n");
-      if (historyText) {
-        effectivePrompt = [
-          "Continue the existing conversation with this history.",
-          "",
-          historyText,
-          "",
-          `User: ${effectivePrompt}`,
-        ].join("\n");
-      }
-      this.pendingHistorySeed = false;
-    }
-
-    const images = Array.isArray(this.options.initialImages) ? this.options.initialImages : [];
-    if (useInitialImages && images.length > 0) {
-      const imageContext = images.map((item, idx) => `${idx + 1}. ${item}`).join("\n");
-      effectivePrompt = `${effectivePrompt}\n\nAttached image files:\n${imageContext}`;
-    }
-
-    return effectivePrompt;
-  }
-
-  emitProgress(onProgress, payload) {
-    if (typeof onProgress !== "function") {
-      return;
-    }
-    try {
-      onProgress(payload);
-    } catch {
-      // best effort
-    }
-  }
-
-  trace(message) {
-    if (!this.tuiTrace) {
-      return;
-    }
-    log(`[${this.backend}] [tui-trace] ${message}`);
-  }
-
-  formatSignalSummary(signals = {}) {
-    return {
-      prompt: sanitizeForLog(signals.promptLine || "", 100) || undefined,
-      replyInProgress: Boolean(signals.replyInProgress),
-      status: sanitizeForLog(signals.statusLine || "", 140) || undefined,
-      done: sanitizeForLog(signals.statusDoneLine || "", 140) || undefined,
-      replyPreview: sanitizeForLog(signals.replyText || "", 180) || undefined,
-      blocks: Array.isArray(signals.replyBlocks) ? signals.replyBlocks.length : 0,
-    };
-  }
-
-  logSignals(state, signals, snapshot) {
-    const summary = this.formatSignalSummary(signals);
-    const signature = JSON.stringify(summary);
-    if (signature === this.lastSignalSignature) {
-      return;
-    }
-    this.lastSignalSignature = signature;
-    this.trace(
-      `signals state=${state} hash=${snapshot?.hash || "n/a"} prompt="${summary.prompt || ""}" status="${summary.status || ""}" done="${summary.done || ""}" replyInProgress=${summary.replyInProgress} blocks=${summary.blocks} preview="${summary.replyPreview || ""}"`,
-    );
-  }
-
-  logSnapshot(state, snapshot) {
-    if (!snapshot || snapshot.hash === this.lastSnapshotHash) {
-      return;
-    }
-    this.lastSnapshotHash = snapshot.hash;
-    const viewportTail = sanitizeForLog(tailLines(snapshot.viewportText, this.tuiTraceLines), 400);
-    this.trace(
-      `snapshot state=${state} hash=${snapshot.hash} cursor=${snapshot.cursor?.x || 0},${snapshot.cursor?.y || 0} tail="${viewportTail}"`,
-    );
-  }
-
-  async runTurn(promptText, { useInitialImages = false, onProgress } = {}) {
-    if (this.closeRequested) {
-      throw this.createSessionClosedError();
-    }
-
-    const effectivePrompt = this.buildPrompt(promptText, { useInitialImages });
-    if (!effectivePrompt) {
-      return {
-        text: "",
-        usage: null,
-        items: [],
-        events: [],
-      };
-    }
-
-    log(`[${this.backend}] Running prompt: ${truncateText(effectivePrompt, 100)}...`);
-    this.trace(`runTurn start promptLen=${effectivePrompt.length} useInitialImages=${Boolean(useInitialImages)}`);
-    const useSessionFileReplyStream = this.usesSessionFileReplyStream();
-
-    const handleStateChange = (transition) => {
-      this.trace(`state ${transition.from} -> ${transition.to}`);
-      if (useSessionFileReplyStream) {
-        return;
-      }
-      this.emitProgress(onProgress, {
-        state: transition.to,
-        phase: "state_change",
-        source: "tui-driver",
-      });
-    };
-
-    this.driver.on("stateChange", handleStateChange);
-
-    const signalTimer = setInterval(() => {
-      const signals = this.driver.getSignals();
-      if (this.tuiTrace) {
-        const pollSummary = this.formatSignalSummary(signals);
-        const pollSignature = JSON.stringify({
-          state: this.driver.state,
-          replyInProgress: pollSummary.replyInProgress,
-          status: pollSummary.status,
-          done: pollSummary.done,
-          preview: pollSummary.replyPreview,
-        });
-        if (pollSignature !== this.lastPollSignature) {
-          this.lastPollSignature = pollSignature;
-          this.trace(
-            `poll state=${this.driver.state} replyInProgress=${pollSummary.replyInProgress} status="${pollSummary.status || ""}" done="${pollSummary.done || ""}" preview="${pollSummary.replyPreview || ""}"`,
-          );
-        }
-      }
-      if (useSessionFileReplyStream) {
-        return;
-      }
-      this.emitProgress(onProgress, {
-        state: this.driver.state,
-        phase: "signal_poll",
-        source: "tui-driver",
-        reply_in_progress: Boolean(signals.replyInProgress),
-        status_line: signals.statusLine || undefined,
-        status_done_line: signals.statusDoneLine || undefined,
-        reply_preview: truncateText(signals.replyText || "", 240) || undefined,
-      });
-    }, 700);
-    if (typeof signalTimer.unref === "function") {
-      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();
-    if (useSessionFileReplyStream) {
-      this.history.push({ role: "user", content: promptText });
-      void this.ensureSessionFileMonitor();
-      void this.ensureWorkingStatusMonitor();
-    }
-
-    try {
-      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}`,
-      );
-
-      if (!useSessionFileReplyStream) {
-        this.history.push({ role: "user", content: promptText });
-      }
-      if (answer && !useSessionFileReplyStream) {
-        this.history.push({ role: "assistant", content: answer });
-      }
-
-      if (!useSessionFileReplyStream) {
-        this.emitProgress(onProgress, {
-          state: result.success ? "DONE" : "ERROR",
-          phase: "turn_result",
-          source: "tui-driver",
-          reply_in_progress: false,
-          status_line: result.statusLine || undefined,
-          status_done_line: result.statusDoneLine || undefined,
-          reply_preview: truncateText(result.replyText || answer, 240) || undefined,
-        });
-      }
-
-      if (!result.success) {
-        const error = result.error || new Error("tui-driver failed to complete this turn");
-        throw error;
-      }
-
-      log(`[${this.backend}] Response received: ${truncateText(answer, 100)}...`);
-      this.trace(`runTurn reply preview="${sanitizeForLog(answer, 220)}"`);
-
-      return {
-        text: answer,
-        usage: null,
-        items: [],
-        events: [],
-        provider: this.backend,
-        metadata: {
-          source: "tui-driver",
-          elapsed_ms: result.elapsedMs,
-          signals: result.signals ?? null,
-        },
-      };
-    } 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 === "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",
-          source: "tui-driver",
-          error: errorMessage,
-          reason: errorReason,
-          matched_pattern: error?.matchedPattern,
-        });
-        log(`[${this.backend}] Login required: ${errorMessage}`);
-        log(`[${this.backend}] Please run "${this.command} login" or authenticate manually.`);
-      } else if (errorReason === "permission_required") {
-        this.emitProgress(onProgress, {
-          state: "ERROR",
-          phase: "permission_required",
-          source: "tui-driver",
-          error: errorMessage,
-          reason: errorReason,
-          matched_pattern: error?.matchedPattern,
-        });
-        log(`[${this.backend}] Permission required: ${errorMessage}`);
-      } else {
-        this.emitProgress(onProgress, {
-          state: "ERROR",
-          phase: "exception",
-          source: "tui-driver",
-          error: errorMessage,
-          reason: errorReason,
-        });
-        log(`[${this.backend}] Error: ${errorMessage}`);
-      }
-
-      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}`);
-    }
-  }
-}
-
 export class BridgeRunner {
   constructor({
     backendSession,
@@ -2069,7 +944,7 @@ export class BridgeRunner {
     includeInitialImages,
     cliArgs,
     backendName,
-    resumeMode,
+    resumeSessionId,
     daemonName,
   }) {
     this.backendSession = backendSession;
@@ -2080,7 +955,10 @@ export class BridgeRunner {
     this.includeInitialImages = includeInitialImages;
     this.cliArgs = cliArgs;
     this.backendName = backendName || "codex";
-    this.resumeMode = Boolean(resumeMode);
+    this.resumeSessionId =
+      typeof resumeSessionId === "string" && resumeSessionId.trim()
+        ? resumeSessionId.trim()
+        : "";
     this.isCopilotBackend = String(this.backendName).toLowerCase() === "copilot";
     this.copilotDebug =
       this.isCopilotBackend &&
@@ -2089,6 +967,7 @@ export class BridgeRunner {
     this.runningTurn = false;
     this.processedMessageIds = new Set();
     this.inFlightMessageIds = new Set();
+    this.sessionStreamReplyCounts = new Map();
     this.lastRuntimeStatusSignature = null;
     this.lastRuntimeStatusPayload = null;
     this.runtimeContextSnapshot = null;
@@ -2172,9 +1051,7 @@ export class BridgeRunner {
       return;
     }
     const discoveredSessionId = String(sessionInfo?.sessionId || "").trim();
-    const fallbackSessionId = this.resumeMode
-      ? String(this.backendSession.threadId || "").trim()
-      : "";
+    const fallbackSessionId = this.resumeSessionId;
     const sessionId = discoveredSessionId || fallbackSessionId;
     const sessionFilePath = sessionInfo?.sessionFilePath ? String(sessionInfo.sessionFilePath).trim() : "";
     const hasRealSessionId = Boolean(sessionId);
@@ -2207,13 +1084,15 @@ export class BridgeRunner {
         {
           state: this.useSessionFileReplyStream ? undefined : "WAIT_READY",
           phase: "session_started",
-          source: "tui-driver",
+          source: "ai-sdk",
           reply_in_progress: false,
           status_done_line: this.useSessionFileReplyStream
             ? undefined
             : `${this.backendName} session started`,
           backend: this.backendName,
           thread_id: hasRealSessionId ? sessionId : undefined,
+          session_id: hasRealSessionId ? sessionId : undefined,
+          session_file_path: sessionFilePath || undefined,
         },
         undefined,
       );
@@ -2244,13 +1123,6 @@ export class BridgeRunner {
     if (this.stopped) {
       return;
     }
-    if (this.resumeMode) {
-      await this.drainBufferedMessagesForResume();
-    }
-    if (this.stopped) {
-      return;
-    }
-
     while (!this.stopped) {
       if (this.needsReconnectRecovery && !this.runningTurn) {
         await this.recoverAfterReconnect();
@@ -2325,41 +1197,6 @@ export 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 : [];
@@ -2457,15 +1294,6 @@ export class BridgeRunner {
         .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}`,
       );
@@ -2574,7 +1402,7 @@ export class BridgeRunner {
     return {
       state: state || undefined,
       phase: phase || undefined,
-      source: "tui-driver",
+      source: payload.source ? String(payload.source) : "ai-sdk",
       reply_in_progress: Boolean(payload.reply_in_progress),
       status_line: statusLine || undefined,
       status_done_line: statusDoneLine || undefined,
@@ -2583,12 +1411,13 @@ export class BridgeRunner {
       backend: this.backendName,
       thread_id:
         String(
-          payload.thread_id || runtimeContext?.session_id || "",
+          payload.thread_id || payload.session_id || runtimeContext?.session_id || "",
         ).trim() || undefined,
       daemon: runtimeContext?.daemon,
       pid: runtimeContext?.pid,
-      session_id: runtimeContext?.session_id,
-      session_file_path: runtimeContext?.session_file_path,
+      session_id:
+        String(payload.session_id || runtimeContext?.session_id || "").trim() || undefined,
+      session_file_path: payload.session_file_path || runtimeContext?.session_file_path,
       token_usage_percent: runtimeContext?.token_usage_percent,
       context_usage_percent: runtimeContext?.context_usage_percent,
     };
@@ -2643,8 +1472,10 @@ export class BridgeRunner {
     if (this.stopped) {
       return;
     }
-    const text = typeof payload?.text === "string" ? payload.text.trim() : "";
-    if (!text) {
+    const preserveWhitespace = Boolean(payload?.preserveWhitespace);
+    const rawText = typeof payload?.text === "string" ? payload.text : "";
+    const text = preserveWhitespace ? rawText : rawText.trim();
+    if (!text || (!preserveWhitespace && !text.trim())) {
       return;
     }
 
@@ -2653,11 +1484,32 @@ export class BridgeRunner {
     const sessionFilePath =
       typeof payload?.sessionFilePath === "string" ? payload.sessionFilePath.trim() : "";
 
-    logBackendReply(this.backendName, text, {
+    await this.sendSessionStreamMessage({
+      text,
+      replyTo,
+      sessionId,
+      sessionFilePath,
+      timestamp: payload?.timestamp,
+    });
+  }
+
+  async sendSessionStreamMessage({
+    text,
+    replyTo,
+    sessionId,
+    sessionFilePath,
+    timestamp,
+  }) {
+    const normalizedText = typeof text === "string" ? text : "";
+    if (!normalizedText) {
+      return;
+    }
+
+    logBackendReply(this.backendName, normalizedText, {
       usage: null,
       replyTo: replyTo || "latest",
     });
-    await this.conductor.sendMessage(this.taskId, text, {
+    await this.conductor.sendMessage(this.taskId, normalizedText, {
       model: this.backendSession.threadOptions?.model || this.backendName,
       backend: this.backendName,
       thread_id: sessionId || this.backendSession.threadId,
@@ -2666,10 +1518,15 @@ export class BridgeRunner {
       reply_to: replyTo || undefined,
       cli_args: this.cliArgs,
       session_stream: true,
-      timestamp: payload?.timestamp || undefined,
+      timestamp: timestamp || undefined,
     });
+    const replyKey = this.normalizeSessionStreamReplyKey(replyTo);
+    this.sessionStreamReplyCounts.set(
+      replyKey,
+      Number(this.sessionStreamReplyCounts.get(replyKey) || 0) + 1,
+    );
     this.copilotLog(
-      `session_file sdk_message sent replyTo=${replyTo || "latest"} responseLen=${text.length}`,
+      `session_file sdk_message sent replyTo=${replyTo || "latest"} responseLen=${normalizedText.length}`,
     );
   }
 
@@ -2677,6 +1534,55 @@ export class BridgeRunner {
     await this.reportRuntimeStatus(payload, payload?.replyTo);
   }
 
+  normalizeSessionStreamReplyKey(replyTo) {
+    const normalizedReplyTo = typeof replyTo === "string" ? replyTo.trim() : "";
+    return normalizedReplyTo || "__latest__";
+  }
+
+  getSessionStreamReplyCount(replyTo) {
+    return Number(
+      this.sessionStreamReplyCounts.get(this.normalizeSessionStreamReplyKey(replyTo)) || 0,
+    );
+  }
+
+  isCodexCheckpointUnavailableError(errorMessage) {
+    return String(errorMessage || "")
+      .toLowerCase()
+      .includes("codex session file checkpoint unavailable");
+  }
+
+  async settleCodexCheckpointUnavailableAfterStream(replyTo, errorMessage, { markProcessed = true } = {}) {
+    if (!this.useSessionFileReplyStream) {
+      return false;
+    }
+    if (String(this.backendName || "").toLowerCase() !== "codex") {
+      return false;
+    }
+    if (!this.isCodexCheckpointUnavailableError(errorMessage)) {
+      return false;
+    }
+    const streamedReplyCount = this.getSessionStreamReplyCount(replyTo);
+    if (streamedReplyCount <= 0) {
+      return false;
+    }
+
+    this.copilotLog(
+      `suppress checkpoint unavailable after streamed replies replyTo=${replyTo || "latest"} count=${streamedReplyCount}`,
+    );
+    await this.reportRuntimeStatus(
+      {
+        phase: "session_stream_settled",
+        reply_in_progress: false,
+      },
+      replyTo,
+    );
+    if (markProcessed && replyTo) {
+      this.processedMessageIds.add(replyTo);
+    }
+    this.resetErrorLoop();
+    return true;
+  }
+
   resetErrorLoop() {
     this.errorLoop = null;
   }
@@ -2864,6 +1770,9 @@ export class BridgeRunner {
         );
         return;
       }
+      if (await this.settleCodexCheckpointUnavailableAfterStream(replyTo, errorMessage)) {
+        return;
+      }
       this.copilotLog(
         `turn failed replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} error="${sanitizeForLog(errorMessage, 200)}"`,
       );
@@ -2969,14 +1878,18 @@ export class BridgeRunner {
         this.copilotLog("synthetic session_file turn settled");
       }
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       if (this.stopped && (this.remoteStopInfo || isSessionClosedError(error))) {
         this.copilotLog(`synthetic turn interrupted by stop_task elapsedMs=${Date.now() - startedAt}`);
         return;
       }
+      if (await this.settleCodexCheckpointUnavailableAfterStream("initial", errorMessage, { markProcessed: false })) {
+        return;
+      }
       this.copilotLog(
-        `synthetic turn failed elapsedMs=${Date.now() - startedAt} error="${sanitizeForLog(error?.message || error, 200)}"`,
+        `synthetic turn failed elapsedMs=${Date.now() - startedAt} error="${sanitizeForLog(errorMessage, 200)}"`,
       );
-      await this.reportError(`初始提示执行失败: ${error.message}`);
+      await this.reportError(`初始提示执行失败: ${errorMessage}`);
     } finally {
       this.copilotLog(`synthetic turn end elapsedMs=${Date.now() - startedAt}`);
       this.runningTurn = false;