@qwen-code/channel-base 0.19.6 → 0.19.7

package/dist/ChannelBase.js

@@ -6,8 +6,9 @@ import { SenderGate } from './SenderGate.js';
 import { PairingStore } from './PairingStore.js';
 import { SessionRouter } from './SessionRouter.js';
 import { getGlobalQwenDir } from './paths.js';
-import { sanitizeSenderName, sanitizeQuotedText, sanitizePromptText, sanitizePromptPath, sanitizeLogText, } from './sanitize.js';
+import { sanitizeSenderName, sanitizeQuotedText, sanitizePromptText, sanitizePromptPath, sanitizeLogText, PROMPT_UNSAFE_INVISIBLES, } from './sanitize.js';
 import { ChannelLoopSkippedError } from './ChannelLoopScheduler.js';
+import { parseChannelMemoryIntent, } from './channel-memory-intent.js';
 /**
  * Max time /clear waits for a cancelled in-flight turn to wind down before
  * purging anyway. A wedged ACP child (stuck tool call, not reading stdin, or
@@ -22,6 +23,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;
+const CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE = 0.7;
+const CHANNEL_MEMORY_CLASSIFIER_TRIGGER_RE = /(记住|记得|记一下|记忆|忘掉|忘记|清空|清除|删除|保存|remember|memory|forget)/iu;
 /** Sentinel message for the loop-prompt timeout rejection; matched by identity below. */
 const LOOP_TIMED_OUT_MESSAGE = 'loop timed out';
 /**
@@ -59,6 +62,7 @@ export class ChannelBase {
     /** Resolved proxy URL, available to subclasses for adapter-specific clients. */
     proxy;
     channelMemory;
+    memoryIntentClassifier;
     groupHistory;
     loopController;
     instructedSessions = new Set();
