@love-moon/conductor-cli 0.2.9 → 0.2.11

package/bin/conductor-config.js

@@ -27,34 +27,24 @@ const DEFAULT_CLIs = {
   },
   copilot: {
     command: "copilot",
-    execArgs: "--allow-all-paths --allow-all-tools -i",
+    execArgs: "--allow-all-paths --allow-all-tools",
     description: "GitHub Copilot CLI"
   },
-  gemini: {
-    command: "gemini",
-    execArgs: "",
-    description: "Google Gemini CLI"
-  },
-  opencode: {
-    command: "opencode",
-    execArgs: "",
-    description: "OpenCode CLI"
-  },
-  kimi: {
-    command: "kimi",
-    execArgs: "--yolo --print --prompt",
-    description: "Kimi CLI"
-  },
-  aider: {
-    command: "aider",
-    execArgs: "",
-    description: "Aider AI Pair Programming"
-  },
-  goose: {
-    command: "goose",
-    execArgs: "",
-    description: "Goose AI Agent CLI"
-  },
+  // gemini: {
+  //   command: "gemini",
+  //   execArgs: "",
+  //   description: "Google Gemini CLI"
+  // },
+  // opencode: {
+  //   command: "opencode",
+  //   execArgs: "",
+  //   description: "OpenCode CLI"
+  // },
+  // kimi: {
+  //   command: "kimi",
+  //   execArgs: "--yolo --print --prompt",
+  //   description: "Kimi CLI"
+  // },
 };
 
 const backendUrl =
