@love-moon/conductor-cli 0.13.3 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,119 @@
 # @love-moon/conductor-cli
 
+## 0.15.0
+
+### Minor Changes
+
+- b61c881: Global AI backend tasks (RFC 0041) that work directly in another daemon's
+  project directory (`launch_config.remoteWorkspace`) now get the same
+  `conductor remote mcp` tools as remote-worktree tasks, bound to that
+  repository and starting in the project directory.
+
+  The daemon advertises `global_backend_v1` so the web app only offers a daemon
+  as a global AI backend when its CLI can drive another daemon.
+
+- cc1e290: New Terminal and Resume Session previews in the create-task dialog.
+
+  - `@love-moon/ai-sdk`: `listSessions` (claude, codex) returns `preview` with
+    the first user message, the assistant reply to it, and the session's last
+    message.
+  - The daemon passes the preview to `list_backend_sessions` as
+    `first_user_message`, `first_reply`, `last_message` and `last_message_role`.
+  - A PTY task with no project path now starts its shell in `$HOME`. The
+    terminal log stays in the dated workspace directory.
+
+- 55b65db: `conductor remote mcp`: structured tools for a task whose worktree lives on
+  another daemon (RFC 0040).
+
+  - New `conductor remote mcp --host <daemon> --root <dir> [--cwd <dir>]`, a
+    stdio MCP server with `remote_read`, `remote_edit`, `remote_write`,
+    `remote_grep`, `remote_glob` and `remote_bash`, bound to that directory.
+  - For a `launch_config.remoteWorktree` task the daemon passes the binding to
+    fire (`CONDUCTOR_REMOTE_WORKTREE`), and fire attaches the server to Claude
+    (`mcpServers`) and Codex (`-c mcp_servers.*`). The agent token is forwarded
+    by env only, never on argv.
+  - `@love-moon/ai-sdk`: the Codex app-server session accepts `configOverrides`,
+    passed to the app-server as `-c key=value`.
+
+### Patch Changes
+
+- Updated dependencies [cc1e290]
+- Updated dependencies [55b65db]
+  - @love-moon/ai-sdk@0.15.0
+  - @love-moon/conductor-sdk@0.15.0
+
+## 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,
@@ -26,6 +26,11 @@ import {
   resolveSessionRunDirectory as resolveCliSessionRunDirectory,
   resumeProviderForBackend as resumeProviderForCliBackend,
 } from "../src/fire/resume.js";
+import {
+  REMOTE_WORKTREE_ENV,
+  buildRemoteWorktreeSessionOptions,
+  readRemoteWorktreeBinding,
+} from "../src/remote/mcp-launch.js";
 import {
   filterRuntimeSupportedAllowCliList,
   inferBuiltInRuntimeBackendFromCommand,
@@ -616,6 +621,13 @@ async function main() {
     delete process.env.CONDUCTOR_BACKEND_WS_URL;
     process.env.CONDUCTOR_CONFIG = cliArgs.configFile;
   }
+  // RFC 0040: the daemon's binding for a remote-worktree task. Consumed here so
+  // it does not leak into the AI's shell (and from there into a nested fire).
+  const remoteWorktreeBinding = readRemoteWorktreeBinding(process.env);
+  delete process.env[REMOTE_WORKTREE_ENV];
+  if (remoteWorktreeBinding) {
+    log(`Remote worktree tools bound to ${remoteWorktreeBinding.host}:${remoteWorktreeBinding.cwd}`);
+  }
   let runtimeProjectPath = process.cwd();
   let backendSession = null;
 
@@ -1024,18 +1036,27 @@ 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 || {}),
+            ...buildRemoteWorktreeSessionOptions({
+              backend: cliArgs.sessionBackend || cliArgs.backend,
+              binding: remoteWorktreeBinding,
+              sessionOptions: cliArgs.sessionOptions || {},
+              commandLine: sessionCommandLine,
+              configFile: cliArgs.configFile,
+            }),
+            ...(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 +1072,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 +1644,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 +2094,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 +2131,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 +2190,10 @@ export class BridgeRunner {
       2,
       20,
     );
+    this.attachSessionStreamHandlers();
+  }
+
+  attachSessionStreamHandlers() {
     if (
       this.useSessionFileReplyStream &&
       typeof this.backendSession?.setSessionMessageHandler === "function"
@@ -2326,6 +2370,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 +3196,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 +3212,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 +3229,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 +3395,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 +3467,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 +3661,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 +3690,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 +3773,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 +3889,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 +3941,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 +3950,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 +4039,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/bin/conductor-remote.js

@@ -20,6 +20,7 @@ import { EXIT } from "../src/remote/client.js";
 import { runRemoteExec, showHelp as showExecHelp } from "../src/remote/exec.js";
 import { runRemoteCp, showHelp as showCpHelp } from "../src/remote/cp.js";
 import { runRemoteWait, showHelp as showWaitHelp } from "../src/remote/wait.js";
+import { runRemoteMcp, showHelp as showMcpHelp } from "../src/remote/mcp.js";
 
 export { EXIT };
 
@@ -27,6 +28,7 @@ const VERBS = new Map([
   ["exec", runRemoteExec],
   ["cp", runRemoteCp],
   ["wait", runRemoteWait],
+  ["mcp", runRemoteMcp],
 ]);
 
 const isMainModule = (() => {
@@ -45,6 +47,7 @@ Verbs:
   exec   Run a command on another daemon's host
   cp     Copy a file to or from another daemon's host
   wait   Wait for a command that \`exec\` left running (by run id)
+  mcp    Serve MCP tools bound to a directory on another daemon's host
 
 Options:
   -h, --help   Show this help
@@ -59,6 +62,7 @@ For verb-specific help:
   conductor remote exec --help
   conductor remote cp --help
   conductor remote wait --help
+  conductor remote mcp --help
 `);
 }
 
@@ -89,7 +93,7 @@ export async function runRemote(argv, deps = {}) {
   return handler(argv.slice(1), deps);
 }
 
-export { showExecHelp, showCpHelp, showWaitHelp };
+export { showExecHelp, showCpHelp, showWaitHelp, showMcpHelp };
 
 if (isMainModule) {
   // `process.exitCode` rather than `process.exit()`: writes to a pipe are async,

package/bin/conductor.js

@@ -137,7 +137,7 @@ Subcommands:
   project   Manage Conductor projects (list/show/create/...)
   issue     Manage issues (list/show/create/update/start/done)
   task      Manage tasks (create/list/show/send/messages/schedule)
-  remote    Run commands and copy files on another daemon's host (exec/cp/wait)
+  remote    Run commands and copy files on another daemon's host (exec/cp/wait/mcp)
 
 Options:
   -h, --help     Show this help message

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.13.3",
-  "gitCommitId": "d61c070",
+  "version": "0.15.0",
+  "gitCommitId": "a097cd6",
   "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.15.0",
+    "@love-moon/conductor-sdk": "0.15.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.15.0"
   },
   "pnpm": {
     "onlyBuiltDependencies": [