@lemoncat7/dsh-partner 2.21.5 → 2.21.13

package/lib/agent-runtime.js

@@ -1,3 +1,8 @@
+import { isActivitySilenceRequested } from './character/activity-tool.js';
+import { installTaskPreamble } from './execution/task-preamble.js';
+import { AsyncSemaphore } from './core/semaphore.js';
+import { automaticMemoryAllowed } from './memory-admission.js';
+import { personaReferenceRequested, renderPersonaReference } from './character/identity-guide.js';
 import { activityPolicyCurrent, postReplyAllowed, postReplyCurrent, postReplyProbability, POST_REPLY_PROMPT } from './character/post-reply.js';
 import { PARTNER_TOOL_ENTRIES } from './collaboration/tool-discovery.js';
 import { setReplyTiming } from './channels/qq/latency.js';
@@ -7,6 +12,7 @@ import { affectionEnabled, awardAffection, renderAffection } from './character/a
 import { affectionTurnEligible, currentAffectionAudience } from './character/affection-context.js';
 import { currentQqIdentityRelation, renderQqIdentityRelation } from './channels/qq/identity-binding.js';
 import { qqSettings, qqSessionTarget } from './channels/qq/settings.js';
+import { fatigueValue } from './character/fatigue.js';
 import { renderSleepContext, isSleeping } from './character/sleep.js';
 import { questionOrigin } from './channels/question-origin.js';
 import { renderCharacterContext } from './character/domain.js';
@@ -70,6 +76,7 @@ export class PartnerAgentRuntime {
     latestPostReplyInput = new Map();
     handles = new Map();
     queues = new Map();
+    replySlots = new AsyncSemaphore(6);
     heartbeatQueues = new Map();
     taskQueues = new Map();
     steeringQueues = new Map();
@@ -113,7 +120,7 @@ export class PartnerAgentRuntime {
                     const configuration = this.configurations.forSession(context.agent.session.id);
                     if (configuration?.companion.toolDiscovery)
                         return { ...assembly, tools: assembly.tools.filter(tool => PARTNER_TOOL_ENTRIES.some(name => name === tool.name)) };
-                    const access = resolveToolAccess({ agent: context.agent, state: this.store.snapshot() });
+                    const access = resolveToolAccess({ agent: context.agent, state: this.store.snapshot(), ...(this.admittedInputs.get(context.agent)?.length ? { events: this.inputEvents(context.agent) } : {}) });
                     return { ...assembly, tools: !access.sendTools ? [] : access.allowedTools ? assembly.tools.filter(tool => access.allowedTools.includes(tool.name)) : assembly.tools };
                 };
                 if (this.rebuildingAssemblies.has(context))
@@ -131,15 +138,33 @@ export class PartnerAgentRuntime {
                 }
             }) : () => { };
         this.disposeConfigurationListener = typeof this.ctx.on === 'function'