@@ -168,6 +158,7 @@ async function main() {
     `agent_token: ${yamlQuote(token)}`,
     `backend_url: ${yamlQuote(backendUrl)}`,
     "log_level: debug",
+    "workspace: '~/ws/fires'",
     "",
     "# Allowed coding CLIs",
     "allow_cli_list:"

package/bin/conductor-fire.js

@@ -30,6 +30,8 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const PKG_ROOT = path.join(__dirname, "..");
 const CLI_PROJECT_PATH = process.cwd();
+const FIRE_LOG_PATH = path.join(CLI_PROJECT_PATH, "conductor.log");
+const ENABLE_FIRE_LOCAL_LOG = !process.env.CONDUCTOR_CLI_COMMAND;
 
 const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
 const CLI_NAME = (process.env.CONDUCTOR_CLI_NAME || path.basename(process.argv[1] || "conductor-fire")).replace(
@@ -106,6 +108,17 @@ const DEFAULT_POLL_INTERVAL_MS = parseInt(
   10,
 );
 
+function appendFireLocalLog(line) {
+  if (!ENABLE_FIRE_LOCAL_LOG) {
+    return;
+  }
+  try {
+    fs.appendFileSync(FIRE_LOG_PATH, line);
+  } catch {
+    // ignore file log errors
+  }
+}
+
 async function main() {
   const cliArgs = parseCliArgs();
 
@@ -1057,6 +1070,7 @@ class BridgeRunner {
     this.includeInitialImages = includeInitialImages;
     this.cliArgs = cliArgs;
     this.backendName = backendName || "codex";
+    this.isCopilotBackend = String(this.backendName).toLowerCase() === "copilot";
     this.stopped = false;
     this.runningTurn = false;
     this.processedMessageIds = new Set();
@@ -1065,16 +1079,25 @@ class BridgeRunner {
     this.needsReconnectRecovery = false;
   }
 
+  copilotLog(message) {
+    if (!this.isCopilotBackend) {
+      return;
+    }
+    log(`[copilot-debug] task=${this.taskId} ${message}`);
+  }
+
   async start(abortSignal) {
     abortSignal?.addEventListener("abort", () => {
       this.stopped = true;
     });
 
     if (this.initialPrompt) {
+      this.copilotLog("processing initial prompt");
       await this.handleSyntheticMessage(this.initialPrompt, {
         includeImages: this.includeInitialImages,
       });
     }
+    this.copilotLog("running startup backfill");
     await this.backfillPendingUserMessages();
 
     while (!this.stopped) {
@@ -1120,17 +1143,24 @@ class BridgeRunner {
     if (messages.length === 0) {
       return false;
     }
+    const ackToken = result.next_ack_token || result.nextAckToken;
+    this.copilotLog(
+      `received batch size=${messages.length} hasMore=${Boolean(result?.has_more)} ackToken=${ackToken ? "yes" : "no"} roles=${messages
+        .map((item) => String(item?.role || "unknown").toLowerCase())
+        .join(",")}`,
+    );
 
     for (const message of messages) {
       if (!this.shouldRespond(message)) {
+        this.copilotLog(`skip message role=${String(message?.role || "unknown").toLowerCase()}`);
         continue;
       }
       await this.respondToMessage(message);
     }
 
-    const ackToken = result.next_ack_token || result.nextAckToken;
     if (ackToken) {
       await this.conductor.ackMessages(this.taskId, ackToken);
+      this.copilotLog(`acked batch ackToken=${truncateText(String(ackToken), 40)}`);
     }
     const hasMore = Boolean(result?.has_more);
     return hasMore;
@@ -1148,6 +1178,7 @@ class BridgeRunner {
     const backendUrl = process.env.CONDUCTOR_BACKEND_URL;
     const token = process.env.CONDUCTOR_AGENT_TOKEN;
     if (!backendUrl || !token) {
+      this.copilotLog("skip backfill: missing backend url or token");
       return;
     }
 
@@ -1163,10 +1194,12 @@ class BridgeRunner {
         },
       );
       if (!response.ok) {
+        this.copilotLog(`backfill request failed status=${response.status}`);
         return;
       }
       const history = await response.json();
       if (!Array.isArray(history) || history.length === 0) {
+        this.copilotLog("backfill: no history messages");
         return;
       }
 
@@ -1182,8 +1215,12 @@ class BridgeRunner {
         .slice(lastSdkIndex + 1)
         .filter((item) => String(item?.role || "").toLowerCase() === "user")
         .filter((item) => typeof item?.content === "string" && item.content.trim());
+      this.copilotLog(
+        `backfill loaded history=${history.length} pendingUsers=${pendingUserMessages.length} lastSdkIndex=${lastSdkIndex}`,
+      );
 
       for (const pending of pendingUserMessages) {
+        this.copilotLog(`backfill replay message id=${pending.id ? String(pending.id) : "unknown"}`);
         await this.respondToMessage({
           message_id: pending.id ? String(pending.id) : undefined,
           role: "user",
@@ -1238,6 +1275,11 @@ class BridgeRunner {
     this.lastRuntimeStatusPayload = {
       ...runtime,
     };
+    this.copilotLog(
+      `runtime replyTo=${replyTo || "latest"} state=${runtime.state || ""} phase=${runtime.phase || ""} inProgress=${Boolean(
+        runtime.reply_in_progress,
+      )} status="${sanitizeForLog(runtime.status_line || "", 120)}" done="${sanitizeForLog(runtime.status_done_line || "", 120)}" preview="${sanitizeForLog(runtime.reply_preview || "", 120)}"`,
+    );
 
     try {
       await this.conductor.sendRuntimeStatus(this.taskId, {
@@ -1266,14 +1308,32 @@ class BridgeRunner {
   async respondToMessage(message) {
     const content = String(message.content || "").trim();
     if (!content) {
+      this.copilotLog(`skip empty message replyTo=${message?.message_id || "latest"}`);
       return;
     }
     const replyTo = message.message_id;
     if (replyTo && this.processedMessageIds.has(replyTo)) {
+      this.copilotLog(`skip duplicated message replyTo=${replyTo}`);
       return;
     }
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
+    const turnStartedAt = Date.now();
+    let turnWatchdog = null;
+    if (this.isCopilotBackend) {
+      turnWatchdog = setInterval(() => {
+        const runtime = this.lastRuntimeStatusPayload || {};
+        this.copilotLog(
+          `turn waiting replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} state=${runtime.state || ""} phase=${runtime.phase || ""} status="${sanitizeForLog(runtime.status_line || runtime.status_done_line || "", 120)}"`,
+        );
+      }, 30000);
+      if (typeof turnWatchdog.unref === "function") {
+        turnWatchdog.unref();
+      }
+    }
+    this.copilotLog(
+      `turn start replyTo=${replyTo || "latest"} role=${String(message.role || "").toLowerCase()} contentLen=${content.length} preview="${sanitizeForLog(content, 120)}"`,
+    );
     log(`Processing message ${replyTo} (${message.role})`);
     try {
       await this.reportRuntimeStatus(
@@ -1291,6 +1351,11 @@ class BridgeRunner {
           void this.reportRuntimeStatus(payload, replyTo);
         },
       });
+      this.copilotLog(
+        `runTurn completed replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} answerLen=${String(
+          result.text || "",
+        ).trim().length} items=${Array.isArray(result.items) ? result.items.length : 0}`,
+      );
 
       await this.reportRuntimeStatus(
         {
@@ -1320,8 +1385,12 @@ class BridgeRunner {
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
+      this.copilotLog(`sdk_message sent replyTo=${replyTo || "latest"} responseLen=${responseText.length}`);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
+      this.copilotLog(
+        `turn failed replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} error="${sanitizeForLog(errorMessage, 200)}"`,
+      );
       await this.reportRuntimeStatus(
         {
           state: "ERROR",
@@ -1333,6 +1402,12 @@ class BridgeRunner {
       );
       await this.reportError(`${this.backendName} 处理失败: ${errorMessage}`, replyTo);
     } finally {
+      if (turnWatchdog) {
+        clearInterval(turnWatchdog);
+      }
+      this.copilotLog(
+        `turn end replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} processedIds=${this.processedMessageIds.size}`,
+      );
       this.runningTurn = false;
     }
   }
@@ -1340,6 +1415,8 @@ class BridgeRunner {
   async handleSyntheticMessage(content, { includeImages }) {
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
+    const startedAt = Date.now();
+    this.copilotLog(`synthetic turn start includeImages=${Boolean(includeImages)} contentLen=${String(content || "").length}`);
     try {
       const result = await this.backendSession.runTurn(content, {
         useInitialImages: includeImages,
@@ -1347,6 +1424,9 @@ class BridgeRunner {
           void this.reportRuntimeStatus(payload, "initial");
         },
       });
+      this.copilotLog(
+        `synthetic runTurn completed elapsedMs=${Date.now() - startedAt} answerLen=${String(result.text || "").trim().length}`,
+      );
       const backendLabel = this.backendName.charAt(0).toUpperCase() + this.backendName.slice(1);
       const intro = `${backendLabel} 已根据初始提示给出回复：`;
       const replyText =
@@ -1364,9 +1444,14 @@ class BridgeRunner {
         cli_args: this.cliArgs,
         synthetic: true,
       });
+      this.copilotLog(`synthetic sdk_message sent responseLen=${text.length}`);
     } catch (error) {
+      this.copilotLog(
+        `synthetic turn failed elapsedMs=${Date.now() - startedAt} error="${sanitizeForLog(error?.message || error, 200)}"`,
+      );
       await this.reportError(`初始提示执行失败: ${error.message}`);
     } finally {
+      this.copilotLog(`synthetic turn end elapsedMs=${Date.now() - startedAt}`);
       this.runningTurn = false;
     }
   }
@@ -1424,7 +1509,9 @@ function extractAgentTextFromMetadata(metadata) {
 
 function log(message) {
   const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-  process.stdout.write(`[${CLI_NAME} ${ts}] ${message}\n`);
+  const line = `[${CLI_NAME} ${ts}] ${message}\n`;
+  process.stdout.write(line);
+  appendFireLocalLog(line);
 }
 
 function logBackendReply(backend, text, { usage, replyTo }) {
@@ -1448,7 +1535,9 @@ function isDirectRun() {
 if (isDirectRun()) {
   main().catch((error) => {
     const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-    process.stderr.write(`[${CLI_NAME} ${ts}] failed: ${error.stack || error.message}\n`);
+    const line = `[${CLI_NAME} ${ts}] failed: ${error.stack || error.message}\n`;
+    process.stderr.write(line);
+    appendFireLocalLog(line);
     process.exitCode = 1;
   });
 }

package/bin/conductor-update.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+/**
+ * conductor update - Check for and install updates to the CLI.
+ */
+
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import { execSync, spawn } from "node:child_process";
+import process from "node:process";
+import readline from "node:readline/promises";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
+const PKG_ROOT = path.join(__dirname, "..");
+
+const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
+const PACKAGE_NAME = pkgJson.name;
+const CURRENT_VERSION = pkgJson.version;
+
+// ANSI 颜色代码
+const COLORS = {
+  yellow: "\x1b[33m",
+  green: "\x1b[32m",
+  cyan: "\x1b[36m",
+  red: "\x1b[31m",
+  reset: "\x1b[0m",
+  bold: "\x1b[1m"
+};
+
+function colorize(text, color) {
+  return `${COLORS[color] || ""}${text}${COLORS.reset}`;
+}
+
+async function main() {
+  // 解析命令行参数
+  const args = process.argv.slice(2);
+  const forceUpdate = args.includes("--force") || args.includes("-f");
+  const skipConfirm = args.includes("--yes") || args.includes("-y");
+  const showHelp = args.includes("--help") || args.includes("-h");
+
+  if (showHelp) {
+    showHelpMessage();
+    process.exit(0);
+  }
+
+  console.log(colorize(`📦 ${PACKAGE_NAME}`, "cyan"));
+  console.log(`   Current version: ${CURRENT_VERSION}`);
+  console.log("");
+
+  // 检查远程最新版本
+  console.log("🔍 Checking for updates...");
+  
+  let latestVersion;
+  try {
+    latestVersion = await getLatestVersion();
+  } catch (error) {
+    console.error(colorize(`❌ Failed to check for updates: ${error.message}`, "red"));
+    process.exit(1);
+  }
+
+  console.log(`   Latest version:  ${latestVersion}`);
+  console.log("");
+
+  // 比较版本
+  if (!forceUpdate && !isNewerVersion(latestVersion, CURRENT_VERSION)) {
+    console.log(colorize("✅ You are already on the latest version!", "green"));
+    process.exit(0);
+  }
+
+  if (forceUpdate) {
+    console.log(colorize("⚡ Force update requested", "yellow"));
+  } else {
+    console.log(colorize(`⬆️  Update available: ${CURRENT_VERSION} → ${latestVersion}`, "green"));
+  }
+
+  console.log("");
+
+  // 确认更新
+  if (!skipConfirm) {
+    const shouldUpdate = await confirmUpdate(latestVersion);
+    if (!shouldUpdate) {
+      console.log("Update cancelled.");
+      process.exit(0);
+    }
+  }
+
+  // 执行更新
+  console.log("");
+  console.log(colorize("🚀 Installing update...", "cyan"));
+  console.log("");
+
+  try {
+    await performUpdate();
+    console.log("");
+    console.log(colorize("✅ Update completed successfully!", "green"));
+    console.log("");
+    console.log("   Run 'conductor --version' to verify the new version.");
+  } catch (error) {
+    console.error("");
+    console.error(colorize(`❌ Update failed: ${error.message}`, "red"));
+    console.error("");
+    console.error("   You can try updating manually with:");
+    console.error(`   npm install -g ${PACKAGE_NAME}@latest`);
+    process.exit(1);
+  }
+}
+
+async function getLatestVersion() {
+  return new Promise((resolve, reject) => {
+    // 使用 npm view 获取最新版本
+    try {
+      const result = execSync(`npm view ${PACKAGE_NAME} version --json`, {
+        encoding: "utf-8",
+        timeout: 10000,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      
+      // npm view 返回的是带引号的字符串 JSON
+      const version = JSON.parse(result.trim());
+      resolve(version);
+    } catch (error) {
+      // 如果失败，尝试从 registry API 获取
+      fetchLatestFromRegistry()
+        .then(resolve)
+        .catch(reject);
+    }
+  });
+}
+
+async function fetchLatestFromRegistry() {
+  return new Promise((resolve, reject) => {
+    const https = require("https");
+    const url = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+    
+    https.get(url, { timeout: 10000 }, (res) => {
+      let data = "";
+      
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          if (json.version) {
+            resolve(json.version);
+          } else {
+            reject(new Error("Invalid response from registry"));
+          }
+        } catch (error) {
+          reject(new Error(`Failed to parse registry response: ${error.message}`));
+        }
+      });
+    }).on("error", (error) => {
+      reject(new Error(`Network error: ${error.message}`));
+    }).on("timeout", () => {
+      reject(new Error("Request timed out"));
+    });
+  });
+}
+
+function isNewerVersion(latest, current) {
+  // 简单的版本比较
+  const parseVersion = (v) => v.replace(/^v/, "").split(".").map(Number);
+  
+  const latestParts = parseVersion(latest);
+  const currentParts = parseVersion(current);
+  
+  for (let i = 0; i < Math.max(latestParts.length, currentParts.length); i++) {
+    const l = latestParts[i] || 0;
+    const c = currentParts[i] || 0;
+    
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  
+  return false; // 版本相同
+}
+
+async function confirmUpdate(version) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  
+  try {
+    const answer = await rl.question(
+      colorize(`Do you want to update to version ${version}? (Y/n): `, "yellow")
+    );
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "" || normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+async function performUpdate() {
+  return new Promise((resolve, reject) => {
+    // 检测使用的包管理器
+    const packageManager = detectPackageManager();
+    console.log(`   Using package manager: ${colorize(packageManager, "cyan")}`);
+    console.log("");
+    
+    let cmd, args;
+    
+    switch (packageManager) {
+      case "pnpm":
+        cmd = "pnpm";
+        args = ["add", "-g", `${PACKAGE_NAME}@latest`];
+        break;
+      case "yarn":
+        cmd = "yarn";
+        args = ["global", "add", `${PACKAGE_NAME}@latest`];
+        break;
+      case "npm":
+      default:
+        cmd = "npm";
+        args = ["install", "-g", `${PACKAGE_NAME}@latest`];
+        break;
+    }
+    
+    console.log(`   Running: ${colorize(`${cmd} ${args.join(" ")}`, "cyan")}`);
+    console.log("");
+    
+    const child = spawn(cmd, args, {
+      stdio: "inherit",
+      shell: true
+    });
+    
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Exit code ${code}`));
+      }
+    });
+    
+    child.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+
+function detectPackageManager() {
+  // 通过分析 conductor 命令的路径来推断包管理器
+  try {
+    const conductorPath = execSync("which conductor || where conductor", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    
+    if (conductorPath.includes("pnpm")) {
+      return "pnpm";
+    }
+    if (conductorPath.includes("yarn")) {
+      return "yarn";
+    }
+    if (conductorPath.includes(".npm") || conductorPath.includes("npm")) {
+      return "npm";
+    }
+  } catch {
+    // 忽略错误，使用默认检测
+  }
+  
+  // 检查哪个包管理器可用
+  try {
+    execSync("pnpm --version", { stdio: "pipe" });
+    return "pnpm";
+  } catch {
+    // pnpm 不可用
+  }
+  
+  try {
+    execSync("yarn --version", { stdio: "pipe" });
+    return "yarn";
+  } catch {
+    // yarn 不可用
+  }
+  
+  return "npm"; // 默认使用 npm
+}
+
+function showHelpMessage() {
+  console.log(`conductor update - Update the CLI to the latest version
+
+Usage: conductor update [options]
+
+Options:
+  -f, --force    Force update even if already on latest version
+  -y, --yes      Skip confirmation prompt
+  -h, --help     Show this help message
+
+Examples:
+  conductor update          Check for updates and prompt to install
+  conductor update --yes    Update without prompting
+  conductor update --force  Force reinstall the latest version
+`);
+}
+
+main().catch((error) => {
+  console.error(colorize(`Unexpected error: ${error?.message || error}`, "red"));
+  process.exit(1);
+});

package/bin/conductor.js

@@ -4,9 +4,10 @@
  * conductor - Main CLI entry point with subcommand routing.
  *
  * Subcommands:
- *   fire    - Run AI coding agents with Conductor integration
- *   daemon  - Start long-running daemon for task orchestration
- *   config  - Interactive configuration setup
+ *   fire     - Run AI coding agents with Conductor integration
+ *   daemon   - Start long-running daemon for task orchestration
+ *   config   - Interactive configuration setup
+ *   update   - Update the CLI to the latest version
  */
 
 import { fileURLToPath } from "node:url";
@@ -42,7 +43,7 @@ if (argv[0] === "--version" || argv[0] === "-v") {
 const subcommand = argv[0];
 
 // Valid subcommands
-const validSubcommands = ["fire", "daemon", "config"];
+const validSubcommands = ["fire", "daemon", "config", "update"];
 
 if (!validSubcommands.includes(subcommand)) {
   console.error(`Error: Unknown subcommand '${subcommand}'`);
@@ -83,6 +84,7 @@ Subcommands:
   fire      Run AI coding agents with Conductor integration
   daemon    Start long-running daemon for task orchestration
   config    Interactive configuration setup
+  update    Update the CLI to the latest version
 
 Options:
   -h, --help     Show this help message
@@ -93,11 +95,13 @@ Examples:
   conductor fire --backend claude -- "add feature"
   conductor daemon --config-file ~/.conductor/config.yaml
   conductor config
+  conductor update
 
 For subcommand-specific help:
   conductor fire --help
   conductor daemon --help
   conductor config --help
+  conductor update --help
 
 Version: ${pkgJson.version}
 `);

package/package.json

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

package/src/daemon.js

@@ -14,15 +14,30 @@ dotenv.config();
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const CLI_PATH = path.resolve(__dirname, "..", "bin", "conductor-fire.js");
+const DAEMON_LOG_DIR = path.join(os.homedir(), ".conductor", "logs");
+const DAEMON_LOG_PATH = path.join(DAEMON_LOG_DIR, "conductor-daemon.log");
+
+function appendDaemonLog(line) {
+  try {
+    fs.mkdirSync(DAEMON_LOG_DIR, { recursive: true });
+    fs.appendFileSync(DAEMON_LOG_PATH, line);
+  } catch {
+    // ignore file log errors
+  }
+}
 
 function log(message) {
   const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-  process.stdout.write(`[conductor-daemon ${ts}] ${message}\n`);
+  const line = `[conductor-daemon ${ts}] ${message}\n`;
+  process.stdout.write(line);
+  appendDaemonLog(line);
 }
 
 function logError(message) {
   const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-  process.stderr.write(`[conductor-daemon ${ts}] ${message}\n`);
+  const line = `[conductor-daemon ${ts}] ${message}\n`;
+  process.stderr.write(line);
+  appendDaemonLog(line);
 }
 
 function getUserConfig(configFilePath) {
@@ -656,6 +671,20 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
+    const existingTaskRecord = activeTaskProcesses.get(taskId);
+    if (existingTaskRecord?.child) {
+      log(
+        `Duplicate create_task ignored for ${taskId}: task already active (pid=${existingTaskRecord.child.pid ?? "unknown"})`,
+      );
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_task",
+        accepted: true,
+      }).catch(() => {});
+      return;
+    }
+
     // Validate and get CLI command for the backend
     const effectiveBackend = backendType || SUPPORTED_BACKENDS[0];
     if (!SUPPORTED_BACKENDS.includes(effectiveBackend)) {