@love-moon/conductor-cli 0.13.0 → 0.13.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @love-moon/conductor-cli
 
+## 0.13.1
+
+### Patch Changes
+
+- 3948125: Support persistent task rounds (RFC 0039). A `create_task` carrying
+  `replace_existing_fire: true` releases the task's previous fire before starting
+  the new round instead of ignoring it as a duplicate: tmux sessions are probed
+  (and killed if still alive), child processes are stopped and awaited, the old
+  fire's terminal status is suppressed, and its undelivered KILLED/COMPLETED
+  events are purged from the reused directory. The tmux liveness reaper also stops
+  reporting a dead session for a task whose new round is still starting. The
+  daemon advertises this as the `persistent_round_v1` capability.
+  - @love-moon/conductor-sdk@0.13.1
+  - @love-moon/ai-sdk@0.13.1
+
 ## 0.13.0
 
 ### Minor Changes

package/bin/conductor-fire.js

@@ -28,6 +28,7 @@ import {
 } from "../src/fire/resume.js";
 import {
   filterRuntimeSupportedAllowCliList,
+  inferBuiltInRuntimeBackendFromCommand,
   isBuiltInRuntimeBackend,
   isCommandOptionalBuiltInRuntimeBackend,
   listAdvertisedBackends,
@@ -218,7 +219,22 @@ export function resolveAiSessionCommandLine(backend, allowCliList, env = process
   const daemonCommand =
     typeof env?.CONDUCTOR_CLI_COMMAND === "string" ? env.CONDUCTOR_CLI_COMMAND.trim() : "";
 
-  const resolvedCommand = configuredCommand || daemonCommand;
+  // CONDUCTOR_CLI_COMMAND may be stale: a tmux-mode Fire inherits the tmux
+  // SERVER's global environment for variables the daemon did not explicitly
+  // override, so a value left by another backend's task (e.g. `claude --model
+  // opus` reaching a dsh task) can leak in. Only honor the fallback when the
+  // command does not provably belong to a different built-in backend. Commands
+  // whose executable is not a known backend name (custom wrappers) are kept.
+  const inferredDaemonBackend = daemonCommand ? inferBuiltInRuntimeBackendFromCommand(daemonCommand) : "";
+  const usableDaemonCommand =
+    daemonCommand &&
+    (!inferredDaemonBackend ||
+      inferredDaemonBackend === normalizedSessionBackend ||
+      inferredDaemonBackend === normalizedBackend)
+      ? daemonCommand
+      : "";
+
+  const resolvedCommand = configuredCommand || usableDaemonCommand;
   if (!resolvedCommand) {
     return "";
   }
@@ -246,6 +262,12 @@ const DEFAULT_POLL_INTERVAL_MS = parseInt(
 const DEFAULT_ERROR_LOOP_WINDOW_MS = 2 * 60 * 1000;
 const DEFAULT_ERROR_LOOP_BACKOFF_MS = 3 * 60 * 1000;
 const DEFAULT_ERROR_LOOP_THRESHOLD = 3;
+// A running turn that has sent no runtime status for this long reports the
+// provider's current tool so the app does not mistake a long tool for a hang.
+const DEFAULT_RUNTIME_HEARTBEAT_MS = 60 * 1000;
+const RUNTIME_HEARTBEAT_QUERY_TIMEOUT_MS = 5000;
+// Keep the line within the web chat status pill.
+const RUNTIME_HEARTBEAT_LINE_MAX_CHARS = 100;
 // Runtime backend tokens (first word of the resolved command line) that mean
 // "this task drives a chat-web Chromium browser". Mirrors ai-sdk's chat-web
 // aliases; user-facing aliases like `web-chatgpt` resolve to one of these.
@@ -738,6 +760,11 @@ async function main() {
     return await pendingRemoteInterruptQueue.enqueue(event);
   };
 
+  const handleReportRuntimeStatusCommand = async (event) => {
+    fireWatchdog.onInbound();
+    await reconnectRunner?.requestRuntimeStatusFromRemote?.(event || {});
+  };
+
   const rememberCompletedRefreshSessionRequest = (requestId, accepted) => {
     if (!requestId) {
       return accepted;
@@ -828,6 +855,7 @@ async function main() {
       onStopTask: handleStopTaskCommand,
       onInterruptTurn: handleInterruptTurnCommand,
       onRefreshSession: handleRefreshSessionCommand,
+      onReportRuntimeStatus: handleReportRuntimeStatusCommand,
     });
 
     const taskContext = await ensureTaskContext(conductor, {
@@ -1806,15 +1834,28 @@ async function resolveDefaultProjectId(conductor) {
   }
 }
 
-function deriveTaskTitle(prompt, explicit, backend = "codex") {
+// Keep in sync with web/src/features/tasks/utils/default-task-title.ts: first clause,
+// capped at 20 display columns (CJK/full-width/emoji = 2) so it fits the mobile header.
+export function deriveTaskTitle(prompt, explicit, backend = "codex") {
   if (explicit && explicit.trim()) {
     return explicit.trim();
   }
-  if (prompt) {
-    const compact = prompt.replace(/\s+/g, " ").trim();
-    if (compact) {
-      return compact.slice(0, 80);
+  const text = (prompt || "").trim();
+  const breakIndex = text.search(/[，。！？；\n]|[,.!?;](?=\s|$)/);
+  const clause = (breakIndex > 0 ? text.slice(0, breakIndex) : text).replace(/\s+/g, " ");
+  let title = "";
+  let width = 0;
+  for (const char of clause) {
+    width += char.codePointAt(0) >= 0x2e80 ? 2 : 1;
+    if (width > 20) {
+      // Never cut an English word in half; drop the partial word unless it is the only one.
+      if (/\w$/.test(title) && /\w/.test(char)) title = title.replace(/\s*\w+$/, "") || title;
+      break;
     }
+    title += char;
+  }
+  if (title.trim()) {
+    return title.trim();
   }
   const backendName = backend.charAt(0).toUpperCase() + backend.slice(1);
   return `${backendName} Task`;
@@ -1917,6 +1958,14 @@ function isTruthyEnv(value) {
   return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
 }
 
+function formatElapsedShort(ms) {
+  const seconds = Math.max(0, Math.floor(ms / 1000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+
 function isSessionClosedError(error) {
   return Boolean(error && typeof error === "object" && error.reason === "session_closed");
 }
@@ -2018,6 +2067,14 @@ export class BridgeRunner {
       500,
       60 * 1000,
     );
+    this.runtimeHeartbeatMs = getBoundedEnvInt(
+      "CONDUCTOR_RUNTIME_HEARTBEAT_MS",
+      DEFAULT_RUNTIME_HEARTBEAT_MS,
+      1000,
+      10 * 60 * 1000,
+    );
+    this.runtimeHeartbeatTimer = null;
+    this.turnStartedAt = 0;
     this.useSessionFileReplyStream =
       Boolean(this.backendSession) &&
       typeof this.backendSession.usesSessionFileReplyStream === "function" &&
@@ -2853,7 +2910,7 @@ export class BridgeRunner {
     };
   }
 
-  async reportRuntimeStatus(payload, replyTo) {
+  async reportRuntimeStatus(payload, replyTo, { force = false } = {}) {
     const runtimeContext = await this.resolveRuntimeContext();
     const runtime = this.createRuntimeStatus(payload, replyTo, runtimeContext);
     if (!runtime) {
@@ -2861,10 +2918,14 @@ export class BridgeRunner {
     }
 
     const signature = JSON.stringify(runtime);
-    if (signature === this.lastRuntimeStatusSignature) {
+    if (!force && signature === this.lastRuntimeStatusSignature) {
       return;
     }
-    this.lastRuntimeStatusSignature = signature;
+    // Heartbeats keep the provider's last signature, so its unchanged periodic
+    // status (e.g. claude tool_progress) does not replace the heartbeat line.
+    if (!force) {
+      this.lastRuntimeStatusSignature = signature;
+    }
     this.lastRuntimeStatusPayload = {
       ...runtime,
     };
@@ -2882,6 +2943,109 @@ export class BridgeRunner {
     } catch (error) {
       log(`Failed to report runtime status: ${error?.message || error}`);
     }
+    this.scheduleRuntimeHeartbeat();
+  }
+
+  /** (Re)start the silence timer; a no-op that just clears it outside a turn. */
+  scheduleRuntimeHeartbeat() {
+    clearTimeout(this.runtimeHeartbeatTimer);
+    this.runtimeHeartbeatTimer = null;
+    if (!this.runningTurn || this.stopped) {
+      return;
+    }
+    this.runtimeHeartbeatTimer = setTimeout(() => {
+      this.runtimeHeartbeatTimer = null;
+      void this.reportRuntimeHeartbeat();
+    }, this.runtimeHeartbeatMs);
+    this.runtimeHeartbeatTimer.unref?.();
+  }
+
+  async fetchBackendTurnStatus() {
+    const session = this.backendSession;
+    if (typeof session?.fetchCurrentTurnStatus === "function") {
+      let timer = null;
+      try {
+        return await Promise.race([
+          session.fetchCurrentTurnStatus(),
+          new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("turn status query timed out")), RUNTIME_HEARTBEAT_QUERY_TIMEOUT_MS);
+          }),
+        ]);
+      } catch {
+        // fall back to the last status the session pushed
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    try {
+      return session?.getCurrentTurnStatus?.() ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  formatRuntimeHeartbeatLine(status, now = Date.now()) {
+    const clip = (text, max) => (text.length > max ? `${text.slice(0, max - 1)}…` : text);
+    const tool = status?.active_tool;
+    const startedAt = Date.parse(tool?.started_at || "") || this.turnStartedAt || now;
+    const elapsed = formatElapsedShort(now - startedAt);
+    // Elapsed time goes before the tool input so it survives truncation.
+    if (tool?.name) {
+      const summary = tool.summary ? `: ${tool.summary}` : "";
+      return clip(`${this.backendName} running ${tool.name} (${elapsed})${summary}`, RUNTIME_HEARTBEAT_LINE_MAX_CHARS);
+    }
+    const base = status?.status_line || `${this.backendName} is working`;
+    return `${clip(base, RUNTIME_HEARTBEAT_LINE_MAX_CHARS - elapsed.length - 3)} (${elapsed})`;
+  }
+
+  async reportRuntimeHeartbeat() {
+    if (!this.runningTurn || this.stopped) {
+      return;
+    }
+    const lastSent = this.lastRuntimeStatusPayload;
+    const status = await this.fetchBackendTurnStatus();
+    // Skip if the turn ended, the provider settled it, or a newer frame (e.g.
+    // the terminal one) went out while querying: never re-open a settled turn.
+    if (
+      !this.runningTurn ||
+      this.stopped ||
+      status?.reply_in_progress === false ||
+      this.lastRuntimeStatusPayload !== lastSent
+    ) {
+      return;
+    }
+    await this.reportRuntimeStatus(
+      {
+        state: status?.state,
+        phase: status?.phase || "heartbeat",
+        reply_in_progress: true,
+        status_line: this.formatRuntimeHeartbeatLine(status),
+      },
+      status?.replyTo || this.activeTurnReplyTo,
+      // Forced so an unchanged line still goes out and re-arms the timer.
+      { force: true },
+    );
+  }
+
+  /** App asked (page load / stale composer) for the current runtime status. */
+  async requestRuntimeStatusFromRemote(event = {}) {
+    const taskId = typeof event.taskId === "string" ? event.taskId.trim() : "";
+    if (taskId && taskId !== this.taskId) {
+      return;
+    }
+    if (this.runningTurn) {
+      await this.reportRuntimeHeartbeat();
+      return;
+    }
+    if (this.lastRuntimeStatusPayload?.reply_in_progress) {
+      // No turn is running, so an in-progress frame is stale; settle it.
+      this.lastRuntimeStatusPayload = {
+        ...this.lastRuntimeStatusPayload,
+        reply_in_progress: false,
+        status_line: undefined,
+      };
+    }
+    await this.replayLastRuntimeStatus();
   }
 
   async replayLastRuntimeStatus() {
@@ -3134,6 +3298,7 @@ export class BridgeRunner {
     this.runningTurn = true;
     this.activeTurnReplyTo = this.normalizeReplyTarget(replyTo);
     const turnStartedAt = Date.now();
+    this.turnStartedAt = turnStartedAt;
     let turnWatchdog = null;
     if (this.isCopilotBackend) {
       turnWatchdog = setInterval(() => {
@@ -3316,6 +3481,7 @@ export class BridgeRunner {
         `turn end replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} processedIds=${this.processedMessageIds.size}`,
       );
       this.runningTurn = false;
+      this.scheduleRuntimeHeartbeat();
     }
   }
 
@@ -3442,6 +3608,7 @@ export class BridgeRunner {
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
     const startedAt = Date.now();
+    this.turnStartedAt = startedAt;
     if (
       this.useSessionFileReplyStream &&
       typeof this.backendSession?.setSessionReplyTarget === "function"
@@ -3523,6 +3690,7 @@ export class BridgeRunner {
     } finally {
       this.copilotLog(`${logTag} turn end elapsedMs=${Date.now() - startedAt}`);
       this.runningTurn = false;
+      this.scheduleRuntimeHeartbeat();
     }
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.13.0",
-  "gitCommitId": "e1e507f",
+  "version": "0.13.1",
+  "gitCommitId": "b82ba1c",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -24,8 +24,8 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.13.0",
-    "@love-moon/conductor-sdk": "0.13.0",
+    "@love-moon/ai-sdk": "0.13.1",
+    "@love-moon/conductor-sdk": "0.13.1",
     "@github/copilot-sdk": "^0.3.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
@@ -38,7 +38,7 @@
   },
   "optionalDependencies": {
     "@roamhq/wrtc": "^0.10.0",
-    "@love-moon/chat-web": "0.13.0"
+    "@love-moon/chat-web": "0.13.1"
   },
   "pnpm": {
     "onlyBuiltDependencies": [

package/src/daemon.js

@@ -891,6 +891,27 @@ const PTY_TASK_SCOPED_ENV_KEYS = [
   "CONDUCTOR_RESUME_CWD",
 ];
 
+// Task-scoped env vars a Fire must NEVER inherit from anywhere but this
+// daemon's explicit choice. In tmux mode the new session merges the tmux
+// SERVER's global environment (inherited from whatever task first started the
+// server), so a variable the daemon sets only conditionally — e.g.
+// CONDUCTOR_CLI_COMMAND, which command-optional backends (dsh/copilot) leave
+// unset — would leak a stale value from an earlier task (2026-09-17: a dsh
+// task inherited `claude --model opus` and forwarded model=opus to the
+// DeepSeek API).
+//
+// The invariant is enforced at the single choke point `spawnFireProcess`:
+// every key in this list is passed to `tmux new-session` explicitly — either
+// with the daemon's value or cleared as `-e KEY=` (empty is our "unset"
+// convention; every consumer trims/negates before use). RULE: any new
+// task-scoped env var added to a Fire spawn must be registered here.
+const FIRE_TASK_SCOPED_ENV_KEYS = [
+  ...PTY_TASK_SCOPED_ENV_KEYS,
+  "CONDUCTOR_AGENT_TOKEN",
+  "CONDUCTOR_BACKEND_URL",
+  "CONDUCTOR_DAEMON_NAME",
+];
+
 function stripPtyTaskScopedEnv(source) {
   const env = {
     ...(source && typeof source === "object" ? source : {}),
@@ -1692,6 +1713,17 @@ export function startDaemon(config = {}, deps = {}) {
       tmuxEnvFlags.push("-e", `${key}=${stringValue}`);
     }
 
+    // Clear every task-scoped variable the daemon did NOT set for this task,
+    // or the session would inherit a stale value from the tmux server's
+    // global environment (see FIRE_TASK_SCOPED_ENV_KEYS). `-e KEY=` (empty)
+    // works on old tmux versions that lack the `-e KEY` unset form, and all
+    // our consumers treat "" as unset.
+    for (const scopedKey of FIRE_TASK_SCOPED_ENV_KEYS) {
+      if (env[scopedKey] === undefined || env[scopedKey] === null) {
+        tmuxEnvFlags.push("-e", `${scopedKey}=`);
+      }
+    }
+
     // Use a non-login `bash -c` here: node and the CLI script are passed by
     // absolute path, so we don't need PATH from a login shell, and `-l`
     // would slow startup and could leak unexpected stderr from user shell
@@ -2001,7 +2033,7 @@ export function startDaemon(config = {}, deps = {}) {
     // *live* replacement as killed, using the previous run's log tail. Worse,
     // the daemon's own map would say running, so reconcile would never repair
     // it. Re-check that the task is still absent before speaking.
-    if (activeTaskProcesses.has(taskId)) {
+    if (activeTaskProcesses.has(taskId) || pendingTaskStarts.has(taskId)) {
       log(
         `Task ${taskId} was restarted while its dead tmux session was being reported; dropping the stale terminal status`,
       );
@@ -3815,6 +3847,7 @@ export function startDaemon(config = {}, deps = {}) {
     "project_agents_registry",
     "restart_daemon",
     "refresh_session_inplace",
+    "persistent_round_v1",
     "task_attachments_v1",
     "backend_session_list",
     CUSTOM_COMMANDS_CAPABILITY,
@@ -6947,6 +6980,42 @@ export function startDaemon(config = {}, deps = {}) {
     return true;
   }
 
+  // RFC 0039: make sure the previous round's fire is gone before a new round
+  // reuses its task id. The server has normally stopped it already, so what is
+  // left is a still-exiting child or a tmux record the liveness reaper has not
+  // swept yet; a fire that is somehow still alive is stopped here. Its terminal
+  // status is suppressed because the task row now belongs to the new round.
+  async function releaseReplacedFire(taskId) {
+    const record = activeTaskProcesses.get(taskId);
+    if (!recordHasLiveFire(record)) {
+      return true;
+    }
+    if (record.tmuxMode) {
+      const { alive, conclusive } = await probeTmuxSession(record.tmuxSession);
+      if (activeTaskProcesses.get(taskId) !== record) {
+        return !recordHasLiveFire(activeTaskProcesses.get(taskId));
+      }
+      if (!conclusive) {
+        return false;
+      }
+      if (!alive) {
+        activeTaskProcesses.delete(taskId);
+        forgetFireSessionRecord(record);
+        return true;
+      }
+      stopActiveTaskProcess(taskId, { reason: "persistent_new_round", suppressExitStatusReport: true });
+      // The tmux stop path retires the record synchronously and never consumes the flag.
+      suppressedExitStatusReports.delete(taskId);
+      return !activeTaskProcesses.has(taskId);
+    }
+    stopActiveTaskProcess(taskId, { reason: "persistent_new_round", suppressExitStatusReport: true });
+    const stopped = await waitForTaskToStop(taskId);
+    if (!stopped) {
+      suppressedExitStatusReports.delete(taskId);
+    }
+    return stopped;
+  }
+
   async function waitForTaskToStop(taskId, timeoutMs = DAEMON_FORCE_STOP_GRACE_MS) {
     const deadline = Date.now() + Math.max(timeoutMs, 0);
 
@@ -7537,6 +7606,23 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
+    // RFC 0039: a persistent task's new round reuses the task id. Release the
+    // previous round's fire first instead of swallowing the round as a duplicate.
+    const replacesPreviousRound = payload?.replace_existing_fire === true;
+    if (
+      replacesPreviousRound &&
+      !pendingTaskStarts.has(taskId) &&
+      !(await releaseReplacedFire(taskId))
+    ) {
+      reportCreateTaskFailure({
+        taskId,
+        projectId,
+        requestId,
+        error: new Error("the previous round is still running on this daemon"),
+      });
+      return;
+    }
+
     const existingTaskRecord = activeTaskProcesses.get(taskId);
     if (recordHasLiveFire(existingTaskRecord) || pendingTaskStarts.has(taskId)) {
       log(
@@ -7679,7 +7765,13 @@ export function startDaemon(config = {}, deps = {}) {
         // even when the daemon was named through the config file.
         CONDUCTOR_DAEMON_NAME: AGENT_NAME,
         CONDUCTOR_LAUNCHED_BY_DAEMON: "1",
-        ...(cliCommand ? { CONDUCTOR_CLI_COMMAND: cliCommand } : {}),
+        // Always set CONDUCTOR_CLI_COMMAND — even to "" — so a tmux-mode Fire
+        // gets an explicit `-e CONDUCTOR_CLI_COMMAND=` that overrides any stale
+        // value in the tmux SERVER's global environment (inherited from whatever
+        // task first started the server). Without the override, a commandless
+        // backend (dsh/copilot) would see e.g. `claude --model opus` here and
+        // mis-apply its flags. Fire treats "" as unset.
+        CONDUCTOR_CLI_COMMAND: cliCommand,
       };
       if (AGENT_TOKEN) {
         env.CONDUCTOR_AGENT_TOKEN = AGENT_TOKEN;
@@ -7688,6 +7780,12 @@ export function startDaemon(config = {}, deps = {}) {
         env.CONDUCTOR_BACKEND_URL = BACKEND_HTTP;
       }
 
+      // A new round may reuse the previous round's directory, and with it that
+      // fire's undelivered KILLED/COMPLETED event (see restart below).
+      if (replacesPreviousRound) {
+        dropSupersededTerminalStatusEvents(taskDir, taskId);
+      }
+
       // Sampled before the spawn so it is a true "everything after this is
       // ours" watermark.
       const logStartOffset = readLogSize(logPath);
@@ -8422,7 +8520,10 @@ export function startDaemon(config = {}, deps = {}) {
       CONDUCTOR_TASK_ID: normalizedTargetTaskId,
       CONDUCTOR_DAEMON_NAME: AGENT_NAME,
       CONDUCTOR_LAUNCHED_BY_DAEMON: "1",
-      ...(cliCommand ? { CONDUCTOR_CLI_COMMAND: cliCommand } : {}),
+      // Always set CONDUCTOR_CLI_COMMAND — even to "" — so a tmux-mode Fire
+      // gets an explicit `-e CONDUCTOR_CLI_COMMAND=` that overrides any stale
+      // value in the tmux SERVER's global environment (see create_task).
+      CONDUCTOR_CLI_COMMAND: cliCommand,
     };
     env.CONDUCTOR_RESUME_CWD = resolvedResumeCwd;
     if (AGENT_TOKEN) {

package/src/serve-ai/index.js

@@ -11,6 +11,7 @@ import { loadServeAiRuntimeConfig } from "./config.js";
 import { sendJson, sendOpenAiError } from "./errors.js";
 import { materializeImageInputs } from "./image-handler.js";
 import {
+  inferBuiltInRuntimeBackendFromCommand,
   listAdvertisedBackends,
   normalizeRuntimeBackendAlias,
   normalizeRuntimeBackendName,
@@ -124,7 +125,7 @@ function extractModelOptionFromCommandLine(commandLine) {
   return "";
 }
 
-function resolveAiSessionCommandLine(backend, allowCliList, env = process.env, sessionBackend = backend) {
+export function resolveAiSessionCommandLine(backend, allowCliList, env = process.env, sessionBackend = backend) {
   const normalizedBackend = normalizeRuntimeBackendName(backend);
   const normalizedSessionBackend = normalizeRuntimeBackendName(sessionBackend);
   const envKeyByBackend = {
@@ -148,7 +149,21 @@ function resolveAiSessionCommandLine(backend, allowCliList, env = process.env, s
       : "";
   const daemonCommand =
     typeof env?.CONDUCTOR_CLI_COMMAND === "string" ? env.CONDUCTOR_CLI_COMMAND.trim() : "";
-  const resolvedCommand = configuredCommand || daemonCommand;
+
+  // CONDUCTOR_CLI_COMMAND may be stale (e.g. leaked from a tmux server's
+  // global environment, left by another backend's task). Only honor the
+  // fallback when the command does not provably belong to a different built-in
+  // backend. Mirrors the same guard in bin/conductor-fire.js.
+  const inferredDaemonBackend = daemonCommand ? inferBuiltInRuntimeBackendFromCommand(daemonCommand) : "";
+  const usableDaemonCommand =
+    daemonCommand &&
+    (!inferredDaemonBackend ||
+      inferredDaemonBackend === normalizedSessionBackend ||
+      inferredDaemonBackend === normalizedBackend)
+      ? daemonCommand
+      : "";
+
+  const resolvedCommand = configuredCommand || usableDaemonCommand;
   if (!resolvedCommand) {
     return "";
   }