@love-moon/conductor-cli 0.13.3 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,77 @@
 # @love-moon/conductor-cli
 
+## 0.14.0
+
+### Minor Changes
+
+- e168077: Support `/clear` in task chats. Fire detects a bare `/clear` message (like
+  `/compact`) and drops the AI's context instead of sending the text to the model.
+  Sessions advertise `capabilities.clear` and implement the new optional
+  `runClear()` on top of each backend's own native reset, so the backend process,
+  browser or RPC connection stays up:
+
+  - claude: native `/clear` slash command (the SDK's `conversation_reset` reports
+    the new conversation id)
+  - codex app-server: `thread/start` on the live transport
+  - codex exec: drops the replayed history, which is the whole context for a
+    stateless CLI
+  - copilot: `createSession()` on the same client; the old conversation is
+    detached, not deleted
+  - kimi wire and legacy print: the CLI's built-in `/clear` (prompt mode opts out)
+  - opencode: `session.create` on the same `opencode serve`
+  - dsh: rotates onto a fresh wire session id and keeps the runtime subprocess
+  - chat-web: `newChat()` in the same browser and profile
+
+  Backends without the capability (external providers) fall back to closing the
+  session and continuing on a brand-new one. Either way the task's chat history is
+  kept and the task is rebound to the session the backend ends up on, so a later
+  restart resumes the cleared conversation rather than the old one. The codex
+  fresh-session bootstrap lock now covers that fallback too, and the kimi wire
+  transport drops configured `--continue`/`--resume`/`--session` flags (like kimi
+  print already did) so they cannot reattach a cleared session to the old
+  conversation. Two caveats: the configured `pre_prompt` is not re-sent to the
+  cleared session, and a chat-web task running with
+  `CONDUCTOR_AI_SDK_DISABLE_WORKER=1` can only clear natively — its fallback would
+  hit the browser profile lock, because in that mode the lock owner is fire itself.
+
+- 12a829c: Show each AI reply's token usage beside its timestamp: the turn's tokens, the
+  task total after it, and the input cache share (the part of the turn's input
+  served from the prompt cache).
+
+  - `@love-moon/ai-sdk`: new `summarizeTurnUsage(usage)` normalizes a turn's usage
+    into `{ tokens, inputTokens, cachedInputTokens }` (Claude: fresh input + cache
+    writes + cache reads; Codex: input already includes cached). The Codex
+    app-server provider's turn/goal `usage` now also carries `turnInputTokens` and
+    `turnCachedInputTokens`.
+  - `@love-moon/conductor-sdk`: `sendTurnUsage` accepts `input_tokens`,
+    `cached_input_tokens` and the reply's `message_id`.
+  - `conductor fire` reports a finished turn's usage after its reply, naming that
+    reply (for streamed sessions, the turn's last streamed reply), so the server
+    records it on the message (`metadata.turn_usage`) and pushes it to open chats.
+
+### Patch Changes
+
+- b06e80e: Fix new tasks never answering when their first message starts with "-" (a
+  markdown list, `--model ...`, `-i ...`). The daemon passed the message to Fire
+  as `--prefill <message>`, and Fire's argument parser read the leading dash as a
+  new flag and dropped the message. It is now passed as `--prefill=<message>`.
+- 4141981: `conductor remote exec` now retries a POST lost to a network error or 5xx
+  without running the command twice. The CLI sends a `runId`, and an upgraded
+  daemon (capability `remote_exec_run_id`) returns the existing run for a repeated
+  id. Before retrying, the CLI asks the server whether the daemon dedupes. Old
+  servers and daemons keep the 429-only retry.
+- b06e80e: "New task from this" can start the new task with a first message you write
+  yourself. When one is set, the daemon sends it to the successor AI instead of
+  the default prompt that loads the source task's conversation as background. The
+  daemon advertises this as the `restart_first_message` capability; for older
+  daemons the dialog locks the field (the new task still starts with the default
+  background) and the server rejects a custom first message.
+- Updated dependencies [e168077]
+- Updated dependencies [d4f6fb9]
+- Updated dependencies [12a829c]
+  - @love-moon/ai-sdk@0.14.0
+  - @love-moon/conductor-sdk@0.14.0
+
 ## 0.13.3
 
 ### Patch Changes

package/bin/conductor-fire.js

@@ -18,7 +18,7 @@ import { fileURLToPath } from "node:url";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import yaml from "js-yaml";
-import { createAiSession } from "@love-moon/ai-sdk";
+import { createAiSession, summarizeTurnUsage } from "@love-moon/ai-sdk";
 import { ConductorClient, ProjectContext, loadConfig } from "@love-moon/conductor-sdk";
 import {
   buildResumeArgsForBackend as buildCliResumeArgsForBackend,
@@ -1024,18 +1024,20 @@ async function main() {
           .trim()
           .toLowerCase();
         const enableGoalsForBackend = GOAL_CAPABLE_BACKENDS.includes(backendForGoalCheck);
-        backendSession = createAiSession(cliArgs.sessionBackend || cliArgs.backend, {
-          initialImages: cliArgs.initialImages,
-          cwd: runtimeProjectPath,
-          resumeSessionId: nextResumeSessionId,
-          configFile: cliArgs.configFile,
-          ...(cliArgs.sessionOptions || {}),
-          ...(sessionCommandLine ? { commandLine: sessionCommandLine } : {}),
-          ...(enableGoalsForBackend ? { goalMode: true } : {}),
-          logger: { log },
-          sessionStoreKey: taskContext.taskId ? `task-${taskContext.taskId}` : undefined,
-          resumePersistedSession: Boolean(!nextResumeSessionId && taskContext.taskId),
-        });
+        const openBackendSession = (resumeSessionId, { fresh = false } = {}) =>
+          (backendSession = createAiSession(cliArgs.sessionBackend || cliArgs.backend, {
+            initialImages: cliArgs.initialImages,
+            cwd: runtimeProjectPath,
+            resumeSessionId,
+            configFile: cliArgs.configFile,
+            ...(cliArgs.sessionOptions || {}),
+            ...(sessionCommandLine ? { commandLine: sessionCommandLine } : {}),
+            ...(enableGoalsForBackend ? { goalMode: true } : {}),
+            logger: { log },
+            sessionStoreKey: taskContext.taskId ? `task-${taskContext.taskId}` : undefined,
+            resumePersistedSession: Boolean(!fresh && !resumeSessionId && taskContext.taskId),
+          }));
+        openBackendSession(nextResumeSessionId);
 
         const runner = new BridgeRunner({
           backendSession,
@@ -1051,6 +1053,11 @@ async function main() {
           daemonName: resolvedDaemonName,
           prePrompt: resolvedPrePrompt || "",
           shouldProcessPrePrompt: Boolean(resolvedPrePrompt) && nextShouldProcessPrePrompt,
+          // `/clear` swaps in a brand-new session (no resume) in-process, and
+          // bootstraps it under the same lock the fresh-session boot path uses.
+          createFreshBackendSession: () => openBackendSession(undefined, { fresh: true }),
+          withFreshSessionBootstrap: (fn) =>
+            withFreshSessionBootstrapLock(cliArgs.sessionBackend || cliArgs.backend, runtimeProjectPath, fn),
         });
         reconnectRunner = runner;
         if (pendingRemoteStopEvent) {
@@ -1618,6 +1625,14 @@ export function formatCompactReply(backendName, compact, instructions = "") {
   return `${backendName} 上下文已压缩${detail}。${ignored}`;
 }
 
+/**
+ * Per-message `/clear` detector. Only a bare `/clear` (case-insensitive)
+ * counts: anything after it is more likely an instruction for the model.
+ */
+export function isClearCommand(content) {
+  return typeof content === "string" && /^\/clear$/i.test(content.trim());
+}
+
 export function injectResolvedTaskId(taskId, env = process.env) {
   const normalizedTaskId = normalizeTaskId(taskId);
   if (!normalizedTaskId) {
@@ -2060,8 +2075,12 @@ export class BridgeRunner {
     daemonName,
     prePrompt,
     shouldProcessPrePrompt,
+    createFreshBackendSession,
+    withFreshSessionBootstrap,
   }) {
     this.backendSession = backendSession;
+    this.createFreshBackendSession = createFreshBackendSession;
+    this.withFreshSessionBootstrap = withFreshSessionBootstrap;
     this.conductor = conductor;
     this.taskId = taskId;
     this.pollIntervalMs = pollIntervalMs;
@@ -2093,6 +2112,8 @@ export class BridgeRunner {
       typeof prePrompt === "string" && prePrompt.trim() ? prePrompt.trim() : "";
     this.shouldProcessPrePrompt = Boolean(shouldProcessPrePrompt) && Boolean(this.prePrompt);
     this.sessionStreamReplyCounts = new Map();
+    // Last streamed reply per reply target: the message a streamed turn's usage is recorded on.
+    this.lastStreamedReplyIds = new Map();
     this.lastRuntimeStatusSignature = null;
     this.lastRuntimeStatusPayload = null;
     this.runtimeContextSnapshot = null;
@@ -2150,6 +2171,10 @@ export class BridgeRunner {
       2,
       20,
     );
+    this.attachSessionStreamHandlers();
+  }
+
+  attachSessionStreamHandlers() {
     if (
       this.useSessionFileReplyStream &&
       typeof this.backendSession?.setSessionMessageHandler === "function"
@@ -2326,6 +2351,13 @@ export class BridgeRunner {
       this.copilotLog(`session binding sync skipped: ${sanitizeForLog(error?.message || error, 160)}`);
       return false;
     }
+    // A deferred id is a local placeholder (chat-web before its first reply,
+    // and right after a native /clear) — binding it would point the task at
+    // something that can never be resumed. announceBackendSession holds off for
+    // the same reason; the real id lands with the next completed turn.
+    if (sessionInfo?.sessionIdDeferred === true) {
+      return false;
+    }
     return this.persistTaskSessionBinding({
       sessionId: sessionInfo?.sessionId,
       sessionFilePath: sessionInfo?.sessionFilePath,
@@ -3145,7 +3177,7 @@ export class BridgeRunner {
       usage: null,
       replyTo: replyTo || "latest",
     });
-    await this.conductor.sendMessage(this.taskId, normalizedText, {
+    const sent = await this.conductor.sendMessage(this.taskId, normalizedText, {
       model: this.backendSession.threadOptions?.model || this.backendName,
       backend: this.backendName,
       thread_id: sessionId || this.backendSession.threadId,
@@ -3161,6 +3193,9 @@ export class BridgeRunner {
       replyKey,
       Number(this.sessionStreamReplyCounts.get(replyKey) || 0) + 1,
     );
+    if (sent?.message_id) {
+      this.lastStreamedReplyIds.set(replyKey, sent.message_id);
+    }
     this.copilotLog(
       `session_file sdk_message sent replyTo=${replyTo || "latest"} responseLen=${normalizedText.length}`,
     );
@@ -3175,6 +3210,14 @@ export class BridgeRunner {
     return normalizedReplyTo || "__latest__";
   }
 
+  /** A streamed turn's last reply, read once so a later turn never reuses it. */
+  takeLastStreamedReplyId(replyTo) {
+    const replyKey = this.normalizeSessionStreamReplyKey(replyTo);
+    const messageId = this.lastStreamedReplyIds.get(replyKey);
+    this.lastStreamedReplyIds.delete(replyKey);
+    return messageId;
+  }
+
   getSessionStreamReplyCount(replyTo) {
     return Number(
       this.sessionStreamReplyCounts.get(this.normalizeSessionStreamReplyKey(replyTo)) || 0,
@@ -3333,6 +3376,8 @@ export class BridgeRunner {
     }
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
+    // Only this turn's own streamed replies may carry its usage.
+    this.lastStreamedReplyIds.clear();
     this.activeTurnReplyTo = this.normalizeReplyTarget(replyTo);
     const turnStartedAt = Date.now();
     this.turnStartedAt = turnStartedAt;
@@ -3403,22 +3448,30 @@ export class BridgeRunner {
         );
       }
 
-      if (!this.useSessionFileReplyStream) {
-        const responseText =
-          result.text ||
-          extractAgentTextFromItems(result.items) ||
-          extractAgentTextFromMetadata(result.metadata) ||
-          `(${this.backendName} 未返回任何文本)`;
-        logBackendReply(this.backendName, responseText, { usage: result.usage, replyTo: replyTo || "latest" });
-        await this.conductor.sendMessage(this.taskId, responseText, {
-          model: this.backendSession.threadOptions?.model || this.backendName,
-          backend: this.backendName,
-          usage: result.usage || null,
-          thread_id: this.backendSession.threadId,
-          items: result.items,
-          reply_to: replyTo,
-          cli_args: this.cliArgs,
-        });
+      // The usage report names the reply it belongs to, so it is sent after that
+      // reply — but a turn that failed to post its reply still spent its tokens.
+      let replyMessageId = this.takeLastStreamedReplyId(replyTo);
+      try {
+        if (!this.useSessionFileReplyStream) {
+          const responseText =
+            result.text ||
+            extractAgentTextFromItems(result.items) ||
+            extractAgentTextFromMetadata(result.metadata) ||
+            `(${this.backendName} 未返回任何文本)`;
+          logBackendReply(this.backendName, responseText, { usage: result.usage, replyTo: replyTo || "latest" });
+          const sent = await this.conductor.sendMessage(this.taskId, responseText, {
+            model: this.backendSession.threadOptions?.model || this.backendName,
+            backend: this.backendName,
+            usage: result.usage || null,
+            thread_id: this.backendSession.threadId,
+            items: result.items,
+            reply_to: replyTo,
+            cli_args: this.cliArgs,
+          });
+          replyMessageId = sent?.message_id;
+        }
+      } finally {
+        this.reportTurnUsage(result.usage, { messageId: replyMessageId });
       }
       await this.syncBackendSessionBinding();
       if (replyTo) {
@@ -3589,6 +3642,9 @@ export class BridgeRunner {
     if (compactDirective) {
       return this.runCompactCommand(compactDirective, options);
     }
+    if (!hasAttachmentInputs && this.createFreshBackendSession && isClearCommand(content)) {
+      return this.runClearCommand(options);
+    }
 
     if (willRunGoal) {
       const goalResult = await this.runWithTurnUsage(() =>
@@ -3615,30 +3671,39 @@ export class BridgeRunner {
     return this.runWithTurnUsage(() => this.backendSession.runTurn(content, options));
   }
 
-  /** Runs one backend turn and reports its token count, including failed or interrupted turns. */
+  /**
+   * Runs one backend turn and reports a failed or interrupted turn's token
+   * count; the caller reports a finished turn's once its reply is sent.
+   */
   async runWithTurnUsage(runTurn) {
-    let result;
     try {
-      result = await runTurn();
+      return 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.
+   * Best-effort: report a turn's token usage to the server, tied to its reply
+   * message when there is one. 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") {
+  reportTurnUsage(usage, { failed = false, messageId } = {}) {
+    const summary = summarizeTurnUsage(usage);
+    if ((!summary && !failed) || typeof this.conductor?.sendTurnUsage !== "function") {
       return;
     }
     Promise.resolve()
-      .then(() => this.conductor.sendTurnUsage(this.taskId, { tokens }))
+      .then(() =>
+        this.conductor.sendTurnUsage(this.taskId, {
+          tokens: summary?.tokens ?? null,
+          ...(summary?.inputTokens !== undefined
+            ? { input_tokens: summary.inputTokens, cached_input_tokens: summary.cachedInputTokens }
+            : {}),
+          ...(messageId ? { message_id: messageId } : {}),
+        }),
+      )
       .catch((error) => {
         log(`Failed to report turn usage: ${error?.message || error}`);
       });
@@ -3689,6 +3754,85 @@ export class BridgeRunner {
     };
   }
 
+  /**
+   * `/clear`: drop the AI context. Backends that advertise
+   * `capabilities.clear` run their own native clear (claude's `/clear` slash
+   * command, kimi's built-in `/clear`, …) so the process and its session file
+   * survive; everyone else falls back to closing the session and swapping in a
+   * fresh one. Either way the task's chat history is kept and the task is
+   * rebound to whatever session id the backend ends up on, so a later fire
+   * restart resumes the cleared conversation instead of the old one.
+   */
+  async runClearCommand({ onProgress, replyTo = "" } = {}) {
+    onProgress?.({
+      phase: "context_clear",
+      reply_in_progress: true,
+      status_line: `${this.backendName} clearing context`,
+    });
+    const snapshot =
+      typeof this.backendSession?.getSnapshot === "function" ? this.backendSession.getSnapshot() : null;
+    const clearCapable =
+      snapshot?.capabilities?.clear === true && typeof this.backendSession?.runClear === "function";
+    if (clearCapable) {
+      const result = await this.runWithTurnUsage(() => this.backendSession.runClear({}, { onProgress }));
+      // A native clear may land on a new session id (claude does); rebind so a
+      // restart resumes the cleared conversation.
+      this.runtimeContextSnapshot = null;
+      await this.syncBackendSessionBinding();
+      const cleared = result?.clear?.status !== "noop";
+      const text = cleared
+        ? `${this.backendName} 上下文已清除。`
+        : `${this.backendName} 当前没有可清除的上下文。`;
+      onProgress?.({ phase: "turn_completed", reply_in_progress: false, status_done_line: text });
+      log(`[clear] backend=${this.backendName} native status=${result?.clear?.status || "cleared"}`);
+      if (this.useSessionFileReplyStream && !this.stopped) {
+        try {
+          await this.sendSessionStreamMessage({ text, replyTo });
+        } catch (error) {
+          log(`[clear] failed to post confirmation: ${error?.message || error}`);
+        }
+      }
+      return {
+        text,
+        items: [],
+        usage: result?.usage || null,
+        provider: this.backendName,
+        events: [],
+        metadata: { ...(result?.metadata || {}), clear: result?.clear || null },
+      };
+    }
+    try {
+      await this.backendSession?.close?.();
+    } catch (error) {
+      log(`[clear] failed to close previous backend session: ${error?.message || error}`);
+    }
+    if (this.stopped) {
+      // The task is shutting down; don't spawn a session nobody will close.
+      throw Object.assign(new Error("backend session closed during /clear"), { reason: "session_closed" });
+    }
+    this.backendSession = this.createFreshBackendSession();
+    this.resumeSessionId = "";
+    this.sessionAnnouncementSent = false;
+    this.sessionAnnouncementSubscribed = false;
+    this.runtimeContextSnapshot = null;
+    this.attachSessionStreamHandlers();
+    await (this.withFreshSessionBootstrap
+      ? this.withFreshSessionBootstrap(() => this.announceBackendSession())
+      : this.announceBackendSession());
+
+    const text = `${this.backendName} 上下文已清除，已开始新会话。`;
+    onProgress?.({ phase: "turn_completed", reply_in_progress: false, status_done_line: text });
+    log(`[clear] backend=${this.backendName} started a fresh session`);
+    if (this.useSessionFileReplyStream && !this.stopped) {
+      try {
+        await this.sendSessionStreamMessage({ text, replyTo });
+      } catch (error) {
+        log(`[clear] failed to post confirmation: ${error?.message || error}`);
+      }
+    }
+    return { text, items: [], usage: null, provider: this.backendName, events: [], metadata: {} };
+  }
+
   async handlePrePromptMessage(content) {
     const text = typeof content === "string" ? content.trim() : "";
     if (!text) {
@@ -3726,6 +3870,8 @@ export class BridgeRunner {
   }) {
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
+    // Only this turn's own streamed replies may carry its usage.
+    this.lastStreamedReplyIds.clear();
     const startedAt = Date.now();
     this.turnStartedAt = startedAt;
     if (
@@ -3776,7 +3922,7 @@ export class BridgeRunner {
           usage: result.usage,
           replyTo: replyTarget,
         });
-        await this.conductor.sendMessage(this.taskId, text, {
+        const sent = await this.conductor.sendMessage(this.taskId, text, {
           model: this.backendSession.threadOptions?.model || this.backendName,
           backend: this.backendName,
           usage: result.usage || null,
@@ -3785,8 +3931,10 @@ export class BridgeRunner {
           synthetic: true,
           ...(replyMetadata || {}),
         });
+        this.reportTurnUsage(result.usage, { messageId: sent?.message_id });
         this.copilotLog(`${logTag} sdk_message sent responseLen=${text.length}`);
       } else {
+        this.reportTurnUsage(result.usage, { messageId: this.takeLastStreamedReplyId(replyTarget) });
         this.copilotLog(`${logTag} session_file turn settled`);
       }
       await this.syncBackendSessionBinding();
@@ -3872,24 +4020,6 @@ 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.13.3",
-  "gitCommitId": "d61c070",
+  "version": "0.14.0",
+  "gitCommitId": "6def94c",
   "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.3",
-    "@love-moon/conductor-sdk": "0.13.3",
+    "@love-moon/ai-sdk": "0.14.0",
+    "@love-moon/conductor-sdk": "0.14.0",
     "@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.3"
+    "@love-moon/chat-web": "0.14.0"
   },
   "pnpm": {
     "onlyBuiltDependencies": [

package/src/daemon.js

@@ -40,6 +40,7 @@ import {
 } from "./custom-command-handlers.js";
 import {
   REMOTE_EXEC_CAPABILITY,
+  REMOTE_EXEC_RUN_ID_CAPABILITY,
   createRemoteExecHandlers,
   handleRemoteExecRequest,
 } from "./remote-exec-handlers.js";
@@ -703,7 +704,9 @@ export function buildFireSpawnArgs({ selectedBackend, initialContent, launchConf
   const prefill = typeof initialContent === "string" ? initialContent : "";
   const effectivePrefill = prefill || goalObjective;
   if (effectivePrefill) {
-    args.push("--prefill", effectivePrefill);
+    // `=` form: as a separate argv entry, yargs reads content that starts with
+    // "-" (a markdown list, "--model ...") as a new flag and drops it.
+    args.push(`--prefill=${effectivePrefill}`);
   }
   const resumeSessionId =
     normalizeOptionalString(launchConfig?.resumeSessionId) ||
@@ -3883,6 +3886,7 @@ export function startDaemon(config = {}, deps = {}) {
     "project_agents_registry",
     "restart_daemon",
     "refresh_session_inplace",
+    "restart_first_message",
     "persistent_round_v1",
     "task_attachments_v1",
     "backend_session_list",
@@ -3890,7 +3894,7 @@ export function startDaemon(config = {}, deps = {}) {
     UPDATE_DAEMON_CAPABILITY,
   ];
   if (remoteExecEnabled) {
-    advertisedCapabilities.push(REMOTE_EXEC_CAPABILITY);
+    advertisedCapabilities.push(REMOTE_EXEC_CAPABILITY, REMOTE_EXEC_RUN_ID_CAPABILITY);
   } else {
     log("[remote-exec] Disabled by config (remote_exec: false); capability not advertised");
   }
@@ -8101,6 +8105,7 @@ export function startDaemon(config = {}, deps = {}) {
       source_session_file_path: sourceSessionFilePath,
       target_backend_type: targetBackendType,
       resume_context_url: resumeContextUrlRaw,
+      initial_content: initialContentRaw,
       request_id: requestIdRaw,
     } = payload || {};
 
@@ -8538,9 +8543,15 @@ export function startDaemon(config = {}, deps = {}) {
     if (isForkMode) {
       // Fork mode starts a brand-new session on the target backend; no --resume.
       // The prior conversation is delivered as a plain-text URL via the prompt
-      // so the target backend fetches it on its own.
-      args.push("--");
-      args.push(resumeHandoffPrompt);
+      // so the target backend fetches it on its own — unless the user set their
+      // own first message, which replaces it. That one goes through --prefill
+      // (string-typed) so fire does not coerce a numeric message like "0.10".
+      const customFirstMessage = normalizeOptionalString(initialContentRaw);
+      if (customFirstMessage) {
+        args.push(`--prefill=${customFirstMessage}`, "--");
+      } else {
+        args.push("--", resumeHandoffPrompt);
+      }
     } else {
       if (shouldResumeSession) {
         args.push("--resume", resolvedResumeSessionId);

package/src/remote/client.js

@@ -112,7 +112,7 @@ export async function withRetry(fn, {
     } catch (error) {
       lastError = error;
       // An aborted transfer is the caller's own deadline firing, not a blip.
-      if (error?.name === "AbortError" || !retryable(error)) throw error;
+      if (error?.name === "AbortError" || !(await retryable(error))) throw error;
       if (attempt === attempts - 1) break;
       await sleep(baseDelayMs * 2 ** attempt);
     }

package/src/remote/exec.js

@@ -6,6 +6,7 @@
  * or globs are actually wanted.
  */
 
+import { randomUUID } from "node:crypto";
 import process from "node:process";
 
 import {
@@ -13,6 +14,7 @@ import {
   UsageError,
   callApi,
   delay,
+  isRetryable,
   loadCliConfig,
   parseTimeoutMs as parseSharedTimeoutMs,
   withRetry,
@@ -25,12 +27,10 @@ const POLL_INTERVAL_MS = 1_000;
 /** How long a single request may block server-side before we switch to polling. */
 const POST_WAIT_MS = 10_000;
 /**
- * A 429 means the per-user in-flight cap (8) is full — nothing was started, so
- * retrying is safe. Six attempts at 500ms doubling waits out ~15s, longer than
- * one saturating POST can block (POST_WAIT_MS). Nothing else is retried here:
- * a 5xx may have started the command already, and a second POST would run it twice.
+ * Six attempts at 500ms doubling wait out ~15s, longer than one saturating POST
+ * can block (POST_WAIT_MS). What is safe to retry is decided in `execRemote`.
  */
-const POST_RETRY = { attempts: 6, retryable: (error) => error?.status === 429 };
+const POST_ATTEMPTS = 6;
 const INTERRUPT_SIGNALS = ["SIGINT", "SIGTERM"];
 
 const VALUE_FLAGS = new Map([
@@ -233,16 +233,31 @@ export async function execRemote(config, target, command, options = {}) {
   const basePath = `/api/agents/${encodeURIComponent(target)}/exec`;
   const deadline = now() + timeoutMs;
 
+  // Sent on every attempt: a daemon that already started this run returns it
+  // instead of running the command again.
+  const runId = randomUUID();
+  let dedupes;
+  const retryable = async (error) => {
+    // The per-user in-flight cap (8) is full: nothing was started.
+    if (error?.status === 429) return true;
+    // A 502 is the daemon's own answer (bad workspace, …); a retry gets the same one.
+    if (!isRetryable(error) || error.status === 502 || now() >= deadline) return false;
+    // A network error or other 5xx may have started the command already.
+    dedupes ??= await dedupesRunId(config, basePath, fetchImpl, sleep);
+    return dedupes;
+  };
+
   const started = await withRetry(() => callApi(config, "POST", basePath, {
     command,
     args,
+    runId,
     ...(workspace ? { workspace } : {}),
     ...(env && Object.keys(env).length > 0 ? { env } : {}),
     // Deliberately short, and independent of the overall deadline: that is
     // owned by the poll loop below. Handing the daemon the full budget would
     // make one HTTP request block for it and leave the loop unreachable.
     timeoutMs: Math.min(timeoutMs, POST_WAIT_MS),
-  }, fetchImpl), { ...POST_RETRY, sleep });
+  }, fetchImpl), { attempts: POST_ATTEMPTS, retryable, sleep });
 
   const waited = await waitForRun(config, basePath, started, {
     deadline, fetchImpl, sleep, now, killOnTimeout, signal,
@@ -250,6 +265,21 @@ export async function execRemote(config, target, command, options = {}) {
   return { ...waited, basePath };
 }
 
+/**
+ * Whether the target dedupes exec on `runId`, which is what makes re-sending a
+ * POST that failed mid-flight safe. Asked only after such a failure, so the happy
+ * path pays nothing. Anything short of a clear yes — an old server answers 405,
+ * an old daemon `false` — keeps the POST to 429-only retries.
+ */
+async function dedupesRunId(config, basePath, fetchImpl, sleep) {
+  try {
+    const answer = await withRetry(() => callApi(config, "GET", basePath, null, fetchImpl), { sleep });
+    return answer?.dedupesRunId === true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * `execRemote` for callers that only care whether it worked. Throws with the
  * remote's own stderr, which is what the user needs to see.

package/src/remote-exec-handlers.js

@@ -18,6 +18,8 @@ const KILL_GRACE_MS = 5_000;
 const NUL = String.fromCharCode(0);
 
 export const REMOTE_EXEC_CAPABILITY = "remote_exec";
+/** `exec` honours a caller-chosen `runId`, so a retried request cannot spawn twice. */
+export const REMOTE_EXEC_RUN_ID_CAPABILITY = "remote_exec_run_id";
 
 /**
  * Run arbitrary commands on this daemon's host on behalf of the account that
@@ -51,6 +53,15 @@ export function createRemoteExecHandlers(opts = {}) {
     // never learned.
     const waitMs = clampWaitMs(args.timeoutMs ?? args.timeout_ms);
     const waitDeadline = Date.now() + waitMs;
+    const attach = async (runState) => {
+      await waitForSettle(runState, Math.max(0, waitDeadline - Date.now()));
+      return toPublicRun(runState);
+    };
+
+    // A retry of a request that already started gets that run back rather than
+    // a second copy of the command.
+    const runId = typeof args.runId === "string" ? args.runId.trim() : "";
+    if (runId && runs.has(runId)) return attach(runs.get(runId));
 
     const command = normalizeCommand(args.command);
     if (!command) {
@@ -65,9 +76,11 @@ export function createRemoteExecHandlers(opts = {}) {
     }
     const cwd = await resolveWorkspace(args.workspace ?? args.workspace_path, defaultWorkspace);
     const env = buildExecEnv(args.env);
+    // ...including one that landed while `stat` above was still pending.
+    if (runId && runs.has(runId)) return attach(runs.get(runId));
 
     const runState = {
-      runId: randomUUID(),
+      runId: runId || randomUUID(),
       command,
       args: argv,
       workspace: cwd,
@@ -126,8 +139,7 @@ export function createRemoteExecHandlers(opts = {}) {
       });
     });
 
-    await waitForSettle(runState, Math.max(0, waitDeadline - Date.now()));
-    return toPublicRun(runState);
+    return attach(runState);
   }
 
   async function status(args = {}) {