@lemoncat7/dsh-partner 2.11.6 → 2.21.11

package/lib/agent-runtime.js

@@ -1,3 +1,15 @@
+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';
+import { resolveToolAccess, installToolAccessGuard } from './execution/tool-access-adapter.js';
+import { renderIdentityRelationship, relationshipTextForIdentity } from './character/relationship-adapter.js';
+import { affectionEnabled, awardAffection, renderAffection } from './character/affection.js';
+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';
 import { renderConversationTurn } from './character/conversation-behavior.js';
@@ -12,7 +24,7 @@ import { conversationMemoryScope } from './memory-scope.js';
 import { mkdir, realpath, stat, writeFile } from 'node:fs/promises';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
-import { IDLE_CONTACT_NOTICE, idleContactDue, idleContactDay, lastIdleContactUser } from './character/idle-contact.js';
+import { IDLE_CONTACT_NOTICE, idleActivityPrompt, isIdleContactNotice, idleActivityProbability, idleContactDue, idleContactDay, idleContactRouteAllowed, lastIdleContactUser } from './character/idle-contact.js';
 import { scopeOf, scopeParentOf } from '@deepseek-ai/dsh-scope';
 import { SessionConfigurationIndex } from './companions/session-configuration.js';
 import { isMissingSession, SessionRecoveryJobs } from './companions/session-recovery.js';
@@ -27,6 +39,7 @@ import { concernExecutionNotes } from './concern-execution-notes.js';
 import { bindTaskSshAccess } from './collaboration/ssh-task-access.js';
 import { hasConcernReply } from './concern-execution-receipt.js';
 import { executeObservationLoop } from './observation-loop.js';
+import { observationKnowledgeEntryDenial } from './observation-knowledge-entry.js';
 import { waitForBoardTurn } from './tasks/continuation-yield.js';
 import { assistantTextAfter, renderPartnerPersona, renderToolProtocol, resolvePartnerAgentOptions as resolveAgentOptions } from './execution/agent-support.js';
 import { channelReplyPartsAfter, isInternalTaskNotice, isRequirementDeliveryReceipt } from './channels/delivery-policy.js';
