@love-moon/conductor-cli 0.2.13 → 0.2.14

package/bin/conductor-config.js

@@ -51,6 +51,7 @@ const backendUrl =
   process.env.CONDUCTOR_BACKEND_URL ||
   process.env.BACKEND_URL ||
   "https://conductor-ai.top";
+const defaultDaemonName = os.hostname() || "my-daemon";
 
 // ANSI 颜色代码
 const COLORS = {
@@ -157,6 +158,7 @@ async function main() {
   const lines = [
     `agent_token: ${yamlQuote(token)}`,
     `backend_url: ${yamlQuote(backendUrl)}`,
+    `daemon_name: ${yamlQuote(defaultDaemonName)}`,
     "log_level: debug",
     "workspace: '~/ws/fires'",
     "",

package/bin/conductor-daemon.js

@@ -92,13 +92,7 @@ function pidFromLockFile(lockFile) {
 
 const args = yargs(argv)
   .scriptName(CLI_NAME)
-  .usage("Usage: $0 [--name <daemon-name>] [--clean-all] [--config-file <path>] [--nohup] [--force]")
-  .option("name", {
-    alias: "n",
-    type: "string",
-    demandOption: false,
-    describe: "Unique daemon name (used as agent host)",
-  })
+  .usage("Usage: $0 [--clean-all] [--config-file <path>] [--nohup] [--force]")
   .option("nohup", {
     type: "boolean",
     default: false,
@@ -118,10 +112,7 @@ const args = yargs(argv)
     type: "string",
     describe: "Path to Conductor config file",
   })
-  .example(
-    "$0 --config-file ~/.conductor/config.yaml --name agent-1",
-    "Use custom config file and daemon name",
-  )
+  .example("$0 --config-file ~/.conductor/config.yaml", "Run with daemon_name from config")
   .example("$0 --nohup", "Run daemon in background with logfile")
   .example("$0 --nohup --force", "Restart daemon in background by stopping the existing one")
   .help()
@@ -155,7 +146,6 @@ if (args.nohup) {
 }
 
 startDaemon({
-  NAME: args.name,
   CLEAN_ALL: args.cleanAll,
   CONFIG_FILE: args.configFile,
   FORCE: args.force,

package/bin/conductor-diagnose.js

@@ -120,7 +120,9 @@ async function runFallbackDiagnosis(baseUrl, token, taskId, timeoutMs) {
   const pendingAgeMs = hasPendingUser && Number.isFinite(latestUserMs) ? Date.now() - latestUserMs : null;
   const latestSdkFailureKey = detectExecutionFailureLoopKey(latestSdk?.content);
 
-  const assignedHost = cleanText(task?.agent_host || task?.agentHost);
+  const assignedHost = cleanText(
+    task?.execution_host || task?.executionHost || task?.agent_host || task?.agentHost,
+  );
   const assignedConnected = Boolean(
     assignedHost && agents.some((agent) => cleanText(agent?.host) === assignedHost),
   );
@@ -139,6 +141,7 @@ async function runFallbackDiagnosis(baseUrl, token, taskId, timeoutMs) {
       id: task?.id || taskId,
       status: normalizeTaskStatus(task?.status),
       agent_host: assignedHost || null,
+      execution_host: cleanText(task?.execution_host || task?.executionHost) || null,
     },
     messages: {
       total: messages.length,
@@ -251,6 +254,7 @@ function printReport(taskId, report) {
   process.stdout.write("Signals:\n");
   process.stdout.write(`- task.status: ${String(task?.status || "unknown")}\n`);
   process.stdout.write(`- task.agent_host: ${String(task?.agent_host || task?.agentHost || "n/a")}\n`);
+  process.stdout.write(`- task.execution_host: ${String(task?.execution_host || task?.executionHost || "n/a")}\n`);
   process.stdout.write(`- bound_agent_host: ${String(realtime?.bound_agent_host || realtime?.boundAgentHost || "n/a")}\n`);
   process.stdout.write(
     `- pending user: ${Boolean(messages?.has_pending_user ?? messages?.hasPendingUser)}${

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";
@@ -109,6 +110,89 @@ 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) {
@@ -124,6 +208,7 @@ function appendFireLocalLog(line) {
 async function main() {
   const cliArgs = parseCliArgs();
   let runtimeProjectPath = process.cwd();
+  let backendSession = null;
 
   if (cliArgs.showHelp) {
     return;
@@ -161,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;
@@ -230,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) {
@@ -241,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
   }
@@ -267,6 +346,7 @@ async function main() {
       providedTaskId: process.env.CONDUCTOR_TASK_ID,
       requestedTitle: requestedTaskTitle,
       backend: cliArgs.backend,
+      daemonName: configuredDaemonName,
     });
 
     log(
@@ -276,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],
@@ -295,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) {
@@ -313,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}`);
         }
@@ -344,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;
@@ -385,7 +515,7 @@ async function main() {
       }
     }
   } finally {
-    if (typeof backendSession.close === "function") {
+    if (backendSession && typeof backendSession.close === "function") {
       try {
         await backendSession.close();
       } catch (error) {
@@ -673,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;
   }
@@ -1106,6 +1239,20 @@ 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,
@@ -1117,6 +1264,26 @@ class TuiDriverSession {
     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,
@@ -1124,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;
@@ -1132,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}`,
@@ -1146,7 +1314,7 @@ class TuiDriverSession {
       profile: {
         ...baseProfile,
         command: this.command,
-        args: this.args,
+        args: effectiveDriverArgs,
         env: {
           ...process.env,
           ...(baseProfile.env || {}),
@@ -1154,6 +1322,7 @@ class TuiDriverSession {
         },
       },
       cwd: this.cwd,
+      expectedSessionId: resumeSessionId || undefined,
       debug: this.tuiDebug,
       onSnapshot: this.tuiTrace
         ? (snapshot, state) => {
@@ -1208,6 +1377,9 @@ class TuiDriverSession {
     this.trace(
       `session id=${sessionId} file="${sanitizeForLog(sessionFilePath, 180)}"`,
     );
+    if (this.useSessionFileReplyStream) {
+      void this.ensureSessionFileMonitor();
+    }
   }
 
   getSessionInfo() {
@@ -1255,6 +1427,233 @@ class TuiDriverSession {
     }
   }
 
+  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";
@@ -1339,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();
@@ -1460,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",
@@ -1490,6 +1895,9 @@ class TuiDriverSession {
           );
         }
       }
+      if (useSessionFileReplyStream) {
+        return;
+      }
       this.emitProgress(onProgress, {
         state: this.driver.state,
         phase: "signal_poll",
@@ -1515,6 +1923,11 @@ 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, turnTimeoutGuard.promise]);
@@ -1523,20 +1936,24 @@ class TuiDriverSession {
         `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");
@@ -1653,6 +2070,7 @@ export class BridgeRunner {
     cliArgs,
     backendName,
     resumeMode,
+    daemonName,
   }) {
     this.backendSession = backendSession;
     this.conductor = conductor;
@@ -1682,7 +2100,12 @@ export class BridgeRunner {
       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()) ||
@@ -1709,6 +2132,22 @@ export class BridgeRunner {
       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) {
@@ -1732,12 +2171,27 @@ export class BridgeRunner {
       this.copilotLog(`session announce skipped: ${sanitizeForLog(error?.message || error, 160)}`);
       return;
     }
-    const sessionId = String(sessionInfo?.sessionId || "").trim();
+    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,
@@ -1751,11 +2205,13 @@ export class BridgeRunner {
       this.copilotLog(hasRealSessionId ? `session announced id=${sessionId}` : "session announced without id");
       await this.reportRuntimeStatus(
         {
-          state: "WAIT_READY",
+          state: this.useSessionFileReplyStream ? undefined : "WAIT_READY",
           phase: "session_started",
           source: "tui-driver",
           reply_in_progress: false,
-          status_done_line: `${this.backendName} session started`,
+          status_done_line: this.useSessionFileReplyStream
+            ? undefined
+            : `${this.backendName} session started`,
           backend: this.backendName,
           thread_id: hasRealSessionId ? sessionId : undefined,
         },
@@ -1794,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) {
@@ -1866,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();
     }
@@ -2190,6 +2639,44 @@ 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;
   }
@@ -2269,6 +2756,12 @@ export class BridgeRunner {
     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();
@@ -2289,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) => {
@@ -2310,36 +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.resetErrorLoop();
-      this.copilotLog(`sdk_message sent replyTo=${replyTo || "latest"} responseLen=${responseText.length}`);
+      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))) {
@@ -2413,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, {
@@ -2424,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}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -16,8 +16,8 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@love-moon/tui-driver": "0.2.13",
-    "@love-moon/conductor-sdk": "0.2.13",
+    "@love-moon/tui-driver": "0.2.14",
+    "@love-moon/conductor-sdk": "0.2.14",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",

package/src/daemon.js

@@ -173,9 +173,18 @@ export function startDaemon(config = {}, deps = {}) {
     deriveWebsocketUrlFromHttp(BACKEND_HTTP);
   const AGENT_TOKEN =
     config.AGENT_TOKEN || process.env.CONDUCTOR_AGENT_TOKEN || fileConfig?.agentToken || "default-agent-token";
-  const AGENT_NAME = (config.NAME || process.env.CONDUCTOR_DAEMON_NAME || os.hostname()).trim();
+  const configuredDaemonName =
+    (typeof userConfig.daemon_name === "string" && userConfig.daemon_name.trim()) ||
+    (typeof fileConfig?.daemonName === "string" && fileConfig.daemonName.trim()) ||
+    "";
+  const AGENT_NAME = (
+    config.DAEMON_NAME ||
+    configuredDaemonName ||
+    process.env.CONDUCTOR_DAEMON_NAME ||
+    os.hostname()
+  ).trim();
   if (!AGENT_NAME) {
-    logError("Daemon name is required. Set --name or CONDUCTOR_DAEMON_NAME.");
+    logError("Daemon name is required. Set daemon_name in ~/.conductor/config.yaml or CONDUCTOR_DAEMON_NAME.");
     return exitAndReturn(1);
   }
   const homeDir = process.env.HOME || os.homedir() || "/tmp";