@qwen-code/qwen-code 0.19.4 → 0.19.5-nightly.20260703.b16baf1ff

package/chunks/{chunk-HI55Z6PR.js → chunk-7DMQRPC7.js}

@@ -14,7 +14,7 @@ import {
 
 // packages/channels/base/dist/sanitize.js
 init_esbuild_shims();
-var PROMPT_UNSAFE_INVISIBLES = /[\u0080-\u009f\u200b-\u200d\u2028\u2029\u202a-\u202e\u2060\u2066-\u2069\ufeff]/g;
+var PROMPT_UNSAFE_INVISIBLES = new RegExp("[\\u0080-\\u009f\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
 function truncateCodePoints(str, max) {
   const cp = Array.from(str);
   return cp.length > max ? cp.slice(0, max).join("") : str;
@@ -340,10 +340,6 @@ function summarizeProtocolDetails(details) {
   return summary;
 }
 __name(summarizeProtocolDetails, "summarizeProtocolDetails");
-async function drainDaemonEventLoop() {
-  await new Promise((resolve2) => setTimeout(resolve2, 0));
-}
-__name(drainDaemonEventLoop, "drainDaemonEventLoop");
 var DaemonChannelBridge = class extends EventEmitter2 {
   static {
     __name(this, "DaemonChannelBridge");
@@ -356,6 +352,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   activePrompts = /* @__PURE__ */ new Set();
   activePromptControllers = /* @__PURE__ */ new Map();
   availableCommandsBySession = /* @__PURE__ */ new Map();
+  turnBarriers = /* @__PURE__ */ new Map();
   connected = false;
   latestAvailableCommandsSessionId;
   lastError;
@@ -378,6 +375,17 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   getAvailableCommands(sessionId) {
     return this.availableCommandsBySession.get(sessionId) ?? [];
   }
+  listSessions() {
+    const result = [];
+    for (const session of this.sessions.values()) {
+      result.push({
+        sessionId: session.sessionId,
+        workspaceCwd: session.workspaceCwd,
+        hasActivePrompt: this.activePrompts.has(session.sessionId)
+      });
+    }
+    return result;
+  }
   async start() {
     this.connected = true;
   }
@@ -429,6 +437,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     }, "onSessionDied");
     this.on("textChunk", onChunk);
     this.on("sessionDied", onSessionDied);
+    const turnBarrier = this.createTurnBarrier(sessionId);
     const prompt = [];
     if (options?.imageBase64 && options.imageMimeType) {
       prompt.push({
@@ -440,7 +449,10 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     prompt.push({ type: "text", text });
     try {
       const result = await session.prompt({ prompt }, controller.signal);
-      await drainDaemonEventLoop();
+      await Promise.race([
+        turnBarrier,
+        new Promise((resolve2) => setTimeout(resolve2, 0))
+      ]);
       const textResult = chunks.join("");
       this.emit("promptComplete", {
         sessionId,
@@ -449,6 +461,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       });
       return textResult;
     } finally {
+      this.clearTurnBarrier(sessionId);
       this.off("textChunk", onChunk);
       this.off("sessionDied", onSessionDied);
       this.activePrompts.delete(sessionId);
@@ -467,9 +480,10 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   }
   async cancelSession(sessionId) {
     const session = this.ensureSession(sessionId);
-    await session.cancel();
+    this.resolveTurnBarrier(sessionId);
     this.abortActivePrompts(sessionId);
     this.activePrompts.delete(sessionId);
+    await session.cancel();
   }
   async setSessionModel(sessionId, modelId) {
     return await this.ensureSession(sessionId).setModel(modelId);
@@ -583,6 +597,13 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       case "stream_error":
         this.dropSession(session.sessionId, this.getStringField(event.data, "error", "stream_error"));
         break;
+      case "turn_complete":
+        this.resolveTurnBarrier(session.sessionId);
+        break;
+      case "turn_error":
+        this.emitProtocolError(`Daemon turn error for session ${session.sessionId}`, event.data);
+        this.resolveTurnBarrier(session.sessionId);
+        break;
       default:
         break;
     }
@@ -728,6 +749,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     if (!this.sessions.has(sessionId)) {
       return;
     }
+    this.resolveTurnBarrier(sessionId);
     this.eventControllers.get(sessionId)?.abort();
     this.eventControllers.delete(sessionId);
     this.sessions.delete(sessionId);
@@ -762,6 +784,21 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     }
     this.activePromptControllers.delete(sessionId);
   }
+  createTurnBarrier(sessionId) {
+    return new Promise((resolve2) => {
+      this.turnBarriers.set(sessionId, resolve2);
+    });
+  }
+  resolveTurnBarrier(sessionId) {
+    const resolve2 = this.turnBarriers.get(sessionId);
+    if (resolve2) {
+      this.turnBarriers.delete(sessionId);
+      resolve2();
+    }
+  }
+  clearTurnBarrier(sessionId) {
+    this.turnBarriers.delete(sessionId);
+  }
   emitProtocolError(message, details) {
     const error = new Error(message);
     error.details = summarizeProtocolDetails(details);
@@ -1664,6 +1701,11 @@ var ChannelLoopSkippedError = class extends Error {
   static {
     __name(this, "ChannelLoopSkippedError");
   }
+  reason;
+  constructor(message, reason = "dropped") {
+    super(message);
+    this.reason = reason;
+  }
 };
 var ChannelLoopScheduler = class {
   static {
@@ -1941,6 +1983,7 @@ var CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
 var GROUP_HISTORY_ENTRY_TEXT_LIMIT = 1e3;
 var GROUP_HISTORY_ENTRY_METADATA_LIMIT = 256;
 var LOOP_CANCEL_GRACE_MS = 5e3;
+var LOOP_TIMED_OUT_MESSAGE = "loop timed out";
 var COMMAND_TOKEN_CHARS = "a-zA-Z0-9_:-";
 var PARSE_COMMAND_RE = new RegExp(`^\\/([${COMMAND_TOKEN_CHARS}]+)(?:@\\S+)?\\s*(.*)`, "s");
 var COMMAND_TOKEN_RE = new RegExp(`^[${COMMAND_TOKEN_CHARS}]+(?:@\\S+)?$`);
@@ -1966,6 +2009,9 @@ var ChannelBase = class {
   gate;
   router;
   name;
+  /** Resolved (defaulted + frozen) identity/scope — adapters should read these, not raw config. */
+  identity;
+  memoryScope;
   /** Resolved proxy URL, available to subclasses for adapter-specific clients. */
   proxy;
   channelMemory;
@@ -1987,19 +2033,41 @@ var ChannelBase = class {
   /** Per-session message buffer for collect mode. */
   collectBuffers = /* @__PURE__ */ new Map();
   bridgeToolCallListener = /* @__PURE__ */ __name((event) => {
-    const target = this.router.getTarget(event.sessionId);
-    if (target) {
-      this.onToolCall(target.chatId, event);
-    }
+    this.dispatchToolCall(event);
   }, "bridgeToolCallListener");
   bridgeSessionDiedListener = /* @__PURE__ */ __name((event) => {
     this.onSessionDied(event.sessionId);
   }, "bridgeSessionDiedListener");
+  dispatchToolCall(event) {
+    const target = this.router.getTarget(event.sessionId);
+    const active = this.activePrompts.get(event.sessionId);
+    const chatId = active?.chatId ?? target?.chatId;
+    if (!chatId) {
+      return;
+    }
+    if (active && !active.cancelled && !active.cancelPending) {
+      const safeToolCall = {
+        sessionId: event.sessionId,
+        toolCallId: event.toolCallId,
+        kind: sanitizeLogText(event.kind ?? "", 20),
+        title: sanitizeLogText(event.title ?? "", 80),
+        status: sanitizeLogText(event.status ?? "", 20)
+      };
+      this.emitTaskLifecycle({
+        ...this.lifecycleBase(chatId, event.sessionId, active.messageId),
+        type: "tool_call",
+        toolCall: safeToolCall
+      });
+    }
+    this.onToolCall(chatId, event);
+  }
   constructor(name, config, bridge, options) {
     this.name = name;
     this.config = config;
     this.bridge = bridge;
     this.proxy = options?.proxy;
+    this.identity = Object.freeze(this.resolveIdentity(name, config));
+    this.memoryScope = Object.freeze(this.resolveMemoryScope(name, config));
     this.channelMemory = options?.channelMemory;
     this.groupHistory = new GroupHistoryStore(options?.groupHistoryPath ?? join4(getGlobalQwenDir(), "channels", `${encodeURIComponent(name)}-group-history.jsonl`));
     this.loopController = options?.loopController;
@@ -2013,6 +2081,96 @@ var ChannelBase = class {
       this.attachBridgeEvents(bridge);
     }
   }
+  /**
+   * Adapter hook for task lifecycle events — the canonical way to track task
+   * state (onPromptStart/onPromptEnd are retained for back-compat). The prompt
+   * flow never awaits this hook; an async override's rejection is caught and
+   * logged, nothing more.
+   */
+  onTaskLifecycle(_event) {
+  }
+  emitTaskLifecycle(event) {
+    try {
+      const result = this.onTaskLifecycle(event);
+      if (result && typeof result.catch === "function") {
+        result.catch((err) => {
+          this.logTaskLifecycleError(event, err);
+        });
+      }
+    } catch (err) {
+      this.logTaskLifecycleError(event, err);
+    }
+  }
+  logTaskLifecycleError(event, err) {
+    const channel = sanitizeLogText(this.name, 64);
+    const sessionId = sanitizeLogText(event.sessionId, 64);
+    const stack = err instanceof Error && err.stack ? ` | ${sanitizeLogText(err.stack, 500)}` : "";
+    process.stderr.write(`[${channel}] onTaskLifecycle threw for ${event.type} session ${sessionId}: ${this.lifecycleError(err)}${stack}
+`);
+  }
+  lifecycleError(err) {
+    return sanitizeLogText(err instanceof Error ? err.message : String(err), 200);
+  }
+  emitTaskCancellation(active, sessionId, reason) {
+    if (active.cancellationEmitted) {
+      return;
+    }
+    active.cancellationEmitted = true;
+    this.emitTaskLifecycle({
+      ...this.lifecycleBase(active.chatId, sessionId, active.messageId),
+      type: "cancelled",
+      reason
+    });
+  }
+  resolveIdentity(name, config) {
+    return {
+      id: config.identity?.id || `channel:${name}`,
+      displayName: config.identity?.displayName || name,
+      ...config.identity?.description ? { description: config.identity.description } : {}
+    };
+  }
+  resolveMemoryScope(name, config) {
+    return {
+      namespace: config.memoryScope?.namespace || `channel:${name}`,
+      mode: config.memoryScope?.mode ?? "metadata-only"
+    };
+  }
+  /** Built once — identity/memoryScope are frozen at construction. */
+  boundaryPrompt;
+  channelBoundaryPrompt() {
+    if (this.boundaryPrompt !== void 0) {
+      return this.boundaryPrompt;
+    }
+    const identityLines = [
+      "Channel identity:",
+      `- id: ${sanitizeQuotedText(this.identity.id, 128)}`,
+      `- display name: ${sanitizeQuotedText(this.identity.displayName, 128)}`,
+      ...this.identity.description ? [
+        `- description: ${sanitizeQuotedText(this.identity.description, 256)}`
+      ] : []
+    ];
+    const memoryLines = [
+      "Memory scope:",
+      `- namespace: ${sanitizeQuotedText(this.memoryScope.namespace, 128)}`,
+      `- mode: ${this.memoryScope.mode}`,
+      "- data from other channels must not be shared."
+    ];
+    this.boundaryPrompt = [...identityLines, "", ...memoryLines].join("\n");
+    return this.boundaryPrompt;
+  }
+  shouldPrependChannelBoundaryPrompt() {
+    return Boolean(this.config.identity || this.config.memoryScope);
+  }
+  lifecycleBase(chatId, sessionId, messageId) {
+    return {
+      channelName: this.name,
+      chatId,
+      sessionId,
+      ...messageId ? { messageId } : {},
+      identity: this.identity,
+      memoryScope: this.memoryScope
+    };
+  }
   supportsProactiveSend() {
     return false;
   }
@@ -2057,7 +2215,7 @@ var ChannelBase = class {
     const sessionId = await this.router.resolve(this.name, job.target.senderId, job.target.chatId, job.target.threadId, job.cwd);
     const label = sanitizeQuotedText(job.label || job.id, 80);
     const createdBy = sanitizeSenderName(job.createdBy || "unknown");
-    let promptText = `[Loop "${label}" created by ${createdBy}]
+    let promptText = `[Loop "${label}" created by ${createdBy}] Scheduled task running unattended: no one is present to answer questions, and your final response is delivered to this chat automatically \u2014 do whatever work the task requires, then put the result in your final response instead of trying to deliver it to this chat yourself.
 
 ${sanitizePromptText(job.prompt)}`;
     const shouldPrependSessionContext = !this.instructedSessions.has(sessionId);
@@ -2097,6 +2255,9 @@ ${sanitizePromptText(memoryText)}`);
         if (this.config.instructions) {
           context.push(this.config.instructions);
         }
+        if (this.shouldPrependChannelBoundaryPrompt()) {
+          context.push(this.channelBoundaryPrompt());
+        }
         if (context.length > 0) {
           promptText = `${context.join("\n\n")}
 
@@ -2124,35 +2285,96 @@ ${promptText}`;
         done,
         resolve: doneResolve,
         chatId: job.target.chatId,
-        messageId: job.id
+        messageId: job.id,
+        loopPrompt: true
       };
       this.activePrompts.set(sessionId, promptState);
-      this.onPromptStart(job.target.chatId, sessionId);
+      this.emitTaskLifecycle({
+        ...this.lifecycleBase(job.target.chatId, sessionId, job.id),
+        type: "started"
+      });
+      try {
+        this.onPromptStart(job.target.chatId, sessionId);
+      } catch (err) {
+        process.stderr.write(`[${this.name}] onPromptStart threw in loop ${job.id} for session ${sessionId}: ${this.lifecycleError(err)}
+`);
+      }
+      const heldChunks = [];
+      const releaseHeldChunks = /* @__PURE__ */ __name(() => {
+        for (const held of heldChunks.splice(0)) {
+          this.emitTaskLifecycle({
+            ...this.lifecycleBase(job.target.chatId, sessionId, job.id),
+            type: "text_chunk",
+            chunk: held
+          });
+          this.onResponseChunk(job.target.chatId, held, sessionId);
+        }
+      }, "releaseHeldChunks");
       const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
-        if (sid === sessionId && !promptState.cancelled) {
-          this.onResponseChunk(job.target.chatId, chunk, sessionId);
+        if (sid !== sessionId || promptState.cancelled) {
+          return;
+        }
+        heldChunks.push(chunk);
+        if (!promptState.cancelPending) {
+          releaseHeldChunks();
         }
       }, "onChunk");
       const promptBridge = this.bridge;
       promptBridge.on("textChunk", onChunk);
       try {
         const response = await this.runLoopBridgePrompt(promptBridge, sessionId, promptText, promptState, job.id, options.timeoutMs);
-        if (promptState.cancelRequested && !promptState.cancelled) {
-          const cancelled = await promptState.cancelRequested;
-          if (cancelled) {
-            promptState.cancelled = true;
-          }
-        }
+        await this.settleCancelRequested(promptState);
         if (promptState.cancelled) {
-          throw new ChannelLoopSkippedError("loop cancelled before delivery");
+          throw new ChannelLoopSkippedError("loop cancelled before delivery", "cancel_command");
         }
+        releaseHeldChunks();
         if (options.shouldContinue && !await options.shouldContinue()) {
           throw new ChannelLoopSkippedError("loop dropped before delivery");
         }
+        if (promptState.cancelled) {
+          throw new ChannelLoopSkippedError("loop cancelled before delivery", "cancel_command");
+        }
         if (response) {
+          promptState.deliveryStarted = true;
           await this.pushProactive(job.target, response);
         }
+        if (!promptState.deliveryStarted) {
+          await this.settleCancelRequested(promptState);
+          if (promptState.cancelled) {
+            throw new ChannelLoopSkippedError("loop cancelled before delivery", "cancel_command");
+          }
+        }
+        if (!promptState.cancellationEmitted) {
+          this.emitTaskLifecycle({
+            ...this.lifecycleBase(job.target.chatId, sessionId, job.id),
+            type: "completed"
+          });
+        }
         return response;
+      } catch (err) {
+        if (!promptState.deliveryStarted) {
+          await this.settleCancelRequested(promptState);
+        }
+        if (err instanceof ChannelLoopSkippedError && !promptState.cancelled) {
+          this.emitTaskCancellation(promptState, sessionId, err.reason);
+          promptState.cancelled = true;
+        }
+        if (!promptState.cancelled && !(err instanceof ChannelLoopSkippedError)) {
+          releaseHeldChunks();
+          this.emitTaskLifecycle({
+            ...this.lifecycleBase(job.target.chatId, sessionId, job.id),
+            type: "failed",
+            error: this.lifecycleError(err),
+            phase: promptState.deliveryStarted ? "delivery" : "agent"
+          });
+        } else if (promptState.cancelled && !(err instanceof ChannelLoopSkippedError) && !(err instanceof Error && err.message === LOOP_TIMED_OUT_MESSAGE)) {
+          const channel = sanitizeLogText(this.name, 64);
+          const safeJobId = sanitizeLogText(job.id, 64);
+          const safeSessionId = sanitizeLogText(sessionId, 64);
+          process.stderr.write(`[${channel}] loop ${safeJobId} threw after cancellation for session ${safeSessionId}: ${this.lifecycleError(err)}
+`);
+        }
+        throw err;
       } finally {
         promptBridge.off("textChunk", onChunk);
         const stillCurrent = this.activePrompts.get(sessionId) === promptState;
@@ -2207,15 +2429,16 @@ ${promptText}`;
         prompt,
         new Promise((_, reject) => {
           timer = setTimeout(() => {
-            reject(new Error("loop timed out"));
+            reject(new Error(LOOP_TIMED_OUT_MESSAGE));
           }, timeoutMs);
           timer.unref?.();
         })
       ]);
     } catch (err) {
-      if (err instanceof Error && err.message === "loop timed out") {
+      if (err instanceof Error && err.message === LOOP_TIMED_OUT_MESSAGE) {
         promptState.cancelled = true;
         await this.cancelTimedOutLoopPrompt(promptBridge, sessionId, jobId);
+        this.emitTaskCancellation(promptState, sessionId, "timeout");
       }
       throw err;
     } finally {
@@ -2245,6 +2468,62 @@ ${promptText}`;
       clearTimeout(graceTimer);
     }
   }
+  requestActivePromptCancellation(sessionId, reason = "cancel_command") {
+    const active = this.activePrompts.get(sessionId);
+    if (!active) {
+      return this.bridge.cancelSession(sessionId).then(() => true, (err) => {
+        this.logCancelSessionFailure(sessionId, err);
+        return false;
+      });
+    }
+    if (active.deliveryStarted) {
+      return Promise.resolve(false);
+    }
+    const cancelRequested = active.cancelRequested ?? this.bridge.cancelSession(sessionId).then(() => true, (err) => {
+      this.logCancelSessionFailure(sessionId, err);
+      active.cancelRequested = void 0;
+      return false;
+    });
+    active.cancelRequested = cancelRequested;
+    active.cancelPending = true;
+    return cancelRequested.finally(() => {
+      active.cancelPending = false;
+    }).then((cancelSucceeded) => {
+      const turnEnded = this.activePrompts.get(sessionId) !== active;
+      if (!cancelSucceeded || active.deliveryStarted || turnEnded && !active.cancelled) {
+        return false;
+      }
+      active.cancelled = true;
+      this.stopActiveStreaming(active, sessionId, reason);
+      this.collectBuffers.delete(sessionId);
+      this.emitTaskCancellation(active, sessionId, reason);
+      return true;
+    });
+  }
+  logCancelSessionFailure(sessionId, err) {
+    process.stderr.write(`[${sanitizeLogText(this.name, 64)}] cancelSession failed for session=${sanitizeLogText(sessionId, 64)}: ${this.lifecycleError(err)}
+`);
+  }
+  async settleCancelRequested(active) {
+    if (!active.cancelRequested || active.cancelled) {
+      return;
+    }
+    let timer;
+    try {
+      const cancelled = await Promise.race([
+        active.cancelRequested,
+        new Promise((resolve2) => {
+          timer = setTimeout(() => resolve2(false), CLEAR_CANCEL_TIMEOUT_MS);
+          timer.unref?.();
+        })
+      ]);
+      if (cancelled) {
+        active.cancelled = true;
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
   onToolCall(_chatId, _event) {
   }
   onSessionDied(sessionId) {
@@ -2311,22 +2590,8 @@ ${promptText}`;
         await this.sendMessage(envelope.chatId, "No request is currently running.");
         return true;
       }
-      const cancelRequested = active.cancelRequested ?? this.bridge.cancelSession(activeSessionId).then(() => true, (err) => {
-        process.stderr.write(`[${this.name}] cancelSession failed for session=${activeSessionId}: ${err instanceof Error ? err.message : err}
-`);
-        active.cancelRequested = void 0;
-        return false;
-      });
-      active.cancelRequested = cancelRequested;
-      const cancelSucceeded = await cancelRequested;
-      if (!cancelSucceeded) {
-        await this.sendMessage(envelope.chatId, "Failed to cancel current request.");
-        return true;
-      }
-      active.cancelled = true;
-      active.stopStreaming?.();
-      this.collectBuffers.delete(activeSessionId);
-      await this.sendMessage(envelope.chatId, "Cancelled current request.");
+      const cancelSucceeded = await this.requestActivePromptCancellation(activeSessionId, "cancel_command");
+      await this.sendMessage(envelope.chatId, cancelSucceeded ? "Cancelled current request." : "Failed to cancel current request.");
       return true;
     });
   }
@@ -2354,7 +2619,7 @@ ${promptText}`;
 `);
               active.clearEvicted = true;
               try {
-                this.onPromptEnd(active.chatId, id, active.messageId);
+                this.onPromptEnd(active.chatId, id, active.loopPrompt ? void 0 : active.messageId);
               } catch (err) {
                 process.stderr.write(`[${this.name}] onPromptEnd threw during /clear eviction for session ${id}: ${err instanceof Error ? err.message : err}
 `);
@@ -2405,6 +2670,12 @@ ${promptText}`;
       const scopeNote = this.config.sessionScope === "single" ? " (shared channel-wide)" : this.isSharedSession(envelope) ? envelope.isGroup ? " (shared by this group)" : "" : envelope.isGroup ? " (private to you)" : "";
       await this.sendMessage(envelope.chatId, [
         `Channel: ${this.name}`,
+        // Identity/memory lines only for channels that opted in — keep
+        // unconfigured channels' output unchanged.
+        ...this.shouldPrependChannelBoundaryPrompt() ? [
+          `Identity: ${sanitizeQuotedText(this.identity.displayName, 128)}`,
+          `Memory: ${sanitizeQuotedText(this.memoryScope.namespace, 128)}`
+        ] : [],
         // Only the basename — don't leak the absolute cwd to group members.
         `Workspace: ${basename(this.config.cwd)}`,
         `Session: ${active ? "active" : "none"}${scopeNote}`
@@ -2542,7 +2813,11 @@ ${promptText}`;
       const lines = [
         `Session: ${hasSession ? "active" : "none"}`,
         `Access: ${policy}`,
-        `Channel: ${this.name}`
+        `Channel: ${this.name}`,
+        ...this.shouldPrependChannelBoundaryPrompt() ? [
+          `Identity: ${sanitizeQuotedText(this.identity.id, 128)}`,
+          `Memory: ${this.memoryScope.mode}`
+        ] : []
       ];
       await this.sendMessage(envelope.chatId, lines.join("\n"));
       return true;
@@ -2855,6 +3130,7 @@ ${promptText}`;
       process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (clear/await): ${err instanceof Error ? err.message : err}
 `);
     });
+    this.emitTaskCancellation(active, sessionId, "clear");
     let timer;
     const settled = await Promise.race([
       active.done.then(() => true),
@@ -3149,14 +3425,18 @@ ${promptText}`;
 `);
             break;
           }
+          const firstCancellation = !active.cancelled;
           active.cancelled = true;
-          process.stderr.write(`[${this.name}] steer: cancelled active turn for ${envelope.senderId} in session ${sessionId}
+          if (firstCancellation) {
+            process.stderr.write(`[${this.name}] steer: cancelled active turn for ${envelope.senderId} in session ${sessionId}
 `);
-          this.stopActiveStreaming(active, sessionId, "steer");
-          void this.bridge.cancelSession(sessionId).catch((err) => {
-            process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (steer): ${err instanceof Error ? err.message : err}
+            this.stopActiveStreaming(active, sessionId, "steer");
+            void this.bridge.cancelSession(sessionId).catch((err) => {
+              process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (steer): ${err instanceof Error ? err.message : err}
 `);
-          });
+            });
+            this.emitTaskCancellation(active, sessionId, "steer");
+          }
           steerWatchdog = setTimeout(() => {
             if (this.activePrompts.get(sessionId) === active) {
               process.stderr.write(`[${this.name}] steer queued behind active turn for session ${sessionId}: still waiting after ${CLEAR_CANCEL_TIMEOUT_MS}ms (use /clear to recover)
@@ -3212,6 +3492,9 @@ ${sanitizePromptText(memoryText)}`);
         if (this.config.instructions) {
           sessionContext.push(this.config.instructions);
         }
+        if (this.shouldPrependChannelBoundaryPrompt()) {
+          sessionContext.push(this.channelBoundaryPrompt());
+        }
       }
       if (this.dropQueuedTurnIfStale(sessionId, generation, envelope)) {
         return;
@@ -3236,7 +3519,16 @@ ${promptToSend}`;
         messageId: envelope.messageId
       };
       this.activePrompts.set(sessionId, promptState);
-      this.onPromptStart(envelope.chatId, sessionId, envelope.messageId);
+      this.emitTaskLifecycle({
+        ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
+        type: "started"
+      });
+      try {
+        this.onPromptStart(envelope.chatId, sessionId, envelope.messageId);
+      } catch (err) {
+        process.stderr.write(`[${this.name}] onPromptStart threw for session ${sessionId}: ${this.lifecycleError(err)}
+`);
+      }
       const streamer = useBlockStreaming ? new BlockStreamer({
         minChars: this.config.blockStreamingChunk?.minChars ?? 400,
         maxChars: this.config.blockStreamingChunk?.maxChars ?? 1e3,
@@ -3244,10 +3536,25 @@ ${promptToSend}`;
         send: /* @__PURE__ */ __name((text) => this.sendMessage(envelope.chatId, text), "send")
       }) : null;
       promptState.stopStreaming = () => streamer?.stop();
+      const heldChunks = [];
+      const releaseHeldChunks = /* @__PURE__ */ __name(() => {
+        for (const held of heldChunks.splice(0)) {
+          this.emitTaskLifecycle({
+            ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
+            type: "text_chunk",
+            chunk: held
+          });
+          this.onResponseChunk(envelope.chatId, held, sessionId);
+          streamer?.push(held);
+        }
+      }, "releaseHeldChunks");
       const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
-        if (sid === sessionId && !promptState.cancelled) {
-          this.onResponseChunk(envelope.chatId, chunk, sessionId);
-          streamer?.push(chunk);
+        if (sid !== sessionId || promptState.cancelled) {
+          return;
+        }
+        heldChunks.push(chunk);
+        if (!promptState.cancelPending) {
+          releaseHeldChunks();
         }
       }, "onChunk");
       const promptBridge = this.bridge;
@@ -3257,19 +3564,47 @@ ${promptToSend}`;
           imageBase64,
           imageMimeType
         });
-        if (promptState.cancelRequested && !promptState.cancelled) {
-          const cancelled = await promptState.cancelRequested;
-          if (cancelled) {
-            promptState.cancelled = true;
-          }
+        await this.settleCancelRequested(promptState);
+        if (!promptState.cancelled) {
+          releaseHeldChunks();
         }
         if (!promptState.cancelled && response) {
+          promptState.deliveryStarted = true;
           if (streamer) {
             await streamer.flush();
           } else {
             await this.onResponseComplete(envelope.chatId, response, sessionId);
           }
         }
+        if (!promptState.deliveryStarted) {
+          await this.settleCancelRequested(promptState);
+        }
+        if (!promptState.cancelled && !promptState.cancellationEmitted) {
+          this.emitTaskLifecycle({
+            ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
+            type: "completed"
+          });
+        }
+      } catch (err) {
+        if (!promptState.deliveryStarted) {
+          await this.settleCancelRequested(promptState);
+        }
+        if (!promptState.cancelled) {
+          releaseHeldChunks();
+          this.emitTaskLifecycle({
+            ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
+            type: "failed",
+            error: this.lifecycleError(err),
+            phase: promptState.deliveryStarted ? "delivery" : "agent"
+          });
+        } else {
+          const channel = sanitizeLogText(this.name, 64);
+          const safeSessionId = sanitizeLogText(sessionId, 64);
+          const safeMessageId = sanitizeLogText(envelope.messageId ?? "", 64);
+          process.stderr.write(`[${channel}] turn ${safeMessageId} threw after cancellation for session ${safeSessionId}: ${this.lifecycleError(err)}
+`);
+        }
+        throw err;
       } finally {
         promptBridge.off("textChunk", onChunk);
         streamer?.stop();
@@ -3507,6 +3842,13 @@ function normalizeJob(job) {
 }
 __name(normalizeJob, "normalizeJob");
 
+// packages/channels/base/dist/types.js
+init_esbuild_shims();
+function isTerminalTaskLifecycleType(type) {
+  return type === "completed" || type === "cancelled" || type === "failed";
+}
+__name(isTerminalTaskLifecycleType, "isTerminalTaskLifecycleType");
+
 export {
   resolvePath,
   getGlobalQwenDir,
@@ -3519,5 +3861,6 @@ export {
   SessionRouter,
   ChannelLoopScheduler,
   ChannelBase,
-  ChannelLoopStore
+  ChannelLoopStore,
+  isTerminalTaskLifecycleType
 };