@qwen-code/channel-base 0.21.0 → 0.21.1

package/dist/ChannelBase.js

@@ -226,7 +226,7 @@ export class ChannelBase {
                 await this.pushProactive(target, text);
             }
             else {
-                await this.sendMessage(target.chatId, text);
+                await this.sendThreadMessage(target.chatId, target.threadId, text);
             }
         }
         catch (err) {
@@ -307,6 +307,14 @@ export class ChannelBase {
             this.attachBridgeEvents(bridge);
         }
     }
+    /**
+     * Thread-targeted delivery. Polling adapters override this to post comments
+     * 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);
+    }
     /**
      * Adapter hook for task lifecycle events — the canonical way to track task
      * state (onPromptStart/onPromptEnd are retained for back-compat). The prompt
@@ -444,7 +452,7 @@ export class ChannelBase {
         if (target.threadId) {
             throw new Error('Channel does not support proactive loop messages for threaded targets.');
         }
-        await this.sendMessage(target.chatId, text);
+        await this.sendThreadMessage(target.chatId, target.threadId, text);
     }
     async pushProactiveDelivery(target, text) {
         try {
@@ -640,6 +648,7 @@ export class ChannelBase {
             alreadyPrefixed: true,
             referencedText: undefined,
             attachments: undefined,
+            metadata: undefined,
             imageBase64: undefined,
             imageMimeType: undefined,
         };
@@ -1142,6 +1151,7 @@ export class ChannelBase {
                 this.router.removeSessionId(sessionId);
                 this.instructedSessions.delete(sessionId);
                 this.unattendedMemorySessions.delete(sessionId);
+                this.discardRetiredSession(promptBridge, sessionId, `timed-out loop ${jobId}`);
                 process.stderr.write(`[${this.name}] retired timed out loop ${jobId} session ${sessionId} after cancel did not settle\n`);
             }
         }
@@ -1152,6 +1162,18 @@ export class ChannelBase {
             clearTimeout(graceTimer);
         }
     }
+    discardRetiredSession(promptBridge, sessionId, reason) {
+        const safeSessionId = sanitizeLogText(sessionId, 64);
+        const safeReason = sanitizeLogText(reason, 128);
+        try {
+            void promptBridge.discardSession?.(sessionId).catch((err) => {
+                process.stderr.write(`[${this.name}] failed to discard ${safeReason} session ${safeSessionId}: ${this.lifecycleError(err)}\n`);
+            });
+        }
+        catch (err) {
+            process.stderr.write(`[${this.name}] failed to discard ${safeReason} session ${safeSessionId}: ${this.lifecycleError(err)}\n`);
+        }
+    }
     requestActivePromptCancellation(sessionId, reason = 'cancel_command') {
         const active = this.activePrompts.get(sessionId);
         if (!active) {
@@ -1294,8 +1316,11 @@ export class ChannelBase {
      * Override to clear adapter-owned streaming buffers.
      */
     onResponseBoundary(_chatId, _sessionId) { }
