@aalis/plugin-agent 0.16.0 → 0.17.0

package/dist/index.js

@@ -1,24 +1,30 @@
 import { Buffer } from 'node:buffer';
 import { agent as agentService, } from '@aalis/api-agent';
+import { authority as authorityService, originTurnOf } from '@aalis/api-authority';
 import { commands as commandsService } from '@aalis/api-commands';
 import { contributions } from '@aalis/api-contributions';
 import { gateway as gatewayService } from '@aalis/api-gateway';
 import { hooks } from '@aalis/api-hooks';
-import { listLLMModels, llm as llmService, resolveLLMModel } from '@aalis/api-llm';
+import { ownHostConfig } from '@aalis/api-host-config';
+import { estimateMsgTokens, estimateTextTokens, LLMCapabilities, listLLMModels, llm as llmService, MODEL_REF_TEXT, resolveLLMModel, } from '@aalis/api-llm';
 import { media as mediaService } from '@aalis/api-media';
 import { memory as memoryService } from '@aalis/api-memory';
-import { messageArchive as messageArchiveService } from '@aalis/api-message-archive';
+import { messageArchive as messageArchiveService, speakerOf } from '@aalis/api-message-archive';
 import { persona as personaService } from '@aalis/api-persona';
 import { getPlatformSelfIdentity, platform as platformService } from '@aalis/api-platform';
-import { rootSessionOf, SESSION_LAYERS, sessionManager as sessionManagerService, } from '@aalis/api-session-manager';
-import { storage as storageService } from '@aalis/api-storage';
+import { originChatOf, rootSessionOf, sessionManager as sessionManagerService } from '@aalis/api-session-manager';
+import { sessionFields as sessionFieldsService } from '@aalis/api-session-settings';
+import { isStorageUri, storage as storageService } from '@aalis/api-storage';
 import { tools as toolsService, } from '@aalis/api-tools';
 import { config as configCap, definePlugin, events, lifecycle, logger as loggerCap, optional, pluginsService, provide, services, } from '@aalis/core';
 import { defineConfig, parseConfig } from '@aalis/schema-config';
-import { CONTROL_KINDS, getMessageName, getSenderLabel, WellKnownKinds, WellKnownMetadataKeys, } from '@aalis/schema-message';
-import { normalizeAssistantContent, stripLeakedSpecialTokens, truncateChars } from '@aalis/util-text-normalize';
-import { buildFocusGuidance, describeLLMFailure, estimateHistoryTokens, estimateMsgTokens, estimateTextTokens, estimateTokens, formatTimeLabel, formatToolArgsForLog, INPUT_CONVENTIONS, isSameMessage, parseToolArguments, toPersonaOptions, } from './helpers.js';
+import { textLines, textOf, toSource } from '@aalis/schema-i18n';
+import { arrivalTag, buildIncomingContent, CONTROL_KINDS, DIRECTIVE_KINDS, getMessageName, getSenderLabel, groupToolCalls, WellKnownKinds, WellKnownMetadataKeys, wasAddressed, } from '@aalis/schema-message';
+import { stripLeakedSpecialTokens, truncateChars } from '@aalis/util-text-normalize';
+import { buildFocusGuidance, describeLLMFailure, estimateHistoryTokens, estimateTokens, formatTimeLabel, formatToolArgsForLog, hasAttachmentDescriptions, historyForModel, INPUT_CONVENTIONS, isSameMessage, parseToolArguments, queuedNote, readHistory, stoppedNote, } from './helpers.js';
 import { assemblePromptContributions, VOLATILE_INJECTOR } from './prompt-assembly.js';
+import { SessionQueues } from './session-queue.js';
+import { t } from './texts.js';
 // ===== 能力声明 =====
 //
 // 对话编排要碰的东西全在这里：没写进 uses 的，插件碰不到。全部 optional——少一样能力
