@qwen-code/channel-base 0.19.4 → 0.19.5

package/dist/ChannelBase.js

@@ -22,6 +22,8 @@ const CURRENT_MESSAGE_MARKER = '[Current message - respond to this]';
 const GROUP_HISTORY_ENTRY_TEXT_LIMIT = 1000;
 const GROUP_HISTORY_ENTRY_METADATA_LIMIT = 256;
 const LOOP_CANCEL_GRACE_MS = 5000;
+/** Sentinel message for the loop-prompt timeout rejection; matched by identity below. */
+const LOOP_TIMED_OUT_MESSAGE = 'loop timed out';
 /**
  * Character class (sans the enclosing `[]`) for a slash-command token: alphanumerics
  * plus `_`, `:` and `-`, so hyphenated and namespaced agent commands (e.g.
@@ -51,6 +53,9 @@ export class ChannelBase {
     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;
@@ -72,19 +77,43 @@ export class ChannelBase {
     /** Per-session message buffer for collect mode. */
     collectBuffers = new Map();
     bridgeToolCallListener = (event) => {
-        const target = this.router.getTarget(event.sessionId);
-        if (target) {
-            this.onToolCall(target.chatId, event);
-        }
+        this.dispatchToolCall(event);
     };
     bridgeSessionDiedListener = (event) => {
         this.onSessionDied(event.sessionId);
     };
+    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) {
+            // `?? ''`: dispatchToolCall is a public entry point — a third-party bridge
+            // omitting a field must not throw out of its emit('toolCall').
+            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 ??
             join(getGlobalQwenDir(), 'channels', `${encodeURIComponent(name)}-group-history.jsonl`));
@@ -104,6 +133,101 @@ export class ChannelBase {
             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}\n`);
+    }
+    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 !== undefined) {
+            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;
     }
@@ -148,7 +272,9 @@ export class ChannelBase {
         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}]\n\n${sanitizePromptText(job.prompt)}`;
+        // Without the delivery-contract sentence the model treats "post X" prompts
+        // as an action it must perform itself and goes hunting for send credentials.
+        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 — do whatever work the task requires, then put the result in your final response instead of trying to deliver it to this chat yourself.\n\n${sanitizePromptText(job.prompt)}`;
         const shouldPrependSessionContext = !this.instructedSessions.has(sessionId);
         const prev = this.sessionQueues.get(sessionId) ?? Promise.resolve();
         const generation = this.sessionGenerations.get(sessionId) ?? 0;
@@ -187,6 +313,11 @@ export class ChannelBase {
                 if (this.config.instructions) {
                     context.push(this.config.instructions);
                 }
+                // Boundary block goes last: recency bias means later instructions win,
+                // and the isolation boundary must not be overridable by operator text.
+                if (this.shouldPrependChannelBoundaryPrompt()) {
+                    context.push(this.channelBoundaryPrompt());
+                }
                 if (context.length > 0) {
                     promptText = `${context.join('\n\n')}\n\n${promptText}`;
                 }
@@ -211,35 +342,116 @@ export class ChannelBase {
                 resolve: doneResolve,
                 chatId: job.target.chatId,
                 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',
+            });
+            // Guarded: an adapter indicator failure must not orphan the started
+            // event (no terminal) or leak the activePrompts entry.
+            // No messageId: the hook contract passes INBOUND platform message ids,
+            // and adapters act on them (cards, reactions) — a loop job id would
+            // collide. Lifecycle events still carry job.id for correlation.
+            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)}\n`);
+            }
+            // Same hold-and-replay contract as handleInbound's onChunk: visible
+            // sinks stay out of the transcript while a cancel is pending.
+            const heldChunks = [];
+            const releaseHeldChunks = () => {
+                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);
+                }
+            };
             const onChunk = (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();
                 }
             };
             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);
                 }
+                // Once delivery started the run counts as completed — a cancel settling
+                // during/after the send must not convert a delivered run into a skip
+                // (a one-shot loop would stay enabled and deliver twice).
+                if (!promptState.deliveryStarted) {
+                    await this.settleCancelRequested(promptState);
+                    if (promptState.cancelled) {
+                        throw new ChannelLoopSkippedError('loop cancelled before delivery', 'cancel_command');
+                    }
+                }
+                // /clear can evict mid-delivery and emit its own terminal event; never
+                // follow a cancelled event with completed for the same prompt.
+                if (!promptState.cancellationEmitted) {
+                    this.emitTaskLifecycle({
+                        ...this.lifecycleBase(job.target.chatId, sessionId, job.id),
+                        type: 'completed',
+                    });
+                }
                 return response;
             }
