@qwen-code/channel-base 0.19.10 → 0.19.11-nightly.20260717.f8e6e8931

package/README.md

@@ -72,9 +72,9 @@ Migration note for existing TypeScript plugins: if your adapter constructor or f
 Channel adapters can run in two host modes:
 
 - `qwen channel start [name]` is the standalone service. It uses `AcpBridge` over a `qwen-code --acp` child process and remains the default channel command.
-- `qwen serve --channel <name>` and `qwen serve --channel all` are experimental daemon-managed modes. `qwen serve` starts one out-of-process channel worker, the worker connects back to the daemon through the SDK, and adapters receive a `DaemonChannelBridge`-backed `ChannelAgentBridge` facade.
+- `qwen serve --channel <name>` and `qwen serve --channel all` are experimental daemon-managed modes. Named channels are grouped by owning workspace and `qwen serve` starts one out-of-process worker per owning runtime. Each worker connects back to the daemon through the SDK, and adapters receive a `DaemonChannelBridge`-backed `ChannelAgentBridge` facade. `--channel all` stays primary-only.
 
-In daemon-managed mode, one daemon is bound to one workspace. Every selected channel's `cwd` must resolve to that same workspace. The optional `shellCommand` method is exposed to adapters only when the daemon advertises the `session_shell_command` capability.
+In daemon-managed mode, every named channel's `cwd` must resolve to exactly one registered, trusted workspace. Its worker receives that runtime's cwd and environment overlay; an ambiguous or untrusted selection fails instead of using primary. The optional `shellCommand` method is exposed to adapters only when the daemon advertises the `session_shell_command` capability.
 
 ## Architecture
 

package/dist/ChannelBase.d.ts

