@love-moon/conductor-cli 0.16.0 → 0.17.1

package/CHANGELOG.md

@@ -1,5 +1,89 @@
 # @love-moon/conductor-cli
 
+## 0.17.1
+
+### Patch Changes
+
+- 7e92c0f: When a task's model quota runs out ("You've hit your session limit · resets
+  1:20am"), fire no longer stops there. It reads the reset time, schedules a
+  one-off Conductor scheduled message to continue a minute or few after the
+  reset, and posts a single notice. Messages that arrive while waiting are queued
+  and handed to the resume turn together instead of each failing with another
+  "处理失败". The resume shows up in the task's scheduled-message list, where it
+  can be canceled. This also covers a quota hit while Claude works on its own
+  between user turns: ai-sdk now reports such a background turn that ends in an
+  error result (or a process exit after it) as a failed turn.
+- Updated dependencies [7e92c0f]
+  - @love-moon/ai-sdk@0.17.1
+  - @love-moon/conductor-sdk@0.17.1
+
+## 0.17.0
+
+### Minor Changes
+
+- 88e1ae0: Support `/stop` in task chats. A bare `/stop` message, sent from the web, the
+  CLI or a channel, makes the server interrupt the AI's running turn right away
+  instead of waiting for fire to read the message once that turn ends. When fire
+  does read the queued `/stop`, it posts a confirmation and does not send it to
+  the model. `/stop` also drops every message queued before it (except the
+  server's end-of-round summary request); resend what you still want. The server
+  targets the reply it knows is running, so older fires stop it too;
+  `interrupt_turn` no longer needs a reply target, and without one fire
+  interrupts the turn it is running, including the initial prompt and pre_prompt
+  turns. In the web chat, the ⋯ menu gains `/stop`, `/clear` and `/compact`,
+  which send those commands as messages, and Interrupt (Esc) sends `/stop`,
+  ignored while an earlier `/stop` is unanswered. The Interrupt action is gone
+  from the message toolbar.
+
+### Patch Changes
+
+- 79ca552: Claude no longer switches to `acceptEdits` mode when the daemon runs as root.
+  That fallback looked like it worked, but in a headless task it silently refused
+  every shell command (ssh, rsync, ...) and every read outside the project. Claude
+  now keeps `bypassPermissions` everywhere. As root without `IS_SANDBOX=1`, the
+  chat shows a warning right after "session started" telling you to add
+  `envs: { IS_SANDBOX: "1" }` to the conductor config (or run the daemon as a
+  regular user). Terminal tasks print the same hint. An `IS_SANDBOX` set in config
+  `envs` now also reaches terminal (PTY) claude tasks. `conductor config` always
+  writes `--dangerously-skip-permissions` for claude.
+- c0c1489: `conductor task speak <text> [-o FILE|-]` saves Doubao text-to-speech as an
+  .mp3 — the same voice the web chat's new voice-conversation mode reads replies with.
+- 39ee057: `conductor update` and the daemon updater compile node-pty against the headers
+  the running Node ships, instead of downloading them from nodejs.org, so an
+  update no longer needs that host to be reachable. `conductor update` also stops
+  an npm install that has not finished after 15 minutes instead of waiting on a
+  stalled registry connection forever.
+- b09b28a: Remove `conductor task create --remote-worktree <host>`; passing it now fails
+  with a pointer to the replacement. Running the AI on one daemon while the code
+  lives on another is done only through a global AI backend:
+  `--global-backend <backend>@<host>` (add `--worktree` for a worktree on the
+  code's daemon). Note the host changes meaning: `--remote-worktree` named the
+  daemon holding the code, `--global-backend` names the daemon running the AI, so
+  create the task in the project on the code's daemon. The server refuses a caller-supplied
+  `launch_config.remoteWorktree`.
+
+  `conductor task create --global-backend` now takes `<backend>@<host>`, the same
+  form as `conductor issue start` and the web UI. The older `<host>:<backend>` is
+  still accepted.
+
+- 68fe7b9: Add `conductor task preview <id> <path>`: open a temporary link to a file on the
+  task's daemon (HTML with its CSS/JS/images, Markdown, images, video), the same
+  preview the chat opens when you click a file link in an AI reply or shows in
+  place for `![](picture.png)` / `![](recording.mp4)`. The link expires after
+  5 idle minutes (30 minutes at most) and only reaches the file's own directory.
+
+  The daemon advertises a new `remote_file_preview` capability; previews need a
+  daemon of this version or later. `conductor config` now writes
+  `remote_file: true` explicitly into a new config file (the default was already
+  on; set it to `false` to decline file transfers and previews).
+
+- Updated dependencies [d088b31]
+- Updated dependencies [79ca552]
+- Updated dependencies [ccbfeeb]
+- Updated dependencies [88e1ae0]
+  - @love-moon/ai-sdk@0.17.0
+  - @love-moon/conductor-sdk@0.17.0
+
 ## 0.16.0
 
 ### Minor Changes

package/bin/conductor-config.js

@@ -10,7 +10,6 @@ import { createRequire } from "node:module";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import { RUNTIME_SUPPORTED_BACKENDS } from "../src/runtime-backends.js";
-import { isClaudeRootPermissionRestricted } from "@love-moon/ai-sdk";
 import { resolveConductorConfigPath } from "../src/conductor-paths.js";
 
 const CONFIG_FILE = resolveConductorConfigPath();
@@ -22,12 +21,10 @@ const packageJson = JSON.parse(
 const DEFAULT_CLIs = {
   claude: {
     command: "claude",
-    // claude exits 1 with `--dangerously-skip-permissions` under root, so never
-    // write a flag the user's own machine cannot run. Same root check the
-    // daemon and the ai-sdk session use.
-    execArgs: isClaudeRootPermissionRestricted()
-      ? "--permission-mode acceptEdits"
-      : "--dangerously-skip-permissions",
+    // Kept even on root: a headless acceptEdits session silently denies every
+    // shell command. Root users opt in with `envs.IS_SANDBOX: "1"`; fire and
+    // the daemon tell them so when claude starts.
+    execArgs: "--dangerously-skip-permissions",
     description: "Anthropic Claude CLI"
   },
   codex: {
@@ -387,9 +384,9 @@ async function main() {
     "# Env: CONDUCTOR_REMOTE_EXEC",
     "# remote_exec: true",
     "",
-    "# Accept `conductor remote cp` file transfers for this host.",
+    "# Accept `conductor remote cp` file transfers and file previews for this host.",
     "# Env: CONDUCTOR_REMOTE_FILE",
-    "# remote_file: true",
+    "remote_file: true",
     "",
     "# Launch each Fire process inside a detached tmux session so it survives a",
     "# daemon restart. Requires tmux on PATH. Env: CONDUCTOR_FIRE_TMUX_MODE",

package/bin/conductor-fire.js

@@ -26,6 +26,17 @@ import {
   resolveSessionRunDirectory as resolveCliSessionRunDirectory,
   resumeProviderForBackend as resumeProviderForCliBackend,
 } from "../src/fire/resume.js";
+import {
+  QUOTA_RESUME_MAX_ATTEMPTS,
+  buildQuotaResumePrompt,
+  computeQuotaResumeAt,
+  createQuotaResumeScheduler,
+  formatResumeTime,
+  isQuotaResumePrompt,
+  mergeQueuedMessages,
+  parseQuotaLimitError,
+  parseQuotaResumePrompt,
+} from "../src/fire/quota-resume.js";
 import {
   REMOTE_WORKTREE_ENV,
   buildRemoteWorktreeSessionOptions,
@@ -1648,6 +1659,10 @@ export function formatCompactReply(backendName, compact, instructions = "") {
  * Per-message `/clear` detector. Only a bare `/clear` (case-insensitive)
  * counts: anything after it is more likely an instruction for the model.
  */
+export function isStopCommand(content) {
+  return typeof content === "string" && /^\/stop$/i.test(content.trim());
+}
+
 export function isClearCommand(content) {
   return typeof content === "string" && /^\/clear$/i.test(content.trim());
 }
@@ -2096,8 +2111,19 @@ export class BridgeRunner {
     shouldProcessPrePrompt,
     createFreshBackendSession,
     withFreshSessionBootstrap,
+    quotaResumeScheduler,
+    now,
+    random,
   }) {
     this.backendSession = backendSession;
+    // Model quota handling (see src/fire/quota-resume.js). `undefined` means
+    // "build the HTTP scheduler from env on first use"; tests inject their own.
+    this.quotaResumeSchedulerOverride = quotaResumeScheduler;
+    this.now = typeof now === "function" ? now : () => new Date();
+    this.random = typeof random === "function" ? random : Math.random;
+    this.quotaWait = null;
+    this.quotaResumeAttempts = 0;
+    this.lastQuotaResumeQueue = null;
     this.createFreshBackendSession = createFreshBackendSession;
     this.withFreshSessionBootstrap = withFreshSessionBootstrap;
     this.conductor = conductor;
@@ -2168,6 +2194,8 @@ export class BridgeRunner {
     this.remoteInterruptsByReplyTo = new Map();
     this.pendingInterruptRetryTimers = new Map();
     this.activeTurnReplyTo = "";
+    // A `/stop` arrived mid-batch: drop the rest of this batch (all sent before it).
+    this.dropQueuedBeforeStop = false;
     this.sessionAnnouncementSent = false;
     this.sessionAnnouncementSubscribed = false;
     this.boundSessionId = "";
@@ -2309,6 +2337,7 @@ export class BridgeRunner {
       });
       this.sessionAnnouncementSent = true;
       this.copilotLog(hasRealSessionId ? `session announced id=${sessionId}` : "session announced without id");
+      await this.reportBackendNotices();
       await this.reportRuntimeStatus(
         {
           state: this.useSessionFileReplyStream ? undefined : "WAIT_READY",
@@ -2421,6 +2450,7 @@ export class BridgeRunner {
       if (this.needsReconnectRecovery && !this.runningTurn) {
         await this.recoverAfterReconnect();
       }
+      await this.runLocalQuotaResumeIfDue();
       let processed = false;
       try {
         processed = await this.processIncomingBatch();
@@ -2577,7 +2607,12 @@ export class BridgeRunner {
     }
     const requestId = typeof event.requestId === "string" ? event.requestId.trim() : "";
     const reason = typeof event.reason === "string" ? event.reason.trim() : "";
-    const targetReplyTo = this.normalizeReplyTarget(event.targetReplyTo);
+    if (reason === "user_stop" && this.runningTurn) {
+      this.dropQueuedBeforeStop = true;
+    }
+    // No target (`/stop`): interrupt whatever turn is running right now.
+    const targetReplyTo =
+      this.normalizeReplyTarget(event.targetReplyTo) || (this.runningTurn ? this.activeTurnReplyTo : "");
     if (!targetReplyTo) {
       return false;
     }
@@ -2767,7 +2802,12 @@ export class BridgeRunner {
         .join(",")}`,
     );
 
-    for (const message of messages) {
+    // `/stop` drops every message queued before it; the user resends what they still want.
+    let lastStopIndex = -1;
+    messages.forEach((message, index) => {
+      if (this.isUserStopMessage(message)) lastStopIndex = index;
+    });
+    for (const [index, message] of messages.entries()) {
       if (this.stopped) {
         break;
       }
@@ -2775,8 +2815,16 @@ export class BridgeRunner {
         this.copilotLog(`skip message role=${String(message?.role || "unknown").toLowerCase()}`);
         continue;
       }
+      if (this.isUserStopMessage(message)) {
+        this.dropQueuedBeforeStop = false;
+      } else if ((index < lastStopIndex || this.dropQueuedBeforeStop) && this.isDroppableOnStop(message)) {
+        if (message.message_id) this.processedMessageIds.add(message.message_id);
+        this.copilotLog(`drop message queued before /stop replyTo=${message.message_id || "unknown"}`);
+        continue;
+      }
       await this.respondToMessage(message);
     }
+    this.dropQueuedBeforeStop = false;
 
     if (ackToken) {
       await this.conductor.ackMessages(this.taskId, ackToken);
@@ -2786,6 +2834,15 @@ export class BridgeRunner {
     return hasMore;
   }
 
+  isUserStopMessage(message) {
+    return String(message?.role || "").toLowerCase() === "user" && isStopCommand(message.content);
+  }
+
+  // The end-of-round summary request is the server's, not the user's: dropping it would lock the round.
+  isDroppableOnStop(message) {
+    return String(message?.role || "").toLowerCase() === "user" && message.metadata?.kind !== "persistent_round_end";
+  }
+
   shouldRespond(message) {
     if (!message || typeof message !== "object") {
       return false;
@@ -3221,6 +3278,19 @@ export class BridgeRunner {
   }
 
   async handleContinuousWorkingStatus(payload) {
+    // A turn claude ran on its own (after a background task or subagent) hit
+    // the quota: no user turn fails, so park the task here.
+    if (
+      payload?.background === true &&
+      payload?.phase === "turn_failed" &&
+      !this.runningTurn &&
+      (await this.enterQuotaWaitIfQuotaError(String(payload.status_done_line || ""), {
+        replyTo: undefined,
+        content: "",
+      }))
+    ) {
+      return;
+    }
     await this.reportRuntimeStatus(payload, payload?.replyTo);
   }
 
@@ -3285,6 +3355,228 @@ export class BridgeRunner {
     this.errorLoop = null;
   }
 
+  getQuotaResumeScheduler() {
+    if (this.quotaResumeSchedulerOverride !== undefined) {
+      return this.quotaResumeSchedulerOverride;
+    }
+    this.quotaResumeSchedulerOverride = createQuotaResumeScheduler();
+    return this.quotaResumeSchedulerOverride;
+  }
+
+  /**
+   * A turn failed because the model quota is used up: park the task until the
+   * quota resets. The resume is a one-off Conductor scheduled message, so it
+   * survives restarts and can be canceled from the schedule list; messages that
+   * arrive meanwhile are queued instead of each failing again. Returns false
+   * (report the error as usual) for other errors, or after
+   * QUOTA_RESUME_MAX_ATTEMPTS resumes in a row hit the quota again.
+   */
+  async enterQuotaWaitIfQuotaError(errorMessage, { replyTo, content }) {
+    const now = this.now();
+    const quota = parseQuotaLimitError(errorMessage, { now });
+    if (!quota) {
+      return false;
+    }
+    const failedItems = this.pendingItemsOfFailedTurn(replyTo, content);
+    if (this.quotaWait) {
+      // Already parked (a background failure, or a turn that raced the wait):
+      // fold this one in rather than scheduling a second resume.
+      await this.addToQuotaWait(failedItems);
+      return true;
+    }
+    this.quotaResumeAttempts += 1;
+    if (this.quotaResumeAttempts > QUOTA_RESUME_MAX_ATTEMPTS) {
+      log(`[quota] ${this.quotaResumeAttempts - 1} resumes in a row hit the quota again; not scheduling another`);
+      this.quotaResumeAttempts = 0;
+      this.lastQuotaResumeQueue = null;
+      return false;
+    }
+    this.lastQuotaResumeQueue = null;
+    const sendAt = computeQuotaResumeAt(quota.resetAt, { now, random: this.random });
+    // Set synchronously, before any await, so messages and background failures
+    // that arrive while the schedule is being created are queued into it.
+    const wait = {
+      // Messages that arrive before this are queued; later ones end the wait.
+      resumeAfter: quota.resetAt && quota.resetAt.getTime() > now.getTime() ? quota.resetAt : sendAt,
+      sendAt,
+      scheduleId: null,
+      localResumeAt: null,
+      queued: failedItems,
+    };
+    this.quotaWait = wait;
+    const scheduler = this.getQuotaResumeScheduler();
+    let scheduleNote = "可在定时消息列表里取消。";
+    let scheduledContent = "";
+    if (scheduler) {
+      // A fire that restarted mid-wait left its resume schedule behind; the new
+      // one replaces it, so carry over what it listed.
+      if (typeof scheduler.listActive === "function") {
+        try {
+          const leftover = await scheduler.listActive({ taskId: this.taskId });
+          wait.queued = mergeQueuedMessages(
+            ...leftover.map((row) => parseQuotaResumePrompt(row?.content)),
+            wait.queued,
+          );
+        } catch (error) {
+          log(`[quota] failed to read earlier resume schedules: ${error?.message || error}`);
+        }
+      }
+      scheduledContent = buildQuotaResumePrompt(wait.queued);
+      try {
+        const created = await scheduler.schedule({
+          taskId: this.taskId,
+          sendAt,
+          content: scheduledContent,
+        });
+        wait.scheduleId = created?.id || null;
+      } catch (error) {
+        log(`[quota] failed to schedule resume: ${error?.message || error}`);
+      }
+    }
+    if (!wait.scheduleId) {
+      // No server schedule: fire keeps the time itself (lost if fire restarts).
+      wait.localResumeAt = sendAt;
+      scheduleNote = "定时消息没有建成，改由本进程计时；如果 fire 重启，需要手动发消息继续。";
+    } else if (buildQuotaResumePrompt(wait.queued) !== scheduledContent) {
+      // Messages queued while the schedule was being created.
+      await this.syncQuotaResumeSchedule();
+    }
+    const resumeLabel = formatResumeTime(sendAt);
+    log(
+      `[quota] waiting until ${sendAt.toISOString()} (reset ${quota.resetAt ? quota.resetAt.toISOString() : "unknown"}) schedule=${wait.scheduleId || "local"} attempt=${this.quotaResumeAttempts}`,
+    );
+    await this.reportRuntimeStatus(
+      {
+        state: "WAITING",
+        phase: "quota_wait",
+        reply_in_progress: false,
+        status_done_line: `额度已用完，${resumeLabel} 自动继续`,
+        quota_resume_at: sendAt.toISOString(),
+      },
+      replyTo,
+    );
+    try {
+      await this.conductor.sendMessage(
+        this.taskId,
+        `${this.backendName} 额度已用完：${errorMessage}\n将在 ${resumeLabel} 自动继续，在此之前收到的消息会排队，届时一起处理。${scheduleNote}`,
+        {
+          severity: "warning",
+          backend: this.backendName,
+          reply_to: replyTo || undefined,
+          quota_wait: true,
+          quota_resume_at: sendAt.toISOString(),
+          cli_args: this.cliArgs,
+        },
+      );
+    } catch (error) {
+      log(`[quota] failed to post wait notice: ${error?.message || error}`);
+    }
+    return true;
+  }
+
+  /** What still has to run after a turn that hit the quota. */
+  pendingItemsOfFailedTurn(replyTo, content) {
+    const text = String(content || "").trim();
+    if (!text) {
+      // A background turn: nothing to redo beyond "continue".
+      return [];
+    }
+    if (!isQuotaResumePrompt(text)) {
+      return [{ messageId: replyTo || null, content: text }];
+    }
+    // A failed resume: what it carried. A fire that restarted mid-wait has no
+    // memory of it, so read the list back out of the prompt itself.
+    return this.lastQuotaResumeQueue
+      ? [...this.lastQuotaResumeQueue]
+      : parseQuotaResumePrompt(text);
+  }
+
+  async addToQuotaWait(items) {
+    const wait = this.quotaWait;
+    const before = wait.queued.length;
+    wait.queued = mergeQueuedMessages(wait.queued, items);
+    if (wait.queued.length !== before) {
+      await this.syncQuotaResumeSchedule();
+    }
+  }
+
+  /** Keep the scheduled resume's text complete, so a fire restart loses nothing. */
+  async syncQuotaResumeSchedule() {
+    const wait = this.quotaWait;
+    const scheduler = this.getQuotaResumeScheduler();
+    if (!wait?.scheduleId || typeof scheduler?.update !== "function") {
+      return;
+    }
+    try {
+      await scheduler.update({
+        taskId: this.taskId,
+        scheduleId: wait.scheduleId,
+        content: buildQuotaResumePrompt(wait.queued),
+      });
+    } catch (error) {
+      log(`[quota] failed to update resume schedule: ${error?.message || error}`);
+    }
+  }
+
+  isQuotaResumeMessage(message, content) {
+    const scheduledMessageId = message?.metadata?.scheduledMessageId;
+    if (scheduledMessageId && this.quotaWait?.scheduleId && scheduledMessageId === this.quotaWait.scheduleId) {
+      return true;
+    }
+    return isQuotaResumePrompt(content);
+  }
+
+  /** While waiting for the quota, queue the message. Returns false once the wait should end. */
+  async queueMessageDuringQuotaWait(message, content) {
+    const wait = this.quotaWait;
+    if (this.isQuotaResumeMessage(message, content)) {
+      return false;
+    }
+    if (this.now().getTime() >= wait.resumeAfter.getTime()) {
+      return false;
+    }
+    const replyTo = message?.message_id || null;
+    if (replyTo) {
+      this.processedMessageIds.add(replyTo);
+    }
+    await this.addToQuotaWait([{ messageId: replyTo, content }]);
+    log(`[quota] queued message ${replyTo || "(no id)"} until ${wait.sendAt.toISOString()} (${wait.queued.length} queued)`);
+    return true;
+  }
+
+  /** Ends the quota wait; returns the prompt for the turn that resumes the task. */
+  async leaveQuotaWait(message, content) {
+    const wait = this.quotaWait;
+    this.quotaWait = null;
+    const isResume = this.isQuotaResumeMessage(message, content);
+    const queued = [...wait.queued];
+    if (!isResume) {
+      // Someone wrote after the quota reset, before the scheduled resume fired.
+      queued.push({ messageId: message?.message_id || null, content });
+      const scheduler = this.getQuotaResumeScheduler();
+      // At or after the send time the schedule is (being) sent: leave it be.
+      if (wait.scheduleId && scheduler?.cancel && this.now().getTime() < wait.sendAt.getTime()) {
+        try {
+          await scheduler.cancel({ taskId: this.taskId, scheduleId: wait.scheduleId });
+        } catch (error) {
+          log(`[quota] failed to cancel resume schedule: ${error?.message || error}`);
+        }
+      }
+    }
+    this.lastQuotaResumeQueue = queued;
+    log(`[quota] resuming with ${queued.length} pending message(s)${isResume ? "" : " (ended by a new message)"}`);
+    return buildQuotaResumePrompt(queued);
+  }
+
+  /** The fallback when no server schedule could be made: resume from fire's own clock. */
+  async runLocalQuotaResumeIfDue() {
+    const wait = this.quotaWait;
+    if (!wait?.localResumeAt || this.runningTurn || this.now().getTime() < wait.localResumeAt.getTime()) {
+      return;
+    }
+    await this.respondToMessage({ role: "user", content: buildQuotaResumePrompt(wait.queued) });
+  }
+
   evaluateErrorLoop(errorMessage) {
     const normalizedKey = normalizeExecutionErrorKey(errorMessage);
     const now = Date.now();
@@ -3349,7 +3641,7 @@ export class BridgeRunner {
         )
       : [];
     const rawContent = String(message.content || "").trim();
-    const content = rawContent || (localAttachments.length ? "Analyze the attached files." : "");
+    let content = rawContent || (localAttachments.length ? "Analyze the attached files." : "");
     if (!content) {
       this.copilotLog(`skip empty message replyTo=${message?.message_id || "latest"}`);
       return;
@@ -3363,6 +3655,16 @@ export class BridgeRunner {
       this.copilotLog(`skip in-flight duplicated message replyTo=${replyTo}`);
       return;
     }
+    if (this.quotaWait) {
+      if (await this.queueMessageDuringQuotaWait(message, content)) {
+        return;
+      }
+      content = await this.leaveQuotaWait(message, content);
+    } else if (isQuotaResumePrompt(content)) {
+      // A resume this fire did not schedule (it restarted while waiting):
+      // its text already lists what was queued.
+      this.lastQuotaResumeQueue = null;
+    }
     if (replyTo) {
       this.inFlightMessageIds.add(replyTo);
     }
@@ -3504,6 +3806,8 @@ export class BridgeRunner {
         this.pendingInitialPrompt = "";
       }
       this.resetErrorLoop();
+      this.quotaResumeAttempts = 0;
+      this.lastQuotaResumeQueue = null;
       if (this.useSessionFileReplyStream) {
         this.copilotLog(`session_file turn settled replyTo=${replyTo || "latest"}`);
       } else {
@@ -3531,6 +3835,12 @@ export class BridgeRunner {
       if (await this.settleCodexCheckpointUnavailableAfterStream(replyTo, errorMessage)) {
         return;
       }
+      if (await this.enterQuotaWaitIfQuotaError(errorMessage, { replyTo, content })) {
+        if (replyTo) {
+          this.processedMessageIds.add(replyTo);
+        }
+        return;
+      }
       this.copilotLog(
         `turn failed replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} error="${sanitizeForLog(errorMessage, 200)}"`,
       );
@@ -3664,6 +3974,9 @@ export class BridgeRunner {
     if (!hasAttachmentInputs && this.createFreshBackendSession && isClearCommand(content)) {
       return this.runClearCommand(options);
     }
+    if (!hasAttachmentInputs && isStopCommand(content)) {
+      return this.runStopCommand(options);
+    }
 
     if (willRunGoal) {
       const goalResult = await this.runWithTurnUsage(() =>
@@ -3852,6 +4165,24 @@ export class BridgeRunner {
     return { text, items: [], usage: null, provider: this.backendName, events: [], metadata: {} };
   }
 
+  /**
+   * `/stop`: the server already interrupted the running turn when the message
+   * arrived (fire only reads it once that turn ends), so just confirm it
+   * instead of sending it to the model.
+   */
+  async runStopCommand({ onProgress, replyTo = "" } = {}) {
+    const text = `${this.backendName} 已停止。`;
+    onProgress?.({ phase: "turn_completed", reply_in_progress: false, status_done_line: text });
+    if (this.useSessionFileReplyStream && !this.stopped) {
+      try {
+        await this.sendSessionStreamMessage({ text, replyTo });
+      } catch (error) {
+        log(`[stop] 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) {
@@ -3887,8 +4218,16 @@ export class BridgeRunner {
     surfaceUserMessage,
     replyMetadata,
   }) {
+    if (this.quotaWait) {
+      // Parked on the quota (e.g. the pre-prompt just hit it): run this with the resume.
+      log(`[quota] ${logTag} queued until ${this.quotaWait.sendAt.toISOString()}`);
+      await this.addToQuotaWait([{ messageId: replyTarget || null, content: String(content || "") }]);
+      return;
+    }
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
+    // Lets a target-less interrupt (`/stop`) reach this turn.
+    this.activeTurnReplyTo = replyTarget;
     // Only this turn's own streamed replies may carry its usage.
     this.lastStreamedReplyIds.clear();
     const startedAt = Date.now();
@@ -3963,6 +4302,11 @@ export class BridgeRunner {
         this.copilotLog(`${logTag} turn interrupted by stop_task elapsedMs=${Date.now() - startedAt}`);
         return;
       }
+      const interruptInfo = this.remoteInterruptsByReplyTo.get(replyTarget);
+      if (interruptInfo && this.isTurnInterruptedError(error)) {
+        await this.handleInterruptedTurn(replyTarget, interruptInfo);
+        return;
+      }
       if (
         await this.settleCodexCheckpointUnavailableAfterStream(replyTarget, errorMessage, {
           markProcessed: false,
@@ -3970,17 +4314,47 @@ export class BridgeRunner {
       ) {
         return;
       }
+      if (await this.enterQuotaWaitIfQuotaError(errorMessage, { replyTo: replyTarget, content })) {
+        return;
+      }
       this.copilotLog(
         `${logTag} turn failed elapsedMs=${Date.now() - startedAt} error="${sanitizeForLog(errorMessage, 200)}"`,
       );
       await this.reportError(`${errorLabel}执行失败: ${errorMessage}`);
     } finally {
       this.copilotLog(`${logTag} turn end elapsedMs=${Date.now() - startedAt}`);
+      this.activeTurnReplyTo = "";
+      this.clearInterruptRetryForReplyTarget(replyTarget);
+      this.remoteInterruptsByReplyTo.delete(replyTarget);
       this.runningTurn = false;
       this.scheduleRuntimeHeartbeat();
     }
   }
 
+  // Provider-level warnings the user has to act on (e.g. claude refusing
+  // bypassPermissions as root without IS_SANDBOX=1). Sent right after the
+  // "session started" line so the reason is visible before the turn fails.
+  async reportBackendNotices() {
+    const snapshot =
+      typeof this.backendSession?.getSnapshot === "function" ? this.backendSession.getSnapshot() : null;
+    const notices = Array.isArray(snapshot?.notices)
+      ? snapshot.notices.filter((notice) => typeof notice === "string" && notice.trim())
+      : [];
+    for (const notice of notices) {
+      try {
+        await this.conductor.sendMessage(this.taskId, notice, {
+          severity: "warning",
+          backend: this.backendName,
+          cli_args: this.cliArgs,
+          synthetic: true,
+        });
+        this.copilotLog(`backend notice sent: ${sanitizeForLog(notice, 120)}`);
+      } catch (error) {
+        log(`Failed to send backend notice: ${error?.message || error}`);
+      }
+    }
+  }
+
   async reportError(message, replyTo) {
     try {
       await this.conductor.sendMessage(this.taskId, message, {