@@ -39,6 +45,12 @@ const uses = {
     persona: optional(personaService),
     messageArchive: optional(messageArchiveService),
     sessionManager: optional(sessionManagerService),
+    /** 判谁是 owner：参与者里合一 owner 的各个身份、存档不在时当轮正文的发送者前缀（与存档同一规则，speakerOf）、/stop */
+    authority: optional(authorityService),
+    /** 按会话读本插件的四项（模型、深度思考、最大工具迭代、历史条数上限）；缺席时只取插件配置里的值 */
+    sessionFields: optional(sessionFieldsService),
+    /** 按会话字段的全局层：宿主配置文档里本实例的那一段 */
+    document: optional(ownHostConfig),
     platform: optional(platformService),
     media: optional(mediaService),
     storage: optional(storageService),
@@ -62,13 +74,13 @@ const uses = {
  */
 /** 统一读取 LLM 单次最大输出 token；缺省回退 4096（与各 adapter 默认一致）。 */
 const DEFAULT_MAX_OUTPUT_TOKENS = 4096;
-/** 会话设置「最大工具迭代」没设时一轮里工具调用循环的最大次数 */
-const MAX_TOOL_ITERATIONS = 30;
 // 宿主通知的公开链接须在最终正文保留；同时识别普通文本和 Markdown 链接的边界。
 const NOTICE_URL = /https?:\/\/[^\s<>()[\]"'`*“”‘’，。！？；、]+/gu;
 function getModelMaxOutput(llm) {
     return llm.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
 }
+/** 条目固定的那个模型写成模型引用 */
+const refOf = (entry) => ({ provider: entry.use.providerId, model: entry.use.id });
 class DefaultAgent {
     instanceId;
     caps;
@@ -79,27 +91,10 @@ class DefaultAgent {
     promptBuildTimeoutMs;
     /** 单条工具结果占上下文窗口的最大比例 (0~1)，超出则截断 */
     toolResultMaxRatio;
-    /** 内存裁剪触发比例 (0~1)：估算输入 token 占 contextLength 的比例上限，超过则触发本次调用的内存裁剪 */
+    /** 裁剪触发比例 (0~1)：裁剪预算按上下文长度乘它再扣输出预留，见 computeTokenBudget */
     trimThresholdRatio;
-    /**
-     * 在飞回合表：lane → 这一轮的 AbortController 与 turnId
-     *
-     * lane = `${sessionId}::${source}` — 同一 session 不同来源（user / scheduler）
-     * 独立管理，互不打断；同来源新消息会中止旧的生成。
-     */
-    activeControllers = new Map();
-    /**
-     * 延续某位发言者身份的宿主通知回合（lane → 会话与 hostNotice.callerUserId）。那位发言者在同一会话发来的真人消息
-     * 中止这些回合；别人的消息与不延续任何人身份的通知（白纸等）不受影响，宿主通知也从不打断别的回合。
-     */
-    noticeCallers = new Map();
-    /**
-     * 在飞回合 Promise。关停时 abort 之后等它们以 AbortError（或正常完成）收尾，
-     * 而不是等 LLM 跑完——收尾里的钩子 / 出站事件还要用 memory。
-     */
-    inflightTurns = new Set();
-    /** 同一 lane 的入站消息归档串行化，避免连续消息读取历史时漏掉前一条输入。 */
-    archiveQueues = new Map();
+    /** 各会话的通道：在跑的一轮、待插入与排队的输入（见 session-queue.ts）。停机由 run() 直接经它停，清消息历史经 clearing */
+    queues;
     /** 每次激活只在实际写入缺少归档时告警一次，不因插件加载顺序误报。 */
     archiveUnavailableWarned = false;
     /**
@@ -113,11 +108,24 @@ class DefaultAgent {
     preferenceFallbacks = new Set();
     /** 已注册的预处理器（name → { dispose }） */
     preprocessors = new Map();
+    /** 本插件的按会话字段：每一轮按会话现读；模型没设时的 actual 是服务此刻为本插件挑的那一个 */
+    fields;
+    /** 判一个身份是不是 owner：工具调用上下文里合一 owner 的各个身份、/stop 都用它；权限服务不在时没有人是 owner */
+    isOwner = (platform, userId) => this.caps.authority.present && this.caps.authority.use.isOwner(platform, userId);
     constructor(caps, cfg, 
     /** 本插件实例 id：读它的本插件偏好 */
     instanceId) {
         this.instanceId = instanceId;
         this.caps = caps;
+        this.queues = new SessionQueues((sessionId, waiting) => {
+            void caps.events.use.emit('agent:queue', { sessionId, waiting });
+        });
+        this.fields = caps.sessionFields.use.fields(configSchema, caps, {
+            llm: () => {
+                const entry = this.resolveLLM(undefined);
+                return entry && { value: refOf(entry) };
+            },
+        });
         this.logger = caps.logger.use.child('agent');
         this.systemPrompt = cfg.systemPrompt;
         this.memoryTokenBudget = cfg.memoryTokenBudget;
@@ -127,18 +135,15 @@ class DefaultAgent {
         this.logger.info('默认对话代理已初始化');
     }
     /**
-     * 根据优先级链解析当前会话该用哪个 LLMModel entry。
+     * 解析会话该用哪个 LLMModel entry：ref 是这个会话的「模型」（按会话字段 llm 的生效值）。
      *
-     * 会话设置的 llm 交给 session-manager.resolveConfig 解析（按层表叠加，全局默认层即 llm 服务的偏好）；
-     * 全局默认之上哪一层都没设时不给值，由 resolveLLMModel 落到本插件此刻选中的那一个（本插件偏好 > 全局偏好 > 提供者优先级 >
-     * 登记先后）。这时该生效的偏好（设了本插件偏好就是它，否则是全局偏好）指向的模型不在（模型删了、提供者在重载或激活失败），
-     * 服务落到别的模型上：照常用它，每个（偏好，实际）组合告警一次。
+     * 「模型」的全局层是本插件的 llm 偏好，哪一层都没设时不给值，由 resolveLLMModel 落到本插件此刻选中的那一个（本插件偏好 >
+     * 全局偏好 > 提供者优先级 > 登记先后）。这时该生效的偏好（设了本插件偏好就是它，否则是全局偏好）指向的模型不在（模型删了、
+     * 提供者在重载或激活失败），服务落到别的模型上：照常用它，每个（偏好，实际）组合告警一次。
      *
      * 返回 llm 的提供者条目（id 与这一家的业务句柄 use），条目固定那一个模型。
      */
-    async resolveLLM(platform, sessionId) {
-        const sm = this.caps.sessionManager.present ? this.caps.sessionManager.use : undefined;
-        const ref = sm && sessionId ? sm.resolveConfig(sessionId, platform).llm : undefined;
+    resolveLLM(ref) {
         // 解析为具体 LLMModel entry（要求至少 chat 能力；ref 为空时走 ServicePreference / 优先级）
         const entry = resolveLLMModel(this.caps.llm, ref, ['chat']);
         if (ref || !entry)
@@ -155,12 +160,14 @@ class DefaultAgent {
         return entry;
     }
     /** 解析失败时说清**为什么**（取数在此，措辞在 helpers 的 describeLLMFailure，纯函数便于单测）。 */
-    explainLLMFailure(platform, sessionId) {
+    explainLLMFailure(wanted) {
         const available = listLLMModels(this.caps.llm, { caps: ['chat'] }).map(e => e.id);
-        const sm = this.caps.sessionManager.present ? this.caps.sessionManager.use : undefined;
-        const wanted = sm && sessionId ? sm.resolveConfig(sessionId, platform).llm : undefined;
         return describeLLMFailure(available, wanted, this.erroredLLMPlugins());
     }
+    /** 把这个会话本会话层的「模型」设成 model：经读取器写本插件的字段，会话设置不在时抛错 */
+    async assignModel(sessionId, model) {
+        await this.fields.set(sessionId, 'llm', model);
+    }
     /** 激活失败且声明提供 llm 的插件实例名——「一个模型都没有」时，病因通常就在它们身上（多为缺 apiKey）。 */
     erroredLLMPlugins() {
         if (!this.caps.plugins.present)
@@ -173,55 +180,33 @@ class DefaultAgent {
             .filter(p => p.state === 'error' && p.provides?.includes('llm'))
             .map(p => p.instanceId);
     }
-    /** 生成 lane key：同 session + 同 source 共用一个 lane */ laneKey(sessionId, source) {
-        return `${sessionId}::${source ?? 'user'}`;
-    }
     /**
-     * 中止指定会话的在飞回合：不带 turnId 时停所有 lane，带 turnId 时只停那一轮。返回是否停下了回合。
+     * 停下这个会话在跑的一轮；queued 为真时连同排队与待插入的一起放掉，放掉的在那一轮落定之后归档（不带回合 id）；by 是停下它的
+     * 人，写进停下标记。禁言、全部停止、停止键与 /stop 经这里
      */
-    abort(sessionId, turnId) {
-        let aborted = false;
-        for (const [key, turn] of this.activeControllers) {
-            if (!key.startsWith(`${sessionId}::`) || (turnId !== undefined && turn.turnId !== turnId))
-                continue;
-            turn.controller.abort();
-            this.activeControllers.delete(key);
-            aborted = true;
-        }
-        if (aborted)
-            this.logger.info(`生成已中止: session=${sessionId}${turnId ? ` turn=${turnId}` : ''}`);
-        return aborted;
+    abort(sessionId, options = {}) {
+        return this.queues.stop(sessionId, { ...options, archive: true });
     }
     /**
-     * 中止全部在飞回合（拆卸路径用）。
-     *
-     * activeControllers 是实例私有的，bounce 后新实例看不见旧实例的在飞回合。
-     * abort 走已有的 AbortError 收尾（outbound:stream done + turn:after outcome='aborted'），
-     * 与 WebUI「停止生成」同语义。关停在 onDrain 里先调本方法再等回合 Promise；
-     * onDispose 再调一次作兜底（已中止的 controller 不在表里，是空操作）。
+     * 清消息历史：先按住这些会话，再停下在跑的一轮、放掉排着与待插入的（不归档），等它落定再跑 clear。被停的一轮落定之前还会写
+     * 工具调用组，先停后清，清空的历史里才不留它的写入。按住期间要交给通道的输入放开再交
      */
-    abortAll() {
-        let n = 0;
-        for (const [key, turn] of this.activeControllers) {
-            turn.controller.abort();
-            this.activeControllers.delete(key);
-            n++;
+    async clearing(sessionIds, clear, reason = '清消息历史') {
+        const release = this.queues.hold(sessionIds);
+        try {
+            await this.queues.stopAll(sessionIds ?? this.queues.sessions(), { archive: false, reason });
+            await clear();
+        }
+        finally {
+            release();
         }
-        if (n > 0)
-            this.logger.info(`拆卸：已中止 ${n} 个在飞回合`);
     }
     /**
-     * 关停收尾：中止在飞回合并等待其 AbortError（或正常完成）收尾落定。
-     * 超时由 core 对 onDrain 回调的 disposeTimeoutMs 护栏负责，不另加配置键。
+     * 会话删除（session:deleted）：停掉这个会话在跑的一轮、放掉排着的（不归档）并等它收尾（在 clearing 之内时它已经停过）：没有
+     * 上限，不响应中止的工具会让它一直等到工具返回。再丢弃它的 token 日志节流状态
      */
-    async abortInflightAndSettle() {
-        this.abortAll();
-        if (this.inflightTurns.size === 0)
-            return;
-        await Promise.allSettled([...this.inflightTurns]);
-    }
-    /** 会话删除时丢弃其节流日志状态（订阅见 run() 的 session:deleted）。 */
-    dropTokenLogState(sessionId) {
+    async sessionDeleted(sessionId) {
+        await this.queues.stopAll([sessionId], { archive: false, reason: '会话删除' });
         this.tokenLogState.delete(sessionId);
     }
     /**
@@ -251,32 +236,6 @@ class DefaultAgent {
         this.logger.info(`预处理器已注册: ${name}`);
         return entry.dispose;
     }
-    /**
-     * 获取当前所有已注册预处理器的元信息（按注册顺序返回）
-     */
-    getPreprocessors() {
-        return [...this.preprocessors.keys()].map(name => ({ name }));
-    }
-    /**
-     * 获取 Agent 子系统的插件分组
-     *
-     * 仅纳入 Agent 直接依赖的能力提供者；不包含 `platform`
-     * （平台属于独立子系统，由 api-platform 的 helper 负责）。
-     */
-    getPluginGroups() {
-        if (!this.caps.plugins.present)
-            return [];
-        const pm = this.caps.plugins.use;
-        // 子系统归属：Agent 域的服务（不含 platform——平台是独立子系统）
-        const targetServices = new Set(['llm', 'memory', 'persona', 'message-archive']);
-        const grouped = [];
-        for (const p of pm.getStatus()) {
-            if (p.provides?.some(s => targetServices.has(s))) {
-                grouped.push(p.instanceId);
-            }
-        }
-        return [{ label: 'Agent', plugins: grouped }];
-    }
     /**
      * 消费流式 LLM 调用，累积完整响应，同时向前端推送增量事件。
      *
@@ -347,21 +306,23 @@ class DefaultAgent {
                 usage = chunk.usage;
             }
         }
-        let finalContent = content;
-        if (content) {
-            // 兜底剥离 LLM 端漏出的特殊 token 残渣（DSML 等），同时修复 GFM 表格
-            const { sanitized, hadLeak } = stripLeakedSpecialTokens(content);
-            if (hadLeak) {
-                this.caps.logger.use.warn(`agent: 检测到 LLM 内容残留 DSML 标记，已剥离（session=${sessionId} platform=${platform} 原长=${content.length} 净化后=${sanitized.length}）`);
-            }
-            finalContent = normalizeAssistantContent(content);
+        // 经 OpenAI 兼容接口接入时，服务端漏进正文的工具调用标记只有这一层会剥：只剥不执行，落库的正文与时间线都过它。
+        // 时间线的正文段是 content 的切片，剥空的段不留
+        const { sanitized, hadLeak } = stripLeakedSpecialTokens(content);
+        if (hadLeak) {
+            this.caps.logger.use.warn(`agent: 检测到 LLM 内容残留 DSML 标记，已剥离（session=${sessionId} platform=${platform} 原长=${content.length} 净化后=${sanitized.length}）`);
         }
         return {
-            content: finalContent,
+            content: sanitized,
             reasoningContent: reasoningContent || undefined,
             toolCalls,
             usage,
-            segments,
+            segments: segments.flatMap((segment) => {
+                if (segment.type !== 'text')
+                    return [segment];
+                const text = stripLeakedSpecialTokens(segment.content).sanitized;
+                return text ? [{ ...segment, content: text }] : [];
+            }),
             generating,
         };
     }
@@ -475,803 +436,782 @@ class DefaultAgent {
         lines.push(sep);
         this.logger.debug(lines.join('\n'));
     }
+    /** 会话管理给这个会话的代号（api-session-manager 的 generationOf）；会话管理不在时没有 */
+    generationOf(sessionId) {
+        return this.caps.sessionManager.present ? this.caps.sessionManager.use.generationOf(sessionId) : undefined;
+    }
     async handleMessage(incoming) {
-        const lane = this.laneKey(incoming.sessionId, incoming.source);
-        // 仅中止同一 lane（同 session + 同 source）的旧生成；不同来源互不打断
-        const prev = this.activeControllers.get(lane);
-        if (prev)
-            prev.controller.abort();
-        // 例外：真人消息打断延续其本人身份的宿主通知回合，本人说话就停得下她自己开的那一轮。
-        if (incoming.source === undefined && incoming.userId !== undefined) {
-            for (const notice of this.noticeCallers.values()) {
-                if (notice.sessionId === incoming.sessionId && notice.callerUserId === incoming.userId) {
-                    notice.controller.abort();
-                }
-            }
+        // 入口记下这个会话的代号：交给通道之前变了（会话管理这期间开始删了这个会话）的是删除之前的一代，放掉、不归档
+        const generation = this.generationOf(incoming.sessionId);
+        // Hook: agent:input:before — 每条输入一次（预处理器挂在这里），中间件可以改写这条；不调 next() 即丢掉它，不进一轮
+        const inputData = { message: incoming };
+        let placed = false;
+        await this.caps.hooks.use.run('agent:input:before', inputData, async () => {
+            placed = true;
+            const { message } = inputData;
+            // 清消息历史与删会话期间按住的会话：放开再交给通道
+            await this.queues.held(message.sessionId);
+            if (this.generationOf(incoming.sessionId) !== generation)
+                this.logRoute(message, '放掉');
+            else
+                await this.settleInput(message, this.queues.place(message));
+        });
+        // 输入被丢掉（如流控缓冲），通知前端结束 loading：它没进一轮，流结束标记的回合 id 只是占位
+        if (!placed) {
+            await this.caps.events.use.emit('outbound:stream', {
+                sessionId: incoming.sessionId,
+                turnId: crypto.randomUUID(),
+                platform: incoming.platform,
+                done: true,
+            });
         }
-        const controller = new AbortController();
-        // 回合 id：这一轮的入站钩子、流式片段、工具调用、用量与回合结束都带它，停止键也能按它只停这一轮
-        const turnId = crypto.randomUUID();
-        this.activeControllers.set(lane, { controller, turnId });
-        const callerUserId = incoming.hostNotice?.callerUserId;
-        if (callerUserId !== undefined) {
-            this.noticeCallers.set(lane, { sessionId: incoming.sessionId, callerUserId, controller });
+    }
+    /** 逐条输入的默认动作：交给通道之后等这条落定（它所在的一轮结束，或它被放掉）；轮到它开轮时由它跑这一轮 */
+    async settleInput(message, placement) {
+        if (placement.route === 'drop') {
+            this.logRoute(message, '放掉');
+            // 停机放掉的在这个会话在跑的一轮落定之后归档
+            await this.queues.settled(message.sessionId);
+            await this.archiveIncomingMessage(message);
+            return;
         }
-        const turn = (async () => {
-            try {
-                await this._handleMessageInner(incoming, controller.signal, lane, turnId);
-            }
-            finally {
-                // 仅清理自己创建的 controller（避免清掉后续新请求的）
-                if (this.activeControllers.get(lane)?.controller === controller) {
-                    this.activeControllers.delete(lane);
-                }
-                if (this.noticeCallers.get(lane)?.controller === controller)
-                    this.noticeCallers.delete(lane);
-            }
-        })();
-        this.inflightTurns.add(turn);
+        if (placement.route !== 'open')
+            this.logRoute(message, placement.route === 'join' ? '待插入' : '排队');
+        const turn = placement.route === 'open' ? placement.turn : await placement.ready;
+        if (turn)
+            await this.playTurn(turn);
+    }
+    /** 每条输入一行 debug：去向、到达序号、会话与回合，不记正文与昵称 */
+    logRoute(message, route, turnId) {
+        this.logger.debug(`→ ${route}${arrivalTag(message)} session=${message.sessionId}${turnId ? ` turn=${turnId}` : ''}`);
+    }
+    /**
+     * 跑一轮：agent:turn:before 的默认动作是这一轮的全部，中间件不调 next() 即拦下这一轮（不归档、不调模型、不发
+     * agent:turn:after）。之后按先后归档这期间放掉、要归档的输入，再交出下一批：agent 在一个会话里的写入因此不交错
+     */
+    async playTurn(turn) {
+        const { sessionId, turnId } = turn;
+        const inputs = turn.batch.map(message => ({ message }));
+        for (const message of turn.batch)
+            this.logRoute(message, '开轮', turnId);
+        const startedAt = Date.now();
+        let outcome;
         try {
-            await turn;
+            await this.caps.hooks.use.run('agent:turn:before', { turnId, sessionId, inputs }, async () => {
+                outcome = await this.runTurn(turn, inputs);
+            });
         }
         finally {
-            this.inflightTurns.delete(turn);
+            // 这一轮被拦下（如已删子会话的消息），通知前端结束 loading
+            if (outcome === undefined) {
+                await this.caps.events.use.emit('outbound:stream', {
+                    sessionId,
+                    turnId,
+                    platform: inputs[0].message.platform,
+                    done: true,
+                });
+            }
+            for (let dropped = this.queues.drain(turn); dropped.length > 0; dropped = this.queues.drain(turn)) {
+                for (const { message, archive, settle } of dropped) {
+                    this.logRoute(message, '放掉');
+                    if (archive)
+                        await this.archiveIncomingMessage(message);
+                    settle();
+                }
+            }
+            const arrivals = inputs.map(({ message }) => arrivalTag(message)).join('');
+            this.logger.info(`回合结束 turn=${turnId} session=${sessionId} 结局=${outcome ?? '拦下'}` +
+                `${turn.reason ? ` 原因=${turn.reason}` : ''} 用时=${Date.now() - startedAt}ms${arrivals && ` 输入${arrivals}`}`);
+            this.queues.release(turn);
         }
     }
-    async _handleMessageInner(incoming, signal, lane, turnId) {
-        // Hook: agent:input:before — 插件可以修改或拦截消息
-        // 中间件不调用 next() 即可中断整个流程（包括 LLM 调用）
-        const msgHookData = {
-            message: incoming,
-            turnId,
-            metadata: {},
-        };
-        let handled = false;
-        await this.caps.hooks.use.run('agent:input:before', msgHookData, async () => {
-            handled = true;
-            // ===== defaultAction: 全部消息处理逻辑在此 =====
-            // 中间件不调用 next() → 此处永远不执行 → 消息被拦截
-            incoming = msgHookData.message;
-            const reportOnly = incoming.hostNotice?.reportOnly === true;
-            const noticeLinks = reportOnly ? (incoming.content.match(NOTICE_URL) ?? []) : [];
-            const archivedIncoming = await this.archiveIncomingMessageInOrder(lane, incoming);
-            const resolved = await this.resolveLLM(incoming.platform, incoming.sessionId);
-            if (!resolved) {
-                const why = this.explainLLMFailure(incoming.platform, incoming.sessionId);
-                this.logger.warn(`LLM 解析失败，无法处理消息：${why}`);
-                if (!reportOnly) {
-                    await this.dispatchOutbound({
-                        content: `[系统] ${why}`,
-                        sessionId: incoming.sessionId,
-                        platform: incoming.platform,
-                        source: 'system',
-                    });
+    /**
+     * agent:turn:before 的默认动作：先按先后归档开轮的输入，再跑这一轮，返回结局。真人消息开的一轮在每次调用模型之前（第一次与
+     * 每批工具之后；格式重试的那几次不算）取走待插入的输入，最后一次模型调用返回不带工具调用的回复之后不再收
+     */
+    async runTurn(turn, inputs) {
+        const { sessionId, turnId } = turn;
+        const { signal } = turn.controller;
+        // 同一轮的输入会话与来源相同；带来源的注入（宿主通知、委派）各自成一轮，只有这一条
+        const first = inputs[0].message;
+        const { platform } = first;
+        const reportOnly = first.hostNotice?.reportOnly === true;
+        const noticeLinks = reportOnly ? (first.content.match(NOTICE_URL) ?? []) : [];
+        const recordOf = (outcome) => ({ outcome, ...(first.source && { source: first.source }) });
+        // 回合记录一轮只写一次：回复了的随回复落库时写下，之后外发或 agent:turn:after 的中间件出错不再另记一条
+        let recorded = false;
+        /** 这一轮落过工具调用组 */
+        let savedGroups = false;
+        /**
+         * 收尾：还没写回合记录的（静默、中止、出错）落一条只带回合 id 与记录的事件标记，不进模型、不进摘要，会话服务据此在历史里还原
+         * 这一轮的结局；中止的先落一条给下一轮的模型看的停下标记。再发 agent:turn:after
+         */
+        const end = async (outcome, { reply = '', error } = {}) => {
+            if (!recorded) {
+                recorded = true;
+                // 只在这一轮在历史里留下了输入或工具调用组时写：什么也没留下时（空闲开话题还没调工具就被停下），下一轮模型看到的上文是
+                // 之前已经答完的一轮，写「上面这一轮被停下了」会被读成上一句回复没发出
+                if (outcome === 'aborted' && (savedGroups || inputs.some(input => input.archived))) {
+                    await this.saveToMemory(sessionId, stoppedNote(this.stopperLabel(sessionId, turn.stoppedBy), turnId));
                 }
-                await this.caps.hooks.use.run('agent:turn:after', {
-                    message: incoming,
-                    reply: '',
-                    outcome: signal.aborted ? 'aborted' : 'error',
-                    ...(signal.aborted ? {} : { error: why }),
-                    sessionId: incoming.sessionId,
-                    turnId,
-                    metadata: msgHookData.metadata,
+                await this.saveToMemory(sessionId, {
+                    role: 'system',
+                    kind: WellKnownKinds.EventMarker,
+                    content: '',
+                    timestamp: Date.now(),
+                    metadata: { [WellKnownMetadataKeys.TurnId]: turnId, [WellKnownMetadataKeys.TurnRecord]: recordOf(outcome) },
                 });
-                return;
             }
-            const llm = resolved.use;
-            // 从 LLM model entry 读取参数。contextLength / maxOutputTokens 均为 per-model 属性，
-            // service-granularity 后不再需要 router.getContextLengthFor() 反查，也不再会出现
-            // 默认 provider 全局窗口与会话实际 model 不一致的偏差（Bug F 结构性修复）。
-            const maxTokens = getModelMaxOutput(llm);
-            const contextLength = llm.contextLength;
-            const tokenBudget = this.computeTokenBudget(contextLength, maxTokens);
-            // 本回合经工具循环写入 memory 的 (assistant+toolCalls + tool 结果) 消息时间戳。
-            // 只用于中止日志里的条数：中止时这些已完成的工具调用记录保留不回滚（见下方 catch 分支）。
-            const turnPersistedTimestamps = [];
-            try {
-                // 统一解析 session 配置（一次解析，多处复用）
-                const sessionMgr = this.caps.sessionManager.present ? this.caps.sessionManager.use : undefined;
-                const resolved = sessionMgr && incoming.sessionId
-                    ? sessionMgr.resolveConfig(incoming.sessionId, incoming.platform)
-                    : undefined;
-                // 会话设置的 maxToolIterations 按登记的字段解析过（正整数），没设置时用默认值
-                const maxToolIterations = resolved?.maxToolIterations ?? MAX_TOOL_ITERATIONS;
-                // 构建 persona 会话选项（从 resolved config 中提取，传给 persona 服务）
-                const personaOpts = toPersonaOptions(resolved);
-                // 会话的深度思考档位：当前模型有这一档才带上；没设置、模型没有这一档或不能调时不带，由模型服务按它的默认档
-                const level = resolved?.think;
-                const thinking = llm.thinking?.levels.some(({ id }) => id === level) ? { think: level } : {};
-                const built = await this.buildMessages(incoming, resolved?.historyLimit, personaOpts, archivedIncoming);
-                const messages = built.messages;
-                /** 这次调用的消息列表里来自会话历史的条数：读进的，加本回合追加的工具调用与结果 */
-                let historyMessages = built.historyMessages;
-                // 通过 resolved config 获取工具分组
-                let enabledGroups;
-                if (resolved?.enabledToolGroups && resolved.enabledToolGroups.length > 0) {
-                    enabledGroups = resolved.enabledToolGroups;
-                }
-                this.logger.debug(`工具分组: platform=${incoming.platform}, enabledGroups=${enabledGroups ? JSON.stringify(enabledGroups) : '(无)'}`);
-                const tools = reportOnly
-                    ? []
-                    : this.caps.tools.present
-                        ? this.caps.tools.use.getDefinitions(enabledGroups ? { groups: enabledGroups } : undefined)
-                        : [];
-                const toolCtx = {
-                    sessionId: incoming.sessionId,
-                    // platform/userId 保持**会话/物理**语义（定时任务归属、平台档继承、记忆平台域都靠它们）；
-                    // 授权身份单独走 actor——authority 守卫按 actor 查等级，
-                    // scheduler/workflow/subtask 等触发的 AI 因此以创建者等级执行而非匿名。
-                    // 不可再用 actor 覆盖 platform：actor 来自另一平台时（如跨平台的定时任务、workflow）
-                    // 会把上述下游全路由到发起者平台。
-                    // 延续某次工具调用的宿主通知不带发言者，userId 取那次调用的（hostNotice.callerUserId），工具眼里是起它的人在调。
-                    // 只用在这里，归档与提示词钩子仍按消息本身的 userId（没有）。
-                    userId: incoming.userId ?? incoming.hostNotice?.callerUserId,
-                    platform: incoming.platform,
-                    actor: incoming.actor,
-                    // 恒为数组：平台档没配分组时给 []（列举面本就等价于「只给无分组工具」），
-                    // 让执行面的分组闸总是生效，而不是在「未配置」时整个失效。
-                    enabledGroups: enabledGroups ?? [],
-                    // 本循环会把 ToolExecutionResult.images 挂到 tool 消息交给主模型（出口由 prepareLLMMessages 编码）
-                    acceptsImages: true,
-                    // 回合中止信号：等 owner 审批期间被 latest-wins / 手动 abort 掐掉的工具不再执行
-                    signal,
-                    // 本回合的入站来源：只有这里填写，工具据此正向区分真人消息（source 缺省）与内部注入；
-                    // 延续某次调用的宿主通知另带那次调用的发言者，执行守卫据此认出 owner 链的延续；
-                    // 入站消息的平台消息 id 供转到后台的调用结束时，通知的回复引用它
-                    inbound: {
-                        source: incoming.source,
-                        callerUserId: incoming.hostNotice?.callerUserId,
-                        messageId: incoming.messageId,
-                    },
-                    turnId,
-                };
-                // 保存原始完整工具列表，后续迭代均以此为基础（避免被 hooks 修改后丢失）
-                const originalTools = [...tools];
-                // Hook: agent:llm:before — 插件可以修改消息或工具列表
-                const llmBeforeData = {
-                    messages,
-                    tools,
-                    sessionId: incoming.sessionId,
-                    userId: incoming.userId,
-                    platform: incoming.platform,
-                    triggerType: incoming.triggerType,
-                    source: incoming.source,
-                };
-                // 组装先于链：贡献块（档案/技能/记忆/即时提示）先物化，拦截者审完整成品
-                await assemblePromptContributions(this.caps, llmBeforeData, {
-                    buildTimeoutMs: this.promptBuildTimeoutMs,
-                    signal,
+            await this.caps.hooks.use.run('agent:turn:after', {
+                inputs,
+                reply,
+                outcome,
+                ...(error === undefined ? {} : { error }),
+                sessionId,
+                turnId,
+            });
+            return outcome;
+        };
+        for (const input of inputs)
+            input.archived = await this.archiveIncomingMessage(input.message, { turnId, entry: 'opened' });
+        // 这一轮的设置在开轮时读一次（下一轮再读，改了不必重载）：插进来的输入不重读，同一轮里换模型或工具列表会改掉之后各次调用的
+        // 前缀。同一会话的输入会话相同，入口平台只对没有出生平台的会话起作用，取开轮那条的
+        const settings = this.fields.get(sessionId, { platform });
+        const resolved = this.resolveLLM(settings.llm);
+        if (!resolved) {
+            const why = this.explainLLMFailure(settings.llm);
+            this.logger.warn(`LLM 解析失败，无法处理消息：${toSource(why)}`);
+            if (!reportOnly) {
+                const text = t('systemNotice', { why });
+                await this.dispatchOutbound({ content: toSource(text), text, sessionId, platform, source: 'system', turnId });
+            }
+            return signal.aborted ? end('aborted') : end('error', { error: why });
+        }
+        const llm = resolved.use;
+        // 这一轮的主模型能不能亲眼看图：按模型服务登记的能力（端点报告或单模型能力覆盖），
+        // 工具上下文与 agent:llm:before 同一个值
+        const acceptsImages = llm.capabilities.includes(LLMCapabilities.Vision);
+        const maxTokens = getModelMaxOutput(llm);
+        const contextLength = llm.contextLength;
+        const tokenBudget = this.computeTokenBudget(contextLength, maxTokens);
+        try {
+            const { maxToolIterations, historyLimit } = settings;
+            // 人设服务按这个会话自己读它的设置（人设、额外提示、结构化输出的两个开关）
+            const personaOpts = { sessionId, platform };
+            // 会话的深度思考档位：当前模型有这一档才带上；没设置、模型没有这一档或不能调时不带，由模型服务按它的默认档
+            const level = settings.think;
+            const thinking = llm.thinking?.levels.some(({ id }) => id === level) ? { think: level } : {};
+            // 多方与否取根会话记下的聊天窗口，开轮时取一次：说明文字与焦点指引同一个出处
+            const multiParty = originChatOf(sessionId, this.caps.sessionManager)?.multiParty === true;
+            const built = await this.buildMessages(turn, inputs, historyLimit, acceptsImages, multiParty, personaOpts);
+            const messages = built.messages;
+            /** 会话历史的条数：这一轮开头的活跃条数（含没发给模型的），加本回合追加的工具调用、结果与插进来的输入 */
+            let historyMessages = built.historyMessages;
+            // 这个会话启用的工具分组：工具注册表按会话读它的设置，不在时没有工具
+            const enabledGroups = this.caps.tools.present ? this.caps.tools.use.sessionGroups(sessionId, platform) : [];
+            this.logger.debug(`工具分组: platform=${platform}, enabledGroups=${JSON.stringify(enabledGroups)}`);
+            const tools = reportOnly || !this.caps.tools.present ? [] : this.caps.tools.use.getDefinitions({ groups: enabledGroups });
+            /**
+             * 一批工具调用的上下文，按这批开始那一刻已送进模型的输入构造：会话、发言者、参与者与入站回合由 originTurnOf 拼（字段语义
+             * 见它与 ToolCallContext，owner 的各个身份按权限服务合成一个参与者）；入站回合只有这里填，工具据此正向区分真人消息与
+             * 内部注入。叠进来的人从下一批起算，已执行的不追溯。续做取起它的那一轮的发言者只用在这里，归档与提示词贡献仍按输入本身的
+             * userId
+             */
+            const toolContext = () => ({
+                ...originTurnOf(inputs.map(input => input.message), this.isOwner),
+                // 恒为数组：没开分组时是 []（列举面本就等价于「只给无分组工具」），让执行面的分组闸总是生效
+                enabledGroups,
+                // 为 true 时本循环把 ToolExecutionResult.images 挂到 tool 消息交给主模型（出口由 prepareLLMMessages 编码）
+                acceptsImages,
+                // 回合中止信号：等审批期间这一轮被停下时，还没执行的工具不再执行
+                signal,
+                turnId,
+            });
+            // 保存原始完整工具列表，后续迭代均以此为基础（避免被 hooks 修改后丢失）
+            const originalTools = [...tools];
+            // Hook: agent:llm:before — 插件可以修改消息或工具列表
+            const llmBeforeData = { messages, tools, acceptsImages, sessionId, platform, source: first.source };
+            // 组装先于链：贡献块（档案/技能/记忆/即时提示）先物化，拦截者审完整成品
+            await assemblePromptContributions(this.caps, llmBeforeData, inputs, {
+                buildTimeoutMs: this.promptBuildTimeoutMs,
+                signal,
+            });
+            await this.caps.hooks.use.run('agent:llm:before', llmBeforeData, undefined, { warnOnStall: true });
+            if (reportOnly) {
+                llmBeforeData.tools = [];
+                // 这是结果汇报，不续跑历史工具链。保留人设与对话，去掉会诱发继续查任务的工具协议。
+                llmBeforeData.messages = llmBeforeData.messages.filter(message => message.role !== 'tool' &&
+                    !message.toolCalls?.length &&
+                    message.metadata?.injector !== WellKnownKinds.HostNotice);
+                // 放在钩子之后、消息末尾，确保裁剪仍保留本次结果及转述要求。
+                llmBeforeData.messages.push({
+                    role: 'system',
+                    content: `[宿主通知]\n${first.content}${first.hostNotice?.untrusted ? `\n\n${first.hostNotice.untrusted}` : ''}\n\n` +
+                        '本轮只转述以上已确认的结果。沿用当前人设和回复格式，向当前会话自然地说明结果，保留通知中的链接；' +
+                        '不要调用工具、重新查询状态或继续执行，不把编号、内部流程当成回复正文，也不要编造通知里没有的细节。请给出非空回复。',
+                    metadata: { injector: WellKnownKinds.HostNotice },
                 });
-                await this.caps.hooks.use.run('agent:llm:before', llmBeforeData, undefined, { warnOnStall: true });
-                if (reportOnly) {
-                    llmBeforeData.tools = [];
-                    // 这是结果汇报，不续跑历史工具链。保留人设与对话，去掉会诱发继续查任务的工具协议。
-                    llmBeforeData.messages = llmBeforeData.messages.filter(message => message.role !== 'tool' &&
-                        !message.toolCalls?.length &&
-                        message.metadata?.injector !== WellKnownKinds.HostNotice);
-                    // 放在钩子之后、消息末尾，确保裁剪仍保留本次结果及转述要求。
-                    llmBeforeData.messages.push({
-                        role: 'system',
-                        content: `[宿主通知]\n${incoming.content}${incoming.hostNotice?.untrusted ? `\n\n${incoming.hostNotice.untrusted}` : ''}\n\n` +
-                            '本轮只转述以上已确认的结果。沿用当前人设和回复格式，向当前会话自然地说明结果，保留通知中的链接；' +
-                            '不要调用工具、重新查询状态或继续制作，不把编号、内部流程当成回复正文，也不要编造未提供的作品细节。请给出非空回复。',
-                        metadata: { injector: WellKnownKinds.HostNotice },
+            }
+            /**
+             * 插入点（调用模型之前，组装与 agent:llm:before 之后、硬裁剪之前）：取这一轮待插入的输入，逐条归档、追加到消息末尾、挂上
+             * 各自的图，再增量组装、重跑 agent:llm:before（插进来的图要经它规范化），然后再取，取空为止
+             */
+            const insertJoined = async (data) => {
+                for (let taken = this.queues.take(turn); taken.length > 0; taken = this.queues.take(turn)) {
+                    const joined = [];
+                    for (const message of taken) {
+                        joined.push({ message, archived: await this.archiveIncomingMessage(message, { turnId, entry: 'joined' }) });
+                        this.logRoute(message, '插入', turnId);
+                    }
+                    inputs.push(...joined);
+                    // 多方房间里插进被点名的：在它们之前另加一块列出至今被点名的各条，不改前面那块（之后各次请求仍以之前的为前缀）
+                    const focus = multiParty && joined.some(input => wasAddressed(input.message)) ? this.focusOf(inputs) : null;
+                    if (focus)
+                        data.messages.push(focus);
+                    for (const input of joined)
+                        data.messages.push(await this.inputMessage(input, acceptsImages));
+                    historyMessages += joined.length;
+                    await assemblePromptContributions(this.caps, data, inputs, {
+                        buildTimeoutMs: this.promptBuildTimeoutMs,
+                        signal,
                     });
+                    await this.caps.hooks.use.run('agent:llm:before', data, undefined, { warnOnStall: true });
                 }
-                /** 本回合到目前为止经过了硬裁剪：首次调用的裁剪结果写回底稿，之后各次调用都在它上面追加 */
-                let turnTrimmed = false;
-                /** 首次调用的硬裁剪从底稿里去掉的历史与工具结果：之后各次调用按底稿估算没裁剪的量时补回 */
-                let trimmedFromBase = 0;
-                /** 硬裁剪这次要发出的列表，删了消息时记一行日志；untrimmedHistory 按没经过硬裁剪的列表估算 */
-                const trimForCall = (list) => {
-                    const sent = this.trimMessages(list, tokenBudget);
-                    if (sent.messages.length < list.length) {
-                        this.logger.info(`上下文硬裁剪: session=${incoming.sessionId}, ${list.length} → ${sent.messages.length} 条消息`);
-                    }
-                    turnTrimmed ||= sent.trimmed;
-                    return { messages: sent.messages, untrimmedHistory: estimateHistoryTokens(list) + trimmedFromBase };
-                };
-                // 裁剪消息以确保不超过上下文窗口；裁剪结果写回，作为之后各次调用的底稿
-                const firstSent = trimForCall(llmBeforeData.messages);
-                trimmedFromBase = firstSent.untrimmedHistory - estimateHistoryTokens(firstSent.messages);
-                llmBeforeData.messages = firstSent.messages;
-                // 每次模型调用之后发一次用量：拆分按这次发出的消息与工具定义估算，used 取模型服务返回的输入 token
-                const reportUsage = (sent, sentTools, response) => this.emitTokenUsage({
-                    sessionId: incoming.sessionId,
-                    platform: incoming.platform,
-                    turnId,
-                    contextWindow: contextLength,
-                    maxTokens,
-                    tokenBudget,
-                    messages: sent.messages,
-                    tools: sentTools,
-                    trimmed: turnTrimmed,
-                    untrimmedHistory: sent.untrimmedHistory,
-                    historyMessages,
-                    promptTokens: response.usage?.promptTokens,
+            };
+            await insertJoined(llmBeforeData);
+            /** 本回合到目前为止经过了硬裁剪：首次调用的裁剪结果写回底稿，之后各次调用都在它上面追加 */
+            let turnTrimmed = false;
+            /** 首次调用的硬裁剪从底稿里去掉的历史与工具结果：之后各次调用按底稿估算没裁剪的量时补回 */
+            let trimmedFromBase = 0;
+            /**
+             * 硬裁剪这次要发出的列表（按 buildMessages 交出的消息对象认出历史），删了消息时记一行日志；untrimmedHistory 按没经过
+             * 硬裁剪的列表估算
+             */
+            const trimForCall = (list) => {
+                const sent = this.trimMessages(list, tokenBudget, built.history);
+                if (sent.messages.length < list.length) {
+                    this.logger.info(`上下文硬裁剪: session=${sessionId}, ${list.length} → ${sent.messages.length} 条消息`);
+                }
+                turnTrimmed ||= sent.trimmed;
+                return { messages: sent.messages, untrimmedHistory: estimateHistoryTokens(list) + trimmedFromBase };
+            };
+            // 裁剪消息以确保不超过上下文窗口；裁剪结果写回，作为之后各次调用的底稿
+            const firstSent = trimForCall(llmBeforeData.messages);
+            trimmedFromBase = firstSent.untrimmedHistory - estimateHistoryTokens(firstSent.messages);
+            llmBeforeData.messages = firstSent.messages;
+            // 每次模型调用之后发一次用量：拆分按这次发出的消息与工具定义估算，used 取模型服务返回的输入 token
+            const reportUsage = (sent, sentTools, response) => this.emitTokenUsage({
+                sessionId,
+                platform,
+                turnId,
+                contextWindow: contextLength,
+                maxTokens,
+                tokenBudget,
+                messages: sent.messages,
+                tools: sentTools,
+                trimmed: turnTrimmed,
+                untrimmedHistory: sent.untrimmedHistory,
+                historyMessages,
+                historyLimit,
+                promptTokens: response.usage?.promptTokens,
+            });
+            this.logger.debug(`LLM 请求: ${llmBeforeData.messages.length} 条消息, ` +
+                `${llmBeforeData.tools.length} 个工具, ` +
+                `maxTokens=${maxTokens}`);
+            const t0 = Date.now();
+            // 本轮累加的用量，用于最终 assistant 消息的 modelInfo 元数据。
+            // 注：缓存命中量（usage.cachedPromptTokens）不进这里——本对象只喂
+            // assistant 消息的 modelInfo，而其字段是逐个挑的（见下方 turnModelInfo），
+            // 加进来也不会流到下游。命中率的观测出口是 LLM 响应日志那一行。
+            const turnUsageAcc = { promptTokens: 0, completionTokens: 0 };
+            const accUsage = (u) => {
+                if (!u)
+                    return;
+                // promptTokens 语义 = "生成这条回复时的上下文大小"。工具迭代循环里每轮都把同一份
+                // （不断增长的）上下文重新发给模型，若累加会把重复发送的上下文重复计入，导致单条
+                // 回复虚高到几十万 token。故取最后一次调用的 prompt（覆盖而非累加）= 回复定稿时的真实上下文。
+                if (u.promptTokens != null)
+                    turnUsageAcc.promptTokens = u.promptTokens;
+                // completionTokens 语义 = "本回合真正新生成的输出"（含中间 reasoning / tool-call 生成
+                // 与最终回复文本），每次调用都是不重复的新输出，故逐次累加。
+                turnUsageAcc.completionTokens += u.completionTokens ?? 0;
+            };
+            const firstResult = await this.consumeStream(llm, {
+                messages: llmBeforeData.messages,
+                tools: llmBeforeData.tools.length > 0 ? llmBeforeData.tools : undefined,
+                maxTokens,
+                signal,
+                ...thinking,
+            }, turnId, sessionId, platform, !reportOnly);
+            await reportUsage(firstSent, llmBeforeData.tools, firstResult);
+            accUsage(firstResult.usage);
+            /** 这一次模型回复里各工具调用在生成进度里配好的 callId 与工具名，按调用的位置 */
+            let generating = firstResult.generating;
+            // 维护本轮（一次完整对话回合）的统一时间线 segments：
+            // 多次 LLM 调用 + 工具执行的输出按到达顺序拼接，保留模型原本的"思考/回答/工具/思考/回答"交错。
+            const turnSegments = [...firstResult.segments];
+            let response = firstResult;
+            this.debugLogResponse(response, Date.now() - t0);
+            // Hook: agent:llm:after — 插件可以处理 LLM 返回结果
+            const llmAfterData = { response, messages: llmBeforeData.messages };
+            await this.caps.hooks.use.run('agent:llm:after', llmAfterData);
+            response = llmAfterData.response;
+            const assistantMetadata = this.buildAssistantMetadata(first, turnId);
+            // 工具调用循环：上限没设即不限
+            let iterations = 0;
+            const withinLimit = () => maxToolIterations === undefined || iterations < maxToolIterations;
+            while (!reportOnly && response.toolCalls && response.toolCalls.length > 0 && withinLimit()) {
+                if (signal.aborted)
+                    throw new DOMException('Generation aborted', 'AbortError');
+                iterations++;
+                this.logger.debug(`工具调用迭代 ${iterations}: ${response.toolCalls.map(tc => tc.function.name).join(', ')}`);
+                // 先解析各次调用的参数：解析不了的，写进本回合消息与存档的那次调用的 arguments 换成 {}（见 parseToolArguments）
+                const parsedCalls = response.toolCalls.map(parseToolArguments);
+                const toolCalls = parsedCalls.map(parsed => parsed.toolCall);
+                // 将 assistant 消息 (含 toolCalls) 加入历史
+                llmBeforeData.messages.push({
+                    role: 'assistant',
+                    content: response.content,
+                    toolCalls,
+                    reasoningContent: response.reasoningContent,
+                    metadata: assistantMetadata,
                 });
-                this.logger.debug(`LLM 请求: ${llmBeforeData.messages.length} 条消息, ` +
-                    `${llmBeforeData.tools.length} 个工具, ` +
-                    `maxTokens=${maxTokens}`);
-                const t0 = Date.now();
-                // 本轮累加的用量，用于最终 assistant 消息的 modelInfo 元数据。
-                // 注：缓存命中量（usage.cachedPromptTokens）不进这里——本对象只喂
-                // assistant 消息的 modelInfo，而其字段是逐个挑的（见下方 turnModelInfo），
-                // 加进来也不会流到下游。命中率的观测出口是 LLM 响应日志那一行。
-                const turnUsageAcc = { promptTokens: 0, completionTokens: 0 };
-                const accUsage = (u) => {
-                    if (!u)
-                        return;
-                    // promptTokens 语义 = "生成这条回复时的上下文大小"。工具迭代循环里每轮都把同一份
-                    // （不断增长的）上下文重新发给模型，若累加会把重复发送的上下文重复计入，导致单条
-                    // 回复虚高到几十万 token。故取最后一次调用的 prompt（覆盖而非累加）= 回复定稿时的真实上下文。
-                    if (u.promptTokens != null)
-                        turnUsageAcc.promptTokens = u.promptTokens;
-                    // completionTokens 语义 = "本回合真正新生成的输出"（含中间 reasoning / tool-call 生成
-                    // 与最终回复文本），每次调用都是不重复的新输出，故逐次累加。
-                    turnUsageAcc.completionTokens += u.completionTokens ?? 0;
+                const assistantToolMessage = {
+                    role: 'assistant',
+                    content: response.content,
+                    toolCalls,
+                    reasoningContent: response.reasoningContent,
+                    metadata: assistantMetadata,
                 };
-                const firstResult = await this.consumeStream(llm, {
-                    messages: llmBeforeData.messages,
-                    tools: llmBeforeData.tools.length > 0 ? llmBeforeData.tools : undefined,
-                    maxTokens,
-                    signal,
-                    ...thinking,
-                }, turnId, incoming.sessionId, incoming.platform, !reportOnly);
-                await reportUsage(firstSent, llmBeforeData.tools, firstResult);
-                accUsage(firstResult.usage);
-                /** 这一次模型回复里各工具调用在生成进度里配好的 callId 与工具名，按调用的位置 */
-                let generating = firstResult.generating;
-                // 维护本轮（一次完整对话回合）的统一时间线 segments：
-                // 多次 LLM 调用 + 工具执行的输出按到达顺序拼接，保留模型原本的"思考/回答/工具/思考/回答"交错。
-                const turnSegments = [...firstResult.segments];
-                let response = firstResult;
-                this.debugLogResponse(response, Date.now() - t0);
-                // Hook: agent:llm:after — 插件可以处理 LLM 返回结果
-                const llmAfterData = { response, messages: llmBeforeData.messages };
-                await this.caps.hooks.use.run('agent:llm:after', llmAfterData);
-                response = llmAfterData.response;
-                // 收集工具调用摘要
-                const toolCallSummaries = [];
-                const assistantMetadata = this.buildAssistantMetadata(incoming, turnId);
-                // 工具调用循环
-                let iterations = 0;
-                while (!reportOnly && response.toolCalls && response.toolCalls.length > 0 && iterations < maxToolIterations) {
-                    if (signal.aborted)
-                        throw new DOMException('Generation aborted', 'AbortError');
-                    iterations++;
-                    this.logger.debug(`工具调用迭代 ${iterations}: ${response.toolCalls.map(tc => tc.function.name).join(', ')}`);
-                    // 先解析各次调用的参数：解析不了的，写进本回合消息与存档的那次调用的 arguments 换成 {}（见 parseToolArguments）
-                    const parsedCalls = response.toolCalls.map(parseToolArguments);
-                    const toolCalls = parsedCalls.map(parsed => parsed.toolCall);
-                    // 将 assistant 消息 (含 toolCalls) 加入历史
-                    llmBeforeData.messages.push({
-                        role: 'assistant',
-                        content: response.content,
-                        toolCalls,
-                        reasoningContent: response.reasoningContent,
-                        metadata: assistantMetadata,
+                const toolMessages = [];
+                // 并行执行所有工具调用（互不依赖的工具无需串行等待）
+                const toolResultMaxChars = Math.floor(contextLength * this.toolResultMaxRatio * 3.5);
+                // 这一批的参与者按此刻已送进模型的输入算
+                const toolCtx = toolContext();
+                const parallelResults = await Promise.all(parsedCalls.map(async (parsed, position) => {
+                    const { toolCall } = parsed;
+                    // 这次调用的 id：开始与结束事件、工具上下文都带它。同一位置生成参数时报过同一个工具的进度，用那时配的
+                    // （会话里已有它的工具卡）；没报过的、或钩子改过调用列表而对不上的现在生成，免得接管画着别的工具的卡。
+                    // 自己生成而不用模型给的 toolCall.id——模型给的 id 不保证唯一（有的 provider 用毫秒时间戳加序号拼，并发的
+                    // 两轮会撞上），而 callId 要在全局配对开始与结束。模型的 id 只留在发回模型的 tool 消息里配对调用与结果。
+                    const generated = generating.get(position);
+                    const callId = generated?.name === toolCall.function.name ? generated.callId : crypto.randomUUID();
+                    // 会话里的工具卡跟着这一对事件走：没执行就失败的调用（参数不合法、执行前的钩子出错）同样发一对，
+                    // 结束带回给模型的错误，否则那张卡一直停在生成中
+                    const announce = (phase, toolName, toolArgs, result) => this.caps.events.use.emit('tool:execute', {
+                        sessionId,
+                        turnId,
+                        callId,
+                        platform,
+                        toolName,
+                        args: toolArgs,
+                        phase,
+                        result,
                     });
-                    const assistantToolMessage = {
-                        role: 'assistant',
-                        content: response.content,
-                        toolCalls,
-                        reasoningContent: response.reasoningContent,
-                        metadata: assistantMetadata,
-                    };
-                    const toolMessages = [];
-                    // 并行执行所有工具调用（互不依赖的工具无需串行等待）
-                    const toolResultMaxChars = Math.floor(contextLength * this.toolResultMaxRatio * 3.5);
-                    const parallelResults = await Promise.all(parsedCalls.map(async (parsed, position) => {
-                        const { toolCall } = parsed;
-                        // 这次调用的 id：开始与结束事件、工具上下文都带它。同一位置生成参数时报过同一个工具的进度，用那时配的
-                        // （会话里已有它的工具卡）；没报过的、或钩子改过调用列表而对不上的现在生成，免得接管画着别的工具的卡。
-                        // 自己生成而不用模型给的 toolCall.id——模型给的 id 不保证唯一（有的 provider 用毫秒时间戳加序号拼，并发的
-                        // 两轮会撞上），而 callId 要在全局配对开始与结束。模型的 id 只留在发回模型的 tool 消息里配对调用与结果。
-                        const generated = generating.get(position);
-                        const callId = generated?.name === toolCall.function.name ? generated.callId : crypto.randomUUID();
-                        // 会话里的工具卡跟着这一对事件走：没执行就失败的调用（参数不合法、执行前的钩子出错）同样发一对，
-                        // 结束带回给模型的错误，否则那张卡一直停在生成中
-                        const announce = (phase, toolName, toolArgs, result) => this.caps.events.use.emit('tool:execute', {
-                            sessionId: incoming.sessionId,
-                            turnId,
+                    if ('error' in parsed) {
+                        // 参数不是合法 JSON 对象：跳过本次执行，把错误当工具结果回给模型重新生成 arguments。
+                        // 不能按空参数执行：「无必填参数」的工具会真的空参跑一遍（副作用已发生，模型却不知情）。
+                        this.logger.warn(`工具参数解析失败: ${toolCall.function.name}: ${parsed.error}`);
+                        const failedAt = Date.now();
+                        const result = JSON.stringify({ error: parsed.error });
+                        await announce('start', toolCall.function.name, {});
+                        await announce('end', toolCall.function.name, {}, result);
+                        return {
+                            toolCall,
                             callId,
-                            platform: incoming.platform,
-                            toolName,
-                            args: toolArgs,
-                            phase,
                             result,
-                        });
-                        if ('error' in parsed) {
-                            // 参数不是合法 JSON 对象：跳过本次执行，把错误当工具结果回给模型重新生成 arguments。
-                            // 不能按空参数执行：「无必填参数」的工具会真的空参跑一遍（副作用已发生，模型却不知情）。
-                            this.logger.warn(`工具参数解析失败: ${toolCall.function.name}: ${parsed.error}`);
-                            const failedAt = Date.now();
-                            const result = JSON.stringify({ error: parsed.error });
-                            await announce('start', toolCall.function.name, {});
-                            await announce('end', toolCall.function.name, {}, result);
-                            return {
-                                toolCall,
-                                callId,
-                                result,
-                                resultImages: undefined,
-                                toolName: toolCall.function.name,
-                                toolArgs: {},
-                                startTime: failedAt,
-                                endTime: failedAt,
-                            };
-                        }
-                        const callCtx = { ...toolCtx, callId };
-                        // Hook: agent:tool:before — 插件可以拦截或修改工具调用
-                        const toolBeforeData = { name: toolCall.function.name, args: parsed.args, toolCallContext: callCtx };
-                        // 单个工具的链路异常（钩子 / 守卫 / 结果处理抛错）只算该工具失败，转成它自己的错误结果：
-                        // 整批照常落定、整组落库，兄弟工具已发生的副作用不会因连坐而从历史里消失。
-                        // executeDone 区分失败发生在执行前还是执行后——后者须明说「已执行」，免得模型重做有副作用的操作。
-                        let executeDone = false;
-                        let toolT0;
-                        try {
-                            await this.caps.hooks.use.run('agent:tool:before', toolBeforeData);
-                            // 通知平台：工具开始执行
-                            await announce('start', toolBeforeData.name, toolBeforeData.args);
-                            // 紧随 start 赋值：catch 据此判断 start 已发出
-                            toolT0 = Date.now();
-                            this.logger.debug(`工具执行: ${toolBeforeData.name} 参数=${formatToolArgsForLog(toolBeforeData.args)}`);
-                            const executed = await (this.caps.tools.present
-                                ? this.caps.tools.use.execute(toolBeforeData.name, toolBeforeData.args, callCtx)
-                                : Promise.resolve({ content: JSON.stringify({ error: 'tools 服务不可用' }) }));
-                            executeDone = true;
-                            let result = executed.content;
-                            // 工具交给主模型看的图：只随本回合的 tool 消息走（出口由 prepareLLMMessages 编码），
-                            // 不进钩子/事件/时间线（那些面都是文本），也不落库（见 saveToolCallGroup）。
-                            const resultImages = executed.images;
-                            // Hook: agent:tool:after — 插件可以处理工具执行结果，写进 metadata 的随结果落库
-                            const toolAfterData = {
-                                name: toolBeforeData.name,
-                                result,
-                                toolCallContext: callCtx,
-                                metadata: {},
-                            };
-                            await this.caps.hooks.use.run('agent:tool:after', toolAfterData);
-                            result = toolAfterData.result;
-                            // 工具结果截断：按上下文窗口比例限制单条工具结果长度
-                            if (result.length > toolResultMaxChars) {
-                                this.logger.info(`工具结果过长 (${result.length} 字符)，截断至 ${toolResultMaxChars} 字符: ${toolBeforeData.name}`);
-                                result = truncateChars(result, toolResultMaxChars, `\n... [工具输出已截断，原始长度 ${result.length} 字符]`);
-                            }
-                            const toolEndTime = Date.now();
-                            this.logger.debug(`工具完成: ${toolBeforeData.name} (${toolEndTime - toolT0}ms) 结果=${result}`);
-                            // 通知平台：工具执行完成
-                            await announce('end', toolBeforeData.name, toolBeforeData.args, result);
-                            return {
-                                toolCall,
-                                callId,
-                                result,
-                                resultImages,
-                                resultMetadata: toolAfterData.metadata,
-                                toolName: toolBeforeData.name,
-                                toolArgs: toolBeforeData.args,
-                                startTime: toolT0,
-                                endTime: toolEndTime,
-                            };
-                        }
-                        catch (err) {
-                            // 执行后的失败不回退到原始结果（fail-closed）：after 钩子可能是脱敏钩子，失败时原始输出不能漏给模型
-                            const reason = err instanceof Error ? err.message : String(err);
-                            this.logger.warn(`工具${executeDone ? '已执行，但结果处理' : '调用'}失败: ${toolBeforeData.name} (${reason})`);
-                            const failedAt = Date.now();
-                            const result = JSON.stringify({
-                                error: executeDone ? `工具已执行，但结果处理失败：${reason}` : `工具调用失败：${reason}`,
-                            });
-                            // 执行前就失败的补发开始，再发配对的结束（emit 恒 resolve）
-                            if (toolT0 === undefined)
-                                await announce('start', toolBeforeData.name, toolBeforeData.args);
-                            await announce('end', toolBeforeData.name, toolBeforeData.args, result);
-                            return {
-                                toolCall,
-                                callId,
-                                result,
-                                resultImages: undefined,
-                                toolName: toolBeforeData.name,
-                                toolArgs: toolBeforeData.args,
-                                startTime: toolT0 ?? failedAt,
-                                endTime: failedAt,
-                            };
-                        }
-                    }));
-                    // 工具交出的图只服务紧接着的这一次请求：上一轮工具结果里的图在这里剥掉，否则多轮
-                    // 工具迭代会让图片在上下文里累积（每张数百 token，且不受文本裁剪约束）。
-                    for (let i = 0; i < llmBeforeData.messages.length; i++) {
-                        const m = llmBeforeData.messages[i];
-                        if (m.role === 'tool' && m.images) {
-                            const { images: _spent, ...rest } = m;
-                            llmBeforeData.messages[i] = rest;
-                        }
-                    }
-                    // 按原始 toolCalls 顺序将结果推入消息列表 + 时间线
-                    for (const { toolCall, callId, result, resultImages, resultMetadata, toolName, toolArgs, startTime, endTime, } of parallelResults) {
-                        const resultPreview = result.length > 200 ? `${result.slice(0, 200)}...` : result;
-                        toolCallSummaries.push(`[${toolCall.function.name}] ${resultPreview}`);
-                        // callId 随工具结果与时间线落库：没回复就收尾的一轮只落工具调用组，历史里的工具卡靠它对回这次调用
-                        const toolMessage = {
-                            role: 'tool',
-                            content: result,
-                            toolCallId: toolCall.id,
-                            ...(resultImages && resultImages.length > 0 ? { images: resultImages } : {}),
-                            metadata: {
-                                ...resultMetadata,
-                                [WellKnownMetadataKeys.TurnId]: turnId,
-                                [WellKnownMetadataKeys.CallId]: callId,
-                            },
+                            resultImages: undefined,
+                            toolName: toolCall.function.name,
+                            toolArgs: {},
+                            startTime: failedAt,
+                            endTime: failedAt,
                         };
-                        llmBeforeData.messages.push(toolMessage);
-                        toolMessages.push(toolMessage);
-                        // 工具调用追加到本回合的统一时间线
-                        turnSegments.push({
-                            type: 'tool_call',
-                            name: toolName,
-                            args: toolArgs,
+                    }
+                    const callCtx = { ...toolCtx, callId };
+                    // Hook: agent:tool:before — 插件可以拦截或修改工具调用
+                    const toolBeforeData = { name: toolCall.function.name, args: parsed.args, toolCallContext: callCtx };
+                    // 单个工具的链路异常（钩子 / 守卫 / 结果处理抛错）只算该工具失败，转成它自己的错误结果：
+                    // 整批照常落定、整组落库，兄弟工具已发生的副作用不会因连坐而从历史里消失。
+                    // executeDone 区分失败发生在执行前还是执行后——后者须明说「已执行」，免得模型重做有副作用的操作。
+                    let executeDone = false;
+                    let toolT0;
+                    try {
+                        await this.caps.hooks.use.run('agent:tool:before', toolBeforeData);
+                        // 通知平台：工具开始执行
+                        await announce('start', toolBeforeData.name, toolBeforeData.args);
+                        // 紧随 start 赋值：catch 据此判断 start 已发出
+                        toolT0 = Date.now();
+                        this.logger.debug(`工具执行: ${toolBeforeData.name} 参数=${formatToolArgsForLog(toolBeforeData.args)}`);
+                        const executed = await (this.caps.tools.present
+                            ? this.caps.tools.use.execute(toolBeforeData.name, toolBeforeData.args, callCtx)
+                            : Promise.resolve({ content: JSON.stringify({ error: 'tools 服务不可用' }) }));
+                        executeDone = true;
+                        let result = executed.content;
+                        // 工具交给主模型看的图：主模型能看图时才随本回合的 tool 消息走（出口由 prepareLLMMessages 编码），
+                        // 不能看时工具硬塞的也不交，模型只读文字结果；不进钩子/事件/时间线（那些面都是文本），
+                        // 也不落库（见 saveToolCallGroup）。
+                        const resultImages = acceptsImages ? executed.images : undefined;
+                        // Hook: agent:tool:after — 插件可以处理工具执行结果，写进 metadata 的随结果落库
+                        const toolAfterData = {
+                            name: toolBeforeData.name,
                             result,
-                            startTime,
-                            endTime,
+                            toolCallContext: callCtx,
+                            metadata: {},
+                        };
+                        await this.caps.hooks.use.run('agent:tool:after', toolAfterData);
+                        result = toolAfterData.result;
+                        // 工具结果截断：按上下文窗口比例限制单条工具结果长度
+                        if (result.length > toolResultMaxChars) {
+                            this.logger.info(`工具结果过长 (${result.length} 字符)，截断至 ${toolResultMaxChars} 字符: ${toolBeforeData.name}`);
+                            result = truncateChars(result, toolResultMaxChars, `\n... [工具输出已截断，原始长度 ${result.length} 字符]`);
+                        }
+                        const toolEndTime = Date.now();
+                        this.logger.debug(`工具完成: ${toolBeforeData.name} (${toolEndTime - toolT0}ms) 结果=${result}`);
+                        // 通知平台：工具执行完成
+                        await announce('end', toolBeforeData.name, toolBeforeData.args, result);
+                        return {
+                            toolCall,
                             callId,
+                            result,
+                            resultImages,
+                            resultMetadata: toolAfterData.metadata,
+                            toolName: toolBeforeData.name,
+                            toolArgs: toolBeforeData.args,
+                            startTime: toolT0,
+                            endTime: toolEndTime,
+                        };
+                    }
+                    catch (err) {
+                        // 执行后的失败不回退到原始结果（fail-closed）：after 钩子可能是脱敏钩子，失败时原始输出不能漏给模型
+                        const reason = err instanceof Error ? err.message : String(err);
+                        this.logger.warn(`工具${executeDone ? '已执行，但结果处理' : '调用'}失败: ${toolBeforeData.name} (${reason})`);
+                        const failedAt = Date.now();
+                        const result = JSON.stringify({
+                            error: executeDone ? `工具已执行，但结果处理失败：${reason}` : `工具调用失败：${reason}`,
                         });
+                        // 执行前就失败的补发开始，再发配对的结束（emit 恒 resolve）
+                        if (toolT0 === undefined)
+                            await announce('start', toolBeforeData.name, toolBeforeData.args);
+                        await announce('end', toolBeforeData.name, toolBeforeData.args, result);
+                        return {
+                            toolCall,
+                            callId,
+                            result,
+                            resultImages: undefined,
+                            toolName: toolBeforeData.name,
+                            toolArgs: toolBeforeData.args,
+                            startTime: toolT0 ?? failedAt,
+                            endTime: failedAt,
+                        };
                     }
-                    historyMessages += 1 + toolMessages.length;
-                    await this.saveToolCallGroup(incoming.sessionId, assistantToolMessage, toolMessages, turnPersistedTimestamps);
-                    // 继续请求 LLM (再次经过 hooks)，使用原始完整工具列表而非被上一轮 hooks 修改过的列表
-                    const nextLlmData = {
-                        messages: llmBeforeData.messages,
-                        tools: [...originalTools],
-                        sessionId: incoming.sessionId,
-                        userId: incoming.userId,
-                        platform: incoming.platform,
-                        triggerType: incoming.triggerType,
-                        source: incoming.source,
-                    };
-                    // 已物化的贡献按全局键跳过；本轮工具调用新注册的贡献（如新激活技能）增量落位
-                    await assemblePromptContributions(this.caps, nextLlmData, {
-                        buildTimeoutMs: this.promptBuildTimeoutMs,
-                        signal,
-                    });
-                    await this.caps.hooks.use.run('agent:llm:before', nextLlmData, undefined, { warnOnStall: true });
-                    // 裁剪消息以确保不超过上下文窗口
-                    const nextSent = trimForCall(nextLlmData.messages);
-                    nextLlmData.messages = nextSent.messages;
-                    const tN = Date.now();
-                    const nextResult = await this.consumeStream(llm, {
-                        messages: nextLlmData.messages,
-                        tools: nextLlmData.tools.length > 0 ? nextLlmData.tools : undefined,
-                        maxTokens,
-                        signal,
-                        ...thinking,
-                    }, turnId, incoming.sessionId, incoming.platform);
-                    await reportUsage(nextSent, nextLlmData.tools, nextResult);
-                    turnSegments.push(...nextResult.segments);
-                    response = nextResult;
-                    generating = nextResult.generating;
-                    accUsage(response.usage);
-                    this.debugLogResponse(response, Date.now() - tN, iterations);
-                    const nextLlmAfterData = { response, messages: nextLlmData.messages };
-                    await this.caps.hooks.use.run('agent:llm:after', nextLlmAfterData);
-                    response = nextLlmAfterData.response;
-                }
-                // 检测是否因工具调用次数达到上限而退出循环
-                const toolLimitReached = iterations >= maxToolIterations && response.toolCalls != null && response.toolCalls.length > 0;
-                if (toolLimitReached) {
-                    this.logger.warn(`工具调用达到上限 (${maxToolIterations})，session=${incoming.sessionId}`);
-                }
-                // 保留原始 LLM 输出，用于存入 memory（避免纯文本历史污染 few-shot 示例）
-                let rawLlmContent = response.content ?? '';
-                let replyContent = rawLlmContent;
-                // Hook: agent:reply:before — 插件可以修改最终回复
-                // JSON 解析/修复统一由 persona 的 agent:reply:before 钩子处理
-                const responseData = {
-                    content: replyContent,
-                    sessionId: incoming.sessionId,
-                    platform: incoming.platform,
-                    userId: incoming.userId,
-                    triggerType: incoming.triggerType,
-                    attempt: 0,
-                };
-                const validateReply = async () => {
-                    const attemptedTools = reportOnly && !!response.toolCalls?.length;
-                    if (attemptedTools)
-                        responseData.content = '';
-                    await this.caps.hooks.use.run('agent:reply:before', responseData);
-                    // 误调用工具或静默先给模型一次纠正机会，复用格式重试预算，不能无限尝试或执行工具。
-                    const replyLinks = reportOnly ? (responseData.content.match(NOTICE_URL) ?? []) : [];
-                    const missingLink = noticeLinks.some(link => !replyLinks.some(candidate => candidate === link || candidate.replace(/[.!;:]+$/u, '') === link));
-                    if (reportOnly && (attemptedTools || !responseData.content.trim() || missingLink)) {
-                        responseData.content = '';
-                        responseData.maxRetries = Math.max(1, responseData.maxRetries ?? 0);
-                        responseData.retryRequested = true;
-                        responseData.retryFeedback =
-                            `${responseData.retryFeedback ?? ''}\n本轮只需转述已给出的宿主结果，不要调用工具或查询状态。` +
-                                '请沿用当前人设和规定的回复格式，给出包含结果与已有链接的非空回复。';
+                }));
+                // 工具交出的图只服务紧接着的这一次请求：上一轮工具结果里的图在这里剥掉，否则多轮
+                // 工具迭代会让图片在上下文里累积（每张数百 token，且不受文本裁剪约束）。
+                for (let i = 0; i < llmBeforeData.messages.length; i++) {
+                    const m = llmBeforeData.messages[i];
+                    if (m.role === 'tool' && m.images) {
+                        const { images: _spent, ...rest } = m;
+                        llmBeforeData.messages[i] = rest;
                     }
-                };
-                await validateReply();
-                // 重试循环：当 hook（如 persona 的 outputFormat 解析）报告 retryRequested 时，
-                // 把失败的 assistant 输出 + 系统反馈追加到消息列表，重新请求 LLM；最多按 maxRetries 次。
-                // maxRetries 由 hook 端写入（plugin-persona 从 outputFormat.retries 读取，默认 1）。
-                // 上游吐空流同样会被判不合格：此时没有可回放的失败输出，只追加系统反馈再请求一次。
-                const maxRetries = Math.max(0, responseData.maxRetries ?? 0);
-                let attempt = 0;
-                while (responseData.retryRequested && attempt < maxRetries) {
-                    attempt++;
-                    this.logger.debug(`agent:reply:before 请求重试 (attempt=${attempt}/${maxRetries}, session=${incoming.sessionId}): ${responseData.retryFeedback ?? '(无反馈)'}`);
-                    if (rawLlmContent.length > 0)
-                        llmBeforeData.messages.push({ role: 'assistant', content: rawLlmContent });
-                    llmBeforeData.messages.push({
-                        role: 'system',
-                        content: responseData.retryFeedback ?? '上一次回复未能通过格式校验，请严格按照系统提示中规定的格式重新输出。',
-                    });
-                    const retrySent = trimForCall(llmBeforeData.messages);
-                    const retryResult = await this.consumeStream(llm, {
-                        messages: retrySent.messages,
-                        tools: undefined,
-                        maxTokens,
-                        signal,
-                        ...thinking,
-                    }, turnId, incoming.sessionId, incoming.platform, !reportOnly);
-                    await reportUsage(retrySent, [], retryResult);
-                    turnSegments.push(...retryResult.segments);
-                    response = retryResult;
-                    accUsage(response.usage);
-                    rawLlmContent = response.content ?? '';
-                    // 用新输出再次跑 hook；hook 端根据 attempt 决定继续重试或走兜底（静默丢弃）
-                    responseData.content = rawLlmContent;
-                    responseData.archiveContent = undefined;
-                    responseData.visibleContent = undefined;
-                    responseData.retryRequested = false;
-                    responseData.retryFeedback = undefined;
-                    responseData.attempt = attempt;
-                    await validateReply();
-                }
-                // 双保险：循环结束后若 hook 仍标记 retryRequested（理论上 persona 已在用尽时自动走兜底），
-                // 强制把 content 置空，避免原始未校验内容被外发。
-                if (responseData.retryRequested) {
-                    this.logger.warn(`agent:reply:before 重试用尽但 retryRequested 仍为 true，强制丢弃回复内容 (session=${incoming.sessionId})`);
-                    responseData.content = '';
-                    responseData.retryRequested = false;
-                }
-                replyContent = responseData.content;
-                const archiveContent = responseData.archiveContent ?? rawLlmContent;
-                const visibleContent = responseData.visibleContent ?? replyContent;
-                // 重复检测：如果回复与最近一条 assistant 消息完全相同，视为模型"卡壳"，静默跳过。
-                // 比的是 archiveContent（与落库同源口径）——启用 outputFormat 时历史里存的是整串 JSON，
-                // 拿解码后的纯文本去比永远不成立。
-                const lastAssistant = [...messages].reverse().find(m => m.role === 'assistant');
-                if (archiveContent && lastAssistant?.content && archiveContent === lastAssistant.content) {
-                    this.logger.warn(`检测到重复回复，跳过发送 (session=${incoming.sessionId})`);
-                    replyContent = '';
                 }
-                // 提交点：此后的流结束标记、落库与外发成组执行。流结束后到这里之间（llm:after / 工具循环退出 /
-                // reply:before / 重试）被 latest-wins、手动停止或拆卸掐掉的回合，走下方 AbortError 收尾，不落库、不外发。
-                if (signal.aborted)
-                    throw new DOMException('Generation aborted', 'AbortError');
-                // 发出流结束标记
-                await this.caps.events.use.emit('outbound:stream', {
-                    sessionId: incoming.sessionId,
-                    turnId,
-                    platform: incoming.platform,
-                    done: true,
-                    toolLimitReached,
-                });
-                // 空回复（outputFormat 中 reply 字段为空字符串或仅空白）时静默，不发送消息
-                if (replyContent.trim().length === 0) {
-                    this.logger.debug(`空回复，跳过发送 (session=${incoming.sessionId})`);
-                }
-                else {
-                    const visibleSegments = !reportOnly && turnSegments.length > 0 ? turnSegments : undefined;
-                    // 在 assistant 最终持久化时记录 modelInfo：前端从消息历史可还原 "这条回复
-                    // 由哪个 model 生成、用了多少 token"，方便用户验证模型切换是否生效。
-                    const turnModelInfo = {
-                        provider: llm.providerId,
-                        model: llm.id,
-                        promptTokens: turnUsageAcc.promptTokens || undefined,
-                        completionTokens: turnUsageAcc.completionTokens || undefined,
-                    };
-                    const finalAssistantMetadata = {
-                        ...(assistantMetadata ?? {}),
-                        [WellKnownMetadataKeys.ModelInfo]: turnModelInfo,
+                // 按原始 toolCalls 顺序将结果推入消息列表 + 时间线
+                for (const { toolCall, callId, result, resultImages, resultMetadata, toolName, toolArgs, startTime, endTime, } of parallelResults) {
+                    // callId 随工具结果与时间线落库：没回复就收尾的一轮只落工具调用组，历史里的工具卡靠它对回这次调用
+                    const toolMessage = {
+                        role: 'tool',
+                        content: result,
+                        toolCallId: toolCall.id,
+                        ...(resultImages && resultImages.length > 0 ? { images: resultImages } : {}),
+                        metadata: {
+                            ...resultMetadata,
+                            [WellKnownMetadataKeys.TurnId]: turnId,
+                            [WellKnownMetadataKeys.CallId]: callId,
+                        },
                     };
-                    // 落库的是信封（如 outputFormat 的整串 JSON）时，另带解码后的可见正文，供检索、摘要等按语义读历史的一方用
-                    if (visibleContent !== archiveContent) {
-                        finalAssistantMetadata[WellKnownMetadataKeys.VisibleContent] = visibleContent;
-                    }
-                    // 保存最终 assistant 回复：优先存 persona 修复/规范化后的 JSON，保持格式完整，
-                    // 避免坏 JSON 或解码后纯文本污染历史 few-shot 示例导致模型不再遵守 outputFormat
-                    await this.saveToMemory(incoming.sessionId, {
-                        role: 'assistant',
-                        content: archiveContent,
-                        reasoningContent: reportOnly ? undefined : response.reasoningContent,
-                        timestamp: Date.now(),
-                        metadata: finalAssistantMetadata,
-                        segments: visibleSegments,
-                    });
-                    // 外发给平台：只带正文与这条回复的模型和 token，思考与时间线只在上面落库的消息上
-                    await this.dispatchOutbound({
-                        content: replyContent,
-                        sessionId: incoming.sessionId,
-                        platform: incoming.platform,
-                        ...(incoming.hostNotice
-                            ? { hostNotice: { kind: incoming.hostNotice.kind, id: incoming.hostNotice.id } }
-                            : {}),
-                        ...(incoming.hostNotice?.replyTo ? { replyTo: incoming.hostNotice.replyTo } : {}),
-                        source: 'agent',
-                        turnId,
-                        modelInfo: turnModelInfo,
+                    llmBeforeData.messages.push(toolMessage);
+                    toolMessages.push(toolMessage);
+                    // 工具调用追加到本回合的统一时间线
+                    turnSegments.push({
+                        type: 'tool_call',
+                        name: toolName,
+                        args: toolArgs,
+                        result,
+                        startTime,
+                        endTime,
+                        callId,
                     });
                 }
-                // Hook: agent:turn:after — 插件可以在完整消息周期结束后做后处理
-                const turnOutcome = replyContent.trim().length === 0 ? 'silent' : 'replied';
-                await this.caps.hooks.use.run('agent:turn:after', {
-                    message: incoming,
-                    reply: replyContent,
-                    outcome: turnOutcome,
-                    sessionId: incoming.sessionId,
-                    turnId,
-                    metadata: msgHookData.metadata,
+                historyMessages += 1 + toolMessages.length;
+                await this.saveToolCallGroup(sessionId, assistantToolMessage, toolMessages);
+                savedGroups = true;
+                // 继续请求 LLM (再次经过 hooks)，使用原始完整工具列表而非被上一轮 hooks 修改过的列表
+                const nextLlmData = {
+                    messages: llmBeforeData.messages,
+                    tools: [...originalTools],
+                    acceptsImages,
+                    sessionId,
+                    platform,
+                    source: first.source,
+                };
+                // 已物化的贡献按全局键跳过；本轮工具调用新注册的贡献（如新激活技能）增量落位
+                await assemblePromptContributions(this.caps, nextLlmData, inputs, {
+                    buildTimeoutMs: this.promptBuildTimeoutMs,
+                    signal,
                 });
+                await this.caps.hooks.use.run('agent:llm:before', nextLlmData, undefined, { warnOnStall: true });
+                await insertJoined(nextLlmData);
+                // 裁剪消息以确保不超过上下文窗口
+                const nextSent = trimForCall(nextLlmData.messages);
+                nextLlmData.messages = nextSent.messages;
+                const tN = Date.now();
+                const nextResult = await this.consumeStream(llm, {
+                    messages: nextLlmData.messages,
+                    tools: nextLlmData.tools.length > 0 ? nextLlmData.tools : undefined,
+                    maxTokens,
+                    signal,
+                    ...thinking,
+                }, turnId, sessionId, platform);
+                await reportUsage(nextSent, nextLlmData.tools, nextResult);
+                turnSegments.push(...nextResult.segments);
+                response = nextResult;
+                generating = nextResult.generating;
+                accUsage(response.usage);
+                this.debugLogResponse(response, Date.now() - tN, iterations);
+                const nextLlmAfterData = { response, messages: nextLlmData.messages };
+                await this.caps.hooks.use.run('agent:llm:after', nextLlmAfterData);
+                response = nextLlmAfterData.response;
             }
-            catch (err) {
-                // 中止错误 — 静默退出，前端通过 outbound:stream done 清理 buffer。
-                //
-                // 历史教训：早期版本会用 turnPersistedTimestamps 把"本轮已持久化的中间消息"全部删掉，
-                // 注释里写的是防"半截 assistant 内容 / 假回退"。但实际审计 saveToolCallGroup（见下方）发现：
-                //   1. saveToolCallGroup 只在并行工具全部落定后整组写入（assistant tool_call + 所有
-                //      tool result 一次性 push；单个工具的异常已在闭包内转成它自己的错误结果），不存在
-                //      写了一半的组；turnPersistedTimestamps 里只可能是"已落定、副作用已发生"的工具调用对。
-                //   2. 删除这些 = 让 agent 忘记自己刚刚做过的有副作用的事（戳一戳/发送消息/调度任务/…），
-                //      下一轮 LLM 看不到自己的行为，会重复调用，外部观察就是"agent 一直以为戳不了"。
-                //   3. 真正的 orphan 风险（assistant tool_calls 缺 tool result）由 sanitizeToolCallHistory
-                //      在装载历史时兜底过滤，不需要 abort 路径主动删除。
-                // 所以这里不再回滚，让已完成的工具调用记录留在 memory，agent 下一轮能正确感知。
-                if (err instanceof DOMException && err.name === 'AbortError') {
-                    this.logger.info(`生成已中止: session=${incoming.sessionId}` +
-                        (turnPersistedTimestamps.length > 0
-                            ? `（保留本轮已完成的 ${turnPersistedTimestamps.length} 条工具调用记录，便于下一轮 agent 感知）`
-                            : ''));
-                    await this.caps.events.use.emit('outbound:stream', {
-                        sessionId: incoming.sessionId,
-                        turnId,
-                        platform: incoming.platform,
-                        done: true,
-                    });
-                    // 中止同样是回合终态：发 agent:turn:after(outcome=aborted) 让生命周期订阅方收尾——
-                    // 编排的 agent 节点在等这一轮的结果，不发它就要等到超时才失败。
-                    // 文档与 agent-api 早已声明 outcome 含 aborted，此处兑现契约。
-                    await this.caps.hooks.use.run('agent:turn:after', {
-                        message: incoming,
-                        reply: '',
-                        outcome: 'aborted',
-                        sessionId: incoming.sessionId,
-                        turnId,
-                        metadata: msgHookData.metadata,
-                    });
-                    return;
-                }
-                const message = err instanceof Error ? err.message : String(err);
-                this.logger.error(`处理消息失败: ${message}`);
-                // 异常同样要结束流：不发 done，CLI 的流式块不收尾、会话里流式输出的条目不结束，
-                // 下一轮 delta 还会抹掉这条 [错误] 与用户的新输入。顺序与正常收尾一致——先 done 再发消息。
-                await this.caps.events.use.emit('outbound:stream', {
-                    sessionId: incoming.sessionId,
-                    turnId,
-                    platform: incoming.platform,
-                    done: true,
-                });
-                if (!reportOnly) {
-                    await this.dispatchOutbound({
-                        content: `[错误] ${message}`,
-                        sessionId: incoming.sessionId,
-                        platform: incoming.platform,
-                        source: 'system',
-                    });
+            // 最后一次模型调用返回了最后的回复：这一轮不再收输入，还没插进去的转为排队
+            this.queues.close(turn);
+            // 检测是否因工具调用次数达到上限而退出循环
+            const toolLimitReached = !withinLimit() && response.toolCalls != null && response.toolCalls.length > 0;
+            if (toolLimitReached) {
+                this.logger.warn(`工具调用达到上限 (${maxToolIterations})，session=${sessionId}`);
+            }
+            // 保留原始 LLM 输出：没有中间件改写落库内容时，落库的就是它
+            let rawLlmContent = response.content ?? '';
+            let replyContent = rawLlmContent;
+            // Hook: agent:reply:before — 插件可以修改最终回复
+            // JSON 解析/修复统一由 persona 的 agent:reply:before 钩子处理
+            const responseData = {
+                content: replyContent,
+                sessionId,
+                platform,
+                attempt: 0,
+            };
+            const validateReply = async () => {
+                const attemptedTools = reportOnly && !!response.toolCalls?.length;
+                if (attemptedTools)
+                    responseData.content = '';
+                await this.caps.hooks.use.run('agent:reply:before', responseData);
+                // 误调用工具或静默先给模型一次纠正机会，复用格式重试预算，不能无限尝试或执行工具。
+                const replyLinks = reportOnly ? (responseData.content.match(NOTICE_URL) ?? []) : [];
+                const missingLink = noticeLinks.some(link => !replyLinks.some(candidate => candidate === link || candidate.replace(/[.!;:]+$/u, '') === link));
+                if (reportOnly && (attemptedTools || !responseData.content.trim() || missingLink)) {
+                    responseData.content = '';
+                    responseData.maxRetries = Math.max(1, responseData.maxRetries ?? 0);
+                    responseData.retryRequested = true;
+                    responseData.retryFeedback =
+                        `${responseData.retryFeedback ?? ''}\n本轮只需转述已给出的宿主结果，不要调用工具或查询状态。` +
+                            '请沿用当前人设和规定的回复格式，给出包含结果与已有链接的非空回复。';
                 }
-                // 异常也是回合终态：同样发 turn:after(outcome=error)，等这一轮结果的订阅方才收得了尾。
-                await this.caps.hooks.use.run('agent:turn:after', {
-                    message: incoming,
-                    reply: '',
-                    outcome: 'error',
-                    error: message,
-                    sessionId: incoming.sessionId,
-                    turnId,
-                    metadata: msgHookData.metadata,
+            };
+            await validateReply();
+            // 重试循环：当 hook（如 persona 的 outputFormat 解析）报告 retryRequested 时，
+            // 把失败的 assistant 输出 + 系统反馈追加到消息列表，重新请求 LLM；最多按 maxRetries 次。
+            // maxRetries 由 hook 端写入（plugin-persona 从 outputFormat.retries 读取，默认 1）。
+            // 上游吐空流同样会被判不合格：此时没有可回放的失败输出，只追加系统反馈再请求一次。
+            const maxRetries = Math.max(0, responseData.maxRetries ?? 0);
+            let attempt = 0;
+            while (responseData.retryRequested && attempt < maxRetries) {
+                attempt++;
+                this.logger.debug(`agent:reply:before 请求重试 (attempt=${attempt}/${maxRetries}, session=${sessionId}): ${responseData.retryFeedback ?? '(无反馈)'}`);
+                if (rawLlmContent.length > 0)
+                    llmBeforeData.messages.push({ role: 'assistant', content: rawLlmContent });
+                llmBeforeData.messages.push({
+                    role: 'system',
+                    content: responseData.retryFeedback ?? '上一次回复未能通过格式校验，请严格按照系统提示中规定的格式重新输出。',
                 });
+                const retrySent = trimForCall(llmBeforeData.messages);
+                const retryResult = await this.consumeStream(llm, {
+                    messages: retrySent.messages,
+                    tools: undefined,
+                    maxTokens,
+                    signal,
+                    ...thinking,
+                }, turnId, sessionId, platform, !reportOnly);
+                await reportUsage(retrySent, [], retryResult);
+                turnSegments.push(...retryResult.segments);
+                response = retryResult;
+                accUsage(response.usage);
+                rawLlmContent = response.content ?? '';
+                // 用新输出再次跑 hook；hook 端根据 attempt 决定继续重试或走兜底（静默丢弃）
+                responseData.content = rawLlmContent;
+                responseData.archiveContent = undefined;
+                responseData.visibleContent = undefined;
+                responseData.retryRequested = false;
+                responseData.retryFeedback = undefined;
+                responseData.attempt = attempt;
+                await validateReply();
             }
-        });
-        // 消息被拦截（如流控缓冲），通知前端结束 loading
-        if (!handled) {
+            // 双保险：循环结束后若 hook 仍标记 retryRequested（理论上 persona 已在用尽时自动走兜底），
+            // 强制把 content 置空，避免原始未校验内容被外发。
+            if (responseData.retryRequested) {
+                this.logger.warn(`agent:reply:before 重试用尽但 retryRequested 仍为 true，强制丢弃回复内容 (session=${sessionId})`);
+                responseData.content = '';
+                responseData.retryRequested = false;
+            }
+            replyContent = responseData.content;
+            const archiveContent = responseData.archiveContent ?? rawLlmContent;
+            const visibleContent = responseData.visibleContent ?? replyContent;
+            // 提交点：此后的流结束标记、落库与外发成组执行。流结束后到这里之间（llm:after / 工具循环退出 /
+            // reply:before / 重试）被停下的回合（停止键、禁言、停机等），走下方 AbortError 收尾，不落库、不外发。
+            if (signal.aborted)
+                throw new DOMException('Generation aborted', 'AbortError');
+            // 发出流结束标记
             await this.caps.events.use.emit('outbound:stream', {
-                sessionId: incoming.sessionId,
+                sessionId,
                 turnId,
-                platform: incoming.platform,
+                platform,
                 done: true,
+                toolLimitReached,
             });
+            // 空回复（outputFormat 中 reply 字段为空字符串或仅空白）时静默，不发送消息
+            if (replyContent.trim().length === 0) {
+                this.logger.debug(`空回复，跳过发送 (session=${sessionId})`);
+            }
+            else {
+                const visibleSegments = !reportOnly && turnSegments.length > 0 ? turnSegments : undefined;
+                // 在 assistant 最终持久化时记录 modelInfo：前端从消息历史可还原 "这条回复
+                // 由哪个 model 生成、用了多少 token"，方便用户验证模型切换是否生效。
+                const turnModelInfo = {
+                    provider: llm.providerId,
+                    model: llm.id,
+                    promptTokens: turnUsageAcc.promptTokens || undefined,
+                    completionTokens: turnUsageAcc.completionTokens || undefined,
+                };
+                const finalAssistantMetadata = {
+                    ...(assistantMetadata ?? {}),
+                    [WellKnownMetadataKeys.ModelInfo]: turnModelInfo,
+                    [WellKnownMetadataKeys.TurnRecord]: recordOf('replied'),
+                };
+                // 落库的是信封（如 outputFormat 的整串 JSON）时，另带解码后的可见正文，供检索、摘要等按语义读历史的一方用
+                if (visibleContent !== archiveContent) {
+                    finalAssistantMetadata[WellKnownMetadataKeys.VisibleContent] = visibleContent;
+                }
+                // 保存最终 assistant 回复：落库存信封原文，交给模型的历史取可见正文（historyForModel）
+                await this.saveToMemory(sessionId, {
+                    role: 'assistant',
+                    content: archiveContent,
+                    reasoningContent: reportOnly ? undefined : response.reasoningContent,
+                    timestamp: Date.now(),
+                    metadata: finalAssistantMetadata,
+                    segments: visibleSegments,
+                });
+                recorded = true;
+                // 外发给平台：只带正文与这条回复的模型和 token，思考与时间线只在上面落库的消息上；
+                // 正文是她写的，其中的 @、媒体与引用标记交适配器解析
+                await this.dispatchOutbound({
+                    content: replyContent,
+                    sessionId,
+                    platform,
+                    ...(first.hostNotice ? { hostNotice: { kind: first.hostNotice.kind, id: first.hostNotice.id } } : {}),
+                    ...(first.hostNotice?.replyTo ? { replyTo: first.hostNotice.replyTo } : {}),
+                    markup: true,
+                    source: 'agent',
+                    turnId,
+                    modelInfo: turnModelInfo,
+                });
+            }
+            // Hook: agent:turn:after — 插件可以在完整消息周期结束后做后处理；在 try 里等它，它的中间件出错同样按出错收尾
+            return await end(replyContent.trim().length === 0 ? 'silent' : 'replied', { reply: replyContent });
+        }
+        catch (err) {
+            // 中止错误 — 静默退出，前端通过 outbound:stream done 清理 buffer。
+            //
+            // 被停下的一轮里已完成的工具调用组留在历史里，不回滚：saveToolCallGroup 只在并行工具全部落定后整组写入（单个工具的
+            // 异常已在闭包内转成它自己的错误结果），不存在写了一半的组，留下的只可能是「已落定、副作用已发生」的工具调用对；删掉
+            // 它们等于让 agent 忘记自己刚做过的有副作用的事（戳一戳、发送消息、调度任务等），下一轮会重复调用。不完整的组
+            // （assistant tool_calls 缺 tool result）由 sanitizeToolCallHistory 在装载历史时兜底过滤。
+            if (err instanceof DOMException && err.name === 'AbortError') {
+                await this.caps.events.use.emit('outbound:stream', { sessionId, turnId, platform, done: true });
+                // 中止同样是回合终态：发 agent:turn:after(outcome=aborted) 让生命周期订阅方收尾——
+                // 编排的 agent 节点在等这一轮的结果，不发它就要等到超时才失败。
+                return end('aborted');
+            }
+            const error = textOf(err);
+            this.logger.error(`处理消息失败: ${toSource(error)}`);
+            // 异常同样要结束流：不发 done，会话里流式输出的条目不结束。顺序与正常收尾一致——先 done 再发消息。
+            await this.caps.events.use.emit('outbound:stream', { sessionId, turnId, platform, done: true });
+            if (!reportOnly) {
+                const text = t('turnError', { error });
+                await this.dispatchOutbound({ content: toSource(text), text, sessionId, platform, source: 'system', turnId });
+            }
+            // 异常也是回合终态：同样发 turn:after(outcome=error)，等这一轮结果的订阅方才收得了尾。
+            return end('error', { error });
         }
     }
     /**
-     * 构建发送给 LLM 的消息列表。历史按会话的条数线读：historyLimit 为 0 或没设置时读全部活跃历史。
-     * historyMessages 是从记忆读进的条数（含已归档的这一轮入站消息），与之后的清洗、裁剪无关
+     * 构建发送给 LLM 的消息列表。历史按会话的条数线成段丢弃（见 readHistory）：historyLimit 为 0 或没设置时发全部活跃历史，
+     * 跳过这一轮各条输入的归档。historyMessages 是会话活跃历史里对话消息的条数（事件标记不算；含已归档的这一轮的输入与没发给
+     * 模型的部分），与之后的清洗、裁剪无关；history 是发出的历史那一段的消息对象，硬裁剪按它认出历史。历史之后依次是易变块、
+     * 由排着的真人消息开的一轮的说明、多方房间里有被点名的输入时的焦点指引、各条输入。acceptsImages 是这一轮的主模型能不能看图，
+     * media 缺席时由它定当轮的图交不交
      */
-    async buildMessages(incoming, historyLimit, personaOpts, archivedIncoming) {
+    async buildMessages(turn, inputs, historyLimit, acceptsImages, multiParty, personaOpts) {
         const messages = [];
         let historyMessages = 0;
+        const { sessionId } = turn;
         // 1. 系统提示
         const systemPrompt = this.buildSystemPrompt(personaOpts);
         messages.push({ role: 'system', content: systemPrompt, metadata: { injector: 'persona' } });
-        // 2. 历史消息
-        const memory = this.caps.memory.present ? this.caps.memory.use : undefined;
-        if (memory) {
-            try {
-                const stored = await memory.getHistory(incoming.sessionId, historyLimit || Infinity);
-                historyMessages = stored.length;
-                const history = this.sanitizeToolCallHistory(stored, incoming.sessionId);
-                const now = Date.now();
-                for (const m of history) {
-                    if (archivedIncoming && this.isSameMessage(m, archivedIncoming))
-                        continue;
-                    if (CONTROL_KINDS.includes(m.kind ?? ''))
-                        continue;
-                    // 为用户消息注入时间标注，帮助 LLM 理解时间先后。标注加在副本上：记忆服务可能直接交出存着的消息对象
-                    if (m.role === 'user' && m.timestamp && m.content) {
-                        const timeLabel = formatTimeLabel(m.timestamp, now);
-                        if (timeLabel && !m.content.startsWith(`(${timeLabel})`)) {
-                            messages.push({ ...m, content: `(${timeLabel}) ${m.content}` });
-                            continue;
-                        }
-                    }
-                    messages.push(m);
-                }
-            }
-            catch (err) {
-                this.logger.warn('获取历史消息失败:', err);
+        // 2. 历史消息：跳过这一轮已归档的输入
+        try {
+            const archived = inputs.flatMap(input => (input.archived ? [input.archived] : []));
+            const past = await this.modelHistory(sessionId, historyLimit, archived);
+            historyMessages = past.count;
+            if (past.dropped > 0) {
+                this.logger.warn(`历史消息中发现不完整工具调用组，已跳过 ${past.dropped} 条 (session=${sessionId})`);
             }
+            messages.push(...past.messages);
         }
-        // 3. 当前消息
-        //
-        // 内容主体由 message-archive 烘焙：sender 前缀 / 引用回复 / 图片描述 / 附件描述
-        // 都已经写进 archivedIncoming.content。这里只在外层加一个时间标注，
-        // 保证「LLM 看到的当前消息」与「历史消息」「向量库存档」三者一致。
-        const senderLabel = getSenderLabel(incoming.nickname, incoming.userId);
-        const nowLabel = formatTimeLabel(Date.now(), Date.now());
-        const archivedBody = archivedIncoming?.content;
-        const fallbackBody = senderLabel ? `[${senderLabel}]: ${incoming.content}` : incoming.content;
-        const currentContent = `(${nowLabel}) ${archivedBody ?? fallbackBody}`;
+        catch (err) {
+            this.logger.warn('获取历史消息失败:', err);
+        }
+        const history = new Set(messages.slice(1));
+        // 3. 这一轮的输入。带来源的注入各自成一轮，宿主通知与委派只有这一条
+        const first = inputs[0].message;
         // 宿主通知分支：宿主撰写的事件通知不是任何人的发言，与 proactive 一样以 system 呈现、
         // 不推当前 user 消息与易变块。不可信段只在当轮接在宿主正文之后（归档只留正文），
         // 之后的回合从历史里只看得到宿主正文。
-        if (incoming.hostNotice) {
-            const { untrusted } = incoming.hostNotice;
+        if (first.hostNotice) {
+            const { untrusted } = first.hostNotice;
             messages.push({
                 role: 'system',
-                content: `[宿主通知]\n${incoming.content}${untrusted ? `\n\n${untrusted}` : ''}`,
+                content: `[宿主通知]\n${first.content}${untrusted ? `\n\n${untrusted}` : ''}`,
                 metadata: { injector: WellKnownKinds.HostNotice },
             });
-            return { messages, historyMessages };
+            return { messages, historyMessages, history };
         }
         // 3a. proactive 分支：系统代发给本会话的任务指令（如 workflow 的 agent 节点）
         //
         // 这条消息不是用户请求，必须作为 system 指令呈现给 LLM，否则 agent 会把它当成
         // 真实用户在指挥（典型 BUG：agent 看到 user 角色的任务指令，回复时使用「您」
         // 「您好」等措辞，把派发方当成了用户）。
-        if (incoming.triggerType === 'proactive') {
+        if (first.triggerType === 'proactive') {
             messages.push({
                 role: 'system',
                 content: `[跨会话委派 — 非用户消息]\n` +
-                    `任务: ${incoming.content}\n\n` +
+                    `任务: ${first.content}\n\n` +
                     `说明: 这是你（作为同一 agent 在另一会话的实例）派发给本会话的任务指令，` +
                     `不是用户请求。处理时不要使用「您」「请问」等面向用户的措辞，按指令直接执行并简明回报结果。\n`,
                 metadata: { injector: WellKnownKinds.CrossSessionDelegation },
             });
-            return { messages, historyMessages };
+            return { messages, historyMessages, history };
         }
         // 3b. 普通用户消息分支
-        // 检测预处理附件内容——引导 LLM 综合分析而非逐项转述
-        const hasPreprocessed = /\[图片\d*[:：]|\[文件[:：]|--- 文件内容 ---/.test(currentContent);
-        if (hasPreprocessed) {
+        // 本轮附件有描述正文（媒体识别的描述、文件说明）时，引导 LLM 综合作答而非逐项转述
+        if (inputs.some(input => hasAttachmentDescriptions(input.message))) {
             messages.push({
                 role: 'system',
                 content: '用户消息中包含系统预处理的附件描述（图片识别结果和/或文件内容提取）。' +
@@ -1280,14 +1220,48 @@ class DefaultAgent {
                 metadata: { injector: 'system-other' },
             });
         }
+        // 易变上下文（当前时间 / 会话环境 / 上一轮状态）落在历史**之后**：
+        // provider 的前缀缓存从第一个 token 起逐位比对，这几块原本混在人设卡开头，
+        // 秒级时间戳一变，人设 + 记忆 + 历史近 7 万 token 的前缀全部作废——实测每个
+        // 新回合命中率恒为 0，只有同回合内的工具迭代（prompt 不重建）才命中。
+        // 放到这里语义也更顺：它们本就是「此刻的事实」，紧挨当前消息说更自然。
+        const persona = this.caps.persona.present ? this.caps.persona.use : undefined;
+        const volatileCtx = persona?.getVolatilePrompt?.(personaOpts);
+        if (volatileCtx) {
+            messages.push({ role: 'system', content: volatileCtx, metadata: { injector: VOLATILE_INJECTOR } });
+        }
+        // 由排着的真人消息开的一轮：说明它们是上一轮进行期间到的；多方房间里全是没点名她的插话时，没有要接的可以不说话
+        if (turn.queued && turn.human)
+            messages.push(queuedNote(multiParty && !turn.batch.some(wasAddressed)));
+        // 群聊焦点指引：多方房间里有被点名的输入时，紧贴在这一轮的输入之前，逐条列出被点名的那几条
+        const focus = multiParty ? this.focusOf(inputs) : null;
+        if (focus)
+            messages.push(focus);
+        for (const input of inputs)
+            messages.push(await this.inputMessage(input, acceptsImages));
+        return { messages, historyMessages, history };
+    }
+    /**
+     * 一条输入发给模型的写法：`(时间) <归档正文>`。正文由 message-archive 烘焙（发送者前缀、引用回复、附件描述）；存档不在时
+     * 按同一份拼法与同一条说话人规则自己拼（schema-message 的 buildIncomingContent、api-message-archive 的 speakerOf）。时间取
+     * 归档时间戳，即进入这一轮的时刻：之后进历史时是同一个标注，前缀不变。带图的挂上它自己的图。空闲开话题的提示以 system 交出
+     */
+    async inputMessage({ message, archived }, acceptsImages) {
+        const body = archived?.content ?? buildIncomingContent(message, this.speakerOf(message));
+        const at = archived?.timestamp ?? Date.now();
+        const content = `(${formatTimeLabel(at, Date.now())}) ${body}`;
+        // 空闲提示是宿主写给模型的指令，不是谁的发言：标成本轮的指令块，锚位、裁剪与 DeepSeek 的 system 归位都按它认
+        if (message.triggerType === 'idle') {
+            return { role: 'system', content, metadata: { injector: WellKnownKinds.IdlePrompt } };
+        }
         const userMessage = {
             role: 'user',
-            content: currentContent,
-            name: getMessageName(incoming.userId),
-            timestamp: Date.now(),
+            content,
+            name: getMessageName(message.userId),
+            timestamp: at,
         };
         // 多模态：把 attachments 中的 image 项传递给 LLM（视觉模型多模态字段）
-        const imageAtts = incoming.attachments?.filter(a => a.kind === 'image') ?? [];
+        const imageAtts = message.attachments?.filter(a => a.kind === 'image') ?? [];
         if (imageAtts.length > 0) {
             if (this.caps.media.present) {
                 // media 在场：原样透传。出口形态由 media 的 agent:llm:before 中间件规范化
@@ -1295,13 +1269,11 @@ class DefaultAgent {
                 // 动图提示都按 attachment.data 原串命中，改形态会打散。
                 userMessage.images = imageAtts.map(a => a.data);
             }
-            else {
-                // media 缺席兜底：只翻译**已知会炸**的一种形态——适配器落盘产生的裸相对路径
-                //（provider 会把它当 base64 校验，整轮请求被拒，见
-                // test/plugins/media-model-images.test.ts 抬头的 400 事故）——经 storage 读出
-                // 转 data URI，保住「视觉主模型直通」的基础体验；翻译不了（storage 缺席/读失败）
-                // 就丢弃该图。其余一切形态（data:/http(s)/file:// 等）原样透传，与 media 出现
-                // 之前的行为一致，各 provider 按自己的解析器处置。
+            else if (acceptsImages) {
+                // media 缺席兜底（主模型不能看图时当轮的图不交，正文里的占位照旧）：存储地址（适配器落盘的附件引用）provider 解不了（当 base64 校验，整轮请求被拒，见
+                // test/plugins/media-model-images.test.ts 抬头的 400 事故），经 storage 读出转 data URI，保住「视觉主模型
+                // 直通」的基础体验；读不出（storage 缺席/读失败）就丢弃该图。其余形态（data URI、http(s)、file:// 等）原样
+                // 交给 provider，各按自己的解析器处置。
                 const images = [];
                 for (const a of imageAtts) {
                     const img = await this.materializeImageWithoutMedia(a.data, a.mimeType);
@@ -1314,23 +1286,31 @@ class DefaultAgent {
                     userMessage.images = images;
             }
         }
-        // 易变上下文（当前时间 / 会话环境 / 上一轮状态）落在历史**之后**：
-        // provider 的前缀缓存从第一个 token 起逐位比对，这几块原本混在人设卡开头，
-        // 秒级时间戳一变，人设 + 记忆 + 历史近 7 万 token 的前缀全部作废——实测每个
-        // 新回合命中率恒为 0，只有同回合内的工具迭代（prompt 不重建）才命中。
-        // 放到这里语义也更顺：它们本就是「此刻的事实」，紧挨当前消息说更自然。
-        const persona = this.caps.persona.present ? this.caps.persona.use : undefined;
-        const volatileCtx = persona?.getVolatilePrompt?.(personaOpts);
-        if (volatileCtx) {
-            messages.push({ role: 'system', content: volatileCtx, metadata: { injector: VOLATILE_INJECTOR } });
-        }
-        // 群聊焦点指引：仅 sessionType=group + triggerType ∈ {direct, immediate} 时注入，
-        // 紧贴在当前 user 消息前，告诉 LLM "下一条就是焦点"。详细动机见 helpers.ts。
-        const focusGuidance = buildFocusGuidance(incoming);
-        if (focusGuidance)
-            messages.push(focusGuidance);
-        messages.push(userMessage);
-        return { messages, historyMessages };
+        return userMessage;
+    }
+    /** 一条输入的说话人：与存档的发送者前缀同一条规则（api-message-archive 的 speakerOf） */
+    speakerOf(message) {
+        return speakerOf(message, {
+            sessionManager: this.caps.sessionManager.present ? this.caps.sessionManager.use : undefined,
+            authority: this.caps.authority.present ? this.caps.authority.use : undefined,
+        });
+    }
+    /** 停下标记里停下的人的称呼：与发送者前缀同一条规则，当他在这个会话里说了一句话；没有停下的人时没有 */
+    stopperLabel(sessionId, by) {
+        const speaker = by && this.speakerOf({ content: '', sessionId, platform: by.platform, userId: by.userId });
+        return getSenderLabel(speaker?.nickname, speaker?.userId);
+    }
+    /**
+     * 这一轮被点名的输入的焦点指引：按时间与发送者账号逐条列出（名字由各条正文的发送者前缀给，群友自己设的名字不进系统消息）；
+     * 没有被点名的为 null
+     */
+    focusOf(inputs) {
+        return buildFocusGuidance(inputs.flatMap(({ message, archived }) => {
+            if (!wasAddressed(message))
+                return [];
+            const time = formatTimeLabel(archived?.timestamp ?? Date.now(), Date.now());
+            return [message.userId ? `(${time}) ${message.userId}` : `(${time})`];
+        }));
     }
     /**
      * 裁剪预算 = 上下文长度 × trimThresholdRatio − 最大输出 token − 512 安全余量（下限 1024）。
@@ -1362,7 +1342,7 @@ class DefaultAgent {
      * 发 token:usage：各维度的拆分按消息与工具定义估算，used 取模型服务返回的输入 token，没有时取估算。
      * 等全部监听者处理完才返回：摘要插件在回合结束时按这一轮最后一条用量判定，不能让它晚于回合结束
      */
-    async emitTokenUsage({ sessionId, platform, turnId, contextWindow, maxTokens, tokenBudget, messages, tools, trimmed, untrimmedHistory, historyMessages, promptTokens, }) {
+    async emitTokenUsage({ sessionId, platform, turnId, contextWindow, maxTokens, tokenBudget, messages, tools, trimmed, untrimmedHistory, historyMessages, historyLimit, promptTokens, }) {
         // 按来源分类统计各消息的 token 占用
         let historyTokens = 0;
         let toolResultTokens = 0;
@@ -1461,6 +1441,7 @@ class DefaultAgent {
             trimmed,
             untrimmedHistory,
             historyMessages,
+            historyLimit,
             breakdown: {
                 system: systemTokens,
                 persona: personaTokens,
@@ -1477,16 +1458,16 @@ class DefaultAgent {
                 reservedForReply: maxTokens,
             },
             parts: [
-                { label: '历史消息', tokens: historyTokens },
-                { label: '工具结果', tokens: toolResultTokens },
-                { label: '工具定义', tokens: toolDefsTokens },
-                { label: '人设', tokens: personaTokens },
-                { label: '对话摘要', tokens: memorySummaryTokens },
-                { label: '向量记忆', tokens: memoryVectorTokens },
-                { label: '技能', tokens: skillsTokens },
-                { label: '平台提示', tokens: platformTokens },
-                { label: '子任务', tokens: subtaskTokens },
-                { label: '其余系统提示', tokens: systemOtherTokens, injectors: injectorTokens },
+                { label: t('partHistory'), tokens: historyTokens },
+                { label: t('partToolResults'), tokens: toolResultTokens },
+                { label: t('partToolDefs'), tokens: toolDefsTokens },
+                { label: t('partPersona'), tokens: personaTokens },
+                { label: t('partMemorySummary'), tokens: memorySummaryTokens },
+                { label: t('partMemoryVector'), tokens: memoryVectorTokens },
+                { label: t('partSkills'), tokens: skillsTokens },
+                { label: t('partPlatform'), tokens: platformTokens },
+                { label: t('partSubtask'), tokens: subtaskTokens },
+                { label: t('partSystemOther'), tokens: systemOtherTokens, injectors: injectorTokens },
             ],
         });
         // 节流日志：与 WebUI 看到的同一份数据，让 CLI / 文件日志使用者也能看见预算消耗。
@@ -1507,23 +1488,19 @@ class DefaultAgent {
     }
     /**
      * media 缺席时的图片物化兜底（仅 buildMessages 的 images 拷贝点使用）。
-     * 只翻译一种形态：适配器落盘产生的裸相对路径 `data/{kind}s/...`——它是已确证的
-     * 炸弹（provider 当 base64 校验 → 400 整轮被拒），经 storage 读出转 data URI；
-     * storage 缺席/读失败返回 null 由调用方丢弃该图。**其余一切形态原样透传**
-     *（data:/http(s)/file:// 等，各 provider 自行解析）——刻意不做更宽的判别：
-     * 透传即维持 media 出现之前的既有行为，改写范围只覆盖已知必炸的那一种。
+     * 只翻译存储地址（适配器落盘的附件引用）：provider 当 base64 校验 → 400 整轮被拒，经 storage 读出转 data URI；
+     * storage 缺席/读失败返回 null 由调用方丢弃该图。**其余形态原样交给 provider**（data URI、http(s)、file:// 等，各 provider
+     * 自行解析）。
      */
     async materializeImageWithoutMedia(data, mimeType) {
         const t = data.trim();
-        const rel = t.match(/^data\/((?:images|videos|audios|files)\/.+)$/);
-        if (!rel)
+        if (!isStorageUri(t))
             return t;
-        // storage 按 URI 的根名路由；缺 data 根（含 storage 整体缺席）时抛错，落到下面的 catch
+        // storage 按 URI 的根名路由；根不认识（含 storage 整体缺席）时抛错，落到下面的 catch
         const storage = this.caps.storage.use;
         try {
-            const raw = (await storage.readFile(`data:/${rel[1]}`));
-            // mime 优先取附件自带的 mimeType；缺省按 basename 扩展名推断（适配器落盘只产
-            // png/jpg/gif/webp 四种，见 attachment-cache 的 detectExtensionFromBuffer）
+            const raw = (await storage.readFile(t));
+            // mime 优先取附件自带的 mimeType；缺省按 basename 扩展名推断（适配器落盘的扩展名取文件头判定的格式）
             const base = t.slice(t.lastIndexOf('/') + 1);
             const dot = base.lastIndexOf('.');
             const ext = dot >= 0 ? base.slice(dot + 1).toLowerCase() : '';
@@ -1536,224 +1513,173 @@ class DefaultAgent {
         }
     }
     /**
-     * 裁剪消息列表，使总 token 数不超过预算；trimmed 报告入口估算超过了预算、进入了硬裁剪（不一定真裁掉了内容）。
-     * 不记日志：token:request 的快照同样走这里，删了消息的日志由真实回合的调用点记
+     * 硬裁剪这次要发出的列表，使估算回到预算内；trimmed 报告进入了硬裁剪：入口估算超过了预算（不一定真裁掉了内容），或历史超过
+     * 它的可用量、丢了一段。不记日志：token:request 的快照同样走这里，删了消息的日志由真实回合的调用点记。没改动的消息原样交出
+     * （同一个对象：首次调用的结果写回底稿之后，history 照样认得出历史），改动的换成副本。
      *
-     * 渐进式压缩策略（保证 agent 在长工具链中无限运行）：
-     *  1. 首条 system（主提示词）和末条消息永不删除
-     *  2. 缩减超出预留额度的 system 消息（长期记忆）
-     *  3. 截断过长的 tool 输出内容（保留头部关键信息）
-     *  4. 将最旧的 assistant+tool 组压缩为紧凑摘要（保留决策上下文）
-     *  5. 删除最旧的非 system 消息
-     *  6. 最后手段：删除 hook 注入的 system 消息
+     * 列表分三段：头部（第一条非 system 之前：人设、技能、摘要等；属于历史的 system 消息不算）、历史（history 里的消息对象，即
+     * 读出、清洗后发出的那段）、本轮（其余：易变块、本轮材料与提示、本轮的输入、本轮追加的工具调用与结果）。依次裁，第 1 步总做，
+     * 之后任一步回到预算内即停：
+     *  1. 历史按 token 成段丢：单位 U = ⌈预算 / 4⌉，历史可用 H = 预算 − 头部 − U（本轮固定留一个单位）；历史超过 H 时（不看本轮
+     *     多大）从第一条起丢到累计第一次达到 ⌈(历史 − H) / U⌉·U 的那一条，切点落在工具调用组中间时组里剩下的结果一起丢（对齐同
+     *     readHistory）。切点只由头部与历史定：头部两次压缩之间不变、历史只追加，切点只在历史跨过一个单位时前移，两次丢弃之间
+     *     发出的开头逐字不变，前缀缓存才命中
+     *  2. 只动本轮追加的：截短过长的工具结果、缩推理内容、把较早的工具调用组压成摘要。历史里的不动（会改开头），超了按第 1 步
+     *     整段丢
+     *  3. 本轮超过一个单位时仍超：历史接着按同一套单位往后丢，丢到累计第一次达到下一个单位整数倍的那一条（本轮在同一个单位内
+     *     变大时切点不动）或丢完；会改开头
+     *  4. 会改开头：注入的 system 块合计超过 memoryTokenBudget 时按比例缩，仍超时从最靠前的删起
+     *  5. 最后手段：最后一组工具调用也截短过长的结果、缩推理内容，请求不超窗发出
+     * 始终不动：首条 system、本轮的输入（user 消息，与宿主通知、委派、空闲开话题那一轮的指令块）。不删不压、只在第 5 步截短：
+     * 最后一组工具调用、末条消息（格式重试的反馈）
      */
-    trimMessages(messages, budget) {
-        const result = messages.map(m => ({ ...m }));
+    trimMessages(messages, budget, history) {
+        let result = [...messages];
         let estimated = this.estimateTokens(result);
-        if (estimated <= budget)
-            return { messages: result, trimmed: false };
-        /** 重新扫描 system 消息索引（首条和末条之间） */
-        const findSystemIndices = () => {
-            const indices = [];
-            for (let i = 1; i < result.length - 1; i++) {
-                if (result[i].role === 'system')
-                    indices.push(i);
-            }
-            return indices;
-        };
-        // === Phase 1: 缩减超出预留额度的 system 消息 ===
-        {
-            const sysIdx = findSystemIndices();
-            const sysTokens = sysIdx.reduce((s, i) => s + estimateMsgTokens(result[i]), 0);
-            if (sysTokens > this.memoryTokenBudget && sysIdx.length > 0) {
-                const ratio = this.memoryTokenBudget / sysTokens;
-                for (const idx of sysIdx) {
-                    const msg = result[idx];
-                    if (msg.content && msg.content.length > 200) {
-                        const oldTokens = estimateMsgTokens(msg);
-                        const targetLen = Math.max(200, Math.floor(msg.content.length * ratio));
-                        msg.content = truncateChars(msg.content, targetLen, '\n... [记忆内容已缩减]');
-                        estimated -= oldTokens - estimateMsgTokens(msg);
-                    }
-                }
-            }
-        }
-        if (estimated <= budget)
-            return { messages: result, trimmed: true };
-        // === Phase 2: 截断过长的 tool 输出 ===
-        for (let i = 1; i < result.length - 1; i++) {
-            if (estimated <= budget)
+        const over = estimated > budget;
+        const directive = (m) => DIRECTIVE_KINDS.includes(String(m.metadata?.injector));
+        // === 1. 历史按 token 成段丢 ===
+        const unit = Math.ceil(budget / 4);
+        /** 丢到不少于 tokens 的下一个单位整数倍 */
+        const onGrid = (tokens) => Math.ceil(tokens / unit) * unit;
+        let head = 0;
+        for (const m of result) {
+            if (m.role !== 'system')
                 break;
-            if (result[i].role === 'tool' && result[i].content && result[i].content.length > 1500) {
-                const oldTokens = estimateMsgTokens(result[i]);
-                result[i].content = truncateChars(result[i].content, 500, '\n... [工具输出已截断]');
-                estimated -= oldTokens - estimateMsgTokens(result[i]);
-            }
+            if (!history.has(m))
+                head += estimateMsgTokens(m);
         }
+        const past = result.filter(m => history.has(m));
+        let cut = 0;
+        let dropped = 0;
+        /** 从历史开头起丢到累计估算达到 tokens 的那一条（含）；切点落在工具调用组中间时，组里剩下的结果一起丢 */
+        const dropPast = (tokens) => {
+            const from = cut;
+            const before = dropped;
+            while (cut < past.length && dropped < tokens)
+                dropped += estimateMsgTokens(past[cut++]);
+            while (cut < past.length && past[cut].role === 'tool')
+                dropped += estimateMsgTokens(past[cut++]);
+            const gone = new Set(past.slice(from, cut));
+            result = result.filter(m => !gone.has(m));
+            estimated -= dropped - before;
+        };
+        const room = budget - head - unit;
+        const pastTokens = past.reduce((sum, m) => sum + estimateMsgTokens(m), 0);
+        if (pastTokens > room)
+            dropPast(onGrid(pastTokens - room));
         if (estimated <= budget)
-            return { messages: result, trimmed: true };
-        // === Phase 2.5: 缩减 assistant 消息的 reasoningContent ===
-        // 深度思考模型的推理内容可能非常长（数万 token），优先缩减旧迭代的推理，
-        // 仍超预算时缩减最新一条（保留头尾摘要以保持上下文连贯性）
-        {
-            // 收集带 reasoningContent 的 assistant 消息索引（从旧到新）
-            const rcIndices = [];
-            for (let i = 1; i < result.length; i++) {
-                if (result[i].role === 'assistant' && result[i].reasoningContent && result[i].reasoningContent.length > 200) {
-                    rcIndices.push(i);
-                }
+            return { messages: result, trimmed: over || cut > 0 };
+        // === 2. 只动本轮追加的，最后一组工具调用（本轮最后一条带调用的 assistant 与紧跟的结果）不动 ===
+        const last = new Set();
+        for (let i = result.length - 1; i >= 0; i--) {
+            if (history.has(result[i]) || !result[i].toolCalls?.length)
+                continue;
+            for (let j = i; j < result.length && (j === i || result[j].role === 'tool'); j++)
+                last.add(result[j]);
+            break;
+        }
+        const appended = (m) => !history.has(m) && !last.has(m);
+        /** 截短 pick 选中的过长工具结果（1500 字以上的留 500） */
+        const shortenResults = (pick) => {
+            for (let i = 0; i < result.length && estimated > budget; i++) {
+                const m = result[i];
+                if (m.role !== 'tool' || !pick(m) || !m.content || m.content.length <= 1500)
+                    continue;
+                const shorter = { ...m, content: truncateChars(m.content, 500, '\n... [工具输出已截断]') };
+                estimated -= estimateMsgTokens(m) - estimateMsgTokens(shorter);
+                result[i] = shorter;
             }
-            // 从最旧开始，先截断非最后一条的推理，仍不够时截断最后一条
-            // 注意：DeepSeek 思考模式要求历史中凡有 reasoning_content 的消息必须原样带回，
-            // 不能将字段设为 undefined，否则 API 返回 400。因此只截断，不删除。
-            for (let k = 0; k < rcIndices.length && estimated > budget; k++) {
-                const idx = rcIndices[k];
-                const msg = result[idx];
-                const oldTokens = estimateMsgTokens(msg);
-                // 所有条目统一保留头部 200 字符（最新条保留稍多以保持上下文连贯性）
-                const keepLen = k < rcIndices.length - 1 ? 200 : 400;
-                msg.reasoningContent = truncateChars(msg.reasoningContent, keepLen, '\n... [推理内容已缩减]');
-                estimated -= oldTokens - estimateMsgTokens(msg);
+        };
+        /**
+         * 缩 pick 选中的推理内容：从旧到新，旧的留 200 字，最新一条留 400。DeepSeek 思考模式要求历史中凡有 reasoning_content 的消息
+         * 原样带回这个字段，设成 undefined 会被拒（400），所以只截断、不删除
+         */
+        const shrinkReasoning = (pick) => {
+            const reasoned = result.flatMap((m, i) => m.role === 'assistant' && pick(m) && (m.reasoningContent?.length ?? 0) > 200 ? [i] : []);
+            for (let k = 0; k < reasoned.length && estimated > budget; k++) {
+                const m = result[reasoned[k]];
+                const keep = k < reasoned.length - 1 ? 200 : 400;
+                const shorter = {
+                    ...m,
+                    reasoningContent: truncateChars(m.reasoningContent ?? '', keep, '\n... [推理内容已缩减]'),
+                };
+                estimated -= estimateMsgTokens(m) - estimateMsgTokens(shorter);
+                result[reasoned[k]] = shorter;
+            }
+        };
+        shortenResults(appended);
+        shrinkReasoning(appended);
+        // 较早的工具调用组从最旧的起压成一条摘要（确实省 token 时）
+        for (let i = 0; i < result.length && estimated > budget; i++) {
+            const call = result[i];
+            if (call.role !== 'assistant' || !call.toolCalls?.length || !appended(call))
+                continue;
+            let end = i + 1;
+            while (end < result.length && result[end].role === 'tool')
+                end++;
+            const outputs = result.slice(i + 1, end);
+            const before = [call, ...outputs].reduce((sum, m) => sum + estimateMsgTokens(m), 0);
+            const previews = outputs.map(({ content }) => {
+                const output = content ?? '';
+                return output.length > 100 ? `${output.slice(0, 100)}...` : output;
+            });
+            const parts = call.toolCalls.map((tc, idx) => `${tc.function.name} → ${previews[idx] ?? '(无结果)'}`);
+            const text = `[历史工具调用] ${parts.join(' | ')}`;
+            const summary = { role: 'assistant', content: call.content ? `${call.content}\n${text}` : text };
+            const after = estimateMsgTokens(summary);
+            if (after < before) {
+                result.splice(i, end - i, summary);
+                estimated -= before - after;
             }
         }
         if (estimated <= budget)
             return { messages: result, trimmed: true };
-        // === Phase 3: 将旧的 assistant+tool 组压缩为摘要 ===
-        // 识别所有工具调用组 (assistant(toolCalls) + 紧跟的 tool 消息)
-        {
-            const groups = [];
-            for (let j = 1; j < result.length; j++) {
-                if (result[j].role === 'assistant' && result[j].toolCalls?.length) {
-                    let end = j + 1;
-                    while (end < result.length && result[end].role === 'tool')
-                        end++;
-                    groups.push({ start: j, end });
-                    j = end - 1;
-                }
-            }
-            // 从最旧开始压缩，保护最后一组（当前工具链需要完整结果）
-            let offset = 0;
-            for (let g = 0; g < groups.length - 1 && estimated > budget; g++) {
-                const start = groups[g].start - offset;
-                const end = groups[g].end - offset;
-                const groupLen = end - start;
-                // 计算当前组的 token
-                let groupTokens = 0;
-                const toolPreviews = [];
-                for (let j = start; j < end; j++) {
-                    groupTokens += estimateMsgTokens(result[j]);
-                    if (result[j].role === 'tool') {
-                        const c = result[j].content ?? '';
-                        toolPreviews.push(c.length > 100 ? `${c.slice(0, 100)}...` : c);
-                    }
-                }
-                // 构建紧凑摘要
-                const aMsg = result[start];
-                const names = aMsg.toolCalls.map(tc => tc.function.name);
-                const parts = names.map((n, idx) => `${n} → ${toolPreviews[idx] ?? '(无结果)'}`);
-                let text = `[历史工具调用] ${parts.join(' | ')}`;
-                if (aMsg.content)
-                    text = `${aMsg.content}\n${text}`;
-                const summaryMsg = { role: 'assistant', content: text };
-                const summaryTokens = estimateMsgTokens(summaryMsg);
-                // 仅在确实能节省 token 时压缩
-                if (summaryTokens < groupTokens) {
-                    result.splice(start, groupLen, summaryMsg);
-                    estimated -= groupTokens - summaryTokens;
-                    offset += groupLen - 1;
-                }
-            }
-        }
+        // === 3. 本轮超过一个单位：历史接着按单位丢 ===
+        dropPast(onGrid(dropped + estimated - budget));
         if (estimated <= budget)
             return { messages: result, trimmed: true };
-        // === Phase 4: 删除最旧的非 system 消息（保护最后一组工具调用 + 最新用户消息） ===
-        {
-            // 识别最后一组工具调用的索引范围，确保不被删除
-            const lastGroupIndices = new Set();
-            for (let j = result.length - 1; j >= 1; j--) {
-                if (result[j].role === 'assistant' && result[j].toolCalls?.length) {
-                    lastGroupIndices.add(j);
-                    let k = j + 1;
-                    while (k < result.length && result[k].role === 'tool') {
-                        lastGroupIndices.add(k);
-                        k++;
-                    }
-                    break;
-                }
-            }
-            // 保护最新的 user 消息（用户发起任务的请求，删掉会导致模型丢失任务上下文）
-            let lastUserIdx = -1;
-            for (let j = result.length - 1; j >= 1; j--) {
-                if (result[j].role === 'user') {
-                    lastUserIdx = j;
-                    break;
-                }
-            }
-            const adjustAfterSplice = (splicedAt) => {
-                const updated = new Set();
-                for (const idx of lastGroupIndices)
-                    updated.add(idx > splicedAt ? idx - 1 : idx);
-                lastGroupIndices.clear();
-                for (const idx of updated)
-                    lastGroupIndices.add(idx);
-                if (lastUserIdx > splicedAt)
-                    lastUserIdx--;
-            };
-            let i = 1;
-            while (estimated > budget && i < result.length - 1) {
-                if (result[i].role === 'system' || lastGroupIndices.has(i) || i === lastUserIdx) {
-                    i++;
+        // === 4. 注入的 system 块：首条与末条之间、不是本轮指令块的 ===
+        const injected = () => result.flatMap((m, i) => (i > 0 && i < result.length - 1 && m.role === 'system' && !directive(m) ? [i] : []));
+        const total = injected().reduce((sum, i) => sum + estimateMsgTokens(result[i]), 0);
+        if (total > this.memoryTokenBudget) {
+            const ratio = this.memoryTokenBudget / total;
+            for (const i of injected()) {
+                const m = result[i];
+                if (!m.content || m.content.length <= 200)
                     continue;
-                }
-                // assistant(含toolCalls) + 紧跟的 tool 消息成组删除
-                if (result[i].role === 'assistant' && result[i].toolCalls?.length) {
-                    estimated -= estimateMsgTokens(result[i]);
-                    result.splice(i, 1);
-                    adjustAfterSplice(i);
-                    while (i < result.length - 1 && result[i].role === 'tool') {
-                        if (lastGroupIndices.has(i))
-                            break;
-                        estimated -= estimateMsgTokens(result[i]);
-                        result.splice(i, 1);
-                        adjustAfterSplice(i);
-                    }
-                    continue;
-                }
-                estimated -= estimateMsgTokens(result[i]);
-                result.splice(i, 1);
-                adjustAfterSplice(i);
+                const targetLen = Math.max(200, Math.floor(m.content.length * ratio));
+                const shorter = { ...m, content: truncateChars(m.content, targetLen, '\n... [记忆内容已缩减]') };
+                estimated -= estimateMsgTokens(m) - estimateMsgTokens(shorter);
+                result[i] = shorter;
             }
         }
-        if (estimated <= budget)
-            return { messages: result, trimmed: true };
-        // === Phase 5: 极端情况 — 删除 hook 注入的 system 消息 ===
-        // 从最靠前的块开始删。turn-context 迁移后头部只剩技能正文/会话摘要、
-        // 档案/记忆类材料都在尾部——正序扫描意味着极端裁剪时**先牺牲头部稳定块**、
-        // 可再生的尾部材料反而最后动，与理想优先级相反。维持正序是刻意取舍：
-        // 本相位是罕见的最后手段，且反转方向会先删掉紧邻当前消息的当轮提示
-        // （focus/平台事件说明），代价更直观；按 injector 分级则是为极端路径
-        // 引入一张需要长期维护的优先级表。真在生产观察到本相位高频触发时再议。
-        {
-            const sysIdx = findSystemIndices();
-            let removed = 0;
-            for (let j = 0; j < sysIdx.length && estimated > budget; j++) {
-                const idx = sysIdx[j] - removed;
-                estimated -= estimateMsgTokens(result[idx]);
-                result.splice(idx, 1);
-                removed++;
-            }
+        // 仍超时从最靠前的块删起。头部只有技能正文/会话摘要、档案/记忆类材料都在尾部——正序扫描意味着极端
+        // 裁剪时**先牺牲头部稳定块**、可再生的尾部材料反而最后动，与理想优先级相反。维持正序是刻意取舍：这是罕见的最后手段，且
+        // 反转方向会先删掉紧邻当前消息的当轮提示（focus/平台事件说明），代价更直观；按 injector 分级则是为极端路径引入一张需要
+        // 长期维护的优先级表。
+        let removed = 0;
+        for (const i of injected()) {
+            if (estimated <= budget)
+                break;
+            estimated -= estimateMsgTokens(result[i - removed]);
+            result.splice(i - removed, 1);
+            removed++;
         }
-        // 大幅裁剪后注入继续执行提示，防止模型因上下文缺失而中止任务
+        // === 5. 最后一组也截短过长的结果、缩推理内容 ===
+        const inLast = (m) => last.has(m);
+        shortenResults(inLast);
+        shrinkReasoning(inLast);
+        // 大幅裁剪后注入继续执行提示，防止模型因上下文缺失而中止任务：放在本轮最后一条输入之后，没有输入（快照）时放在末尾
         if (messages.length - result.length >= 6) {
             const hint = {
                 role: 'system',
                 content: '[系统提示] 由于上下文长度限制，部分历史消息已被压缩或移除。请基于当前可见的上下文和最新用户请求继续完成任务，不要因为看不到之前的细节而停止工作。如果你之前有正在执行的多步骤任务或计划，请查看对话摘要和 todo-list 工具确认当前进度，然后继续未完成的步骤。',
                 metadata: { injector: 'system-other' },
             };
-            // 插入到最后一条 user 消息之后（如果有），否则插到末尾前
-            let insertIdx = result.length - 1;
-            for (let j = result.length - 1; j >= 1; j--) {
-                if (result[j].role === 'user') {
+            let insertIdx = result.length;
+            for (let j = result.length - 1; j >= 0; j--) {
+                if (!history.has(result[j]) && (result[j].role === 'user' || directive(result[j]))) {
                     insertIdx = j + 1;
                     break;
                 }
@@ -1778,13 +1704,18 @@ class DefaultAgent {
                 await archive.saveMessage(sessionId, message);
             }
             catch (err) {
-                this.logger.warn('保存消息到记忆失败:', err);
+                this.logger.warn(`保存消息到记忆失败 (session=${sessionId}):`, err);
             }
         }
     }
-    /** 这一轮落库的 assistant 消息的元数据；带 turnId，会话的客户端据此把存档归回它所在的回合 */
+    /**
+     * 这一轮落库的 assistant 消息的元数据；带 turnId，会话的客户端据此把存档归回它所在的回合。自身账号随窗口：子会话没有
+     * 窗口，取根会话的
+     */
     buildAssistantMetadata(incoming, turnId) {
-        const identity = getPlatformSelfIdentity(this.caps.platform, incoming.platform, incoming.sessionId);
+        const sm = this.caps.sessionManager.present ? this.caps.sessionManager.use : undefined;
+        const root = sm && rootSessionOf(sm.getSession(incoming.sessionId), id => sm.getSession(id));
+        const identity = getPlatformSelfIdentity(this.caps.platform, incoming.platform, root?.id ?? incoming.sessionId);
         const metadata = {
             [WellKnownMetadataKeys.Platform]: incoming.platform,
             senderType: 'assistant',
@@ -1802,84 +1733,67 @@ class DefaultAgent {
             metadata[WellKnownMetadataKeys.SessionType] = incoming.sessionType;
         return Object.keys(metadata).length > 0 ? metadata : undefined;
     }
-    async saveToolCallGroup(sessionId, assistantMessage, toolMessages, persistedTimestamps) {
+    async saveToolCallGroup(sessionId, assistantMessage, toolMessages) {
         const timestamp = Date.now();
         await this.saveToMemory(sessionId, { ...assistantMessage, timestamp });
-        persistedTimestamps?.push(timestamp);
         for (let i = 0; i < toolMessages.length; i++) {
-            const ts = timestamp + i + 1;
             // 工具交出的图只服务本回合的主模型（data URI 体积大、历史回看也不再需要它），不落库
             const { images: _transient, ...persisted } = toolMessages[i];
-            await this.saveToMemory(sessionId, { ...persisted, timestamp: ts });
-            persistedTimestamps?.push(ts);
+            await this.saveToMemory(sessionId, { ...persisted, timestamp: timestamp + i + 1 });
         }
     }
-    sanitizeToolCallHistory(history, sessionId) {
-        const result = [];
-        let dropped = 0;
-        for (let i = 0; i < history.length; i++) {
-            const message = history[i];
-            if (message.role === 'tool') {
-                dropped++;
+    /**
+     * 交给模型的会话历史，真实回合与 token:request 的快照共用：按条数线读出的那一段（见 readHistory）清洗工具调用组，跳过控制类
+     * 与 skip 里的各条，用户消息加时间标注，她的回复取可见正文（historyForModel）。改动都在副本上：记忆服务可能直接交出存着的
+     * 消息对象。count 同 readHistory，dropped 是清洗跳过的条数；没有记忆服务时为空。不记日志：快照同样走这里，跳过的条数由真实
+     * 回合的调用点记
+     */
+    async modelHistory(sessionId, historyLimit, skip = []) {
+        if (!this.caps.memory.present)
+            return { messages: [], count: 0, dropped: 0 };
+        const stored = await readHistory(this.caps.memory.use, sessionId, historyLimit);
+        const { kept, dropped } = this.sanitizeToolCallHistory(stored.messages);
+        const now = Date.now();
+        const messages = [];
+        for (const m of kept) {
+            if (skip.some(input => isSameMessage(m, input)))
                 continue;
-            }
-            if (message.role === 'assistant' && message.toolCalls?.length) {
-                const expectedIds = new Set(message.toolCalls.map(tc => tc.id));
-                const seenIds = new Set();
-                const tools = [];
-                let j = i + 1;
-                while (j < history.length && history[j].role === 'tool') {
-                    const toolMessage = history[j];
-                    const id = toolMessage.toolCallId;
-                    if (!id || !expectedIds.has(id) || seenIds.has(id))
-                        break;
-                    tools.push(toolMessage);
-                    seenIds.add(id);
-                    j++;
-                }
-                if (seenIds.size === expectedIds.size) {
-                    result.push(message, ...tools);
-                }
-                else {
-                    dropped += 1 + tools.length;
-                }
-                i = j - 1;
+            if (CONTROL_KINDS.includes(m.kind ?? ''))
                 continue;
+            // 为用户消息注入时间标注，帮助 LLM 理解时间先后
+            if (m.role === 'user' && m.timestamp && m.content) {
+                const timeLabel = formatTimeLabel(m.timestamp, now);
+                if (timeLabel && !m.content.startsWith(`(${timeLabel})`)) {
+                    messages.push({ ...m, content: `(${timeLabel}) ${m.content}` });
+                    continue;
+                }
             }
-            result.push(message);
+            messages.push(historyForModel(m));
         }
-        if (dropped > 0) {
-            this.logger.warn(`历史消息中发现不完整工具调用组，已跳过 ${dropped} 条 (session=${sessionId})`);
-        }
-        return result;
-    }
-    isSameMessage(a, b) {
-        return isSameMessage(a, b);
+        return { messages, count: stored.count, dropped };
     }
-    async archiveIncomingMessageInOrder(lane, incoming) {
-        const previous = this.archiveQueues.get(lane) ?? Promise.resolve();
-        const current = previous.catch(() => undefined).then(() => this.archiveIncomingMessage(incoming));
-        const tail = current.then(() => undefined, () => undefined);
-        this.archiveQueues.set(lane, tail);
-        try {
-            return await current;
-        }
-        finally {
-            if (this.archiveQueues.get(lane) === tail) {
-                this.archiveQueues.delete(lane);
-            }
+    /**
+     * 装载历史时清洗工具调用组：按 schema-message 的 groupToolCalls 归组（夹进调用与结果之间的别的消息挪到组后），结果不齐的组
+     * 连同找到的结果跳过，不在任何组里的结果跳过。dropped 是跳过的条数
+     */
+    sanitizeToolCallHistory(history) {
+        const kept = [];
+        let dropped = 0;
+        for (const { at, shape } of groupToolCalls(history)) {
+            if (shape === 'partial' || shape === 'loose')
+                dropped += at.length;
+            else
+                kept.push(...at.map(i => history[i]));
         }
+        return { kept, dropped };
     }
-    async archiveIncomingMessage(incoming) {
-        // 跳过非真实用户输入：闲聊主动触发是系统提示，不应作为 user 消息写入历史
-        if (incoming.source === 'idle-trigger')
-            return undefined;
+    /** 归档一条输入：进了一轮的带回合 id 与进入方式（开轮 opened，插进来 joined），放掉的不带 */
+    async archiveIncomingMessage(message, turn) {
         const archive = this.getArchiveForWrite();
         if (!archive)
             return undefined;
         try {
-            const result = await archive.archiveIncoming(incoming);
-            return result.message;
+            return (await archive.archiveIncoming(message, turn))?.message;
         }
         catch (err) {
             this.logger.warn('归档用户消息失败:', err);
@@ -1912,198 +1826,106 @@ class DefaultAgent {
 const configSchema = defineConfig({
     systemPrompt: {
         type: 'textarea',
-        label: '行为准则提示词',
-        description: '定义 Agent 的行为准则。当人设插件存在时，身份描述由人设提供，此处仅作为行为指令追加。',
+        label: t('systemPromptLabel'),
+        description: t('systemPromptDescription'),
         default: '',
     },
     memoryTokenBudget: {
         type: 'number',
-        label: '长期记忆预留 Token',
+        label: t('memoryTokenBudgetLabel'),
         default: 4096,
         secret: false,
-        description: '为注入的 system 消息预留的 token 额度：超出时先按比例缩减，极端情况下（最后阶段）仍会删除',
+        description: t('memoryTokenBudgetDescription'),
     },
     promptBuildTimeoutMs: {
         type: 'number',
-        label: '提示词贡献构建超时 (ms)',
+        label: t('promptBuildTimeoutMsLabel'),
         default: 10000,
-        description: '单个 agent:prompt 贡献 build 的等待上限。挂死的构建（如网络检索卡住）超时后本轮缺席、其余照常，避免拖住每次 LLM 调用。0 表示不设限。',
+        description: t('promptBuildTimeoutMsDescription'),
     },
     toolResultMaxRatio: {
         type: 'number',
-        label: '工具结果最大比例',
+        label: t('toolResultMaxRatioLabel'),
         default: 0.15,
-        description: '单条工具结果占上下文窗口的最大比例 (0~1)，超出则截断。例如 0.15 表示 15%',
+        description: t('toolResultMaxRatioDescription'),
     },
     trimThresholdRatio: {
         type: 'number',
-        label: '裁剪触发比例',
+        label: t('trimThresholdRatioLabel'),
         default: 1.0,
-        description: '裁剪预算 = 上下文长度 × 该比例 − 最大输出 token − 512 安全余量（下限 1024）。本次调用估算输入 token 超过该预算才会对消息列表做内存裁剪（不影响 DB）。默认 1.0 表示用满扣除输出预留后的可用窗口；调低可提前裁剪。压缩触发在会话设置里调：自动压缩线（摘要插件登记）与历史条数上限（本插件登记）。',
+        description: t('trimThresholdRatioDescription'),
     },
-});
-/**
- * 本插件登记的会话设置项：模型（输入框旁的快捷切换）、深度思考、工具迭代上限与历史条数上限，各种会话都适用。模型的全局
- * 默认层就是 llm 服务的偏好（会话管理按字段类型承担），界面写服务实际用的那一个
- */
-const SESSION_SETTINGS = [
-    {
-        key: 'llm',
-        field: {
-            type: 'llm-ref',
-            label: '模型',
-            description: '没设置时用默认模型：给本插件设了 llm 的服务偏好时用它，否则是全局默认层的「模型」，那里也没设时用第一个可用的对话模型',
-        },
-        appliesTo: ['owner', 'room', 'task'],
-        prominence: 'composer',
-        // 会话选的是一个具体的模型：服务与模型都要给
-        validate: value => {
-            const ref = value;
-            return typeof ref?.provider === 'string' &&
-                ref.provider !== '' &&
-                typeof ref.model === 'string' &&
-                ref.model !== ''
-                ? undefined
-                : '要是 { provider, model }，两项都是非空字符串';
-        },
+    // ----- 按会话字段：各层可覆盖，每一轮按会话读 -----
+    llm: {
+        type: 'llm-ref',
+        label: t('llmLabel'),
+        description: t('llmDescription'),
+        ...MODEL_REF_TEXT,
+        // 全局层不在插件配置里：是本插件的 llm 偏好
+        session: { prominence: 'composer', preference: 'llm', unset: t('llmUnset'), minLevel: 1 },
     },
-    {
-        key: 'think',
-        field: {
-            type: 'select',
-            label: '深度思考',
-            dynamicOptions: 'llm-thinking',
-            description: '可选的档位随所用的模型；没设置或当前模型没有这一档时按模型的默认档',
-        },
+    think: {
+        type: 'select',
+        label: t('thinkLabel'),
+        description: t('thinkDescription'),
         // 可选项是「模型」这一项生效的那个模型声明的档位
-        dependsOn: 'llm',
-        appliesTo: ['owner', 'room', 'task'],
-        prominence: 'common',
-        order: 20,
-        validate: value => (typeof value === 'string' && value !== '' ? undefined : '要是档位 id（非空字符串）'),
+        dynamicOptions: 'llm-thinking',
+        session: { prominence: 'common', order: 20, dependsOn: 'llm', unset: t('thinkUnset'), minLevel: 1 },
     },
-    {
-        key: 'maxToolIterations',
-        field: {
-            type: 'number',
-            label: '最大工具迭代',
-            integer: true,
-            min: 1,
-            default: MAX_TOOL_ITERATIONS,
-            description: '一轮里工具调用循环的最大次数',
-        },
-        appliesTo: ['owner', 'room', 'task'],
-        prominence: 'advanced',
+    maxToolIterations: {
+        type: 'number',
+        label: t('maxToolIterationsLabel'),
+        description: t('maxToolIterationsDescription'),
+        integer: true,
+        min: 1,
+        session: { prominence: 'advanced', unset: t('maxToolIterationsUnset') },
     },
-    {
-        key: 'historyLimit',
-        field: {
-            type: 'number',
-            label: '历史条数上限',
-            integer: true,
-            min: 0,
-            default: 0,
-            description: '一轮最多读进这么多条会话历史；装了摘要插件时，会话的消息到这个条数就压缩。0 表示不按条数：读全部活跃历史，只按自动压缩线压缩',
-        },
-        appliesTo: ['owner', 'room', 'task'],
-        prominence: 'advanced',
-        // 子会话按自己的继承链实时解析，不冻结父会话当时的值
-        liveOnly: true,
+    historyLimit: {
+        type: 'number',
+        label: t('historyLimitLabel'),
+        description: t('historyLimitDescription'),
+        integer: true,
+        min: 0,
+        default: 0,
+        session: { prominence: 'advanced' },
     },
-];
+});
 function run(caps) {
     const cfg = parseConfig(configSchema, caps.config.use, caps.logger.use);
-    for (const setting of SESSION_SETTINGS)
-        caps.sessionManager.use.registerSetting(setting);
     const agentImpl = new DefaultAgent(caps, cfg, caps.lifecycle.use.id);
     caps.provide.use(agentService, agentImpl);
-    // 收尾段中止在飞回合并等 AbortError 落定。
-    // 第一方栈由 core 关停编排（optional 环成员先全部 drain）与 agent:turn:after 收口；
+    // 收尾段停下全部在跑的一轮、放掉排着的（归档；按 core 的关停编排 agent 关完之前存档还在），等它们以 AbortError 收尾落定；
+    // 之后到的输入一律放掉。第一方栈由 core 关停编排（optional 环成员先全部 drain）与 agent:turn:after 收口；
     // session-manager 的 onDrain 兜的是未装 agent 或钩子未挂上的路径。
     // 超时沿用 core 对 onDrain 的 disposeTimeoutMs，不另加配置键。
-    caps.lifecycle.use.onDrain(() => agentImpl.abortInflightAndSettle(), '中止在飞回合');
-    // 清理段再 abort 一次：drain 超时或未走到收尾时的兜底，表空则空操作。
-    caps.lifecycle.use.onDispose(() => agentImpl.abortAll(), '中止在飞回合（兜底）');
-    // 会话删除：丢弃该会话的 token 日志节流状态（与 todo-list / file-reader 走同一条会话清理路径）
-    caps.events.use.on('session:deleted', sessionId => agentImpl.dropTokenLogState(sessionId));
+    caps.lifecycle.use.onDrain(() => agentImpl.queues.shutdown(), '停下在跑的回合');
+    // 清理段再停一次：drain 超时或未走到收尾时的兜底，不再等落定；已停下的是空操作。
+    caps.lifecycle.use.onDispose(() => void agentImpl.queues.shutdown(), '停下在跑的回合（兜底）');
+    // 会话删除：停下这个会话（见 sessionDeleted）
+    caps.events.use.on('session:deleted', sessionId => agentImpl.sessionDeleted(sessionId));
     const agent = agentImpl;
-    // ===== 会话级配置指令 =====
-    // /session 查（模型+人设+名+来源） · /session.set 改 · /session.reset 复位 · /model 列可用模型
-    // 与"会话"相关的模型改写统一收敛到 /session.*；/model 只保留全局的"列可用模型"发现。
-    /** 会话设置存在会话管理里：它没在运行时三条会话指令都回这一句 */
-    const NO_SESSION_MANAGER = '会话管理没有在运行，会话设置要靠它：在 WebUI 插件区启用「会话管理」，' +
-        '或把它从配置文件的 disabledPlugins 里删掉；启用了还起不来就用 /doctor 看原因';
-    /**
-     * 继承值的来源：层表里这一层的称呼，平台档、平台类型档与场所另写这个会话取的是哪一份（「平台档 onebot」
-     * 「平台类型档 onebot · group」「场所『<显示名>』」）；哪一层都没设时为「默认」
-     */
-    function sourceName(smSvc, sessionId, inheritance, layer) {
-        if (layer === undefined)
-            return '默认';
-        const label = SESSION_LAYERS.find(({ name }) => name === layer).label;
-        if (layer === 'platform')
-            return `${label} ${inheritance.platform}`;
-        if (layer === 'type')
-            return `${label} ${inheritance.platform} · ${inheritance.type}`;
-        if (layer !== 'place')
-            return label;
-        const { key } = smSvc.placeOf(sessionId);
-        return `${label}『${smSvc.getPlace(key)?.name ?? key}』`;
-    }
-    function resolutionLines(smSvc, sessionId, platform, label, key, pick) {
-        const inheritance = smSvc.resolveInheritance(sessionId, platform);
-        const inherited = pick(inheritance.values);
-        const from = sourceName(smSvc, sessionId, inheritance, inheritance.sources[key]);
-        const own = pick(smSvc.getOwnConfig(sessionId));
-        if (own == null)
-            return [`${label}: ${inherited ?? '(默认)'}  [来源: ${from}]`];
-        return [`${label}: ${own}  [来源: 会话覆盖]`, `  被覆盖的继承值: ${inherited ?? '(默认)'}  [来源: ${from}]`];
-    }
-    const fmtModel = (c) => (c?.llm ? `${c.llm.provider}/${c.llm.model}` : undefined);
-    const fmtPersona = (c) => c?.persona;
-    const fmtThink = (c) => c?.think;
-    /**
-     * /session 模型那一行之后：这一轮实际会用的模型与显示的生效值不同时写出来（哪一层都没设、偏好也没有时，或偏好指向的
-     * 模型不在时，服务落到别的模型上）
-     */
-    async function modelNote(smSvc, sessionId, platform) {
-        const actual = (await agent.resolveLLM(platform, sessionId))?.id;
-        const shown = fmtModel(smSvc.getOwnConfig(sessionId)) ?? fmtModel(smSvc.resolveInheritance(sessionId, platform).values);
-        return actual && actual !== shown ? `  这一轮会用: ${actual}` : '';
-    }
-    /** 模型的档位写成一句：id（名字），由浅到深 */
-    const levelList = (thinking) => thinking.levels.map(({ id, label }) => `${id}（${label}）`).join('、');
-    /** /session 深度思考那一行之后：这一轮会用的模型的档位与默认档，生效的档位它没有时写明按默认 */
-    async function thinkingNote(sessionId, platform) {
-        const thinking = (await agent.resolveLLM(platform, sessionId))?.use.thinking;
-        if (!thinking)
-            return '  当前模型不能调';
-        const level = caps.sessionManager.present
-            ? caps.sessionManager.use.resolveConfig(sessionId, platform).think
-            : undefined;
-        const missing = level !== undefined && !thinking.levels.some(({ id }) => id === level);
-        return `  当前模型的档位：${levelList(thinking)}，默认 ${thinking.default}${missing ? '；当前模型没有这一档，按默认' : ''}`;
-    }
+    // /model 列可用模型、/persona 列可用人设；会话设置的查看与修改是会话设置插件的 /session 系列
     // 分页渲染 helper：限制每页 PAGE_SIZE 条 + 关键词过滤 + 翻页提示（/model 与 /persona 共用）。
     const PAGE_SIZE = 20;
-    function renderPaged(all, keyword, page, label, cmd) {
+    function renderPaged(all, keyword, page, label, command) {
         const kw = keyword.trim().toLowerCase();
         const list = kw ? all.filter(x => x.toLowerCase().includes(kw)) : all;
         if (list.length === 0)
-            return kw ? `无匹配 "${keyword}" 的${label}` : `(无可用${label})`;
+            return kw ? t('pagedNoMatch', { keyword, label }) : t('pagedNone', { label });
         const pages = Math.max(1, Math.ceil(list.length / PAGE_SIZE));
         const p = Math.min(Math.max(1, Math.trunc(page) || 1), pages);
         const body = list.slice((p - 1) * PAGE_SIZE, p * PAGE_SIZE).map(x => `- ${x}`);
-        const lines = [`${label}（${kw ? `含"${keyword}" ` : ''}共 ${list.length} · 第 ${p}/${pages} 页）:`, ...body];
+        const counts = { label, count: list.length, page: p, pages };
+        const lines = [kw ? t('pagedHeaderMatching', { ...counts, keyword }) : t('pagedHeader', counts), ...body];
         if (pages > 1) {
             const next = p < pages ? p + 1 : 1;
-            lines.push(`—— 翻页: ${cmd}${kw ? ` ${keyword}` : ''} -p ${next}${kw ? '' : `　搜索: ${cmd} <关键词>`}`);
+            lines.push(kw ? t('pagedHintMatching', { command, keyword, next }) : t('pagedHint', { command, next }));
         }
-        return lines.join('\n');
+        return textLines(lines);
     }
     caps.commands.use
-        .command('model [keyword:string]', '列出/搜索可用对话模型。分页显示，-p 翻页；如 /model grok')
-        .option('page', '-p <n:number>', { description: '页码（默认 1）' })
+        .command('model [keyword:string]', t('modelDescription'))
+        .option('page', '-p <n:number>', { description: t('pageOptionDescription') })
         .action(async (argv, keyword) => {
         const seen = new Set();
         const ids = [];
@@ -2114,156 +1936,31 @@ function run(caps) {
             ids.push(e.id);
         }
         const page = typeof argv.options.page === 'number' ? argv.options.page : 1;
-        return renderPaged(ids, String(keyword ?? ''), page, '可用模型', '/model');
+        return renderPaged(ids, String(keyword ?? ''), page, t('modelsLabel'), '/model');
     });
     caps.commands.use
-        .command('persona [keyword:string]', '列出/搜索可用人设（分页，-p 翻页）')
-        .option('page', '-p <n:number>', { description: '页码（默认 1）' })
+        .command('persona [keyword:string]', t('personaDescription'))
+        .option('page', '-p <n:number>', { description: t('pageOptionDescription') })
         .action(async (argv, keyword) => {
         const persona = caps.persona.present ? caps.persona.use : undefined;
         const names = persona?.listModels ? await persona.listModels() : [];
         const page = typeof argv.options.page === 'number' ? argv.options.page : 1;
-        return renderPaged(names, String(keyword ?? ''), page, '可用人设', '/persona');
-    });
-    // ---- 会话级「模型 + 人设 + 深度思考 + 名称」配置（onebot 等平台对话直接改当前对话生效） ----
-    caps.commands.use
-        .command('session', '查看当前对话生效的设定及来源。设定指模型、人设、深度思考与名称', { risk: 'sensitive' })
-        .action(async (argv) => {
-        if (!caps.sessionManager.present)
-            return NO_SESSION_MANAGER;
-        const smSvc = caps.sessionManager.use;
-        const sid = argv.session.sessionId;
-        const session = smSvc.getSession(sid);
-        return [
-            `会话: ${session?.name ?? sid}`,
-            ...resolutionLines(smSvc, sid, argv.session.platform, '模型', 'llm', fmtModel),
-            await modelNote(smSvc, sid, argv.session.platform),
-            ...resolutionLines(smSvc, sid, argv.session.platform, '人设', 'persona', fmtPersona),
-            ...resolutionLines(smSvc, sid, argv.session.platform, '深度思考', 'think', fmtThink),
-            await thinkingNote(sid, argv.session.platform),
-            session ? '' : '（本对话尚无独立配置记录，全部继承默认）',
-            '────',
-            '改配置: /session.set -m <模型> -p <人设> -t <档位> [-n <名>]   （/model 看可用模型/人设名错时也会列出）',
-            '复位:   /session.reset          （-m 仅模型 / -p 仅人设 / -t 仅深度思考）',
-        ]
-            .filter(Boolean)
-            .join('\n');
-    });
-    caps.commands.use
-        .command('session.set', '设定当前对话的模型、人设、深度思考或显示名。会话级覆盖，持久化，重启不丢', {
-        risk: 'sensitive',
-        examples: [
-            '/session.set -m @aalis/plugin-llm-openai:main/gpt-4o -p catgirl',
-            '/session.set -p strict-reviewer',
-            '/session.set -t off',
-            '/session.set -n 深夜助手',
-        ],
-    })
-        .option('model', '-m <ref:string>', { description: '模型 provider/model（LLM entry 的 contextId；/model 可列出）' })
-        .option('persona', '-p <name:string>', { description: '人设卡名（不含后缀）' })
-        .option('think', '-t <level:string>', {
-        description: '深度思考的档位 id，按当前模型的档位（/session 列出；会话级覆盖，/session.reset 后回落默认）',
-    })
-        .option('name', '-n <label:string>', { description: '会话显示名（可选）' })
-        .action(async (argv) => {
-        if (!caps.sessionManager.present)
-            return NO_SESSION_MANAGER;
-        const smSvc = caps.sessionManager.use;
-        const modelRef = typeof argv.options.model === 'string' ? argv.options.model.trim() : '';
-        const personaName = typeof argv.options.persona === 'string' ? argv.options.persona.trim() : '';
-        const level = typeof argv.options.think === 'string' ? argv.options.think.trim() : '';
-        const displayName = typeof argv.options.name === 'string' ? argv.options.name.trim() : '';
-        if (!modelRef && !personaName && !level && !displayName) {
-            return '至少给一项。敲 /session.set -h 看用法';
-        }
-        const config = {};
-        // 模型：校验存在再落，避免错名静默回退默认
-        let chosen;
-        if (modelRef) {
-            const lastSlash = modelRef.lastIndexOf('/');
-            if (lastSlash <= 0 || lastSlash === modelRef.length - 1) {
-                return '模型格式错误。请用 `provider/model`，例如 `@aalis/plugin-llm-openai:main/gpt-4o`';
-            }
-            const chatModels = listLLMModels(caps.llm, { caps: ['chat'] });
-            chosen = chatModels.find(e => e.id === modelRef);
-            if (!chosen) {
-                return `未知模型 "${modelRef}"。用 /model <关键词> 搜索（如 /model grok），共 ${chatModels.length} 个可用。`;
-            }
-            config.llm = { provider: modelRef.slice(0, lastSlash), model: modelRef.slice(lastSlash + 1) };
-        }
-        // 深度思考：按这一轮会用的模型（同时改了模型时按新模型）的档位校验
-        if (level) {
-            const thinking = (chosen ?? (await agent.resolveLLM(argv.session.platform, argv.session.sessionId)))?.use
-                .thinking;
-            if (!thinking)
-                return '当前模型不能调深度思考';
-            if (!thinking.levels.some(({ id }) => id === level)) {
-                return `当前模型没有档位「${level}」，可选：${levelList(thinking)}`;
-            }
-            config.think = level;
-        }
-        // 人设：人设插件不在时这一项没有登记，session-manager 拒绝写入
-        if (personaName) {
-            const persona = caps.persona.present ? caps.persona.use : undefined;
-            if (persona?.listModels) {
-                const names = await persona.listModels();
-                if (!names.includes(personaName)) {
-                    return `未知人设 "${personaName}"。用 /persona 查看可用人设（共 ${names.length} 个）。`;
-                }
-            }
-            config.persona = personaName;
-        }
-        await smSvc.ensureSession(argv.session.sessionId, { config, ...(displayName ? { name: displayName } : {}) });
-        const lines = ['本对话已切换 →'];
-        if (config.llm)
-            lines.push(`· 模型: ${config.llm.provider}/${config.llm.model}`);
-        if (config.persona)
-            lines.push(`· 人设: ${config.persona}`);
-        if (config.think)
-            lines.push(`· 深度思考: ${config.think}`);
-        if (displayName)
-            lines.push(`· 名称: ${displayName}`);
-        lines.push('后续消息持续生效（已持久化，重启不丢）。/session.reset 可复位。');
-        return lines.join('\n');
+        return renderPaged(names, String(keyword ?? ''), page, t('personasLabel'), '/persona');
     });
-    caps.commands.use
-        .command('session.reset', '复位当前对话的会话级覆盖。默认清模型、人设与深度思考，-m/-p/-t 单独清对应项', {
-        risk: 'sensitive',
-        examples: ['/session.reset', '/session.reset -m', '/session.reset -p', '/session.reset -t'],
-    })
-        .option('model', '-m', { description: '仅复位模型覆盖' })
-        .option('persona', '-p', { description: '仅复位人设覆盖' })
-        .option('think', '-t', { description: '仅复位深度思考覆盖' })
-        .action(async (argv) => {
-        if (!caps.sessionManager.present)
-            return NO_SESSION_MANAGER;
-        const smSvc = caps.sessionManager.use;
-        const mFlag = argv.options.model === true;
-        const pFlag = argv.options.persona === true;
-        const tFlag = argv.options.think === true;
-        // 都不给 = 全清；给了任意 flag = 只清点名的那些
-        const noFlags = !mFlag && !pFlag && !tFlag;
-        const clearModel = mFlag || noFlags;
-        const clearPersona = pFlag || noFlags;
-        const clearThink = tFlag || noFlags;
-        const sid = argv.session.sessionId;
-        const session = smSvc.getSession(sid);
-        const willClear = (clearModel && session?.config?.llm) ||
-            (clearPersona && session?.config?.persona) ||
-            (clearThink && session?.config?.think != null);
-        if (willClear) {
-            // null 删掉这一项，回到继承链
-            const patch = {};
-            if (clearModel)
-                patch.llm = null;
-            if (clearPersona)
-                patch.persona = null;
-            if (clearThink)
-                patch.think = null;
-            await smSvc.updateSession(sid, { config: patch });
-        }
-        const eff = smSvc.resolveConfig(sid, argv.session.platform);
-        return `已复位 → 模型: ${eff.llm ? `${eff.llm.provider}/${eff.llm.model}` : '(默认)'}，人设: ${eff.persona ?? '(默认)'}，深度思考: ${eff.think ?? '(默认)'}`;
+    // /stop 同停止键：只停本会话在跑的一轮，排着的照常开下一轮。不看等级：发出者是这一轮的参与者（进了这一轮的各条输入按
+    // originTurnOf 算：真人的话是发言者，续做与子任务是起它的那一轮的参与者，定时任务与编排是它的授权身份），或是 owner；排队与
+    // 待插入的不算，没有账号的不算任何人
+    caps.commands.use.command('stop', t('stopDescription'), { risk: 'safe' }).action(({ session }) => {
+        const { sessionId, platform, userId } = session;
+        const inputs = agentImpl.queues.inputs(sessionId);
+        if (!inputs)
+            return t('stopIdle');
+        const { participants } = originTurnOf(inputs, agentImpl.isOwner);
+        const inTurn = Boolean(userId) && participants.some(who => who.platform === platform && who.userId === userId);
+        if (!inTurn && !agentImpl.isOwner(platform, userId))
+            return t('stopDenied');
+        agentImpl.abort(sessionId, { reason: '/stop', ...(userId ? { by: { platform, userId } } : {}) });
+        return t('stopped');
     });
     // 监听 token:request 事件 — 客户端刷新/重连时主动请求 token 用量
     caps.events.use.on('token:request', async (data) => {
@@ -2276,42 +1973,41 @@ function run(caps) {
         const origin = sm && rootSessionOf(sm.getSession(data.sessionId), id => sm.getSession(id))?.originPlatform;
         const platform = data.platform ?? origin ?? 'webui';
         try {
-            const resolved = await agent.resolveLLM(platform, data.sessionId);
+            // 与真实回合同一份会话读法：模型、条数线；人设覆盖、结构化输出开关、额外提示由人设服务按会话读，都影响系统提示长度
+            const settings = agent.fields.get(data.sessionId, { platform });
+            const resolved = agent.resolveLLM(settings.llm);
             if (!resolved)
                 return;
             const llm = resolved.use;
             const contextLength = llm.contextLength;
             const maxTokens = getModelMaxOutput(llm);
             const tokenBudget = agent.computeTokenBudget(contextLength, maxTokens);
-            // 与真实回合同一份会话解析：人设覆盖、结构化输出开关、额外提示都影响系统提示长度
-            const sessionResolved = sm ? sm.resolveConfig(data.sessionId, platform) : undefined;
-            // 获取历史消息并构建基础消息列表
-            const memory = caps.memory.present ? caps.memory.use : undefined;
+            // 构建基础消息列表
             const messages = [];
             // 系统提示
-            const systemPrompt = agent.buildSystemPrompt(toPersonaOptions(sessionResolved));
+            const systemPrompt = agent.buildSystemPrompt({ sessionId: data.sessionId, platform });
             messages.push({ role: 'system', content: systemPrompt, metadata: { injector: 'persona' } });
-            // 历史消息：与真实回合同样按会话的条数线读
-            const history = memory ? await memory.getHistory(data.sessionId, sessionResolved?.historyLimit || Infinity) : [];
-            messages.push(...history.filter(m => !CONTROL_KINDS.includes(m.kind ?? '')));
+            // 历史消息：与真实回合同一个读法
+            const history = await agent.modelHistory(data.sessionId, settings.historyLimit);
+            messages.push(...history.messages);
             // 与真实回合同序：先组装 agent:prompt 贡献（摘要/向量记忆/档案等物化为 system 块），
             // 再跑 agent:llm:before（工具搜索层过滤等拦截职责），使快照贴近实际送入 LLM 的形态
-            const enabledGroups = sessionResolved?.enabledToolGroups?.length ? sessionResolved.enabledToolGroups : undefined;
             const tools = caps.tools.present
-                ? caps.tools.use.getDefinitions(enabledGroups ? { groups: enabledGroups } : undefined)
+                ? caps.tools.use.getDefinitions({ groups: caps.tools.use.sessionGroups(data.sessionId, platform) })
                 : [];
             const llmBeforeData = {
                 messages,
                 tools,
+                acceptsImages: llm.capabilities.includes(LLMCapabilities.Vision),
                 sessionId: data.sessionId,
-                userId: '',
                 platform,
                 dryRun: true, // 纯统计路径:昂贵注入者(向量检索/档案加载)据此跳过副作用
             };
-            await assemblePromptContributions(caps, llmBeforeData, { buildTimeoutMs: agent.promptBuildTimeoutMs });
+            // 不在回合里：没有输入，各贡献按没有输入处理
+            await assemblePromptContributions(caps, llmBeforeData, [], { buildTimeoutMs: agent.promptBuildTimeoutMs });
             await caps.hooks.use.run('agent:llm:before', llmBeforeData, undefined, { warnOnStall: true });
             // 与真实回合同样过硬裁剪，拆分按裁剪之后的消息算
-            const sent = agent.trimMessages(llmBeforeData.messages, tokenBudget);
+            const sent = agent.trimMessages(llmBeforeData.messages, tokenBudget, new Set(history.messages));
             await agent.emitTokenUsage({
                 sessionId: data.sessionId,
                 platform,
@@ -2322,7 +2018,8 @@ function run(caps) {
                 tools: llmBeforeData.tools,
                 trimmed: sent.trimmed,
                 untrimmedHistory: estimateHistoryTokens(llmBeforeData.messages),
-                historyMessages: history.length,
+                historyMessages: history.count,
+                historyLimit: settings.historyLimit,
             });
         }
         catch (err) {
@@ -2332,7 +2029,7 @@ function run(caps) {
 }
 export default definePlugin({
     name: '@aalis/plugin-agent',
-    displayName: '默认 Agent',
+    displayName: t('displayName'),
     subsystem: 'agent',
     configSchema,
     provides: [agentService],