@qwen-code/qwen-code 0.23.5-dev.codemode-responses.20260915.f024b37689 → 0.23.5-preview.0

package/chunks/{chunk-EPVEPTI3.js → chunk-PZRXWQUA.js}

@@ -3,6 +3,7 @@
 import {
   ClientSideConnection,
   PROTOCOL_VERSION,
+  RequestError,
   ndJsonStream
 } from "./chunk-IJOS26LH.js";
 import {
@@ -461,6 +462,18 @@ init_esbuild_shims();
 var CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY = "qwen.daemon.promptDisplayText";
 var CHANNEL_PROMPT_AUTHORIZATION_META_KEY = "qwen.daemon.channelPromptAuthorization";
 var CHANNEL_PROMPT_META_KEY = "qwen.channel.prompt";
+var CHANNEL_OUTPUT_MODE_META_KEY = "qwen.channel.outputMode";
+var CHANNEL_TASK_RESULT_META_KEY = "qwen.channel.taskResult";
+var CHANNEL_TASK_RESULT_PARTIAL_META_KEY = "qwen.channel.taskResultPartial";
+var CHANNEL_TASK_OUTPUT_META_KEY = "qwen.channel.taskOutput";
+var ChannelPromptCancelledError = class extends Error {
+  static {
+    __name(this, "ChannelPromptCancelledError");
+  }
+  constructor() {
+    super("Channel task cancelled");
+  }
+};
 var CHANNEL_BTW_METHOD = "qwen/control/session/btw";
 var ACP_PRIVATE_PARENT_CAPABILITY_META_KEY = "qwen-code/private-parent-capability";
 var ACP_PRIVATE_PARENT_CAPABILITY_ENV = "QWEN_CODE_PRIVATE_ACP_CAPABILITY";
@@ -857,22 +870,32 @@ var AcpBridge = class extends EventEmitter {
     }
     prompt.push({ type: "text", text });
     try {
-      await conn.prompt({
+      const result = await conn.prompt({
         sessionId,
         prompt,
         _meta: {
           [CHANNEL_PROMPT_META_KEY]: true,
+          ...options?.outputMode === "per_task" ? { [CHANNEL_OUTPUT_MODE_META_KEY]: "per_task" } : {},
           ...options?.displayText !== void 0 ? {
             [CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY]: options.displayText
           } : {}
         }
       });
+      if (options?.outputMode === "per_task" && result?.stopReason === "cancelled") {
+        throw new ChannelPromptCancelledError();
+      }
+      const taskResult = result?._meta?.[CHANNEL_TASK_RESULT_META_KEY];
+      if (options?.outputMode === "per_task") {
+        options.onTaskResult?.({
+          partial: result?._meta?.[CHANNEL_TASK_RESULT_PARTIAL_META_KEY] === true
+        });
+      }
+      return options?.outputMode === "per_task" && typeof taskResult === "string" && taskResult.trim() ? taskResult : chunks.join("") || slashCommandOutput;
     } finally {
       this.off("textChunk", onChunk);
       this.off("slashCommandOutput", onSlashCommandOutput);
       this.off("responseBoundary", clearChunks);
     }
-    return chunks.join("") || slashCommandOutput;
   }
   async btw(sessionId, question, signal) {
     if (!this.knownSessionIds.has(sessionId)) {
@@ -957,7 +980,7 @@ var AcpBridge = class extends EventEmitter {
         }
         const content = update["content"];
         if (meta?.["qwenDiscreteMessage"] === true) {
-          if (meta["source"] === "background_notification_response" && meta["rewritten"] !== true) {
+          if (meta["source"] === "background_notification_response" && meta["rewritten"] !== true && meta[CHANNEL_TASK_OUTPUT_META_KEY] !== true) {
             const context = parseBackgroundResponseContext(meta["backgroundTask"]);
             if (content?.type === "text" && (content.text || context?.turnComplete)) {
               this.emit("backgroundResponse", sessionId, content.text ?? "", context);
@@ -1149,7 +1172,7 @@ var AcpBridge = class extends EventEmitter {
         hasQueuedPrompt: false
       };
     }
-    throw new Error(`Method not found: ${method}`);
+    throw RequestError.methodNotFound(method);
   }
   async handleClientMcpMessage(params) {
     if (!this.channelLoopMcpServer) {
@@ -1230,6 +1253,35 @@ function formatSkippedRegistrationReason(result) {
 }
 __name(formatSkippedRegistrationReason, "formatSkippedRegistrationReason");
 
+// packages/channels/base/dist/output-mode.js
+init_esbuild_shims();
+var DEFAULT_CHANNEL_OUTPUT_MODE = "per_turn";
+var CHANNEL_OUTPUT_MODE_FIELD = {
+  key: "outputMode",
+  label: "Output Mode",
+  kind: "enum",
+  default: DEFAULT_CHANNEL_OUTPUT_MODE,
+  description: "Choose one final result for the complete task, each complete assistant response, or the last reply in each turn. Defaults to per turn: the main response finishes independently of background follow-ups. Applies to cards and ordinary messages.",
+  options: [
+    { value: "per_task", label: "Per task" },
+    { value: "per_response", label: "Per response" },
+    { value: "per_turn", label: "Per turn (default)" }
+  ]
+};
+function parseChannelOutputMode(name, value, supportsOutputMode) {
+  if (value === void 0) {
+    return supportsOutputMode ? DEFAULT_CHANNEL_OUTPUT_MODE : void 0;
+  }
+  if (!supportsOutputMode) {
+    throw new Error(`Channel "${name}" does not support outputMode.`);
+  }
+  if (value !== "per_task" && value !== "per_response" && value !== "per_turn") {
+    throw new Error(`Channel "${name}" outputMode must be "per_task", "per_response", or "per_turn".`);
+  }
+  return value;
+}
+__name(parseChannelOutputMode, "parseChannelOutputMode");
+
 // packages/channels/base/dist/index.js
 init_esbuild_shims();
 
@@ -2130,7 +2182,7 @@ var SessionRouter = class {
    * heals it through the superseded redirect — the failed reset drops the
    * old id from the live set so that load consults the daemon again.
    */
-  async replaceManagedWorktreeSession(sessionId, target, workspaceCwd, expectedCwd) {
+  async replaceManagedWorktreeSession(sessionId, target, workspaceCwd, expectedCwd, beforeForget) {
     const bridge = this.bridge;
     if (!bridge.resetWorktreeSession) {
       throw new Error("Worktree reset is not supported by this bridge");
@@ -2156,6 +2208,7 @@ var SessionRouter = class {
       this.toTarget.set(replacementId, target);
       this.toCwd.set(replacementId, actualCwd);
       this.liveSessionIds.add(replacementId);
+      beforeForget?.();
       this.forgetManagedSession(sessionId);
       return replacementId;
     } catch (error) {
@@ -2224,13 +2277,14 @@ var SessionRouter = class {
     if (changed)
       this.persist();
   }
-  async detachManagedSession(sessionId) {
+  async detachManagedSession(sessionId, beforeForget) {
     try {
       if (this.bridge.discardSession) {
         await this.bridge.discardSession(sessionId);
       } else if (this.liveSessionIds.has(sessionId)) {
         throw new Error("Managed session detach is not supported");
       }
+      beforeForget?.();
     } finally {
       this.forgetManagedSession(sessionId);
     }
@@ -2730,6 +2784,7 @@ var NamedSessionManager = class {
   filePath;
   router;
   isBusy;
+  onSessionRetiring;
   now;
   registry;
   taskBySessionId;
@@ -2747,6 +2802,7 @@ var NamedSessionManager = class {
     this.filePath = options.filePath;
     this.router = options.router;
     this.isBusy = options.isBusy;
+    this.onSessionRetiring = options.onSessionRetiring;
     this.now = options.now ?? Date.now;
     this.registry = this.readRegistry();
     this.taskBySessionId = this.buildTaskIndex(this.registry);
@@ -2986,7 +3042,7 @@ var NamedSessionManager = class {
         this.router.activateManagedSession(replacementSessionId ?? replacement.sessionId, replacement.target, replacement.cwd, { isolation: replacement.isolation, workspaceCwd: this.cwd });
       }
       try {
-        await this.router.detachManagedSession(task.sessionId);
+        await this.router.detachManagedSession(task.sessionId, () => this.onSessionRetiring?.(task.sessionId));
       } catch (error) {
         const healedReplacement = replacement !== void 0 && replacementSessionId !== void 0 && replacementSessionId !== replacement.sessionId ? { ...replacement, sessionId: replacementSessionId } : void 0;
         this.commitOwner(healedReplacement ? this.replaceTask(owner, healedReplacement, owner.activeTaskName) : owner);
@@ -3059,6 +3115,7 @@ var NamedSessionManager = class {
         throw error;
       }
       this.router.activateManagedSession(sessionId, updatedTask.target, updatedTask.cwd, { isolation: updatedTask.isolation, workspaceCwd: this.cwd });
+      this.onSessionRetiring?.(task.sessionId);
       this.router.forgetManagedSession(task.sessionId);
       this.repointSupersededSessionIds(task.sessionId, sessionId);
       this.supersededSessionIds.delete(task.sessionId);
@@ -3225,7 +3282,7 @@ var NamedSessionManager = class {
   }
   async resetWorktreeSession(task) {
     try {
-      return await this.router.replaceManagedWorktreeSession(task.sessionId, task.target, this.cwd, task.cwd);
+      return await this.router.replaceManagedWorktreeSession(task.sessionId, task.target, this.cwd, task.cwd, () => this.onSessionRetiring?.(task.sessionId));
     } catch (error) {
       throw new NamedSessionTaskError(`Could not reset task "${task.name}".`, task.name, { cause: error });
     }
@@ -4332,6 +4389,14 @@ var ChannelBase = class {
     }
     await this.deliverBackgroundResponseToTarget(sessionId, text, delivery);
   }
+  getBackgroundResponseSourceLabel(sessionId) {
+    const target = this.router.getTarget(sessionId);
+    const presentation = this.namedSessions?.presentation(sessionId);
+    if (!target || target.channelName !== this.name || !this.router.isSessionLive(sessionId) || !presentation || presentation.status !== "open" || !this.sameTaskOwner(target, presentation.target)) {
+      return void 0;
+    }
+    return this.createSourceLabel(presentation, target);
+  }
   async resolveBackgroundResponseDelivery(sessionId) {
     let target = this.router.getTarget(sessionId);
     if (!target || target.channelName !== this.name)
@@ -4863,7 +4928,8 @@ No answer is available from the current conversation context.`;
         cwd: config.cwd,
         filePath: join5(options.stateDir, "named-sessions.json"),
         router: this.router,
-        isBusy: /* @__PURE__ */ __name((sessionId) => this.isNamedSessionBusy(sessionId), "isBusy")
+        isBusy: /* @__PURE__ */ __name((sessionId) => this.isNamedSessionBusy(sessionId), "isBusy"),
+        onSessionRetiring: /* @__PURE__ */ __name((sessionId) => this.onSessionRetiring(sessionId), "onSessionRetiring")
       });
     }
     this.registerSharedCommands();
@@ -5787,9 +5853,13 @@ ${promptText}` : promptText;
       active.cancelPending = false;
     }).then((cancelSucceeded) => {
       const turnEnded = this.activePrompts.get(sessionId) !== active;
-      if (!cancelSucceeded || active.deliveryStarted || turnEnded && !active.cancelled) {
+      if (!cancelSucceeded || active.deliveryStarted || turnEnded && !active.cancelled && !active.cancellationEmitted) {
         return false;
       }
+      if (turnEnded) {
+        this.emitTaskCancellation(active, sessionId, reason);
+        return true;
+      }
       active.cancelled = true;
       this.dropCollectBuffer(sessionId);
       this.removePendingPermissionsForSession(sessionId, "run_cancelled");
@@ -6525,7 +6595,6 @@ ${requestList}`);
           const result = await namedSessions.close(owner, parts[0]);
           if (closing) {
             this.cancelBtw(closing.sessionId);
-            this.onSessionRetiring(closing.sessionId);
           }
           await this.sendThreadMessage(envelope.chatId, envelope.threadId, result.active ? `Closed task "${result.closed.name}". Selected "${result.active.name}".` : `Closed task "${result.closed.name}". No task is selected.`);
           return true;
@@ -6595,8 +6664,9 @@ ${requestList}`);
       this.clearPendingGroupHistory(envelope);
       if (removedIds.length > 0) {
         for (const id of removedIds) {
-          if (id !== retiringSessionId)
+          if (!this.namedSessions && id !== retiringSessionId) {
             this.onSessionRetiring(id);
+          }
           this.cancelBtw(id);
           if (this.isSharedSession(envelope)) {
             const who = sanitizeSenderName(envelope.senderName || envelope.senderId || "unknown");
@@ -8451,8 +8521,15 @@ ${promptToSend}`;
       const promptBridge = this.bridge;
       promptBridge.on("textChunk", onChunk);
       promptBridge.on("responseBoundary", onResponseBoundary);
+      let taskResultPartial = false;
       try {
         const response = await promptBridge.prompt(sessionId, promptToSend, {
+          ...this.config.outputMode === "per_task" ? {
+            outputMode: "per_task",
+            onTaskResult: /* @__PURE__ */ __name(({ partial }) => {
+              taskResultPartial = partial;
+            }, "onTaskResult")
+          } : {},
           ...images.length > 0 ? { images } : {},
           imageBase64,
           imageMimeType,
@@ -8467,6 +8544,8 @@ ${promptToSend}`;
         if (!promptState.cancelled && response) {
           promptState.deliveryStarted = true;
           const segment = this.ensureOutputSegment(sessionId, promptState);
+          if (segment && taskResultPartial)
+            segment.partial = true;
           await this.onResponseComplete(envelope.chatId, response, sessionId, segment);
           if (segment && promptState.activeSegmentId === segment.segmentId) {
             promptState.activeSegmentId = void 0;
@@ -8484,10 +8563,14 @@ ${promptToSend}`;
           });
         }
       } catch (err) {
+        const runtimeCancelled = !promptState.deliveryStarted && err instanceof ChannelPromptCancelledError;
         if (!promptState.deliveryStarted) {
           await this.settleCancelRequested(promptState);
+          if (runtimeCancelled) {
+            this.emitTaskCancellation(promptState, sessionId, "runtime_cancelled");
+          }
         }
-        if (!promptState.cancelled) {
+        if (!promptState.cancelled && !runtimeCancelled) {
           releaseHeldChunks();
           const segment = this.closeOutputSegment(sessionId, promptState);
           void this.notifyOutputSegmentEnd(envelope.chatId, sessionId, segment, "failed");
@@ -8504,7 +8587,7 @@ ${promptToSend}`;
           process.stderr.write(`[${channel}] turn ${safeMessageId} threw after cancellation for session ${safeSessionId}: ${this.lifecycleError(err)}
 `);
         }
-        if (promptState.cancelled) {
+        if (promptState.cancelled || runtimeCancelled) {
           return;
         }
         if (sourceLabel) {
@@ -8825,6 +8908,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   requestToSession = /* @__PURE__ */ new Map();
   respondedRequestToSession = /* @__PURE__ */ new Map();
   activePrompts = /* @__PURE__ */ new Set();
+  taskOutputs = /* @__PURE__ */ new Map();
   activePromptControllers = /* @__PURE__ */ new Map();
   availableCommandsBySession = /* @__PURE__ */ new Map();
   toolCallKindsBySession = /* @__PURE__ */ new Map();
@@ -8987,6 +9071,9 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       throw new Error(`Prompt already in flight for daemon session ${sessionId}`);
     }
     this.activePrompts.add(sessionId);
+    const taskOutput = options?.outputMode === "per_task" ? {} : void 0;
+    if (taskOutput)
+      this.taskOutputs.set(sessionId, taskOutput);
     const controller = new AbortController();
     let controllers = this.activePromptControllers.get(sessionId);
     if (!controllers) {
@@ -9103,6 +9190,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
           prompt,
           _meta: {
             [CHANNEL_PROMPT_META_KEY]: true,
+            ...options?.outputMode === "per_task" ? { [CHANNEL_OUTPUT_MODE_META_KEY]: "per_task" } : {},
             ...promptAuthorization ? {
               [CHANNEL_PROMPT_AUTHORIZATION_META_KEY]: promptAuthorization
             } : {},
@@ -9121,7 +9209,13 @@ var DaemonChannelBridge = class extends EventEmitter2 {
         turnBarrier,
         new Promise((resolve3) => setTimeout(resolve3, 0))
       ]);
-      const textResult = chunks.join("") || slashCommandOutput;
+      if (options?.outputMode === "per_task" && result.stopReason === "cancelled") {
+        throw new ChannelPromptCancelledError();
+      }
+      if (taskOutput) {
+        options?.onTaskResult?.({ partial: taskOutput.partial === true });
+      }
+      const textResult = taskOutput?.text || chunks.join("") || slashCommandOutput;
       this.emit("promptComplete", {
         sessionId,
         text: textResult,
@@ -9135,6 +9229,9 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       this.off("responseBoundary", clearChunks);
       this.off("sessionDied", onSessionDied);
       this.activePrompts.delete(sessionId);
+      if (this.taskOutputs.get(sessionId) === taskOutput) {
+        this.taskOutputs.delete(sessionId);
+      }
       controllers.delete(controller);
       if (controllers.size === 0 && this.activePromptControllers.get(sessionId) === controllers) {
         this.activePromptControllers.delete(sessionId);
@@ -9322,6 +9419,8 @@ var DaemonChannelBridge = class extends EventEmitter2 {
         this.dropSession(session.sessionId, this.getStringField(event.data, "error", "stream_error"));
         break;
       case "turn_complete":
+        if (isRecord3(event.data) && event.data["backgroundTurn"])
+          break;
         this.resolveTurnBarrier(session.sessionId);
         break;
       case "turn_error":
@@ -9347,7 +9446,21 @@ var DaemonChannelBridge = class extends EventEmitter2 {
         }
         const text = getTextContent(update["content"]);
         if (meta?.["qwenDiscreteMessage"] === true) {
-          if (meta["source"] === "background_notification_response" && meta["rewritten"] !== true) {
+          if (meta["source"] === "background_notification_response" && meta["rewritten"] !== true && meta[CHANNEL_TASK_OUTPUT_META_KEY] === true) {
+            const taskOutput = this.taskOutputs.get(sessionId);
+            if (taskOutput) {
+              const context = parseBackgroundResponseContext(meta["backgroundTask"]);
+              if (text?.trim()) {
+                taskOutput.text = text;
+                taskOutput.turnId = context?.turnId;
+                taskOutput.partial = context?.partial === true;
+              } else if (context?.turnComplete && context.turnId !== void 0 && context.turnId === taskOutput.turnId) {
+                taskOutput.partial = context.partial === true;
+              }
+            }
+            break;
+          }
+          if (meta["source"] === "background_notification_response" && meta["rewritten"] !== true && meta[CHANNEL_TASK_OUTPUT_META_KEY] !== true) {
             const context = parseBackgroundResponseContext(meta["backgroundTask"]);
             if (text || context?.turnComplete) {
               this.emit("backgroundResponse", sessionId, text ?? "", context);
@@ -9810,6 +9923,620 @@ function isTerminalTaskLifecycleType(type) {
 }
 __name(isTerminalTaskLifecycleType, "isTerminalTaskLifecycleType");
 
+// packages/channels/base/dist/output-turn.js
+init_esbuild_shims();
+var ChannelOutputTurn = class {
+  static {
+    __name(this, "ChannelOutputTurn");
+  }
+  mode;
+  lastOutput;
+  finished = false;
+  constructor(mode = DEFAULT_CHANNEL_OUTPUT_MODE) {
+    this.mode = mode;
+  }
+  get latestOnly() {
+    return this.mode === "per_turn" || this.mode === "per_task";
+  }
+  shouldPreview(text) {
+    return !this.finished && text.trim() !== "";
+  }
+  close(text, reason) {
+    if (this.finished)
+      return { kind: "skip" };
+    if (reason === "failed" || reason === "cancelled") {
+      this.lastOutput = void 0;
+      return { kind: reason };
+    }
+    if (!text.trim()) {
+      if (reason === "response_boundary" || !this.latestOnly) {
+        return { kind: "skip" };
+      }
+      text = this.lastOutput ?? "";
+      if (!text.trim())
+        return { kind: "skip" };
+    }
+    if (reason === "response_boundary" && this.mode !== "per_response") {
+      this.lastOutput = text;
+      return {
+        kind: "preview",
+        text
+      };
+    }
+    this.lastOutput = void 0;
+    return { kind: "complete", text, rotate: reason !== "completed" };
+  }
+  finish(terminal) {
+    const output = terminal === "completed" ? this.lastOutput : void 0;
+    this.lastOutput = void 0;
+    this.finished = true;
+    return output;
+  }
+};
+
+// packages/channels/base/dist/background-output-coordinator.js
+init_esbuild_shims();
+var BACKGROUND_OUTPUT_TIMEOUT_MS = 10 * 60 * 1e3;
+var BACKGROUND_OUTPUT_RETRY_MS = 30 * 1e3;
+var BACKGROUND_OUTPUT_MAX_RETRIES = 3;
+var BackgroundOutputCoordinator = class {
+  static {
+    __name(this, "BackgroundOutputCoordinator");
+  }
+  options;
+  backgroundResponseAggregations = /* @__PURE__ */ new Map();
+  detachedBackgroundResponseAggregations = /* @__PURE__ */ new Set();
+  pendingBackgroundResponseTerminals = /* @__PURE__ */ new Map();
+  detachedPendingBackgroundResponseTerminals = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.options = options;
+  }
+  /** False leaves delivery to the adapter's immediate response path. */
+  async dispatch(sessionId, text, context) {
+    if (this.options.outputMode !== "per_turn" && this.options.outputMode !== "per_task" || !context || typeof context.turnComplete !== "boolean") {
+      return false;
+    }
+    await this.collect(sessionId, text, context);
+    return true;
+  }
+  async collect(sessionId, text, context) {
+    const target = this.options.getTarget(sessionId);
+    if (!target)
+      return;
+    const key = JSON.stringify([
+      sessionId,
+      context.kind,
+      context.taskId,
+      context.turnId
+    ]);
+    let current = this.backgroundResponseAggregations.get(key);
+    let parked = this.pendingBackgroundResponseTerminals.get(key);
+    if (current?.turnComplete === true) {
+      this.detachedBackgroundResponseAggregations.add(current);
+      this.backgroundResponseAggregations.delete(key);
+      current = void 0;
+    }
+    if (!current && (parked?.turnEnded === true || parked?.turnComplete === true && (parked.retryTimer || parked.retryInFlight || parked.resolvers > 0))) {
+      if (!parked.turnEnded) {
+        this.detachedPendingBackgroundResponseTerminals.add(parked);
+      }
+      parked = {
+        sessionId,
+        target,
+        sourceLabel: this.options.getSourceLabel?.(sessionId),
+        resolvers: 0,
+        held: []
+      };
+      this.pendingBackgroundResponseTerminals.set(key, parked);
+    }
+    if (!current && text.trim().length === 0) {
+      if (!parked || parked.resolvers === 0 && !parked.retryTimer && !parked.retryInFlight && !parked.resolutionDropped && !parked.turnComplete) {
+        if (parked)
+          this.pendingBackgroundResponseTerminals.delete(key);
+        return;
+      }
+      if (context.turnComplete) {
+        parked.turnComplete = true;
+        parked.status = context.status;
+        parked.label = context.label ?? parked.label;
+        parked.completionPartial = context.partial === true;
+        if (parked.resolvers === 0 && !parked.retryTimer && !parked.retryInFlight && (parked.retryAttempts ?? 0) >= BACKGROUND_OUTPUT_MAX_RETRIES) {
+          parked.turnEnded = true;
+          this.pendingBackgroundResponseTerminals.delete(key);
+        }
+      }
+      return;
+    }
+    if (!current) {
+      parked ??= {
+        sessionId,
+        target,
+        sourceLabel: this.options.getSourceLabel?.(sessionId),
+        resolvers: 0,
+        held: []
+      };
+      this.pendingBackgroundResponseTerminals.set(key, parked);
+      this.holdPendingBackgroundResponse(parked, text, context);
+      parked.resolvers++;
+      try {
+        let delivery;
+        try {
+          delivery = await this.options.resolveDelivery(sessionId);
+        } catch (error) {
+          if (parked.resolvers === 1 && !this.backgroundResponseAggregations.has(key)) {
+            this.scheduleBackgroundResponseResolutionRetry(key, sessionId, parked);
+          } else {
+            const existing = this.backgroundResponseAggregations.get(key);
+            if (existing) {
+              if (parked.held.length > 0) {
+                this.applyHeldBackgroundResponses(existing, parked);
+              }
+              this.applyPendingBackgroundResponseTerminal(existing, parked);
+              if (parked.resolvers === 1) {
+                if (existing.turnComplete) {
+                  await this.completeBackgroundResponseAggregation(key, existing);
+                } else {
+                  this.scheduleBackgroundResponseAggregationFlush(key, existing);
+                }
+              }
+            }
+          }
+          throw error;
+        }
+        if (!delivery || this.options.getTarget(sessionId) !== delivery.target) {
+          if (parked.resolvers === 1 && !this.backgroundResponseAggregations.has(key)) {
+            this.scheduleBackgroundResponseResolutionRetry(key, sessionId, parked);
+          } else {
+            const existing = this.backgroundResponseAggregations.get(key);
+            if (existing) {
+              if (parked.held.length > 0) {
+                this.applyHeldBackgroundResponses(existing, parked);
+              }
+              this.applyPendingBackgroundResponseTerminal(existing, parked);
+              if (parked.resolvers === 1) {
+                if (existing.turnComplete) {
+                  await this.completeBackgroundResponseAggregation(key, existing);
+                } else {
+                  this.scheduleBackgroundResponseAggregationFlush(key, existing);
+                }
+              }
+            }
+          }
+          return;
+        }
+        if (parked.retiring || parked.turnEnded === true || this.pendingBackgroundResponseTerminals.get(key) !== parked) {
+          await this.flushDetachedBackgroundResponse(key, sessionId, parked, delivery);
+          return;
+        }
+        parked.sourceLabel = delivery.sourceLabel;
+        if (parked.retryTimer) {
+          clearTimeout(parked.retryTimer);
+          parked.retryTimer = void 0;
+        }
+        current = this.backgroundResponseAggregations.get(key) ?? this.createBackgroundResponseAggregation(key, sessionId, parked.held[0]?.context ?? context, delivery.target, delivery.sourceLabel);
+        this.applyHeldBackgroundResponses(current, parked);
+        this.applyPendingBackgroundResponseTerminal(current, parked);
+        if (parked.resolutionDropped) {
+          current.resolutionDropped = true;
+          parked.resolutionDropped = void 0;
+        }
+      } finally {
+        parked.resolvers--;
+        if (this.pendingBackgroundResponseTerminals.get(key) === parked && parked.resolvers === 0 && !parked.retryTimer && parked.held.length === 0 && (!parked.resolutionDropped || parked.turnEnded)) {
+          this.pendingBackgroundResponseTerminals.delete(key);
+        }
+      }
+      if (!current)
+        return;
+      if (current.turnComplete && parked.resolvers > 0)
+        return;
+      if (!current.turnComplete) {
+        this.scheduleBackgroundResponseAggregationFlush(key, current);
+      } else {
+        await this.completeBackgroundResponseAggregation(key, current);
+      }
+      return;
+    }
+    current.status = context.status;
+    current.label = context.label ?? current.label;
+    if (text.trim())
+      current.text = text;
+    if (context.turnComplete && parked && parked.resolvers > 0) {
+      parked.turnComplete = true;
+      parked.status = context.status;
+      parked.label = context.label ?? parked.label;
+      parked.completionPartial = context.partial === true;
+    } else if (context.turnComplete) {
+      current.turnComplete = true;
+      current.completionPartial = context.partial === true;
+    } else if (parked?.turnComplete && parked.resolvers === 0) {
+      current.turnComplete = true;
+      current.status = parked.status ?? current.status;
+      current.label = parked.label ?? current.label;
+      current.completionPartial = parked.completionPartial === true;
+    }
+    current.resolutionDropped ||= parked?.resolutionDropped;
+    if (!current.turnComplete) {
+      this.scheduleBackgroundResponseAggregationFlush(key, current);
+      return;
+    }
+    await this.completeBackgroundResponseAggregation(key, current);
+  }
+  flushBackgroundResponseAggregation(key, aggregation) {
+    if (aggregation.flushing)
+      return Promise.resolve();
+    const flushing = this.flushBackgroundResponseAggregationInner(key, aggregation).finally(() => {
+      if (aggregation.flushing === flushing)
+        aggregation.flushing = void 0;
+    });
+    aggregation.flushing = flushing;
+    return flushing;
+  }
+  async flushBackgroundResponseAggregationInner(key, aggregation) {
+    if (this.backgroundResponseAggregations.get(key) !== aggregation && !this.detachedBackgroundResponseAggregations.has(aggregation)) {
+      return;
+    }
+    if (aggregation.retryTimer)
+      clearTimeout(aggregation.retryTimer);
+    aggregation.retryTimer = void 0;
+    let delivery = aggregation.delivery;
+    if (!delivery) {
+      if (!aggregation.text) {
+        if (!this.owesTerminalBackgroundResponse(aggregation)) {
+          if (aggregation.retiring || aggregation.turnComplete) {
+            this.removeBackgroundResponseAggregation(key, aggregation);
+          } else {
+            this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+          }
+          return;
+        }
+      }
+      if (aggregation.timeoutTimer)
+        clearTimeout(aggregation.timeoutTimer);
+      aggregation.timeoutTimer = void 0;
+      const text = aggregation.text;
+      aggregation.text = "";
+      delivery = {
+        status: aggregation.status,
+        kind: aggregation.kind,
+        label: aggregation.label,
+        text,
+        partial: this.isPartialBackgroundResponseDelivery(aggregation, text.length > 0),
+        attempts: 0,
+        send: this.options.createDelivery(aggregation.sessionId, {
+          target: aggregation.target,
+          sourceLabel: aggregation.sourceLabel
+        })
+      };
+      aggregation.delivery = delivery;
+    }
+    let error;
+    let composedTurnComplete = false;
+    try {
+      const result = await delivery.send({
+        status: delivery.status,
+        kind: delivery.kind,
+        label: delivery.label,
+        text: delivery.text,
+        partial: delivery.partial,
+        turnComplete: aggregation.turnComplete === true
+      });
+      composedTurnComplete = result.turnComplete;
+    } catch (caught) {
+      error = caught;
+    }
+    if (error === void 0) {
+      aggregation.delivery = void 0;
+      aggregation.delivered = true;
+      if (composedTurnComplete && aggregation.turnComplete && delivery.partial !== true && !aggregation.retiring) {
+        aggregation.completionDelivered = true;
+      }
+      if (aggregation.retiring || aggregation.turnComplete) {
+        await this.flushBackgroundResponseAggregationInner(key, aggregation);
+      } else {
+        this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+      }
+      return;
+    }
+    delivery.attempts++;
+    this.options.log(`background response delivery failed (attempt ${delivery.attempts}): ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+    if (aggregation.retiring || delivery.attempts >= BACKGROUND_OUTPUT_MAX_RETRIES || // A permanently rejected send cannot
+    // succeed later; retrying it only spends the chat's send quota.
+    !this.options.isRetryableError(error)) {
+      aggregation.delivery = void 0;
+      aggregation.dropped = true;
+      if (!aggregation.text) {
+        if (aggregation.retiring || aggregation.turnComplete) {
+          this.removeBackgroundResponseAggregation(key, aggregation);
+        } else {
+          this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+        }
+      } else if (aggregation.retiring || aggregation.turnComplete) {
+        await this.flushBackgroundResponseAggregationInner(key, aggregation);
+      } else {
+        this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+      }
+      return;
+    }
+    aggregation.retryTimer = setTimeout(() => {
+      aggregation.retryTimer = void 0;
+      void this.flushBackgroundResponseAggregation(key, aggregation);
+    }, BACKGROUND_OUTPUT_RETRY_MS);
+    aggregation.retryTimer.unref?.();
+  }
+  /**
+   * A delivery is partial whenever it is not the turn's whole output: the
+   * turn is still open, earlier text already went out (or was given up on),
+   * or the turn itself ended early.
+   */
+  isPartialBackgroundResponseDelivery(aggregation, hasText) {
+    return hasText && (aggregation.delivered === true || aggregation.dropped === true || aggregation.resolutionDropped === true || aggregation.retiring === true || aggregation.completionPartial === true || aggregation.turnComplete !== true);
+  }
+  /**
+   * If a turn outlives the bounded wait, its final empty marker still needs
+   * a terminal delivery so recipients learn that the partial output finished.
+   */
+  owesTerminalBackgroundResponse(aggregation) {
+    return aggregation.turnComplete === true && aggregation.delivered === true && aggregation.completionDelivered !== true && aggregation.retiring !== true && aggregation.completionPartial !== true && aggregation.dropped !== true && aggregation.resolutionDropped !== true;
+  }
+  removeBackgroundResponseAggregation(key, aggregation) {
+    if (this.backgroundResponseAggregations.get(key) === aggregation) {
+      this.backgroundResponseAggregations.delete(key);
+    }
+    this.detachedBackgroundResponseAggregations.delete(aggregation);
+  }
+  drain(sessionId) {
+    const flushes = [];
+    for (const [key, pending] of this.pendingBackgroundResponseTerminals) {
+      if (sessionId !== void 0 && pending.sessionId !== sessionId)
+        continue;
+      if (pending.retryTimer)
+        clearTimeout(pending.retryTimer);
+      pending.retryTimer = void 0;
+      pending.retiring = true;
+      pending.turnComplete = true;
+      pending.completionPartial = true;
+      this.pendingBackgroundResponseTerminals.delete(key);
+      this.detachedPendingBackgroundResponseTerminals.add(pending);
+    }
+    for (const pending of this.detachedPendingBackgroundResponseTerminals) {
+      if (sessionId !== void 0 && pending.sessionId !== sessionId)
+        continue;
+      if (pending.retryTimer)
+        clearTimeout(pending.retryTimer);
+      pending.retryTimer = void 0;
+      pending.retiring = true;
+      pending.turnComplete = true;
+      pending.completionPartial = true;
+      if (pending.held.length > 0 && this.options.getTarget(pending.sessionId) === pending.target) {
+        flushes.push(this.flushDetachedBackgroundResponse("", pending.sessionId, pending, {
+          target: pending.target,
+          sourceLabel: pending.sourceLabel
+        }));
+      } else if (pending.held.length > 0) {
+        this.options.log(`background response target unavailable during drain; ${pending.held.length} buffered segment(s) discarded
+`);
+        pending.held.length = 0;
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      } else if (pending.held.length === 0) {
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      }
+    }
+    const aggregations = /* @__PURE__ */ new Set([
+      ...this.backgroundResponseAggregations.values(),
+      ...this.detachedBackgroundResponseAggregations
+    ]);
+    for (const aggregation of aggregations) {
+      if (sessionId !== void 0 && aggregation.sessionId !== sessionId) {
+        continue;
+      }
+      if (aggregation.timeoutTimer)
+        clearTimeout(aggregation.timeoutTimer);
+      if (aggregation.retryTimer)
+        clearTimeout(aggregation.retryTimer);
+      aggregation.timeoutTimer = void 0;
+      aggregation.retryTimer = void 0;
+      aggregation.retiring = true;
+      aggregation.turnComplete = true;
+      aggregation.completionPartial = true;
+      flushes.push(aggregation.flushing ?? this.flushBackgroundResponseAggregation(aggregation.key, aggregation));
+    }
+    return Promise.allSettled(flushes).then((results) => {
+      for (const result of results) {
+        if (result.status === "rejected") {
+          const error = result.reason;
+          this.options.log(`background response delivery failed during drain: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+        }
+      }
+    });
+  }
+  createBackgroundResponseAggregation(key, sessionId, context, target, sourceLabel) {
+    const aggregation = {
+      key,
+      sessionId,
+      target,
+      sourceLabel,
+      status: context.status,
+      kind: context.kind,
+      label: context.label,
+      text: ""
+    };
+    this.backgroundResponseAggregations.set(key, aggregation);
+    return aggregation;
+  }
+  scheduleBackgroundResponseResolutionRetry(key, sessionId, pending) {
+    if (pending.retiring)
+      return;
+    if (pending.retryTimer)
+      return;
+    pending.retryAttempts = (pending.retryAttempts ?? 0) + 1;
+    if (pending.retryAttempts >= BACKGROUND_OUTPUT_MAX_RETRIES) {
+      this.options.log(`background response target unresolved after ${pending.retryAttempts} attempts; ${pending.held.length} buffered segment(s) discarded
+`);
+      pending.resolutionDropped = true;
+      pending.turnEnded = pending.turnComplete === true;
+      pending.held.length = 0;
+      pending.turnComplete = void 0;
+      pending.status = void 0;
+      pending.label = void 0;
+      pending.completionPartial = void 0;
+      if (pending.turnEnded) {
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      }
+      return;
+    }
+    pending.retryTimer = setTimeout(() => {
+      pending.retryTimer = void 0;
+      pending.retryInFlight = true;
+      void this.retryBackgroundResponseResolution(key, sessionId, pending).catch((error) => {
+        this.options.log(`background response target resolution failed: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+      }).finally(() => {
+        pending.retryInFlight = false;
+        if (pending.retiring || !pending.retryTimer && !pending.resolutionDropped) {
+          this.detachedPendingBackgroundResponseTerminals.delete(pending);
+        }
+        if (this.pendingBackgroundResponseTerminals.get(key) === pending && pending.resolvers === 0 && !pending.retryTimer && pending.held.length === 0 && (!pending.resolutionDropped || pending.turnEnded)) {
+          this.pendingBackgroundResponseTerminals.delete(key);
+        }
+      });
+    }, BACKGROUND_OUTPUT_RETRY_MS);
+    pending.retryTimer.unref?.();
+    const active = this.pendingBackgroundResponseTerminals.get(key);
+    if (!active || active === pending) {
+      this.pendingBackgroundResponseTerminals.set(key, pending);
+    }
+  }
+  async retryBackgroundResponseResolution(key, sessionId, pending) {
+    let delivery;
+    try {
+      delivery = await this.options.resolveDelivery(sessionId);
+    } catch (error) {
+      if (this.pendingBackgroundResponseTerminals.get(key) === pending && !this.backgroundResponseAggregations.has(key) || this.detachedPendingBackgroundResponseTerminals.has(pending)) {
+        this.scheduleBackgroundResponseResolutionRetry(key, sessionId, pending);
+      }
+      throw error;
+    }
+    if (!delivery || this.options.getTarget(sessionId) !== delivery.target) {
+      if (pending.retiring) {
+        if (pending.held.length > 0) {
+          this.options.log(`background response target unavailable during drain; ${pending.held.length} buffered segment(s) discarded
+`);
+        }
+        pending.held.length = 0;
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+        return;
+      }
+      if (this.pendingBackgroundResponseTerminals.get(key) === pending && !this.backgroundResponseAggregations.has(key) || this.detachedPendingBackgroundResponseTerminals.has(pending)) {
+        this.scheduleBackgroundResponseResolutionRetry(key, sessionId, pending);
+      }
+      return;
+    }
+    if (pending.retiring || this.pendingBackgroundResponseTerminals.get(key) !== pending || pending.turnComplete) {
+      await this.flushDetachedBackgroundResponse(key, sessionId, pending, delivery);
+      return;
+    }
+    const first = pending.held[0];
+    if (!first)
+      return;
+    const aggregation = this.createBackgroundResponseAggregation(key, sessionId, first.context, delivery.target, delivery.sourceLabel);
+    this.applyHeldBackgroundResponses(aggregation, pending);
+    if (pending.resolutionDropped) {
+      aggregation.resolutionDropped = true;
+      pending.resolutionDropped = void 0;
+    }
+    if (this.pendingBackgroundResponseTerminals.get(key) === pending) {
+      this.pendingBackgroundResponseTerminals.delete(key);
+    }
+    this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+  }
+  holdPendingBackgroundResponse(pending, text, context) {
+    if (text.trim().length > 0)
+      pending.held.push({ text, context });
+    if (context.turnComplete) {
+      pending.turnComplete = true;
+      pending.status = context.status;
+      pending.label = context.label ?? pending.label;
+      pending.completionPartial = context.partial === true;
+    }
+  }
+  applyHeldBackgroundResponses(aggregation, pending) {
+    for (const { text, context } of pending.held.splice(0)) {
+      aggregation.status = context.status;
+      aggregation.label = context.label ?? aggregation.label;
+      if (text.trim())
+        aggregation.text = text;
+      if (context.turnComplete) {
+        aggregation.turnComplete = true;
+        aggregation.completionPartial = context.partial === true;
+      }
+    }
+  }
+  applyPendingBackgroundResponseTerminal(aggregation, pending) {
+    if (!pending.turnComplete)
+      return;
+    aggregation.turnComplete = true;
+    aggregation.status = pending.status ?? aggregation.status;
+    aggregation.label = pending.label ?? aggregation.label;
+    aggregation.completionPartial = pending.completionPartial === true;
+    pending.turnComplete = void 0;
+    pending.status = void 0;
+    pending.label = void 0;
+    pending.completionPartial = void 0;
+  }
+  async completeBackgroundResponseAggregation(key, aggregation) {
+    if (aggregation.delivery) {
+      aggregation.delivery.status = aggregation.status;
+      aggregation.delivery.label = aggregation.label ?? aggregation.delivery.label;
+      aggregation.delivery.partial = this.isPartialBackgroundResponseDelivery(aggregation, aggregation.delivery.text.length > 0) || aggregation.text.length > 0;
+    }
+    if (aggregation.timeoutTimer)
+      clearTimeout(aggregation.timeoutTimer);
+    aggregation.timeoutTimer = void 0;
+    await this.flushBackgroundResponseAggregation(key, aggregation);
+  }
+  async flushDetachedBackgroundResponse(key, sessionId, pending, delivery) {
+    const first = pending.held[0];
+    if (!first) {
+      this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      return;
+    }
+    const aggregation = {
+      key,
+      sessionId,
+      target: delivery.target,
+      sourceLabel: delivery.sourceLabel,
+      status: first.context.status,
+      kind: first.context.kind,
+      label: first.context.label,
+      text: "",
+      turnComplete: pending.turnComplete,
+      completionPartial: pending.completionPartial,
+      resolutionDropped: pending.resolutionDropped
+    };
+    this.applyHeldBackgroundResponses(aggregation, pending);
+    aggregation.status = pending.status ?? aggregation.status;
+    aggregation.label = pending.label ?? aggregation.label;
+    if (this.pendingBackgroundResponseTerminals.get(key) === pending) {
+      this.pendingBackgroundResponseTerminals.delete(key);
+    }
+    this.detachedPendingBackgroundResponseTerminals.delete(pending);
+    this.detachedBackgroundResponseAggregations.add(aggregation);
+    await this.flushBackgroundResponseAggregation(key, aggregation);
+  }
+  scheduleBackgroundResponseAggregationFlush(key, aggregation) {
+    if (aggregation.timeoutTimer || aggregation.delivery)
+      return;
+    aggregation.timeoutTimer = setTimeout(() => {
+      aggregation.timeoutTimer = void 0;
+      void this.flushBackgroundResponseAggregation(key, aggregation);
+    }, BACKGROUND_OUTPUT_TIMEOUT_MS);
+    aggregation.timeoutTimer.unref?.();
+  }
+};
+
 export {
   resolvePath,
   getGlobalQwenDir,
@@ -9824,16 +10551,24 @@ export {
   sanitizeDisplayText,
   sanitizeLogText,
   SessionRouter,
+  CHANNEL_PROMPT_META_KEY,
+  CHANNEL_OUTPUT_MODE_META_KEY,
+  CHANNEL_TASK_RESULT_META_KEY,
+  CHANNEL_TASK_RESULT_PARTIAL_META_KEY,
+  CHANNEL_TASK_OUTPUT_META_KEY,
   ChannelLoopScheduler,
   ChannelBase,
   PollingChannelBase,
-  CHANNEL_PROMPT_META_KEY,
   CHANNEL_LOOP_MCP_SERVER_NAME,
   ACP_EVENT_LOOP_STALL_RESTART_MS,
   AcpBridge,
   DaemonChannelBridge,
   ChannelLoopStore,
-  isTerminalTaskLifecycleType
+  isTerminalTaskLifecycleType,
+  CHANNEL_OUTPUT_MODE_FIELD,
+  parseChannelOutputMode,
+  ChannelOutputTurn,
+  BackgroundOutputCoordinator
 };
 /**
  * @license