@qwen-code/channel-base 0.22.2-preview.1 → 0.22.3

package/dist/ChannelBase.js

@@ -8,6 +8,7 @@ import { GroupHistoryStore } from './group-history-store.js';
 import { SenderGate } from './SenderGate.js';
 import { PairingStore } from './PairingStore.js';
 import { SessionRouter } from './SessionRouter.js';
+import { NamedSessionManager, } from './named-session-manager.js';
 import { getGlobalQwenDir } from './paths.js';
 import { sanitizeSenderName, sanitizeQuotedText, sanitizePromptText, sanitizePromptPath, sanitizeLogText, sanitizeDisplayText, truncateCodePoints, PROMPT_UNSAFE_INVISIBLES, } from './sanitize.js';
 import { ChannelLoopSkippedError } from './ChannelLoopScheduler.js';
@@ -122,6 +123,7 @@ export class ChannelBase {
     groupPairingNotified = new Map();
     loopController;
     observedContacts;
+    namedSessions;
     observedContactEnvelopes = new WeakSet();
     instructedSessions = new Set();
     unattendedMemorySessions = new Set();
@@ -130,6 +132,8 @@ export class ChannelBase {
     commands = new Map();
     /** Per-session promise chain to serialize prompt + send (followup mode). */
     sessionQueues = new Map();
+    queuedTurns = new Map();
+    namedTurnBindings = new WeakMap();
     registerBridgeEvents;
     bridgeRecovery;
     /**
@@ -208,7 +212,16 @@ export class ChannelBase {
             await this.pushProactive(target, text);
             return;
         }
-        await this.sendResponseMessage(target.chatId, text, sessionId);
+        await this.deliverBackgroundReply(target.chatId, text, sessionId);
+    }
+    /**
+     * Fallback delivery of a background response when proactive send is
+     * unavailable. Adapters whose turn replies bypass sendResponseMessage (to
+     * 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 dispatchPermissionRequest(event) {
         const target = this.permissionTargetForEvent(event);
@@ -471,6 +484,21 @@ export class ChannelBase {
         this.router =
             options?.router ||
                 new SessionRouter(bridge, config.cwd, config.sessionScope);
+        if (config.multiSession) {
+            if (config.sessionScope !== 'user') {
+                throw new Error(`Channel "${name}" requires sessionScope "user" when multiSession is enabled.`);
+            }
+            if (!options?.stateDir) {
+                throw new Error(`Channel "${name}" multiSession is available only in daemon-managed mode.`);
+            }
+            this.namedSessions = new NamedSessionManager({
+                channelName: name,
+                cwd: config.cwd,
+                filePath: join(options.stateDir, 'named-sessions.json'),
+                router: this.router,
+                isBusy: (sessionId) => this.isNamedSessionBusy(sessionId),
+            });
+        }
         this.registerSharedCommands();
         if (this.loopController) {
             bridge.registerChannelLoopToolHandler?.(this.channelLoopToolHandler);
@@ -893,8 +921,11 @@ export class ChannelBase {
             imageBase64: undefined,
             imageMimeType: undefined,
         };
+        if (this.namedSessions) {
+            this.bindNamedTurn(syntheticEnvelope, sessionId);
+        }
         this.markPreflighted(syntheticEnvelope);
-        this.processInbound(syntheticEnvelope).catch((err) => {
+        void this.processPreflightedInbound(syntheticEnvelope).catch((err) => {
             process.stderr.write(`[${this.name}] dropped ${lost} buffered message(s) after ${taskLabel} for session ${sessionId} (last sender ${lastEnvelope.senderId}): ${err instanceof Error ? err.message : String(err)}\n`);
         });
     }
@@ -1630,7 +1661,9 @@ export class ChannelBase {
                 await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Only authorized members can cancel requests in this shared session.');
                 return true;
             }
-            const activeSessionId = this.findActiveSessionId(envelope);
+            const activeSessionId = this.namedSessions
+                ? await this.findNamedActiveSessionId(envelope)
+                : this.findActiveSessionId(envelope);
             if (!activeSessionId) {
                 await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No request is currently running.');
                 return true;
@@ -1900,10 +1933,221 @@ export class ChannelBase {
             : 'Permission request is no longer pending.');
         return true;
     }
+    namedSessionOwner(envelope) {
+        return {
+            senderId: envelope.senderId,
+            chatId: envelope.chatId,
+            ...(envelope.threadId !== undefined
+                ? { threadId: envelope.threadId }
+                : {}),
+            ...(envelope.isGroup !== undefined ? { isGroup: envelope.isGroup } : {}),
+        };
+    }
+    async currentSessionId(envelope) {
+        if (this.namedSessions) {
+            return (await this.namedSessions.current(this.namedSessionOwner(envelope)))?.sessionId;
+        }
+        return this.router.getSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+    }
+    reserveQueuedTurn(sessionId) {
+        this.queuedTurns.set(sessionId, (this.queuedTurns.get(sessionId) ?? 0) + 1);
+    }
+    releaseQueuedTurn(sessionId) {
+        const remaining = (this.queuedTurns.get(sessionId) ?? 1) - 1;
+        if (remaining === 0) {
+            this.queuedTurns.delete(sessionId);
+        }
+        else {
+            this.queuedTurns.set(sessionId, remaining);
+        }
+    }
+    bindNamedTurn(envelope, sessionId) {
+        const binding = {
+            sessionId,
+            generation: this.sessionGenerations.get(sessionId) ?? 0,
+            claimed: false,
+            released: false,
+        };
+        this.namedTurnBindings.set(envelope, binding);
+        this.reserveQueuedTurn(sessionId);
+        return binding;
+    }
+    releaseNamedTurnBinding(binding) {
+        if (binding.sessionId === null || binding.claimed || binding.released) {
+            return;
+        }
+        binding.released = true;
+        this.releaseQueuedTurn(binding.sessionId);
+    }
+    finishNamedTurnBinding(envelope) {
+        const binding = this.namedTurnBindings.get(envelope);
+        if (!binding)
+            return;
+        this.releaseNamedTurnBinding(binding);
+        this.namedTurnBindings.delete(envelope);
+    }
+    bypassesNamedTurnBinding(envelope) {
+        const parsed = this.parseCommand(envelope.text);
+        if (parsed && this.commands.has(parsed.command))
+            return true;
+        const bangText = envelope.text.trimStart();
+        return (bangText.startsWith('!') &&
+            (envelope.isGroup || this.isSharedSession(envelope)));
+    }
+    async prepareNamedTurnBinding(envelope) {
+        const namedSessions = this.namedSessions;
+        if (!namedSessions || this.namedTurnBindings.has(envelope))
+            return true;
+        if (this.bypassesNamedTurnBinding(envelope))
+            return true;
+        try {
+            const sessionId = await namedSessions.resolve(this.namedSessionOwner(envelope), undefined, (resolvedSessionId) => {
+                const binding = this.bindNamedTurn(envelope, resolvedSessionId);
+                return () => this.releaseNamedTurnBinding(binding);
+            });
+            if (!sessionId && !this.namedTurnBindings.has(envelope)) {
+                this.namedTurnBindings.set(envelope, {
+                    sessionId: null,
+                    generation: 0,
+                    claimed: false,
+                    released: true,
+                });
+            }
+            return true;
+        }
+        catch (error) {
+            this.finishNamedTurnBinding(envelope);
+            await this.sendNamedSessionError(envelope, error);
+            return false;
+        }
+    }
+    isNamedSessionBusy(sessionId) {
+        if ((this.queuedTurns.get(sessionId) ?? 0) > 0)
+            return true;
+        if (this.activePrompts.has(sessionId))
+            return true;
+        for (const permission of this.pendingPermissions.values()) {
+            if (permission.sessionId === sessionId)
+                return true;
+        }
+        try {
+            return (this.bridge
+                .listSessions?.()
+                .some((session) => session.sessionId === sessionId && session.hasActivePrompt) ?? false);
+        }
+        catch {
+            return true;
+        }
+    }
+    async sendNamedSessionError(envelope, error) {
+        const message = error instanceof Error
+            ? sanitizeDisplayText(error.message, 500)
+            : 'Named-session operation failed.';
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, message || 'Named-session operation failed.');
+    }
+    async handleNamedSessionsCommand(envelope, args) {
+        const namedSessions = this.namedSessions;
+        if (!namedSessions)
+            return false;
+        const normalized = args.trim().toLowerCase();
+        if (normalized !== '' && normalized !== 'all') {
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Usage: /sessions [all]');
+            return true;
+        }
+        try {
+            const tasks = await namedSessions.list(this.namedSessionOwner(envelope), normalized === 'all');
+            if (tasks.length === 0) {
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, normalized === 'all' ? 'No named tasks.' : 'No open named tasks.');
+                return true;
+            }
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, [
+                normalized === 'all' ? 'Tasks:' : 'Open tasks:',
+                ...tasks.map((task) => `${task.active ? '*' : '-'} ${task.name} (${task.status}, ${task.isolation})`),
+            ].join('\n'));
+        }
+        catch (error) {
+            await this.sendNamedSessionError(envelope, error);
+        }
+        return true;
+    }
+    async handleNamedSessionCommand(envelope, args) {
+        const namedSessions = this.namedSessions;
+        if (!namedSessions)
+            return false;
+        const parts = args.trim().split(/\s+/u).filter(Boolean);
+        const subcommand = parts.shift()?.toLowerCase() ?? '';
+        const owner = this.namedSessionOwner(envelope);
+        try {
+            switch (subcommand) {
+                case 'current': {
+                    if (parts.length > 0)
+                        break;
+                    const current = await namedSessions.current(owner);
+                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, current
+                        ? `Current task: ${current.name} (${current.isolation})`
+                        : 'No task is currently selected. Use /session new <name> or /session use <name>.');
+                    return true;
+                }
+                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>.');
+                        return true;
+                    }
+                    if (parts.length !== 1)
+                        break;
+                    const created = await namedSessions.create(owner, parts[0]);
+                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Created and selected task "${created.name}" (shared workspace).`);
+                    return true;
+                }
+                case 'use': {
+                    if (parts.length !== 1)
+                        break;
+                    const selected = await namedSessions.use(owner, parts[0]);
+                    await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Selected task "${selected.name}" (${selected.isolation} workspace).`);
+                    return true;
+                }
+                case 'close': {
+                    if (parts.length !== 1)
+                        break;
+                    const result = await namedSessions.close(owner, parts[0]);
+                    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.');
+                    return true;
+                default:
+                    break;
+            }
+        }
+        catch (error) {
+            await this.sendNamedSessionError(envelope, error);
+            return true;
+        }
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Usage: /session current | /session new <name> | /session use <name> | /session close <name> | /session cancel [<name>]');
+        return true;
+    }
     /** Register shared slash commands. Called from constructor. */
     registerSharedCommands() {
         const doClear = async (envelope) => {
-            const removedIds = this.router.removeSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+            let resetTaskName;
+            let removedIds;
+            if (this.namedSessions) {
+                try {
+                    const reset = await this.namedSessions.reset(this.namedSessionOwner(envelope));
+                    resetTaskName = reset?.name;
+                    removedIds = reset ? [reset.previousSessionId] : [];
+                }
+                catch (error) {
+                    await this.sendNamedSessionError(envelope, error);
+                    return;
+                }
+            }
+            else {
+                removedIds = this.router.removeSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+            }
             this.clearPendingGroupHistory(envelope);
             if (removedIds.length > 0) {
                 for (const id of removedIds) {
@@ -1995,7 +2239,9 @@ export class ChannelBase {
                     }
                     this.discardRetiredSession(this.bridge, id, 'cleared');
                 }
-                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Session cleared. The next message starts a fresh conversation.');
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, resetTaskName
+                    ? `Task "${resetTaskName}" reset with a fresh conversation.`
+                    : 'Session cleared. The next message starts a fresh conversation.');
             }
             else {
                 await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No active session to clear.');
@@ -2020,6 +2266,10 @@ export class ChannelBase {
         this.registerCommand('clear', clearHandler);
         this.registerCommand('reset', clearHandler);
         this.registerCommand('new', clearHandler);
+        if (this.namedSessions) {
+            this.registerCommand('sessions', (envelope, args) => this.handleNamedSessionsCommand(envelope, args));
+            this.registerCommand('session', (envelope, args) => this.handleNamedSessionCommand(envelope, args));
+        }
         this.registerCommand('approve', (envelope, args) => this.handlePermissionResponseCommand(envelope, args, 'approve'));
         this.registerCommand('approve-always', (envelope, args) => this.handlePermissionResponseCommand(envelope, args, 'approve-always'));
         this.registerCommand('deny', (envelope, args) => this.handlePermissionResponseCommand(envelope, args, 'deny'));
@@ -2031,7 +2281,9 @@ export class ChannelBase {
                 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);
+            const active = this.namedSessions
+                ? Boolean(await this.currentSessionId(envelope))
+                : this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
             // `single` collapses EVERY DM and group to one `__single__` session, so it
             // is shared channel-wide regardless of where the /who came from — report
             // that explicitly (a group `single` session understates its blast radius as
@@ -2073,6 +2325,12 @@ 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.namedSessions
+                    ? [
+                        '/sessions [all] — List your named tasks',
+                        '/session current|new|use|close — Manage your named tasks',
+                    ]
+                    : []),
             ];
             // Platform-specific commands (registered by adapters, not shared ones)
             const sharedCmds = new Set([
@@ -2088,6 +2346,8 @@ export class ChannelBase {
                 'forget-channel',
                 'who',
                 'status',
+                'sessions',
+                'session',
             ]);
             const platformCmds = [...this.commands.keys()].filter((c) => !sharedCmds.has(c));
             if (platformCmds.length > 0) {
@@ -2095,7 +2355,7 @@ export class ChannelBase {
                     lines.push(`/${cmd}`);
                 }
             }
-            const sessionId = this.router.getSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+            const sessionId = await this.currentSessionId(envelope);
             const agentCommands = sessionId
                 ? this.getAgentCommandsForSession(sessionId)
                 : this.bridge.availableCommands;
@@ -2116,7 +2376,9 @@ export class ChannelBase {
                 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);
+            const hasSession = this.namedSessions
+                ? Boolean(await this.currentSessionId(envelope))
+                : this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
             const policy = this.config.senderPolicy;
             const lines = [
                 `Session: ${hasSession ? 'active' : 'none'}`,
@@ -2466,6 +2728,12 @@ export class ChannelBase {
             ? sessionId
             : undefined;
     }
+    async findNamedActiveSessionId(envelope) {
+        const sessionId = await this.currentSessionId(envelope);
+        return sessionId && this.activePrompts.has(sessionId)
+            ? sessionId
+            : undefined;
+    }
     channelMemoryTarget(envelope) {
         return {
             channelName: this.name,
@@ -3302,9 +3570,14 @@ export class ChannelBase {
         });
         return `${GROUP_HISTORY_CONTEXT_MARKER}\n${formatted.join('\n')}\n\n${CURRENT_MESSAGE_MARKER}\n${promptText}`;
     }
-    preflightInbound(envelope) {
-        const groupResult = this.groupGate.check(envelope);
-        if (!groupResult.allowed) {
+    preflightInbound(envelope, options = {}) {
+        const groupResult = this.groupGate.check(envelope, {
+            createPairingRequest: !options.deferPairingRequests,
+        });
+        const deferredGroupPairing = options.deferPairingRequests === true &&
+            groupResult.reason === 'pairing_trigger_required' &&
+            (envelope.isMentioned || envelope.isReplyToBot);
+        if (!groupResult.allowed && !deferredGroupPairing) {
             if (groupResult.pairing !== undefined) {
                 this.logPreflightRejected('group_pairing_required');
                 return this.onGroupPairingRequired(envelope.chatId, groupResult.pairing, envelope.threadId)
@@ -3335,6 +3608,12 @@ export class ChannelBase {
             this.markPreflighted(envelope);
             return true;
         }
+        if (options.deferPairingRequests === true &&
+            this.config.senderPolicy === 'pairing' &&
+            !this.gate.isAllowed(envelope.senderId)) {
+            this.markPreflighted(envelope);
+            return true;
+        }
         const result = this.gate.check(envelope.senderId, envelope.senderName);
         if (!result.allowed) {
             if (result.pairing !== undefined) {
@@ -3370,7 +3649,55 @@ export class ChannelBase {
         const preflight = this.preflightInbound(envelope);
         if (!(isPromiseLike(preflight) ? await preflight : preflight))
             return;
-        await this.processInbound(envelope);
+        await this.processPreflightedInbound(envelope);
+    }
+    async prepareThenHandleInbound(envelope, prepare, preflightOptions = {}) {
+        const preflight = this.preflightInbound(envelope, preflightOptions);
+        if (!(isPromiseLike(preflight) ? await preflight : preflight))
+            return;
+        if (this.namedSessions) {
+            const result = await this.namedSessions.resolveAfterPreparation(this.namedSessionOwner(envelope), prepare, () => !this.bypassesNamedTurnBinding(envelope), (sessionId) => {
+                const binding = this.bindNamedTurn(envelope, sessionId);
+                return () => this.releaseNamedTurnBinding(binding);
+            });
+            if (result.status === 'aborted')
+                return;
+            if (result.status === 'resolve_error') {
+                this.finishNamedTurnBinding(envelope);
+                await this.sendNamedSessionError(envelope, result.error);
+                return;
+            }
+            if (result.status === 'resolved' &&
+                !result.sessionId &&
+                !this.namedTurnBindings.has(envelope)) {
+                this.namedTurnBindings.set(envelope, {
+                    sessionId: null,
+                    generation: 0,
+                    claimed: false,
+                    released: true,
+                });
+            }
+        }
+        else if ((await prepare()) === false) {
+            return;
+        }
+        try {
+            await this.handleInbound(envelope);
+        }
+        finally {
+            this.finishNamedTurnBinding(envelope);
+        }
+    }
+    async processPreflightedInbound(envelope, process = () => this.processInbound(envelope)) {
+        if (this.namedSessions && !(await this.prepareNamedTurnBinding(envelope))) {
+            return;
+        }
+        try {
+            await process();
+        }
+        finally {
+            this.finishNamedTurnBinding(envelope);
+        }
     }
     async recordObservedContact(envelope) {
         if (!this.observedContacts)
@@ -3532,7 +3859,48 @@ export class ChannelBase {
         // Preprocessing above can await memory/command hooks; recovery may have
         // started since the entry check. Recheck immediately before session routing.
         await this.waitForBridgeRecovery();
-        const sessionId = await this.router.resolve(this.name, envelope.senderId, envelope.chatId, envelope.threadId, this.config.cwd, envelope.isGroup);
+        let sessionId;
+        let namedTurn = this.namedTurnBindings.get(envelope);
+        if (this.namedSessions && namedTurn) {
+            if (namedTurn.sessionId === null) {
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No task was selected when this message was received. Select a task and send it again.');
+                return;
+            }
+            if (this.dropQueuedTurnIfStale(namedTurn.sessionId, namedTurn.generation, envelope)) {
+                return;
+            }
+            try {
+                sessionId = await this.namedSessions.resolve(this.namedSessionOwner(envelope), namedTurn.sessionId);
+            }
+            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`);
+                return;
+            }
+        }
+        else if (this.namedSessions) {
+            try {
+                sessionId = await this.namedSessions.resolve(this.namedSessionOwner(envelope), undefined, (resolvedSessionId) => {
+                    const binding = this.bindNamedTurn(envelope, resolvedSessionId);
+                    namedTurn = binding;
+                    return () => this.releaseNamedTurnBinding(binding);
+                });
+            }
+            catch (error) {
+                await this.sendNamedSessionError(envelope, error);
+                return;
+            }
+            if (!sessionId) {
+                await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No task is currently selected. Use /session new <name> or /session use <name>.');
+                return;
+            }
+        }
+        else {
+            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.
@@ -3616,15 +3984,22 @@ export class ChannelBase {
             const quoted = sanitizeQuotedText(envelope.referencedText, 500);
             promptText = `[Replying to: "${quoted}"]\n\n${promptText}`;
         }
-        // Resolve attachments: extract image for bridge, append file paths to text
+        // Resolve attachments: extract images for bridge, append file paths to text
         let imageBase64 = envelope.imageBase64;
         let imageMimeType = envelope.imageMimeType;
+        const images = [];
+        if (imageBase64 && imageMimeType) {
+            images.push({ data: imageBase64, mimeType: imageMimeType });
+        }
         if (envelope.attachments?.length) {
             const filePaths = [];
             for (const att of envelope.attachments) {
-                if (att.type === 'image' && att.data && !imageBase64) {
-                    imageBase64 = att.data;
-                    imageMimeType = att.mimeType;
+                if (att.type === 'image' && att.data) {
+                    images.push({ data: att.data, mimeType: att.mimeType });
+                    if (!imageBase64) {
+                        imageBase64 = att.data;
+                        imageMimeType = att.mimeType;
+                    }
                 }
                 else if (att.filePath) {
                     const label = att.type === 'file' ? 'file' : att.type;
@@ -3784,13 +4159,17 @@ export class ChannelBase {
         // a fresh Promise.resolve()) is what guarantees this turn never runs while the
         // turn it supersedes is still active — see the steer branch above.
         const prev = this.sessionQueues.get(sessionId) ?? Promise.resolve();
-        // Snapshot the session generation at enqueue time to guard against a /clear
-        // racing this turn. There is no await between reading `active` above and this
-        // snapshot, so the capture is atomic with the enqueue; if /clear bumps the
-        // generation before this turn dequeues, the session we captured is gone — bail
-        // (at the dequeue guard below) rather than resurrect it.
-        const generation = this.sessionGenerations.get(sessionId) ?? 0;
+        // Fresh turns snapshot the generation at enqueue time. A collected re-entry
+        // keeps the generation captured when its buffer drained, so /clear cannot
+        // resurrect it while preprocessing runs before this queue.
+        const generation = namedTurn?.generation ?? this.sessionGenerations.get(sessionId) ?? 0;
         const useBlockStreaming = this.config.blockStreaming === 'on';
+        if (namedTurn) {
+            namedTurn.claimed = true;
+        }
+        else {
+            this.reserveQueuedTurn(sessionId);
+        }
         const current = prev.then(async () => {
             // Disarm the steer watchdog: the predecessor's tail has resolved, so this
             // chained turn is no longer wedged behind it. No-op when unarmed (the timer is
@@ -3962,6 +4341,7 @@ export class ChannelBase {
             promptBridge.on('responseBoundary', onResponseBoundary);
             try {
                 const response = await promptBridge.prompt(sessionId, promptToSend, {
+                    ...(images.length > 0 ? { images } : {}),
                     imageBase64,
                     imageMimeType,
                     displayText,
@@ -4033,7 +4413,13 @@ export class ChannelBase {
             finally {
                 promptBridge.off('textChunk', onChunk);
                 promptBridge.off('responseBoundary', onResponseBoundary);
-                streamer?.stop();
+                if (streamer) {
+                    streamer.stop();
+                    // Queued block sends belong to this turn: let them land before
+                    // onPromptEnd settles turn-scoped adapter state, or a send racing
+                    // the settle can recreate discarded state and leak unredacted text.
+                    await streamer.drain();
+                }
                 // Identity guard: a turn that wedged past /clear's bounded wait gets
                 // EVICTED — /clear gives up on active.done, deletes activePrompts, and a
                 // turn the user starts AFTER the clear can re-seed activePrompts (and own
@@ -4085,42 +4471,14 @@ export class ChannelBase {
                 // settles late can't drain a buffer a later turn now owns. (Belt-and-
                 // suspenders: /clear already deletes the buffer on eviction, so this guard
                 // is defensive — but it keeps the invariant "only the current turn drains".)
-                const buffer = this.collectBuffers.get(sessionId);
-                if (stillCurrent && buffer && buffer.length > 0) {
-                    this.collectBuffers.delete(sessionId);
-                    const lost = buffer.length;
-                    const coalesced = buffer.map((b) => b.text).join('\n\n');
-                    const coalescedDisplayText = buffer
-                        .map((b) => b.displayText)
-                        .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,
-                        text: coalesced,
-                        displayText: coalescedDisplayText,
-                        // Coalesced text already carries each message's [sender] prefix.
-                        alreadyPrefixed: true,
-                        // Clear attachments/references — already resolved in original text
-                        referencedText: undefined,
-                        mentionedMemberIds: undefined,
-                        attachments: undefined,
-                        metadata: undefined,
-                        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.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`);
-                    });
-                }
+                this.drainCollectBufferForCurrentPrompt(sessionId, stillCurrent, 'prompt completion');
             }
         });
-        this.sessionQueues.set(sessionId, current.catch(() => { }));
-        await current;
+        const tracked = current.finally(() => {
+            this.releaseQueuedTurn(sessionId);
+        });
+        this.sessionQueues.set(sessionId, tracked.catch(() => { }));
+        await tracked;
     }
     pairingRejectionMessage(rejected) {
         return rejected === 'sender_pending'