@aalis/plugin-agent 0.15.2 → 0.16.0

package/dist/index.js

@@ -10,14 +10,14 @@ import { memory as memoryService } from '@aalis/api-memory';
 import { messageArchive as messageArchiveService } from '@aalis/api-message-archive';
 import { persona as personaService } from '@aalis/api-persona';
 import { getPlatformSelfIdentity, platform as platformService } from '@aalis/api-platform';
-import { sessionManager as sessionManagerService } from '@aalis/api-session-manager';
-import { createStorageGateway, storage as storageService } from '@aalis/api-storage';
+import { rootSessionOf, SESSION_LAYERS, sessionManager as sessionManagerService, } from '@aalis/api-session-manager';
+import { 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, estimateMsgTokens, estimateTextTokens, estimateTokens, formatTimeLabel, formatToolArgsForLog, INPUT_CONVENTIONS, isSameMessage, toPersonaOptions, } from './helpers.js';
+import { buildFocusGuidance, describeLLMFailure, estimateHistoryTokens, estimateMsgTokens, estimateTextTokens, estimateTokens, formatTimeLabel, formatToolArgsForLog, INPUT_CONVENTIONS, isSameMessage, parseToolArguments, toPersonaOptions, } from './helpers.js';
 import { assemblePromptContributions, VOLATILE_INJECTOR } from './prompt-assembly.js';
 // ===== 能力声明 =====
 //