@@ -36,6 +49,7 @@ export { extractOutboundAttachments } from './channels/outbound-media.js';
 export { renderToolProtocol, resolvePartnerAgentOptions as resolveAgentOptions } from './execution/agent-support.js';
 const PARTNER_TASK_TIMEOUT_MS = 30 * 60_000;
 const HEARTBEAT_READ_ONLY_TOOLS = new Set([
+    'knowledge',
     'knowledge_base_search',
     'knowledge_search',
     'knowledge_read',
@@ -55,6 +69,7 @@ export class PartnerAgentRuntime {
     reflection;
     concerns;
     composer;
+    latestPostReplyInput = new Map();
     handles = new Map();
     queues = new Map();
     heartbeatQueues = new Map();
@@ -65,7 +80,9 @@ export class PartnerAgentRuntime {
     restoredCompositionJobs = new Map();
     disposeAgentListener;
     disposeConfigurationListener;
+    disposeToolAuthority;
     disposeAssemblyListener;
+    autonomousAssemblyContexts = new WeakSet();
     rebuildingAssemblies = new WeakSet();
     configurations;
     characterContexts = new Map();
@@ -84,33 +101,65 @@ export class PartnerAgentRuntime {
         this.concerns = concerns;
         this.composer = composer;
         this.configurations = new SessionConfigurationIndex(store);
+        this.disposeToolAuthority = typeof this.ctx.tools?.guard === 'function' ? installToolAccessGuard(this.ctx.tools, () => this.store.snapshot()) : (() => { });
         // Current hosts snapshot providers BEFORE agent/pre-step. Rebuild the first
         // assembly after installing scoped contributions; returning the old snapshot
         // would still omit tools for one request even though registration succeeded.
         this.disposeAssemblyListener = typeof this.ctx.on === 'function'
             ? this.ctx.on('system-prompt/assemble', async (_assembly, context, next) => {
-                if (!context.agent || !context.signal || this.rebuildingAssemblies.has(context))
+                if (!context.agent || !context.signal)
                     return next();
+                const enforce = (assembly) => {
+                    if (this.autonomousAssemblyContexts.has(context))
+                        return assembly;
+                    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(), ...(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))
+                    return enforce(await next());
                 const changed = await this.prepareAgentAssembly(context.agent, context.signal);
                 const contextual = await this.prepareConversationContext(context.agent, context.signal);
                 if (!changed && !contextual)
-                    return next();
+                    return enforce(await next());
                 this.rebuildingAssemblies.add(context);
                 try {
-                    return await this.ctx.systemPrompt.assemble(context);
+                    return enforce(await this.ctx.systemPrompt.assemble(context));
                 }
                 finally {
                     this.rebuildingAssemblies.delete(context);
                 }
             }) : () => { };
         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);
@@ -122,51 +171,143 @@ 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
+            && ['pending', 'claimed'].includes(r.postReplyOpportunity.status) && r.postReplyOpportunity.userMessageId !== keepUserMessageId;
+        if (!this.store.snapshot().sessions.some(needsCancel))
+            return;
+        await this.store.update(state => { for (const route of state.sessions)
+            if (needsCancel(route))
+                route.postReplyOpportunity.status = 'cancelled'; });
+    }
+    async localReplyDisplayed(source) {
+        const state = this.store.snapshot(), route = state.sessions.find(r => r.id === source.routeId && r.sessionId === source.sessionId && r.kind === 'local');
+        const companion = state.companions.find(c => c.id === route?.companionId);
+        if (!route || !companion || !postReplyAllowed(state, companion, route))
+            return;
+        const agent = await this.ensureAgent(companion, route);
+        if (agent.status !== 'idle')
+            await agent.whenIdle();
+        await this.replyDelivered(source);
+    }
+    /** Called only after delivery succeeds; autonomous notices never carry this provenance. */
+    async replyDelivered(source) {
+        const state = this.store.snapshot(), route = state.sessions.find(r => r.id === source.routeId && r.sessionId === source.sessionId);
+        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}`;
+        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)
+            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)
+                return;
+            // At most one pending continuation per companion; different owner accounts share it.
+            for (const other of draft.sessions)
+                if (other.companionId === companion.id && 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,
+                deliveredAt: now, dueAt: now + 20_000 + Math.floor(Math.random() * 70_000), expiresAt: now + 180_000,
+                probability, status: Math.random() < probability ? 'pending' : 'missed' };
+        });
+    }
     /** 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.isCompanionBusy(companionId) || this.queues.has(key) || this.taskQueues.has(key) || this.heartbeatQueues.has(key) || this.steeringQueues.has(key) || this.store.isCompanionRemoving(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))
             return;
         const state = this.store.snapshot(), companion = state.companions.find(c => c.id === companionId);
-        const route = state.sessions.find(r => r.id === companion?.idleContact?.routeId && r.companionId === companionId);
+        const pendingRoute = state.sessions.find(r => r.companionId === companionId && r.postReplyOpportunity?.status === 'pending');
+        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);
+                return;
+            }
+            if (Date.now() < pending.dueAt)
+                return;
+        }
         if (!companion?.idleContact?.enabled || !route || this.isArchived(route))
             return;
+        const channel = state.channels.find(c => c.id === route.channelId);
+        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.isCompanionBusy(companionId) || this.queues.has(key) || this.taskQueues.has(key))
+        if (agent.status !== 'idle' || this.companionActivity(companionId).some(a => a.kind !== 'memory' && a.kind !== 'observation') || this.queues.has(key) || this.taskQueues.has(key))
             return;
         const user = lastIdleContactUser(agent.session.snapshotEvents());
-        if (!idleContactDue(this.store.snapshot(), companion, user, Date.now(), timeZone))
+        const completed = [...agent.session.snapshotEvents()].reverse().find(e => e.type === 'turn/end');
+        if (user && completed)
+            user.at = Math.max(user.at, completed.time);
+        if (continuation) {
+            if (user?.id !== route.postReplyOpportunity?.userMessageId) {
+                await this.cancelPostReply(companionId);
+                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: '这是已开启的闲时主动联系，不是用户新发言。沿用当前角色和真实聊天记录，自然主动说一句，有具体话题才展开；不固定问候、不凑两段、不说“检测到你空闲”、不催促或内疚施压，不假装已做过事情。不要重复回答上轮问题。只生成这次联系的最终正文，不调用渠道发送工具、不设置下一次提醒；系统会将最终正文发送到指定会话。其他工具权限保持原样。'
+        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 => {
             const current = draft.companions.find(c => c.id === companionId), target = draft.sessions.find(r => r.id === route.id);
             const now = Date.now();
-            if (!current || current.updatedAt !== companion.updatedAt || !target || target.sessionId !== route.sessionId || !idleContactDue(draft, current, user, now, timeZone))
+            if (!current || current.updatedAt !== companion.updatedAt || !target || target.sessionId !== route.sessionId || (continuation ? !postReplyCurrent(draft, current, target, now) || target.postReplyOpportunity?.status !== 'pending' || target.postReplyOpportunity.userMessageId !== user?.id || now > target.postReplyOpportunity.expiresAt : !idleContactDue(draft, current, user, now, timeZone)))
                 return;
+            const probability = continuation ? target.postReplyOpportunity.probability : idleActivityProbability(draft, current, user, now);
+            target.idleActivityCheck = { at: now, probability };
+            if (!continuation && Math.random() >= probability)
+                return;
+            if (continuation)
+                target.postReplyOpportunity.status = 'claimed';
             const day = idleContactDay(now, timeZone);
-            target.idleContactState = { userMessageId: user.id, messageId: message.id, attemptedAt: now, day, count: (target.idleContactState?.day === day ? target.idleContactState.count : 0) + 1, timeZone, policyRevision: current.updatedAt };
+            target.idleContactState = { ...(continuation ? { kind: 'post-reply' } : {}), userMessageId: user.id, messageId: message.id, attemptedAt: now, day, count: (target.idleContactState?.day === day ? target.idleContactState.count : 0) + 1, timeZone, policyRevision: current.updatedAt };
             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))
             return;
-        const current = this.store.snapshot().companions.find(c => c.id === companionId);
-        if (!current?.idleContact?.enabled || current.updatedAt !== companion.updatedAt || this.isArchived(route))
+        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))
             return;
         agent.followup(message);
     }
+    async idleContactDeliveryCurrent(origin) {
+        const state = this.store.snapshot(), route = state.sessions.find(r => r.id === origin.routeId);
+        const companion = state.companions.find(c => c.id === route?.companionId);
+        if (!route || !companion || route.sessionId !== origin.sessionId || !activityPolicyCurrent(state, companion, route) || companion.updatedAt !== origin.policyRevision || route.idleContactState?.messageId !== origin.messageId || !idleContactRouteAllowed(state, companion, route.id) || isSleeping(companion) || this.isArchived(route) || this.store.isCompanionRemoving(companion.id))
+            return false;
+        const channel = state.channels.find(c => c.id === route.channelId);
+        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;
+    }
     async reply(companion, channelId, userId, message, progress) {
         const key = `companion:${companion.id}`;
+        await this.cancelPostReply(companion.id);
+        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); });
+        const current = previous.catch(() => { }).then(async () => { output = await this.drive(companion, channelId, userId, message, progress, queuedAt); });
         this.queues.set(key, current);
         try {
             await current;
@@ -178,6 +319,7 @@ export class PartnerAgentRuntime {
         }
     }
     async steer(companion, channelId, userId, message) {
+        await this.cancelPostReply(companion.id);
         const key = `companion:${companion.id}`;
         const previous = this.steeringQueues.get(key) ?? Promise.resolve();
         let accepted = false;
@@ -196,6 +338,9 @@ export class PartnerAgentRuntime {
         const route = this.store.snapshot().sessions.find(item => item.channelId === channelId && item.userId === userId && item.companionId === companion.id);
         if (route === undefined)
             return false;
+        const channel = this.store.snapshot().channels.find(c => c.id === channelId);
+        if (channel?.platform === 'qq' && route.qqSessionMode !== (qqSettings(channel.qq).mainSessionPeers.includes(qqSessionTarget(userId)) ? 'main' : 'separate'))
+            return false;
         const agent = this.handles.get(route.sessionId)?.agent ?? this.ctx.agents.get(route.sessionId);
         if (agent === undefined || agent.status !== 'running')
             return false;
@@ -258,7 +403,7 @@ export class PartnerAgentRuntime {
             // If there was no local conversation, continue the newest existing channel
             // conversation. Do not concatenate unrelated historical transcripts.
             if (!existing) {
-                const previous = state.sessions.filter(item => item.companionId === companion.id && canReuseSession(item, companion.id, this.ctx.workspaceRegistry.archivedSessionIds)).sort((a, b) => b.lastMessageAt - a.lastMessageAt)[0];
+                const previous = state.sessions.filter(item => item.companionId === companion.id && !state.channels.some(c => c.id === item.channelId && c.platform === 'qq') && canReuseSession(item, companion.id, this.ctx.workspaceRegistry.archivedSessionIds)).sort((a, b) => b.lastMessageAt - a.lastMessageAt)[0];
                 if (previous) {
                     route.sessionId = previous.sessionId;
                     if (previous.cwd)
@@ -338,9 +483,16 @@ export class PartnerAgentRuntime {
         const agent = await this.ensureAgent(companion, route);
         if (!this.store.snapshot().sessions.some(s => s.id === route.id && s.sessionId === wake.originSessionId) || this.isArchived(route))
             throw new Error('原续接会话已变更');
-        const assembly = await agent.ctx.systemPrompt.assemble(assembleContextFor(agent, signal));
-        signal.throwIfAborted();
-        assertWakeTools(entry, assembly.tools.map(tool => tool.name));
+        const preflight = assembleContextFor(agent, signal);
+        this.autonomousAssemblyContexts.add(preflight);
+        try {
+            const assembly = await agent.ctx.systemPrompt.assemble(preflight);
+            signal.throwIfAborted();
+            assertWakeTools(entry, assembly.tools.map(tool => tool.name));
+        }
+        finally {
+            this.autonomousAssemblyContexts.delete(preflight);
+        }
         const message = createUserMessage({ content: [{ type: 'text', text: continuationPrompt(entry) }],
             source: { kind: 'plugin:@lemoncat7/dsh-partner', plugin: '@lemoncat7/dsh-partner', form: 'notice', summary: '伙伴长任务续接' } });
         await this.store.update(state => {
@@ -584,6 +736,19 @@ 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);
+            }
+            return;
+        }
         if (event.type !== 'turn/end' || event.data.reason.kind !== 'completed')
             return;
         const route = this.store.snapshot().sessions.find(item => item.sessionId === session.id);
@@ -612,6 +777,7 @@ export class PartnerAgentRuntime {
         if (companion === undefined)
             return;
         const events = completedTurnEvents(session.snapshotEvents(), event);
+        const identityRelation = currentQqIdentityRelation(session.id, events, this.store.snapshot().sessions, this.store.snapshot().channels ?? []);
         const prompt = events.find(item => item.type === 'user/message' && item.data.source.kind === 'user');
         const replies = events.filter(item => item.type === 'assistant/message' && !item.data.interrupted);
         const userText = events.filter(e => e.type === 'user/message' && e.data.source.kind === 'user').map(e => e.type === 'user/message' ? textContent(e.data.content) : '').filter(Boolean).join('\n\n');
@@ -620,10 +786,11 @@ export class PartnerAgentRuntime {
         if (!userText || !assistantText)
             return;
         const scopeId = memoryScope(route.channelId, route.userId);
-        const concernDirective = await this.concerns?.applyUserDirective(companion.id, scopeId, userText, event.time);
+        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, {
             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 } : {}),
             userMessageIds: events.flatMap(e => e.type === 'user/message' && e.data.source.kind === 'user' ? [e.data.id] : []),
             sessionId: session.id, at: event.time, user: userText, assistant: assistantText, concernScopeId: scopeId,
             ...(concernDirective === undefined ? {} : { concernDirective }),
@@ -645,6 +812,9 @@ export class PartnerAgentRuntime {
             const target = state.sessions.find(item => item.id === route.id);
             if (target)
                 target.lastMessageAt = Date.now();
+            const current = state.companions.find(c => c.id === companion.id);
+            if (current && affectionEnabled(current) && affectionTurnEligible(state, current.id, session.id, events))
+                awardAffection(current, `${session.id}:${event.seq}`, event.time);
         });
     }
     async recordConcernCreatedNotice(companion, scopeId, concerns) {
@@ -740,12 +910,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);
     }
@@ -765,6 +935,18 @@ export class PartnerAgentRuntime {
         if (this.store.isCompanionRemoving(configuration.companion.id))
             throw new Error('伙伴正在删除，不能启动新轮次');
         signal.throwIfAborted();
+        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') {
+            this.replyPresentations.set(agent, agent.ctx.tools.presentAs('native'));
+            presentationChanged = true;
+        }
+        else if (!stableNative && this.replyPresentations.has(agent)) {
+            this.replyPresentations.get(agent)();
+            this.replyPresentations.delete(agent);
+            presentationChanged = true;
+        }
         const installed = this.restoredCompositions.get(agent.session.id);
         if (installed?.agent !== agent || installed.revision !== configuration.revision) {
             const job = (async () => {
@@ -783,24 +965,48 @@ export class PartnerAgentRuntime {
             }
             return true;
         }
-        return false;
+        return presentationChanged;
     }
+    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)
             return false;
         const { companion, route } = config;
-        if ((!this.memory || !companion.automation.memory.enabled) && !companion.characterCard?.enabled) {
+        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))
+            ? this.inputEvents(agent) : undefined;
+        const identityRelation = relationEvents ? currentQqIdentityRelation(agent.session.id, relationEvents, state.sessions, state.channels) : undefined;
+        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 revision = `${config.revision}:${last?.id ?? ''}`;
+        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 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);
@@ -814,10 +1020,16 @@ export class PartnerAgentRuntime {
                 consecutiveUserMessages++;
         }
         signal.throwIfAborted();
-        const text = [renderCharacterContext(companion.characterCard, messages.slice(-6).filter(m => m.role === 'user' || m.role === 'assistant').map(m => textContent(m.content)).join('\n').slice(-12000), story),
+        const relationshipAllowed = !identityRelation || identityRelation.matched;
+        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 ? renderProfile(recalled.profile) : '',
-            renderConversationTurn(companion.characterCard, consecutiveUserMessages),
+            recalled && relationshipAllowed ? renderProfile(recalled.profile) : '',
+            renderConversationTurn(companion.characterCard, consecutiveUserMessages, autonomous),
+            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.
@@ -907,10 +1119,25 @@ export class PartnerAgentRuntime {
         }
         return renewed;
     }
-    isCompanionBusy(companionId) {
-        return this.reflection?.isRunning(companionId) === true || this.observationJobs.has(companionId) || this.agentSetupJobs.has(companionId) || this.store.snapshot().sessions.some(route => route.companionId === companionId
-            && (this.handles.get(route.sessionId)?.agent ?? this.ctx.agents.get(route.sessionId))?.status === 'running');
+    companionActivity(companionId) {
+        const activity = [];
+        if (this.reflection?.isRunning(companionId))
+            activity.push({ kind: 'memory', label: '后台记忆整理（不阻止群聊判断）' });
+        if (this.observationJobs.has(companionId))
+            activity.push({ kind: 'observation', label: '归档已完成的聊天' });
+        if (this.agentSetupJobs.has(companionId))
+            activity.push({ kind: 'setup', label: '准备伙伴会话' });
+        const seen = new Set();
+        for (const route of this.store.snapshot().sessions.filter(r => r.companionId === companionId)) {
+            if (seen.has(route.sessionId))
+                continue;
+            seen.add(route.sessionId);
+            if ((this.handles.get(route.sessionId)?.agent ?? this.ctx.agents.get(route.sessionId))?.status === 'running')
+                activity.push({ kind: 'conversation', label: route.qqSessionTitle || (route.kind === 'local' ? '主会话正在运行' : '渠道会话正在运行'), sessionId: route.sessionId });
+        }
+        return activity;
     }
+    isCompanionBusy(companionId) { return this.companionActivity(companionId).length > 0; }
     async releaseCompanion(companionId) {
         const sessions = this.store.snapshot().sessions.filter(item => item.companionId === companionId);
         await Promise.all(sessions.map(async (item) => {
@@ -936,7 +1163,11 @@ export class PartnerAgentRuntime {
         this.closed = true;
         this.disposeConfigurationListener();
         this.disposeAssemblyListener();
+        this.disposeToolAuthority();
         this.disposeAgentListener();
+        for (const dispose of this.replyPresentations.values())
+            dispose();
+        this.replyPresentations.clear();
         this.configurations.close();
         await Promise.allSettled(this.restoredCompositionJobs.values());
         for (const restored of this.restoredCompositions.values())
@@ -948,6 +1179,7 @@ export class PartnerAgentRuntime {
         this.restoredCompositionJobs.clear();
         await Promise.all([...this.handles.values()].map(handle => handle.dispose().catch(() => { })));
         this.handles.clear();
+        this.latestPostReplyInput.clear();
         this.heartbeatQueues.clear();
         this.taskQueues.clear();
         this.steeringQueues.clear();
@@ -962,9 +1194,11 @@ export class PartnerAgentRuntime {
         restored?.dispose();
         this.restoredCompositions.delete(sessionId);
     }
-    async drive(companion, channelId, userId, message, progress) {
+    async drive(companion, channelId, userId, message, progress, queuedAt = Date.now()) {
         reportProgress(progress, 'working');
-        const session = await this.ensureSession(companion, channelId, userId);
+        const enteredAt = Date.now();
+        let submittedAt = enteredAt, modelEndedAt = enteredAt, lastTurnEnd;
+        const session = await this.ensureSession(companion, channelId, userId, message.sessionTitle);
         const agent = await this.ensureAgent(companion, session);
         if (agent.status !== 'idle')
             await agent.whenIdle();
@@ -976,10 +1210,13 @@ export class PartnerAgentRuntime {
                 source: { kind: 'plugin:@lemoncat7/dsh-partner', plugin: '@lemoncat7/dsh-partner', form: 'notice', summary: '伙伴想起了与当前消息相关的挂念' },
             }));
         const startSeq = agent.session.seq;
+        let deliveredUserMessageId = '';
         let directProgress = false;
-        const detach = progress ? this.ctx.on('session/event', (current, event) => {
+        const detach = this.ctx.on('session/event', (current, event) => {
             if (current.id !== agent.session.id || event.seq < startSeq)
                 return;
+            if (event.type === 'turn/end')
+                lastTurnEnd = event.time;
             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')
@@ -992,28 +1229,38 @@ export class PartnerAgentRuntime {
                 if (activity)
                     reportProgress(progress, activity);
             }
-        }) : () => { };
+        });
         try {
             const userMessage = createUserMessage({
                 content: inbound.content,
                 source: { kind: 'user' },
             });
+            deliveredUserMessageId = userMessage.id;
             await this.rememberMessageOrigin(session, userMessage.id);
+            submittedAt = Date.now();
             agent.followup(userMessage);
             await agent.whenIdle();
+            modelEndedAt = Date.now();
         }
         finally {
             detach();
         }
         const response = channelReplyPartsAfter(agent.session.snapshotEvents(), startSeq);
+        const stateStarted = Date.now();
         await this.store.update(state => {
             for (const target of state.sessions)
                 if (target.sessionId === session.sessionId)
                     target.lastMessageAt = Date.now();
         });
+        const stateEnded = Date.now();
         if (deferred && deferred.length > 0)
             await this.concerns?.markMentioned(companion.id, deferred.map(item => item.id)).catch(() => { });
-        return prepareChannelReply(response, session.cwd ?? this.defaultCwd);
+        const reply = await prepareChannelReply(response, session.cwd ?? this.defaultCwd);
+        reply.postReplySource = { routeId: session.id, sessionId: session.sessionId, userMessageId: deliveredUserMessageId };
+        if (this.store.snapshot().channels.some(c => c.id === channelId && c.platform === 'qq'))
+            this.ctx.logger?.info?.(`[qq-latency] ${JSON.stringify({ stage: 'agent', sessionId: session.sessionId, inputPrepMs: submittedAt - enteredAt, modelMs: modelEndedAt - submittedAt, afterModelMs: Date.now() - modelEndedAt })}`);
+        setReplyTiming(reply, { queueMs: enteredAt - queuedAt, inputPrepMs: submittedAt - enteredAt, modelAndIdleMs: modelEndedAt - submittedAt, idleAfterTurnEndMs: lastTurnEnd === undefined ? 0 : Math.max(0, modelEndedAt - lastTurnEnd), stateCommitMs: stateEnded - stateStarted, outboundPrepMs: Date.now() - stateEnded });
+        return reply;
     }
     async rememberMessageOrigin(route, messageId) {
         await this.store.update(state => {
@@ -1049,28 +1296,78 @@ export class PartnerAgentRuntime {
             content.push({ type: 'text', text: '[渠道附件消息]' });
         return { content, query: [message.text, ...message.attachments.map(item => item.name)].filter(Boolean).join(' ') };
     }
-    async ensureSession(companion, channelId, userId) {
+    async reconcileQqSessions() {
+        const state = this.store.snapshot();
+        // Startup only: workers have not started, so stale leases can be recovered.
+        for (const route of state.sessions.filter(r => r.kind === 'channel' && state.channels.some(c => c.id === r.channelId && c.platform === 'qq'))) {
+            const companion = state.companions.find(c => c.id === route.companionId);
+            if (companion)
+                await this.ensureSession(companion, route.channelId, route.userId, undefined, true);
+        }
+    }
+    async ensureSession(companion, channelId, userId, title, recoverLeases = false) {
         const primary = await this.ensureLocalSessionRecord(companion.id);
-        const existing = this.store.snapshot().sessions.find(item => item.channelId === channelId && item.userId === userId);
-        if (existing !== undefined && existing.sessionId === primary.sessionId && canReuseSession(existing, companion.id, this.ctx.workspaceRegistry.archivedSessionIds))
+        const snapshot = this.store.snapshot(), channel = snapshot.channels.find(c => c.id === channelId);
+        const existing = snapshot.sessions.find(item => item.channelId === channelId && item.userId === userId && item.companionId === companion.id);
+        const isQq = channel?.platform === 'qq', target = qqSessionTarget(userId);
+        if (!isQq && existing?.sessionId === primary.sessionId && canReuseSession(existing, companion.id, this.ctx.workspaceRegistry.archivedSessionIds))
             return existing;
-        const now = Date.now();
-        const session = {
-            id: `route-${randomUUID()}`,
-            kind: 'channel',
-            channelId,
-            userId,
-            companionId: companion.id,
-            sessionId: primary.sessionId,
-            cwd: primary.cwd ?? partnerCwd(this.defaultCwd, companion.id),
-            lastMessageAt: now,
-        };
-        await this.memory?.mergeScopes(companion.id, conversationMemoryScope(primary, [primary]), [memoryScope(channelId, userId)]);
+        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)
+            await this.memory?.mergeScopes(companion.id, sharedScope, [...new Set([...sources, memoryScope(channelId, userId)])], recoverLeases);
+        let result;
         await this.store.update(state => {
-            state.sessions = state.sessions.filter(item => !(item.channelId === channelId && item.userId === userId));
-            state.sessions.push(session);
+            const currentChannel = state.channels.find(c => c.id === channelId);
+            if (this.store.isCompanionRemoving(companion.id) || !state.companions.some(c => c.id === companion.id))
+                throw Error('伙伴已移除');
+            const main = !isQq || qqSettings(currentChannel?.qq).mainSessionPeers.includes(target);
+            const current = state.sessions.find(r => r.channelId === channelId && r.userId === userId && r.companionId === companion.id);
+            const peers = state.sessions.filter(r => r.channelId === channelId && r.companionId === companion.id && qqSessionTarget(r.userId) === target).sort((a, b) => b.lastMessageAt - a.lastMessageAt);
+            const archived = this.ctx.workspaceRegistry.archivedSessionIds;
+            // Prefer an active shared group route, then its saved separate conversation.
+            const separate = peers.find(r => r.qqSessionMode !== 'main' && r.sessionId !== primary.sessionId && !archived.includes(r.sessionId));
+            const saved = peers.find(r => r.qqSeparateSessionId && !archived.includes(r.qqSeparateSessionId));
+            const separateId = separate?.sessionId ?? saved?.qqSeparateSessionId ?? `session-${randomUUID()}`;
+            const separateCwd = separate?.cwd ?? saved?.qqSeparateCwd ?? partnerCwd(this.defaultCwd, companion.id);
+            const sessionId = main ? primary.sessionId : separateId;
+            const name = title?.replace(/[\x00-\x1f\x7f]/g, ' ').trim().slice(0, 140) || peers.find(r => r.qqSessionTitle)?.qqSessionTitle || `${target.startsWith('group:') ? '群聊' : '私聊'} · ${target.split(':')[1]}`;
+            const route = { ...current, id: current?.id ?? `route-${randomUUID()}`, kind: 'channel', channelId, userId, companionId: companion.id, sessionId, cwd: main ? (primary.cwd ?? partnerCwd(this.defaultCwd, companion.id)) : separateCwd, lastMessageAt: current?.lastMessageAt ?? Date.now(),
+                ...(isQq ? { memoryScopeId: sharedScope, qqSessionTarget: target, qqSessionMode: main ? 'main' : 'separate', qqSeparateSessionId: separateId, qqSeparateCwd: separateCwd, qqSessionTitle: name } : {}) };
+            const applied = peers.find(r => r.sessionId === sessionId && r.qqAppliedTitle)?.qqAppliedTitle;
+            if (applied)
+                route.qqAppliedTitle = applied;
+            if (current?.sessionId !== sessionId)
+                delete route.inboundMessageIds;
+            // One group context for all members, with separate delivery/grant identities.
+            if (isQq)
+                for (const peer of peers) {
+                    if (peer.sessionId !== sessionId)
+                        delete peer.inboundMessageIds;
+                    Object.assign(peer, { sessionId, cwd: route.cwd, memoryScopeId: sharedScope, qqSessionTarget: target, qqSessionMode: route.qqSessionMode, qqSeparateSessionId: separateId, qqSeparateCwd: separateCwd, qqSessionTitle: name });
+                }
+            state.sessions = state.sessions.filter(r => !(r.channelId === channelId && r.userId === userId));
+            state.sessions.push(route);
+            result = route;
         });
-        return session;
+        return result;
+    }
+    async nameQqSession(agent, route) {
+        if (route.qqSessionMode !== 'separate' || !route.qqSessionTitle)
+            return;
+        const titles = this.ctx.get('sessionTitle');
+        if (!titles)
+            return;
+        const current = titles.get(agent.session);
+        // Respect a user-edited title; only refresh our own generated names.
+        if (current?.source.kind === 'user' && current.title !== route.qqAppliedTitle)
+            return;
+        if (current?.title === route.qqSessionTitle)
+            return;
+        titles.rename(agent.session, route.qqSessionTitle);
+        await this.store.update(state => { for (const peer of state.sessions)
+            if (peer.sessionId === route.sessionId)
+                peer.qqAppliedTitle = route.qqSessionTitle; });
     }
     async ensureAgent(companion, route) {
         if (this.store.isCompanionRemoving(companion.id) || !this.store.snapshot().companions.some(item => item.id === companion.id))
@@ -1094,11 +1391,13 @@ export class PartnerAgentRuntime {
         const held = this.handles.get(route.sessionId);
         if (held !== undefined) {
             await this.attachSession(companion, route);
+            await this.nameQqSession(held.agent, route);
             return held.agent;
         }
         const live = this.ctx.agents.get(route.sessionId);
         if (live !== undefined) {
             await this.attachSession(companion, route);
+            await this.nameQqSession(live, route);
             return live;
         }
         const options = resolveAgentOptions(this.ctx.agentDefaultModel, companion);
@@ -1134,6 +1433,7 @@ export class PartnerAgentRuntime {
         }
         this.handles.set(route.sessionId, handle);
         await this.attachSession(companion, route);
+        await this.nameQqSession(handle.agent, route);
         return handle.agent;
     }
     async composeRestoredAgent(agent, companion, route, revision, signal) {
@@ -1157,7 +1457,7 @@ export class PartnerAgentRuntime {
         try {
             // Native DEPLOYMENT_PERSONA_SUFFIX: delivery style follows the general work preset,
             // while all tool definitions and execution/permission policies remain present.
-            disposers.push(agentCtx.systemPrompt.section({ name: 'partner-identity', order: companion.characterCard?.enabled ? 10200 : -10, interpolate: false, text: renderPartnerPersona(companion, route.kind === 'local' ? 'local' : 'conversation') }));
+            disposers.push(agentCtx.systemPrompt.section({ name: 'partner-identity', order: companion.characterCard?.enabled ? 10200 : -10, interpolate: false, text: renderPartnerPersona(companion, route.kind === 'local' ? 'local' : 'conversation', false) }));
             disposers.push(agentCtx.systemPrompt.section({ name: 'partner-tool-routing', order: -9, text: renderToolProtocol() }));
             if (this.memory)
                 disposers.push(agentCtx.tools.register({
@@ -1371,6 +1671,8 @@ async function resolveHeartbeatFileAccess(cwd, concerns) {
     return { root, writable };
 }
 export function heartbeatToolDenial(name, argumentsValue, access) {
+    if (name === 'knowledge')
+        return observationKnowledgeEntryDenial(argumentsValue);
     if (['knowledge_note_references', 'knowledge_note_read', 'knowledge_note_update'].includes(name))
         return '关注不处理依据中的笔记引用；记录仅使用手动配置的 recordTarget 和专用记录工具。';
     if (!isRecord(argumentsValue))