@love-moon/conductor-cli 0.13.0 → 0.13.2

package/CHANGELOG.md

@@ -1,5 +1,83 @@
 # @love-moon/conductor-cli
 
+## 0.13.2
+
+### Patch Changes
+
+- 6547b2c: Add read-only daemon queries and archived-task search to the CLI:
+  `conductor daemon list [--all]` (online daemons, version, AI backends),
+  `conductor daemon tools <host>` (installed AI tools and reachability),
+  `conductor daemon quota <host> [--tool] [--refresh]` (usage windows / balance
+  per tool), and `conductor task list --archived [--search] [--all-projects]
+[--page]`. The SDK's `BackendApiClient` gains `listAgents`,
+  `getAiManagerStatus`, `getAiManagerQuota` and `listAchievedTasks` over the
+  existing web API routes; no server change.
+- 8c2833d: Support `/compact [focus instructions]` in task chats. Fire detects the command
+  per message (like `/goal`), runs the backend's native context compaction
+  instead of sending the text to the model, and posts one confirmation with the
+  token savings. Sessions advertise `capabilities.compact` and implement the new
+  optional `runCompact()`: claude (native `/compact`), codex app-server
+  (`thread/compact/start`), copilot (`session.history.compact`), kimi wire and
+  legacy print (built-in `/compact`), opencode (`session.summarize`) and dsh
+  (summary turn, then a fresh session seeded with the summary). Backends without
+  the capability (chat-web, codex exec, Kimi Code prompt mode) reply with a
+  not-supported notice. Opencode compaction summaries no longer surface as chat
+  replies, and dsh clears its "compacting context" status when automatic
+  compaction ends.
+- c3a55b8: Fix tmux-mode Fire launches that failed before Fire started. The daemon now
+  drops an inherited `TMUX`/`TMUX_PANE` at startup, so a daemon launched from
+  another user's tmux pane (e.g. `su` from root's session) no longer aims every
+  tmux call at that user's socket and fails with `error connecting to
+/tmp/tmux-0/default (Permission denied)`. A launch whose tmux argv would exceed
+  tmux's 16KB command limit (`command too long`), such as a persistent-round
+  prompt with a long summary, now runs through a self-deleting 0600 launch script
+  instead of `bash -c <command>`.
+- 8e3a4c3: Report how many model tokens each turn consumed. After every turn (or `/goal`)
+  `conductor fire` sends the turn's token count (fresh input + cache reads/writes +
+  output) over the new `task_turn_usage` websocket event, and the server adds it
+  to the task's running total shown in the task detail card. A persistent task's
+  total restarts with each round.
+
+  Failed or interrupted turns and `/compact` are counted too; when a turn's usage
+  is unknown the fire reports `null`, which clears the task's last-turn count.
+
+  - `@love-moon/conductor-sdk`: new `ConductorClient.sendTurnUsage(taskId, { tokens })`.
+  - `@love-moon/ai-sdk`: the Codex app-server provider's turn/goal `usage` now
+    carries `turnTotalTokens`, the turn's share of Codex's thread-cumulative total.
+    Claude and Codex turn errors carry the tokens spent before the failure as
+    `error.usage` (Claude sums streamed usage when an interrupted query ends
+    without a result).
+  - Claude and Codex backends are counted; other backends report nothing yet.
+
+- 6989999: `conductor task list --include-moved` also lists tasks moved into the project
+  from other projects (`project_id == P OR second_project_id == P`), with a MOVED
+  column naming the origin/target project. `--json` output now carries
+  `secondProjectId`. The SDK gains `TasksApi.listTasks({ includeMoved })`,
+  `BackendApiClient.listTasks({ projectScope: 'display' })` and
+  `Task/TaskSummary.secondProjectId`; it merges the server's existing real and
+  display scopes, so no server change is needed.
+- Updated dependencies [6547b2c]
+- Updated dependencies [8c2833d]
+- Updated dependencies [8e3a4c3]
+- Updated dependencies [6989999]
+  - @love-moon/conductor-sdk@0.13.2
+  - @love-moon/ai-sdk@0.13.2
+
+## 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-daemon-query.js

@@ -0,0 +1,185 @@
+/**
+ * conductor daemon list|tools|quota — read-only queries about daemons.
+ *
+ *   list [--all]                          Online daemons, CLI version, AI backends
+ *   tools <host>                          AI tools installed on a daemon + network
+ *   quota <host> [--tool t] [--refresh]   Usage windows / balance per AI tool
+ *
+ * Dispatched from conductor-daemon.js before any daemon startup logic.
+ */
+
+import process from "node:process";
+
+import yargs from "yargs/yargs";
+
+import { EXIT, buildApis, pad, printJson, printPretty, reportError } from "../src/entity-helpers.js";
+
+export const DAEMON_QUERY_VERBS = new Set(["list", "tools", "quota"]);
+
+// Ephemeral per-task `conductor fire` processes also register as agents.
+const FIRE_HOST_PREFIX = "conductor-fire-";
+
+const WINDOW_LABELS = { fiveHour: "5h", weekly: "weekly", weeklySonnet: "weekly-sonnet" };
+
+function printTable(stream, header, rows) {
+  const widths = header
+    .slice(0, -1)
+    .map((title, i) => Math.max(title.length, ...rows.map((row) => String(row[i]).length)));
+  for (const row of [header, ...rows]) {
+    printPretty(stream, row.map((cell, i) => (i < widths.length ? pad(cell, widths[i]) : cell)).join("  "));
+  }
+}
+
+function formatReset(window) {
+  if (typeof window.resetAt !== "number") return window.resetOnDate ?? "";
+  const date = new Date(window.resetAt * 1000);
+  const two = (n) => String(n).padStart(2, "0");
+  return `${two(date.getMonth() + 1)}-${two(date.getDate())} ${two(date.getHours())}:${two(date.getMinutes())}`;
+}
+
+function formatQuota(quota) {
+  if (!quota || typeof quota !== "object") return "";
+  if (quota.error) {
+    // Provider errors can embed multi-line response bodies; --json keeps the full text.
+    const text = String(quota.error).replace(/\s+/g, " ").trim();
+    return `error: ${text.length > 160 ? `${text.slice(0, 157)}...` : text}`;
+  }
+  const parts = [];
+  for (const [key, window] of Object.entries(quota)) {
+    // Copilot's `primary` duplicates one of its named windows.
+    if (key === "primary" || typeof window?.usedPercent !== "number") continue;
+    const reset = formatReset(window);
+    parts.push(`${WINDOW_LABELS[key] ?? key} ${Math.round(window.usedPercent)}% used${reset ? ` (resets ${reset})` : ""}`);
+  }
+  if (quota.credits?.unlimited) parts.push("credits unlimited");
+  else if (quota.credits?.balance != null) parts.push(`credits ${quota.credits.balance}`);
+  if (quota.primaryBalance) {
+    parts.push(`balance ${quota.primaryBalance.totalBalance} ${quota.primaryBalance.currency}`);
+  }
+  if (quota.overage?.status) {
+    const reason = quota.overage.disabledReason ? ` (${quota.overage.disabledReason})` : "";
+    parts.push(`overage ${quota.overage.status}${reason}`);
+  }
+  return parts.join(" · ") || "(no usage data)";
+}
+
+async function handleList(argv, deps) {
+  const { apiClient } = await buildApis(deps);
+  const agents = (await apiClient.listAgents())
+    .filter((agent) => argv.all || !String(agent.host).startsWith(FIRE_HOST_PREFIX));
+  if (argv.json) {
+    printJson(deps.stdout, agents);
+    return EXIT.OK;
+  }
+  if (agents.length === 0) {
+    printPretty(deps.stdout, "(no daemons online)");
+    return EXIT.OK;
+  }
+  printTable(deps.stdout, ["HOST", "VERSION", "BACKENDS"], agents.map((agent) => [
+    agent.shared ? `${agent.host} (shared by ${agent.ownerLabel})` : agent.host,
+    agent.version ?? "",
+    (agent.supportedBackends ?? []).join(","),
+  ]));
+  return EXIT.OK;
+}
+
+async function handleTools(argv, deps) {
+  const { apiClient } = await buildApis(deps);
+  const status = await apiClient.getAiManagerStatus(argv.host);
+  if (argv.json) {
+    printJson(deps.stdout, status);
+    return EXIT.OK;
+  }
+  const install = status?.install ?? {};
+  const network = status?.network ?? {};
+  printTable(deps.stdout, ["TOOL", "INSTALLED", "VERSION", "NETWORK"], Object.keys(install).map((tool) => {
+    const net = network[tool];
+    const reach = !install[tool]?.installed || !net
+      ? ""
+      : net.reachable
+        ? `ok${net.latencyMs != null ? ` (${net.latencyMs}ms)` : ""}`
+        : `unreachable${net.error ? `: ${net.error}` : ""}`;
+    return [tool, install[tool]?.installed ? "yes" : "no", install[tool]?.version ?? "", reach];
+  }));
+  return EXIT.OK;
+}
+
+async function handleQuota(argv, deps) {
+  const { apiClient } = await buildApis(deps);
+  const quota = await apiClient.getAiManagerQuota(argv.host, {
+    tool: argv.tool,
+    forceRefresh: argv.refresh,
+  });
+  if (argv.json) {
+    printJson(deps.stdout, quota);
+    return EXIT.OK;
+  }
+  const { external, ...tools } = quota ?? {};
+  const entries = [...Object.entries(tools), ...Object.entries(external ?? {})];
+  if (entries.length === 0) {
+    printPretty(deps.stdout, "(no quota data)");
+    return EXIT.OK;
+  }
+  printTable(deps.stdout, ["TOOL", "SOURCE", "QUOTA"], entries.map(([tool, entry]) => [
+    tool,
+    entry?.source ?? "",
+    formatQuota(entry),
+  ]));
+  return EXIT.OK;
+}
+
+export async function main(argvInput, deps = {}) {
+  const stdout = deps.stdout || process.stdout;
+  const stderr = deps.stderr || process.stderr;
+  const consoleErr = { error: (msg) => stderr.write(`${msg}\n`) };
+  const handlerDeps = { ...deps, stdout, stderr, env: deps.env || process.env, cwd: deps.cwd || process.cwd() };
+  let exitCode = EXIT.OK;
+  const run = (handler) => async (argv) => {
+    exitCode = await handler(argv, { ...handlerDeps, configFile: argv.configFile });
+  };
+
+  try {
+    await yargs(argvInput)
+      .scriptName("conductor daemon")
+      .strict()
+      .help()
+      .option("json", { type: "boolean", default: false })
+      .option("config-file", { type: "string", describe: "Path to Conductor config file" })
+      .command(
+        "list",
+        "List online daemons with their CLI version and AI backends",
+        (cmd) => cmd.option("all", {
+          type: "boolean",
+          default: false,
+          describe: `Include ephemeral ${FIRE_HOST_PREFIX}* hosts`,
+        }),
+        run(handleList),
+      )
+      .command(
+        "tools <host>",
+        "Show which AI tools are installed on a daemon and whether they are reachable",
+        (cmd) => cmd.positional("host", { type: "string", describe: "Daemon host name" }),
+        run(handleTools),
+      )
+      .command(
+        "quota <host>",
+        "Show usage windows / balance for each AI tool on a daemon",
+        (cmd) => cmd
+          .positional("host", { type: "string", describe: "Daemon host name" })
+          .option("tool", { type: "string", describe: "Only this tool, e.g. claude or codex" })
+          .option("refresh", { type: "boolean", default: false, describe: "Bypass the daemon's quota cache" }),
+        run(handleQuota),
+      )
+      .demandCommand(1)
+      .fail((msg, err) => {
+        // Throw so the command handler does not run after a validation error
+        // (e.g. a missing <host>); yargs keeps going if fail() returns.
+        if (err) throw err;
+        throw Object.assign(new Error(msg), { code: "ARGS" });
+      })
+      .parseAsync();
+  } catch (err) {
+    exitCode = reportError(consoleErr, err);
+  }
+  return exitCode;
+}

package/bin/conductor-daemon.js

@@ -20,9 +20,19 @@ import {
   describeForceRestartRefusal,
   parseDaemonLockState,
 } from "../src/daemon-lock.js";
+import { DAEMON_QUERY_VERBS, main as runDaemonQuery } from "./conductor-daemon-query.js";
 
 const argv = hideBin(process.argv);
 
+// `conductor daemon list|tools|quota` are read-only queries, not a daemon launch.
+// Exit (so startup below never runs) only after stdout drains: a piped
+// --json payload over 64KB would otherwise be cut off.
+if (DAEMON_QUERY_VERBS.has(argv[0])) {
+  const code = await runDaemonQuery(argv);
+  await new Promise((resolve) => process.stdout.write("", resolve));
+  process.exit(code);
+}
+
 const CLI_NAME = process.env.CONDUCTOR_CLI_NAME || "conductor-daemon";
 const CONDUCTOR_HOME = resolveConductorHome();
 
@@ -170,6 +180,7 @@ const args = yargs(argv)
   .example(`$0 --config-file ${resolveConductorConfigPath()}`, "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")
+  .example("$0 list | tools <host> | quota <host>", "Query online daemons, their AI tools and quota")
   .help()
   .strict()
   .parse();

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, {
@@ -1553,6 +1581,43 @@ export function parseGoalDirectiveFromMessage(content) {
   return objective ? { objective } : null;
 }
 
+/**
+ * Per-message `/compact` detector: first non-empty line is `/compact`
+ * (case-insensitive), optionally followed by focus instructions; any remaining
+ * lines are appended to them. Returns null when there is no directive.
+ */
+export function parseCompactDirectiveFromMessage(content) {
+  if (typeof content !== "string") {
+    return null;
+  }
+  const lines = content.split("\n");
+  let i = 0;
+  while (i < lines.length && lines[i].trim() === "") {
+    i += 1;
+  }
+  const match = i < lines.length ? lines[i].trim().match(/^\/compact(?:\s+(.*))?$/i) : null;
+  if (!match) {
+    return null;
+  }
+  const rest = lines.slice(i + 1).join("\n").trim();
+  return { instructions: [(match[1] || "").trim(), rest].filter(Boolean).join("\n\n") };
+}
+
+export function formatCompactReply(backendName, compact, instructions = "") {
+  if (compact?.status !== "compacted") {
+    return `${backendName} 当前没有可压缩的上下文。`;
+  }
+  const count = (value) => Number(value).toLocaleString("en-US");
+  const detail =
+    Number.isFinite(compact.preTokens) && Number.isFinite(compact.postTokens)
+      ? `（约 ${count(compact.preTokens)} → ${count(compact.postTokens)} tokens）`
+      : Number.isFinite(compact.tokensRemoved)
+        ? `（释放约 ${count(compact.tokensRemoved)} tokens）`
+        : "";
+  const ignored = instructions && !compact.instructionsApplied ? `\n${backendName} 不支持压缩附加说明，已忽略。` : "";
+  return `${backendName} 上下文已压缩${detail}。${ignored}`;
+}
+
 export function injectResolvedTaskId(taskId, env = process.env) {
   const normalizedTaskId = normalizeTaskId(taskId);
   if (!normalizedTaskId) {
@@ -1806,15 +1871,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 +1995,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 +2104,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 +2947,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 +2955,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 +2980,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 +3335,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(() => {
@@ -3175,6 +3377,7 @@ export class BridgeRunner {
         useInitialImages,
         media,
         contextFiles,
+        replyTo,
         onProgress: (payload) => {
           void this.reportRuntimeStatus(payload, replyTo);
         },
@@ -3316,6 +3519,7 @@ export class BridgeRunner {
         `turn end replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} processedIds=${this.processedMessageIds.size}`,
       );
       this.runningTurn = false;
+      this.scheduleRuntimeHeartbeat();
     }
   }
 
@@ -3381,10 +3585,17 @@ export class BridgeRunner {
       // best-effort
     }
 
+    const compactDirective = hasAttachmentInputs ? null : parseCompactDirectiveFromMessage(content);
+    if (compactDirective) {
+      return this.runCompactCommand(compactDirective, options);
+    }
+
     if (willRunGoal) {
-      const goalResult = await this.backendSession.runGoal(
-        { objective: goalDirective.objective, source: { type: "manual" } },
-        options,
+      const goalResult = await this.runWithTurnUsage(() =>
+        this.backendSession.runGoal(
+          { objective: goalDirective.objective, source: { type: "manual" } },
+          options,
+        ),
       );
       // Goal SDK is expected to return `{ text, goal, usage, metadata }`. We
       // normalize back into the runTurn-compatible shape downstream consumers
@@ -3401,7 +3612,81 @@ export class BridgeRunner {
         },
       };
     }
-    return this.backendSession.runTurn(content, options);
+    return this.runWithTurnUsage(() => this.backendSession.runTurn(content, options));
+  }
+
+  /** Runs one backend turn and reports its token count, including failed or interrupted turns. */
+  async runWithTurnUsage(runTurn) {
+    let result;
+    try {
+      result = await runTurn();
+    } catch (error) {
+      this.reportTurnUsage(error?.usage, { failed: true });
+      throw error;
+    }
+    this.reportTurnUsage(result?.usage);
+    return result;
+  }
+
+  /**
+   * Best-effort: report a turn's token count to the server. A failed turn with
+   * unknown usage reports `null` so the task card drops the previous turn's count.
+   */
+  reportTurnUsage(usage, { failed = false } = {}) {
+    const tokens = countTurnTokens(usage);
+    if ((tokens === null && !failed) || typeof this.conductor?.sendTurnUsage !== "function") {
+      return;
+    }
+    Promise.resolve()
+      .then(() => this.conductor.sendTurnUsage(this.taskId, { tokens }))
+      .catch((error) => {
+        log(`Failed to report turn usage: ${error?.message || error}`);
+      });
+  }
+
+  /**
+   * `/compact`: compact the backend's context instead of sending the message
+   * to the model. Providers stay silent while compacting, so fire posts the
+   * single confirmation itself; backends without the capability get a notice
+   * rather than having `/compact` forwarded as prose.
+   */
+  async runCompactCommand({ instructions }, { onProgress, replyTo = "" } = {}) {
+    const snapshot =
+      typeof this.backendSession?.getSnapshot === "function" ? this.backendSession.getSnapshot() : null;
+    const compactCapable =
+      snapshot?.capabilities?.compact === true && typeof this.backendSession?.runCompact === "function";
+    let result = null;
+    let text;
+    if (compactCapable) {
+      onProgress?.({
+        phase: "context_compaction",
+        reply_in_progress: true,
+        status_line: `${this.backendName} compacting context`,
+      });
+      result = await this.runWithTurnUsage(() => this.backendSession.runCompact({ instructions }, { onProgress }));
+      text = formatCompactReply(this.backendName, result?.compact, instructions);
+    } else {
+      text = `${this.backendName} 不支持 /compact，未执行压缩。`;
+    }
+    // Fire owns this reply, so it also settles the status: providers' noop
+    // paths return without emitting any progress of their own.
+    onProgress?.({ phase: "turn_completed", reply_in_progress: false, status_done_line: text });
+    log(`[compact] backend=${this.backendName} capable=${compactCapable} status=${result?.compact?.status || "unsupported"}`);
+    if (this.useSessionFileReplyStream && !this.stopped) {
+      try {
+        await this.sendSessionStreamMessage({ text, replyTo });
+      } catch (error) {
+        log(`[compact] failed to post confirmation: ${error?.message || error}`);
+      }
+    }
+    return {
+      text,
+      items: [],
+      usage: result?.usage || null,
+      provider: this.backendName,
+      events: [],
+      metadata: { ...(result?.metadata || {}), compact: result?.compact || null },
+    };
   }
 
   async handlePrePromptMessage(content) {
@@ -3442,6 +3727,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"
@@ -3470,6 +3756,7 @@ export class BridgeRunner {
     try {
       const result = await this.dispatchBackendTurn(content, {
         useInitialImages: Boolean(includeImages),
+        replyTo: replyTarget,
         onProgress: (payload) => {
           void this.reportRuntimeStatus(payload, replyTarget);
         },
@@ -3523,6 +3810,7 @@ export class BridgeRunner {
     } finally {
       this.copilotLog(`${logTag} turn end elapsedMs=${Date.now() - startedAt}`);
       this.runningTurn = false;
+      this.scheduleRuntimeHeartbeat();
     }
   }
 
@@ -3584,6 +3872,24 @@ function log(message) {
   appendFireLocalLog(line);
 }
 
+/**
+ * Tokens one turn consumed: everything the model read (fresh input plus cache
+ * reads/writes) and wrote. Claude reports per-turn usage; the Codex provider
+ * derives `turnTotalTokens` from thread totals. Other shapes → null.
+ */
+export function countTurnTokens(usage) {
+  if (!usage || typeof usage !== "object") {
+    return null;
+  }
+  if (Number.isFinite(usage.turnTotalTokens)) {
+    return usage.turnTotalTokens;
+  }
+  const counts = ["input_tokens", "cache_creation_input_tokens", "cache_read_input_tokens", "output_tokens"]
+    .map((key) => Number(usage[key]))
+    .filter(Number.isFinite);
+  return counts.length > 0 ? counts.reduce((sum, count) => sum + count, 0) : null;
+}
+
 function logBackendReply(backend, text, { usage, replyTo }) {
   const usageSuffix = usage?.total_tokens ? ` (tokens: ${usage.total_tokens})` : "";
   log(`${backend} reply (${replyTo}): ${text}${usageSuffix}`);

package/bin/conductor-task.js

@@ -4,7 +4,8 @@
  * conductor task — entity-oriented task management.
  *
  * Subcommands:
- *   list [--project ...] [--issue <id>] [--status ...]
+ *   list [--project ...] [--issue <id>] [--status ...] [--include-moved]
+ *   list --archived [--search <text>] [--all-projects] [--page N]
  *   create --title <title> [--prompt <prompt>] [--backend <backend>]
  *          [--parent-task-id <id>] [--project ...]
  *   show <id>
@@ -59,6 +60,7 @@ function taskAsObject(task) {
   return {
     id: task.id,
     projectId: task.projectId,
+    secondProjectId: task.secondProjectId ?? null,
     issueId: task.issueId ?? null,
     title: task.title,
     status: task.status,
@@ -220,13 +222,83 @@ function formatContentPreview(value) {
   return `${text.slice(0, 57)}...`;
 }
 
+// "from <project>" for tasks moved into `projectId`, "to <project>" for tasks
+// moved out of it, "" otherwise. Project names are only fetched when needed.
+async function buildMovedLabels(apis, projectId, tasks) {
+  const moved = tasks.map((task) => {
+    if (task.secondProjectId === projectId && task.projectId !== projectId) {
+      return { dir: "from", id: task.projectId };
+    }
+    if (task.projectId === projectId && task.secondProjectId && task.secondProjectId !== projectId) {
+      return { dir: "to", id: task.secondProjectId };
+    }
+    return null;
+  });
+  const names = new Map();
+  if (moved.some(Boolean)) {
+    for (const p of await apis.projects.listProjects({ includeHidden: true })) {
+      names.set(p.id, p.daemonHost ? `${p.name ?? p.id}@${p.daemonHost}` : (p.name ?? p.id));
+    }
+  }
+  return moved.map((m) => (m ? `${m.dir} ${names.get(m.id) ?? m.id}` : ""));
+}
+
+// Archived (achieved) tasks come from a separate search endpoint: 10 per page,
+// matched against title and transcript, newest-archived first.
+async function handleArchivedList(argv, deps, apis) {
+  const project = argv.allProjects
+    ? null
+    : await resolveProject(apis, { env: deps.env, cwd: deps.cwd, project: argv.project });
+  const result = await apis.apiClient.listAchievedTasks({
+    query: argv.search,
+    projectId: project?.id,
+    page: argv.page,
+  });
+  if (argv.json) {
+    printJson(deps.stdout, result);
+    return EXIT.OK;
+  }
+  if (result.tasks.length === 0) {
+    printPretty(deps.stdout, "(no archived tasks)");
+    return EXIT.OK;
+  }
+  const projectWidth = Math.max(7, ...result.tasks.map((task) => String(task.projectName ?? "").length));
+  printPretty(deps.stdout, `${pad("ID", 36)} ${pad("ARCHIVED", 10)} ${pad("PROJECT", projectWidth)} TITLE`);
+  for (const task of result.tasks) {
+    printPretty(
+      deps.stdout,
+      `${pad(task.id, 36)} ${pad(String(task.achievedAt ?? "").slice(0, 10), 10)} ${pad(task.projectName ?? "", projectWidth)} ${task.title ?? ""}`,
+    );
+    if (task.snippet) printPretty(deps.stdout, `    ${task.snippet}`);
+  }
+  if (result.totalPages > 1) {
+    printPretty(deps.stdout, `Page ${result.page}/${result.totalPages} (${result.total} archived tasks); use --page for more.`);
+  }
+  return EXIT.OK;
+}
+
 async function handleList(argv, deps) {
+  // Validated here rather than with yargs implies/conflicts: those count the
+  // boolean defaults as "set", and the parser's fail() does not stop the handler.
+  let argsProblem = null;
+  if (!argv.archived && (argv.search !== undefined || argv.allProjects || argv.page !== undefined)) {
+    argsProblem = "--search, --all-projects and --page require --archived";
+  } else if (argv.archived && (argv.issue || argv.status || argv.includeMoved || (argv.allProjects && argv.project))) {
+    argsProblem = "--archived cannot be combined with --issue, --status, --include-moved, or --project with --all-projects";
+  }
+  if (argsProblem) {
+    const err = new Error(argsProblem);
+    err.code = "ARGS";
+    throw err;
+  }
   const apis = await buildApis(deps);
+  if (argv.archived) return handleArchivedList(argv, deps, apis);
   const project = await resolveProject(apis, { env: deps.env, cwd: deps.cwd, project: argv.project });
   const list = await apis.tasks.listTasks({
     projectId: project.id,
     issueId: argv.issue ? String(argv.issue) : undefined,
     status: parseStatusList(argv.status),
+    includeMoved: argv.includeMoved,
   });
   const objects = (Array.isArray(list) ? list : []).map(taskAsObject);
   if (argv.json) {
@@ -237,13 +309,16 @@ async function handleList(argv, deps) {
     printPretty(deps.stdout, "(no tasks)");
     return EXIT.OK;
   }
-  printPretty(deps.stdout, `${pad("ID", 24)} ${pad("STATUS", 12)} TITLE`);
-  for (const task of objects) {
+  const movedLabels = argv.includeMoved ? await buildMovedLabels(apis, project.id, objects) : null;
+  const movedWidth = movedLabels ? Math.max(5, ...movedLabels.map((label) => label.length)) : 0;
+  const movedCol = (label) => (movedLabels ? `${pad(label, movedWidth)} ` : "");
+  printPretty(deps.stdout, `${pad("ID", 24)} ${pad("STATUS", 12)} ${movedCol("MOVED")}TITLE`);
+  objects.forEach((task, i) => {
     printPretty(
       deps.stdout,
-      `${pad(task.id, 24)} ${pad(task.status, 12)} ${task.title ?? ""}`,
+      `${pad(task.id, 24)} ${pad(task.status, 12)} ${movedCol(movedLabels?.[i] ?? "")}${task.title ?? ""}`,
     );
-  }
+  });
   return EXIT.OK;
 }
 
@@ -571,7 +646,16 @@ export async function main(argvInput = hideBin(process.argv), deps = {}) {
         "List tasks in a project",
         (cmd) => cmd
           .option("issue", { type: "string", describe: "Filter by linked issue id" })
-          .option("status", { type: "string", describe: "Comma-separated status filter" }),
+          .option("status", { type: "string", describe: "Comma-separated status filter" })
+          .option("include-moved", {
+            type: "boolean",
+            default: false,
+            describe: "Also list tasks moved into this project from other projects (adds a MOVED column)",
+          })
+          .option("archived", { type: "boolean", describe: "List archived tasks instead of active ones" })
+          .option("search", { type: "string", describe: "With --archived: match title or transcript text" })
+          .option("all-projects", { type: "boolean", describe: "With --archived: search every project" })
+          .option("page", { type: "number", describe: "With --archived: result page (10 per page)" }),
         async (argv) => {
           exitCode = await handleList(argv, { ...handlerDeps, configFile: argv.configFile });
         },

package/bin/conductor.js

@@ -127,7 +127,7 @@ Usage: conductor <subcommand> [options]
 
 Subcommands:
   fire      Run AI coding agents with Conductor integration
-  daemon    Start long-running daemon for task orchestration
+  daemon    Start long-running daemon (or: daemon list/tools/quota to query daemons)
   config    Interactive configuration setup
   update    Update the CLI to the latest version
   diagnose  Diagnose a task and print likely root cause
@@ -151,6 +151,7 @@ Examples:
   conductor fire -- "fix the bug"
   conductor fire --backend claude -- "add feature"
   conductor daemon --config-file ~/.conductor/config.yaml
+  conductor daemon quota macmini --tool claude
   conductor diagnose <task-id>
   conductor send-file ./screenshot.png
   conductor channel connect feishu

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.13.0",
-  "gitCommitId": "e1e507f",
+  "version": "0.13.2",
+  "gitCommitId": "d60a6a2",
   "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.2",
+    "@love-moon/conductor-sdk": "0.13.2",
     "@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.2"
   },
   "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 : {}),
@@ -1167,6 +1188,13 @@ export function startDaemon(config = {}, deps = {}) {
   // below after we verify tmux is installed; if tmux is missing we log a
   // warning and silently fall back to direct spawn rather than failing every
   // create_task with ENOENT.
+  //
+  // The daemon is not inside any tmux pane, so drop the launching shell's
+  // TMUX/TMUX_PANE: tmux prefers $TMUX over the per-uid default socket, and a
+  // daemon started via `su` from root's tmux pointed every spawn/probe/kill at
+  // /tmp/tmux-0/default ("Permission denied").
+  delete process.env.TMUX;
+  delete process.env.TMUX_PANE;
   const FIRE_TMUX_MODE_ENABLED = getFireTmuxModeEnabled(userConfig);
   // RFC 0035: a guest daemon runs on someone else's machine as a different
   // account. It keeps the ordinary daemon code path but drops the capabilities
@@ -1604,6 +1632,9 @@ export function startDaemon(config = {}, deps = {}) {
     return { attach, append, tail };
   }
 
+  // Headroom under tmux's 16384-byte imsg limit for a client command's argv.
+  const TMUX_ARGV_BYTE_BUDGET = 12 * 1024;
+
   // Spawn the Fire CLI either directly (default) or inside a detached tmux
   // session (when FIRE_TMUX_MODE_ACTIVE). In tmux mode the returned `child`
   // is the short-lived `tmux new-session` client; once it exits with code 0
@@ -1692,6 +1723,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
@@ -1708,7 +1750,21 @@ export function startDaemon(config = {}, deps = {}) {
       "-c",
       shellCommand,
     ];
-    log(`Spawning Fire via tmux: session=${sessionName} cwd=${cwd}`);
+    // tmux rejects a command whose argv exceeds its 16KB message limit
+    // ("command too long"). The -e flags alone can take ~8KB on GPU hosts, so
+    // a long prompt (e.g. a persistent-round summary) no longer fits: hand
+    // bash a self-deleting 0600 script instead of `-c <command>`.
+    let launchScriptPath = "";
+    if (tmuxArgs.reduce((n, arg) => n + Buffer.byteLength(arg) + 1, 0) > TMUX_ARGV_BYTE_BUDGET) {
+      launchScriptPath = path.join(FIRE_SESSION_REGISTRY_DIR, `${sessionName}.sh`);
+      mkdirSyncFn(FIRE_SESSION_REGISTRY_DIR, { recursive: true });
+      writeFileSyncFn(launchScriptPath, `rm -f -- "$0"\n${shellCommand}\n`, { mode: 0o600 });
+      tmuxArgs.splice(-2, 2, launchScriptPath);
+    }
+    log(
+      `Spawning Fire via tmux: session=${sessionName} cwd=${cwd}` +
+        (launchScriptPath ? ` script=${launchScriptPath}` : ""),
+    );
     const child = spawnFn("tmux", tmuxArgs, {
       cwd,
       env,
@@ -1718,6 +1774,18 @@ export function startDaemon(config = {}, deps = {}) {
     if (typeof child.unref === "function") {
       child.unref();
     }
+    if (launchScriptPath) {
+      // Without a session nothing will run (and delete) the script.
+      const removeLaunchScript = () => {
+        try {
+          unlinkSyncFn(launchScriptPath);
+        } catch {
+          // already gone
+        }
+      };
+      child.once("exit", (code) => code !== 0 && removeLaunchScript());
+      child.once("error", removeLaunchScript);
+    }
     return { child, tmuxSession: sessionName, exitMarkerToken };
   }
 
@@ -2001,7 +2069,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 +3883,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 +7016,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 +7642,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 +7801,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 +7816,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 +8556,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 "";
   }