+            catch (err) {
+                // Once delivery started, a late-settling cancel must not flip
+                // `cancelled` here — it would suppress the failed emit while the
+                // /cancel handler (seeing deliveryStarted) declines to emit its own
+                // terminal, leaving the task with no terminal event at all.
+                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)}\n`);
+                }
+                throw err;
+            }
             finally {
                 promptBridge.off('textChunk', onChunk);
                 const stillCurrent = this.activePrompts.get(sessionId) === promptState;
@@ -291,16 +503,17 @@ export class ChannelBase {
                 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;
         }
@@ -331,6 +544,72 @@ export class ChannelBase {
             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 = undefined;
+                return false;
+            });
+        active.cancelRequested = cancelRequested;
+        active.cancelPending = true;
+        return cancelRequested
+            .finally(() => {
+            active.cancelPending = false;
+        })
+            .then((cancelSucceeded) => {
+            // Re-check after the await: while the cancel RPC was in flight the
+            // turn may have started delivery, or ended on its own (uncancelled) —
+            // claiming success then would emit a spurious cancelled event for a
+            // response the user received. A turn that ended already-cancelled
+            // (the abort landed) still counts as a successful cancel.
+            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)}\n`);
+    }
+    async settleCancelRequested(active) {
+        if (!active.cancelRequested || active.cancelled) {
+            return;
+        }
+        let timer;
+        try {
+            const cancelled = await Promise.race([
+                active.cancelRequested,
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve(false), CLEAR_CANCEL_TIMEOUT_MS);
+                    timer.unref?.();
+                }),
+            ]);
+            if (cancelled) {
+                active.cancelled = true;
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
     onToolCall(_chatId, _event) { }
     onSessionDied(sessionId) {
         this.router.removeSessionId(sessionId);
@@ -397,22 +676,12 @@ export class ChannelBase {
                 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}\n`);
-                    active.cancelRequested = undefined;
-                    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.');
+            // Single cancel state machine: adapter stop buttons and /cancel share
+            // requestActivePromptCancellation so the two paths cannot drift.
+            const cancelSucceeded = await this.requestActivePromptCancellation(activeSessionId, 'cancel_command');
+            await this.sendMessage(envelope.chatId, cancelSucceeded
+                ? 'Cancelled current request.'
+                : 'Failed to cancel current request.');
             return true;
         });
     }
@@ -471,7 +740,7 @@ export class ChannelBase {
                             // onPromptEnd anyway. Letting the purge proceed makes the turn
                             // non-current, so the clearEvicted guard then skips correctly.
                             try {
-                                this.onPromptEnd(active.chatId, id, active.messageId);
+                                this.onPromptEnd(active.chatId, id, active.loopPrompt ? undefined : active.messageId);
                             }
                             catch (err) {
                                 process.stderr.write(`[${this.name}] onPromptEnd threw during /clear eviction for session ${id}: ${err instanceof Error ? err.message : err}\n`);
@@ -557,6 +826,14 @@ export class ChannelBase {
                         : '';
             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}`,
@@ -705,6 +982,12 @@ export class ChannelBase {
                 `Session: ${hasSession ? 'active' : 'none'}`,
                 `Access: ${policy}`,
                 `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;
@@ -1036,6 +1319,7 @@ export class ChannelBase {
         void this.bridge.cancelSession(sessionId).catch((err) => {
             process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (clear/await): ${err instanceof Error ? err.message : err}\n`);
         });
