@qwen-code/channel-base 0.19.10 → 0.19.11-nightly.20260718.767a32484

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/ChannelAgentBridge.d.ts

@@ -62,6 +62,13 @@ export interface BridgeSessionInfo {
 }
 export interface ChannelAgentBridgeSessionOptions {
     approvalMode?: string;
+    /**
+     * Channel instance name (e.g. `feishu-main`) stamped as the daemon `sourceId`
+     * on **new** sessions — creation-time attribution paired with
+     * `sourceType: 'channel'`. Ignored by `loadSession`: loading an existing
+     * session never re-stamps its creation attribution.
+     */
+    sourceId?: string;
 }
 export interface ChannelAgentBridge {
     readonly availableCommands: AvailableCommand[];

package/dist/ChannelBase.d.ts

@@ -70,7 +70,8 @@ export declare abstract class ChannelBase {
      * so a cleared session can't be resurrected by an already-queued prompt.
      */
     private sessionGenerations;
-    private pendingClears;
+    private pendingChannelMemoryMutations;
+    private pendingChannelMemoryMutationDeliveries;
     /** Per-session active prompt tracking for dispatch modes. */
     private activePrompts;
     /** Per-session message buffer for collect mode. */
@@ -111,6 +112,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,10 +214,15 @@ export declare abstract class ChannelBase {
     private invalidateSessionContext;
     private dropQueuedTurnIfStale;
     private getChannelMemory;
+    private entriesForChannelMemoryIds;
+    private renderChannelMemoryCandidate;
+    private renderChannelMemoryCandidates;
     private handleChannelMemoryIntent;
     private shouldClassifyChannelMemoryIntent;
-    private clearPendingKey;
-    private setPendingClear;
+    private channelMemoryPendingKey;
+    private deliverPendingChannelMemoryMutation;
+    private takePendingChannelMemoryMutation;
+    private deletePendingChannelMemoryMutation;
     private classifyChannelMemoryIntent;
     private channelMemoryErrorMessage;
     private channelMemoryUserErrorMessage;

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';
@@ -108,7 +110,8 @@ export class ChannelBase {
      * so a cleared session can't be resurrected by an already-queued prompt.
      */
     sessionGenerations = new Map();
-    pendingClears = new Map();
+    pendingChannelMemoryMutations = new Map();
+    pendingChannelMemoryMutationDeliveries = new Map();
     /** Per-session active prompt tracking for dispatch modes. */
     activePrompts = new Map();
     /** Per-session message buffer for collect mode. */
@@ -370,6 +373,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 +681,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 +1413,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,10 +1920,138 @@ 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.');
+            await this.deliverPendingChannelMemoryMutation(envelope, { kind: 'clear' }, 'This clears channel memory for this chat. Say "确认清空记忆" or "confirm clear memory" to proceed.');
+            return;
+        }
+        if (intent.kind === 'update_confirm' || intent.kind === 'remove_confirm') {
+            const pending = intent.kind === 'update_confirm'
+                ? this.takePendingChannelMemoryMutation(envelope, 'update')
+                : this.takePendingChannelMemoryMutation(envelope, 'remove');
+            if (!pending) {
+                await this.sendMessage(envelope.chatId, intent.kind === 'update_confirm'
+                    ? 'No pending channel memory update. Start a new update request first.'
+                    : 'No pending channel memory removal. Start a new removal request first.');
+                return;
+            }
+            const channelMemory = await this.getChannelMemory(envelope);
+            if (!channelMemory)
+                return;
+            const isUpdate = pending.kind === 'update';
+            let changed;
+            try {
+                if (isUpdate) {
+                    ({ changed } = await channelMemory.updateChannelMemoryEntry(this.channelMemoryTarget(envelope), {
+                        id: pending.id,
+                        text: pending.proposedText,
+                        expectedText: pending.expectedText,
+                    }));
+                }
+                else {
+                    ({ changed } = await channelMemory.removeChannelMemoryEntries(this.channelMemoryTarget(envelope), {
+                        ids: [pending.id],
+                        expectedTextById: { [pending.id]: pending.expectedText },
+                    }));
+                }
+            }
+            catch (error) {
+                const message = this.channelMemoryErrorMessage(error);
+                this.logChannelMemoryError(isUpdate ? 'update' : 'remove', envelope, message);
+                await this.sendMessage(envelope.chatId, message === 'Channel memory entry changed'
+                    ? 'That channel memory entry changed since it was selected. View channel memory and start the operation again.'
+                    : `Failed to ${isUpdate ? 'update' : 'remove'} channel memory: ${this.channelMemoryUserErrorMessage()}`);
+                return;
+            }
+            if (!changed) {
+                await this.sendMessage(envelope.chatId, `No channel memory entry ${pending.id}.`);
+                return;
+            }
+            this.invalidateSessionContext(envelope);
+            await this.sendMessage(envelope.chatId, `Channel memory ${pending.id} ${isUpdate ? 'updated' : 'removed'}.`);
+            return;
+        }
+        if (intent.kind === 'natural_update') {
+            await this.deliverPendingChannelMemoryMutation(envelope, {
+                kind: 'update',
+                id: intent.id,
+                expectedText: intent.expectedText,
+                proposedText: intent.text,
+            }, [
+                `Update channel memory ${intent.id}?`,
+                `Before: ${sanitizePromptText(intent.expectedText).trim()}`,
+                `After: ${sanitizePromptText(intent.text).trim()}`,
+                'Say "确认更新记忆" or "confirm memory update" within 60 seconds.',
+            ].join('\n'));
+            return;
+        }
+        if (intent.kind === 'natural_remove') {
+            await this.deliverPendingChannelMemoryMutation(envelope, {
+                kind: 'remove',
+                id: intent.id,
+                expectedText: intent.expectedText,
+            }, [
+                `Remove channel memory ${intent.id}?`,
+                sanitizePromptText(intent.expectedText).trim(),
+                'Say "确认删除记忆" or "confirm memory removal" within 60 seconds.',
+            ].join('\n'));
             return;
         }
         const channelMemory = await this.getChannelMemory(envelope);
@@ -1949,8 +2059,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.texts, envelope.senderId);
             }
             catch (error) {
                 const message = this.channelMemoryErrorMessage(error);
@@ -1958,14 +2069,29 @@ 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, result.duplicateIds.length > 0
+                    ? `Channel memory saved: ${ids.join(', ')}. Skipped duplicates: ${result.duplicateIds.join(', ')}.`
+                    : ids.length === 1
+                        ? `Channel memory ${ids[0]} saved.`
+                        : `Channel memory saved: ${ids.join(', ')}.`);
+            }
+            else if (result.duplicateIds.length > 0) {
+                await this.sendMessage(envelope.chatId, `Channel memory already contains ${result.duplicateIds.join(', ')}.`);
+            }
+            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 +2099,61 @@ 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') {
+            let changed;
+            const isUpdate = intent.kind === 'update';
+            const id = intent.id;
+            try {
+                if (isUpdate) {
+                    ({ changed } = await channelMemory.updateChannelMemoryEntry(this.channelMemoryTarget(envelope), { id: intent.id, text: intent.text }));
+                }
+                else {
+                    ({ changed } = await channelMemory.removeChannelMemoryEntries(this.channelMemoryTarget(envelope), { 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 pending = this.takePendingChannelMemoryMutation(envelope, 'clear');
+            if (!pending) {
+                await this.sendMessage(envelope.chatId, 'No pending clear request. Say "清空记忆" first.');
+                return;
+            }
             let result;
             try {
                 result = await channelMemory.clearChannelMemory(this.channelMemoryTarget(envelope));
@@ -1996,7 +2164,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;
         }
@@ -2010,45 +2180,184 @@ export class ChannelBase {
             !normalized.startsWith('/') &&
             CHANNEL_MEMORY_CLASSIFIER_TRIGGER_RE.test(normalized));
     }
-    clearPendingKey(envelope) {
-        return `${this.name}:${envelope.chatId}:${envelope.threadId ?? ''}:${envelope.senderId ?? ''}`;
+    channelMemoryPendingKey(envelope) {
+        return JSON.stringify([
+            this.name,
+            envelope.chatId,
+            envelope.threadId ?? null,
+            envelope.senderId ?? null,
+        ]);
     }
-    setPendingClear(key) {
+    async deliverPendingChannelMemoryMutation(envelope, mutation, message) {
         const now = Date.now();
-        for (const [pendingKey, expiresAt] of this.pendingClears) {
-            if (expiresAt < now) {
-                this.pendingClears.delete(pendingKey);
+        for (const [pendingKey, pending] of this.pendingChannelMemoryMutations) {
+            if (pending.expiresAt < now) {
+                this.pendingChannelMemoryMutations.delete(pendingKey);
+            }
+        }
+        this.deletePendingChannelMemoryMutation(envelope);
+        const key = this.channelMemoryPendingKey(envelope);
+        this.pendingChannelMemoryMutationDeliveries.set(key, mutation);
+        try {
+            await this.sendMessage(envelope.chatId, message);
+        }
+        catch (error) {
+            if (this.pendingChannelMemoryMutationDeliveries.get(key) === mutation) {
+                this.pendingChannelMemoryMutationDeliveries.delete(key);
             }
+            throw error;
         }
-        this.pendingClears.set(key, now + 60_000);
+        if (this.pendingChannelMemoryMutationDeliveries.get(key) !== mutation) {
+            return;
+        }
+        this.pendingChannelMemoryMutationDeliveries.delete(key);
+        this.pendingChannelMemoryMutations.set(key, {
+            ...mutation,
+            expiresAt: Date.now() + 60_000,
+        });
     }
-    async classifyChannelMemoryIntent(text) {
-        if (!this.memoryIntentClassifier) {
+    takePendingChannelMemoryMutation(envelope, kind) {
+        const key = this.channelMemoryPendingKey(envelope);
+        const pending = this.pendingChannelMemoryMutations.get(key);
+        if (!pending) {
+            return undefined;
+        }
+        if (pending.expiresAt < Date.now()) {
+            this.pendingChannelMemoryMutations.delete(key);
+            return undefined;
+        }
+        if (pending.kind !== kind) {
+            return undefined;
+        }
+        this.pendingChannelMemoryMutations.delete(key);
+        return pending;
+    }
+    deletePendingChannelMemoryMutation(envelope) {
+        const key = this.channelMemoryPendingKey(envelope);
+        this.pendingChannelMemoryMutations.delete(key);
+        this.pendingChannelMemoryMutationDeliveries.delete(key);
+    }
+    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) {
-            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' };
+        try {
+            if (typeof classified !== 'object' || classified === null)
+                return null;
+            const result = classified;
+            const confidence = result.confidence;
+            if (typeof confidence !== 'number' ||
+                !Number.isFinite(confidence) ||
+                confidence < 0 ||
+                confidence > 1 ||
+                confidence < CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE) {
+                return null;
+            }
+            const intent = result.intent;
+            if (intent === 'remember') {
+                const hasMemory = Object.prototype.hasOwnProperty.call(result, 'memory');
+                const hasMemories = Object.prototype.hasOwnProperty.call(result, 'memories');
+                if (hasMemory === hasMemories)
+                    return null;
+                let texts = [];
+                if (hasMemory) {
+                    const memory = result.memory;
+                    texts = typeof memory === 'string' ? [memory.trim()] : [];
+                }
+                else {
+                    const memories = result.memories;
+                    if (Array.isArray(memories)) {
+                        const snapshot = Array.from(memories);
+                        if (snapshot.every((memory) => typeof memory === 'string')) {
+                            texts = snapshot.map((memory) => memory.trim());
+                        }
+                    }
+                }
+                return texts.length >= 1 &&
+                    texts.length <= 10 &&
+                    texts.every((text) => text.length > 0)
+                    ? { kind: 'remember', texts }
+                    : null;
+            }
+            if (intent === 'clear_all')
+                return { kind: 'clear_request' };
+            if (intent !== 'list' &&
+                intent !== 'inspect' &&
+                intent !== 'update' &&
+                intent !== 'remove') {
+                return null;
+            }
+            const targetIds = result.targetIds;
+            if (intent === 'list' && targetIds === undefined) {
+                return { kind: 'list', page: 1 };
+            }
+            if (!Array.isArray(targetIds))
+                return null;
+            const targetIdSnapshot = Array.from(targetIds);
+            const entryById = new Map(entries.map((entry) => [entry.id, entry]));
+            if (!targetIdSnapshot.every((id) => typeof id === 'string' && entryById.has(id)) ||
+                new Set(targetIdSnapshot).size !== targetIdSnapshot.length) {
+                return null;
+            }
+            const resolvedEntries = this.entriesForChannelMemoryIds(entries, targetIdSnapshot);
+            if (intent === 'list') {
+                return resolvedEntries.length === 0
+                    ? { kind: 'no_match' }
+                    : {
+                        kind: 'list_matches',
+                        ids: resolvedEntries.map((entry) => entry.id),
+                    };
+            }
+            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 (intent === 'inspect')
+                return { kind: 'inspect', id: entry.id };
+            if (intent === 'remove') {
+                return {
+                    kind: 'natural_remove',
+                    id: entry.id,
+                    expectedText: entry.text,
+                };
+            }
+            const memory = result.memory;
+            const text = typeof memory === 'string' ? memory.trim() : '';
+            return text
+                ? {
+                    kind: 'natural_update',
+                    id: entry.id,
+                    text,
+                    expectedText: entry.text,
+                }
+                : null;
         }
-        if (classified.intent === 'clear_all') {
-            return { kind: 'clear_request' };
+        catch (error) {
+            process.stderr.write(`[${this.name}] channel memory intent validation failed: ${sanitizeLogText(this.channelMemoryErrorMessage(error), 200)}\n`);
+            return null;
         }
-        return null;
     }
     channelMemoryErrorMessage(error) {
         return error instanceof Error ? error.message : String(error);
@@ -2418,9 +2727,12 @@ export class ChannelBase {
             throw new Error('processInbound called without a successful preflightInbound check.');
         }
         let memoryIntent = parseChannelMemoryIntent(envelope.text);
+        if (memoryIntent?.kind === 'update' || memoryIntent?.kind === 'remove') {
+            this.deletePendingChannelMemoryMutation(envelope);
+        }
         if (!memoryIntent &&
             this.shouldClassifyChannelMemoryIntent(envelope.text)) {
-            memoryIntent = await this.classifyChannelMemoryIntent(envelope.text);
+            memoryIntent = await this.classifyChannelMemoryIntent(envelope);
         }
         if (memoryIntent) {
             await this.handleChannelMemoryIntent(envelope, memoryIntent);