-            ? this.ctx.on('agent/pre-step', async ({ agent, turn, signal }, next) => {
-                await this.prepareAgentTurn(agent, turn, signal);
-                return next();
+            ? this.ctx.on('agent/pre-step', async ({ agent, turn, signal, messages }, next) => {
+                try {
+                    await this.prepareAgentTurn(agent, turn, signal, messages);
+                    const decision = await next();
+                    if (decision.kind === 'reject') {
+                        this.admittedInputs.delete(agent);
+                        this.contextRevisions.delete(agent);
+                    }
+                    else if (decision.kind === 'enter') {
+                        this.admittedInputs.set(agent, decision.messages);
+                        await this.sleepService?.acceptInput(agent.session.id, decision.messages);
+                        await this.prepareConversationContext(agent, signal);
+                    }
+                    return decision;
+                }
+                catch (error) {
+                    this.admittedInputs.delete(agent);
+                    this.contextRevisions.delete(agent);
+                    throw error;
+                }
             }) : () => { };
         this.disposeAgentListener = typeof this.ctx.on === 'function'
             ? this.ctx.on('agent/disposed', ({ agent }) => {
                 this.replyPresentations.get(agent)?.();
                 this.replyPresentations.delete(agent);
                 this.preparedTurns.delete(agent);
+                this.admittedInputs.delete(agent);
                 this.characterContexts.get(agent.session.id)?.();
                 this.characterContexts.delete(agent.session.id);
                 this.contextRevisions.delete(agent);
@@ -151,12 +176,14 @@ export class PartnerAgentRuntime {
             })
             : () => { };
     }
+    sleepService;
+    setSleepService(service) { this.sleepService = service; }
     setQuestionAnswerer(answerer) {
         this.questionAnswerer = answerer;
     }
     /** Cancel pending/claimed continuations as soon as another real input is admitted. */
-    async cancelPostReply(companionId, keepUserMessageId) {
-        const needsCancel = (r) => r.companionId === companionId && r.postReplyOpportunity
+    async cancelPostReply(companionId, keepUserMessageId, sessionId) {
+        const needsCancel = (r) => r.companionId === companionId && (!sessionId || r.sessionId === sessionId) && r.postReplyOpportunity
             && ['pending', 'claimed'].includes(r.postReplyOpportunity.status) && r.postReplyOpportunity.userMessageId !== keepUserMessageId;
         if (!this.store.snapshot().sessions.some(needsCancel))
             return;
@@ -180,21 +207,21 @@ export class PartnerAgentRuntime {
         const companion = state.companions.find(c => c.id === route?.companionId);
         if (!route || !companion || !postReplyAllowed(state, companion, route) || this.closed || this.isArchived(route) || this.store.isCompanionRemoving(companion.id))
             return;
-        const key = `companion:${companion.id}`;
+        const key = route.sessionId;
         if (this.queues.has(key) || this.steeringQueues.has(key))
             return;
         const agent = await this.ensureAgent(companion, route);
-        if (agent.status !== 'idle' || (this.latestPostReplyInput.has(companion.id) && this.latestPostReplyInput.get(companion.id) !== source.userMessageId) || lastIdleContactUser(agent.session.snapshotEvents())?.id !== source.userMessageId)
+        if (agent.status !== 'idle' || (this.latestPostReplyInput.has(route.sessionId) && this.latestPostReplyInput.get(route.sessionId) !== source.userMessageId) || lastIdleContactUser(agent.session.snapshotEvents())?.id !== source.userMessageId)
             return;
         await this.store.update(draft => {
             const current = draft.companions.find(c => c.id === companion.id), target = draft.sessions.find(r => r.id === route.id);
             if (!current || !target || target.sessionId !== source.sessionId || !postReplyAllowed(draft, current, target)
                 || target.postReplyOpportunity?.userMessageId === source.userMessageId || agent.status !== 'idle'
-                || this.queues.has(key) || this.steeringQueues.has(key) || (this.latestPostReplyInput.has(companion.id) && this.latestPostReplyInput.get(companion.id) !== source.userMessageId) || lastIdleContactUser(agent.session.snapshotEvents())?.id !== source.userMessageId)
+                || this.queues.has(key) || this.steeringQueues.has(key) || (this.latestPostReplyInput.has(route.sessionId) && this.latestPostReplyInput.get(route.sessionId) !== source.userMessageId) || lastIdleContactUser(agent.session.snapshotEvents())?.id !== source.userMessageId)
                 return;
-            // At most one pending continuation per companion; different owner accounts share it.
+            // Shared history has one opportunity; unrelated conversations remain independent.
             for (const other of draft.sessions)
-                if (other.companionId === companion.id && other.postReplyOpportunity?.status === 'pending')
+                if (other.sessionId === route.sessionId && other.postReplyOpportunity?.status === 'pending')
                     other.postReplyOpportunity.status = 'cancelled';
             const now = Date.now(), probability = postReplyProbability(current);
             target.postReplyOpportunity = { userMessageId: source.userMessageId, sessionId: source.sessionId, policyRevision: current.updatedAt,
@@ -205,16 +232,17 @@ export class PartnerAgentRuntime {
     /** Use the existing timer and real conversation; never impersonate user input. */
     async idleContact(companionId, timeZone = 'Asia/Shanghai') {
         const key = `companion:${companionId}`;
-        if (this.closed || this.companionActivity(companionId).some(a => a.kind !== 'memory' && a.kind !== 'observation') || this.queues.has(key) || this.taskQueues.has(key) || this.heartbeatQueues.has(key) || this.steeringQueues.has(key) || this.store.isCompanionRemoving(companionId))
+        if (this.closed || this.taskQueues.has(key) || this.heartbeatQueues.has(key) || this.store.isCompanionRemoving(companionId))
             return;
         const state = this.store.snapshot(), companion = state.companions.find(c => c.id === companionId);
-        const pendingRoute = state.sessions.find(r => r.companionId === companionId && r.postReplyOpportunity?.status === 'pending');
+        const activity = this.companionActivity(companionId);
+        const pendingRoute = state.sessions.filter(r => r.companionId === companionId && r.postReplyOpportunity?.status === 'pending' && !this.queues.has(r.sessionId) && !this.steeringQueues.has(r.sessionId) && !activity.some(a => a.sessionId === r.sessionId)).sort((a, b) => a.postReplyOpportunity.dueAt - b.postReplyOpportunity.dueAt)[0];
         let route = pendingRoute ?? state.sessions.find(r => r.id === companion?.idleContact?.routeId && r.companionId === companionId);
         const continuation = !!pendingRoute;
         if (pendingRoute && companion) {
             const pending = pendingRoute.postReplyOpportunity;
             if (!postReplyCurrent(state, companion, pendingRoute) || Date.now() > pending.expiresAt) {
-                await this.cancelPostReply(companionId);
+                await this.cancelPostReply(companionId, undefined, route?.sessionId);
                 return;
             }
             if (Date.now() < pending.dueAt)
@@ -226,7 +254,7 @@ export class PartnerAgentRuntime {
         if (channel?.platform === 'qq' && route.qqSessionMode !== (qqSettings(channel.qq).mainSessionPeers.includes(qqSessionTarget(route.userId)) ? 'main' : 'separate'))
             route = await this.ensureSession(companion, route.channelId, route.userId);
         const agent = await this.ensureAgent(companion, route);
-        if (agent.status !== 'idle' || this.companionActivity(companionId).some(a => a.kind !== 'memory' && a.kind !== 'observation') || this.queues.has(key) || this.taskQueues.has(key))
+        if (agent.status !== 'idle' || this.companionActivity(companionId).some(a => a.sessionId === route.sessionId) || this.queues.has(route.sessionId) || this.steeringQueues.has(route.sessionId) || this.taskQueues.has(key))
             return;
         const user = lastIdleContactUser(agent.session.snapshotEvents());
         const completed = [...agent.session.snapshotEvents()].reverse().find(e => e.type === 'turn/end');
@@ -234,14 +262,14 @@ export class PartnerAgentRuntime {
             user.at = Math.max(user.at, completed.time);
         if (continuation) {
             if (user?.id !== route.postReplyOpportunity?.userMessageId) {
-                await this.cancelPostReply(companionId);
+                await this.cancelPostReply(companionId, undefined, route?.sessionId);
                 return;
             }
         }
         else if (!idleContactDue(this.store.snapshot(), companion, user, Date.now(), timeZone))
             return;
         const stableSeq = agent.session.seq;
-        const message = createUserMessage({ content: [{ type: 'text', text: idleActivityPrompt(this.store.snapshot(), companion) + (continuation ? '\n' + POST_REPLY_PROMPT : '')
+        const message = createUserMessage({ content: [{ type: 'text', text: idleActivityPrompt(this.store.snapshot(), companion, agent.session.snapshotEvents()) + (continuation ? '\n' + POST_REPLY_PROMPT : '')
                 }], source: { kind: 'plugin:@lemoncat7/dsh-partner', plugin: '@lemoncat7/dsh-partner', form: 'notice', summary: IDLE_CONTACT_NOTICE } });
         let claimed = false;
         await this.store.update(draft => {
@@ -260,7 +288,7 @@ export class PartnerAgentRuntime {
             claimed = true;
         });
         // Claim before generation survives restart. Don't replay uncertain sends or steal active turns.
-        if (!claimed || this.closed || this.store.isCompanionRemoving(companionId) || agent.status !== 'idle' || agent.session.seq !== stableSeq || this.queues.has(key) || this.taskQueues.has(key))
+        if (!claimed || this.closed || this.store.isCompanionRemoving(companionId) || agent.status !== 'idle' || agent.session.seq !== stableSeq || this.queues.has(route.sessionId) || this.taskQueues.has(key))
             return;
         const currentState = this.store.snapshot(), current = currentState.companions.find(c => c.id === companionId), currentRoute = currentState.sessions.find(r => r.id === route.id);
         if (!current || !currentRoute || !activityPolicyCurrent(currentState, current, currentRoute) || isSleeping(current) || current.updatedAt !== companion.updatedAt || this.isArchived(route))
@@ -276,16 +304,25 @@ export class PartnerAgentRuntime {
         if (channel?.platform === 'qq' && route.qqSessionMode !== (qqSettings(channel.qq).mainSessionPeers.includes(qqSessionTarget(route.userId)) ? 'main' : 'separate'))
             return false;
         const agent = await this.ensureAgent(companion, route);
-        return lastIdleContactUser(agent.session.snapshotEvents())?.id === origin.userMessageId;
+        const events = agent.session.snapshotEvents();
+        const noticeIndex = events.findIndex(e => e.type === 'user/message' && e.data.id === origin.messageId);
+        if (noticeIndex >= 0) {
+            const tail = events.slice(noticeIndex + 1);
+            const boundary = tail.findIndex(e => e.type === 'turn/start' || e.type === 'turn/end' || e.type === 'user/message' && e.data.source.kind === 'user');
+            if (tail.slice(0, boundary < 0 ? tail.length : boundary).some(isActivitySilenceRequested))
+                return false;
+        }
+        return lastIdleContactUser(events)?.id === origin.userMessageId;
     }
     async reply(companion, channelId, userId, message, progress) {
-        const key = `companion:${companion.id}`;
-        await this.cancelPostReply(companion.id);
+        const route = await this.ensureSession(companion, channelId, userId, message.sessionTitle);
+        const key = route.sessionId;
+        await this.cancelPostReply(companion.id, undefined, route.sessionId);
         const queuedAt = Date.now();
         const previous = this.queues.get(key) ?? Promise.resolve();
         let output = { text: '', attachments: [] };
         reportProgress(progress, 'queued');
-        const current = previous.catch(() => { }).then(async () => { output = await this.drive(companion, channelId, userId, message, progress, queuedAt); });
+        const current = previous.catch(() => { }).then(async () => { output = await this.replySlots.use(() => this.drive(companion, channelId, userId, message, progress, queuedAt, route)); });
         this.queues.set(key, current);
         try {
             await current;
@@ -297,8 +334,9 @@ export class PartnerAgentRuntime {
         }
     }
     async steer(companion, channelId, userId, message) {
-        await this.cancelPostReply(companion.id);
-        const key = `companion:${companion.id}`;
+        const route = await this.ensureSession(companion, channelId, userId, message.sessionTitle);
+        const key = route.sessionId;
+        await this.cancelPostReply(companion.id, undefined, route.sessionId);
         const previous = this.steeringQueues.get(key) ?? Promise.resolve();
         let accepted = false;
         const current = previous.catch(() => { }).then(async () => { accepted = await this.deliverSteering(companion, channelId, userId, message); });
@@ -700,13 +738,13 @@ export class PartnerAgentRuntime {
     }
     async runHeartbeatWhenIdle(key, companion, route, concerns) {
         for (;;) {
-            await this.queues.get(key)?.catch(() => { });
+            await this.queues.get(route.sessionId)?.catch(() => { });
             const conversation = await this.ensureAgent(companion, route);
             if (conversation.status !== 'idle')
                 await conversation.whenIdle();
             const stableSeq = conversation.session.seq;
             await delay(2_000);
-            if (this.queues.has(key))
+            if (this.queues.has(route.sessionId))
                 continue;
             if (conversation.status !== 'idle' || conversation.session.seq !== stableSeq)
                 continue;
@@ -714,11 +752,16 @@ export class PartnerAgentRuntime {
         }
     }
     async observeSessionEvent(session, event) {
+        if (event.type === 'turn/end') {
+            const agent = this.ctx?.agents?.get(session.id);
+            if (agent)
+                this.admittedInputs?.delete(agent);
+        }
         if (event.type === 'user/message' && event.data.source.kind === 'user') {
             const owner = this.store.snapshot().sessions.find(r => r.sessionId === session.id)?.companionId;
             if (owner) {
-                this.latestPostReplyInput.set(owner, event.data.id);
-                await this.cancelPostReply(owner, event.data.id);
+                this.latestPostReplyInput.set(session.id, event.data.id);
+                await this.cancelPostReply(owner, event.data.id, session.id);
             }
             return;
         }
@@ -760,7 +803,7 @@ export class PartnerAgentRuntime {
             return;
         const scopeId = memoryScope(route.channelId, route.userId);
         const concernDirective = identityRelation && !identityRelation.matched ? undefined : await this.concerns?.applyUserDirective(companion.id, scopeId, userText, event.time);
-        const created = companion.automation.memory.enabled && this.reflection !== undefined ? await this.reflection.reflect(companion, {
+        const created = companion.automation.memory.enabled && automaticMemoryAllowed(session.id, events, this.store.snapshot().sessions) && this.reflection !== undefined ? await this.reflection.reflect(companion, {
             id: `turn-${createHash('sha256').update(JSON.stringify([session.id, event.time, userText])).digest('hex').slice(0, 32)}`, companionId: companion.id, scopeId: conversationMemoryScope(route, this.store.snapshot().sessions),
             characterEnabled: companion.characterCard?.enabled === true,
             ...(identityRelation ? { identityRelation } : {}),
@@ -883,12 +926,12 @@ export class PartnerAgentRuntime {
             throw new Error('伙伴不存在');
     }
     /** Awaited by the host before prompt/tool assembly, never from a running tool. */
-    async prepareAgentTurn(agent, turn, signal) {
+    async prepareAgentTurn(agent, turn, signal, messages = []) {
         if (this.closed)
             throw new Error('伙伴运行时已关闭');
-        if (this.preparedTurns.get(agent) === turn)
-            return;
-        await this.prepareAgentAssembly(agent, signal);
+        this.admittedInputs.set(agent, messages);
+        if (this.preparedTurns.get(agent) !== turn)
+            await this.prepareAgentAssembly(agent, signal);
         await this.prepareConversationContext(agent, signal);
         this.preparedTurns.set(agent, turn);
     }
@@ -908,7 +951,7 @@ export class PartnerAgentRuntime {
         if (this.store.isCompanionRemoving(configuration.companion.id))
             throw new Error('伙伴正在删除，不能启动新轮次');
         signal.throwIfAborted();
-        const access = resolveToolAccess({ agent, state: this.store.snapshot() });
+        const access = resolveToolAccess({ agent, state: this.store.snapshot(), ...(this.admittedInputs.get(agent)?.length ? { events: this.inputEvents(agent) } : {}) });
         let presentationChanged = false;
         const stableNative = configuration.companion.toolDiscovery || !!access.allowedTools;
         if (stableNative && !this.replyPresentations.has(agent) && typeof agent.ctx.tools?.presentAs === 'function') {
@@ -942,6 +985,18 @@ export class PartnerAgentRuntime {
     }
     replyPresentations = new Map();
     contextRevisions = new WeakMap();
+    admittedInputs = new WeakMap();
+    /** Projection only: the host commits admitted input after prompt preparation. */
+    inputEvents(agent) {
+        const events = agent.session.snapshotEvents();
+        const pending = this.admittedInputs?.get(agent) ?? [];
+        if (!pending.length)
+            return events;
+        const committed = new Set(events.flatMap(e => e.type === 'user/message' ? [e.data.id] : []));
+        return [...events, ...pending.filter(m => !committed.has(m.id)).map((data, index) => ({
+                type: 'user/message', data, seq: (agent.session.seq + index + 1), time: Date.now(), surfaceOp: 'append',
+            }))];
+    }
     async prepareConversationContext(agent, signal) {
         const config = this.configurations.forSession(agent.session.id);
         if (!config)
@@ -949,22 +1004,25 @@ export class PartnerAgentRuntime {
         const { companion, route } = config;
         const state = this.store.snapshot();
         const relationEvents = state.channels?.some(c => c.platform === 'qq' && state.sessions.some(r => r.sessionId === agent.session.id && r.channelId === c.id))
-            ? agent.session.snapshotEvents() : undefined;
+            ? this.inputEvents(agent) : undefined;
         const identityRelation = relationEvents ? currentQqIdentityRelation(agent.session.id, relationEvents, state.sessions, state.channels) : undefined;
-        if (!identityRelation && !relationshipTextForIdentity(companion) && (!this.memory || !companion.automation.memory.enabled) && !companion.characterCard?.enabled && !renderSleepContext(companion, route.id)) {
+        const committedMessages = agent.session.deriveMessages?.() ?? [];
+        const committedIds = new Set(committedMessages.map(m => m.id));
+        const messages = [...committedMessages, ...(this.admittedInputs?.get(agent) ?? []).filter(m => !committedIds.has(m.id))];
+        const last = [...messages].reverse().find(m => m.role === 'user' && m.source.kind === 'user');
+        const query = last && last.role === 'user' ? textContent(last.content) : '';
+        if (!identityRelation && !relationshipTextForIdentity(companion) && (!this.memory || !companion.automation.memory.enabled) && !companion.characterCard?.enabled && !renderSleepContext(companion, route.id) && !personaReferenceRequested(query)) {
             this.characterContexts.get(agent.session.id)?.();
             this.characterContexts.delete(agent.session.id);
             this.contextRevisions.delete(agent);
             return false;
         }
-        const messages = agent.session.deriveMessages();
-        const last = [...messages].reverse().find(m => m.role === 'user' && m.source.kind === 'user');
-        const query = last && last.role === 'user' ? textContent(last.content) : '';
-        const events = relationEvents ?? agent.session.snapshotEvents();
+        const events = relationEvents ?? this.inputEvents(agent);
         const origin = [...events].reverse().find(e => e.type === 'user/message' && (e.data.source.kind === 'user' || isIdleContactNotice(e) || isInternalTaskNotice(e)));
         const autonomous = Boolean(origin && isIdleContactNotice(origin));
         const affectionAudience = currentAffectionAudience(state, companion.id, agent.session.id, events);
-        const revision = `${JSON.stringify(identityRelation)}:${config.revision}:${last?.id ?? ''}:${autonomous && origin?.type === 'user/message' ? origin.data.id : ''}:${companion.sleepState?.dreams?.at(-1)?.id ?? ''}:${affectionAudience}:${companion.affection?.updatedAt ?? 0}`;
+        const access = resolveToolAccess({ agent, state, events });
+        const revision = `${JSON.stringify(access)}:${JSON.stringify(identityRelation)}:${config.revision}:${last?.id ?? ''}:${autonomous && origin?.type === 'user/message' ? origin.data.id : ''}:${JSON.stringify([companion.sleepState?.episode, companion.sleepState?.reception, Math.round(fatigueValue(companion))])}:${companion.sleepState?.dreams?.at(-1)?.id ?? ''}:${affectionAudience}:${companion.affection?.updatedAt ?? 0}`;
         if (this.contextRevisions.get(agent) === revision)
             return false;
         const scope = conversationMemoryScope(route, this.store.snapshot().sessions);
@@ -979,16 +1037,15 @@ export class PartnerAgentRuntime {
         }
         signal.throwIfAborted();
         const relationshipAllowed = !identityRelation || identityRelation.matched;
-        const access = resolveToolAccess({ agent, state });
-        const text = [access.allowedTools || !access.sendTools ? access.denialReason + ' 回复能力通过 partner_tools 查询和调用（未开启统一入口时使用原工具）；语音能力为 partner_qq_reply；不能代办操作，不承诺使用私有能力。' : '',
+        const text = [origin?.type === 'user/message' && origin.data.source.kind === 'user' && access.sendTools && (!access.allowedTools || access.allowedTools.includes('partner_identity')) && personaReferenceRequested(query) ? renderPersonaReference() : '', access.allowedTools || !access.sendTools ? access.denialReason + ' 回复能力通过 partner_tools 查询和调用（未开启统一入口时使用原工具）；语音能力为 partner_qq_reply；不能代办操作，不承诺使用私有能力。' : '',
             renderIdentityRelationship(companion, identityRelation ? { channel: 'qq', matched: identityRelation.matched } : { channel: 'default' }),
             renderAffection(companion, affectionAudience),
             renderCharacterContext(companion.characterCard, messages.slice(-6).filter(m => m.role === 'user' || m.role === 'assistant').map(m => textContent(m.content)).join('\n').slice(-12000), relationshipAllowed ? story : undefined),
             recalled ? renderMemory(recalled.relevant, recalled.connections, recalled.scenes, recalled.history) : '',
             recalled && relationshipAllowed ? renderProfile(recalled.profile) : '',
             renderConversationTurn(companion.characterCard, consecutiveUserMessages, autonomous),
-            renderQqIdentityRelation(identityRelation),
-            renderSleepContext(companion, this.store.snapshot().sessions.filter(r => r.companionId === companion.id && r.sessionId === route.sessionId).map(r => r.id)),
+            renderQqIdentityRelation(identityRelation, autonomous && access.sendTools && !access.allowedTools),
+            renderSleepContext(companion, this.store.snapshot().sessions.filter(r => r.companionId === companion.id && r.sessionId === route.sessionId).map(r => r.id), autonomous ? undefined : last?.id),
         ].filter(Boolean).join('\n\n');
         this.characterContexts.get(agent.session.id)?.();
         // A changing .section() appends an entire system prompt on in-history routes.
@@ -1007,7 +1064,7 @@ export class PartnerAgentRuntime {
         const companion = this.configurations.companion(companionId);
         if (!companion?.automation.memory.enabled)
             return;
-        const routes = [...new Map(this.store.snapshot().sessions.filter(r => r.companionId === companionId).map(r => [r.sessionId, r])).values()];
+        const routes = this.store.snapshot().sessions.filter(r => r.companionId === companionId && r.kind === 'local');
         for (const route of routes) {
             if (this.isArchived(route))
                 continue;
@@ -1031,6 +1088,8 @@ export class PartnerAgentRuntime {
                         replies.push(textContent(next.content));
                 }
                 const original = agent.session.snapshotEvents().find(e => e.type === 'user/message' && e.data.id === item.id);
+                if (!original || !automaticMemoryAllowed(route.sessionId, [original], this.store.snapshot().sessions))
+                    continue;
                 await this.memory.enqueue({ id: 'renewal-' + createHash('sha256').update(route.sessionId + ':' + item.id).digest('hex').slice(0, 32),
                     companionId, scopeId: scope, sessionId: route.sessionId, at: original?.time ?? Date.now(), userMessageIds: [item.id],
                     user: textContent(item.content), assistant: replies.join('\n\n') || '（本条消息没有已完成的回复，仅整理用户原话，不推测处理结果。）',
@@ -1039,17 +1098,17 @@ export class PartnerAgentRuntime {
         }
     }
     async renewReviewedContexts(companionId, day) {
-        if (!this.memory || this.isCompanionBusy(companionId) || this.queues.has(`companion:${companionId}`))
+        if (!this.memory || this.isCompanionBusy(companionId) || this.store.snapshot().sessions.some(r => r.companionId === companionId && this.queues.has(r.sessionId)))
             return 0;
         const companion = this.configurations.companion(companionId);
         if (!companion || companion.automation.memory.contextRenewalEnabled === false)
             return 0;
-        const learning = companion.automation.memory.enabled;
         let renewed = 0;
         const routes = [...new Map(this.store.snapshot().sessions.filter(r => r.companionId === companionId).map(r => [r.sessionId, r])).values()];
         for (const route of routes) {
             if (this.ctx.workspaceRegistry.archivedSessionIds.includes(route.sessionId))
                 continue;
+            const learning = companion.automation.memory.enabled && this.store.snapshot().sessions.some(r => r.kind === 'local' && r.sessionId === route.sessionId && r.companionId === companionId);
             const scope = conversationMemoryScope(route, this.store.snapshot().sessions);
             const agent = await this.ensureAgent(companion, route);
             if (agent.session.surface.nodes.length <= 1) {
@@ -1068,7 +1127,7 @@ export class PartnerAgentRuntime {
                     return false;
                 if (!learning)
                     return true;
-                return this.memory.coversContext(companionId, scope, agent.session.deriveMessages().filter(m => m.role === 'user' && m.source.kind === 'user').map(m => ({ id: m.id, text: textContent(m.content) })));
+                return this.memory.coversContext(companionId, scope, agent.session.deriveMessages().filter(m => m.role === 'user' && m.source.kind === 'user' && automaticMemoryAllowed(route.sessionId, agent.session.snapshotEvents().filter(e => e.type === 'user/message' && e.data.id === m.id), this.store.snapshot().sessions)).map(m => ({ id: m.id, text: textContent(m.content) })));
             }, session => this.ctx.sessions.flush(session), learning);
             if (removed > 0 || agent.session.deriveMessages().some(m => m.role === 'user' && m.source.kind === 'plugin:@lemoncat7/dsh-partner' && m.source.form === 'notice' && m.source.summary === `上下文焕新 ${day}`)) {
                 await this.memory.markRenewed(companionId, route.sessionId, day, removed);
@@ -1153,11 +1212,13 @@ export class PartnerAgentRuntime {
         restored?.dispose();
         this.restoredCompositions.delete(sessionId);
     }
-    async drive(companion, channelId, userId, message, progress, queuedAt = Date.now()) {
+    async drive(companion, channelId, userId, message, progress, queuedAt = Date.now(), preparedRoute) {
         reportProgress(progress, 'working');
         const enteredAt = Date.now();
         let submittedAt = enteredAt, modelEndedAt = enteredAt, lastTurnEnd;
-        const session = await this.ensureSession(companion, channelId, userId, message.sessionTitle);
+        const session = preparedRoute ?? await this.ensureSession(companion, channelId, userId, message.sessionTitle);
+        if (!this.store.snapshot().sessions.some(r => r.id === session.id && r.sessionId === session.sessionId))
+            throw new Error('会话配置已变化，请重新发送消息');
         const agent = await this.ensureAgent(companion, session);
         if (agent.status !== 'idle')
             await agent.whenIdle();
@@ -1179,7 +1240,7 @@ export class PartnerAgentRuntime {
             if (event.type === 'turn/start' || event.type === 'turn/end' || (isInternalTaskNotice(event) && !isRequirementDeliveryReceipt(event)))
                 directProgress = false;
             if (event.type === 'user/message' && event.data.source.kind === 'user')
-                directProgress = true;
+                directProgress = questionOrigin(agent.session.id, agent.session.snapshotEvents(), this.store.snapshot().sessions)?.id === session.id;
             const stage = replyStage(event);
             if (stage)
                 reportProgress(progress, stage);
@@ -1189,6 +1250,7 @@ export class PartnerAgentRuntime {
                     reportProgress(progress, activity);
             }
         });
+        const detachPreamble = progress?.acknowledge ? installTaskPreamble(agent, progress.acknowledge, () => questionOrigin(agent.session.id, agent.session.snapshotEvents(), this.store.snapshot().sessions)?.id === session.id) : undefined;
         try {
             const userMessage = createUserMessage({
                 content: inbound.content,
@@ -1202,6 +1264,7 @@ export class PartnerAgentRuntime {
             modelEndedAt = Date.now();
         }
         finally {
+            detachPreamble?.();
             detach();
         }
         const response = channelReplyPartsAfter(agent.session.snapshotEvents(), startSeq);
@@ -1273,7 +1336,7 @@ export class PartnerAgentRuntime {
             return existing;
         const sharedScope = conversationMemoryScope(primary, [primary]);
         const sources = isQq ? snapshot.sessions.filter(r => r.channelId === channelId && r.companionId === companion.id && qqSessionTarget(r.userId) === target && r.memoryScopeId !== sharedScope).map(r => memoryScope(r.channelId, r.userId)) : [];
-        if (existing?.memoryScopeId !== sharedScope || sources.length)
+        if ((!isQq || !target.startsWith('group:') && qqSettings(channel?.qq).mainSessionPeers.includes(target)) && (existing?.memoryScopeId !== sharedScope || sources.length))
             await this.memory?.mergeScopes(companion.id, sharedScope, [...new Set([...sources, memoryScope(channelId, userId)])], recoverLeases);
         let result;
         await this.store.update(state => {