+        this.emitTaskCancellation(active, sessionId, 'clear');
         let timer;
         const settled = await Promise.race([
             active.done.then(() => true),
@@ -1469,14 +1753,21 @@ export class ChannelBase {
                     // turn that runs without waiting for a wedged predecessor) is the
                     // deferred fix — it needs an API change across every adapter and is out
                     // of scope for this phase (wenshao option (b)).
+                    const firstCancellation = !active.cancelled;
                     active.cancelled = true;
-                    process.stderr.write(`[${this.name}] steer: cancelled active turn for ${envelope.senderId} in session ${sessionId}\n`);
-                    this.stopActiveStreaming(active, sessionId, 'steer');
-                    // Fire-and-forget, but LOG the IPC failure rather than swallow it, so a
-                    // best-effort cancel that fails isn't silently invisible to operators.
-                    void this.bridge.cancelSession(sessionId).catch((err) => {
-                        process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (steer): ${err instanceof Error ? err.message : err}\n`);
-                    });
+                    if (firstCancellation) {
+                        process.stderr.write(`[${this.name}] steer: cancelled active turn for ${envelope.senderId} in session ${sessionId}\n`);
+                        this.stopActiveStreaming(active, sessionId, 'steer');
+                        // Fire-and-forget, but LOG the IPC failure rather than swallow it, so a
+                        // best-effort cancel that fails isn't silently invisible to operators.
+                        void this.bridge.cancelSession(sessionId).catch((err) => {
+                            process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (steer): ${err instanceof Error ? err.message : err}\n`);
+                        });
+                        // Emitted before the bridge cancel settles: steer supersedes the
+                        // turn at the channel level (cancelled is already set above), so
+                        // the event reflects that intent, not the bridge RPC outcome.
+                        this.emitTaskCancellation(active, sessionId, 'steer');
+                    }
                     // Diagnostic watchdog: if the predecessor turn is STILL the active prompt
                     // after the wind-down bound, this steered turn is wedged behind a hung
                     // bridge.prompt() — surface it (the chained `.then()` clears it once the
@@ -1557,6 +1848,11 @@ export class ChannelBase {
                 if (this.config.instructions) {
                     sessionContext.push(this.config.instructions);
                 }
+                // Boundary block goes last: recency bias means later instructions win,
+                // and the isolation boundary must not be overridable by operator text.
+                if (this.shouldPrependChannelBoundaryPrompt()) {
+                    sessionContext.push(this.channelBoundaryPrompt());
+                }
             }
             if (this.dropQueuedTurnIfStale(sessionId, generation, envelope)) {
                 return;
@@ -1584,7 +1880,18 @@ export class ChannelBase {
             // (Steer no longer hands a still-active session to a replacement; only
             // /clear evicts, and it gives the next turn a fresh session.)
             this.activePrompts.set(sessionId, promptState);
-            this.onPromptStart(envelope.chatId, sessionId, envelope.messageId);
+            this.emitTaskLifecycle({
+                ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
+                type: 'started',
+            });
+            // Guarded: an adapter indicator failure must not orphan the started
+            // event (no terminal) or leak the activePrompts entry.
+            try {
+                this.onPromptStart(envelope.chatId, sessionId, envelope.messageId);
+            }
+            catch (err) {
+                process.stderr.write(`[${this.name}] onPromptStart threw for session ${sessionId}: ${this.lifecycleError(err)}\n`);
+            }
             const streamer = useBlockStreaming
                 ? new BlockStreamer({
                     minChars: this.config.blockStreamingChunk?.minChars ?? 400,
@@ -1594,10 +1901,28 @@ export class ChannelBase {
                 })
                 : null;
             promptState.stopStreaming = () => streamer?.stop();
+            // Chunks arriving while a cancel is PENDING are held here: pushing them
+            // to any visible sink could send output the cancel can't recall. On a
+            // failed cancel they're replayed; on success, discarded.
+            const heldChunks = [];
+            const releaseHeldChunks = () => {
+                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);
+                }
+            };
             const onChunk = (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();
                 }
             };
             const promptBridge = this.bridge;
@@ -1607,14 +1932,13 @@ export class ChannelBase {
                     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 cancelled, skip sending the response
                 if (!promptState.cancelled && response) {
+                    promptState.deliveryStarted = true;
                     if (streamer) {
                         await streamer.flush();
                     }
@@ -1622,6 +1946,41 @@ export class ChannelBase {
                         await this.onResponseComplete(envelope.chatId, response, sessionId);
                     }
                 }
+                // Once delivery started the turn's outcome is fixed — don't let a
+                // cancel settling during the send rewrite completed into cancelled.
+                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) {
+                // Mirror the try path: once delivery started, a late-settling cancel
+                // must not suppress the failed emit (the /cancel handler declines to
+                // emit its own terminal once deliveryStarted is set).
+                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)}\n`);
+                }
+                throw err;
             }
             finally {
                 promptBridge.off('textChunk', onChunk);