@@ -72,16 +76,24 @@ export class ChannelBase {
      * so a cleared session can't be resurrected by an already-queued prompt.
      */
     sessionGenerations = new Map();
+    pendingClears = new Map();
     /** Per-session active prompt tracking for dispatch modes. */
     activePrompts = new Map();
     /** Per-session message buffer for collect mode. */
     collectBuffers = new Map();
+    preflightedEnvelopes = new WeakSet();
     bridgeToolCallListener = (event) => {
         this.dispatchToolCall(event);
     };
     bridgeSessionDiedListener = (event) => {
         this.onSessionDied(event.sessionId);
     };
+    channelLoopToolHandler = {
+        canHandle: (sessionId) => this.router.getTarget(sessionId)?.channelName === this.name,
+        create: (sessionId, input) => this.createLoopFromTool(sessionId, input),
+        list: (sessionId) => this.listLoopsFromTool(sessionId),
+        cancel: (sessionId, id) => this.cancelLoopFromTool(sessionId, id),
+    };
     dispatchToolCall(event) {
         const target = this.router.getTarget(event.sessionId);
         const active = this.activePrompts.get(event.sessionId);
@@ -115,6 +127,7 @@ export class ChannelBase {
         this.identity = Object.freeze(this.resolveIdentity(name, config));
         this.memoryScope = Object.freeze(this.resolveMemoryScope(name, config));
         this.channelMemory = options?.channelMemory;
+        this.memoryIntentClassifier = options?.memoryIntentClassifier;
         this.groupHistory = new GroupHistoryStore(options?.groupHistoryPath ??
             join(getGlobalQwenDir(), 'channels', `${encodeURIComponent(name)}-group-history.jsonl`));
         this.loopController = options?.loopController;
@@ -125,6 +138,9 @@ export class ChannelBase {
             options?.router ||
                 new SessionRouter(bridge, config.cwd, config.sessionScope);
         this.registerSharedCommands();
+        if (this.loopController) {
+            bridge.registerChannelLoopToolHandler?.(this.channelLoopToolHandler);
+        }
         // When running standalone, register bridge listeners directly.
         // In gateway mode, the ChannelManager dispatches events instead.
         this.registerBridgeEvents =
@@ -247,6 +263,9 @@ export class ChannelBase {
         }
         this.router.setBridge(bridge);
         this.bridge = bridge;
+        if (this.loopController) {
+            bridge.registerChannelLoopToolHandler?.(this.channelLoopToolHandler);
+        }
         if (this.registerBridgeEvents) {
             this.attachBridgeEvents(bridge);
         }
@@ -269,7 +288,7 @@ export class ChannelBase {
             await this.loopController?.disable(job.id);
             throw new Error(`Loop ${job.id} target is no longer authorized.`);
         }
-        const sessionId = await this.router.resolve(this.name, job.target.senderId, job.target.chatId, job.target.threadId, job.cwd);
+        const sessionId = await this.router.resolve(this.name, job.target.senderId, job.target.chatId, job.target.threadId, job.cwd, job.target.isGroup);
         const label = sanitizeQuotedText(job.label || job.id, 80);
         const createdBy = sanitizeSenderName(job.createdBy || 'unknown');
         // Without the delivery-contract sentence the model treats "post X" prompts
@@ -342,6 +361,8 @@ export class ChannelBase {
                 resolve: doneResolve,
                 chatId: job.target.chatId,
                 messageId: job.id,
+                senderId: job.target.senderId,
+                senderName: job.createdBy,
                 loopPrompt: true,
             };
             this.activePrompts.set(sessionId, promptState);
@@ -473,6 +494,7 @@ export class ChannelBase {
                     const lost = buffer.length;
                     const coalesced = buffer.map((b) => b.text).join('\n\n');
                     const lastEnvelope = buffer[buffer.length - 1].envelope;
+                    this.notifyPromptBufferDrained(lastEnvelope.chatId, sessionId, buffer);
                     const syntheticEnvelope = {
                         ...lastEnvelope,
                         text: coalesced,
@@ -482,7 +504,8 @@ export class ChannelBase {
                         imageBase64: undefined,
                         imageMimeType: undefined,
                     };
-                    this.handleInbound(syntheticEnvelope).catch((err) => {
+                    this.markPreflighted(syntheticEnvelope);
+                    this.processInbound(syntheticEnvelope).catch((err) => {
                         process.stderr.write(`[${this.name}] dropped ${lost} buffered message(s) after loop ${job.id} for session ${sessionId} (last sender ${lastEnvelope.senderId}): ${err instanceof Error ? err.message : String(err)}\n`);
                     });
                 }
@@ -581,11 +604,41 @@ export class ChannelBase {
             }
             active.cancelled = true;
             this.stopActiveStreaming(active, sessionId, reason);
-            this.collectBuffers.delete(sessionId);
+            this.dropCollectBuffer(sessionId);
             this.emitTaskCancellation(active, sessionId, reason);
             return true;
         });
     }
+    dropCollectBuffer(sessionId) {
+        const buffer = this.collectBuffers.get(sessionId);
+        if (!buffer)
+            return;
+        this.collectBuffers.delete(sessionId);
+        const chatId = buffer[0]?.envelope.chatId ?? '';
+        const messageIds = this.collectBufferMessageIds(buffer);
+        try {
+            this.onPromptBufferDropped(chatId, sessionId, messageIds);
+        }
+        catch (err) {
+            process.stderr.write(`[${this.name}] onPromptBufferDropped threw for session ${sessionId}: ${err instanceof Error ? err.message : err}\n`);
+        }
+    }
+    notifyPromptBufferDrained(chatId, sessionId, buffer) {
+        const messageIds = this.collectBufferMessageIds(buffer);
+        if (messageIds.length === 0)
+            return;
+        try {
+            this.onPromptBufferDrained(chatId, sessionId, messageIds);
+        }
+        catch (err) {
+            process.stderr.write(`[${this.name}] onPromptBufferDrained threw for session ${sessionId}: ${err instanceof Error ? err.message : err}\n`);
+        }
+    }
+    collectBufferMessageIds(buffer) {
+        return buffer
+            .map((entry) => entry.envelope.messageId)
+            .filter((id) => typeof id === 'string' && id.length > 0);
+    }
     logCancelSessionFailure(sessionId, err) {
         process.stderr.write(`[${sanitizeLogText(this.name, 64)}] cancelSession failed for session=${sanitizeLogText(sessionId, 64)}: ${this.lifecycleError(err)}\n`);
     }
@@ -629,6 +682,9 @@ export class ChannelBase {
      * Not called for buffered messages (collect mode) or gated/blocked messages.
      */
     onPromptStart(_chatId, _sessionId, _messageId) { }
+    onPromptBuffered(_chatId, _sessionId, _messageId) { }
+    onPromptBufferDrained(_chatId, _sessionId, _messageIds) { }
+    onPromptBufferDropped(_chatId, _sessionId, _messageIds) { }
     /**
      * Called when a prompt finishes (response sent or cancelled).
      * Override to hide the working indicator.
@@ -708,7 +764,7 @@ export class ChannelBase {
                     // purging, so a running prompt can't deliver a stale response into —
                     // or resurrect via collect-drain — the just-cleared session.
                     const active = this.activePrompts.get(id);
-                    this.collectBuffers.delete(id);
+                    this.dropCollectBuffer(id);
                     if (active) {
                         // Bounded cancel + wind-down wait; purge regardless of the result.
                         const settled = await this.cancelAndAwaitActive(active, id);
@@ -802,6 +858,37 @@ export class ChannelBase {
         this.registerCommand('clear', clearHandler);
         this.registerCommand('reset', clearHandler);
         this.registerCommand('new', clearHandler);
+        this.registerCommand('remember-channel', async (envelope, args) => {
+            const text = args.trim();
+            if (text === '') {
+                await this.sendMessage(envelope.chatId, 'Usage: /remember-channel <text>');
+                return true;
+            }
+            await this.handleChannelMemoryIntent(envelope, {
+                kind: 'remember',
+                text,
+            });
+            return true;
+        });
+        this.registerCommand('channel-memory', async (envelope) => {
+            await this.handleChannelMemoryIntent(envelope, { kind: 'list' });
+            return true;
+        });
+        this.registerCommand('forget-channel', async (envelope, args) => {
+            if (!(await this.ensureChannelMemoryAuthorized(envelope))) {
+                return true;
+            }
+            if (envelope.isGroup) {
+                await this.sendMessage(envelope.chatId, 'Channel memory cannot be changed in group chats.');
+                return true;
+            }
+            if (args.toLowerCase() !== 'confirm') {
+                await this.sendMessage(envelope.chatId, 'This clears channel memory for this chat. Re-send with "confirm" (e.g. /forget-channel confirm) to proceed.');
+                return true;
+            }
+            await this.handleChannelMemoryIntent(envelope, { kind: 'clear_confirm' }, { skipPendingClear: true });
+            return true;
+        });
         // Read-only: report the current (possibly group-shared) session and workspace.
         // For a shared session, gate it to authorized senders like /clear — /who
         // leaks the workspace basename, so non-members shouldn't see it either.
@@ -840,90 +927,6 @@ export class ChannelBase {
             ].join('\n'));
             return true;
         });
-        this.registerCommand('remember-channel', async (envelope, args) => {
-            if (!(await this.ensureChannelMemoryAuthorized(envelope))) {
-                return true;
-            }
-            if (envelope.isGroup) {
-                await this.sendMessage(envelope.chatId, 'Channel memory cannot be changed in group chats.');
-                return true;
-            }
-            if (args.trim() === '') {
-                await this.sendMessage(envelope.chatId, 'Usage: /remember-channel <text>');
-                return true;
-            }
-            const channelMemory = await this.getChannelMemory(envelope);
-            if (!channelMemory) {
-                return true;
-            }
-            try {
-                await channelMemory.appendChannelMemory(this.channelMemoryTarget(envelope), args.trim());
-            }
-            catch (error) {
-                const message = this.channelMemoryErrorMessage(error);
-                this.logChannelMemoryError('save', envelope, message);
-                await this.sendMessage(envelope.chatId, `Failed to save channel memory: ${this.channelMemoryUserErrorMessage()}`);
-                return true;
-            }
-            this.invalidateSessionContext(envelope);
-            await this.sendMessage(envelope.chatId, 'Channel memory updated.');
-            return true;
-        });
-        this.registerCommand('channel-memory', async (envelope) => {
-            if (!(await this.ensureChannelMemoryAuthorized(envelope))) {
-                return true;
-            }
-            if (envelope.isGroup) {
-                await this.sendMessage(envelope.chatId, 'Channel memory cannot be shown in group chats.');
-                return true;
-            }
-            const channelMemory = await this.getChannelMemory(envelope);
-            if (!channelMemory) {
-                return true;
-            }
-            let text;
-            try {
-                text = (await channelMemory.readChannelMemory(this.channelMemoryTarget(envelope))).trim();
-            }
-            catch (error) {
-                const message = this.channelMemoryErrorMessage(error);
-                this.logChannelMemoryError('read', envelope, message);
-                await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
-                return true;
-            }
-            await this.sendMessage(envelope.chatId, text === '' ? 'No channel memory saved.' : sanitizePromptText(text));
-            return true;
-        });
-        this.registerCommand('forget-channel', async (envelope, args) => {
-            if (!(await this.ensureChannelMemoryAuthorized(envelope))) {
-                return true;
-            }
-            if (envelope.isGroup) {
-                await this.sendMessage(envelope.chatId, 'Channel memory cannot be changed in group chats.');
-                return true;
-            }
-            if (args.toLowerCase() !== 'confirm') {
-                await this.sendMessage(envelope.chatId, 'This clears channel memory for this chat. Re-send with "confirm" (e.g. /forget-channel confirm) to proceed.');
-                return true;
-            }
-            const channelMemory = await this.getChannelMemory(envelope);
-            if (!channelMemory) {
-                return true;
-            }
-            let result;
-            try {
-                result = await channelMemory.clearChannelMemory(this.channelMemoryTarget(envelope));
-            }
-            catch (error) {
-                const message = this.channelMemoryErrorMessage(error);
-                this.logChannelMemoryError('clear', envelope, message);
-                await this.sendMessage(envelope.chatId, `Failed to clear channel memory: ${this.channelMemoryUserErrorMessage()}`);
-                return true;
-            }
-            this.invalidateSessionContext(envelope);
-            await this.sendMessage(envelope.chatId, result.changed ? 'Channel memory cleared.' : 'No channel memory saved.');
-            return true;
-        });
         this.registerCommand('help', async (envelope) => {
             const lines = [
                 'Commands:',
@@ -933,9 +936,6 @@ export class ChannelBase {
                     : '/clear — Clear your session (aliases: /reset, /new)',
                 '/who — Show current session & workspace',
                 '/status — Show session info',
-                '/remember-channel <text> — Save memory for this chat',
-                '/channel-memory — Show memory for this chat',
-                '/forget-channel confirm — Clear memory for this chat',
             ];
             // Platform-specific commands (registered by adapters, not shared ones)
             const sharedCmds = new Set([
@@ -943,11 +943,11 @@ export class ChannelBase {
                 'clear',
                 'reset',
                 'new',
-                'who',
-                'status',
                 'remember-channel',
                 'channel-memory',
                 'forget-channel',
+                'who',
+                'status',
             ]);
             const platformCmds = [...this.commands.keys()].filter((c) => !sharedCmds.has(c));
             if (platformCmds.length > 0) {
@@ -1079,6 +1079,105 @@ export class ChannelBase {
         await this.sendMessage(envelope.chatId, `Loop ${job.id}: ${job.cron}`);
         return true;
     }
+    async createLoopFromTool(sessionId, input) {
+        if (!this.loopController) {
+            return { text: 'Channel loops are not configured.', isError: true };
+        }
+        if (!this.supportsProactiveSend()) {
+            return {
+                text: 'This channel does not support proactive loop messages.',
+                isError: true,
+            };
+        }
+        if (this.config.sessionScope === 'single') {
+            return {
+                text: 'Loops are not supported when sessionScope is single.',
+                isError: true,
+            };
+        }
+        const target = this.loopToolTarget(sessionId);
+        if (typeof target === 'string')
+            return { text: target, isError: true };
+        if (!this.supportsProactiveTarget(target)) {
+            return {
+                text: 'This channel does not support proactive loop messages for this chat target.',
+                isError: true,
+            };
+        }
+        const cron = input.cron.trim();
+        try {
+            this.loopController.validateCron(cron);
+        }
+        catch (err) {
+            return {
+                text: `Invalid cron expression: ${err instanceof Error ? err.message : String(err)}`,
+                isError: true,
+            };
+        }
+        const prompt = sanitizePromptText(input.prompt.trim());
+        if (Array.from(prompt).length > MAX_LOOP_PROMPT_CHARS) {
+            return {
+                text: `Loop prompt is too long; keep it under ${MAX_LOOP_PROMPT_CHARS} characters.`,
+                isError: true,
+            };
+        }
+        const loopInput = {
+            channelName: this.name,
+            target,
+            cwd: this.config.cwd,
+            cron,
+            prompt,
+            label: truncateLoopLabel(prompt),
+            recurring: input.recurring !== false,
+            createdBy: sanitizeSenderName(this.toolCallerName(sessionId, target)),
+        };
+        let job;
+        if (this.loopController.createForTarget) {
+            job = await this.loopController.createForTarget(loopInput, MAX_LOOP_JOBS_PER_TARGET);
+        }
+        else {
+            const existingJobs = await this.loopController.listForTarget(this.name, target);
+            if (existingJobs.filter((existingJob) => existingJob.enabled).length <
+                MAX_LOOP_JOBS_PER_TARGET) {
+                job = await this.loopController.create(loopInput);
+            }
+        }
+        if (!job) {
+            return {
+                text: 'Too many loops for this chat. Cancel an existing loop before adding another.',
+                isError: true,
+            };
+        }
+        return `Loop ${job.id}: ${job.cron}`;
+    }
+    async listLoopsFromTool(sessionId) {
+        if (!this.loopController) {
+            return { text: 'Channel loops are not configured.', isError: true };
+        }
+        const target = this.loopToolTarget(sessionId);
+        if (typeof target === 'string')
+            return { text: target, isError: true };
+        const jobs = await this.loopController.listForTarget(this.name, target);
+        if (jobs.length === 0)
+            return 'No loops.';
+        return jobs.map((job) => this.formatLoopListLine(job)).join('\n');
+    }
+    async cancelLoopFromTool(sessionId, id) {
+        if (!this.loopController) {
+            return { text: 'Channel loops are not configured.', isError: true };
+        }
+        const target = this.loopToolTarget(sessionId);
+        if (typeof target === 'string')
+            return { text: target, isError: true };
+        const jobs = await this.loopController.listForTarget(this.name, target);
+        const match = jobs.find((job) => job.id === id);
+        if (!match)
+            return { text: `No loop ${id}.`, isError: true };
+        const disabled = await this.loopController.disable(id);
+        return disabled
+            ? `Cancelled loop ${id}.`
+            : { text: `Failed to cancel loop ${id}.`, isError: true };
+    }
     async handleLoopList(envelope) {
         if (!this.loopController)
             return true;
@@ -1160,36 +1259,57 @@ export class ChannelBase {
         }
         const jobs = await this.loopController.listForTarget(this.name, this.loopTargetFromEnvelope(envelope));
         const match = jobs.find((job) => job.id === id);
-        const disabled = match ? await this.loopController.disable(id) : false;
-        await this.sendMessage(envelope.chatId, disabled ? `Cancelled loop ${id}.` : `No loop ${id}.`);
+        if (!match) {
+            await this.sendMessage(envelope.chatId, `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}.`);
         return true;
     }
     loopTargetFromEnvelope(envelope) {
-        return {
+        return this.normalizeLoopTarget({
             channelName: this.name,
             senderId: envelope.senderId,
             chatId: envelope.chatId,
             threadId: envelope.threadId,
             isGroup: envelope.isGroup === true,
-        };
+        });
     }
-    isStoredLoopTargetAuthorized(target, senderName) {
-        if (target.isGroup === undefined) {
-            return false;
+    normalizeLoopTarget(target) {
+        // Older persisted loop targets may not have isGroup; treat them as one-to-one chats.
+        return { ...target, isGroup: target.isGroup === true };
+    }
+    loopToolTarget(sessionId) {
+        const target = this.router.getTarget(sessionId);
+        if (!target || target.channelName !== this.name) {
+            return 'No channel target is bound to this session.';
+        }
+        if (!this.isAuthorizedForSharedSessionToolCall(target, sessionId)) {
+            return 'Only authorized members can use loops in this shared session.';
+        }
+        const senderId = this.activePrompts.get(sessionId)?.senderId;
+        const normalizedTarget = this.normalizeLoopTarget(target);
+        if (senderId && this.isSharedSessionTarget(normalizedTarget)) {
+            return { ...normalizedTarget, senderId };
         }
+        return normalizedTarget;
+    }
+    isStoredLoopTargetAuthorized(target, senderName) {
+        const normalizedTarget = this.normalizeLoopTarget(target);
         const envelope = {
             channelName: this.name,
-            senderId: target.senderId,
+            senderId: normalizedTarget.senderId,
             senderName,
-            chatId: target.chatId,
+            chatId: normalizedTarget.chatId,
             text: '',
-            threadId: target.threadId,
-            isGroup: target.isGroup === true,
+            threadId: normalizedTarget.threadId,
+            isGroup: normalizedTarget.isGroup,
             isMentioned: true,
             isReplyToBot: true,
         };
         return (this.groupGate.check(envelope).allowed &&
-            this.gate.isAllowed(target.senderId) &&
+            this.gate.isAllowed(normalizedTarget.senderId) &&
             this.isAuthorizedForSharedSession(envelope));
     }
     /** Check if a message text matches a registered local command. */
@@ -1254,6 +1374,125 @@ export class ChannelBase {
         }
         return this.channelMemory;
     }
+    async handleChannelMemoryIntent(envelope, intent, options = {}) {
+        if (!(await this.ensureChannelMemoryAuthorized(envelope))) {
+            return;
+        }
+        if (envelope.isGroup && intent.kind !== 'list') {
+            await this.sendMessage(envelope.chatId, 'Channel memory cannot be changed in group chats.');
+            return;
+        }
+        if (intent.kind === 'clear_request') {
+            this.setPendingClear(this.clearPendingKey(envelope));
+            await this.sendMessage(envelope.chatId, 'This clears channel memory for this chat. Say "确认清空记忆" or "confirm clear memory" to proceed.');
+            return;
+        }
+        const channelMemory = await this.getChannelMemory(envelope);
+        if (!channelMemory) {
+            return;
+        }
+        if (intent.kind === 'remember') {
+            try {
+                await channelMemory.appendChannelMemory(this.channelMemoryTarget(envelope), intent.text);
+            }
+            catch (error) {
+                const message = this.channelMemoryErrorMessage(error);
+                this.logChannelMemoryError('save', envelope, message);
+                await this.sendMessage(envelope.chatId, `Failed to save channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                return;
+            }
+            this.invalidateSessionContext(envelope);
+            await this.sendMessage(envelope.chatId, 'Channel memory updated.');
+            return;
+        }
+        if (intent.kind === 'list') {
+            let text;
+            try {
+                text = (await channelMemory.readChannelMemory(this.channelMemoryTarget(envelope))).trim();
+            }
+            catch (error) {
+                const message = this.channelMemoryErrorMessage(error);
+                this.logChannelMemoryError('read', envelope, message);
+                await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                return;
+            }
+            await this.sendMessage(envelope.chatId, text === '' ? 'No channel memory saved.' : sanitizePromptText(text));
+            return;
+        }
+        if (intent.kind === 'clear_confirm') {
+            if (!options.skipPendingClear) {
+                const pendingKey = this.clearPendingKey(envelope);
+                const expiresAt = this.pendingClears.get(pendingKey);
+                this.pendingClears.delete(pendingKey);
+                if (expiresAt === undefined || expiresAt < Date.now()) {
+                    await this.sendMessage(envelope.chatId, 'No pending clear request. Say "清空记忆" first.');
+                    return;
+                }
+            }
+            let result;
+            try {
+                result = await channelMemory.clearChannelMemory(this.channelMemoryTarget(envelope));
+            }
+            catch (error) {
+                const message = this.channelMemoryErrorMessage(error);
+                this.logChannelMemoryError('clear', envelope, message);
+                await this.sendMessage(envelope.chatId, `Failed to clear channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                return;
+            }
+            this.invalidateSessionContext(envelope);
+            await this.sendMessage(envelope.chatId, result.changed ? 'Channel memory cleared.' : 'No channel memory saved.');
+            return;
+        }
+        const unhandled = intent;
+        throw new Error(`Unhandled channel memory intent: ${JSON.stringify(unhandled)}`);
+    }
+    shouldClassifyChannelMemoryIntent(text) {
+        const normalized = text.replace(PROMPT_UNSAFE_INVISIBLES, '').trim();
+        return (this.channelMemory !== undefined &&
+            this.memoryIntentClassifier !== undefined &&
+            !normalized.startsWith('/') &&
+            CHANNEL_MEMORY_CLASSIFIER_TRIGGER_RE.test(normalized));
+    }
+    clearPendingKey(envelope) {
+        return `${this.name}:${envelope.chatId}:${envelope.threadId ?? ''}:${envelope.senderId ?? ''}`;
+    }
+    setPendingClear(key) {
+        const now = Date.now();
+        for (const [pendingKey, expiresAt] of this.pendingClears) {
+            if (expiresAt < now) {
+                this.pendingClears.delete(pendingKey);
+            }
+        }
+        this.pendingClears.set(key, now + 60_000);
+    }
+    async classifyChannelMemoryIntent(text) {
+        if (!this.memoryIntentClassifier) {
+            return null;
+        }
+        let classified;
+        try {
+            classified =
+                await this.memoryIntentClassifier.classifyChannelMemoryIntent(text);
+        }
+        catch (error) {
+            process.stderr.write(`[${this.name}] channel memory intent classifier failed: ${sanitizeLogText(this.channelMemoryErrorMessage(error), 200)}\n`);
+            return null;
+        }
+        if (classified.confidence < CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE) {
+            return null;
+        }
+        if (classified.intent === 'remember') {
+            const memory = classified.memory?.trim();
+            return memory ? { kind: 'remember', text: memory } : null;
+        }
+        if (classified.intent === 'list') {
+            return { kind: 'list' };
+        }
+        if (classified.intent === 'clear_all') {
+            return { kind: 'clear_request' };
+        }
+        return null;
+    }
     channelMemoryErrorMessage(error) {
         return error instanceof Error ? error.message : String(error);
     }
@@ -1286,10 +1525,26 @@ export class ChannelBase {
      * gate can't drift; each caller sends its own rejection wording.
      */
     isAuthorizedForSharedSession(envelope) {
-        if (!this.isSharedSession(envelope))
+        return this.isAuthorizedForSharedSessionTarget(envelope);
+    }
+    isAuthorizedForSharedSessionTarget(target) {
+        if (!this.isSharedSessionTarget(target))
             return true;
         const authorized = this.config.allowedUsers;
-        return authorized.length === 0 || authorized.includes(envelope.senderId);
+        return authorized.length === 0 || authorized.includes(target.senderId);
+    }
+    isAuthorizedForSharedSessionToolCall(target, sessionId) {
+        if (!this.isSharedSessionTarget(target))
+            return true;
+        const authorized = this.config.allowedUsers;
+        if (authorized.length === 0)
+            return true;
+        const senderId = this.activePrompts.get(sessionId)?.senderId;
+        return senderId !== undefined && authorized.includes(senderId);
+    }
+    toolCallerName(sessionId, target) {
+        const active = this.activePrompts.get(sessionId);
+        return active?.senderName || active?.senderId || target.senderId || 'agent';
     }
     stopActiveStreaming(active, sessionId, reason) {
         try {
@@ -1537,21 +1792,56 @@ export class ChannelBase {
         });
         return `${GROUP_HISTORY_CONTEXT_MARKER}\n${formatted.join('\n')}\n\n${CURRENT_MESSAGE_MARKER}\n${promptText}`;
     }
-    async handleInbound(envelope) {
-        // 1. Group gate: policy + allowlist + mention gating
+    preflightInbound(envelope) {
         const groupResult = this.groupGate.check(envelope);
         if (!groupResult.allowed) {
             if (groupResult.reason === 'mention_required') {
                 this.recordPendingGroupHistory(envelope);
             }
-            return; // silently drop — no pairing, no reply
+            return false;
         }
-        // 2. Sender gate: allowlist / pairing / open
         const result = this.gate.check(envelope.senderId, envelope.senderName);
         if (!result.allowed) {
             if (result.pairingCode !== undefined) {
-                await this.onPairingRequired(envelope.chatId, result.pairingCode);
+                return this.onPairingRequired(envelope.chatId, result.pairingCode)
+                    .then(() => false)
+                    .catch((err) => {
+                    process.stderr.write(`[Channel:${this.name}] pairing notification failed: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}\n`);
+                    return false;
+                });
             }
+            return false;
+        }
+        this.markPreflighted(envelope);
+        return true;
+    }
+    async handleInbound(envelope) {
+        const preflight = this.preflightInbound(envelope);
+        if (!(isPromiseLike(preflight) ? await preflight : preflight))
+            return;
+        await this.processInbound(envelope);
+    }
+    markPreflighted(envelope) {
+        this.preflightedEnvelopes.add(envelope);
+    }
+    /**
+     * Process an inbound message after preflight gates have passed.
+     *
+     * This method does not run group gating, sender allowlisting, or pairing
+     * checks. Callers must run preflightInbound() first unless the envelope was
+     * already preflighted, such as during collect-buffer drain.
+     */
+    async processInbound(envelope) {
+        if (!this.preflightedEnvelopes.delete(envelope)) {
+            throw new Error('processInbound called without a successful preflightInbound check.');
+        }
+        let memoryIntent = parseChannelMemoryIntent(envelope.text);
+        if (!memoryIntent &&
+            this.shouldClassifyChannelMemoryIntent(envelope.text)) {
+            memoryIntent = await this.classifyChannelMemoryIntent(envelope.text);
+        }
+        if (memoryIntent) {
+            await this.handleChannelMemoryIntent(envelope, memoryIntent);
             return;
         }
         // 3. Slash command handling — before session/agent routing
@@ -1590,7 +1880,7 @@ export class ChannelBase {
                 return;
             }
         }
-        const sessionId = await this.router.resolve(this.name, envelope.senderId, envelope.chatId, envelope.threadId, this.config.cwd);
+        const sessionId = await this.router.resolve(this.name, envelope.senderId, envelope.chatId, envelope.threadId, this.config.cwd, envelope.isGroup);
         // 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.
@@ -1713,6 +2003,12 @@ export class ChannelBase {
                         this.collectBuffers.set(sessionId, buffer);
                     }
                     buffer.push({ text: promptText, envelope });
+                    try {
+                        this.onPromptBuffered(envelope.chatId, sessionId, envelope.messageId);
+                    }
+                    catch (err) {
+                        process.stderr.write(`[${this.name}] onPromptBuffered threw for session ${sessionId}: ${err instanceof Error ? err.message : err}\n`);
+                    }
                     return;
                 }
                 case 'steer': {
@@ -1875,6 +2171,8 @@ export class ChannelBase {
                 resolve: doneResolve,
                 chatId: envelope.chatId,
                 messageId: envelope.messageId,
+                senderId: envelope.senderId,
+                senderName: envelope.senderName,
             };
             // 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
@@ -2042,6 +2340,7 @@ export class ChannelBase {
                     const lost = buffer.length;
                     const coalesced = buffer.map((b) => b.text).join('\n\n');
                     const lastEnvelope = buffer[buffer.length - 1].envelope;
+                    this.notifyPromptBufferDrained(lastEnvelope.chatId, sessionId, buffer);
                     // Re-enter handleInbound with the coalesced message
                     const syntheticEnvelope = {
                         ...lastEnvelope,
@@ -2054,9 +2353,10 @@ export class ChannelBase {
                         imageBase64: undefined,
                         imageMimeType: undefined,
                     };
+                    this.markPreflighted(syntheticEnvelope);
                     // Queue the coalesced prompt (don't await to avoid deadlock on the queue).
                     // Surface a drain failure instead of silently losing buffered turns.
-                    this.handleInbound(syntheticEnvelope).catch((err) => {
+                    this.processInbound(syntheticEnvelope).catch((err) => {
                         process.stderr.write(`[${this.name}] dropped ${lost} buffered message(s) on collect re-entry for session ${sessionId} (last sender ${lastEnvelope.senderId}): ${err instanceof Error ? err.message : String(err)}\n`);
                     });
                 }
@@ -2077,6 +2377,11 @@ export class ChannelBase {
 function truncateGroupHistoryField(value) {
     return value.slice(0, GROUP_HISTORY_ENTRY_METADATA_LIMIT);
 }
+function isPromiseLike(value) {
+    return (value !== null &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        typeof value.then === 'function');
+}
 function truncateLoopLabel(prompt) {
     const chars = Array.from(prompt);
     return chars.length > 60 ? `${chars.slice(0, 57).join('')}...` : prompt;