@love-moon/conductor-cli 0.2.6 → 0.2.8

package/bin/conductor-fire.js

@@ -4,24 +4,21 @@
  * conductor-fire - Conductor-aware AI coding agent runner.
  *
  * Supports configurable backends via allow_cli_list in config file.
- * This CLI bridges various AI coding agents with Conductor via MCP.
+ * This CLI bridges various AI coding agents with Conductor via the Conductor SDK.
  */
 
 import fs from "node:fs";
-import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
 
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import yaml from "js-yaml";
 import { TuiDriver, claudeCodeProfile, codexProfile, copilotProfile } from "@love-moon/tui-driver";
-import { loadConfig } from "@love-moon/conductor-sdk";
+import { ConductorClient, loadConfig } from "@love-moon/conductor-sdk";
 import {
   loadHistoryFromSpec,
   parseFromSpec,
@@ -31,21 +28,8 @@ import {
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const require = createRequire(import.meta.url);
 const PKG_ROOT = path.join(__dirname, "..");
 const CLI_PROJECT_PATH = process.cwd();
-const REPO_ROOT_FALLBACK = path.resolve(__dirname, "..", "..");
-const SDK_FALLBACK_PATH = path.join(REPO_ROOT_FALLBACK, "modules", "sdk");
-const SDK_ROOT =
-  process.env.CONDUCTOR_SDK_PATH ||
-  (() => {
-    try {
-      return path.dirname(require.resolve("@love-moon/conductor-sdk/package.json"));
-    } catch {
-      return SDK_FALLBACK_PATH;
-    }
-  })();
-const MCP_SERVER_SCRIPT = path.join(SDK_ROOT, "dist", "bin", "mcp-server.js");
 
 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(
@@ -122,12 +106,6 @@ const DEFAULT_POLL_INTERVAL_MS = parseInt(
   10,
 );
 
-const MCP_SERVER_LAUNCH = {
-  command: "node",
-  args: [MCP_SERVER_SCRIPT],
-  cwd: SDK_ROOT,
-};
-
 async function main() {
   const cliArgs = parseCliArgs();
 
@@ -204,6 +182,45 @@ async function main() {
   log(`Using backend: ${cliArgs.backend}`);
 
   const env = buildEnv();
+  const launchedByDaemon = Boolean(process.env.CONDUCTOR_CLI_COMMAND);
+  let reconnectRunner = null;
+  let reconnectTaskId = null;
+  let conductor = null;
+  let reconnectResumeInFlight = false;
+
+  const scheduleReconnectRecovery = ({ isReconnect }) => {
+    if (!isReconnect) {
+      return;
+    }
+    log("Conductor connection restored");
+    if (reconnectRunner && typeof reconnectRunner.noteReconnect === "function") {
+      reconnectRunner.noteReconnect();
+    }
+    if (!conductor || !reconnectTaskId || reconnectResumeInFlight) {
+      return;
+    }
+    reconnectResumeInFlight = true;
+    void (async () => {
+      try {
+        await conductor.sendAgentResume({
+          active_tasks: [reconnectTaskId],
+          source: "conductor-fire",
+          metadata: { reconnect: true },
+        });
+        if (!launchedByDaemon) {
+          await conductor.sendTaskStatus(reconnectTaskId, {
+            status: "RUNNING",
+            summary: "conductor fire reconnected",
+          });
+        }
+      } catch (error) {
+        log(`Failed to report reconnect resume: ${error?.message || error}`);
+      } finally {
+        reconnectResumeInFlight = false;
+      }
+    })();
+  };
+
   if (cliArgs.configFile) {
     env.CONDUCTOR_CONFIG = cliArgs.configFile;
   }
@@ -222,11 +239,11 @@ async function main() {
     // Ignore config loading errors, rely on env vars or defaults
   }
 
-  const conductor = await ConductorClient.connect({
-    launcher: MCP_SERVER_LAUNCH,
-    workingDirectory: CLI_PROJECT_PATH,
+  conductor = await ConductorClient.connect({
     projectPath: CLI_PROJECT_PATH,
     extraEnv: env,
+    configFile: cliArgs.configFile,
+    onConnected: scheduleReconnectRecovery,
   });
 
   const taskContext = await ensureTaskContext(conductor, {
@@ -242,6 +259,17 @@ async function main() {
       taskContext.appUrl ? ` (${taskContext.appUrl})` : ""
     }`,
   );
+  reconnectTaskId = taskContext.taskId;
+
+  try {
+    await conductor.sendAgentResume({
+      active_tasks: [taskContext.taskId],
+      source: "conductor-fire",
+      metadata: { reconnect: false },
+    });
+  } catch (error) {
+    log(`Failed to report agent resume: ${error?.message || error}`);
+  }
 
   const runner = new BridgeRunner({
     backendSession,
@@ -253,10 +281,10 @@ async function main() {
     cliArgs: cliArgs.rawBackendArgs,
     backendName: cliArgs.backend,
   });
+  reconnectRunner = runner;
 
   const signals = new AbortController();
   let shutdownSignal = null;
-  const launchedByDaemon = Boolean(process.env.CONDUCTOR_CLI_COMMAND);
   const onSigint = () => {
     shutdownSignal = shutdownSignal || "SIGINT";
     signals.abort();
@@ -268,19 +296,44 @@ async function main() {
   process.on("SIGINT", onSigint);
   process.on("SIGTERM", onSigterm);
 
+  if (!launchedByDaemon) {
+    try {
+      await conductor.sendTaskStatus(taskContext.taskId, {
+        status: "RUNNING",
+      });
+    } catch (error) {
+      log(`Failed to report task status (RUNNING): ${error?.message || error}`);
+    }
+  }
+
+  let runnerError = null;
   try {
     await runner.start(signals.signal);
+  } catch (error) {
+    runnerError = error;
+    throw error;
   } finally {
     process.off("SIGINT", onSigint);
     process.off("SIGTERM", onSigterm);
-    if (shutdownSignal && !launchedByDaemon) {
+    if (!launchedByDaemon) {
+      const finalStatus = shutdownSignal
+        ? {
+            status: "KILLED",
+            summary: `terminated by ${shutdownSignal}`,
+          }
+        : runnerError
+          ? {
+              status: "KILLED",
+              summary: `conductor fire failed: ${runnerError?.message || runnerError}`,
+            }
+          : {
+              status: "COMPLETED",
+              summary: "conductor fire exited",
+            };
       try {
-        await conductor.sendTaskStatus(taskContext.taskId, {
-          status: "KILLED",
-          summary: `terminated by ${shutdownSignal}`,
-        });
+        await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
       } catch (error) {
-        log(`Failed to report task status (KILLED): ${error?.message || error}`);
+        log(`Failed to report task status (${finalStatus.status}): ${error?.message || error}`);
       }
     }
     if (typeof backendSession.close === "function") {
@@ -537,7 +590,19 @@ async function resolveProjectId(conductor, explicit) {
   try {
     const record = await conductor.getLocalProjectRecord();
     if (record?.project_id) {
-      return record.project_id;
+      try {
+        const listing = await conductor.listProjects();
+        const exists = Array.isArray(listing?.projects)
+          ? listing.projects.some((project) => String(project?.id || "") === String(record.project_id))
+          : false;
+        if (exists) {
+          return record.project_id;
+        }
+        log(`Local session project ${record.project_id} no longer exists; falling back to server project list`);
+      } catch (verifyError) {
+        log(`Unable to verify local project record; using cached project id: ${verifyError.message}`);
+        return record.project_id;
+      }
     }
   } catch (error) {
     log(`Unable to resolve project via local session: ${error.message}`);
@@ -973,174 +1038,6 @@ class TuiDriverSession {
   }
 }
 
-class ConductorClient {
-  constructor(client, transport, options = {}) {
-    this.client = client;
-    this.transport = transport;
-    this.closed = false;
-    this.projectPath = options.projectPath || process.cwd();
-  }
-
-  static async connect({ launcher, workingDirectory, extraEnv, projectPath }) {
-    if (!fs.existsSync(launcher.args[0])) {
-      throw new Error(`Conductor MCP server not found at ${launcher.args[0]}`);
-    }
-
-    const transport = new StdioClientTransport({
-      command: launcher.command,
-      args: launcher.args,
-      env: extraEnv,
-      cwd: launcher.cwd || workingDirectory,
-      stderr: "pipe",
-    });
-
-    const client = new Client({
-      name: CLI_NAME,
-      version: pkgJson.version,
-    });
-
-    client.onerror = (err) => {
-      log(`MCP client error: ${err.message}`);
-    };
-
-    const stderr = transport.stderr;
-    if (stderr) {
-      stderr.setEncoding("utf-8");
-      stderr.on("data", (chunk) => {
-        const text = chunk.toString();
-        const ts = new Date().toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" }).replace(" ", "T");
-        text
-          .split(/\r?\n/)
-          .filter(Boolean)
-          .forEach((line) => process.stderr.write(`[conductor ${ts}] ${line}\n`));
-      });
-    }
-
-    await client.connect(transport);
-    return new ConductorClient(client, transport, { projectPath });
-  }
-
-  async close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    await this.client.close();
-    await this.transport.close();
-  }
-
-  injectProjectPath(payload = {}) {
-    if (!this.projectPath || payload.project_path) {
-      return payload;
-    }
-    return { ...payload, project_path: this.projectPath };
-  }
-
-  async createTaskSession(payload) {
-    const args = payload ? { ...payload } : {};
-    return this.callTool("create_task_session", this.injectProjectPath(args));
-  }
-
-  async sendMessage(taskId, content, metadata) {
-    return this.callTool("send_message", {
-      task_id: taskId,
-      content,
-      metadata,
-    });
-  }
-
-  async sendTaskStatus(taskId, payload) {
-    return this.callTool("send_task_status", {
-      task_id: taskId,
-      ...(payload || {}),
-    });
-  }
-
-  async sendRuntimeStatus(taskId, payload) {
-    return this.callTool("send_runtime_status", {
-      task_id: taskId,
-      ...(payload || {}),
-    });
-  }
-
-  async receiveMessages(taskId, limit = 20) {
-    return this.callTool("receive_messages", {
-      task_id: taskId,
-      limit,
-    });
-  }
-
-  async ackMessages(taskId, ackToken) {
-    if (!ackToken) {
-      return;
-    }
-    await this.callTool("ack_messages", { task_id: taskId, ack_token: ackToken });
-  }
-
-  async listProjects() {
-    return this.callTool("list_projects", {});
-  }
-
-  async createProject(name, description, metadata) {
-    return this.callTool("create_project", {
-      name,
-      description,
-      metadata,
-    });
-  }
-
-  async getLocalProjectRecord() {
-    return this.callTool("get_local_project_id", this.injectProjectPath({}));
-  }
-
-  async matchProjectByPath() {
-    return this.callTool("match_project_by_path", this.injectProjectPath({}));
-  }
-
-  async bindProjectPath(projectId) {
-    return this.callTool("bind_project_path", this.injectProjectPath({ project_id: projectId }));
-  }
-
-  async callTool(name, args) {
-    const result = await this.client.callTool({
-      name,
-      arguments: args || {},
-    });
-    if (result?.isError) {
-      const message = extractFirstText(result?.content) || `tool ${name} failed`;
-      throw new Error(message);
-    }
-    const structured = result?.structuredContent;
-    if (structured && Object.keys(structured).length > 0) {
-      return structured;
-    }
-    const textPayload = extractFirstText(result?.content);
-    if (!textPayload) {
-      return undefined;
-    }
-    try {
-      return JSON.parse(textPayload);
-    } catch {
-      return textPayload;
-    }
-  }
-}
-
-function extractFirstText(blocks) {
-  if (!Array.isArray(blocks)) {
-    return "";
-  }
-  for (const block of blocks) {
-    if (block?.type === "text" && typeof block.text === "string") {
-      const trimmed = block.text.trim();
-      if (trimmed) {
-        return trimmed;
-      }
-    }
-  }
-  return "";
-}
-
 class BridgeRunner {
   constructor({
     backendSession,
@@ -1164,6 +1061,8 @@ class BridgeRunner {
     this.runningTurn = false;
     this.processedMessageIds = new Set();
     this.lastRuntimeStatusSignature = null;
+    this.lastRuntimeStatusPayload = null;
+    this.needsReconnectRecovery = false;
   }
 
   async start(abortSignal) {
@@ -1179,6 +1078,9 @@ class BridgeRunner {
     await this.backfillPendingUserMessages();
 
     while (!this.stopped) {
+      if (this.needsReconnectRecovery && !this.runningTurn) {
+        await this.recoverAfterReconnect();
+      }
       let processed = false;
       try {
         processed = await this.processIncomingBatch();
@@ -1192,6 +1094,26 @@ class BridgeRunner {
     }
   }
 
+  noteReconnect() {
+    this.needsReconnectRecovery = true;
+  }
+
+  async recoverAfterReconnect() {
+    if (!this.needsReconnectRecovery) {
+      return;
+    }
+    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).
+    if (process.env.CONDUCTOR_FIRE_RECONNECT_BACKFILL === "1") {
+      await this.backfillPendingUserMessages();
+    }
+    await this.replayLastRuntimeStatus();
+  }
+
   async processIncomingBatch() {
     const result = await this.conductor.receiveMessages(this.taskId, 20);
     const messages = Array.isArray(result?.messages) ? result.messages : [];
@@ -1313,6 +1235,9 @@ class BridgeRunner {
       return;
     }
     this.lastRuntimeStatusSignature = signature;
+    this.lastRuntimeStatusPayload = {
+      ...runtime,
+    };
 
     try {
       await this.conductor.sendRuntimeStatus(this.taskId, {
@@ -1324,6 +1249,20 @@ class BridgeRunner {
     }
   }
 
+  async replayLastRuntimeStatus() {
+    if (!this.lastRuntimeStatusPayload) {
+      return;
+    }
+    try {
+      await this.conductor.sendRuntimeStatus(this.taskId, {
+        ...this.lastRuntimeStatusPayload,
+        created_at: new Date().toISOString(),
+      });
+    } catch (error) {
+      log(`Failed to replay runtime status after reconnect: ${error?.message || error}`);
+    }
+  }
+
   async respondToMessage(message) {
     const content = String(message.content || "").trim();
     if (!content) {
@@ -1334,6 +1273,7 @@ class BridgeRunner {
       return;
     }
     this.lastRuntimeStatusSignature = null;
+    this.runningTurn = true;
     log(`Processing message ${replyTo} (${message.role})`);
     try {
       await this.reportRuntimeStatus(
@@ -1392,11 +1332,14 @@ class BridgeRunner {
         replyTo,
       );
       await this.reportError(`${this.backendName} 处理失败: ${errorMessage}`, replyTo);
+    } finally {
+      this.runningTurn = false;
     }
   }
 
   async handleSyntheticMessage(content, { includeImages }) {
     this.lastRuntimeStatusSignature = null;
+    this.runningTurn = true;
     try {
       const result = await this.backendSession.runTurn(content, {
         useInitialImages: includeImages,
@@ -1423,6 +1366,8 @@ class BridgeRunner {
       });
     } catch (error) {
       await this.reportError(`初始提示执行失败: ${error.message}`);
+    } finally {
+      this.runningTurn = false;
     }
   }
 

package/package.json

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

package/src/daemon.js

@@ -272,6 +272,7 @@ export function startDaemon(config = {}, deps = {}) {
   let didRecoverStaleTasks = false;
   const activeTaskProcesses = new Map();
   const suppressedExitStatusReports = new Set();
+  const seenCommandRequestIds = new Set();
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders: {
       "x-conductor-host": AGENT_NAME,
@@ -282,11 +283,18 @@ export function startDaemon(config = {}, deps = {}) {
         log("Connected to backend");
       }
       disconnectedSinceLastConnectedLog = false;
+      sendAgentResume(isReconnect).catch((error) => {
+        logError(`sendAgentResume failed: ${error?.message || error}`);
+      });
       if (!didRecoverStaleTasks) {
         didRecoverStaleTasks = true;
         recoverStaleTasks().catch((error) => {
           logError(`recoverStaleTasks failed: ${error?.message || error}`);
         });
+      } else if (isReconnect) {
+        reconcileAssignedTasks().catch((error) => {
+          logError(`reconcileAssignedTasks failed: ${error?.message || error}`);
+        });
       }
     },
     onDisconnected: () => {
@@ -356,6 +364,102 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
+  async function reconcileAssignedTasks() {
+    try {
+      const response = await fetchFn(`${BACKEND_HTTP}/api/tasks`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${AGENT_TOKEN}`,
+          Accept: "application/json",
+        },
+      });
+      if (!response.ok) {
+        logError(`Failed to reconcile tasks: HTTP ${response.status}`);
+        return;
+      }
+      const tasks = await response.json();
+      if (!Array.isArray(tasks)) {
+        return;
+      }
+      const localTaskIds = new Set(activeTaskProcesses.keys());
+      const assigned = tasks.filter((task) => {
+        const agentHost = String(task?.agent_host || "").trim();
+        const status = String(task?.status || "").trim().toLowerCase();
+        return agentHost === AGENT_NAME && (status === "unknown" || status === "running");
+      });
+
+      let killedCount = 0;
+      for (const task of assigned) {
+        const taskId = String(task?.id || "");
+        if (!taskId) continue;
+        if (localTaskIds.has(taskId)) {
+          continue;
+        }
+        const patchResp = await fetchFn(`${BACKEND_HTTP}/api/tasks/${taskId}`, {
+          method: "PATCH",
+          headers: {
+            Authorization: `Bearer ${AGENT_TOKEN}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ status: "killed" }),
+        });
+        if (patchResp.ok) {
+          killedCount += 1;
+        } else {
+          logError(`Failed to reconcile stale task ${taskId}: HTTP ${patchResp.status}`);
+        }
+      }
+
+      if (assigned.length || localTaskIds.size) {
+        log(
+          `Reconciled tasks after reconnect: backendAssigned=${assigned.length} localActive=${localTaskIds.size} markedKilled=${killedCount}`,
+        );
+      }
+    } catch (error) {
+      logError(`reconcileAssignedTasks error: ${error?.message || error}`);
+    }
+  }
+
+  async function sendAgentResume(isReconnect = false) {
+    await client.sendJson({
+      type: "agent_resume",
+      payload: {
+        active_tasks: [...activeTaskProcesses.keys()],
+        source: "conductor-daemon",
+        metadata: { is_reconnect: Boolean(isReconnect) },
+      },
+    });
+  }
+
+  function markRequestSeen(requestId) {
+    if (!requestId) return true;
+    if (seenCommandRequestIds.has(requestId)) {
+      return false;
+    }
+    seenCommandRequestIds.add(requestId);
+    if (seenCommandRequestIds.size > 2000) {
+      const first = seenCommandRequestIds.values().next();
+      if (!first.done) {
+        seenCommandRequestIds.delete(first.value);
+      }
+    }
+    return true;
+  }
+
+  function sendAgentCommandAck({ requestId, taskId, eventType, accepted = true }) {
+    if (!requestId) return Promise.resolve();
+    return client.sendJson({
+      type: "agent_command_ack",
+      payload: {
+        request_id: String(requestId),
+        task_id: taskId ? String(taskId) : undefined,
+        event_type: eventType,
+        accepted: Boolean(accepted),
+      },
+    });
+  }
+
   function handleEvent(event) {
     if (event.type === "create_task") {
       handleCreateTask(event.payload);
@@ -369,8 +473,18 @@ export function startDaemon(config = {}, deps = {}) {
   function handleStopTask(payload) {
     const taskId = payload?.task_id;
     if (!taskId) return;
-
     const requestId = payload?.request_id ? String(payload.request_id) : "";
+    if (requestId && !markRequestSeen(requestId)) {
+      log(`Duplicate stop_task ignored for ${taskId} (request_id=${requestId})`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "stop_task",
+        accepted: true,
+      }).catch(() => {});
+      return;
+    }
+
     const sendStopAck = (accepted) => {
       if (!requestId) return;
       client
@@ -385,6 +499,14 @@ export function startDaemon(config = {}, deps = {}) {
         .catch((err) => {
           logError(`Failed to report task_stop_ack for ${taskId}: ${err?.message || err}`);
         });
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "stop_task",
+        accepted,
+      }).catch((err) => {
+        logError(`Failed to report agent_command_ack(stop_task) for ${taskId}: ${err?.message || err}`);
+      });
     };
 
     const record = activeTaskProcesses.get(taskId);
@@ -485,11 +607,35 @@ export function startDaemon(config = {}, deps = {}) {
   }
 
   async function handleCreateTask(payload) {
-    const { task_id: taskId, project_id: projectId, backend_type: backendType, initial_content: initialContent } =
+    const {
+      task_id: taskId,
+      project_id: projectId,
+      backend_type: backendType,
+      initial_content: initialContent,
+      request_id: requestIdRaw,
+    } =
       payload || {};
+    const requestId = requestIdRaw ? String(requestIdRaw) : "";
 
     if (!taskId || !projectId) {
       logError(`Invalid create_task payload: ${JSON.stringify(payload)}`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_task",
+        accepted: false,
+      }).catch(() => {});
+      return;
+    }
+
+    if (requestId && !markRequestSeen(requestId)) {
+      log(`Duplicate create_task ignored for ${taskId} (request_id=${requestId})`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_task",
+        accepted: true,
+      }).catch(() => {});
       return;
     }
 
@@ -497,6 +643,12 @@ export function startDaemon(config = {}, deps = {}) {
     const effectiveBackend = backendType || SUPPORTED_BACKENDS[0];
     if (!SUPPORTED_BACKENDS.includes(effectiveBackend)) {
       logError(`Unsupported backend: ${effectiveBackend}. Supported: ${SUPPORTED_BACKENDS.join(", ")}`);
+      sendAgentCommandAck({
+        requestId,
+        taskId,
+        eventType: "create_task",
+        accepted: false,
+      }).catch(() => {});
       client
         .sendJson({
           type: "task_status_update",
@@ -511,6 +663,15 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
+    sendAgentCommandAck({
+      requestId,
+      taskId,
+      eventType: "create_task",
+      accepted: true,
+    }).catch((err) => {
+      logError(`Failed to report agent_command_ack(create_task) for ${taskId}: ${err?.message || err}`);
+    });
+
     const cliCommand = ALLOW_CLI_LIST[effectiveBackend];
 
     log("");