@qwen-code/channel-base 0.22.3 → 0.23.0

package/dist/ChannelBase.js

@@ -82,6 +82,8 @@ const LOOP_ADD_RE = /^"([^"]+)"\s+(.+)$/su;
 const MAX_LOOP_JOBS_PER_TARGET = 10;
 const MAX_LOOP_PROMPT_CHARS = 4000;
 const MAX_DISPLAY_PROJECTION_CHARS = 8000;
+// Mirrors BTW_MAX_INPUT_LENGTH in core without adding core to channel-base.
+const CHANNEL_BTW_MAX_INPUT_LENGTH = 4096;
 function parseLoopAddArgs(args) {
     const match = args.trim().match(LOOP_ADD_RE);
     if (!match)
@@ -134,6 +136,7 @@ export class ChannelBase {
     sessionQueues = new Map();
     queuedTurns = new Map();
     namedTurnBindings = new WeakMap();
+    inboundErrorSourceLabels = new WeakMap();
     registerBridgeEvents;
     bridgeRecovery;
     /**
@@ -146,6 +149,7 @@ export class ChannelBase {
     pendingChannelMemoryMutationDeliveries = new Map();
     /** Per-session active prompt tracking for dispatch modes. */
     activePrompts = new Map();
+    activeBtw = new Map();
     /** Per-session message buffer for collect mode. */
     collectBuffers = new Map();
     preflightedEnvelopes = new WeakSet();
@@ -202,17 +206,46 @@ export class ChannelBase {
         this.onToolCall(chatId, event);
     }
     async dispatchBackgroundResponse(sessionId, text) {
-        const target = this.router.getTarget(sessionId);
+        let target = this.router.getTarget(sessionId);
         if (!target ||
             target.channelName !== this.name ||
             text.trim().length === 0) {
             return;
         }
+        let sourceLabel;
+        if (this.namedSessions) {
+            const presentation = await this.namedSessions.resolvePresentation(sessionId);
+            const currentTarget = this.router.getTarget(sessionId);
+            const currentPresentation = this.namedSessions.presentation(sessionId);
+            if (!presentation ||
+                presentation.status !== 'open' ||
+                !currentTarget ||
+                !this.router.isSessionLive(sessionId) ||
+                !currentPresentation ||
+                currentPresentation.status !== 'open' ||
+                currentPresentation.taskName !== presentation.taskName ||
+                !this.sameTaskOwner(target, currentTarget) ||
+                !this.sameTaskOwner(currentTarget, currentPresentation.target)) {
+                throw new Error('Named background response ownership is unavailable.');
+            }
+            target = currentTarget;
+            sourceLabel = this.createSourceLabel(presentation, target);
+        }
         if (this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
-            await this.pushProactive(target, text);
+            if (sourceLabel) {
+                await this.pushProactive(target, text, sourceLabel);
+            }
+            else {
+                await this.pushProactive(target, text);
+            }
             return;
         }
-        await this.deliverBackgroundReply(target.chatId, text, sessionId);
+        if (sourceLabel) {
+            await this.deliverBackgroundReply(target.chatId, text, sessionId, sourceLabel);
+        }
+        else {
+            await this.deliverBackgroundReply(target.chatId, text, sessionId);
+        }
     }
     /**
      * Fallback delivery of a background response when proactive send is
@@ -220,8 +253,132 @@ export class ChannelBase {
      * stay out of turn-scoped streaming state, for example) override only this
      * step instead of re-implementing the whole dispatch flow.
      */
-    async deliverBackgroundReply(chatId, text, sessionId) {
-        await this.sendResponseMessage(chatId, text, sessionId);
+    async deliverBackgroundReply(chatId, text, sessionId, sourceLabel) {
+        await this.sendResponseMessage(chatId, text, sessionId, sourceLabel);
+    }
+    async handleBtw(envelope, sessionId, question, sourceLabel) {
+        const target = this.router.getTarget(sessionId);
+        if (!target || target.channelName !== this.name) {
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Could not resolve the current task for /btw.', sourceLabel);
+            return;
+        }
+        const running = this.activeBtw.get(sessionId);
+        if (running) {
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `BTW #${running.id} is still running for this task.`, sourceLabel);
+            return;
+        }
+        const reference = this.namedSessions?.presentation(sessionId);
+        const request = {
+            id: randomUUID().slice(0, 8),
+            bridge: this.bridge,
+            controller: new AbortController(),
+            target: { ...target },
+            chatId: envelope.chatId,
+            ...(envelope.threadId ? { threadId: envelope.threadId } : {}),
+            ...(sourceLabel ? { sourceLabel } : {}),
+            ...(reference?.status === 'open' ? { taskName: reference.taskName } : {}),
+        };
+        this.activeBtw.set(sessionId, request);
+        try {
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `BTW #${request.id} received. The main task will continue.`, sourceLabel);
+        }
+        catch (error) {
+            if (this.activeBtw.get(sessionId) === request) {
+                this.cancelBtw(sessionId);
+            }
+            throw error;
+        }
+        if (!this.isBtwCurrent(sessionId, request)) {
+            if (this.activeBtw.get(sessionId) === request) {
+                this.cancelBtw(sessionId);
+            }
+            return;
+        }
+        void this.deliverBtw(sessionId, question, request).catch((error) => {
+            process.stderr.write(`[${this.name}] BTW delivery failed for session ${sanitizeLogText(sessionId, 128)}: ${this.lifecycleError(error)}\n`);
+        });
+    }
+    async deliverBtw(sessionId, question, request) {
+        let message;
+        try {
+            let result;
+            try {
+                result = await request.bridge.btw(sessionId, question, request.controller.signal);
+                if (result.sessionId !== sessionId) {
+                    throw new Error('BTW response session did not match the request');
+                }
+                const answer = result.answer?.trim();
+                message = answer
+                    ? `BTW #${request.id}\n\n${answer}`
+                    : `BTW #${request.id}\n\nNo answer is available from the current conversation context.`;
+            }
+            catch (error) {
+                if (request.controller.signal.aborted)
+                    return;
+                process.stderr.write(`[${this.name}] BTW request failed for session ${sanitizeLogText(sessionId, 128)}: ${this.lifecycleError(error)}\n`);
+                message = `BTW #${request.id} failed. Please try again.`;
+            }
+            if (!this.isBtwCurrent(sessionId, request))
+                return;
+            try {
+                await this.sendThreadMessage(request.chatId, request.threadId, message, request.sourceLabel);
+            }
+            catch (error) {
+                try {
+                    await this.sendThreadMessage(request.chatId, request.threadId, `BTW #${request.id} failed. Please try again.`, request.sourceLabel);
+                }
+                catch {
+                    // Best effort only; the original delivery failure is logged by the caller.
+                }
+                throw error;
+            }
+        }
+        finally {
+            if (this.activeBtw.get(sessionId) === request) {
+                this.activeBtw.delete(sessionId);
+            }
+        }
+    }
+    isBtwCurrent(sessionId, request) {
+        if (request.controller.signal.aborted ||
+            this.activeBtw.get(sessionId) !== request ||
+            this.bridge !== request.bridge ||
+            !this.router.isSessionLive(sessionId)) {
+            return false;
+        }
+        const currentTarget = this.router.getTarget(sessionId);
+        // Compare owner + thread only: SessionRouter.promoteTargetToGroup flips
+        // the live target's isGroup whenever any group envelope or loop/webhook
+        // target resolves the same routing key, which changes neither the
+        // conversation nor the delivery destination, so it must not void an
+        // acknowledged answer. The named-task branch applies the same tolerance to
+        // the registry's creation-time snapshot, which keeps the pre-promotion
+        // isGroup value.
+        if (!currentTarget ||
+            !this.sameTaskOwner(request.target, currentTarget) ||
+            request.target.threadId !== currentTarget.threadId) {
+            return false;
+        }
+        if (!request.taskName)
+            return true;
+        const reference = this.namedSessions?.presentation(sessionId);
+        return (reference?.status === 'open' &&
+            reference.taskName === request.taskName &&
+            this.sameTaskOwner(currentTarget, reference.target) &&
+            currentTarget.threadId === reference.target.threadId);
+    }
+    cancelBtw(sessionId) {
+        const request = this.activeBtw.get(sessionId);
+        if (!request)
+            return;
+        this.activeBtw.delete(sessionId);
+        request.controller.abort();
+    }
+    cancelAllBtw() {
+        const requests = Array.from(this.activeBtw.values());
+        this.activeBtw.clear();
+        for (const request of requests)
+            request.controller.abort();
     }
     async dispatchPermissionRequest(event) {
         const target = this.permissionTargetForEvent(event);
@@ -236,12 +393,70 @@ export class ChannelBase {
             }
             return;
         }
+        let sourceLabel;
+        let taskName;
+        if (this.namedSessions) {
+            let presentation;
+            try {
+                presentation = await this.namedSessions.resolvePresentation(event.sessionId);
+            }
+            catch (err) {
+                try {
+                    await this.bridge.respondToPermission?.(event.requestId, {
+                        outcome: { outcome: 'cancelled' },
+                    });
+                }
+                catch (respondErr) {
+                    process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}\n`);
+                }
+                throw err;
+            }
+            const currentTarget = this.permissionTargetForEvent(event);
+            const currentPresentation = this.namedSessions.presentation(event.sessionId);
+            if (!presentation ||
+                presentation.status !== 'open' ||
+                !currentTarget ||
+                !this.router.isSessionLive(event.sessionId) ||
+                !currentPresentation ||
+                currentPresentation.status !== 'open' ||
+                currentPresentation.taskName !== presentation.taskName ||
+                !this.sameTaskOwner(target, currentTarget) ||
+                !this.sameTaskOwner(currentTarget, currentPresentation.target)) {
+                try {
+                    await this.bridge.respondToPermission?.(event.requestId, {
+                        outcome: { outcome: 'cancelled' },
+                    });
+                }
+                catch (respondErr) {
+                    process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}\n`);
+                }
+                return;
+            }
+            const active = this.activePrompts.get(event.sessionId);
+            sourceLabel = active
+                ? active.sourceLabel
+                : this.createSourceLabel(presentation, target);
+            if (!sourceLabel) {
+                try {
+                    await this.bridge.respondToPermission?.(event.requestId, {
+                        outcome: { outcome: 'cancelled' },
+                    });
+                }
+                catch (respondErr) {
+                    process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}\n`);
+                }
+                return;
+            }
+            taskName = presentation.taskName;
+        }
         this.removePendingPermission(event.requestId);
         const pending = {
             requestId: event.requestId,
             sessionId: event.sessionId,
             target,
             request: event.request,
+            ...(sourceLabel ? { sourceLabel } : {}),
+            ...(taskName ? { taskName } : {}),
             settlementListeners: new Set(),
         };
         this.pendingPermissions.set(event.requestId, pending);
@@ -258,10 +473,10 @@ export class ChannelBase {
             if (target.threadId !== undefined &&
                 this.supportsProactiveSend() &&
                 this.supportsProactiveTarget(target)) {
-                await this.pushProactive(target, text);
+                await this.pushProactive(target, text, pending.sourceLabel);
             }
             else {
-                await this.sendThreadMessage(target.chatId, target.threadId, text);
+                await this.sendThreadMessage(target.chatId, target.threadId, text, pending.sourceLabel);
             }
         }
         catch (err) {
@@ -296,6 +511,7 @@ export class ChannelBase {
             runId: active.runId,
             owner: active.owner,
             target: pending.target,
+            ...(pending.sourceLabel ? { sourceLabel: pending.sourceLabel } : {}),
             ...(precedingSegment
                 ? { precedingSegmentId: precedingSegment.segmentId }
                 : {}),
@@ -516,8 +732,8 @@ export class ChannelBase {
      * on a specific issue/PR. The default falls through to sendMessage(chatId,
      * text), ignoring threadId — existing IM adapters are behaviorally unchanged.
      */
-    async sendThreadMessage(chatId, _threadId, text) {
-        await this.sendMessage(chatId, text);
+    async sendThreadMessage(chatId, _threadId, text, sourceLabel) {
+        await this.sendMessage(chatId, this.formatAttributedText(text, sourceLabel));
     }
     /**
      * Adapter hook for task lifecycle events — the canonical way to track task
@@ -673,6 +889,7 @@ export class ChannelBase {
             segmentId,
             owner: active.owner,
             target: resolvedTarget,
+            ...(active.sourceLabel ? { sourceLabel: active.sourceLabel } : {}),
             ...(active.messageId ? { messageId: active.messageId } : {}),
         };
     }
@@ -714,11 +931,11 @@ export class ChannelBase {
     supportsProactiveWebhookTarget(target) {
         return this.supportsProactiveTarget(target);
     }
-    async pushProactive(target, text) {
+    async pushProactive(target, text, sourceLabel) {
         if (target.threadId) {
             throw new Error('Channel does not support proactive loop messages for threaded targets.');
         }
-        await this.sendThreadMessage(target.chatId, target.threadId, text);
+        await this.sendThreadMessage(target.chatId, target.threadId, text, sourceLabel);
     }
     async pushProactiveDelivery(target, text) {
         try {
@@ -931,6 +1148,7 @@ export class ChannelBase {
     }
     /** Replace the bridge instance (used after crash recovery restart). */
     setBridge(bridge) {
+        this.cancelAllBtw();
         if (this.registerBridgeEvents) {
             this.detachBridgeEvents(this.bridge);
         }
@@ -1427,6 +1645,7 @@ export class ChannelBase {
                 }),
             ]);
             if (!cancelled) {
+                this.cancelBtw(sessionId);
                 this.router.removeSessionId(sessionId);
                 this.instructedSessions.delete(sessionId);
                 this.unattendedMemorySessions.delete(sessionId);
@@ -1559,6 +1778,7 @@ export class ChannelBase {
     }
     onToolCall(_chatId, _event) { }
     onSessionDied(sessionId) {
+        this.cancelBtw(sessionId);
         this.router.handleSessionDied(sessionId);
         this.instructedSessions.delete(sessionId);
         this.unattendedMemorySessions.delete(sessionId);
@@ -1608,11 +1828,11 @@ export class ChannelBase {
      * Override to clear adapter-owned streaming buffers.
      */
     onResponseBoundary(_chatId, _sessionId) { }
-    async sendResponseMessage(chatId, text, sessionId) {
+    async sendResponseMessage(chatId, text, sessionId, sourceLabel) {
         const active = this.activePrompts.get(sessionId);
         const target = this.router.getTarget(sessionId);
         const threadId = active?.threadId ?? target?.threadId;
-        await this.sendThreadMessage(chatId, threadId, text);
+        await this.sendThreadMessage(chatId, threadId, text, sourceLabel ?? active?.sourceLabel);
     }
     /**
      * Adapter hook for delivery-only metadata. The response delivery path can read
@@ -1627,6 +1847,12 @@ export class ChannelBase {
     getResponseMetadata(sessionId) {
         return this.activePrompts.get(sessionId)?.metadata;
     }
+    getResponseSourceLabel(sessionId) {
+        return this.activePrompts.get(sessionId)?.sourceLabel;
+    }
+    getInboundErrorSourceLabel(envelope) {
+        return this.inboundErrorSourceLabels.get(envelope);
+    }
     /**
      * Returns the active prompt's response thread while it remains available for
      * adapter delivery. Falls back to the session target after prompt cleanup.
@@ -1640,8 +1866,8 @@ export class ChannelBase {
      * Override to customize delivery (e.g., finalize an AI card).
      * Default: sends the full response text.
      */
-    async onResponseComplete(chatId, fullText, sessionId, _segment) {
-        await this.sendResponseMessage(chatId, fullText, sessionId);
+    async onResponseComplete(chatId, fullText, sessionId, segment) {
+        await this.sendResponseMessage(chatId, fullText, sessionId, segment?.sourceLabel);
     }
     /**
      * Register a slash command handler. Subclasses can call this to add
@@ -1762,7 +1988,7 @@ export class ChannelBase {
         }
         return 'resolved_outside_presenter';
     }
-    pendingPermissionForEnvelope(envelope, args) {
+    pendingPermissionForEnvelope(envelope, args, selectedSessionId) {
         const trimmed = args.trim();
         if (trimmed) {
             const explicit = this.pendingPermissions.get(trimmed);
@@ -1779,6 +2005,8 @@ export class ChannelBase {
         const matching = requestIds
             .map((id) => this.pendingPermissions.get(id))
             .filter((pending) => pending !== undefined &&
+            (selectedSessionId === undefined ||
+                pending.sessionId === selectedSessionId) &&
             this.canEnvelopeAnswerPendingPermission(envelope, pending));
         if (matching.length === 0) {
             return { kind: 'none', explicit: false };
@@ -1801,29 +2029,91 @@ export class ChannelBase {
     }
     formatPermissionRequest(pending) {
         const { toolCall } = pending.request;
-        const title = sanitizeQuotedText(toolCall.title || 'Tool use', 160);
+        const parameters = this.permissionParameterSummary(toolCall);
+        const approveLabel = this.permissionOptionLabel(this.approvalOption(pending), 'allow once');
         const alwaysOption = this.approvalAlwaysOption(pending);
+        const denyLabel = this.permissionOptionLabel(this.denialOption(pending), 'deny');
+        const requestSuffix = pending.taskName ? ` ${pending.requestId}` : '';
+        const replyPadding = pending.taskName
+            ? { approve: '          ', always: '   ', deny: '             ' }
+            : { approve: '        ', always: ' ', deny: '           ' };
         const replies = [
-            '/approve        allow once',
-            ...(alwaysOption ? [`/approve-always ${alwaysOption.label}`] : []),
-            '/deny           deny',
+            `/approve${requestSuffix}${replyPadding.approve}${approveLabel}`,
+            ...(alwaysOption
+                ? [
+                    `/approve-always${requestSuffix}${replyPadding.always}${alwaysOption.label}`,
+                ]
+                : []),
+            `/deny${requestSuffix}${replyPadding.deny}${denyLabel}`,
         ];
-        const lines = [
+        return [
             'Permission required to run a tool',
+            ...(pending.taskName ? [`Request: ${pending.requestId}`] : []),
             '',
-            'Command:',
-            title,
+            `Tool: ${this.permissionToolName(toolCall)}`,
+            `Action: ${this.permissionTitle(toolCall)}`,
+            ...(parameters ? [`Parameters: ${parameters}`] : []),
             '',
             'Reply with:',
             ...replies,
-        ];
-        return lines.join('\n');
+        ].join('\n');
     }
-    approvalOptionId(pending) {
+    permissionTitle(toolCall) {
+        const rawTitle = typeof toolCall.title === 'string' ? toolCall.title : undefined;
+        return sanitizeQuotedText(rawTitle || '', 160).trim() || 'Tool use';
+    }
+    permissionToolName(toolCall) {
+        const rawToolCall = toolCall;
+        const meta = isRecord(rawToolCall['_meta'])
+            ? rawToolCall['_meta']
+            : undefined;
+        for (const candidate of [meta?.['toolName'], rawToolCall['kind']]) {
+            if (typeof candidate !== 'string')
+                continue;
+            const name = sanitizeQuotedText(candidate, 120).trim();
+            if (name)
+                return name;
+        }
+        return 'unknown';
+    }
+    permissionParameterSummary(toolCall) {
+        const rawToolCall = toolCall;
+        const rawInput = isRecord(rawToolCall['rawInput'])
+            ? rawToolCall['rawInput']
+            : undefined;
+        if (!rawInput)
+            return undefined;
+        const entries = Object.entries(rawInput);
+        if (entries.length === 0)
+            return undefined;
+        const visible = entries.slice(0, 4).map(([key, value]) => {
+            const safeKey = sanitizeQuotedText(key, 48).trim() || 'unknown';
+            if (Array.isArray(value)) {
+                return `${safeKey} (${value.length} ${value.length === 1 ? 'item' : 'items'})`;
+            }
+            if (isRecord(value)) {
+                return `${safeKey} (object)`;
+            }
+            return safeKey;
+        });
+        if (entries.length > visible.length) {
+            visible.push(`+${entries.length - visible.length} more`);
+        }
+        return visible.join(', ');
+    }
+    permissionOptionLabel(option, fallback) {
+        const rawLabel = typeof option?.name === 'string' ? option.name : '';
+        const label = sanitizeQuotedText(rawLabel, 160).trim();
+        return label || fallback;
+    }
+    approvalOption(pending) {
         const options = pending.request.options;
-        return (options.find((option) => option.kind === 'allow_once')?.optionId ??
+        return (options.find((option) => option.kind === 'allow_once') ??
             options.find((option) => option.optionId === 'proceed_once' &&
-                option.kind === undefined)?.optionId);
+                option.kind === undefined));
+    }
+    approvalOptionId(pending) {
+        return this.approvalOption(pending)?.optionId;
     }
     approvalAlwaysOption(pending) {
         const options = pending.request.options.filter((option) => option.kind === 'allow_always');
@@ -1835,7 +2125,7 @@ export class ChannelBase {
         }
         return {
             optionId: option.optionId,
-            label: this.approvalAlwaysLabel(option),
+            label: this.permissionOptionLabel(option, this.approvalAlwaysLabel(option)),
         };
     }
     findScopedAlwaysOption(options, scope) {
@@ -1851,29 +2141,45 @@ export class ChannelBase {
         return 'always allow';
     }
     denialResponse(pending) {
-        const option = pending.request.options.find((candidate) => candidate.kind === 'reject_once') ??
-            pending.request.options.find((candidate) => candidate.optionId === 'cancel' &&
-                candidate.kind === undefined);
+        const option = this.denialOption(pending);
         if (option) {
             return { outcome: { outcome: 'selected', optionId: option.optionId } };
         }
         return { outcome: { outcome: 'cancelled' } };
     }
+    denialOption(pending) {
+        return (pending.request.options.find((candidate) => candidate.kind === 'reject_once') ??
+            pending.request.options.find((candidate) => candidate.optionId === 'cancel' &&
+                candidate.kind === undefined));
+    }
     async handlePermissionResponseCommand(envelope, args, decision) {
         if (!this.isAuthorizedForSharedSession(envelope)) {
             await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Only authorized members can answer permission requests in this shared session.');
             return true;
         }
-        const lookup = this.pendingPermissionForEnvelope(envelope, args);
+        const namedSessions = this.namedSessions;
+        const bareNamedCommand = namedSessions !== undefined && args.trim() === '';
+        let selectedTask;
+        if (bareNamedCommand) {
+            try {
+                selectedTask = await namedSessions.current(this.namedSessionOwner(envelope));
+            }
+            catch (error) {
+                await this.sendNamedSessionError(envelope, error);
+                return true;
+            }
+        }
+        const lookup = this.pendingPermissionForEnvelope(envelope, args, bareNamedCommand ? (selectedTask?.sessionId ?? null) : undefined);
         if (lookup.kind === 'ambiguous') {
             const requestList = lookup.requestIds
                 .slice(0, 6)
                 .map((id) => {
                 const pending = this.pendingPermissions.get(id);
                 const title = pending
-                    ? `: ${sanitizeQuotedText(pending.request.toolCall.title || 'Tool use', 160)}`
+                    ? `: ${this.permissionTitle(pending.request.toolCall)}`
                     : '';
-                return `- ${sanitizeQuotedText(id, 128)}${title}`;
+                const task = pending?.taskName ? `Task ${pending.taskName} — ` : '';
+                return `- ${task}${sanitizeQuotedText(id, 128)}${title}`;
             })
                 .join('\n');
             await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Multiple permission requests are pending for this chat. Reply with /${decision} <request-id>.\n${requestList}`);