-    async sendResponseMessage(chatId, text, _sessionId) {
-        await this.sendMessage(chatId, text);
+    async sendResponseMessage(chatId, text, sessionId) {
+        const active = this.activePrompts.get(sessionId);
+        const target = this.router.getTarget(sessionId);
+        const threadId = active?.threadId ?? target?.threadId;
+        await this.sendThreadMessage(chatId, threadId, text);
     }
     /**
      * Called when the agent's full response is ready.
@@ -1320,23 +1345,23 @@ export class ChannelBase {
             // to authorized senders like /clear (auth gate only — no confirm step). A
             // non-shared (1:1) session is always authorized, so behavior is unchanged.
             if (!this.isAuthorizedForSharedSession(envelope)) {
-                await this.sendMessage(envelope.chatId, 'Only authorized members can cancel requests in this shared session.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Only authorized members can cancel requests in this shared session.');
                 return true;
             }
             const activeSessionId = this.findActiveSessionId(envelope);
             if (!activeSessionId) {
-                await this.sendMessage(envelope.chatId, 'No request is currently running.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No request is currently running.');
                 return true;
             }
             const active = this.activePrompts.get(activeSessionId);
             if (!active) {
-                await this.sendMessage(envelope.chatId, 'No request is currently running.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No request is currently running.');
                 return true;
             }
             // 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
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, cancelSucceeded
                 ? 'Cancelled current request.'
                 : 'Failed to cancel current request.');
             return true;
@@ -1487,7 +1512,7 @@ export class ChannelBase {
     }
     async handlePermissionResponseCommand(envelope, args, decision) {
         if (!this.isAuthorizedForSharedSession(envelope)) {
-            await this.sendMessage(envelope.chatId, 'Only authorized members can answer permission requests in this shared session.');
+            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);
@@ -1502,17 +1527,17 @@ export class ChannelBase {
                 return `- ${sanitizeQuotedText(id, 128)}${title}`;
             })
                 .join('\n');
-            await this.sendMessage(envelope.chatId, `Multiple permission requests are pending for this chat. Reply with /${decision} <request-id>.\n${requestList}`);
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Multiple permission requests are pending for this chat. Reply with /${decision} <request-id>.\n${requestList}`);
             return true;
         }
         if (lookup.kind === 'none') {
-            await this.sendMessage(envelope.chatId, lookup.explicit
+            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.');
             return true;
         }
         if (!this.bridge.respondToPermission) {
-            await this.sendMessage(envelope.chatId, 'Permission relay is not available for this session.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Permission relay is not available for this session.');
             return true;
         }
         const { pending } = lookup;
@@ -1528,7 +1553,7 @@ export class ChannelBase {
                 : undefined;
         })();
         if (!response) {
-            await this.sendMessage(envelope.chatId, decision === 'approve-always'
+            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.');
             return true;
@@ -1540,11 +1565,11 @@ 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.sendMessage(envelope.chatId, 'Failed to answer the permission request.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Failed to answer the permission request.');
             return true;
         }
         this.removePendingPermission(pending.requestId);
-        await this.sendMessage(envelope.chatId, accepted
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, accepted
             ? decision === 'approve'
                 ? 'Permission approved.'
                 : decision === 'approve-always'
@@ -1646,11 +1671,12 @@ export class ChannelBase {
                         // bumped value — reclaim it immediately.
                         this.sessionGenerations.delete(id);
                     }
+                    this.discardRetiredSession(this.bridge, id, 'cleared');
                 }
-                await this.sendMessage(envelope.chatId, 'Session cleared. The next message starts a fresh conversation.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Session cleared. The next message starts a fresh conversation.');
             }
             else {
-                await this.sendMessage(envelope.chatId, 'No active session to clear.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No active session to clear.');
             }
         };
         // For a shared session, clearing it affects everyone who shares it: restrict
@@ -1659,11 +1685,11 @@ export class ChannelBase {
         // directly — there /clear only touches the caller's own session.
         const clearHandler = async (envelope, args) => {
             if (!this.isAuthorizedForSharedSession(envelope)) {
-                await this.sendMessage(envelope.chatId, 'Only authorized members can clear this shared session.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Only authorized members can clear this shared session.');
                 return true;
             }
             if (this.isSharedSession(envelope) && args.toLowerCase() !== 'confirm') {
-                await this.sendMessage(envelope.chatId, 'This clears the shared session for everyone who shares it. Re-send with "confirm" (e.g. /clear confirm) to proceed.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'This clears the shared session for everyone who shares it. Re-send with "confirm" (e.g. /clear confirm) to proceed.');
                 return true;
             }
             await doClear(envelope);
@@ -1680,7 +1706,7 @@ export class ChannelBase {
         // leaks the workspace basename, so non-members shouldn't see it either.
         this.registerCommand('who', async (envelope) => {
             if (!this.isAuthorizedForSharedSession(envelope)) {
-                await this.sendMessage(envelope.chatId, 'Only authorized members can view this shared session.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Only authorized members can view this shared session.');
                 return true;
             }
             const active = this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
@@ -1697,7 +1723,7 @@ export class ChannelBase {
                     : envelope.isGroup
                         ? ' (private to you)'
                         : '';
-            await this.sendMessage(envelope.chatId, [
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, [
                 `Channel: ${this.name}`,
                 // Identity/memory lines only for channels that opted in — keep
                 // unconfigured channels' output unchanged.
@@ -1758,14 +1784,14 @@ export class ChannelBase {
                 }
             }
             lines.push('', 'Send any text to chat with the agent.');
-            await this.sendMessage(envelope.chatId, lines.join('\n'));
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, lines.join('\n'));
             return true;
         });
         this.registerCommand('status', async (envelope) => {
             // For a shared session, gate it to authorized senders like /who — /status
             // reports session & access state, so non-members shouldn't read it either.
             if (!this.isAuthorizedForSharedSession(envelope)) {
-                await this.sendMessage(envelope.chatId, 'Only authorized members can view this shared session.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Only authorized members can view this shared session.');
                 return true;
             }
             const hasSession = this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
@@ -1781,18 +1807,18 @@ export class ChannelBase {
                     ]
                     : []),
             ];
-            await this.sendMessage(envelope.chatId, lines.join('\n'));
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, lines.join('\n'));
             return true;
         });
         this.registerCommand('loop', async (envelope, args) => this.handleLoopCommand(envelope, args));
     }
     async handleLoopCommand(envelope, args) {
         if (!this.loopController) {
-            await this.sendMessage(envelope.chatId, 'Loops are not available.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Loops are not available.');
             return true;
         }
         if (!this.isAuthorizedForSharedSession(envelope)) {
-            await this.sendMessage(envelope.chatId, 'Only authorized members can use loops in this shared session.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Only authorized members can use loops in this shared session.');
             return true;
         }
         const [subcommand = '', ...rest] = args.trim().split(/\s+/u);
@@ -1806,7 +1832,7 @@ export class ChannelBase {
             case 'cancel':
                 return this.handleLoopCancel(envelope, rest[0]);
             default:
-                await this.sendMessage(envelope.chatId, 'Usage: /loop add "<cron>" <prompt> | /loop list | /loop inspect <id> | /loop cancel <id>');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Usage: /loop add "<cron>" <prompt> | /loop list | /loop inspect <id> | /loop cancel <id>');
                 return true;
         }
     }
@@ -1814,33 +1840,33 @@ export class ChannelBase {
         if (!this.loopController)
             return true;
         if (!this.supportsProactiveSend()) {
-            await this.sendMessage(envelope.chatId, 'This channel does not support proactive loop messages.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'This channel does not support proactive loop messages.');
             return true;
         }
         if (this.config.sessionScope === 'single') {
-            await this.sendMessage(envelope.chatId, 'Loops are not supported when sessionScope is single.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Loops are not supported when sessionScope is single.');
             return true;
         }
         const parsed = parseLoopAddArgs(args);
         if (!parsed) {
-            await this.sendMessage(envelope.chatId, 'Usage: /loop add "<cron>" <prompt>');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Usage: /loop add "<cron>" <prompt>');
             return true;
         }
         try {
             this.loopController.validateCron(parsed.cron);
         }
         catch (err) {
-            await this.sendMessage(envelope.chatId, `Invalid cron expression: ${err instanceof Error ? err.message : String(err)}`);
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Invalid cron expression: ${err instanceof Error ? err.message : String(err)}`);
             return true;
         }
         const target = this.loopTargetFromEnvelope(envelope);
         if (!this.supportsProactiveTarget(target)) {
-            await this.sendMessage(envelope.chatId, 'This channel does not support proactive loop messages for this chat target.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'This channel does not support proactive loop messages for this chat target.');
             return true;
         }
         const prompt = sanitizePromptText(parsed.prompt.trim());
         if (Array.from(prompt).length > MAX_LOOP_PROMPT_CHARS) {
-            await this.sendMessage(envelope.chatId, `Loop prompt is too long; keep it under ${MAX_LOOP_PROMPT_CHARS} characters.`);
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Loop prompt is too long; keep it under ${MAX_LOOP_PROMPT_CHARS} characters.`);
             return true;
         }
         const input = {
@@ -1865,10 +1891,10 @@ export class ChannelBase {
             }
         }
         if (!job) {
-            await this.sendMessage(envelope.chatId, `Too many loops for this chat. Cancel an existing loop before adding another.`);
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Too many loops for this chat. Cancel an existing loop before adding another.`);
             return true;
         }
-        await this.sendMessage(envelope.chatId, `Loop ${job.id}: ${job.cron}`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Loop ${job.id}: ${job.cron}`);
         return true;
     }
     async createLoopFromTool(sessionId, input) {
@@ -1975,23 +2001,23 @@ export class ChannelBase {
             return true;
         const jobs = await this.loopController.listForTarget(this.name, this.loopTargetFromEnvelope(envelope));
         if (jobs.length === 0) {
-            await this.sendMessage(envelope.chatId, 'No loops.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No loops.');
             return true;
         }
-        await this.sendMessage(envelope.chatId, jobs.map((job) => this.formatLoopListLine(job)).join('\n'));
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, jobs.map((job) => this.formatLoopListLine(job)).join('\n'));
         return true;
     }
     async handleLoopInspect(envelope, id) {
         if (!this.loopController)
             return true;
         if (!id) {
-            await this.sendMessage(envelope.chatId, 'Usage: /loop inspect <id>');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Usage: /loop inspect <id>');
             return true;
         }
         const jobs = await this.loopController.listForTarget(this.name, this.loopTargetFromEnvelope(envelope));
         const job = jobs.find((candidate) => candidate.id === id);
         if (!job) {
-            await this.sendMessage(envelope.chatId, `No loop ${id}.`);
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `No loop ${id}.`);
             return true;
         }
         const lines = [
@@ -2013,7 +2039,7 @@ export class ChannelBase {
             lines.push(`Last result: ${job.lastResultPreview}`);
         }
         lines.push(`Prompt: ${job.prompt}`);
-        await this.sendMessage(envelope.chatId, lines.join('\n'));
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, lines.join('\n'));
         return true;
     }
     formatLoopListLine(job) {
@@ -2046,17 +2072,17 @@ export class ChannelBase {
         if (!this.loopController)
             return true;
         if (!id) {
-            await this.sendMessage(envelope.chatId, 'Usage: /loop cancel <id>');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Usage: /loop cancel <id>');
             return true;
         }
         const jobs = await this.loopController.listForTarget(this.name, this.loopTargetFromEnvelope(envelope));
         const match = jobs.find((job) => job.id === id);
         if (!match) {
-            await this.sendMessage(envelope.chatId, `No loop ${id}.`);
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `No loop ${id}.`);
             return true;
         }
         const disabled = await this.loopController.disable(id);
-        await this.sendMessage(envelope.chatId, disabled ? `Cancelled loop ${id}.` : `Failed to cancel loop ${id}.`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, disabled ? `Cancelled loop ${id}.` : `Failed to cancel loop ${id}.`);
         return true;
     }
     loopTargetFromEnvelope(envelope) {
@@ -2191,7 +2217,7 @@ export class ChannelBase {
     }
     async getChannelMemory(envelope) {
         if (!this.channelMemory) {
-            await this.sendMessage(envelope.chatId, 'Channel memory is not configured for this channel.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Channel memory is not configured for this channel.');
             return undefined;
         }
         return this.channelMemory;
@@ -2211,7 +2237,7 @@ export class ChannelBase {
     }
     async handleChannelMemoryIntent(envelope, intent, options = {}) {
         if (intent.kind === 'no_match') {
-            await this.sendMessage(envelope.chatId, 'No matching channel memory entry.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No matching channel memory entry.');
             return;
         }
         if (intent.kind === 'ambiguous') {
@@ -2224,11 +2250,11 @@ export class ChannelBase {
             }
             catch (error) {
                 this.logChannelMemoryError('read', envelope, this.channelMemoryErrorMessage(error));
-                await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
                 return;
             }
             const selected = this.entriesForChannelMemoryIds(entries, intent.ids);
-            await this.sendMessage(envelope.chatId, [
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, [
                 'Multiple channel memory entries match:',
                 ...this.renderChannelMemoryCandidates(selected),
             ].join('\n'));
@@ -2244,11 +2270,11 @@ export class ChannelBase {
             }
             catch (error) {
                 this.logChannelMemoryError('read', envelope, this.channelMemoryErrorMessage(error));
-                await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
                 return;
             }
             const selected = this.entriesForChannelMemoryIds(entries, intent.ids);
-            await this.sendMessage(envelope.chatId, [
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, [
                 'Channel memory (page 1/1):',
                 ...this.renderChannelMemoryCandidates(selected),
             ].join('\n'));
@@ -2263,7 +2289,7 @@ export class ChannelBase {
                 ? this.takePendingChannelMemoryMutation(envelope, 'update')
                 : this.takePendingChannelMemoryMutation(envelope, 'remove');
             if (!pending) {
-                await this.sendMessage(envelope.chatId, intent.kind === 'update_confirm'
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, intent.kind === 'update_confirm'
                     ? 'No pending channel memory update. Start a new update request first.'
                     : 'No pending channel memory removal. Start a new removal request first.');
                 return;
@@ -2291,17 +2317,17 @@ export class ChannelBase {
             catch (error) {
                 const message = this.channelMemoryErrorMessage(error);
                 this.logChannelMemoryError(isUpdate ? 'update' : 'remove', envelope, message);
-                await this.sendMessage(envelope.chatId, message === 'Channel memory entry changed'
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, message === 'Channel memory entry changed'
                     ? 'That channel memory entry changed since it was selected. View channel memory and start the operation again.'
                     : `Failed to ${isUpdate ? 'update' : 'remove'} channel memory: ${this.channelMemoryUserErrorMessage()}`);
                 return;
             }
             if (!changed) {
-                await this.sendMessage(envelope.chatId, `No channel memory entry ${pending.id}.`);
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, `No channel memory entry ${pending.id}.`);
                 return;
             }
             this.invalidateUnattendedMemory(envelope);
-            await this.sendMessage(envelope.chatId, `Channel memory ${pending.id} ${isUpdate ? 'updated' : 'removed'}.`);
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Channel memory ${pending.id} ${isUpdate ? 'updated' : 'removed'}.`);
             return;
         }
         if (intent.kind === 'natural_update') {
@@ -2342,7 +2368,7 @@ export class ChannelBase {
             catch (error) {
                 const message = this.channelMemoryErrorMessage(error);
                 this.logChannelMemoryError('save', envelope, message);
-                await this.sendMessage(envelope.chatId, `Failed to save channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to save channel memory: ${this.channelMemoryUserErrorMessage()}`);
                 return;
             }
             if (result.changed) {
@@ -2357,17 +2383,17 @@ export class ChannelBase {
             }
             if (result.added.length > 0) {
                 const ids = result.added.map((entry) => entry.id);
-                await this.sendMessage(envelope.chatId, result.duplicateIds.length > 0
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, result.duplicateIds.length > 0
                     ? `Channel memory saved: ${ids.join(', ')}. Skipped duplicates: ${result.duplicateIds.join(', ')}.`
                     : ids.length === 1
                         ? `Channel memory ${ids[0]} saved.`
                         : `Channel memory saved: ${ids.join(', ')}.`);
             }
             else if (result.duplicateIds.length > 0) {
-                await this.sendMessage(envelope.chatId, `Channel memory already contains ${result.duplicateIds.join(', ')}.`);
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Channel memory already contains ${result.duplicateIds.join(', ')}.`);
             }
             else {
-                await this.sendMessage(envelope.chatId, 'Channel memory updated.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Channel memory updated.');
             }
             return;
         }
@@ -2379,30 +2405,30 @@ export class ChannelBase {
             catch (error) {
                 const message = this.channelMemoryErrorMessage(error);
                 this.logChannelMemoryError('read', envelope, message);
-                await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
                 return;
             }
             if (intent.kind === 'inspect') {
                 const entry = entries.find((candidate) => candidate.id === intent.id);
-                await this.sendMessage(envelope.chatId, entry
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, entry
                     ? `Channel memory ${entry.id}:\n${sanitizePromptText(entry.text).trim()}`
                     : `No channel memory entry ${intent.id}.`);
                 return;
             }
             const totalPages = Math.max(1, Math.ceil(entries.length / CHANNEL_MEMORY_PAGE_SIZE));
             if (intent.page > totalPages) {
-                await this.sendMessage(envelope.chatId, `Channel memory page ${intent.page} does not exist.`);
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Channel memory page ${intent.page} does not exist.`);
                 return;
             }
             if (entries.length === 0) {
-                await this.sendMessage(envelope.chatId, 'No channel memory saved.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No channel memory saved.');
                 return;
             }
             const pageStart = (intent.page - 1) * CHANNEL_MEMORY_PAGE_SIZE;
             const lines = entries
                 .slice(pageStart, pageStart + CHANNEL_MEMORY_PAGE_SIZE)
                 .map((entry) => this.renderChannelMemoryCandidate(entry));
-            await this.sendMessage(envelope.chatId, [`Channel memory (page ${intent.page}/${totalPages}):`, ...lines].join('\n'));
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, [`Channel memory (page ${intent.page}/${totalPages}):`, ...lines].join('\n'));
             return;
         }
         if (intent.kind === 'update' || intent.kind === 'remove') {
@@ -2420,21 +2446,21 @@ export class ChannelBase {
             catch (error) {
                 const message = this.channelMemoryErrorMessage(error);
                 this.logChannelMemoryError(isUpdate ? 'update' : 'remove', envelope, message);
-                await this.sendMessage(envelope.chatId, `Failed to ${isUpdate ? 'update' : 'remove'} channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to ${isUpdate ? 'update' : 'remove'} channel memory: ${this.channelMemoryUserErrorMessage()}`);
                 return;
             }
             if (!changed) {
-                await this.sendMessage(envelope.chatId, `No channel memory entry ${id}.`);
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, `No channel memory entry ${id}.`);
                 return;
             }
             this.invalidateUnattendedMemory(envelope);
-            await this.sendMessage(envelope.chatId, `Channel memory ${id} ${isUpdate ? 'updated' : 'removed'}.`);
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Channel memory ${id} ${isUpdate ? 'updated' : 'removed'}.`);
             return;
         }
         if (intent.kind === 'clear_confirm') {
             const pending = this.takePendingChannelMemoryMutation(envelope, 'clear');
             if (!pending) {
-                await this.sendMessage(envelope.chatId, 'No pending clear request. Say "清空记忆" first.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No pending clear request. Say "清空记忆" first.');
                 return;
             }
             let result;
@@ -2444,13 +2470,13 @@ export class ChannelBase {
             catch (error) {
                 const message = this.channelMemoryErrorMessage(error);
                 this.logChannelMemoryError('clear', envelope, message);
-                await this.sendMessage(envelope.chatId, `Failed to clear channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to clear channel memory: ${this.channelMemoryUserErrorMessage()}`);
                 return;
             }
             if (result.changed) {
                 this.invalidateUnattendedMemory(envelope);
             }
-            await this.sendMessage(envelope.chatId, result.changed ? 'Channel memory cleared.' : 'No channel memory saved.');
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, result.changed ? 'Channel memory cleared.' : 'No channel memory saved.');
             return;
         }
         const unhandled = intent;
@@ -2482,7 +2508,7 @@ export class ChannelBase {
         const key = this.channelMemoryPendingKey(envelope);
         this.pendingChannelMemoryMutationDeliveries.set(key, mutation);
         try {
-            await this.sendMessage(envelope.chatId, message);
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, message);
         }
         catch (error) {
             if (this.pendingChannelMemoryMutationDeliveries.get(key) === mutation) {
@@ -2655,15 +2681,18 @@ export class ChannelBase {
      * Whether the resolved session is SHARED across senders. `single` collapses
      * the whole channel to one `__single__` session for EVERY sender — group OR
      * DM — so it is ALWAYS shared (even a DM maps to `__single__`). `thread` is
-     * shared only in a group (a DM maps to the lone caller's own chat). `user` is
-     * per-sender, never shared. Drives both the destructive-/clear confirm gate
-     * and the host-shell (`!`) gate.
+     * shared only in a group (a DM maps to the lone caller's own chat).
+     * `chat_thread` is always shared: it scopes by chat+thread, and a thread
+     * (issue/PR discussion) can carry multiple participants even outside a
+     * group. `user` is per-sender, never shared. Drives both the
+     * destructive-/clear confirm gate and the host-shell (`!`) gate.
      */
     isSharedSession(envelope) {
         return this.isSharedSessionTarget(envelope);
     }
     isSharedSessionTarget(target) {
         return (this.config.sessionScope === 'single' ||
+            this.config.sessionScope === 'chat_thread' ||
             (target.isGroup === true && this.config.sessionScope === 'thread'));
     }
     /**
@@ -2962,7 +2991,7 @@ export class ChannelBase {
         if (!result.allowed) {
             if (result.pairingCode !== undefined) {
                 this.logPreflightRejected('sender_pairing_required');
-                return this.onPairingRequired(envelope.chatId, result.pairingCode)
+                return this.onPairingRequired(envelope.chatId, result.pairingCode, envelope.threadId)
                     .then(() => false)
                     .catch((err) => {
                     process.stderr.write(`[Channel:${this.name}] pairing notification failed: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}\n`);
@@ -3103,13 +3132,13 @@ export class ChannelBase {
                 process.stderr.write(`[${this.name}] blocked ! shell command from ${who} (sender ${envelope.senderId}) in chat ${sanitizeLogText(envelope.chatId, 64)}\n`);
             }
             if (envelope.isGroup) {
-                await this.sendMessage(envelope.chatId, 'Shell commands (`!`) are disabled in group chats.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Shell commands (`!`) are disabled in group chats.');
                 return;
             }
             // A single-scope DM collapses every DM to one channel-wide session, so it
             // is multi-operator too despite not being a group.
             if (this.isSharedSession(envelope)) {
-                await this.sendMessage(envelope.chatId, 'Shell commands (`!`) are disabled in shared sessions.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Shell commands (`!`) are disabled in shared sessions.');
                 return;
             }
         }
@@ -3131,10 +3160,10 @@ export class ChannelBase {
                     const exitLine = result.exitCode !== null && result.exitCode !== 0
                         ? `\nExit code: ${result.exitCode}`
                         : '';
-                    await this.sendMessage(envelope.chatId, `$ ${cmd}\n${output}${exitLine}`);
+                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, `$ ${cmd}\n${output}${exitLine}`);
                 }
                 catch (error) {
-                    await this.sendMessage(envelope.chatId, `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)}`);
                 }
                 return;
             }
@@ -3212,6 +3241,9 @@ export class ChannelBase {
                 promptText = promptText + '\n\n' + filePaths.join('\n');
             }
         }
+        if (envelope.metadata) {
+            promptText = promptText + '\n\n' + sanitizePromptText(envelope.metadata);
+        }
         // Resolve dispatch mode: per-group override → channel config → default
         const groupCfg = envelope.isGroup
             ? this.config.groups[envelope.chatId] || this.config.groups['*']
@@ -3628,6 +3660,7 @@ export class ChannelBase {
                         // Clear attachments/references — already resolved in original text
                         referencedText: undefined,
                         attachments: undefined,
+                        metadata: undefined,
                         imageBase64: undefined,
                         imageMimeType: undefined,
                     };
@@ -3643,12 +3676,12 @@ export class ChannelBase {
         this.sessionQueues.set(sessionId, current.catch(() => { }));
         await current;
     }
-    async onPairingRequired(chatId, code) {
+    async onPairingRequired(chatId, code, threadId) {
         if (code) {
-            await this.sendMessage(chatId, `Your pairing code is: ${code}\n\nAsk the bot operator to approve you with:\n  qwen channel pairing approve ${this.name} ${code}`);
+            await this.sendThreadMessage(chatId, threadId, `Your pairing code is: ${code}\n\nAsk the bot operator to approve you with:\n  qwen channel pairing approve ${this.name} ${code}`);
         }
         else {
-            await this.sendMessage(chatId, 'Too many pending pairing requests. Please try again later.');
+            await this.sendThreadMessage(chatId, threadId, 'Too many pending pairing requests. Please try again later.');
         }
     }
 }