@love-moon/conductor-cli 0.2.12 → 0.2.14

package/bin/conductor-fire.js

@@ -8,6 +8,7 @@
  */
 
 import fs from "node:fs";
+import { createHash } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
@@ -103,6 +104,95 @@ 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;
+const SESSION_BOOTSTRAP_LOCK_TIMEOUT_MS = 15_000;
+const SESSION_BOOTSTRAP_LOCK_RETRY_MS = 50;
+
+function sleepSync(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) {
+    return;
+  }
+  try {
+    const buffer = new SharedArrayBuffer(4);
+    const arr = new Int32Array(buffer);
+    Atomics.wait(arr, 0, 0, ms);
+  } catch {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < ms) {
+      // busy wait fallback
+    }
+  }
+}
+
+function resolveLockWorkingDirectory(workingDirectory) {
+  const normalizedPath =
+    typeof workingDirectory === "string" && workingDirectory.trim()
+      ? path.resolve(workingDirectory.trim())
+      : process.cwd();
+  try {
+    return fs.realpathSync(normalizedPath);
+  } catch {
+    return normalizedPath;
+  }
+}
+
+export function resolveFreshSessionBootstrapLockPath(backendName, workingDirectory) {
+  const normalizedBackend = String(backendName || "").trim().toLowerCase();
+  if (normalizedBackend !== "codex") {
+    return null;
+  }
+  const lockKey = `${normalizedBackend}:${resolveLockWorkingDirectory(workingDirectory)}`;
+  const digest = createHash("sha1").update(lockKey).digest("hex");
+  return path.join(os.homedir(), ".conductor", "locks", `session-bootstrap-${digest}.lock`);
+}
+
+function acquireFileLock(lockPath) {
+  const startedAt = Date.now();
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+  while (true) {
+    try {
+      const fd = fs.openSync(lockPath, "wx");
+      return () => {
+        try {
+          fs.closeSync(fd);
+        } catch {
+          // ignore close failure
+        }
+        try {
+          fs.unlinkSync(lockPath);
+        } catch {
+          // ignore unlink failure
+        }
+      };
+    } catch (error) {
+      if (error?.code !== "EEXIST") {
+        throw error;
+      }
+      if (Date.now() - startedAt > SESSION_BOOTSTRAP_LOCK_TIMEOUT_MS) {
+        throw new Error(`Timed out waiting for fresh session lock: ${lockPath}`);
+      }
+      sleepSync(SESSION_BOOTSTRAP_LOCK_RETRY_MS);
+    }
+  }
+}
+
+export async function withFreshSessionBootstrapLock(backendName, workingDirectory, fn) {
+  const lockPath = resolveFreshSessionBootstrapLockPath(backendName, workingDirectory);
+  if (!lockPath) {
+    return await fn();
+  }
+  const release = acquireFileLock(lockPath);
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+}
 
 function appendFireLocalLog(line) {
   if (!ENABLE_FIRE_LOCAL_LOG) {
@@ -118,6 +208,7 @@ function appendFireLocalLog(line) {
 async function main() {
   const cliArgs = parseCliArgs();
   let runtimeProjectPath = process.cwd();
+  let backendSession = null;
 
   if (cliArgs.showHelp) {
     return;
@@ -155,16 +246,6 @@ async function main() {
     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: runtimeProjectPath,
-    resumeSessionId: cliArgs.resumeSessionId,
-    configFile: cliArgs.configFile,
-  });
-
-  log(`Using backend: ${cliArgs.backend}`);
-
   const env = buildEnv();
   const launchedByDaemon = Boolean(process.env.CONDUCTOR_CLI_COMMAND);
   let reconnectRunner = null;
@@ -224,6 +305,7 @@ async function main() {
   if (cliArgs.configFile) {
     env.CONDUCTOR_CONFIG = cliArgs.configFile;
   }
+  let configuredDaemonName = "";
   try {
     const config = loadConfig(cliArgs.configFile);
     if (config.backendUrl && !env.CONDUCTOR_BACKEND_URL) {
@@ -235,6 +317,9 @@ async function main() {
     if (config.agentToken && !env.CONDUCTOR_AGENT_TOKEN) {
       env.CONDUCTOR_AGENT_TOKEN = config.agentToken;
     }
+    if (config.daemonName) {
+      configuredDaemonName = config.daemonName;
+    }
   } catch (error) {
     // Ignore config loading errors, rely on env vars or defaults
   }
@@ -261,6 +346,7 @@ async function main() {
       providedTaskId: process.env.CONDUCTOR_TASK_ID,
       requestedTitle: requestedTaskTitle,
       backend: cliArgs.backend,
+      daemonName: configuredDaemonName,
     });
 
     log(
@@ -270,6 +356,48 @@ async function main() {
     );
     reconnectTaskId = taskContext.taskId;
 
+    if (typeof conductor.bindTaskSession === "function") {
+      try {
+        await conductor.bindTaskSession(taskContext.taskId, {
+          project_id: process.env.CONDUCTOR_PROJECT_ID,
+          project_path: runtimeProjectPath,
+          backend_type: cliArgs.backend,
+        });
+      } catch {
+        // best effort only
+      }
+    }
+
+    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
+      }
+    }
+
+    backendSession = new TuiDriverSession(cliArgs.backend, {
+      initialImages: cliArgs.initialImages,
+      cwd: runtimeProjectPath,
+      resumeSessionId: resolvedResumeSessionId,
+      configFile: cliArgs.configFile,
+    });
+
+    log(`Using backend: ${cliArgs.backend}`);
+
     try {
       await conductor.sendAgentResume({
         active_tasks: [taskContext.taskId],
@@ -289,7 +417,8 @@ async function main() {
       includeInitialImages: Boolean(cliArgs.initialPrompt && cliArgs.initialImages.length),
       cliArgs: cliArgs.rawBackendArgs,
       backendName: cliArgs.backend,
-      resumeMode: Boolean(cliArgs.resumeSessionId),
+      resumeMode: Boolean(resolvedResumeSessionId),
+      daemonName: configuredDaemonName,
     });
     reconnectRunner = runner;
     if (pendingRemoteStopEvent) {
@@ -307,7 +436,9 @@ async function main() {
       backendShutdownRequested = true;
       void (async () => {
         try {
-          await backendSession.close();
+          if (backendSession && typeof backendSession.close === "function") {
+            await backendSession.close();
+          }
         } catch (error) {
           log(`Failed to close backend session after ${source}: ${error?.message || error}`);
         }
@@ -338,6 +469,11 @@ async function main() {
 
     let runnerError = null;
     try {
+      if (!resolvedResumeSessionId && String(cliArgs.backend).trim().toLowerCase() === "codex") {
+        await withFreshSessionBootstrapLock(cliArgs.backend, runtimeProjectPath, async () => {
+          await runner.announceBackendSession();
+        });
+      }
       await runner.start(signals.signal);
     } catch (error) {
       runnerError = error;
@@ -379,7 +515,7 @@ async function main() {
       }
     }
   } finally {
-    if (typeof backendSession.close === "function") {
+    if (backendSession && typeof backendSession.close === "function") {
       try {
         await backendSession.close();
       } catch (error) {
@@ -667,6 +803,9 @@ async function ensureTaskContext(conductor, opts) {
     task_title: deriveTaskTitle(opts.initialPrompt, opts.requestedTitle, opts.backend),
     backend_type: opts.backend,
   };
+  if (opts.daemonName) {
+    payload.daemon_name = opts.daemonName;
+  }
   if (opts.initialPrompt) {
     payload.prefill = opts.initialPrompt;
   }
@@ -1027,6 +1166,39 @@ function sanitizeForLog(value, maxLen = 180) {
   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/);
@@ -1045,6 +1217,7 @@ class TuiDriverSession {
     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;
@@ -1066,11 +1239,51 @@ class TuiDriverSession {
     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,
@@ -1078,6 +1291,7 @@ class TuiDriverSession {
       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;
@@ -1086,10 +1300,10 @@ class TuiDriverSession {
       log(`Using proxy: ${proxyEnv.http_proxy || proxyEnv.https_proxy || proxyEnv.all_proxy}`);
     }
 
-    log(`Using TUI command for ${backend}: ${[this.command, ...this.args].join(" ")} (cwd: ${this.cwd})`);
+    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(this.args)}`,
+        `[${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}`,
@@ -1100,7 +1314,7 @@ class TuiDriverSession {
       profile: {
         ...baseProfile,
         command: this.command,
-        args: this.args,
+        args: effectiveDriverArgs,
         env: {
           ...process.env,
           ...(baseProfile.env || {}),
@@ -1108,6 +1322,7 @@ class TuiDriverSession {
         },
       },
       cwd: this.cwd,
+      expectedSessionId: resumeSessionId || undefined,
       debug: this.tuiDebug,
       onSnapshot: this.tuiTrace
         ? (snapshot, state) => {
@@ -1129,6 +1344,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() {
@@ -1139,12 +1358,316 @@ 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)}"`,
+    );
+    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 {
@@ -1169,6 +1692,32 @@ class TuiDriverSession {
     };
   }
 
+  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;
@@ -1189,6 +1738,8 @@ class TuiDriverSession {
     }
     this.closed = true;
     this.closeRequested = true;
+    this.sessionMonitorStopRequested = true;
+    this.workingStatusMonitorStopRequested = true;
     this.flushCloseWaiters();
     if (this.driver) {
       this.driver.kill();
@@ -1310,9 +1861,13 @@ class TuiDriverSession {
 
     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",
@@ -1340,6 +1895,9 @@ class TuiDriverSession {
           );
         }
       }
+      if (useSessionFileReplyStream) {
+        return;
+      }
       this.emitProgress(onProgress, {
         state: this.driver.state,
         phase: "signal_poll",
@@ -1364,28 +1922,38 @@ class TuiDriverSession {
       }
     }
     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]);
+      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}`,
       );
 
-      this.history.push({ role: "user", content: promptText });
-      if (answer) {
+      if (!useSessionFileReplyStream) {
+        this.history.push({ role: "user", content: promptText });
+      }
+      if (answer && !useSessionFileReplyStream) {
         this.history.push({ role: "assistant", content: answer });
       }
 
-      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 (!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");
@@ -1415,8 +1983,23 @@ class TuiDriverSession {
         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",
@@ -1469,6 +2052,7 @@ class TuiDriverSession {
       }
       clearInterval(signalTimer);
       this.driver.off("stateChange", handleStateChange);
+      turnTimeoutGuard.cleanup();
       closeGuard.cleanup();
       this.trace(`runTurn cleanup state=${this.driver.state}`);
     }
@@ -1486,6 +2070,7 @@ export class BridgeRunner {
     cliArgs,
     backendName,
     resumeMode,
+    daemonName,
   }) {
     this.backendSession = backendSession;
     this.conductor = conductor;
@@ -1503,10 +2088,66 @@ export class BridgeRunner {
     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.useSessionFileReplyStream =
+      Boolean(this.backendSession) &&
+      typeof this.backendSession.usesSessionFileReplyStream === "function" &&
+      this.backendSession.usesSessionFileReplyStream();
+    this.daemonName =
+      (typeof daemonName === "string" && daemonName.trim()) ||
+      (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,
+    );
+    if (
+      this.useSessionFileReplyStream &&
+      typeof this.backendSession?.setSessionMessageHandler === "function"
+    ) {
+      this.backendSession.setSessionMessageHandler((payload) =>
+        this.handleSessionFileAssistantMessage(payload),
+      );
+    }
+    if (
+      this.useSessionFileReplyStream &&
+      typeof this.backendSession?.setWorkingStatusHandler === "function"
+    ) {
+      this.backendSession.setWorkingStatusHandler((payload) =>
+        this.handleContinuousWorkingStatus(payload),
+      );
+    }
   }
 
   copilotLog(message) {
@@ -1516,6 +2157,71 @@ export class BridgeRunner {
     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 discoveredSessionId = String(sessionInfo?.sessionId || "").trim();
+    const fallbackSessionId = this.resumeMode
+      ? String(this.backendSession.threadId || "").trim()
+      : "";
+    const sessionId = discoveredSessionId || fallbackSessionId;
+    const sessionFilePath = sessionInfo?.sessionFilePath ? String(sessionInfo.sessionFilePath).trim() : "";
+    const hasRealSessionId = Boolean(sessionId);
+    const message = hasRealSessionId
+      ? `${this.backendName} session started: ${sessionId}`
+      : `${this.backendName} session started`;
+    if (hasRealSessionId && typeof this.conductor?.bindTaskSession === "function") {
+      try {
+        await this.conductor.bindTaskSession(this.taskId, {
+          session_id: sessionId,
+          session_file_path: sessionFilePath || undefined,
+          backend_type: this.backendName,
+        });
+      } catch (error) {
+        log(`Failed to persist task session binding for ${this.taskId}: ${error?.message || error}`);
+      }
+    }
+    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: this.useSessionFileReplyStream ? undefined : "WAIT_READY",
+          phase: "session_started",
+          source: "tui-driver",
+          reply_in_progress: false,
+          status_done_line: this.useSessionFileReplyStream
+            ? undefined
+            : `${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;
@@ -1524,6 +2230,11 @@ export class BridgeRunner {
       return;
     }
 
+    await this.announceBackendSession();
+    if (this.stopped) {
+      return;
+    }
+
     if (this.initialPrompt) {
       this.copilotLog("processing initial prompt");
       await this.handleSyntheticMessage(this.initialPrompt, {
@@ -1539,11 +2250,6 @@ export class BridgeRunner {
     if (this.stopped) {
       return;
     }
-    this.copilotLog("running startup backfill");
-    await this.backfillPendingUserMessages();
-    if (this.stopped) {
-      return;
-    }
 
     while (!this.stopped) {
       if (this.needsReconnectRecovery && !this.runningTurn) {
@@ -1611,10 +2317,8 @@ export class BridgeRunner {
     }
     this.needsReconnectRecovery = false;
     log(`Recovering task ${this.taskId} after reconnect`);
-    // With durable web outbox enabled, user messages are replayed by the server.
-    // Re-running DB-history backfill here can re-drive stale prompts and confuse
-    // the local TUI session after reconnect. Keep startup backfill, but disable
-    // reconnect backfill by default (opt-in for debugging/legacy fallback).
+    // User-message recovery relies on the durable server outbox. DB-history replay
+    // stays opt-in here only as a legacy/debugging fallback after reconnect.
     if (process.env.CONDUCTOR_FIRE_RECONNECT_BACKFILL === "1") {
       await this.backfillPendingUserMessages();
     }
@@ -1779,7 +2483,80 @@ export 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;
     }
@@ -1804,12 +2581,22 @@ export 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;
     }
@@ -1852,6 +2639,105 @@ export class BridgeRunner {
     }
   }
 
+  async handleSessionFileAssistantMessage(payload) {
+    if (this.stopped) {
+      return;
+    }
+    const text = typeof payload?.text === "string" ? payload.text.trim() : "";
+    if (!text) {
+      return;
+    }
+
+    const replyTo = typeof payload?.replyTo === "string" ? payload.replyTo.trim() : "";
+    const sessionId = typeof payload?.sessionId === "string" ? payload.sessionId.trim() : "";
+    const sessionFilePath =
+      typeof payload?.sessionFilePath === "string" ? payload.sessionFilePath.trim() : "";
+
+    logBackendReply(this.backendName, text, {
+      usage: null,
+      replyTo: replyTo || "latest",
+    });
+    await this.conductor.sendMessage(this.taskId, text, {
+      model: this.backendSession.threadOptions?.model || this.backendName,
+      backend: this.backendName,
+      thread_id: sessionId || this.backendSession.threadId,
+      session_id: sessionId || undefined,
+      session_file_path: sessionFilePath || undefined,
+      reply_to: replyTo || undefined,
+      cli_args: this.cliArgs,
+      session_stream: true,
+      timestamp: payload?.timestamp || undefined,
+    });
+    this.copilotLog(
+      `session_file sdk_message sent replyTo=${replyTo || "latest"} responseLen=${text.length}`,
+    );
+  }
+
+  async handleContinuousWorkingStatus(payload) {
+    await this.reportRuntimeStatus(payload, payload?.replyTo);
+  }
+
+  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) {
@@ -1863,6 +2749,19 @@ export 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);
+    }
+    if (
+      this.useSessionFileReplyStream &&
+      typeof this.backendSession?.setSessionReplyTarget === "function"
+    ) {
+      this.backendSession.setSessionReplyTarget(replyTo);
+    }
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
     const turnStartedAt = Date.now();
@@ -1883,15 +2782,25 @@ export class BridgeRunner {
     );
     log(`Processing message ${replyTo} (${message.role})`);
     try {
-      await this.reportRuntimeStatus(
-        {
-          state: "PREPARE_TURN",
-          phase: "start_turn",
-          reply_in_progress: true,
-          status_line: `${this.backendName} is preparing the response`,
-        },
-        replyTo,
-      );
+      if (this.useSessionFileReplyStream) {
+        await this.reportRuntimeStatus(
+          {
+            phase: "start_turn",
+            reply_in_progress: true,
+          },
+          replyTo,
+        );
+      } else {
+        await this.reportRuntimeStatus(
+          {
+            state: "PREPARE_TURN",
+            phase: "start_turn",
+            reply_in_progress: true,
+            status_line: `${this.backendName} is preparing the response`,
+          },
+          replyTo,
+        );
+      }
 
       const result = await this.backendSession.runTurn(content, {
         onProgress: (payload) => {
@@ -1904,35 +2813,49 @@ export class BridgeRunner {
         ).trim().length} items=${Array.isArray(result.items) ? result.items.length : 0}`,
       );
 
-      await this.reportRuntimeStatus(
-        {
-          state: "DONE",
-          phase: "reply_ready",
-          reply_in_progress: false,
-          status_done_line: `${this.backendName} finished`,
-        },
-        replyTo,
-      );
+      if (!this.useSessionFileReplyStream) {
+        await this.reportRuntimeStatus(
+          {
+            state: "DONE",
+            phase: "reply_ready",
+            reply_in_progress: false,
+            status_done_line: `${this.backendName} finished`,
+          },
+          replyTo,
+        );
+      }
 
-      const responseText =
-        result.text ||
-        extractAgentTextFromItems(result.items) ||
-        extractAgentTextFromMetadata(result.metadata) ||
-        `(${this.backendName} 未返回任何文本)`;
-      logBackendReply(this.backendName, responseText, { usage: result.usage, replyTo: replyTo || "latest" });
-      await this.conductor.sendMessage(this.taskId, responseText, {
-        model: this.backendSession.threadOptions?.model || this.backendName,
-        backend: this.backendName,
-        usage: result.usage || null,
-        thread_id: this.backendSession.threadId,
-        items: result.items,
-        reply_to: replyTo,
-        cli_args: this.cliArgs,
-      });
+      if (!this.useSessionFileReplyStream) {
+        const responseText =
+          result.text ||
+          extractAgentTextFromItems(result.items) ||
+          extractAgentTextFromMetadata(result.metadata) ||
+          `(${this.backendName} 未返回任何文本)`;
+        logBackendReply(this.backendName, responseText, { usage: result.usage, replyTo: replyTo || "latest" });
+        await this.conductor.sendMessage(this.taskId, responseText, {
+          model: this.backendSession.threadOptions?.model || this.backendName,
+          backend: this.backendName,
+          usage: result.usage || null,
+          thread_id: this.backendSession.threadId,
+          items: result.items,
+          reply_to: replyTo,
+          cli_args: this.cliArgs,
+        });
+      }
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
-      this.copilotLog(`sdk_message sent replyTo=${replyTo || "latest"} responseLen=${responseText.length}`);
+      this.resetErrorLoop();
+      if (this.useSessionFileReplyStream) {
+        this.copilotLog(`session_file turn settled replyTo=${replyTo || "latest"}`);
+      } else {
+        const responseText =
+          result.text ||
+          extractAgentTextFromItems(result.items) ||
+          extractAgentTextFromMetadata(result.metadata) ||
+          `(${this.backendName} 未返回任何文本)`;
+        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))) {
@@ -1953,11 +2876,48 @@ export 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}`,
       );
@@ -1969,6 +2929,12 @@ export class BridgeRunner {
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
     const startedAt = Date.now();
+    if (
+      this.useSessionFileReplyStream &&
+      typeof this.backendSession?.setSessionReplyTarget === "function"
+    ) {
+      this.backendSession.setSessionReplyTarget("initial");
+    }
     this.copilotLog(`synthetic turn start includeImages=${Boolean(includeImages)} contentLen=${String(content || "").length}`);
     try {
       const result = await this.backendSession.runTurn(content, {
@@ -1980,24 +2946,28 @@ export class BridgeRunner {
       this.copilotLog(
         `synthetic runTurn completed elapsedMs=${Date.now() - startedAt} answerLen=${String(result.text || "").trim().length}`,
       );
-      const backendLabel = this.backendName.charAt(0).toUpperCase() + this.backendName.slice(1);
-      const intro = `${backendLabel} 已根据初始提示给出回复：`;
-      const replyText =
-        result.text || extractAgentTextFromItems(result.items) || extractAgentTextFromMetadata(result.metadata);
-      const text = replyText ? `${intro}\n\n${replyText}` : intro;
-      logBackendReply(this.backendName, replyText || "(无文本输出)", {
-        usage: result.usage,
-        replyTo: "initial",
-      });
-      await this.conductor.sendMessage(this.taskId, text, {
-        model: this.backendSession.threadOptions?.model || this.backendName,
-        backend: this.backendName,
-        usage: result.usage || null,
-        thread_id: this.backendSession.threadId,
-        cli_args: this.cliArgs,
-        synthetic: true,
-      });
-      this.copilotLog(`synthetic sdk_message sent responseLen=${text.length}`);
+      if (!this.useSessionFileReplyStream) {
+        const backendLabel = this.backendName.charAt(0).toUpperCase() + this.backendName.slice(1);
+        const intro = `${backendLabel} 已根据初始提示给出回复：`;
+        const replyText =
+          result.text || extractAgentTextFromItems(result.items) || extractAgentTextFromMetadata(result.metadata);
+        const text = replyText ? `${intro}\n\n${replyText}` : intro;
+        logBackendReply(this.backendName, replyText || "(无文本输出)", {
+          usage: result.usage,
+          replyTo: "initial",
+        });
+        await this.conductor.sendMessage(this.taskId, text, {
+          model: this.backendSession.threadOptions?.model || this.backendName,
+          backend: this.backendName,
+          usage: result.usage || null,
+          thread_id: this.backendSession.threadId,
+          cli_args: this.cliArgs,
+          synthetic: true,
+        });
+        this.copilotLog(`synthetic sdk_message sent responseLen=${text.length}`);
+      } else {
+        this.copilotLog("synthetic session_file turn settled");
+      }
     } catch (error) {
       if (this.stopped && (this.remoteStopInfo || isSessionClosedError(error))) {
         this.copilotLog(`synthetic turn interrupted by stop_task elapsedMs=${Date.now() - startedAt}`);