@@ -1882,16 +2188,20 @@ export class ChannelBase {
         if (lookup.kind === 'none') {
             await this.sendThreadMessage(envelope.chatId, envelope.threadId, lookup.explicit
                 ? 'No pending permission request with that id for this chat.'
-                : 'No pending permission request for this chat.');
+                : selectedTask
+                    ? `No pending permission request for selected task "${selectedTask.name}". Use an explicit request ID to answer another task.`
+                    : this.namedSessions
+                        ? 'No task is currently selected. Use an explicit request ID to answer a named task.'
+                        : 'No pending permission request for this chat.');
             return true;
         }
+        const { pending } = lookup;
         if (!this.bridge.respondToPermission) {
-            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Permission relay is not available for this session.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Permission relay is not available for this session.', pending.sourceLabel);
             return true;
         }
-        const { pending } = lookup;
         if (pending.userInputPresented && decision !== 'deny') {
-            await this.sendMessage(envelope.chatId, 'Submit this question through its interactive card, or use /deny [request-id] to cancel it.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Submit this question through its interactive card, or use /deny [request-id] to cancel it.', pending.sourceLabel);
             return true;
         }
         const response = (() => {
@@ -1908,7 +2218,7 @@ export class ChannelBase {
         if (!response) {
             await this.sendThreadMessage(envelope.chatId, envelope.threadId, decision === 'approve-always'
                 ? 'This permission request has no always-allow option.'
-                : 'This permission request has no approvable option.');
+                : 'This permission request has no approvable option.', pending.sourceLabel);
             return true;
         }
         let accepted;
@@ -1920,7 +2230,7 @@ export class ChannelBase {
         catch (err) {
             this.removePendingPermission(pending.requestId);
             process.stderr.write(`[${this.name}] permission response failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}\n`);
-            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Failed to answer the permission request.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Failed to answer the permission request.', pending.sourceLabel);
             return true;
         }
         this.removePendingPermission(pending.requestId);
@@ -1930,7 +2240,7 @@ export class ChannelBase {
                 : decision === 'approve-always'
                     ? 'Permission approved always.'
                     : 'Permission denied.'
-            : 'Permission request is no longer pending.');
+            : 'Permission request is no longer pending.', pending.sourceLabel);
         return true;
     }
     namedSessionOwner(envelope) {
@@ -2001,7 +2311,7 @@ export class ChannelBase {
         if (this.bypassesNamedTurnBinding(envelope))
             return true;
         try {
-            const sessionId = await namedSessions.resolve(this.namedSessionOwner(envelope), undefined, (resolvedSessionId) => {
+            const sessionId = await namedSessions.resolve(this.namedSessionOwner(envelope), (resolvedSessionId) => {
                 const binding = this.bindNamedTurn(envelope, resolvedSessionId);
                 return () => this.releaseNamedTurnBinding(binding);
             });
@@ -2090,7 +2400,7 @@ export class ChannelBase {
                 }
                 case 'new': {
                     if (parts.includes('--worktree')) {
-                        await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Worktree tasks are not available in Part 2 yet. Create a shared task with /session new <name>.');
+                        await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Worktree tasks are planned for Part 4. Create a shared task with /session new <name>.');
                         return true;
                     }
                     if (parts.length !== 1)
@@ -2109,15 +2419,42 @@ export class ChannelBase {
                 case 'close': {
                     if (parts.length !== 1)
                         break;
+                    const closing = await namedSessions.lookup(owner, parts[0]);
                     const result = await namedSessions.close(owner, parts[0]);
+                    if (closing)
+                        this.cancelBtw(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;
                 }
-                case 'cancel':
-                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Named task cancellation is not available in Part 2 yet. Wait for the selected task to finish before switching; Telegram users can use /cancel.');
+                case 'cancel': {
+                    if (parts.length > 1)
+                        break;
+                    const taskName = parts[0];
+                    const task = taskName
+                        ? await namedSessions.lookup(owner, taskName)
+                        : await namedSessions.current(owner);
+                    if (!task) {
+                        await this.sendThreadMessage(envelope.chatId, envelope.threadId, taskName
+                            ? `Task "${sanitizeQuotedText(taskName, 32)}" was not found.`
+                            : 'No task is currently selected.');
+                        return true;
+                    }
+                    if (task.status !== 'open') {
+                        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Task "${task.name}" is closed.`);
+                        return true;
+                    }
+                    if (!this.activePrompts.has(task.sessionId)) {
+                        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `No request is currently running for task "${task.name}".`);
+                        return true;
+                    }
+                    const cancelled = await this.requestActivePromptCancellation(task.sessionId, 'cancel_command');
+                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, cancelled
+                        ? `Cancelled task "${task.name}".`
+                        : `Failed to cancel task "${task.name}".`);
                     return true;
+                }
                 default:
                     break;
             }
@@ -2151,6 +2488,7 @@ export class ChannelBase {
             this.clearPendingGroupHistory(envelope);
             if (removedIds.length > 0) {
                 for (const id of removedIds) {
+                    this.cancelBtw(id);
                     // Audit: clearing a SHARED session wipes the conversation for every
                     // participant, so record who triggered it (sanitized display name +
                     // stable senderId) and which session — mirrors the file's stderr audit
@@ -2266,6 +2604,7 @@ export class ChannelBase {
         this.registerCommand('clear', clearHandler);
         this.registerCommand('reset', clearHandler);
         this.registerCommand('new', clearHandler);
+        this.registerCommand('btw', () => Promise.resolve(false));
         if (this.namedSessions) {
             this.registerCommand('sessions', (envelope, args) => this.handleNamedSessionsCommand(envelope, args));
             this.registerCommand('session', (envelope, args) => this.handleNamedSessionCommand(envelope, args));
@@ -2325,10 +2664,15 @@ export class ChannelBase {
                 '/approve [request-id] — Approve a pending permission request',
                 '/approve-always [request-id] — Always approve a pending permission request',
                 '/deny [request-id] — Deny a pending permission request',
+                ...(this.bridge.btw
+                    ? [
+                        '/btw <question> — Ask a side question without interrupting the current task',
+                    ]
+                    : []),
                 ...(this.namedSessions
                     ? [
                         '/sessions [all] — List your named tasks',
-                        '/session current|new|use|close — Manage your named tasks',
+                        '/session current|new|use|close|cancel — Manage your named tasks',
                     ]
                     : []),
             ];
@@ -2341,6 +2685,7 @@ export class ChannelBase {
                 'approve',
                 'approve-always',
                 'deny',
+                'btw',
                 'remember-channel',
                 'channel-memory',
                 'forget-channel',
@@ -2356,9 +2701,13 @@ export class ChannelBase {
                 }
             }
             const sessionId = await this.currentSessionId(envelope);
-            const agentCommands = sessionId
+            const agentCommands = (sessionId
                 ? this.getAgentCommandsForSession(sessionId)
-                : this.bridge.availableCommands;
+                : this.bridge.availableCommands).filter((command) => !this.commands.has(command.name) ||
+                // `btw` is registered unconditionally but only handled locally when
+                // the bridge supports it. Without that capability the agent's entry
+                // is the working one, so it must stay listed.
+                (command.name === 'btw' && !this.bridge.btw));
             if (agentCommands.length > 0) {
                 lines.push('', 'Agent commands (forwarded to Qwen Code):');
                 for (const cmd of agentCommands) {
@@ -3758,6 +4107,67 @@ export class ChannelBase {
             return undefined;
         }
     }
+    formatAttributedText(text, sourceLabel) {
+        if (!sourceLabel || text.trim().length === 0)
+            return text;
+        return `${sourceLabel} ${text}`;
+    }
+    formatMarkdownAttributedText(text, sourceLabel) {
+        const escapedLabel = sourceLabel?.replace(/([\\`*_[\]{}()#+\-.!|>~])/gu, '\\$1');
+        if (!escapedLabel || text.trim().length === 0)
+            return text;
+        return `${escapedLabel}\n${text}`;
+    }
+    sameTaskOwner(a, b) {
+        return (a.channelName === b.channelName &&
+            a.chatId === b.chatId &&
+            a.senderId === b.senderId);
+    }
+    createSourceLabel(reference, target, active) {
+        const activeName = active?.senderName
+            ? this.sanitizeSourceSender(active.senderName)
+            : undefined;
+        const senderLabel = (activeName && activeName !== 'unknown' ? activeName : undefined) ??
+            this.observedSenderLabel(target.chatId, target.senderId) ??
+            this.sanitizeSourceSender(target.senderId || 'unknown');
+        const isGroup = active?.isGroup ?? target.isGroup ?? true;
+        return isGroup
+            ? `[${senderLabel} · ${reference.taskName}]`
+            : `[${reference.taskName}]`;
+    }
+    observedSenderLabel(chatId, senderId) {
+        const graph = this.persistedObservedContacts();
+        if (!graph)
+            return undefined;
+        const sources = [
+            graph.groups
+                .filter((group) => group.id === chatId)
+                .flatMap((group) => group.users)
+                .filter((user) => user.id === senderId),
+            graph.users.filter((user) => user.id === senderId),
+        ];
+        for (const source of sources) {
+            const candidates = source.sort((a, b) => b.lastObservedAt.localeCompare(a.lastObservedAt));
+            for (const candidate of candidates) {
+                const label = this.sanitizeSourceSender(candidate.label);
+                if (label !== 'unknown')
+                    return label;
+            }
+        }
+        return undefined;
+    }
+    sanitizeSourceSender(value) {
+        return sanitizeSenderName(value).replace(/\s+/gu, ' ').trim() || 'unknown';
+    }
+    sourceLabelForTurn(sessionId, envelope) {
+        const reference = this.namedSessions?.presentation(sessionId);
+        if (!reference || reference.status !== 'open')
+            return undefined;
+        return this.createSourceLabel(reference, reference.target, {
+            isGroup: envelope.isGroup,
+            senderName: envelope.senderName,
+        });
+    }
     markPreflighted(envelope) {
         this.preflightedEnvelopes.add(envelope);
     }
@@ -3794,12 +4204,16 @@ export class ChannelBase {
         // control chars cannot reach the session-bus echo, recorded transcript,
         // or session previews.
         const displayText = sanitizeDisplayText(envelope.displayText ?? envelope.text, MAX_DISPLAY_PROJECTION_CHARS);
-        let memoryIntent = parseChannelMemoryIntent(envelope.text);
+        const parsed = this.parseCommand(envelope.text);
+        let memoryIntent = parsed?.command === 'btw'
+            ? null
+            : parseChannelMemoryIntent(envelope.text);
         let memoryIntentFromClassifier = false;
         if (memoryIntent?.kind === 'update' || memoryIntent?.kind === 'remove') {
             this.deletePendingChannelMemoryMutation(envelope);
         }
         if (!memoryIntent &&
+            parsed?.command !== 'btw' &&
             this.shouldClassifyChannelMemoryIntent(envelope.text)) {
             memoryIntent = await this.classifyChannelMemoryIntent(envelope);
             memoryIntentFromClassifier = memoryIntent !== null;
@@ -3821,7 +4235,7 @@ export class ChannelBase {
             }
         }
         // 3. Slash command handling — before session/agent routing
-        const parsed = this.parseCommand(envelope.text);
+        let btwQuestion;
         if (parsed) {
             const handler = this.commands.get(parsed.command);
             if (handler) {
@@ -3830,6 +4244,29 @@ export class ChannelBase {
                     return;
             }
             // Unrecognized commands fall through to the agent
+            // Intercept /btw only where the bridge can answer it out of band. With no
+            // btw capability this is not a locally handled command at all: it falls
+            // through to the agent, which serves /btw as its own slash command, the
+            // same path it took before this interception existed.
+            if (parsed.command === 'btw' && this.bridge.btw) {
+                if (!this.isAuthorizedForSharedSession(envelope)) {
+                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Only authorized members can use /btw in this shared session.');
+                    return;
+                }
+                btwQuestion = parsed.args.trim();
+                if (!btwQuestion) {
+                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Usage: /btw <question>');
+                    return;
+                }
+                if (btwQuestion.length > CHANNEL_BTW_MAX_INPUT_LENGTH) {
+                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, `BTW questions are limited to ${CHANNEL_BTW_MAX_INPUT_LENGTH} characters.`);
+                    return;
+                }
+                if (envelope.imageBase64 || envelope.attachments?.length) {
+                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, '/btw supports text-only questions.');
+                    return;
+                }
+            }
         }
         // 3.5. Bang (!) shell command — refuse outside a private 1:1 chat BEFORE
         // resolving a session, so a refused command never creates or persists one.
@@ -3870,20 +4307,21 @@ export class ChannelBase {
                 return;
             }
             try {
-                sessionId = await this.namedSessions.resolve(this.namedSessionOwner(envelope), namedTurn.sessionId);
+                const resumed = await this.namedSessions.resumeReserved(this.namedSessionOwner(envelope), namedTurn.sessionId);
+                sessionId = resumed ? namedTurn.sessionId : undefined;
             }
             catch (error) {
                 await this.sendNamedSessionError(envelope, error);
                 return;
             }
             if (!sessionId) {
-                process.stderr.write(`[${this.name}] dropped collected turn from ${envelope.senderId} for session ${namedTurn.sessionId}: selected task changed before it ran\n`);
+                process.stderr.write(`[${this.name}] dropped collected turn from ${envelope.senderId} for session ${namedTurn.sessionId}: reserved task is no longer available\n`);
                 return;
             }
         }
         else if (this.namedSessions) {
             try {
-                sessionId = await this.namedSessions.resolve(this.namedSessionOwner(envelope), undefined, (resolvedSessionId) => {
+                sessionId = await this.namedSessions.resolve(this.namedSessionOwner(envelope), (resolvedSessionId) => {
                     const binding = this.bindNamedTurn(envelope, resolvedSessionId);
                     namedTurn = binding;
                     return () => this.releaseNamedTurnBinding(binding);
@@ -3901,6 +4339,17 @@ export class ChannelBase {
         else {
             sessionId = await this.router.resolve(this.name, envelope.senderId, envelope.chatId, envelope.threadId, this.config.cwd, envelope.isGroup);
         }
+        const sourceLabel = this.namedSessions
+            ? this.sourceLabelForTurn(sessionId, envelope)
+            : undefined;
+        if (this.namedSessions && !sourceLabel) {
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Could not identify the selected task. Use /sessions, select it again, and retry.');
+            return;
+        }
+        if (btwQuestion !== undefined) {
+            await this.handleBtw(envelope, sessionId, btwQuestion, sourceLabel);
+            return;
+        }
         // Bang (!) execution — a private 1:1 session has a single operator, so
         // direct shell execution stays allowed. Group/shared contexts were refused
         // above, before the session was resolved.
@@ -3918,10 +4367,10 @@ export class ChannelBase {
                     const exitLine = result.exitCode !== null && result.exitCode !== 0
                         ? `\nExit code: ${result.exitCode}`
                         : '';
-                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, `$ ${cmd}\n${output}${exitLine}`);
+                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, `$ ${cmd}\n${output}${exitLine}`, sourceLabel);
                 }
                 catch (error) {
-                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Shell command failed: ${error instanceof Error ? error.message : String(error)}`);
+                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Shell command failed: ${error instanceof Error ? error.message : String(error)}`, sourceLabel);
                 }
                 return;
             }
@@ -4268,6 +4717,7 @@ export class ChannelBase {
                 senderId: envelope.senderId,
                 senderName: envelope.senderName,
                 metadata: envelope.metadata,
+                sourceLabel,
             };
             // This turn is now the single owner of the session's active-prompt slot.
             // (Steer no longer hands a still-active session to a replacement; only
@@ -4290,7 +4740,7 @@ export class ChannelBase {
                     minChars: this.config.blockStreamingChunk?.minChars ?? 400,
                     maxChars: this.config.blockStreamingChunk?.maxChars ?? 1000,
                     idleMs: this.config.blockStreamingCoalesce?.idleMs ?? 1500,
-                    send: (text) => this.sendResponseMessage(envelope.chatId, text, sessionId),
+                    send: (text) => this.sendResponseMessage(envelope.chatId, text, sessionId, sourceLabel),
                 })
                 : null;
             promptState.stopStreaming = () => streamer?.stop();
@@ -4408,6 +4858,9 @@ export class ChannelBase {
                 if (promptState.cancelled) {
                     return;
                 }
+                if (sourceLabel) {
+                    this.inboundErrorSourceLabels.set(envelope, sourceLabel);
+                }
                 throw err;
             }
             finally {