@@ -111,6 +111,7 @@ export declare abstract class ChannelBase {
     private lifecycleBase;
     supportsProactiveSend(): boolean;
     protected supportsProactiveTarget(target: SessionTarget): boolean;
+    protected supportsProactiveWebhookTarget(target: SessionTarget): boolean;
     protected pushProactive(target: SessionTarget, text: string): Promise<void>;
     private prependUnattendedSessionContext;
     private drainCollectBufferForCurrentPrompt;
@@ -212,6 +213,9 @@ export declare abstract class ChannelBase {
     private invalidateSessionContext;
     private dropQueuedTurnIfStale;
     private getChannelMemory;
+    private entriesForChannelMemoryIds;
+    private renderChannelMemoryCandidate;
+    private renderChannelMemoryCandidates;
     private handleChannelMemoryIntent;
     private shouldClassifyChannelMemoryIntent;
     private clearPendingKey;

package/dist/ChannelBase.js

@@ -26,8 +26,10 @@ const GROUP_HISTORY_ENTRY_TEXT_LIMIT = 1000;
 const GROUP_HISTORY_ENTRY_METADATA_LIMIT = 256;
 const LOOP_CANCEL_GRACE_MS = 5000;
 const CHANNEL_MEMORY_PROMPT_CODE_POINT_LIMIT = 12_000;
+const CHANNEL_MEMORY_PAGE_SIZE = 20;
+const CHANNEL_MEMORY_PREVIEW_CODE_POINT_LIMIT = 160;
 const CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE = 0.7;
-const CHANNEL_MEMORY_CLASSIFIER_TRIGGER_RE = /(记住|记得|记一下|记忆|忘掉|忘记|清空|清除|删除|保存|remember|memory|forget)/iu;
+const CHANNEL_MEMORY_CLASSIFIER_TRIGGER_RE = /(?:记住|记得|记一下|记忆|忘掉|忘记|清空|清除|删除|删掉|改成|更新|刚才那条|保存|(?:只|仅)(?:看|列出)[\p{Script=Han}\s]{0,12}(?:偏好|习惯)|\b(?:remember|memory|forget|delete|remove|update|change)\b)/iu;
 /** Sentinel message for the loop-prompt timeout rejection; matched by identity below. */
 const LOOP_TIMED_OUT_MESSAGE = 'loop timed out';
 const DEBUG_PAYLOAD_ENV = 'QWEN_CHANNEL_DEBUG_PAYLOAD';
@@ -370,6 +372,9 @@ export class ChannelBase {
     supportsProactiveTarget(target) {
         return target.threadId === undefined;
     }
+    supportsProactiveWebhookTarget(target) {
+        return this.supportsProactiveTarget(target);
+    }
     async pushProactive(target, text) {
         if (target.threadId) {
             throw new Error('Channel does not support proactive loop messages for threaded targets.');
@@ -675,7 +680,7 @@ export class ChannelBase {
             throw new Error(`Unknown webhook source "${task.source}".`);
         }
         const target = resolveChannelWebhookTarget(this.name, this.config.webhooks, task.source, task.targetRef);
-        if (!this.supportsProactiveTarget(target)) {
+        if (!this.supportsProactiveWebhookTarget(target)) {
             throw new Error('Channel does not support proactive webhook messages for this chat target.');
         }
         return target;
@@ -1407,30 +1412,6 @@ export class ChannelBase {
         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'));
-        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 (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.
@@ -1938,7 +1919,64 @@ export class ChannelBase {
         }
         return this.channelMemory;
     }
-    async handleChannelMemoryIntent(envelope, intent, options = {}) {
+    entriesForChannelMemoryIds(entries, ids) {
+        const selected = new Set(ids);
+        return entries.filter((entry) => selected.has(entry.id));
+    }
+    renderChannelMemoryCandidate(entry) {
+        const preview = truncateCodePoints(sanitizePromptText(entry.text)
+            .replace(/[\r\n]+/gu, ' ')
+            .trim(), CHANNEL_MEMORY_PREVIEW_CODE_POINT_LIMIT);
+        return `${entry.id}  ${preview}`;
+    }
+    renderChannelMemoryCandidates(entries) {
+        return entries.map((entry) => this.renderChannelMemoryCandidate(entry));
+    }
+    async handleChannelMemoryIntent(envelope, intent) {
+        if (intent.kind === 'no_match') {
+            await this.sendMessage(envelope.chatId, 'No matching channel memory entry.');
+            return;
+        }
+        if (intent.kind === 'ambiguous') {
+            const channelMemory = await this.getChannelMemory(envelope);
+            if (!channelMemory)
+                return;
+            let entries;
+            try {
+                entries = await channelMemory.listChannelMemoryEntries(this.channelMemoryTarget(envelope));
+            }
+            catch (error) {
+                this.logChannelMemoryError('read', envelope, this.channelMemoryErrorMessage(error));
+                await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                return;
+            }
+            const selected = this.entriesForChannelMemoryIds(entries, intent.ids);
+            await this.sendMessage(envelope.chatId, [
+                'Multiple channel memory entries match:',
+                ...this.renderChannelMemoryCandidates(selected),
+            ].join('\n'));
+            return;
+        }
+        if (intent.kind === 'list_matches') {
+            const channelMemory = await this.getChannelMemory(envelope);
+            if (!channelMemory)
+                return;
+            let entries;
+            try {
+                entries = await channelMemory.listChannelMemoryEntries(this.channelMemoryTarget(envelope));
+            }
+            catch (error) {
+                this.logChannelMemoryError('read', envelope, this.channelMemoryErrorMessage(error));
+                await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                return;
+            }
+            const selected = this.entriesForChannelMemoryIds(entries, intent.ids);
+            await this.sendMessage(envelope.chatId, [
+                'Channel memory (page 1/1):',
+                ...this.renderChannelMemoryCandidates(selected),
+            ].join('\n'));
+            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.');
@@ -1949,8 +1987,9 @@ export class ChannelBase {
             return;
         }
         if (intent.kind === 'remember') {
+            let result;
             try {
-                await channelMemory.appendChannelMemory(this.channelMemoryTarget(envelope), intent.text);
+                result = await channelMemory.addChannelMemoryEntries(this.channelMemoryTarget(envelope), [intent.text], envelope.senderId);
             }
             catch (error) {
                 const message = this.channelMemoryErrorMessage(error);
@@ -1958,14 +1997,27 @@ export class ChannelBase {
                 await this.sendMessage(envelope.chatId, `Failed to save channel memory: ${this.channelMemoryUserErrorMessage()}`);
                 return;
             }
-            this.invalidateSessionContext(envelope);
-            await this.sendMessage(envelope.chatId, 'Channel memory updated.');
+            if (result.changed) {
+                this.invalidateSessionContext(envelope);
+            }
+            if (result.added.length > 0) {
+                const ids = result.added.map((entry) => entry.id);
+                await this.sendMessage(envelope.chatId, 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(', ')}.`);
+            }
+            else {
+                await this.sendMessage(envelope.chatId, 'Channel memory updated.');
+            }
             return;
         }
-        if (intent.kind === 'list') {
-            let text;
+        if (intent.kind === 'list' || intent.kind === 'inspect') {
+            let entries;
             try {
-                text = (await channelMemory.readChannelMemory(this.channelMemoryTarget(envelope))).trim();
+                entries = await channelMemory.listChannelMemoryEntries(this.channelMemoryTarget(envelope));
             }
             catch (error) {
                 const message = this.channelMemoryErrorMessage(error);
@@ -1973,19 +2025,77 @@ export class ChannelBase {
                 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));
+            if (intent.kind === 'inspect') {
+                const entry = entries.find((candidate) => candidate.id === intent.id);
+                await this.sendMessage(envelope.chatId, 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.`);
+                return;
+            }
+            if (entries.length === 0) {
+                await this.sendMessage(envelope.chatId, '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'));
             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;
+        if (intent.kind === 'update' ||
+            intent.kind === 'remove' ||
+            intent.kind === 'natural_update' ||
+            intent.kind === 'natural_remove') {
+            let changed;
+            const isUpdate = intent.kind === 'update' || intent.kind === 'natural_update';
+            const id = intent.id;
+            try {
+                if (isUpdate) {
+                    ({ changed } = await channelMemory.updateChannelMemoryEntry(this.channelMemoryTarget(envelope), intent.kind === 'natural_update'
+                        ? {
+                            id: intent.id,
+                            text: intent.text,
+                            expectedText: intent.expectedText,
+                        }
+                        : { id: intent.id, text: intent.text }));
+                }
+                else {
+                    ({ changed } = await channelMemory.removeChannelMemoryEntries(this.channelMemoryTarget(envelope), intent.kind === 'natural_remove'
+                        ? {
+                            ids: [intent.id],
+                            expectedTextById: { [intent.id]: intent.expectedText },
+                        }
+                        : { ids: [intent.id] }));
                 }
             }
+            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()}`);
+                return;
+            }
+            if (!changed) {
+                await this.sendMessage(envelope.chatId, `No channel memory entry ${id}.`);
+                return;
+            }
+            this.invalidateSessionContext(envelope);
+            await this.sendMessage(envelope.chatId, `Channel memory ${id} ${isUpdate ? 'updated' : 'removed'}.`);
+            return;
+        }
+        if (intent.kind === 'clear_confirm') {
+            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));
@@ -1996,7 +2106,9 @@ export class ChannelBase {
                 await this.sendMessage(envelope.chatId, `Failed to clear channel memory: ${this.channelMemoryUserErrorMessage()}`);
                 return;
             }
-            this.invalidateSessionContext(envelope);
+            if (result.changed) {
+                this.invalidateSessionContext(envelope);
+            }
             await this.sendMessage(envelope.chatId, result.changed ? 'Channel memory cleared.' : 'No channel memory saved.');
             return;
         }
@@ -2022,32 +2134,100 @@ export class ChannelBase {
         }
         this.pendingClears.set(key, now + 60_000);
     }
-    async classifyChannelMemoryIntent(text) {
-        if (!this.memoryIntentClassifier) {
+    async classifyChannelMemoryIntent(envelope) {
+        if (!this.memoryIntentClassifier || !this.channelMemory) {
+            return null;
+        }
+        let entries;
+        try {
+            entries = await this.channelMemory.listChannelMemoryEntries(this.channelMemoryTarget(envelope));
+        }
+        catch (error) {
+            this.logChannelMemoryError('read', envelope, this.channelMemoryErrorMessage(error));
             return null;
         }
         let classified;
         try {
             classified =
-                await this.memoryIntentClassifier.classifyChannelMemoryIntent(text);
+                await this.memoryIntentClassifier.classifyChannelMemoryIntent(envelope.text, entries);
         }
         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) {
+        const confidence = classified && typeof classified === 'object'
+            ? classified.confidence
+            : undefined;
+        if (typeof confidence !== 'number' ||
+            !Number.isFinite(confidence) ||
+            confidence < 0 ||
+            confidence > 1 ||
+            confidence < CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE) {
             return null;
         }
-        if (classified.intent === 'remember') {
-            const memory = classified.memory?.trim();
+        const result = classified;
+        const targetIds = result.targetIds;
+        const entryById = new Map(entries.map((entry) => [entry.id, entry]));
+        const resolvedEntries = targetIds === undefined
+            ? undefined
+            : Array.isArray(targetIds) &&
+                targetIds.every((id) => typeof id === 'string' && entryById.has(id)) &&
+                new Set(targetIds).size === targetIds.length
+                ? this.entriesForChannelMemoryIds(entries, targetIds)
+                : null;
+        if (result.intent === 'remember') {
+            const memory = typeof result.memory === 'string' ? result.memory.trim() : '';
             return memory ? { kind: 'remember', text: memory } : null;
         }
-        if (classified.intent === 'list') {
-            return { kind: 'list' };
-        }
-        if (classified.intent === 'clear_all') {
+        if (result.intent === 'list') {
+            if (resolvedEntries === undefined)
+                return { kind: 'list', page: 1 };
+            if (resolvedEntries === null)
+                return null;
+            return resolvedEntries.length === 0
+                ? { kind: 'no_match' }
+                : {
+                    kind: 'list_matches',
+                    ids: resolvedEntries.map((entry) => entry.id),
+                };
+        }
+        if (result.intent === 'clear_all') {
             return { kind: 'clear_request' };
         }
+        if (result.intent !== 'inspect' &&
+            result.intent !== 'update' &&
+            result.intent !== 'remove') {
+            return null;
+        }
+        if (resolvedEntries === null || resolvedEntries === undefined)
+            return null;
+        if (resolvedEntries.length === 0)
+            return { kind: 'no_match' };
+        if (resolvedEntries.length > 1) {
+            return {
+                kind: 'ambiguous',
+                ids: resolvedEntries.map((entry) => entry.id),
+            };
+        }
+        const entry = resolvedEntries[0];
+        if (result.intent === 'inspect')
+            return { kind: 'inspect', id: entry.id };
+        if (result.intent === 'remove') {
+            return {
+                kind: 'natural_remove',
+                id: entry.id,
+                expectedText: entry.text,
+            };
+        }
+        const text = typeof result.memory === 'string' ? result.memory.trim() : '';
+        if (text) {
+            return {
+                kind: 'natural_update',
+                id: entry.id,
+                text,
+                expectedText: entry.text,
+            };
+        }
         return null;
     }
     channelMemoryErrorMessage(error) {
@@ -2420,7 +2600,7 @@ export class ChannelBase {
         let memoryIntent = parseChannelMemoryIntent(envelope.text);
         if (!memoryIntent &&
             this.shouldClassifyChannelMemoryIntent(envelope.text)) {
-            memoryIntent = await this.classifyChannelMemoryIntent(envelope.text);
+            memoryIntent = await this.classifyChannelMemoryIntent(envelope);
         }
         if (memoryIntent) {
             await this.handleChannelMemoryIntent(envelope, memoryIntent);