@@ -32,7 +32,6 @@ const uses = {
     contributions,
     lifecycle,
     provide,
-    services,
     commands: optional(commandsService),
     tools: optional(toolsService),
     llm: optional(llmService),
@@ -45,6 +44,8 @@ const uses = {
     storage: optional(storageService),
     gateway: optional(gatewayService),
     plugins: optional(pluginsService),
+    /** 会话没设模型时比对本插件该生效的 llm 偏好与实际用的模型 */
+    services,
 };
 /**
  * 默认 Agent 实现 —— 对话编排器
@@ -61,16 +62,19 @@ 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;
 }
 class DefaultAgent {
+    instanceId;
     caps;
     logger;
     systemPrompt;
     memoryTokenBudget;
-    historyLimit;
-    maxToolIterations;
     /** 单个 agent:prompt 贡献 build 的等待上限（毫秒；0=不设限）——见 prompt-assembly 的护栏说明 */
     promptBuildTimeoutMs;
     /** 单条工具结果占上下文窗口的最大比例 (0~1)，超出则截断 */
@@ -78,12 +82,17 @@ class DefaultAgent {
     /** 内存裁剪触发比例 (0~1)：估算输入 token 占 contextLength 的比例上限，超过则触发本次调用的内存裁剪 */
     trimThresholdRatio;
     /**
-     * 活跃 AbortController 表
+     * 在飞回合表：lane → 这一轮的 AbortController 与 turnId
      *
-     * key = `${sessionId}::${source}` — 同一 session 不同来源（user / scheduler）
+     * lane = `${sessionId}::${source}` — 同一 session 不同来源（user / scheduler）
      * 独立管理，互不打断；同来源新消息会中止旧的生成。
      */
     activeControllers = new Map();
+    /**
+     * 延续某位发言者身份的宿主通知回合（lane → 会话与 hostNotice.callerUserId）。那位发言者在同一会话发来的真人消息
+     * 中止这些回合；别人的消息与不延续任何人身份的通知（白纸等）不受影响，宿主通知也从不打断别的回合。
+     */
+    noticeCallers = new Map();
     /**
      * 在飞回合 Promise。关停时 abort 之后等它们以 AbortError（或正常完成）收尾，
      * 而不是等 LLM 跑完——收尾里的钩子 / 出站事件还要用 memory。
@@ -100,15 +109,18 @@ class DefaultAgent {
      * 与 token:usage 事件共用同一份 breakdown 数据，零额外计算。
      */
     tokenLogState = new Map();
+    /** 已告警过的（llm 服务的偏好，实际用的模型）组合 */
+    preferenceFallbacks = new Set();
     /** 已注册的预处理器（name → { dispose }） */
     preprocessors = new Map();
-    constructor(caps, cfg) {
+    constructor(caps, cfg, 
+    /** 本插件实例 id：读它的本插件偏好 */
+    instanceId) {
+        this.instanceId = instanceId;
         this.caps = caps;
-        this.logger = caps.logger.child('agent');
+        this.logger = caps.logger.use.child('agent');
         this.systemPrompt = cfg.systemPrompt;
         this.memoryTokenBudget = cfg.memoryTokenBudget;
-        this.historyLimit = cfg.historyLimit;
-        this.maxToolIterations = cfg.maxToolIterations;
         this.promptBuildTimeoutMs = cfg.promptBuildTimeoutMs;
         this.toolResultMaxRatio = cfg.toolResultMaxRatio;
         this.trimThresholdRatio = cfg.trimThresholdRatio;
@@ -117,38 +129,43 @@ class DefaultAgent {
     /**
      * 根据优先级链解析当前会话该用哪个 LLMModel entry。
      *
-     * 全部交给 session-manager.resolveConfig。优先级（从高到低）：
-     * 1. 会话 config
-     * 2. 父会话 sessionDefaults
-     * 3. 平台 profile
-     * 4. ServicePreference（由 agent 启动时锁定的全局默认 entry，未传 ref 时生效）
+     * 会话设置的 llm 交给 session-manager.resolveConfig 解析（按层表叠加，全局默认层即 llm 服务的偏好）；
+     * 全局默认之上哪一层都没设时不给值，由 resolveLLMModel 落到本插件此刻选中的那一个（本插件偏好 > 全局偏好 > 提供者优先级 >
+     * 登记先后）。这时该生效的偏好（设了本插件偏好就是它，否则是全局偏好）指向的模型不在（模型删了、提供者在重载或激活失败），
+     * 服务落到别的模型上：照常用它，每个（偏好，实际）组合告警一次。
      *
-     * 返回 LLMModelEntry（含 instance / contextId / capabilities），entry 已绑定具体 model。
+     * 返回 llm 的提供者条目（id 与这一家的业务句柄 use），条目固定那一个模型。
      */
     async resolveLLM(platform, sessionId) {
-        let ref;
-        // session-manager 一步到位：会话 > 父 sessionDefaults > platform profile
-        const sm = this.caps.sessionManager.current;
-        if (sm && sessionId) {
-            const resolved = sm.resolveConfig(sessionId, platform);
-            if (resolved.llm?.provider && resolved.llm?.model)
-                ref = resolved.llm;
-        }
+        const sm = this.caps.sessionManager.present ? this.caps.sessionManager.use : undefined;
+        const ref = sm && sessionId ? sm.resolveConfig(sessionId, platform).llm : undefined;
         // 解析为具体 LLMModel entry（要求至少 chat 能力；ref 为空时走 ServicePreference / 优先级）
-        return resolveLLMModel(this.caps.llm, ref, ['chat']);
+        const entry = resolveLLMModel(this.caps.llm, ref, ['chat']);
+        if (ref || !entry)
+            return entry;
+        const own = this.caps.services.use.preferred(llmService, { for: this.instanceId });
+        const preferred = own ?? this.caps.services.use.preferred(llmService);
+        if (preferred !== undefined && entry.id !== preferred) {
+            const combo = `${preferred}\n${entry.id}`;
+            if (!this.preferenceFallbacks.has(combo)) {
+                this.preferenceFallbacks.add(combo);
+                this.logger.warn(`llm 服务的${own === undefined ? '' : '本插件'}偏好 ${preferred} 没有生效（指向的模型不在、提供者在重载或激活失败），实际用的是 ${entry.id}`);
+            }
+        }
+        return entry;
     }
     /** 解析失败时说清**为什么**（取数在此，措辞在 helpers 的 describeLLMFailure，纯函数便于单测）。 */
     explainLLMFailure(platform, sessionId) {
-        const available = listLLMModels(this.caps.llm, { caps: ['chat'] }).map(e => e.contextId);
-        const sm = this.caps.sessionManager.current;
+        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());
     }
     /** 激活失败且声明提供 llm 的插件实例名——「一个模型都没有」时，病因通常就在它们身上（多为缺 apiKey）。 */
     erroredLLMPlugins() {
-        const pm = this.caps.plugins.current;
-        if (!pm)
+        if (!this.caps.plugins.present)
             return [];
+        const pm = this.caps.plugins.use;
         // 只取实例名：这串会拼进**发到聊天**（含群聊）的文案里，error 原文可能带内网地址与端口等部署细节，
         // 原因留在日志、WebUI 与 /doctor
         return pm
@@ -160,16 +177,20 @@ class DefaultAgent {
         return `${sessionId}::${source ?? 'user'}`;
     }
     /**
-     * 中止指定会话的当前生成（所有 lane）
+     * 中止指定会话的在飞回合：不带 turnId 时停所有 lane，带 turnId 时只停那一轮。返回是否停下了回合。
      */
-    abort(sessionId) {
-        for (const [key, controller] of this.activeControllers) {
-            if (key.startsWith(`${sessionId}::`)) {
-                controller.abort();
-                this.activeControllers.delete(key);
-            }
+    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;
         }
-        this.logger.info(`生成已中止: session=${sessionId}`);
+        if (aborted)
+            this.logger.info(`生成已中止: session=${sessionId}${turnId ? ` turn=${turnId}` : ''}`);
+        return aborted;
     }
     /**
      * 中止全部在飞回合（拆卸路径用）。
@@ -181,8 +202,8 @@ class DefaultAgent {
      */
     abortAll() {
         let n = 0;
-        for (const [key, controller] of this.activeControllers) {
-            controller.abort();
+        for (const [key, turn] of this.activeControllers) {
+            turn.controller.abort();
             this.activeControllers.delete(key);
             n++;
         }
@@ -213,7 +234,7 @@ class DefaultAgent {
     registerPreprocessor(name, handler) {
         // 同名替换
         this.preprocessors.get(name)?.dispose();
-        const dispose = this.caps.hooks.middleware('agent:input:before', async (data, next) => {
+        const dispose = this.caps.hooks.use.middleware('agent:input:before', async (data, next) => {
             await handler(data.message, next);
         });
         // 退订按条目引用比对：同名重注册后，旧退订闭包只摘自己的中间件，不动新登记的账目
@@ -243,9 +264,9 @@ class DefaultAgent {
      * （平台属于独立子系统，由 api-platform 的 helper 负责）。
      */
     getPluginGroups() {
-        const pm = this.caps.plugins.current;
-        if (!pm)
+        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 = [];
@@ -261,8 +282,12 @@ class DefaultAgent {
      *
      * 同时构建本轮调用的 segments 时间线（按 chunk 到达顺序记录 text / reasoning_text，
      * 相邻同类合并）——用于上层将多轮调用 + 工具执行交错拼接成统一时间线。
+     *
+     * 工具调用的生成进度按调用的序号各配一个 callId 随进度推出，界面在参数生成期间就画出它的工具卡。generating 按序号
+     * 记下 callId 与工具名（provider 按序号组装 toolCalls，序号即调用在 toolCalls 里的位置）；没报过进度的调用没有。
      */
-    async consumeStream(llm, request, sessionId, platform) {
+    async consumeStream(llm, request, turnId, sessionId, platform, emitProgress = true) {
+        const generating = new Map();
         let content = '';
         let reasoningContent = '';
         let toolCalls;
@@ -277,7 +302,7 @@ class DefaultAgent {
                 segments.push({ type: kind, content: delta });
             }
         };
-        for await (const chunk of llm.chatStream(request)) {
+        for await (const chunk of llm.chatStream({ ...request, sessionId, purpose: this.purposeOf(sessionId) })) {
             // 检查中止信号
             if (request.signal?.aborted) {
                 throw new DOMException('Generation aborted', 'AbortError');
@@ -285,26 +310,34 @@ class DefaultAgent {
             if (chunk.contentDelta) {
                 content += chunk.contentDelta;
                 appendDelta('text', chunk.contentDelta);
-                await this.caps.events.emit('outbound:stream', {
-                    sessionId,
-                    platform,
-                    contentDelta: chunk.contentDelta,
-                });
+                if (emitProgress)
+                    await this.caps.events.use.emit('outbound:stream', {
+                        sessionId,
+                        turnId,
+                        platform,
+                        contentDelta: chunk.contentDelta,
+                    });
             }
             if (chunk.reasoningDelta) {
                 reasoningContent += chunk.reasoningDelta;
                 appendDelta('reasoning_text', chunk.reasoningDelta);
-                await this.caps.events.emit('outbound:stream', {
-                    sessionId,
-                    platform,
-                    reasoningDelta: chunk.reasoningDelta,
-                });
+                if (emitProgress)
+                    await this.caps.events.use.emit('outbound:stream', {
+                        sessionId,
+                        turnId,
+                        platform,
+                        reasoningDelta: chunk.reasoningDelta,
+                    });
             }
-            if (chunk.toolCallProgress) {
-                await this.caps.events.emit('outbound:stream', {
+            if (emitProgress && chunk.toolCallProgress) {
+                const { index, name } = chunk.toolCallProgress;
+                const callId = generating.get(index)?.callId ?? crypto.randomUUID();
+                generating.set(index, { callId, name });
+                await this.caps.events.use.emit('outbound:stream', {
                     sessionId,
+                    turnId,
                     platform,
-                    toolCallProgress: chunk.toolCallProgress,
+                    toolCallProgress: { ...chunk.toolCallProgress, callId },
                 });
             }
             if (chunk.done) {
@@ -319,7 +352,7 @@ class DefaultAgent {
             // 兜底剥离 LLM 端漏出的特殊 token 残渣（DSML 等），同时修复 GFM 表格
             const { sanitized, hadLeak } = stripLeakedSpecialTokens(content);
             if (hadLeak) {
-                this.caps.logger.warn(`agent: 检测到 LLM 内容残留 DSML 标记，已剥离（session=${sessionId} platform=${platform} 原长=${content.length} 净化后=${sanitized.length}）`);
+                this.caps.logger.use.warn(`agent: 检测到 LLM 内容残留 DSML 标记，已剥离（session=${sessionId} platform=${platform} 原长=${content.length} 净化后=${sanitized.length}）`);
             }
             finalContent = normalizeAssistantContent(content);
         }
@@ -329,8 +362,16 @@ class DefaultAgent {
             toolCalls,
             usage,
             segments,
+            generating,
         };
     }
+    /** 记账的用途：子会话里的回合是子任务，其余是对话 */
+    purposeOf(sessionId) {
+        return (this.caps.sessionManager.present ? this.caps.sessionManager.use.getSession(sessionId)?.kind : undefined) ===
+            'task'
+            ? '子任务'
+            : '对话';
+    }
     /**
      * Debug 模式下格式化输出 LLM 响应详情
      */
@@ -439,18 +480,34 @@ class DefaultAgent {
         // 仅中止同一 lane（同 session + 同 source）的旧生成；不同来源互不打断
         const prev = this.activeControllers.get(lane);
         if (prev)
-            prev.abort();
+            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 controller = new AbortController();
-        this.activeControllers.set(lane, controller);
+        // 回合 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 });
+        }
         const turn = (async () => {
             try {
-                await this._handleMessageInner(incoming, controller.signal, lane);
+                await this._handleMessageInner(incoming, controller.signal, lane, turnId);
             }
             finally {
                 // 仅清理自己创建的 controller（避免清掉后续新请求的）
-                if (this.activeControllers.get(lane) === 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);
@@ -461,33 +518,47 @@ class DefaultAgent {
             this.inflightTurns.delete(turn);
         }
     }
-    async _handleMessageInner(incoming, signal, lane) {
+    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.run('agent:input:before', msgHookData, async () => {
+        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}`);
-                await this.dispatchOutbound({
-                    content: `[系统] ${why}`,
+                if (!reportOnly) {
+                    await this.dispatchOutbound({
+                        content: `[系统] ${why}`,
+                        sessionId: incoming.sessionId,
+                        platform: incoming.platform,
+                        source: 'system',
+                    });
+                }
+                await this.caps.hooks.use.run('agent:turn:after', {
+                    message: incoming,
+                    reply: '',
+                    outcome: signal.aborted ? 'aborted' : 'error',
+                    ...(signal.aborted ? {} : { error: why }),
                     sessionId: incoming.sessionId,
-                    platform: incoming.platform,
-                    source: 'system',
+                    turnId,
+                    metadata: msgHookData.metadata,
                 });
                 return;
             }
-            const llm = resolved.instance;
+            const llm = resolved.use;
             // 从 LLM model entry 读取参数。contextLength / maxOutputTokens 均为 per-model 属性，
             // service-granularity 后不再需要 router.getContextLengthFor() 反查，也不再会出现
             // 默认 provider 全局窗口与会话实际 model 不一致的偏差（Bug F 结构性修复）。
@@ -499,35 +570,42 @@ class DefaultAgent {
             const turnPersistedTimestamps = [];
             try {
                 // 统一解析 session 配置（一次解析，多处复用）
-                const sessionMgr = this.caps.sessionManager.current;
+                const sessionMgr = this.caps.sessionManager.present ? this.caps.sessionManager.use : undefined;
                 const resolved = sessionMgr && incoming.sessionId
                     ? sessionMgr.resolveConfig(incoming.sessionId, incoming.platform)
                     : undefined;
-                // 会话级 maxToolIterations 覆盖（WebUI 会话页可编辑）：正整数才生效，其余视为未设置、回落全局配置
-                const sessionMaxIter = resolved?.maxToolIterations;
-                const maxToolIterations = typeof sessionMaxIter === 'number' && Number.isInteger(sessionMaxIter) && sessionMaxIter >= 1
-                    ? sessionMaxIter
-                    : this.maxToolIterations;
+                // 会话设置的 maxToolIterations 按登记的字段解析过（正整数），没设置时用默认值
+                const maxToolIterations = resolved?.maxToolIterations ?? MAX_TOOL_ITERATIONS;
                 // 构建 persona 会话选项（从 resolved config 中提取，传给 persona 服务）
                 const personaOpts = toPersonaOptions(resolved);
-                // 会话级 thinking 覆盖（/session.set -t on|off）：未设置则不带 think 字段，
-                // 由各 provider 按自己的全局配置决定（ollama thinking / deepseek thinkingMode）。
-                const thinkOverride = resolved?.think;
-                const messages = await this.buildMessages(incoming, personaOpts, archivedIncoming);
+                // 会话的深度思考档位：当前模型有这一档才带上；没设置、模型没有这一档或不能调时不带，由模型服务按它的默认档
+                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 = this.caps.tools.current?.getDefinitions(enabledGroups ? { groups: enabledGroups } : undefined) ?? [];
+                const tools = reportOnly
+                    ? []
+                    : this.caps.tools.present
+                        ? this.caps.tools.use.getDefinitions(enabledGroups ? { groups: enabledGroups } : undefined)
+                        : [];
                 const toolCtx = {
                     sessionId: incoming.sessionId,
-                    // platform/userId 保持**会话/物理**语义（定时任务归属、平台档继承、记忆平台域、
-                    // confirm 选路都靠它们）；授权身份单独走 actor——authority 守卫按 actor 查等级，
-                    // scheduler/delegate/subtask 等触发的 AI 因此以创建者等级执行而非匿名。
-                    // 不可再用 actor 覆盖 platform：跨平台委派会把上述四类下游全路由到发起者平台。
-                    userId: incoming.userId,
+                    // 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,
                     // 恒为数组：平台档没配分组时给 []（列举面本就等价于「只给无分组工具」），
@@ -535,8 +613,17 @@ class DefaultAgent {
                     enabledGroups: enabledGroups ?? [],
                     // 本循环会把 ToolExecutionResult.images 挂到 tool 消息交给主模型（出口由 prepareLLMMessages 编码）
                     acceptsImages: true,
-                    // 回合中止信号：等确认期间被 latest-wins / 手动 abort 掐掉的工具不再执行
+                    // 回合中止信号：等 owner 审批期间被 latest-wins / 手动 abort 掐掉的工具不再执行
                     signal,
+                    // 本回合的入站来源：只有这里填写，工具据此正向区分真人消息（source 缺省）与内部注入；
+                    // 延续某次调用的宿主通知另带那次调用的发言者，执行守卫据此认出 owner 链的延续；
+                    // 入站消息的平台消息 id 供转到后台的调用结束时，通知的回复引用它
+                    inbound: {
+                        source: incoming.source,
+                        callerUserId: incoming.hostNotice?.callerUserId,
+                        messageId: incoming.messageId,
+                    },
+                    turnId,
                 };
                 // 保存原始完整工具列表，后续迭代均以此为基础（避免被 hooks 修改后丢失）
                 const originalTools = [...tools];
@@ -548,27 +635,70 @@ class DefaultAgent {
                     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.run('agent:llm:before', llmBeforeData, undefined, { warnOnStall: true });
-                // 裁剪消息以确保不超过上下文窗口
-                llmBeforeData.messages = this.trimMessages(llmBeforeData.messages, tokenBudget);
-                // 推送 token 使用量统计
-                this.emitTokenUsage(incoming.sessionId, incoming.platform, llmBeforeData.messages, llmBeforeData.tools, contextLength, maxTokens, tokenBudget);
+                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 },
+                    });
+                }
+                /** 本回合到目前为止经过了硬裁剪：首次调用的裁剪结果写回底稿，之后各次调用都在它上面追加 */
+                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,
+                });
                 this.logger.debug(`LLM 请求: ${llmBeforeData.messages.length} 条消息, ` +
                     `${llmBeforeData.tools.length} 个工具, ` +
                     `maxTokens=${maxTokens}`);
                 const t0 = Date.now();
-                // 本轮初始时间与累加用量，用于最终 assistant 消息的 modelInfo 元数据。
-                const turnStartTs = t0;
+                // 本轮累加的用量，用于最终 assistant 消息的 modelInfo 元数据。
                 // 注：缓存命中量（usage.cachedPromptTokens）不进这里——本对象只喂
                 // assistant 消息的 modelInfo，而其字段是逐个挑的（见下方 turnModelInfo），
                 // 加进来也不会流到下游。命中率的观测出口是 LLM 响应日志那一行。
-                const turnUsageAcc = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+                const turnUsageAcc = { promptTokens: 0, completionTokens: 0 };
                 const accUsage = (u) => {
                     if (!u)
                         return;
@@ -580,16 +710,18 @@ class DefaultAgent {
                     // completionTokens 语义 = "本回合真正新生成的输出"（含中间 reasoning / tool-call 生成
                     // 与最终回复文本），每次调用都是不重复的新输出，故逐次累加。
                     turnUsageAcc.completionTokens += u.completionTokens ?? 0;
-                    turnUsageAcc.totalTokens = turnUsageAcc.promptTokens + turnUsageAcc.completionTokens;
                 };
                 const firstResult = await this.consumeStream(llm, {
                     messages: llmBeforeData.messages,
                     tools: llmBeforeData.tools.length > 0 ? llmBeforeData.tools : undefined,
                     maxTokens,
                     signal,
-                    ...(thinkOverride !== undefined ? { think: thinkOverride } : {}),
-                }, incoming.sessionId, incoming.platform);
+                    ...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];
@@ -597,57 +729,71 @@ class DefaultAgent {
                 this.debugLogResponse(response, Date.now() - t0);
                 // Hook: agent:llm:after — 插件可以处理 LLM 返回结果
                 const llmAfterData = { response, messages: llmBeforeData.messages };
-                await this.caps.hooks.run('agent:llm:after', llmAfterData);
+                await this.caps.hooks.use.run('agent:llm:after', llmAfterData);
                 response = llmAfterData.response;
-                // 收集所有思考内容
-                const allReasoning = [];
-                if (response.reasoningContent) {
-                    allReasoning.push(response.reasoningContent);
-                }
                 // 收集工具调用摘要
                 const toolCallSummaries = [];
-                const assistantMetadata = this.buildAssistantMetadata(incoming);
+                const assistantMetadata = this.buildAssistantMetadata(incoming, turnId);
                 // 工具调用循环
                 let iterations = 0;
-                while (response.toolCalls && response.toolCalls.length > 0 && iterations < maxToolIterations) {
+                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: response.toolCalls,
+                        toolCalls,
                         reasoningContent: response.reasoningContent,
                         metadata: assistantMetadata,
                     });
                     const assistantToolMessage = {
                         role: 'assistant',
                         content: response.content,
-                        toolCalls: response.toolCalls,
+                        toolCalls,
                         reasoningContent: response.reasoningContent,
                         metadata: assistantMetadata,
                     };
                     const toolMessages = [];
                     // 并行执行所有工具调用（互不依赖的工具无需串行等待）
                     const toolResultMaxChars = Math.floor(contextLength * this.toolResultMaxRatio * 3.5);
-                    const parallelResults = await Promise.all(response.toolCalls.map(async (toolCall) => {
-                        // 无参工具的 arguments 常是空串（流式路径没有 argument delta 时拼出来就是 ''），不算坏 JSON
-                        const rawArgs = toolCall.function.arguments?.trim();
-                        let args;
-                        try {
-                            args = rawArgs ? JSON.parse(rawArgs) : {};
-                        }
-                        catch (parseErr) {
-                            // 参数不是合法 JSON：跳过本次执行，把错误当工具结果回给模型重新生成 arguments。
-                            // 旧行为 args = {} 会让"无必填参数"的工具真的空参跑一遍（副作用已发生，模型却不知情）。
-                            const reason = parseErr instanceof Error ? parseErr.message : String(parseErr);
-                            this.logger.warn(`工具参数解析失败: ${toolCall.function.name} (${reason}) 原始参数=${rawArgs?.slice(0, 200)}`);
+                    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,
+                            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,
-                                result: JSON.stringify({ error: `工具参数不是合法 JSON：${reason}；请重新生成 arguments` }),
+                                callId,
+                                result,
                                 resultImages: undefined,
                                 toolName: toolCall.function.name,
                                 toolArgs: {},
@@ -655,35 +801,37 @@ class DefaultAgent {
                                 endTime: failedAt,
                             };
                         }
+                        const callCtx = { ...toolCtx, callId };
                         // Hook: agent:tool:before — 插件可以拦截或修改工具调用
-                        const toolBeforeData = { name: toolCall.function.name, args, toolCallContext: toolCtx };
+                        const toolBeforeData = { name: toolCall.function.name, args: parsed.args, toolCallContext: callCtx };
                         // 单个工具的链路异常（钩子 / 守卫 / 结果处理抛错）只算该工具失败，转成它自己的错误结果：
                         // 整批照常落定、整组落库，兄弟工具已发生的副作用不会因连坐而从历史里消失。
                         // executeDone 区分失败发生在执行前还是执行后——后者须明说「已执行」，免得模型重做有副作用的操作。
                         let executeDone = false;
                         let toolT0;
                         try {
-                            await this.caps.hooks.run('agent:tool:before', toolBeforeData);
+                            await this.caps.hooks.use.run('agent:tool:before', toolBeforeData);
                             // 通知平台：工具开始执行
-                            await this.caps.events.emit('tool:execute', {
-                                sessionId: incoming.sessionId,
-                                platform: incoming.platform,
-                                toolName: toolBeforeData.name,
-                                args: toolBeforeData.args,
-                                phase: 'start',
-                            });
-                            // 紧随 start 赋值：catch 据此判断 start 已发出、要补发配对的 end
+                            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.current?.execute(toolBeforeData.name, toolBeforeData.args, toolCtx) ?? Promise.resolve({ content: JSON.stringify({ error: 'tools 服务不可用' }) }));
+                            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 — 插件可以处理工具执行结果
-                            const toolAfterData = { name: toolBeforeData.name, result, toolCallContext: toolCtx };
-                            await this.caps.hooks.run('agent:tool:after', toolAfterData);
+                            // 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) {
@@ -693,18 +841,13 @@ class DefaultAgent {
                             const toolEndTime = Date.now();
                             this.logger.debug(`工具完成: ${toolBeforeData.name} (${toolEndTime - toolT0}ms) 结果=${result}`);
                             // 通知平台：工具执行完成
-                            await this.caps.events.emit('tool:execute', {
-                                sessionId: incoming.sessionId,
-                                platform: incoming.platform,
-                                toolName: toolBeforeData.name,
-                                args: toolBeforeData.args,
-                                phase: 'end',
-                                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,
@@ -719,19 +862,13 @@ class DefaultAgent {
                             const result = JSON.stringify({
                                 error: executeDone ? `工具已执行，但结果处理失败：${reason}` : `工具调用失败：${reason}`,
                             });
-                            // start 已发出就补发配对的 end（emit 恒 resolve）：否则 WebUI 流式缓冲里这一段一直显示执行中
-                            if (toolT0 !== undefined) {
-                                await this.caps.events.emit('tool:execute', {
-                                    sessionId: incoming.sessionId,
-                                    platform: incoming.platform,
-                                    toolName: toolBeforeData.name,
-                                    args: toolBeforeData.args,
-                                    phase: 'end',
-                                    result,
-                                });
-                            }
+                            // 执行前就失败的补发开始，再发配对的结束（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,
@@ -751,14 +888,20 @@ class DefaultAgent {
                         }
                     }
                     // 按原始 toolCalls 顺序将结果推入消息列表 + 时间线
-                    for (const { toolCall, result, resultImages, toolName, toolArgs, startTime, endTime } of parallelResults) {
+                    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,
+                            },
                         };
                         llmBeforeData.messages.push(toolMessage);
                         toolMessages.push(toolMessage);
@@ -770,8 +913,10 @@ class DefaultAgent {
                             result,
                             startTime,
                             endTime,
+                            callId,
                         });
                     }
+                    historyMessages += 1 + toolMessages.length;
                     await this.saveToolCallGroup(incoming.sessionId, assistantToolMessage, toolMessages, turnPersistedTimestamps);
                     // 继续请求 LLM (再次经过 hooks)，使用原始完整工具列表而非被上一轮 hooks 修改过的列表
                     const nextLlmData = {
@@ -781,35 +926,34 @@ class DefaultAgent {
                         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.run('agent:llm:before', nextLlmData, undefined, { warnOnStall: true });
+                    await this.caps.hooks.use.run('agent:llm:before', nextLlmData, undefined, { warnOnStall: true });
                     // 裁剪消息以确保不超过上下文窗口
-                    nextLlmData.messages = this.trimMessages(nextLlmData.messages, tokenBudget);
-                    // 推送 token 使用量统计
-                    this.emitTokenUsage(incoming.sessionId, incoming.platform, nextLlmData.messages, nextLlmData.tools, contextLength, maxTokens, tokenBudget);
+                    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,
-                        ...(thinkOverride !== undefined ? { think: thinkOverride } : {}),
-                    }, incoming.sessionId, incoming.platform);
+                        ...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.run('agent:llm:after', nextLlmAfterData);
+                    await this.caps.hooks.use.run('agent:llm:after', nextLlmAfterData);
                     response = nextLlmAfterData.response;
-                    if (response.reasoningContent) {
-                        allReasoning.push(response.reasoningContent);
-                    }
                 }
                 // 检测是否因工具调用次数达到上限而退出循环
                 const toolLimitReached = iterations >= maxToolIterations && response.toolCalls != null && response.toolCalls.length > 0;
@@ -829,7 +973,24 @@ class DefaultAgent {
                     triggerType: incoming.triggerType,
                     attempt: 0,
                 };
-                await this.caps.hooks.run('agent:reply:before', responseData);
+                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本轮只需转述已给出的宿主结果，不要调用工具或查询状态。` +
+                                '请沿用当前人设和规定的回复格式，给出包含结果与已有链接的非空回复。';
+                    }
+                };
+                await validateReply();
                 // 重试循环：当 hook（如 persona 的 outputFormat 解析）报告 retryRequested 时，
                 // 把失败的 assistant 输出 + 系统反馈追加到消息列表，重新请求 LLM；最多按 maxRetries 次。
                 // maxRetries 由 hook 端写入（plugin-persona 从 outputFormat.retries 读取，默认 1）。
@@ -845,20 +1006,19 @@ class DefaultAgent {
                         role: 'system',
                         content: responseData.retryFeedback ?? '上一次回复未能通过格式校验，请严格按照系统提示中规定的格式重新输出。',
                     });
-                    const retryTrimmed = this.trimMessages(llmBeforeData.messages, tokenBudget);
+                    const retrySent = trimForCall(llmBeforeData.messages);
                     const retryResult = await this.consumeStream(llm, {
-                        messages: retryTrimmed,
+                        messages: retrySent.messages,
                         tools: undefined,
                         maxTokens,
                         signal,
-                        ...(thinkOverride !== undefined ? { think: thinkOverride } : {}),
-                    }, incoming.sessionId, incoming.platform);
+                        ...thinking,
+                    }, turnId, incoming.sessionId, incoming.platform, !reportOnly);
+                    await reportUsage(retrySent, [], retryResult);
                     turnSegments.push(...retryResult.segments);
                     response = retryResult;
                     accUsage(response.usage);
                     rawLlmContent = response.content ?? '';
-                    if (response.reasoningContent)
-                        allReasoning.push(response.reasoningContent);
                     // 用新输出再次跑 hook；hook 端根据 attempt 决定继续重试或走兜底（静默丢弃）
                     responseData.content = rawLlmContent;
                     responseData.archiveContent = undefined;
@@ -866,7 +1026,7 @@ class DefaultAgent {
                     responseData.retryRequested = false;
                     responseData.retryFeedback = undefined;
                     responseData.attempt = attempt;
-                    await this.caps.hooks.run('agent:reply:before', responseData);
+                    await validateReply();
                 }
                 // 双保险：循环结束后若 hook 仍标记 retryRequested（理论上 persona 已在用尽时自动走兜底），
                 // 强制把 content 置空，避免原始未校验内容被外发。
@@ -891,8 +1051,9 @@ class DefaultAgent {
                 if (signal.aborted)
                     throw new DOMException('Generation aborted', 'AbortError');
                 // 发出流结束标记
-                await this.caps.events.emit('outbound:stream', {
+                await this.caps.events.use.emit('outbound:stream', {
                     sessionId: incoming.sessionId,
+                    turnId,
                     platform: incoming.platform,
                     done: true,
                     toolLimitReached,
@@ -902,20 +1063,18 @@ class DefaultAgent {
                     this.logger.debug(`空回复，跳过发送 (session=${incoming.sessionId})`);
                 }
                 else {
-                    const combinedReasoning = allReasoning.length > 0 ? allReasoning.join('\n\n---\n\n') : undefined;
+                    const visibleSegments = !reportOnly && turnSegments.length > 0 ? turnSegments : undefined;
                     // 在 assistant 最终持久化时记录 modelInfo：前端从消息历史可还原 "这条回复
-                    // 由哪个 model 生成、用了多少 token、耗时多久"，方便用户验证模型切换是否生效。
+                    // 由哪个 model 生成、用了多少 token"，方便用户验证模型切换是否生效。
                     const turnModelInfo = {
                         provider: llm.providerId,
                         model: llm.id,
                         promptTokens: turnUsageAcc.promptTokens || undefined,
                         completionTokens: turnUsageAcc.completionTokens || undefined,
-                        totalTokens: turnUsageAcc.totalTokens || undefined,
-                        elapsedMs: Date.now() - turnStartTs,
                     };
                     const finalAssistantMetadata = {
                         ...(assistantMetadata ?? {}),
-                        modelInfo: turnModelInfo,
+                        [WellKnownMetadataKeys.ModelInfo]: turnModelInfo,
                     };
                     // 落库的是信封（如 outputFormat 的整串 JSON）时，另带解码后的可见正文，供检索、摘要等按语义读历史的一方用
                     if (visibleContent !== archiveContent) {
@@ -926,29 +1085,33 @@ class DefaultAgent {
                     await this.saveToMemory(incoming.sessionId, {
                         role: 'assistant',
                         content: archiveContent,
-                        reasoningContent: response.reasoningContent,
+                        reasoningContent: reportOnly ? undefined : response.reasoningContent,
                         timestamp: Date.now(),
                         metadata: finalAssistantMetadata,
-                        segments: turnSegments.length > 0 ? turnSegments : undefined,
+                        segments: visibleSegments,
                     });
-                    // 发送给流式客户端时使用合并版本（统一时间线 segments 同时给出，前端按到达顺序渲染）
+                    // 外发给平台：只带正文与这条回复的模型和 token，思考与时间线只在上面落库的消息上
                     await this.dispatchOutbound({
                         content: replyContent,
                         sessionId: incoming.sessionId,
                         platform: incoming.platform,
-                        reasoningContent: combinedReasoning,
+                        ...(incoming.hostNotice
+                            ? { hostNotice: { kind: incoming.hostNotice.kind, id: incoming.hostNotice.id } }
+                            : {}),
+                        ...(incoming.hostNotice?.replyTo ? { replyTo: incoming.hostNotice.replyTo } : {}),
                         source: 'agent',
-                        segments: turnSegments.length > 0 ? turnSegments : undefined,
+                        turnId,
                         modelInfo: turnModelInfo,
                     });
                 }
                 // Hook: agent:turn:after — 插件可以在完整消息周期结束后做后处理
                 const turnOutcome = replyContent.trim().length === 0 ? 'silent' : 'replied';
-                await this.caps.hooks.run('agent:turn:after', {
+                await this.caps.hooks.use.run('agent:turn:after', {
                     message: incoming,
                     reply: replyContent,
                     outcome: turnOutcome,
                     sessionId: incoming.sessionId,
+                    turnId,
                     metadata: msgHookData.metadata,
                 });
             }
@@ -970,84 +1133,94 @@ class DefaultAgent {
                         (turnPersistedTimestamps.length > 0
                             ? `（保留本轮已完成的 ${turnPersistedTimestamps.length} 条工具调用记录，便于下一轮 agent 感知）`
                             : ''));
-                    await this.caps.events.emit('outbound:stream', {
+                    await this.caps.events.use.emit('outbound:stream', {
                         sessionId: incoming.sessionId,
+                        turnId,
                         platform: incoming.platform,
                         done: true,
                     });
                     // 中止同样是回合终态：发 agent:turn:after(outcome=aborted) 让生命周期订阅方收尾——
-                    // session-manager 把会话状态从 active 收口为 completed（否则永远停在"进行中"），
-                    // checkpoint 关闭当前回合（否则中止后回合不关闭、长期泄漏）。
+                    // 编排的 agent 节点在等这一轮的结果，不发它就要等到超时才失败。
                     // 文档与 agent-api 早已声明 outcome 含 aborted，此处兑现契约。
-                    await this.caps.hooks.run('agent:turn:after', {
+                    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 的流式块不收尾、WebUI 的工具进度与上限标记不复位，
+                // 异常同样要结束流：不发 done，CLI 的流式块不收尾、会话里流式输出的条目不结束，
                 // 下一轮 delta 还会抹掉这条 [错误] 与用户的新输入。顺序与正常收尾一致——先 done 再发消息。
-                await this.caps.events.emit('outbound:stream', {
+                await this.caps.events.use.emit('outbound:stream', {
                     sessionId: incoming.sessionId,
+                    turnId,
                     platform: incoming.platform,
                     done: true,
                 });
-                await this.dispatchOutbound({
-                    content: `[错误] ${message}`,
-                    sessionId: incoming.sessionId,
-                    platform: incoming.platform,
-                    source: 'system',
-                });
-                // 异常也是回合终态：同样发 turn:after(outcome=error) 让 checkpoint 关闭回合、
-                // session-manager 收口状态。dispatchOutbound 已发系统错误消息，状态可被 outbound:message
-                // 与本钩子双路径幂等收口。
-                await this.caps.hooks.run('agent:turn:after', {
+                if (!reportOnly) {
+                    await this.dispatchOutbound({
+                        content: `[错误] ${message}`,
+                        sessionId: incoming.sessionId,
+                        platform: incoming.platform,
+                        source: 'system',
+                    });
+                }
+                // 异常也是回合终态：同样发 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,
                 });
             }
         });
         // 消息被拦截（如流控缓冲），通知前端结束 loading
         if (!handled) {
-            await this.caps.events.emit('outbound:stream', {
+            await this.caps.events.use.emit('outbound:stream', {
                 sessionId: incoming.sessionId,
+                turnId,
                 platform: incoming.platform,
                 done: true,
             });
         }
     }
     /**
-     * 构建发送给 LLM 的消息列表
+     * 构建发送给 LLM 的消息列表。历史按会话的条数线读：historyLimit 为 0 或没设置时读全部活跃历史。
+     * historyMessages 是从记忆读进的条数（含已归档的这一轮入站消息），与之后的清洗、裁剪无关
      */
-    async buildMessages(incoming, personaOpts, archivedIncoming) {
+    async buildMessages(incoming, historyLimit, personaOpts, archivedIncoming) {
         const messages = [];
+        let historyMessages = 0;
         // 1. 系统提示
         const systemPrompt = this.buildSystemPrompt(personaOpts);
         messages.push({ role: 'system', content: systemPrompt, metadata: { injector: 'persona' } });
         // 2. 历史消息
-        const memory = this.caps.memory.current;
+        const memory = this.caps.memory.present ? this.caps.memory.use : undefined;
         if (memory) {
             try {
-                const history = this.sanitizeToolCallHistory(await memory.getHistory(incoming.sessionId, this.historyLimit), incoming.sessionId);
+                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 理解时间先后
+                    // 为用户消息注入时间标注，帮助 LLM 理解时间先后。标注加在副本上：记忆服务可能直接交出存着的消息对象
                     if (m.role === 'user' && m.timestamp && m.content) {
                         const timeLabel = formatTimeLabel(m.timestamp, now);
                         if (timeLabel && !m.content.startsWith(`(${timeLabel})`)) {
-                            m.content = `(${timeLabel}) ${m.content}`;
+                            messages.push({ ...m, content: `(${timeLabel}) ${m.content}` });
+                            continue;
                         }
                     }
                     messages.push(m);
@@ -1067,34 +1240,33 @@ class DefaultAgent {
         const archivedBody = archivedIncoming?.content;
         const fallbackBody = senderLabel ? `[${senderLabel}]: ${incoming.content}` : incoming.content;
         const currentContent = `(${nowLabel}) ${archivedBody ?? fallbackBody}`;
-        // 3a. proactive 委派分支：跨会话由「同一 agent 在另一会话的实例」派发过来的任务
-        //
-        // 这条消息不是用户请求，必须作为 system 指令呈现给 LLM，否则 B 会把它当成
-        // 真实用户在指挥（典型 BUG：源会话 agent 决定派发，目标会话 agent 看到 user
-        // 角色的消息，回复时使用「您」「您好」等措辞，把 agent 当成了用户）。
+        // 宿主通知分支：宿主撰写的事件通知不是任何人的发言，与 proactive 一样以 system 呈现、
+        // 不推当前 user 消息与易变块。不可信段只在当轮接在宿主正文之后（归档只留正文），
+        // 之后的回合从历史里只看得到宿主正文。
+        if (incoming.hostNotice) {
+            const { untrusted } = incoming.hostNotice;
+            messages.push({
+                role: 'system',
+                content: `[宿主通知]\n${incoming.content}${untrusted ? `\n\n${untrusted}` : ''}`,
+                metadata: { injector: WellKnownKinds.HostNotice },
+            });
+            return { messages, historyMessages };
+        }
+        // 3a. proactive 分支：系统代发给本会话的任务指令（如 workflow 的 agent 节点）
         //
-        // 同时附上源会话 ID，并明确告诉 B：如需了解源会话上下文，按需调用
-        // session_get_history(sessionId="<源>") —— 把"是否需要上下文"的决策权
-        // 交给 B 的 LLM，避免无差别拼接源历史造成 token 浪费。
+        // 这条消息不是用户请求，必须作为 system 指令呈现给 LLM，否则 agent 会把它当成
+        // 真实用户在指挥（典型 BUG：agent 看到 user 角色的任务指令，回复时使用「您」
+        // 「您好」等措辞，把派发方当成了用户）。
         if (incoming.triggerType === 'proactive') {
-            const sourceMatch = incoming.source?.match(/^proactive:from:(.+)$/);
-            const sourceSessionId = sourceMatch?.[1];
-            const sourceLine = sourceSessionId ? `源会话 ID: ${sourceSessionId}\n` : '';
-            // 不在 hint 里写死 limit，让 LLM 按 plugin-tool-session 的 defaultLimit / 自身判断决定
-            const hintLine = sourceSessionId
-                ? `如需了解源会话上下文（例如「按之前讨论的方案」之类的引用），调用 \`session_get_history(sessionId="${sourceSessionId}")\` 自行查阅（可按需附加 limit）。\n`
-                : '';
             messages.push({
                 role: 'system',
                 content: `[跨会话委派 — 非用户消息]\n` +
-                    sourceLine +
                     `任务: ${incoming.content}\n\n` +
                     `说明: 这是你（作为同一 agent 在另一会话的实例）派发给本会话的任务指令，` +
-                    `不是用户请求。处理时不要使用「您」「请问」等面向用户的措辞，按指令直接执行并简明回报结果。\n` +
-                    hintLine,
-                metadata: { injector: WellKnownKinds.CrossSessionDelegation, sourceSessionId },
+                    `不是用户请求。处理时不要使用「您」「请问」等面向用户的措辞，按指令直接执行并简明回报结果。\n`,
+                metadata: { injector: WellKnownKinds.CrossSessionDelegation },
             });
-            return messages;
+            return { messages, historyMessages };
         }
         // 3b. 普通用户消息分支
         // 检测预处理附件内容——引导 LLM 综合分析而非逐项转述
@@ -1117,7 +1289,7 @@ class DefaultAgent {
         // 多模态：把 attachments 中的 image 项传递给 LLM（视觉模型多模态字段）
         const imageAtts = incoming.attachments?.filter(a => a.kind === 'image') ?? [];
         if (imageAtts.length > 0) {
-            if (this.caps.media.current !== undefined) {
+            if (this.caps.media.present) {
                 // media 在场：原样透传。出口形态由 media 的 agent:llm:before 中间件规范化
                 //（describe 剥离 / passthrough 物化），此处不做任何转换——它的描述缓存键与
                 // 动图提示都按 attachment.data 原串命中，改形态会打散。
@@ -1147,7 +1319,7 @@ class DefaultAgent {
         // 秒级时间戳一变，人设 + 记忆 + 历史近 7 万 token 的前缀全部作废——实测每个
         // 新回合命中率恒为 0，只有同回合内的工具迭代（prompt 不重建）才命中。
         // 放到这里语义也更顺：它们本就是「此刻的事实」，紧挨当前消息说更自然。
-        const persona = this.caps.persona.current;
+        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 } });
@@ -1158,7 +1330,7 @@ class DefaultAgent {
         if (focusGuidance)
             messages.push(focusGuidance);
         messages.push(userMessage);
-        return messages;
+        return { messages, historyMessages };
     }
     /**
      * 裁剪预算 = 上下文长度 × trimThresholdRatio − 最大输出 token − 512 安全余量（下限 1024）。
@@ -1172,7 +1344,7 @@ class DefaultAgent {
      * 构建系统提示词
      */
     buildSystemPrompt(personaOpts) {
-        const persona = this.caps.persona.current;
+        const persona = this.caps.persona.present ? this.caps.persona.use : undefined;
         const base = persona
             ? this.systemPrompt
                 ? `${persona.getSystemPrompt(personaOpts)}\n\n${this.systemPrompt}`
@@ -1187,11 +1359,10 @@ class DefaultAgent {
         return estimateTokens(messages);
     }
     /**
-     * 推送 token 使用量统计事件
-     *
-     * 包含各维度的 token 使用分解，供前端展示和自动压缩判断。
+     * 发 token:usage：各维度的拆分按消息与工具定义估算，used 取模型服务返回的输入 token，没有时取估算。
+     * 等全部监听者处理完才返回：摘要插件在回合结束时按这一轮最后一条用量判定，不能让它晚于回合结束
      */
-    emitTokenUsage(sessionId, platform, messages, tools, contextLength, maxTokens, tokenBudget) {
+    async emitTokenUsage({ sessionId, platform, turnId, contextWindow, maxTokens, tokenBudget, messages, tools, trimmed, untrimmedHistory, historyMessages, promptTokens, }) {
         // 按来源分类统计各消息的 token 占用
         let historyTokens = 0;
         let toolResultTokens = 0;
@@ -1250,11 +1421,11 @@ class DefaultAgent {
                         personaTokens += t;
                     }
                 }
-                else {
+                else if (rawSource) {
                     // 其余注入者(memory-history/user-profile/user-relation/自定义插件等):
-                    // 计入 systemOther 汇总之余按标签点名,预算争抢时能看出是谁在吃。
+                    // 计入 systemOther 汇总之余按全局键点名,预算争抢时能看出是谁在吃;界面按键里的实例前缀合并到插件
                     systemOtherTokens += t;
-                    injectorTokens[source] = (injectorTokens[source] ?? 0) + t;
+                    injectorTokens[rawSource] = (injectorTokens[rawSource] ?? 0) + t;
                 }
             }
             else if (msg.role === 'tool') {
@@ -1273,17 +1444,23 @@ class DefaultAgent {
             platformTokens +
             subtaskTokens +
             systemOtherTokens;
-        const totalUsed = systemTokens + historyTokens + toolResultTokens + toolDefsTokens;
-        const usageRatio = contextLength > 0 ? totalUsed / contextLength : 0;
-        this.caps.events
-            .emit('token:usage', {
+        // 服务商回的数没人核过：不是正的有限数（缺省、0、NaN）时按估算，一次调用的输入不会是 0 token
+        const used = promptTokens !== undefined && promptTokens > 0 && Number.isFinite(promptTokens)
+            ? promptTokens
+            : systemTokens + historyTokens + toolResultTokens + toolDefsTokens;
+        const usageRatio = contextWindow > 0 ? used / contextWindow : 0;
+        await this.caps.events.use.emit('token:usage', {
             sessionId,
+            turnId,
             platform,
-            contextWindow: contextLength,
+            contextWindow,
             maxTokens,
             tokenBudget,
-            used: totalUsed,
+            used,
             usageRatio,
+            trimmed,
+            untrimmedHistory,
+            historyMessages,
             breakdown: {
                 system: systemTokens,
                 persona: personaTokens,
@@ -1299,8 +1476,19 @@ class DefaultAgent {
                 toolDefs: toolDefsTokens,
                 reservedForReply: maxTokens,
             },
-        })
-            .catch(() => { });
+            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 },
+            ],
+        });
         // 节流日志：与 WebUI 看到的同一份数据，让 CLI / 文件日志使用者也能看见预算消耗。
         // 跨过 0.5 / 0.7 / 0.85 阈值必输出，否则每 10 轮一次。
         const bucket = usageRatio >= 0.85 ? 3 : usageRatio >= 0.7 ? 2 : usageRatio >= 0.5 ? 1 : 0;
@@ -1309,7 +1497,7 @@ class DefaultAgent {
         const crossedBucket = bucket !== st.lastRatioBucket;
         if (crossedBucket || st.count % 10 === 1) {
             const tag = bucket >= 3 ? 'CRITICAL' : bucket >= 2 ? 'WARN' : bucket >= 1 ? 'INFO' : 'OK';
-            this.logger.info(`[token-usage:${tag}] ${sessionId} ${totalUsed}/${contextLength} (${(usageRatio * 100).toFixed(1)}%) ` +
+            this.logger.info(`[token-usage:${tag}] ${sessionId} ${used}/${contextWindow} (${(usageRatio * 100).toFixed(1)}%) ` +
                 `sys=${systemTokens}(persona=${personaTokens} mem=${memorySummaryTokens + memoryVectorTokens} ` +
                 `skills=${skillsTokens} subtask=${subtaskTokens} other=${systemOtherTokens}) ` +
                 `hist=${historyTokens} tools=${toolResultTokens}+${toolDefsTokens}def reserve=${maxTokens}`);
@@ -1330,9 +1518,8 @@ class DefaultAgent {
         const rel = t.match(/^data\/((?:images|videos|audios|files)\/.+)$/);
         if (!rel)
             return t;
-        // 经网关按 URI 路由：storage 按根逐条提供，胜者只是其中一个根（多根时通常是 workspace），
-        // 读不了 data:/。缺 data 根（含 storage 整体缺席）时网关抛错，落到下面的 catch
-        const storage = createStorageGateway(this.caps.storage);
+        // storage 按 URI 的根名路由；缺 data 根（含 storage 整体缺席）时抛错，落到下面的 catch
+        const storage = this.caps.storage.use;
         try {
             const raw = (await storage.readFile(`data:/${rel[1]}`));
             // mime 优先取附件自带的 mimeType；缺省按 basename 扩展名推断（适配器落盘只产
@@ -1349,7 +1536,8 @@ class DefaultAgent {
         }
     }
     /**
-     * 裁剪消息列表，使总 token 数不超过预算
+     * 裁剪消息列表，使总 token 数不超过预算；trimmed 报告入口估算超过了预算、进入了硬裁剪（不一定真裁掉了内容）。
+     * 不记日志：token:request 的快照同样走这里，删了消息的日志由真实回合的调用点记
      *
      * 渐进式压缩策略（保证 agent 在长工具链中无限运行）：
      *  1. 首条 system（主提示词）和末条消息永不删除
@@ -1363,7 +1551,7 @@ class DefaultAgent {
         const result = messages.map(m => ({ ...m }));
         let estimated = this.estimateTokens(result);
         if (estimated <= budget)
-            return result;
+            return { messages: result, trimmed: false };
         /** 重新扫描 system 消息索引（首条和末条之间） */
         const findSystemIndices = () => {
             const indices = [];
@@ -1391,7 +1579,7 @@ class DefaultAgent {
             }
         }
         if (estimated <= budget)
-            return result;
+            return { messages: result, trimmed: true };
         // === Phase 2: 截断过长的 tool 输出 ===
         for (let i = 1; i < result.length - 1; i++) {
             if (estimated <= budget)
@@ -1403,7 +1591,7 @@ class DefaultAgent {
             }
         }
         if (estimated <= budget)
-            return result;
+            return { messages: result, trimmed: true };
         // === Phase 2.5: 缩减 assistant 消息的 reasoningContent ===
         // 深度思考模型的推理内容可能非常长（数万 token），优先缩减旧迭代的推理，
         // 仍超预算时缩减最新一条（保留头尾摘要以保持上下文连贯性）
@@ -1429,7 +1617,7 @@ class DefaultAgent {
             }
         }
         if (estimated <= budget)
-            return result;
+            return { messages: result, trimmed: true };
         // === Phase 3: 将旧的 assistant+tool 组压缩为摘要 ===
         // 识别所有工具调用组 (assistant(toolCalls) + 紧跟的 tool 消息)
         {
@@ -1476,12 +1664,8 @@ class DefaultAgent {
                 }
             }
         }
-        if (estimated <= budget) {
-            if (result.length < messages.length) {
-                this.logger.info(`上下文压缩: ${messages.length} → ${result.length} 条消息 (约 ${estimated} tokens)`);
-            }
-            return result;
-        }
+        if (estimated <= budget)
+            return { messages: result, trimmed: true };
         // === Phase 4: 删除最旧的非 system 消息（保护最后一组工具调用 + 最新用户消息） ===
         {
             // 识别最后一组工具调用的索引范围，确保不被删除
@@ -1540,10 +1724,8 @@ class DefaultAgent {
                 adjustAfterSplice(i);
             }
         }
-        if (estimated <= budget) {
-            this.logger.info(`上下文截断: ${messages.length} → ${result.length} 条消息 (约 ${estimated} tokens)`);
-            return result;
-        }
+        if (estimated <= budget)
+            return { messages: result, trimmed: true };
         // === Phase 5: 极端情况 — 删除 hook 注入的 system 消息 ===
         // 从最靠前的块开始删。turn-context 迁移后头部只剩技能正文/会话摘要、
         // 档案/记忆类材料都在尾部——正序扫描意味着极端裁剪时**先牺牲头部稳定块**、
@@ -1577,15 +1759,11 @@ class DefaultAgent {
                 }
             }
             result.splice(insertIdx, 0, hint);
-            estimated += estimateMsgTokens(hint);
         }
-        if (result.length < messages.length) {
-            this.logger.info(`上下文截断: ${messages.length} → ${result.length} 条消息 (约 ${estimated} tokens)`);
-        }
-        return result;
+        return { messages: result, trimmed: true };
     }
     getArchiveForWrite() {
-        const archive = this.caps.messageArchive.current;
+        const archive = this.caps.messageArchive.present ? this.caps.messageArchive.use : undefined;
         if (!archive && !this.archiveUnavailableWarned) {
             this.archiveUnavailableWarned = true;
             this.logger.warn('message-archive 服务不可用，缺席期间的新消息不会写入记忆，对话继续。请加载 @aalis/plugin-message-archive 及其 memory 依赖。');
@@ -1604,22 +1782,24 @@ class DefaultAgent {
             }
         }
     }
-    buildAssistantMetadata(incoming) {
+    /** 这一轮落库的 assistant 消息的元数据；带 turnId，会话的客户端据此把存档归回它所在的回合 */
+    buildAssistantMetadata(incoming, turnId) {
         const identity = getPlatformSelfIdentity(this.caps.platform, incoming.platform, incoming.sessionId);
         const metadata = {
-            platform: incoming.platform,
+            [WellKnownMetadataKeys.Platform]: incoming.platform,
             senderType: 'assistant',
+            [WellKnownMetadataKeys.TurnId]: turnId,
         };
         if (identity?.selfId)
-            metadata.userId = identity.selfId;
+            metadata[WellKnownMetadataKeys.UserId] = identity.selfId;
         if (identity?.nickname)
-            metadata.nickname = identity.nickname;
+            metadata[WellKnownMetadataKeys.Nickname] = identity.nickname;
         if (incoming.groupId)
-            metadata.groupId = incoming.groupId;
+            metadata[WellKnownMetadataKeys.GroupId] = incoming.groupId;
         if (incoming.groupName)
-            metadata.groupName = incoming.groupName;
+            metadata[WellKnownMetadataKeys.GroupName] = incoming.groupName;
         if (incoming.sessionType)
-            metadata.sessionType = incoming.sessionType;
+            metadata[WellKnownMetadataKeys.SessionType] = incoming.sessionType;
         return Object.keys(metadata).length > 0 ? metadata : undefined;
     }
     async saveToolCallGroup(sessionId, assistantMessage, toolMessages, persistedTimestamps) {
@@ -1719,22 +1899,17 @@ class DefaultAgent {
      * 生产部署务必确保 plugin-gateway 已加载，否则中间件链会被跳过。
      */
     async dispatchOutbound(message) {
-        const gateway = this.caps.gateway.current;
+        const gateway = this.caps.gateway.present ? this.caps.gateway.use : undefined;
         if (gateway) {
             await gateway.dispatchOutbound(message);
             return;
         }
         this.logger.warn('Gateway 服务不可用，回退至 outbound:message 事件（中间件链被跳过）');
-        await this.caps.events.emit('outbound:message', message);
+        await this.caps.events.use.emit('outbound:message', message);
     }
 }
 // ----- 插件导出 -----
 const configSchema = defineConfig({
-    defaultLLM: {
-        type: 'llm-ref',
-        label: '默认对话模型',
-        description: '全局默认 LLM。apply() 时经 services.prefer 锁定 llm 服务的偏好提供者。会话 / 平台 profile 未覆盖时生效。',
-    },
     systemPrompt: {
         type: 'textarea',
         label: '行为准则提示词',
@@ -1745,20 +1920,9 @@ const configSchema = defineConfig({
         type: 'number',
         label: '长期记忆预留 Token',
         default: 4096,
+        secret: false,
         description: '为注入的 system 消息预留的 token 额度：超出时先按比例缩减，极端情况下（最后阶段）仍会删除',
     },
-    historyLimit: {
-        type: 'number',
-        label: '历史消息条数',
-        default: 50,
-        description: '从记忆中加载的最近对话历史条数',
-    },
-    maxToolIterations: {
-        type: 'number',
-        label: '最大工具迭代',
-        default: 30,
-        description: '工具调用循环的最大迭代次数',
-    },
     promptBuildTimeoutMs: {
         type: 'number',
         label: '提示词贡献构建超时 (ms)',
@@ -1775,66 +1939,151 @@ const configSchema = defineConfig({
         type: 'number',
         label: '裁剪触发比例',
         default: 1.0,
-        description: '裁剪预算 = 上下文长度 × 该比例 − 最大输出 token − 512 安全余量（下限 1024）。本次调用估算输入 token 超过该预算才会对消息列表做内存裁剪（不影响 DB）。默认 1.0 表示用满扣除输出预留后的可用窗口；调低可提前裁剪。压缩触发请在“@aalis/plugin-memory-summary”中配置。',
+        description: '裁剪预算 = 上下文长度 × 该比例 − 最大输出 token − 512 安全余量（下限 1024）。本次调用估算输入 token 超过该预算才会对消息列表做内存裁剪（不影响 DB）。默认 1.0 表示用满扣除输出预留后的可用窗口；调低可提前裁剪。压缩触发在会话设置里调：自动压缩线（摘要插件登记）与历史条数上限（本插件登记）。',
     },
 });
+/**
+ * 本插件登记的会话设置项：模型（输入框旁的快捷切换）、深度思考、工具迭代上限与历史条数上限，各种会话都适用。模型的全局
+ * 默认层就是 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 }，两项都是非空字符串';
+        },
+    },
+    {
+        key: 'think',
+        field: {
+            type: 'select',
+            label: '深度思考',
+            dynamicOptions: 'llm-thinking',
+            description: '可选的档位随所用的模型；没设置或当前模型没有这一档时按模型的默认档',
+        },
+        // 可选项是「模型」这一项生效的那个模型声明的档位
+        dependsOn: 'llm',
+        appliesTo: ['owner', 'room', 'task'],
+        prominence: 'common',
+        order: 20,
+        validate: value => (typeof value === 'string' && value !== '' ? undefined : '要是档位 id（非空字符串）'),
+    },
+    {
+        key: 'maxToolIterations',
+        field: {
+            type: 'number',
+            label: '最大工具迭代',
+            integer: true,
+            min: 1,
+            default: MAX_TOOL_ITERATIONS,
+            description: '一轮里工具调用循环的最大次数',
+        },
+        appliesTo: ['owner', 'room', 'task'],
+        prominence: 'advanced',
+    },
+    {
+        key: 'historyLimit',
+        field: {
+            type: 'number',
+            label: '历史条数上限',
+            integer: true,
+            min: 0,
+            default: 0,
+            description: '一轮最多读进这么多条会话历史；装了摘要插件时，会话的消息到这个条数就压缩。0 表示不按条数：读全部活跃历史，只按自动压缩线压缩',
+        },
+        appliesTo: ['owner', 'room', 'task'],
+        prominence: 'advanced',
+        // 子会话按自己的继承链实时解析，不冻结父会话当时的值
+        liveOnly: true,
+    },
+];
 function run(caps) {
-    const cfg = parseConfig(configSchema, caps.config, caps.logger);
-    const agentImpl = new DefaultAgent(caps, cfg);
-    caps.provide(agentService, agentImpl);
+    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 收口；
     // session-manager 的 onDrain 兜的是未装 agent 或钩子未挂上的路径。
     // 超时沿用 core 对 onDrain 的 disposeTimeoutMs，不另加配置键。
-    caps.lifecycle.onDrain(() => agentImpl.abortInflightAndSettle(), '中止在飞回合');
+    caps.lifecycle.use.onDrain(() => agentImpl.abortInflightAndSettle(), '中止在飞回合');
     // 清理段再 abort 一次：drain 超时或未走到收尾时的兜底，表空则空操作。
-    caps.lifecycle.onDispose(() => agentImpl.abortAll(), '中止在飞回合（兜底）');
+    caps.lifecycle.use.onDispose(() => agentImpl.abortAll(), '中止在飞回合（兜底）');
     // 会话删除：丢弃该会话的 token 日志节流状态（与 todo-list / file-reader 走同一条会话清理路径）
-    caps.events.on('session:deleted', sessionId => agentImpl.dropTokenLogState(sessionId));
+    caps.events.use.on('session:deleted', sessionId => agentImpl.dropTokenLogState(sessionId));
     const agent = agentImpl;
-    // 全局默认 LLM：通过 ServicePreference 锁定 llm 服务的首选 entry。
-    // 偏好的持久化在宿主配置文档（servicePreferences 字段，WebUI 切换时写入）；这里只是开机时按 agent
-    // 自己的 cfg.defaultLLM 覆写一次，便于纯文件配置流（无 webui 干预）也能生效。
-    const defaultLLM = cfg.defaultLLM;
-    if (defaultLLM?.provider && defaultLLM?.model) {
-        caps.services.prefer(llmService, `${defaultLLM.provider}/${defaultLLM.model}`);
+    // ===== 会话级配置指令 =====
+    // /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(sessionId, platform, label, pick) {
-        const smSvc = caps.sessionManager.current;
-        if (!smSvc)
-            return [`${label}: (session-manager 不可用)`];
-        const session = smSvc.getSession(sessionId);
-        const own = pick(session?.config);
-        const parent = session?.parentId ? smSvc.getSession(session.parentId) : undefined;
-        const parentDefaults = pick(parent?.config?.sessionDefaults);
-        const profile = pick(smSvc.getPlatformProfiles()?.[platform || 'webui']);
-        const resolved = pick(smSvc.resolveConfig(sessionId, platform));
-        let source = '默认';
-        if (own)
-            source = '会话覆盖';
-        else if (parentDefaults)
-            source = '父会话 sessionDefaults';
-        else if (profile)
-            source = `平台 profile (${platform})`;
-        const lines = [`${label}: ${resolved ?? '(默认)'}  [来源: ${source}]`];
-        const chain = [];
-        if (own)
-            chain.push(`会话: ${own}`);
-        if (parentDefaults)
-            chain.push(`父 sessionDefaults: ${parentDefaults}`);
-        if (profile)
-            chain.push(`平台 profile: ${profile}`);
-        if (chain.length > 0) {
-            lines.push('  解析链（高优先级在前）:');
-            for (const c of chain)
-                lines.push(`  - ${c}`);
-        }
-        return lines;
+    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;
-    // null 与 undefined 同义（BSON 持久化读回 null，契约见 session-manager stripUndefined）
-    const fmtThink = (c) => (c?.think == null ? undefined : c.think ? 'on' : 'off');
+    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 ? '；当前模型没有这一档，按默认' : ''}`;
+    }
     // 分页渲染 helper：限制每页 PAGE_SIZE 条 + 关键词过滤 + 翻页提示（/model 与 /persona 共用）。
     const PAGE_SIZE = 20;
     function renderPaged(all, keyword, page, label, cmd) {
@@ -1852,54 +2101,56 @@ function run(caps) {
         }
         return lines.join('\n');
     }
-    caps.commands
-        .command('model [keyword:string]', '列出/搜索可用对话模型（分页，-p 翻页；如 /model grok）')
+    caps.commands.use
+        .command('model [keyword:string]', '列出/搜索可用对话模型。分页显示，-p 翻页；如 /model grok')
         .option('page', '-p <n:number>', { description: '页码（默认 1）' })
         .action(async (argv, keyword) => {
         const seen = new Set();
         const ids = [];
         for (const e of listLLMModels(caps.llm, { caps: ['chat'] })) {
-            if (seen.has(e.contextId))
+            if (seen.has(e.id))
                 continue;
-            seen.add(e.contextId);
-            ids.push(e.contextId);
+            seen.add(e.id);
+            ids.push(e.id);
         }
         const page = typeof argv.options.page === 'number' ? argv.options.page : 1;
         return renderPaged(ids, String(keyword ?? ''), page, '可用模型', '/model');
     });
-    caps.commands
+    caps.commands.use
         .command('persona [keyword:string]', '列出/搜索可用人设（分页，-p 翻页）')
         .option('page', '-p <n:number>', { description: '页码（默认 1）' })
         .action(async (argv, keyword) => {
-        const persona = caps.persona.current;
+        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');
     });
-    // ---- 会话级「模型 + 人设 + thinking + 名称」配置（onebot 等平台对话直接改当前对话生效） ----
-    caps.commands
-        .command('session', '查看当前对话生效的模型 / 人设 / thinking / 名称及来源与解析链', { risk: 'sensitive' })
+    // ---- 会话级「模型 + 人设 + 深度思考 + 名称」配置（onebot 等平台对话直接改当前对话生效） ----
+    caps.commands.use
+        .command('session', '查看当前对话生效的设定及来源。设定指模型、人设、深度思考与名称', { risk: 'sensitive' })
         .action(async (argv) => {
-        const smSvc = caps.sessionManager.current;
-        if (!smSvc)
-            return 'session-manager 服务不可用';
+        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(sid, argv.session.platform, '模型', fmtModel),
-            ...resolutionLines(sid, argv.session.platform, '人设', fmtPersona),
-            ...resolutionLines(sid, argv.session.platform, 'thinking', fmtThink),
+            ...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 <on|off> [-n <名>]   （/model 看可用模型/人设名错时也会列出）',
-            '复位:   /session.reset          （-m 仅模型 / -p 仅人设 / -t 仅 thinking）',
+            '改配置: /session.set -m <模型> -p <人设> -t <档位> [-n <名>]   （/model 看可用模型/人设名错时也会列出）',
+            '复位:   /session.reset          （-m 仅模型 / -p 仅人设 / -t 仅深度思考）',
         ]
             .filter(Boolean)
             .join('\n');
     });
-    caps.commands
-        .command('session.set', '设定当前对话的模型 / 人设 / thinking / 显示名（会话级覆盖，持久化，重启不丢）', {
+    caps.commands.use
+        .command('session.set', '设定当前对话的模型、人设、深度思考或显示名。会话级覆盖，持久化，重启不丢', {
         risk: 'sensitive',
         examples: [
             '/session.set -m @aalis/plugin-llm-openai:main/gpt-4o -p catgirl',
@@ -1910,42 +2161,50 @@ function run(caps) {
     })
         .option('model', '-m <ref:string>', { description: '模型 provider/model（LLM entry 的 contextId；/model 可列出）' })
         .option('persona', '-p <name:string>', { description: '人设卡名（不含后缀）' })
-        .option('think', '-t <mode:string>', {
-        description: 'thinking 开关：on|off（会话级覆盖；/session.reset 后回落全局配置）',
+        .option('think', '-t <level:string>', {
+        description: '深度思考的档位 id，按当前模型的档位（/session 列出；会话级覆盖，/session.reset 后回落默认）',
     })
         .option('name', '-n <label:string>', { description: '会话显示名（可选）' })
         .action(async (argv) => {
-        const smSvc = caps.sessionManager.current;
-        if (!smSvc)
-            return 'session-manager 服务不可用';
+        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 thinkRaw = typeof argv.options.think === 'string' ? argv.options.think.trim().toLowerCase() : '';
+        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 && !thinkRaw && !displayName) {
-            return '用法: /session.set -m <provider/model> -p <人设名> -t <on|off> [-n <显示名>]（至少给一项）';
-        }
-        if (thinkRaw && thinkRaw !== 'on' && thinkRaw !== 'off') {
-            return `thinking 取值只能是 on 或 off（收到 "${thinkRaw}"）。例：/session.set -t off`;
+        if (!modelRef && !personaName && !level && !displayName) {
+            return '至少给一项。敲 /session.set -h 看用法';
         }
         const config = {};
-        if (thinkRaw)
-            config.think = thinkRaw === 'on';
         // 模型：校验存在再落，避免错名静默回退默认
+        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'] });
-            if (!chatModels.some(e => e.contextId === modelRef)) {
+            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) };
         }
-        // 人设：listModels 可选，缺失则不校验（persona 插件缺席时不误拒）
+        // 深度思考：按这一轮会用的模型（同时改了模型时按新模型）的档位校验
+        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.current;
+            const persona = caps.persona.present ? caps.persona.use : undefined;
             if (persona?.listModels) {
                 const names = await persona.listModels();
                 if (!names.includes(personaName)) {
@@ -1954,35 +2213,31 @@ function run(caps) {
             }
             config.persona = personaName;
         }
-        await smSvc.ensureSession(argv.session.sessionId, {
-            config,
-            createdBy: 'user',
-            ...(displayName ? { name: displayName } : {}),
-        });
+        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 !== undefined)
-            lines.push(`· thinking: ${config.think ? 'on' : 'off'}`);
+        if (config.think)
+            lines.push(`· 深度思考: ${config.think}`);
         if (displayName)
             lines.push(`· 名称: ${displayName}`);
         lines.push('后续消息持续生效（已持久化，重启不丢）。/session.reset 可复位。');
         return lines.join('\n');
     });
-    caps.commands
-        .command('session.reset', '复位当前对话的会话级覆盖（默认清模型+人设+thinking；-m/-p/-t 单独清对应项）', {
+    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: '仅复位 thinking 覆盖' })
+        .option('think', '-t', { description: '仅复位深度思考覆盖' })
         .action(async (argv) => {
-        const smSvc = caps.sessionManager.current;
-        if (!smSvc)
-            return 'session-manager 服务不可用';
+        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;
@@ -1996,53 +2251,55 @@ function run(caps) {
         const willClear = (clearModel && session?.config?.llm) ||
             (clearPersona && session?.config?.persona) ||
             (clearThink && session?.config?.think != null);
-        if (session?.config && willClear) {
-            // 写 undefined → resolveConfig 的 stripUndefined 使其回落默认级联
-            const patch = { ...session.config };
+        if (willClear) {
+            // null 删掉这一项，回到继承链
+            const patch = {};
             if (clearModel)
-                patch.llm = undefined;
+                patch.llm = null;
             if (clearPersona)
-                patch.persona = undefined;
+                patch.persona = null;
             if (clearThink)
-                patch.think = undefined;
-            await smSvc.ensureSession(sid, { config: patch });
+                patch.think = null;
+            await smSvc.updateSession(sid, { config: patch });
         }
         const eff = smSvc.resolveConfig(sid, argv.session.platform);
-        const thinkStr = eff.think == null ? '(默认)' : eff.think ? 'on' : 'off';
-        return `已复位 → 模型: ${eff.llm ? `${eff.llm.provider}/${eff.llm.model}` : '(默认)'}，人设: ${eff.persona ?? '(默认)'}，thinking: ${thinkStr}`;
+        return `已复位 → 模型: ${eff.llm ? `${eff.llm.provider}/${eff.llm.model}` : '(默认)'}，人设: ${eff.persona ?? '(默认)'}，深度思考: ${eff.think ?? '(默认)'}`;
     });
     // 监听 token:request 事件 — 客户端刷新/重连时主动请求 token 用量
-    caps.events.on('token:request', async (data) => {
+    caps.events.use.on('token:request', async (data) => {
         if (!data?.sessionId)
             return;
-        // 唯一发射方是 WebUI；平台缺省按 'webui' 兜底，否则模型/会话配置解析会绕过平台 profile 层
-        const platform = data.platform ?? 'webui';
+        // platform 是调用方的入口平台（owner 面会话的快照按它选档）；会话服务对房间不填、其余填连接的平台。
+        // 缺省时 IM 房间按会话记下的出生平台（子会话取根会话的）、其余按 'webui'：它还是提示词贡献方的「当前平台」
+        //（按平台取跨会话料），不能缺省成空
+        const sm = caps.sessionManager.present ? caps.sessionManager.use : undefined;
+        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);
             if (!resolved)
                 return;
-            const llm = resolved.instance;
+            const llm = resolved.use;
             const contextLength = llm.contextLength;
             const maxTokens = getModelMaxOutput(llm);
             const tokenBudget = agent.computeTokenBudget(contextLength, maxTokens);
             // 与真实回合同一份会话解析：人设覆盖、结构化输出开关、额外提示都影响系统提示长度
-            const sm = caps.sessionManager.current;
             const sessionResolved = sm ? sm.resolveConfig(data.sessionId, platform) : undefined;
             // 获取历史消息并构建基础消息列表
-            const memory = caps.memory.current;
+            const memory = caps.memory.present ? caps.memory.use : undefined;
             const messages = [];
             // 系统提示
             const systemPrompt = agent.buildSystemPrompt(toPersonaOptions(sessionResolved));
             messages.push({ role: 'system', content: systemPrompt, metadata: { injector: 'persona' } });
-            // 历史消息
-            if (memory) {
-                const history = await memory.getHistory(data.sessionId, agent.historyLimit);
-                messages.push(...history.filter(m => !CONTROL_KINDS.includes(m.kind ?? '')));
-            }
+            // 历史消息：与真实回合同样按会话的条数线读
+            const history = memory ? await memory.getHistory(data.sessionId, sessionResolved?.historyLimit || Infinity) : [];
+            messages.push(...history.filter(m => !CONTROL_KINDS.includes(m.kind ?? '')));
             // 与真实回合同序：先组装 agent:prompt 贡献（摘要/向量记忆/档案等物化为 system 块），
             // 再跑 agent:llm:before（工具搜索层过滤等拦截职责），使快照贴近实际送入 LLM 的形态
             const enabledGroups = sessionResolved?.enabledToolGroups?.length ? sessionResolved.enabledToolGroups : undefined;
-            const tools = caps.tools.current?.getDefinitions(enabledGroups ? { groups: enabledGroups } : undefined) ?? [];
+            const tools = caps.tools.present
+                ? caps.tools.use.getDefinitions(enabledGroups ? { groups: enabledGroups } : undefined)
+                : [];
             const llmBeforeData = {
                 messages,
                 tools,
@@ -2052,11 +2309,24 @@ function run(caps) {
                 dryRun: true, // 纯统计路径:昂贵注入者(向量检索/档案加载)据此跳过副作用
             };
             await assemblePromptContributions(caps, llmBeforeData, { buildTimeoutMs: agent.promptBuildTimeoutMs });
-            await caps.hooks.run('agent:llm:before', llmBeforeData, undefined, { warnOnStall: true });
-            agent.emitTokenUsage(data.sessionId, platform, llmBeforeData.messages, llmBeforeData.tools, contextLength, maxTokens, tokenBudget);
+            await caps.hooks.use.run('agent:llm:before', llmBeforeData, undefined, { warnOnStall: true });
+            // 与真实回合同样过硬裁剪，拆分按裁剪之后的消息算
+            const sent = agent.trimMessages(llmBeforeData.messages, tokenBudget);
+            await agent.emitTokenUsage({
+                sessionId: data.sessionId,
+                platform,
+                contextWindow: contextLength,
+                maxTokens,
+                tokenBudget,
+                messages: sent.messages,
+                tools: llmBeforeData.tools,
+                trimmed: sent.trimmed,
+                untrimmedHistory: estimateHistoryTokens(llmBeforeData.messages),
+                historyMessages: history.length,
+            });
         }
         catch (err) {
-            caps.logger.debug('token:request 处理失败:', err);
+            caps.logger.use.debug('token:request 处理失败:', err);
         }
     });
 }